DEV Community: Tito

3 Easy Steps to Setup Gmail Less Secure Apps(Django)

Tito — Wed, 03 Jul 2024 07:52:09 +0000

Introduction

On your software development journey, you'll likely want to integrate email to test event-driven email sending. Pre-deployment testing of this feature requires an email client to verify functionalities.

While you might initially think you need endless bandwidth for mass testing, that's not necessarily the case.

Gmail, a product of Google and one of the most popular email services, is a great option for email testing. I've personally found it highly effective for solving this issue over the past five years of development.

In this article, I'll break down the three steps of Gmail integration with Django.

Log in to your Gmail account. In the top right corner, click your profile picture and then select the "Manage account" option.

2.
Go to the search bar and search "App Passwords" and click on the matching option:

The information you need to provide will depend on your account's security settings. Once you meet all the security checks, you'll be redirected to a page where you can name your app and create it.

Afterward, the following will be prompted showing the password.
copy the password to a secure location.KEEP IT SECRET

3.
Django Email Integration
In production environments, it's crucial to secure your passwords. A common approach is to use a .env file to store your email credentials. Here's how to set it up:

Create the following variables in your .env file:

EMAIL_HOST = 'smtp.gmail.com'
EMAIL_USE_TLS = True
EMAIL_USE_SSL = False
EMAIL_PORT = 587
EMAIL_HOST_USER = 'your-gmail-email-address'
EMAIL_HOST_PASSWORD = 'password-generated-above-from-app-passwords'

Open the project settings file and add the following settings

from dotenv import load_dotenv
load_dotenv()

EMAIL_HOST = os.getenv('EMAIL_HOST')
EMAIL_USE_TLS = os.getenv('EMAIL_USE_TLS')
EMAIL_USE_SSL = os.getenv('EMAIL_USE_SSL')
EMAIL_PORT = os.getenv('EMAIL_PORT')
EMAIL_HOST_USER = os.getenv('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = os.getenv('EMAIL_HOST_PASSWORD')

Congratulations! you have successfully set up Django to send emails.
Thank you.

How to Set Up Multiple PostgreSQL Instances on a Single Server

Tito — Wed, 10 Apr 2024 20:00:14 +0000

Introduction

PostgreSQL has gained so much popularity in recent years due to its robust features. These features include the storage of advanced data structures (e.g., JSON, arrays), scalability for high-traffic environments, and a rich set of functionalities specifically designed for data handling. Additionally, PostgreSQL offers many other benefits.

In this short article, I will briefly discuss a simple way to create multiple PostgreSQL instances on a single machine. This is a very common scenario, depending on your usage. In my case, I wanted to test two services that will coexist in different environments.

Requirements

Installed PostgreSQL (Any version)
Ubuntu (any version)

We'll assume you already have a running PostgreSQL server on port 5432.

Steps of creating a second instance

Open the bash and run the following command

$sudo pg_createcluster 12 main1 --port=5433 --start

Use name of your choice for "main1" folder and the port number.Use any port number but not 5432 as By default, PostgreSQL is configured to run on port 5432. If you want to run a second instance, you'll need to configure it to use a different port.
This command creates another PostgreSQL cluster named main1 and
starts it on port 5433.

2.
Running this command will result to this:

3.
Modify Postgres configuration file to allow change of password:
When you try to access the new service, you will be denied entry. To ease the process of changing your password, navigate to this folder and open the pg_hba.conf file with your favorite text editor. Please note that the version of PostgreSQL may differ.

$sudo nano /etc/postgresql/12/main3/pg_hba.conf

4.
Scroll down to this section:

and make the following changes:

NB:

Remember to revert these changes back to the original configuration after resetting your passwords. These changes may pose a threat to your database security.
5.
Accessing the Instances:

$sudo su postgres
$psql -U postgres -h localhost -p 5433 -W

6.
Change the password:

psql$\password postgres

psql$\q

restart the server.

sudo service postgreSQL restart 5433

And update the Postgres configuration file back to the original settings.

sudo nano /etc/postgresql/12/main3/pg_hba.conf

to check the number of postgres instance running, use the following command:

ps -aux

for my case you can see I have 3 instances running

Useful commands to manage your instances

for this example, we shall assume the service is in folder main2

To start service

sudo pg_ctlcluster 12 main2 start

To stop service

sudo pg_ctlcluster 12 main2 stop

To restart service

sudo pg_ctlcluster 12 main2 restart

Thank you!

Simplified: 8 Guidelines for Commit Message

Tito — Wed, 09 Aug 2023 20:32:26 +0000

Introduction

Writing quality commit messages is what distinguishes the level of professionalism of an engineering team. As Quality commit messages ease collaboration and code maintenance.
Have you been writing quality commit messages?
Check and review some if not all your commit message by running this command on your git bash console or Terminal

 git log

Are you proud of what you have been writing?
Now take time and read this article to understand tips for writing professional git commit messages that tech novices can comfortably understand and derive a report out of it.
This article, assumes you have a basic for git workflow. If this is your first encounter kindly read

Guidelines for Commit message

Thou shall not write commit messages in the past tense One of the most emphasized rules for writing commit message is to ensure both the body and subject are not written in the past tense. Instead, use the present tense Example

git commit -m 'Fixed button colour'

Instead

git commit -m 'Fix: Change of button colour'

2. Thou shall not write short/unclear messages with a maximum of 50 characters

For the benefit of the maintainer, it is advised not to write a movie script with characters. Instead, write a clear commit subject and body. With a maximum of 50 characters.

3. Thou shall refer to bug ID

In big projects, there are systematic reporting channels where every bug has an id. The Id is referred to the issue registered on GitHub. Therefore including this id would make it easy to track the issue.
Example

git commit -m "#5:improve lazy loading"

4. Thou shall specify the type of commit

Specifying the type of commit makes it
feat: The new feature you're adding to a particular application
fix: A bug fix
style: Feature and updates related to styling
refactor: Refactoring a specific section of the code base
test: Everything related to testing
docs: Everything related to documentation
chore: Regular code maintenance. Example

git commit -m "feat:A bug fix"

5. Thou shall separate the subject and body by one line

Writing a commit message with both body and subject will provide excellent documentation to other team members.
For those in a Debian environment, just type

 git commit -a

and Vim editor will be prompted. Write the Subject and body into different lines, save and push to the remote repository.

6. Thou shall not include unnecessary punctuation in the message

Avoid adding unnecessary punctuation such as question marks, apostrophes and semi-colon. Don't create suspense in your colleague's mind. Just be clear

7. Thou shall follow rules set by the team

Rules are there to be broken. However, this is not the case in the software engineering world. Instead, rules are set to harmonize the team during the development and maintenance period. Respect them at all costs, as it is expensive to break them.

8. Thou shall start the message with an impressive verb e.g. as “Add”, “Fix”, “Update” “Delete”

Bonus Tip

You can also use emojis to represent commit types. In visual Code, install the Gitmoji extension

Simplified: Linux Directory Structure [Part 2]

Tito — Wed, 05 Jul 2023 18:30:13 +0000

Introduction
This is a part 2 of Linux Directory Structure part 1. If your are learning Linux kindly check out the first post in order to have a better understanding

/media

The /media directory plays a specific role in automatically mounting external storage devices when they are connected and accessed. Unlike other entries on this list, /media is not rooted in the 1970s because it is a result of the more recent development of on-the-fly insertion and detection of storage devices (such as USB drives, external hard disks, SD cards, external SSDs, etc.) while a computer is running.

/mnt

In contrast, the /mnt directory persists as a remnant from earlier times, primarily intended for manually mounting storage devices or partitions. However, its relevance and usage have greatly diminished in modern times.

/opt

The /opt directory is frequently used to store manually compiled software, which means it is built from source code instead of being installed from distribution repositories. Within this directory, applications are usually stored in /opt/bin, while libraries are placed in /opt/lib.
As a slight deviation, another location where applications and libraries are occasionally installed is /usr/local. When software is installed in this directory, corresponding /usr/local/bin and /usr/local/lib directories are created. The decision of which software goes to each location depends on how the developers have configured the files governing the compilation and installation process.

/proc

Similar to /dev, /proc is a virtual directory that contains computer-related information, such as details about your CPU and the kernel running on your Linux system. Like /dev, the files and directories in /proc are dynamically generated either during system startup or as your system operates and undergoes changes.

/run

/run is another new directory. System processes use it to store temporary data for their own nefarious reasons. This is another one of those DO NOT TOUCH folders.

/sbin

/sbin, resembling /bin, houses applications that are specifically intended for use by the superuser (hence the "s" in the directory name). These applications can be accessed using the sudo command, which grants temporary superuser privileges on many distributions. /sbin usually comprises tools capable of installing, deleting, and formatting various components. It is crucial to exercise caution while using these instructions since some of them can have severe consequences if utilized incorrectly.

/srv

The /srv directory is designated for storing server-related data. For instance, if you operate a web server on your Linux machine, the HTML files for your websites would be placed in /srv/http (or /srv/www). Similarly, if you run an FTP server, the files would be stored in /srv/ftp.

/sys

Similar to /proc and /dev, /sys is another virtual directory that contains information from devices connected to your computer. In some cases, it is also possible to manipulate those devices. For example, adjusting the brightness of a laptop screen can be achieved by modifying the value stored in the /sys/devices/pci0000:00/0000:00:02.0/drm/card1/card1-eDP-1/intel_backlight/brightness file (note that the file path may vary on different machines). However, performing such actions requires superuser privileges. This is because, like many other virtual directories, tampering with the contents and files in /sys can be risky and may lead to system issues. It is crucial to exercise caution and avoid making any changes unless you are confident in your understanding of the consequences.

/bin

The /bin directory is where binary files, including various applications and programs, are stored. This directory houses fundamental tools such as the mentioned ls program, which is used for listing files. It also includes essential utilities for creating and deleting files and directories, as well as moving them. While there are additional bin directories scattered throughout the file system tree, we will discuss those in a moment.

/var

The naming of the /var directory originally implied that its contents were variable, as they were expected to change frequently. However, in modern times, this name can be misleading because there are other directories, including virtual directories mentioned earlier, that also contain frequently changing data.

Nevertheless, /var encompasses various items, such as logs found in the sub-directories of /var/log. Logs are files that record system events, including kernel failures logged in files within /var/log, or firewall attempts to breach your computer from external sources, which are also logged here. Additionally, /var holds spools for tasks. These tasks can include print jobs sent to a shared printer, causing a delay if another user is printing a lengthy document, or mail waiting to be delivered to system users.

It's worth noting that your system may have additional directories not mentioned above. For instance, in the provided screenshot, there is a /snap directory, which is specific to Ubuntu systems. Ubuntu has recently introduced snap packages as a method of software distribution, and the /snap directory contains the files and software installed from snap packages.

Simplified: Linux Directory Structure [Part 1]

Tito — Tue, 27 Jun 2023 18:23:28 +0000

Introduction

Linux operating systems runs nearly 90% of world's server and micro-computers in smart devices.The top reason Linux-based OS are considered for such operations is attributed to:

Stability and security: Linux is known for its stability and security. This is due in part to the fact that Linux is a monolithic kernel, which means that all of the core components of the operating system are tightly integrated. This makes it more difficult for attackers to exploit vulnerabilities in Linux.
Performance: Linux is a very efficient operating system. This is due in part to the fact that Linux is designed to be lightweight and modular. This means that Linux can run on a wide variety of hardware, from old laptops to powerful servers.
Customization: Linux is highly customizable. This means that you can tailor the operating system to your specific needs and preferences. There are many different Linux distributions available, each with its own set of features and customization options.

Of course, no operating system is perfect. Linux also has some disadvantages, such as:

Linux can be difficult to learn: Linux is a complex operating system. It can be difficult to learn, especially if you are used to Windows.
Linux has a smaller software selection than Windows: There are fewer software packages available for Linux than for Windows. However, there are still many great software packages available for Linux.
Linux support can be difficult to find: If you need help with Linux, you may have to search online forums or chat rooms. There are fewer Linux support options than for Windows. Overall, Linux is a great operating system with many advantages. However, it is important to be aware of the disadvantages before you decide to switch to Linux.

For purpose of the topic , let's dive into Linux Directory Structure,we shall have another session to discuss Linux based-OS in depth

Illustration of Linux Directories Structures

As shown above, we shall discuss these directories in two series post.Let's get Started.

(/)root

This the top most or parent directory that stores all the directories in a Linux system. Every file's absolute path traverses through the root directory since it serves as the parent to all other directories.

/boot

DISCLAIMER: Don't modify any file in this directory!
The boot directory houses crucial files required by the boot loader, including the kernel and the initial ram file system (initramfs). It is advised not to modify this directory on your main machine, as it can have significant consequences. If you wish to experiment, it is recommended to do so within a virtual machine, where any potential issues can be contained.

/etc

The /etc directory can be a source of confusion when it comes to naming conventions. Its name originated from early Unix systems, where it was simply called "et cetera" because it served as a miscellaneous storage location for system files that administrators were uncertain where else to place.

In modern times, it would be more appropriate to interpret "etc" as an abbreviation for "Everything to configure." This directory houses a wide range of system-wide configuration files, encompassing various aspects. For instance, you can find files containing the system's name, user accounts and passwords, network machine names, and specifications on how and where hard disk partitions should be mounted.

If you are new to Linux, it is advisable to exercise caution and refrain from making extensive modifications in this directory until you have gained a better understanding of how the system operates.

/dev

Several of these files are created during the boot process or dynamically as needed. For instance, when you connect a new webcam or a USB pen-drive to your machine, a corresponding device entry will automatically appear in this directory.

In Linux, the principle of treating everything as a file extends to hardware components as well. The /dev directory holds special virtual files that represent various hardware elements such as a mouse, keyboard, storage devices, and more, which are connected to your system.

/home

The /home directory is the designated location for users' personal directories. In my situation, there are two directories under /home: /home/tito , which holds all of my personal files.

In terms of functionality, the /home directory is similar to the C:/Users directory in a Windows environment. It stores individual user configurations within each user's specific directory, allowing for personalized settings and files.

/usr

In the early days of UNIX, the /usr directory served as the location for users' home directories. However, as we mentioned earlier, the /home directory is now the designated place for users to store their personal files.

In modern times, the /usr directory has evolved to become a diverse collection of subdirectories that house applications, libraries, documentation, wallpapers, icons, and various other resources required to be shared among applications and services. It has become a repository for a wide range of items necessary for the functioning and support of software and services.

/tmp

The /tmp directory serves as a storage location for temporary files that are typically generated by the applications you are running. These files and directories often (though not always) contain data that an application doesn't require immediately but might need at a later point.

/lib

The /lib directory is the designated home for libraries. Libraries are files that contain code utilized by your applications. They consist of code snippets that applications utilize to perform various tasks, such as rendering windows on your desktop, managing peripherals, or saving files to your hard disk.

While there are multiple lib directories spread across the file system, the one directly attached to / holds particular significance. It houses crucial components, including the essential kernel modules. Kernel modules serve as drivers responsible for enabling the functionality of various hardware components such as video cards, sound cards, WiFi adapters, printers, and more.

In conclusion, we have explored the first part of the simplified Linux Directory Structure. We have learned about important directories such as /root, /boot, /etc, /dev, /usr, and /lib, understanding their significance and the types of files they contain.

This overview provides a foundation for further exploration into the Linux Directory Structure. In the upcoming second series, we will delve into additional directories, uncovering their roles and functionalities within the Linux operating system.

By gaining a better understanding of the directory structure, you will be equipped with valuable knowledge to navigate and manage your Linux system effectively. Stay tuned for the next installment as we continue our exploration of the Linux Directory Structure.

Linux Directory Part 2

3 Easy Commands to Install Postman in Kali Linux

Tito — Thu, 20 Apr 2023 19:50:56 +0000

Introduction

For an effective development environment especially back-end, you will require postman to test your endpoints. It has been constantly said that Debian environments are ideal for Software development/engineering processes. Having said this, I will take 3 simple steps to install Postman in Kali Linux.

Requirements

Internet
Proficiency with Command utility
x64 Linux architecture

1.Extract the folder using the following command and a Postman folder will be created:

sudo tar -xvz -f postman-linux-x64.tar.gz

2.Move the folder to the root opt folder

sudo mv Postman /opt/

3.Navigate to this folder /usr/share/applications/ and create a file Postman.desktop and open the nano editor

touch Postman.desktop && nano Postman.desktop

write the following content

[Desktop Entry]
Encoding=UTF-8
Name=Postman
Exec=/opt/Postman/app/Postman %U
Icon=/opt/Postman/app/resources/app/assets/icon.png
Terminal=false
Type=Application
Categories=Development;

You have successfully installed Postman!

Simplified O.O.P : Abstraction in Python

Tito — Wed, 31 Aug 2022 18:45:14 +0000

Introduction

In previous post , Simplified: Object-oriented Programming Python, I promised to get into details on abstraction. The assumption for this post is you are proficient with python . If you are starting , start here

In this article, we are going to dive deep on Abstraction in Python. Below is an overview of this post:

Definition and importance of Abstraction
Application of abstraction
Abstract Classes and Methods
Summary

Definition of abstraction

Before getting into technical definition of abstraction ,let's first define it with simpler and relatable example. consider your T.V remote, the '+' button ,which is used to increase the volume .You can use the button but you cannot see how operations are carried out. This is a perfect example of abstraction.

Now what is Abstraction in technical term ? In Python, data abstraction can be defined as ,hiding all the irrelevant data/process of an application in order to reduce complexity and increase the efficiency of the program.

Application of Abstraction

Data abstraction has been wholly been implemented in Django framework(Assumption you have basic experience with django).
When creating a model , take an example of Student model:

from django import models

class student(models.Model):
   first_name= models.CharField(max_length=100, blank=True,null=True)
   last_name= models.CharField(max_length=100, blank=True,null=True)
   def __str__(self):
       return self.first_name + "" + self.last_name

This is a perfect example of application of abstraction in solving real-world problem. class model inherited from ensure uniformity in definition of a model. As we progress , you will see the consequences of not following the set of instruction provided in the data abstracted.

Abstract Classes and Methods

Abstract Class is a class created as a blueprint of an object that can be inherited to create new objects, whereas abstract method is a method that is declared, but does not contain implementation. An abstract method in a base class identifies the functionality that should be implemented by all its subclasses.

implementation
To declare an Abstract class, we firstly need to import the abc module. Let us look at an example.

from abc import ABC
class payment_class(ABC):
     #abstract methods goes below

Now lets implement a complete abstract class with methods

from abc import ABC
class payment_class(ABC):
     #abstract methods
    @abstractmethod 
    def send_money(self):
         pass
   @abstractmethod 
   def withdraw_money(self):
        pass

Apart from abstract method, an abstract class also can have a method and every time an abstract class is inherited it would be called and run.
Let's create a working example:

#Section 1
from abc import ABC,abstractmethod
class payment_class(ABC):
  def welcome_text(self,x):
    print(f'Welcome to {x}')
  #abstract methods
  @abstractmethod 
  def send_money(self):
    pass
  @abstractmethod 
  def withdraw_money(self):
    pass
#Section 2
# Create payment service 
class Terminal_pay(payment_class):
  def __init__(self,total,tax,amount,sendcharges,commission,balance=0):
    self.amount = amount
    self.sendcharges = sendcharges
    self.commission = commission
    self.tax = tax
    self.balance = balance
    self.total = self.tax + self.commission + self.amount + self.sendcharges
  def send_money(self):
    self.balance = self.balance - self.total
    print(f'Send USD. {self.amount} at USD. {self.sendcharges} commission charged USD.{self.commission} give USD. {self.total}.Your balance is USD. {self.balance}')
  def withdraw_money(self):
    self.balance = self.balance - self.total
    print(f'USD.{self.amount} withdrawn at {self.sendcharges} give {self.total}')

safariPay = Terminal_pay(total=0,tax=16,sendcharges=10,commission=10,amount=200)
safariPay.welcome_text("safariPay")
safariPay.send_money()

Output:
Welcome to safariPay
Send USD. 200 at USD.10 commission charged USD.10 give USD.236.Your balance is USD.-236

Explanation

In this example(Divided into two sections), Section 1 is importing ABC,abstractmethod from abc module, declaration of Abstract Base Class with a generic method that has an argument X declared and an Abstract methods : send_money,withdraw_money.

In section 2, We create a payment service that inherits from the payment_class Abstract Base class. The payment_class we create a constructor and what follows is definition of the methods:withdraw_money,send_money and lastly we instantiate the Terminal_class.

Follow me for more update

Python: Introduction to DataClasses

Tito — Wed, 27 Apr 2022 10:17:09 +0000

Introduction

This article will be explaining the concept of data class introduced in python 3.7+.My assumption are you are conversant with python in particular object-oriented Programming. However, I will briefly explain the concept and redirect you to more resources.

Classes Recap:

What is a class ?

it can simply be defined as an object constructor or a blueprint of creating an object.

Example

class Student:
  def __init__(self, name, age):
    self.name = name
    self.age = age

line 1: class definition with the name of the object (Student).
line 2 to 4: Object constructor.The init() function is called automatically every time the class is being used to create a new object.

NB:

The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.It does not have to be named self , you can call it whatever you like, but it has to be the first parameter of any function in the class.

DataClasses

The new dataclass() decorator provides a way to declare data classes. A data class describes its attributes using class variable annotations. Its constructor and other magic methods, such as repr(), eq(), and hash() are generated
automatically.

Example 1:

Consider the example of Student object created above, but now modified.

from dataclasses import dataclass
@dataclass
class Student:
  name: str
  age: int
  def greet_student(self) -> str:
    return f'Hello {self.name}, you are {self.age} years old'
p = Student('Tito',16)
print(p.greet_student())

Output:
Hello Tito, you are 16 years old

Example 2:

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

From the above example, you will notice we have omitted the init() constructor , data class will added it automatically. Data class will help you create object easily and add more configurations to your objects.Now that you have a basic understanding of data classes in python. In our next episode I will be diving deep into data classes concepts.
Follow for more content.

Interpreted Python: Linear Data Structures

Tito — Mon, 07 Mar 2022 08:16:33 +0000

Introduction

Welcome back to this exciting data structures series. This is a continuation of Built-in Data Structures in python.If you are new to python, I would highly recommend you to read my previous post .
User-defined data structures are data structures created by user primitively while keeping in mind the built-in data structure.
Additionally they can be classified into :
1. Linear:
a. Stack b. Queue c. Linked List
2. Non-linear:
a. Tree b. Graph c. HashMap

Demo and Explanation
a.Stack
Stacks Store items on the basis of First-In/Last-Out (FILO) or Last-In/First-Out (LIFO). To add and remove item from a stack, you will use push and pop respectively. Other functions related to Stack are empty(), size() and top().

Stacks can be implemented using modules and data structures from the Python library – list, collections.deque, and queue.LifoQueue.

Implementation
As stated earlier , stacks can be implemented in 3 ways, namely

List
collections.deque
queue.LifoQueue

And We shall cover them in the simplest form

Implementing Stack Using list

car_stack = []
car_stack.append('Audi')
car_stack.append('Subaru')
car_stack.append('BMW')
car_stack.append('Chevrolet')
car_stack

Output:
['Audi', 'Subaru', 'BMW', 'Chevrolet']
#note the order of appending.
car_stack.pop()
'Chevrolet'

Note

Creating stacks using List might be easier due to it's familiarity, however list has some drawbacks. You will realize, as a list grow, speed will become a challenge.
Additionally,Inserting item to your stack at a position other than the end, it can take much longer. This is not normally something you would do to a stack, however.

Implementing stacks Using collections.deque

deque is pronounced “deck” and stands for “double-ended queue.”
You can use the same methods on deque as you saw above for list, .append(), and .pop()

from collections import deque

town_stack = deque()
town_stack.append('kilifi')
town_stack.append('mumbai')
town_stack.append('kansas')
town_stack

Output:
deque(['kilifi', 'mumbai', 'kansas'])

town_stack.pop()
Output:
kansas

NOTE

From the brief explanation on deque, you will realize deque and list serve the same operations. However , you will realize deque and list have a difference in the why they store data.

List store elements in blocks of adjacent memory which might take time to append() a stack especially when the stack is full.
Deque store elements in its own memory block and has a reference to the next entry in the list.This facilitate easy update of nodes

Implementing stacks Using queue.LifoQueue

There are various functions available in this module:

Method	Description
maxsize	Number of items allowed in the queue.
empty()	Return True if the queue is empty, False otherwise.
full()	Return True if there are maxsize items in the queue. If the queue was initialized with maxsize=0 (the default), then full() never returns True.
get()	Remove and return an item from the queue. If the queue is empty, wait until an item is available.
get_nowait()	Return an item if one is immediately available, else raise QueueEmpty.
put(item)	Put an item into the queue. If the queue is full, wait until a free slot is available before adding the item.
put_nowait(item)	Put an item into the queue without blocking.
qsize()	Return the number of items in the queue. If no free slot is immediately available, raise QueueFull.

from queue import LifoQueue

# Initializing a stack
mystack = LifoQueue(maxsize = 6)

# qsize() show the number of elements
# in the stack
print(mystack.qsize())

# put() function to push
# element in the stack
mystack.put('ub40')
mystack.put('Lucky dube')
mystack.put('Charlie Chaplin')
mystack.put('Sinach')
mystack.put('Davido')
mystack.put('Hillsong')

print("Full: ", mystack.full()) 
print("Size: ", mystack.qsize()) 

# get() fucntion to pop
# element from stack in 
# LIFO order
print('\nElements poped from the stack')
print(mystack.get())
print(mystack.get())
print(mystack.get())

print("\nEmpty: ", mystack.empty())

Output:
0
Full:  True
Size:  6

Elements popped from the stack
Hillsong
Davido
Sinach

Empty:  False

b.Queue
A queue is a useful data structure in programming, so far we have discussed the LIFO operation in stack. For queue it follows FIFO operation(First In First Out or in simple term first come first Served).Therefore , the item that goes in first goes out first.

In programming terms, putting items in the queue is called enqueue, and removing items from the queue is called dequeue.

Basic Queue Operations

Operation	Description
Enqueue	Add an element to the end of the queue
Dequeue	Remove an element from the front of the queue
IsEmpty	Check if the queue is empty
IsFull	Check if the queue is full
Peek	Get the value of the front of the queue without removing it


#implementing queue
class Queue:
  def __init__(self):
    self.queue = list()

  #adding elements
  def enqueue(self,item):
    self.queue.append(item)

  #remove item from queue
  def dequeue(self,item):
    if len(self.queue)< 1:
      return None
    return self.queue.pop(0)

  #Display queue
  def display(self):
    print(self.queue)

  #queue size
  def size(self):
    return len(self.queue)

q = Queue()
q.enqueue(18)
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
q.enqueue(4)
q.enqueue(5)
q.dequeue(0)
q.display()

c. Linked list

A linked list is a sequence of data elements, which are connected together via links. This is implemented using the concept of nodes.Each data element contains a connection to another data element in form of a pointer.Each node contains a value and a pointer to the next node in the chain.
Linked list can be implemented in various form:

Singly Linked list
Circularly Linked Lists
Doubly Linked Lists

However in this post we will majorly look into singly linked list.Which is the simplest and a building block for the rest of the lists.
Terminologies:

Head:This is the first node of a linked list
Tail: This is the last node of a linked list and can be identified as having a None value as its next reference.
link or pointer : It is simply the identifier to the next node
Traversing(link hopping or pointer hopping): It is the process of moving from the head through each node following each node’s next reference, and finally to the tail of the linked list

Basic Implementation of Linked List

class Node:
    # Creating a node
    def __init__(self, item):
        self.item = item
        self.next = None
class LinkedList:
  def __init__(self):
    self.head = None


if __name__ == '__main__':

    linked_list = LinkedList()
    linked_list.head = Node(1)
    second = Node(2)
    third = Node(3)
    linked_list.head.next = second
    second.next = third
    while linked_list.head != None:
        print(linked_list.head.item, end=" ")
        linked_list.head = linked_list.head.next

In this post , I have basically define the structure and definition of linear data structures.In my upcoming posts I will be going into details especially for linked List.
Follow me for more post

Built-in Data Structures In Python

Tito — Tue, 14 Dec 2021 11:59:00 +0000

Introduction

Python has always been classified as a general-purpose programming language due to it's versatility, from web dev to data science.
However, data has become a lifestyle and has to be considered during systems design. All the data collected needs to be store and accessed efficiently. To attain this , data structures come in hand.

1. What's a Data structure ?

A data structure is a specialized format for organizing, processing, retrieving and storing data.

Types of Data Structures

1. Built-in

As the name suggest, Built-in data structures are predefined data structures that come along with python.Can be accessed from any python environment.
a.Lists
They are used to store data of different data types in a sequential manner.Every member of the list are assigned unique address called index.The first member of a list is assigned number 0. Members of the list can accessed in two ways; Positive indexing(the most common method) and Negative indexing.All this will be demonstrated in examples.
List are created by assigning square rackets to a variable and add a values accordingly.
Implementation

#creating empty values
cars = []
print(cars)
#adding elements to a list
cars = ["Audi",3.2,"Subaru",5,"Romeo",432.789]
print(cars)

Output:
[]
["Audi",3.2,"Subaru",5,"Romeo",432.789]

List Methods

These are built-in operations for manipulating lists. We shall explore them with examples.

Methods	Description
append()	Adds an element at the end of the list
clear()	Removes all the elements from the list
copy()	Returns a copy of the list
count()	Returns the number of elements with the specified value
extend()	Add the elements of a list (or any iterable), to the end of the current list
index()	Returns the index of the first element with the specified value
insert()	Adds an element at the specified position
pop()	Removes the element at the specified position
remove()	Removes the first item with the specified value
reverse()	Reverses the order of the list
sort()	Sorts the list

Example

cars = ["Audi",3.2,"Subaru",5,"Romeo",432.789]
print(cars)
# append 
cars.append("Toyota")
print(cars)
#copy
cars_1 = cars.copy()
print(cars_1)
# clear
cars_1.clear()
print(cars_1)
# count
print(cars.count("Audi"))
# Extend
fruit = ["kiwi","cherry","grapes"]
city = ["morotro","iraq","texas","qalit"]
fruit.extend(city)
print(fruit)
# index
cars = ["Audi",3.2,"Subaru",5,"Toyota","Romeo",432.789]
print(cars.index("Toyota"))
#insert
fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits)
#pop
fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits)

output:
["Audi",3.2,"Subaru",5,"Romeo",432.789]
["Audi",3.2,"Subaru",5,"Romeo",432.789,"Toyota"]
["Audi",3.2,"Subaru",5,"Romeo",432.789]
[]
1
["kiwi","cherry","grapes","morotro","iraq","texas","qalit"]
4
['apple','orange','banana', 'cherry']

['apple','cherry']

b.Tuples

These are data structure that store an ordered sequence of values. Tuples are immutable. This means you cannot change the values in a tuple. Tuples are defined with parenthesis.

NOTE

Tuples allow duplicate values
it is not necessary to enclose the tuple elements in parentheses
Tuples allow use of heterogeneous data

Implementation

realk = ("Texas","Estonia","Monaco")
print(realk)
# duplicate values
realk1 = ("Texas","Estonia","Monaco","Texas")
print(realk1)
# No parentheses
realk = 'Texas','Estonia','Monaco'
print(realk)
# Heterogeneous data
employee=(1, 'Steve', True, 25, 12000)
print(employee)

output:
('Texas','Estonia','Monaco')
('Texas','Estonia','Monaco','Texas')
('Texas','Estonia','Monaco')
(1, 'Steve', True, 25, 12000)

Tuples Operations

Tuple is unchangeable. So, once a tuple is created, any operation that seeks to change its contents is not allowed. For instance, trying to modify or delete an element of any tuple will result in an error.

Operator
The + operator returns a tuple containing all the elements of the first and the second tuple object.

Example

t1=(1,2,3)
t2=(4,5,6)         
t1+t2              
(1, 2, 3, 4, 5, 6) 
t2+(7,)            
(4, 5, 6, 7)

Operator
The * operator Concatenates multiple copies of the same tuple.

Example

>>> t1=(1,2,3)
>>> t1*4                             
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)

Operator
The [] operator Returns the item at the given index. A negative index counts the position from the right side.

Example

>>> t1=(1,2,3,4,5,6)     
>>> t1[3]                
4                        
>>> t1[-2]               
5

Operator
The [:] operator returns the items in the range specified by two index operands separated by the : symbol.
If the first operand is omitted, the range starts from zero. If the second operand is omitted, the range goes up to the end of the tuple.

>>> t1=(1,2,3,4,5,6) 
>>> t1[1:3]              
(2, 3)                   
>>> t1[3:]               
(4, 5, 6)                
>>> t1[:3]               
(1, 2, 3)

Operator
The in operator returns true if an item exists in the given tuple.

Example

>>> t1=(1,2,3,4,5,6) 
>>> 5 in t1
True                
>>> 10 in t1 
False

Operator
The not in operator returns true if an item does not exist in the given tuple.

Example

>>> t1=(1,2,3,4,5,6) 
>>> 4 not in t1 
False                    
>>> 10 not in t1
True

c.Dictionary

Dictionaries are used to store data values in key:value pairs.

Characteristics of Dictionaries

They are ordered:The items have a defined order, and that order will not change.
They are Changeable: that we can change, add or remove items after the dictionary has been created.
They do not allow duplicates: cannot have two items with the same key
The values of a dictionaries can be of any data type.

NB: As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.

Dictionary methods

Method	Description
clear()	Removes all the elements from the dictionary

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
members.clear()
print(members)

Output:
{}

Method	Description
copy()	Returns a copy of the dictionary

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
copy_members = members.copy()
print(copy_members)

Output:
{'sales':'Rhorda','Accounts':'Mustafa','Technical':'Naliaka'}

Method	Description
fromkeys()	Returns a dictionary with the specified keys and value.Can be used to make dictionary with the same values

Example

departmet = ("account","IT","Engineering")
members = ("Tityo")
dict_1 = dict.fromkeys(departmet,members)
print(dict_1)

Output:
{'account': 'Tityo', 'IT': 'Tityo', 'Engineering': 'Tityo'}

Method	Description
get()	Returns the value of the specified key

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.get("Accounts")
print(Acc_1)

Output:
Mustafa

Method	Description
items()	Returns a list containing a tuple for each key value pair.The view object contains the key-value pairs of the dictionary, as tuples in a list.

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.items()
print(Acc_1)

Output:
dict_items([('sales', 'Rhorda'), ('Accounts', 'Mustafa'), ('Technical', 'Naliaka')])

Method	Description
keys()	Returns a list containing the dictionary's keys.The view object contains the keys of the dictionary, as a list.

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Acc_1 = members.keys()
print(Acc_1)

Output:
dict_items(['sales','Accounts','Technical'])

Method	Description
pop()	Removes the element with the specified key

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.pop("sales")
print(Remove_member)

Output:
{'Accounts':'Mustafa','Technical':'Naliaka'}

Method	Description
popitem()	Removes the last inserted key-value pair

NB:Before Python 3.7, the popitem() method removes a random item.
Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.popitem()
print(Remove_member)

Output:
{'Accounts':'Mustafa','Accounts': 'Mustafa'}

Method	Description
setdefault()	Returns the value of the specified key. If the key does not exist: insert the key, with the specified value

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
Remove_member = members.setdefault("sales","phagra")
print(Remove_member)
Output:
Rhorda

Method	Description
update()	Updates the dictionary with the specified key-value pairs.The specified items can be a dictionary, or an iterable object with key value pairs.

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
New_member = members.update({"Engineering":"phagra"})
print(New_member)
Output:
{'sales':'Rhorda','Accounts':'Mustafa','Technical':'Naliaka','Engineering':'phagra'}

Method	Description
values()	Returns a list of all the values in the dictionary.The view object contains the values of the dictionary, as a list.The view object will reflect any changes done to the dictionary

Example

members = {
  "sales": "Rhorda",
  "Accounts": "Mustafa",
  "Technical": "Naliaka"
          }
member_values = members.values()
print(member_values)
Output:
dict_values(['Rhorda','Mustafa','Naliaka'])

d.Sets
A set is an unordered collection of items.

Characteristics of Sets

Every set element is unique (no duplicates)
They must be unchangeable.
It is created by placing all the items (elements) inside curly braces {}, separated by comma, or by using the built-in set() function.

Set Methods

Method	Description
add()	Adds an element to the set

Example

x = {"facebook", "instagram", "whatsapp"}
x.add("twitter")
print(x)

Output:
{'facebook', 'instagram', 'whatsapp','twitter'}

Method	Description
clear()	Removes all the elements from the set

Example

x = {"facebook", "instagram", "whatsapp"}
x.clear()
print(x)

Output:
set()

Method	Description
copy()	Returns a copy of the set

Example

x = {"facebook", "instagram", "whatsapp"}
y = x.copy()
print(y)

Output:
{'facebook','instagram', 'whatsapp'}

Method	Description
difference()	Returns a set containing the difference between two or more sets

Method	Description
difference_update()	Removes the items in this set that are also included in another, specified set

Method	Description
discard()	Remove the specified item

Method	Description
intersection()	Returns a set, that is the intersection of two other sets

Method	Description
intersection_update()	Removes the items in this set that are not present in other, specified set(s)

Method	Description
isdisjoint()	Returns whether two sets have a intersection or not

Method	Description
issubset()	Returns whether another set contains this set or not

Method	Description
issuperset()	Returns whether this set contains another set or not

Method	Description
pop()	Removes an element from the set randomly

Example

x = {"facebook", "instagram", "whatsapp"}
x.pop()
print(x)

Output:
{'instagram','whatsapp'}

Method	Description
remove()	Removes the specified element

Example

x = {"facebook", "instagram", "whatsapp"}
x.remove("facebook")
print(x)

Output:
{'instagram','whatsapp'}

Method	Description
symmetric_difference()	Returns a set with the symmetric differences of two sets

Example

x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "facebook"}

x.symmetric_difference(y)
print(x)

Output:
{'instagram','whatsapp','google','microsoft'}

Method	Description
symmetric_difference_update()	inserts the symmetric differences from this set and another

Example

x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "facebook"}

x.symmetric_difference_update(y)
print(x)

Output:
{'instagram','whatsapp','google','microsoft'}

Method	Description
union()	Return a set containing the union of sets

NB:You can specify as many sets you want, separated by commas.
It does not have to be a set, it can be any iterable object.
If an item is present in more than one set, the result will contain only one appearance of this item.

Example

x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "apple"}
w = {"google","twitch","whatsapp"}
x.union(y,w)
print(x)

Output:
{'facebook','instagram','microsoft','apple','whatsapp','google','twitch'}

Method	Description
update()	Update the set with the union of this set and others

Example

x = {"facebook", "instagram", "whatsapp"}
y = {"google", "microsoft", "apple"}
x.update(y)
print(x)

Output:
{'facebook','instagram','whatsapp','google','microsoft','apple'}

In my next article, I will be discussing User-defined Data Structures in python. Stay tuned by following me.
Your comment is highly-valued

RESOURCES

Flask[Part 2]: Setting up Database

Tito — Thu, 26 Aug 2021 14:35:29 +0000

Introduction

This article is a continuation of our Previous Post where we tackled setting up working directory, working environment , installing flask and run a flask app.
In this article we will focus on creating models , migrations and testing database

Prerequisite

python 3+ installed
Flask Installed; A working flask app
PostgreSQL optional; work with DBMS of your choice

Before you start, create a model.py file in project folder and install ,import the following packages:

flask-login
flask-sqlalchemy
flask-migrate
itsdangerous On the database configuration, it is advisable to hide the db details using environment variables.

Now Go ahead the model

After creating our model and ensuring that the DBMS of your choice is working, carry out a migration:

(env) tito@tito-HP-2000-Notebook-PC:~/Desktop/Milestone/Mile_Proj$ flask db init
(env) tito@tito-HP-2000-Notebook-PC:~/Desktop/Milestone/Mile_Proj$ flask db migrate

The migrations will automatically create tables in your Database.
Thank you for following .
The next article , I will handle forms for collecting data.
------------------------------------ NEXT ARTICLE------------------------------------

Flask[Part 1]: Register-login Authorization System

Tito — Thu, 26 Aug 2021 11:34:54 +0000

Introduction

Hello reader, thank you for opening this article, which documents an authorization system made with flask. Lets get straight to the agenda,In your development journey, holding the stack constant,you will realize authorization system is an important section of your software. Therefore in this article we will build an authorization system. Lets get starting

Objective

To allow new users create account and data saved in the Database. If the email or username already exists in the database, the user will not create the account.
To allow Users can log in only if their credentials are present in the database.
To prevent users from accessing other pages without logging in
To recover password through email
To allow users log out and redirect to page.

Section

As the project is quite large, I will subdivide it into section to ease the learning. In the first session, I will handle the following:

Setup Project folder and Project Environment
Flask installation and testing it
Setting up routes

Section 1:

Prerequisite

Some 2 months experience in Programming
Python 3+ installed
Linux bash / Windows CMD
Optional, Linux Ubuntu 20.04 LTS

Setup Project folder and Project Environment Open up you Linux bash ,create a project folder and an Project Environment with in it.

navigate to you Desktop directory and create a working directory, Additionally we will create a folder within to store project files.
Name of the project:MileStone

tito@titoOwnerPc:cd ~ && cd Desktop
tito@titoOwnerPc:~/Desktop$ mkdir MileStone
tito@titoOwnerPc:~/Desktop$cd MileStone
tito@titoOwnerPc:~/Desktop/MileStone$ mkdir Mile_Proj
tito@titoOwnerPc:~/Desktop/MileStone$

Let create an environment ,name it Mile_env :

tito@titoOwnerPc:~/Desktop/MileStone$ python3 -m venv Mile_env

fire up VsCode from the terminal while on the working directory

tito@titoOwnerPc:~/Desktop/MileStone$ code .

Now, while in your VsCode terminal, activate the environment and and navigate to the project folder(Mile_Proj) in the VsCode terminal

tito@titoOwnerPc:~/Desktop/MileStone$ cd Mile_env && cd bin && source activate
(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_env/bin$ cd .. && cd .. && cd Mile_Proj
(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_Proj$

Install flask with this command:

(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_Proj$ pip3 install flask

Create an 'app.py' file

(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_Proj$ touch apps.py

Congratulations for getting to this level.Your VsCode should look like this

Now , lets get working by creating the backbone of our flask app and run it

To run the flask app:

(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_Proj$ export FLASK_APP=apps.py

then:

(Mile_env)tito@titoOwnerPc:~/Desktop/MileStone/Mile_Proj$ flask run

After running, you should see this:

Open your browser and open this link:
(Do not click the link)
http://127.0.0.1:5000/home
Optionally, hold Ctrl + click the link provided in the terminal after running the app

I will end section 1 of this project by adding routes to the project. For the base , application will have:

login route
logout route
home route
Register route

Lets do this:

Try running and make sure the routes are running well without errors.
I wish to end the first section here. In the next post, which I will focus on setting up database.
-------------------------NEXT ARTICLE---------------------------