DEV Community: Pratik Mishra

Docker - Containers & Images.

Pratik Mishra — Tue, 20 Apr 2021 06:24:45 +0000

Let's move on with our Docker series but before that if you haven't read the previous 2 articles then please go and give them a read I assure you that you'll like it.

Docker - Basic Introduction.

Pratik Mishra ・ Apr 15 '21 ・ 3 min read

#docker #devops #career #beginners

Docker Engine - Deep Dive into Docker.

Pratik Mishra ・ Apr 15 '21 ・ 5 min read

#docker #dockerengine #dockerdeepdive #coreconcepts

Okay, Now let's talk about Images First, like what are Docker Images?
Images are nothing but a prototype for your application with all the dependancies and other stuff defined inside it.In short you can think of Images as a Class and a container as an object of that class.
You can check out various pre-built images on Docker Hub.
Docker Hub is a Docker Registry where you can upload and Download Images from. Note: Only the official Images can be found directly on Docker Hub but what if you want to get Images from some other trusted user(Please only download Official Images or from a user you trust you don't want to create problems for your machine) then you can find their Images here: Organization/repository/Image:tag like docker.io/pratik6217/covid-webapp:latest. This is my repository on Docker Hub).
Now, as I said Earlier in the previous posts that Dockerfile contain Intructions to build your Docker Image. so let's see some of the instructions right now:
Here is a simple Dockerfile:

# The base os Image for our application.
FROM ubuntu:latest

# Updating all it's packages.
RUN apt-get update && apt-get upgrade
RUN apt-get install python3 && apt-get install python3-pip

# Making a directory in the container for our project files.
RUN mkdir project
# Copying the files over from our machine on to the container.
COPY ./project:./project
# Setting the working directory to our projects directory.
WORKDIR ./project

# Installing Python requirments (modules) used.
RUN pip3 install -r requirements.txt

EXPOSE 8501
CMD streamlit run test.py

Let's break it down what exactly is happening here, first we always need a base os Image for our application on which our application sits.(These are lightweight os Images unlike VM's which only contain the necessary files which makes them to boot very quickly).
So first we mention which base Image we are going to use using the FROM keyword.
Next is the RUN instructions it is used to Run commands in the base Images bash(shell) to update it and get it ready for our use.
Next, we installed python3 and pip since I am deploying a python based app. As I said docker packs in all the required files and dependencies, so we copy all our project files from our local machine to the container.
Next, I have exposed port 8501 of the docker container as streamlit uses that port.
Then the final part is defining the entrypoint for your application so as you run your container the application will start running.

Now, let's build this Image:
The syntax for building Images is as follows:

# You can either use docker image build or docker build they are one and the same.
# docker build-keyword tag-name and then the loaction where the Dockerfile is.
docker build -t qrcode:latest .

As you can see from the above video our Image was successfully compiled and we are ready to start a container from it.

But before doing that let's analyse what happened when we ran docker build command as we saw when we ran this command docker daemon was called and it started building each stage one by one by stage I mean whenever you run commands in your docker file docker spins up a temporary container from it and runs your commands within that container and upon finishing that task it exits and saves the committed changes. Now Images are not a single file it consists of several layers within it which are lossely connected in the correct order using a manifest ( manifest is nothing but it consists of the metadata as well as a list of all the layers and the order in which they need to be stacked ).

Also you might have noticed that I used -t flag along with the build command it is nothing but used to specify a tag(name) to your image.

Now, lets run our built Image:
The syntax for running a container is as follows:

# You can either use docker container run or docker run they are one and the same command.
# docker run-keyword tags and at last the name of the image.
docker run -i -t -p 8501:8501 --name qrcode qrcode:latest

As we can see I easily started a container from the built Image within seconds also note that I used several tags with the docker run command let's understand those one by one.

-i flag: It is used to specify that we want our container to be interactive that we want to see the output of our docker container on our local terminal. So docker basically links the containers terminal with your local terminal. It stands for Interactive.

-t flag: Docker in it's self doesn't provide terminal to it's containers now if you wish to give a terminal to your docker container (reasons can be many for this say you want to change certain things in your container so you easily do those using the containers terminal) you can use this flag. It stands for Pseudo Terminal.

-p flag: This flag is used to publish the ports on the container and link those ports of our docker container with the ports of our local machine. See in the video above I have linked port 8501 of my docker container to port 8501 of my local machine. (always remember the port on the left is your local machine's port and the one on the right is the port of your docker container

-p (local machine -> )8501:8501(<- Docker container))

--name flag: is used to name your container if not mentioned docker will give it some random name.

So, that's it here's how you can create your own Images and run Containers from them.I know I have'nt covered each and every command and the reason is I myself don't know each and every command and you don't need to know it either it's just that whenever you are about to use these commands for your use case you can just look them up on docker's official website. I know it must be difficult to grasp all of these in the first time and I totally Understand that as it took me a lot of time to get used to all of these just practise all of these and one day all this will be a piece of cake for you :)

Python - Read and Generate Qrcodes Under 10 Lines.

Pratik Mishra — Fri, 16 Apr 2021 15:34:14 +0000

Let's make a Qrcode Generator and reader in Python.
First Install all the dependencies, we'll be using qrcode module for generatin the qrcode and Pillow library as it used by qrcode.

pip install qrcode pillow

First create a folder for your project as in this way all of your things will be properly organised.
Now inside your folder create a python file and name it anything you want to I have named mine as "main.py"

Now let's begin with coding, First import all the required modules:

import qrcode
from PIL import Image

Now create a variable to take input from the user:

text = input('Please enter a text:')

since we have the text ready to be encoded let's create a qrcode from the text:

encoded_text = qrcode.make(text)
# You can name your file to anything you like here in the save method.
encoded_text.save('./qrcode.png')

And there you go you have a your own qrcode ready in just under 10 line of python code.

Now, Let's decode a qrcode in python.
Install the required modules:

pip install pyzbar

Import all the required modules:

from pyzbar.pyzbar import decode
from PIL import Image

Now let's write the remaining code:

#Open your Image in Python using Pillow's Image.open() method.
img = Image.open('./qrcode.png') 
decoded_img = decode(img)

print(decoded_img[0][0].decode())

That's it Now you can create your own qrcodes as well as decode them in Python :)

Linux - New Beginnings.

Pratik Mishra — Fri, 16 Apr 2021 07:07:04 +0000

Let's learn Linux together. I would like to answer all of your questions regarding why to learn linux and all that stuff.

so, what are we waiting for let's begin.
Before beginning with anything I would just like to clearify that linux is not an operating system rather it is a Kernel.
The operating systems that are based on linux kernel are known as Linux based Operating systems. Just like we generalized "xerox" for photocopy in the same way "Linux" was generalised to be an Operating system due to its popularity but it's not an operating system it's a Kernel.

Why Linux ??
This is the most famous question asked by everyone like why do we need to learn linux if we have windows in the first place. There are a lot of reasons why linux is far better than windows and we will cover each one of them today.

First and the most important one, Linux is open source and it's code is freely available for everyone to go through and change it according to their preferences and infact you can build your own Operating system based on Linux Kernel. Being Open source you can just simply change things which you don't like in it and tweak it according to your needs and requirements like we have kali linux which is the best os for hacking as it packs in all the necessary and required stuff for hacking all in one place and pre configured for you to just use them out of the box. But what is all this a beginner would'nt do all of these stuff like what am I even talking about I cannot expect a beginner to build an Operating system and I am not expecting you to do so I am just mentioning how good linux is and who knows in the future after learning and getting to know about it you might end up creating one.

Okay, so let's begin,

Linux is one of the most secure Operating systems out there far better than windows. I agree in the earlier versions there were kernel vulnerabilities but all of those are now fixed. I mean you can look at it's source code if you would like to and check it for yourself what data is it collecting from you or what data is it accessing on your machines unlike windows or other os which are not open sourced we don't even know what data they are actually collecting from us. Now, for many of you that may not be a big deal as not everyone has sensitive data on their machines afterall but don't worry I have other reasons too.

Linux is less vulnerable to malwares as compared to other operating systems. Most of the Programs/Applications that we use are First built for Linux and then ported to other Operating systems.

Linux is way powerfull as compared to the rest of them and you can do a lot of stuff on linux freely which would be restricted or sometimes not even available on other operating systems.

It is most widely used Operating system on this planet. What, you don't believe me, feel free to consult your friend Google and have a look and why is it so ? Most of the servers we use are Linux Based Servers, IOT devices use Linux, the most famous android operating system is built on top of Linux Kernel which makes it the most installed Operating system worldwide.

You have much more control over Linux and all the stuff that we do can done from a terminal. Yeah I know using a terminal may not be easy for users swithing from windows but once you are comfortable with it it's game over. You can literally do anything from a single terminal from openeing your files, installing/uninstalling Programs, accessing remote computers I mean everything. Also the benefits of using a terminal include it is way faster than your normal GUI and much quicker and also you can perform certain tasks which not possible in a GUI application.

Linux is the standard Operating systems that most of the companies use nowadays because of it's rich features, security, Open Source.......

So, what are you even waiting for start using Linux you'll love it !!

Docker Engine - Deep Dive into Docker.

Pratik Mishra — Thu, 15 Apr 2021 09:40:22 +0000

In my previous post I gave an Overview about Docker if you haven't read that then stop whatever you are doing right now and go have a look at the previous post I guarantee you won't regret it.
Here is a link to my previous post:
Docker - Basic Introduction

Now, let's Move on with our topic but wait before going to the engine itself I would like to clear some of the terminologies first that are used in Docker Engine.

Linux Namespaces: This is nothing new and has been in Linux for years now. Then, what is this namespace and how it is used in Docker??
Namespaces are basically used to provide isolation to our containers. It limits the access to resouces for our container. Like a single Docker Engine can have multiple Docker Containers running on it and all of these containers are completely isolated from one another. Each Container thinks that it is the only container running on the host. If you ask a container about the other containers it will be confused as it thinks it is the only container running on this host and doesn't know anything about the other containers because containers are completely isolated.
Even now if you didn't get it then think of it in this way namespaces basically restrict your permissions like it restricts how much amount of data you can view/modify/edit or delete. Also the processes running within a container are completely isolated from those services running on the host machine.
Control Groups : As from the name itself you can guess that this is something used to control stuff and your guess is right. Control Groups are basically used to limit the amount of resouces( CPU,Memeory, Networking.....) that a container can use like we don't want a single container taking up all of the underlying OS resources and leaving none for the other containers or processes of the Host machine.
Daemons: ooh they sound like evil monsters don't worry they are not something that your are thinking of. Daemons in computers are basically software/processes that run in background without intervening the user and performing certain tasks periodiaclly or in response to certain commands. They are basically processes that run in background and perform tasks for us.
Shim : Shims are nothing but programs that let newer API's to work on older hardware and older API's to work on newer hardware. It basically intercepts API calls and makes them compatible to use.
OCI : Open Conatiner Initiative started by GNU which gives an industry standards specifications for creating and running containers.

So in short Namespace are used for isolating and control groups are used to control the resouces being allocated to a container.

Now these things getting out of our way let's move further with the Docker Engine. But before we do that I just want to bring an important point to your notice which I missed Earlier, A Docker engine set up on a particular OS can run only those types of containers. Now what do I mean by that, it basically means that if I am running docker on top of Linux I will only be able run Linux Based Containers and not windows or Mac Based Containers but things are a little bit different on Windows since we got virtualisation support in windows 10 and with the use of wsl (windows subsystem for Linux) we can easily run linux on top of our native windows (if you want to know more about wsl or how did they achieved it then feel free to google about it.) So in windows you can literally run windows as well as linux based containers.

ooh that was a lot to digest but just bare with me all this will help you in understanding the core of Docker.

Docker Engine :

So now let's see how docker works under the hood.
First we have client that is us the end users whenever we type in commands in the CLI for docker, docker daemon get's activated remember what I said about daemons they run in background and responsd to certain commands or execute commands periodically. Now docker uses REST API to send commands to the docker daemon and in turn docker daeomon asks containerd. Now what is containerd - It is an industry standards runtime for containers. It's main responsibility is to maintain the container's lifecycle. (create/update/stop/restart or delete) Now how does containerd start a container it asks runc to do it. Now what is runc - It is nothing but runtime specification given by OCI (remembers OCI) for running containers.

Containerd basically communicates with the underlying kernel inorder to create containers using Liunx Namespaces and Control Groups as discussed earlier.
Just a point to be noted Runc is initialised when we need to create a container and after the creation of that container runc exits and only shim remains throughout the lifecycle of the container.

Think of it in this way, we send commands to docker daemon through the CLI(REST API) then the daemon asks containerd and if something needs to be created or updated it asks runc to co-ordinate with the kernel and complete the tasks assigned like creating a container.

Also, somethings are different in case of windows docker engine, in windows we don't have containerd or runc instead we have compute services which is microsoft's equivalence to containerd and does the same job as that of containerd. Also windows provides additional isolation methods as compared to linux known as hyperv isolation as I explained earlier we now have wsl in windows that means whenever we need to run linux containers on windows it fires up a lightweight vm in the background on top of which we run our docker engine and are able to run linux based containers on windows.
Also if you are wondering why we have different engines for each Operating Systems you see docker is unlike a Virtual machine it uses the hosts kernel and a windows Kernel is completely different than that of Linux Or Mac's Kernel.

So that was it for Docker Engine, I hope by now you are familiar with the docker engine and are aware of how docker works under the hood.

The next blogs will be on Containers, Images and Docker Hub and then we'll apply all of these concepts to make our first docker image and start a container from it so stay tuned for that :)

Docker - Basic Introduction.

Pratik Mishra — Thu, 15 Apr 2021 05:35:39 +0000

Docker we have been hearing this buzzword for quiet a while now. Everyone is talking about docker so today let's unfold what docker is and get familiar with the basics of docker and I can guarantee that after getting to know about docker you'll never look behind.

So, What is Docker ??
The answer is pretty simple docker is a containerization service that helps you build, pack and ship your applications in a Container.

Containers ?? what is this, are we shipping containers in computers ??
As we know when we develop applicatons this application has certain dependencies inorder to function. Now when we send this application to our co-worker or friend who is working on the same project too, chances are that when your friend or co-worker runs this software it might not run and give some random errors or maybe they'll need to download and setup all of the dependencies before running the application. Now, why does this happen ?? maybe the version that you used to develop the application will not match on your friend's machine or he/she may not have all the dependencies installed in their machine for running your program or maybe the versions don't match, there can be a number of reasons why our program may not run on their machine and they'll need to spend hours to solve all the problems or to setup the development environment. This is where docker containers come into picture you can think of containers as a complete package for your application which bundles all of the dependencies/requirements into a single box known as a container. If that container runs on your machine it will definately run on every machine that has docker in it and your problem of "It runs on my machine" is solved permanently.

Now, let's look at the Docker Architecture and also let's differentiate docker from virtual machines as both go hand in hand and many people cannot differentiate both of them.

So, as we can see from the above figure docker engine sits on the host operating system and docker containers are deployed on top of the engine. This implies that docker uses the underlying host's Kernel ( using Namespaces and Control Groups - These are advanced topics and I don't want you'll to get overwhelmed with all these topics all at once I will make a seperate blog for these topics) to maintain the containers lifecycle and this is the reason why docker containers load up much quicker as compared to a VM.
In case of a VM we have something known as a Hypervisor which virtualises hardware resources for each virtual machine. Each Machine has it's own full fledged Operating System and their own Kernel. When you boot up a Virtual Machine it's boots up a heavy OS all from scratch and that is the reason it takes time inorder to boot.
In case of Docker if you see it uses the hosts kernel so when you spin up a container it doesn't needs to boot an entire os from scratch as it uses the hosts Operating Systems Resources. You can think of it in this way Instead of Virtualising Hardware Resources Docker Virtualises Hosts Operating System's Resources.

Using Docker You can literally start a Container within seconds. Also these Containers are basically a running instance of a Docker Image.

Now, What is this Docker Image ??
Images are basically a prototype for our containers you can think of images as a class and containers as object of that class. So in short Containers are an instance of an image. We first create a docker image from a Dockerfile ( Dockerfile is nothing but instructions to compile a docker image ) and if that build is successful we can spin up n number of containers from that image.

As you can see we first make a Dockerfile( instructions ) then build an image from that Dockerfile and finally start containers from that Docker Image.

Till now we saw that what is docker, containers, Dockerfile and Docker Images and basically how is Docker Different from a Virtual Machine.
This was just a Basic Overview of all the stuff in the upcoming blogs we'll deep dive into each of these components and have a look into the docker Engine like how everything is Being done under the hood and get a firm grip on docker so stay tuned for that.

I hope you got an overview of Docker and ready to dive in deep into Docker :)

Next Step,
Docker Engine - Deep Dive into Docker

Notepad Clone in Python.

Pratik Mishra — Wed, 24 Mar 2021 10:46:19 +0000

Today Let's see how you can build your own notepad in Python using the Tkinter Module and later we'll even convert this program into a .exe executable so that we run it as an application and do not need to run it again and again from the terminal or an ide.

Let's begin, First import all the necessary modules as follows:

from tkinter import *
from tkinter.filedialog import asksaveasfilename, askopenfilename
from tkinter.messagebox import *
import os

For now import all these modules as we'll be needing them later in this article.
The tkinter module has all the necessary modules and methods required pre made and ready to use. This is something I like about coding in Python you have a library for each and everything which speeds up the development a lot.

Let's first see how to make a simple window in Tkinter:

# Creating a window for our application.
window = Tk()

window.mainloop()

Just run this code You'll get something like this:

This is a simple window in tkinter you can play around it and if you are new to tkinter you can change somethings try running the code without the mainloop() and see what happens.

Did nothing appear on your screen ? This is because when we are running a gui we want our application to run infinitely and perform certain tasks until the window is manually closed or exited.

Now this is simple plain window let's start tweaking it a bit according to our preferances.
You can change the title of you window easily by using window.title() as follows:

# Defining the title of our Window.
window.title('Notepad')

Now the next thing that we need is a Text Box in which we can type something otherwise what's the use of our text editor !!

You can simply create a Text as follows:

# Creating a variable for the text inputs so that later on we can retrieve the data from it.
editor = Text()
# Now You need to place this input Text box on your window.
editor.pack(expand= True, fill= 'both')

The expand argument is set to True and we are filling the text box widget in both the directions i.e horizontally as well as vertically. This is done because We want our text input widget to span the entire window so when we minize or maximize or resize our window it scales accordingly.
You can first try by just doing editor.pack() and then try to resize your window and see the changes in this way you'll learn what is going on and why we are doing such things.

Now, we have a simple window with out title and in this window we can type anything anywhere within the window.

Now, Let's create a menubar as a typical notepad has one:

# Defining a MenuBar. In Menu pass in the name of your window mine happens to be window (Which we declared earlier window = Tk() ).
menu_bar = Menu(window)

# Creating a File Menu for our menubar.
# For the first time just run this code without the tearoff= False and observe what you get.
file_menu = Menu(menu_bar, tearoff= False)

# Adding commands to our file_menu.
# Note: the open file is a function just pass the function without the parenethesis so whenever you choose that option from the file menu that action will be performed.
file_menu.add_command(label= 'open', command= open_file)

# Now, Let's add a cascade to our menubar.
menu_bar.add_cascade(label= 'File', menu= file_menu)

# Now our menubar is ready but wait we didn't tell the window that hey we have a menubar. So let's do that.
window.config(menu = menu_bar)

Before running this code please make sure to define a function named open_file() and write pass into it as for now we don't need it to do anything.
Run this code you'll get something like this:

Now, as we are done with that let's add some commands for our open option.
To open a File dialog box as we have in our native windows notepad app we are using tkinter.filedialog as follows:

def open_file():
    path = askopenfilename()

# Now since we have the path of the file that we want to open let's import it's contents in our Notepad app.

    with open(path, 'r') as file:
        text = file.read()

# We have the contents of that file let's displat it on our window.
# First delete all the existing contents from your window so that we can load the stuff fresh

    editor.delete('1.0', END)
    editor.insert('1.0', text)

Run this and check whether it works or not.

Here, we go it successfully opened a file Dialog and opened that file for us into our text editor !!

Also, Yoy may have noticed that a traditional Notepad has keybindings for tasks such as 'Ctrl + s' to save the work and so on so let's add that functionality to our App.

# Applying keybindings to our app.
# Also note that if you want to apply keybindings to a function you need to pass an argument named event to that functions as follows:

def open_file(event):
    path = askopenfilename()

# Now since we have the path of the file that we want to open let's import it's contents in our Notepad app.

    with open(path, 'r') as file:
        text = file.read()

# We have the contents of that file let's displat it on our window.
# First delete all the existing contents from your window so that we can load the stuff fresh

    editor.delete('1.0', END)
    editor.insert('1.0', text)

window.bind('<Control-o>', open_file)

# This will bind the keys 'ctrl + o' to our open file function.

This was Basic Overview of the things which I tried to explain in Depth so that the rest of the parts can be easily understood.
Also, the best way to build something is to make mistakes but learn from them and grow.
I can explain each and every function here but that will be way too lengthy and time consuming also if I do so you'll know only limited stuff about the topics which I cover. Instead, I'll leave my code below for you'll to go through and then you'll can implement those features in your application also you can even add more and better features than me if you opt to do it that way and the amount of things that you,ll learn will be much higher.

You can check out the entire code in my Github account I have implemented a lot of functionalities trying it to keep it as identical as we have in our native windows.
Also below that I have attached a replit Notebook where you can run my code and the output here it self.

Here our some ScreenShots from my Application to get you motivated:

Github:

pratik6217 / Notepad

Replit Playground:

Thankyou for reading my post Hope You liked it :)

Python to .exe Executable.

Pratik Mishra — Sun, 21 Mar 2021 10:57:35 +0000

As we all know at some point in our coding journey we always wanted to compile our pyhton code into an executable file so that we can simply run it by just double clicking it !!
I mean who doesn't wants to have an executable file of their code and boast about it in front of our friends( just joking )

So, Let's begin with it
First of all you'll need two things One is pyinstaller which you can easily install by typing in:

pip install pyinstaller

and the second thing is NSIS which you can download it from their official website.
Just Download them and keep it ready and don't worry I'll walk you through each and every step one by one.
Here is the link for the NSIS Download Page:
NSIS

Once everything is installed and ready to go we can move forward.
Navigate on to your folder where the python file is.
For E.g:

Here is a simple guess the number game which I made in Python.
If you want to see the code for the same you can checkout here:
Guess The Number

Now open a terminal in the current directory by pressing Shift + Right mouse Button and selecting open a command window here.

or you can simply type cmd in the file explorer section.

Now once a terminal is open in the current dirctory go ahead and type this:

# Type the name of the file without the quotes.
pyinstaller --onefile "Name of your python file.py"

The --onefile flag compiles all the files into a single executable.
Like if you have various dependancies and other files which is required for your program then it will all be compiled into a single file.
Also there is another flag known as -w use this flag if you don't need a terminal in your program say if you have GUI then you can use this flag. Since mine is a simple command line program I didn't use it.

It will take some time to compile your code depending upon the size and the dependencies once it has completed you will have multiple folders created just like this:

Now go to the dist folder you'll have your executable file there just move that file to the main folder where you have all your code and dependencies and that's it you can just double click it and run your code as an executable just like an application.

Now, moving further you can even compile all this into an installer by using NSIS as follows:
first make a zip of the folder where you have all the files and the exectable file which you just made just like this:

Now, go ahead and open The NSIS Software. It will look somewhat like this:

Select the Installer based on .zip file and the select the zip file which you made just now and then click on generate in the bottom right corner:

This will create an installer which you can easliy share with your friends who can just download it run it and boom they have all the file pre compiled and ready to go !!

This pretty much makes your task easier to share your programs and folders to anyone also it makes it beginner friendly for those who are new to programming.

Socket Programming in Python.

Pratik Mishra — Sun, 21 Mar 2021 10:09:32 +0000

Today, let's see how sockets work in Python.
First of all this tutorial will only work with sockets in your Local Area Network as it will use your Internal Ip Address within your network. If you want to build sockets worldwide for like everyone you can update the Ip Adress to your global Ip but to do so there is lot of things to keep into considerations like make sure your Firewall allows the connections and so on which is beyond the scope of this tutorial.

Now that's getting out of the way let's continue,
Let's first start with the server,
First let's import all the modules:

import socket
import threading

As you can see we'll be using the socket and the threading module.
Now, you might be wondering what is threading, threading is nothing but it let's you run code parallely to each other.
what do I mean by that, like consider you have a server and there are multiple clients on your server now if a client is executing some commands we don't want our other clients to keep waiting untill the first one is done executing we want all of them to access our server at the same time. So by using the concept of threading you can run multiple programs simultaneously i.e concurrently without them interfering with each other.

Let's define all the constants that we are going to use:

# Defining the size of the Header.
HEADER = 64

# The Port you want to use for your server.
PORT = 5050

# The IP address of your machine or the machine on which you want to host your server with the help of python as shown below.
# You can either hard code your Ip address but when you change your machine you'll have to do it again manually.
# Instead I have used a code to get the Ip address of the host machine.
SERVER = socket.gethostbyname(socket.gethostname())

# Tuple of Ip adress and Port number to be used for the socket
ADDR = (SERVER, PORT)

# Defining the encoding Format
FORMAT = 'utf-8'

# Defining the Disconect Message for our protocol to end the connection.
DISCONNECT_MESSAGE = '!DISCONNECT'

Here, The port is the Port number which you want to use for your server.
I generally use 5050 but you can use any other "free" port on your machine. Also, notice I have used Capitals for the variables as this is the industry standards for defining constant variables.

Now, let's configure our server,

# AF_INET -> Category or family of connections such as IPV4 Adresses.
# SOCK_STREAM -> Streaming data through the socket.
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.bind(ADDR) # Here addr is a tuple consisting of Ip Adress and the Port of your Server.

The bind() method binds your server with the mentioned Ip Address and the Port Number.

Now the main fun part begins:
I have used functions for writing every part of the program to keep the code cleaner.
Let's start with the start Function:

def start():
    server.listen()
    while True:
        # Get the socket connect object and Ip address of the client.
        # server.accept() is a block code that means it will wait until a client connects to it.
        conn, addr = server.accept()
        thread = threading.Thread(target= handle_clients, args= (conn, addr))
        thread.start()
        # There is one thread always running that is the start() [function] thread.
        # Hence, substracting one to get the active clients apart from start thread.
        print(f'[ACTIVE CONNECTIONS] : {threading.activeCount() - 1}')

Let's break down what's going on here,
First we want our server to listen for new connections for that we use the listen() method.

Next I have used a While loop to run the loop infinitely to keep on accepting the clients.

The accept() methods accepts the clients who want to connect to our server and stores the socket object and the client address in the conn and addr variables.

Now the concept of threading comes into play,
You see for every client we are starting a new thread so that all of them can run concurrently. In Thread declaration you just provide the name of the functions without the Parenthesis and in the args we provide all the parameters or the arguments of the function as shown above.

The last line of code I have used to print all the active connections to our server just to keep a track of the number.
Notice that I have substracted 1 from the activeCount that is because start() function is also a thread which is infinitely running so we don't want to include that in the number of clients.

Now, Let's write another function to handle all the connected clients on our server as follows:

def handle_clients(conn, addr):
    print(f'[New Connection] : {addr} connected.')

    connected = True
    while connected:
        # Blocking line of code.
        # This will not pass this line of code until it gets a message from the client.
        # RECV takes the size of the message to recieve.
        msg_length = conn.recv(HEADER).decode(FORMAT)
        if msg_length:
            msg_length = int(msg_length)
            msg = conn.recv(msg_length).decode(FORMAT)
            print(f'[{addr}] : {msg}')
            if msg == DISCONNECT_MESSAGE:
                connected = False
                print(f'[{addr}] : Disconnected.')

    # Closing the Connection.
    conn.close()

Now, again let's break the function line by line,
we want the loop to run continuously till a client is connected on to our server for that I have used a variable connected.

Now, Let's talk about the protocal that we'll be using, the protocol goes somewhat like this(Client Side):

Send the length of the message that you'll be sending onto the server.
Then send that many bytes of message to the server.
IF Disconnect message is sent then close the connection and exit.

The recv() method recieves the bytes from the client, all of this will be much more clearer once we start with the client side program.

Now let's run our server and see if everything is working fine:

print(f'[Starting] Server starting on {SERVER}.....')
start()

The entire server code is:

import socket
import threading

# Defining the size of the Header.
HEADER = 64

# The Port you want to use for your server.
PORT = 5050
# The IP address of your machine or the machine on which you want to host your server.
SERVER = socket.gethostbyname(socket.gethostname())
# Tuple of Ip adress and Port number to be used for the socket
ADDR = (SERVER, PORT)
# DEfining the Disconect Message for our protocol to end the connection.
DISCONNECT_MESSAGE = '!DISCONNECT'

# AF_INET -> Category or family of connections such as IPV4 Adresses.
# SOCK_STREAM -> Streaming data through the socket.
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(ADDR)

FORMAT = 'utf-8'

def handle_clients(conn, addr):
    print(f'[New Connection] : {addr} connected.')

    connected = True
    while connected:
        # Blocking line of code.
        # This will not pass this line of code until it gets a message from the client.
        # RECV takes the size of the message to recieve.
        msg_length = conn.recv(HEADER).decode(FORMAT)
        if msg_length:
            msg_length = int(msg_length)
            msg = conn.recv(msg_length).decode(FORMAT)
            print(f'[{addr}] : {msg}')
            if msg == DISCONNECT_MESSAGE:
                connected = False
                print(f'[{addr}] : Disconnected.')

    # Closing the Connection.
    conn.close()


def start():
    server.listen()
    while True:
        # Get the socket connect object and Ip address of the client.
        # server.accept() is a block code that means it will wait until a client connects to it.
        conn, addr = server.accept()
        thread = threading.Thread(target= handle_clients, args= (conn, addr))
        thread.start()
        # There is one thread always running that is the start() [function] thread.
        # Hence, substracting one to get the active clients apart from start thread.
        print(f'[ACTIVE CONNECTIONS] : {threading.activeCount() - 1}')



print(f'[Starting] Server starting on {SERVER}.....')
start()

If Everything went well you'll see something like this:

Now, Let's move on to our client side code:

import socket

HEADER = 64

# Port of the server to connect to..
PORT = 5050
# Ip Adrress of the Server..
SERVER = '192.168.56.1'

FORMAT = 'utf-8'

ADDR = (SERVER, PORT)
DISCONNECT_MESSAGE = '!DISCONNECT'

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(ADDR)


def send(msg):
    message = msg.encode(FORMAT)
    msg_length = len(message)
    send_length = str(msg_length).encode(FORMAT)
    send_length += b' ' * (HEADER - len(send_length))
    client.send(send_length)
    client.send(message)


# m = input("Enter your message:\n")
send('Hi')
send(DISCONNECT_MESSAGE)

Again let's understand it line by line,
First we import all the necessary modules,
Then define all the constants and then setup the client socket.

Note: The Server and port in the client will be the server's IP Address and the port on which the server is listening on to.

Next, the connect() method is used to connect a client on the server. Once the client get's connected it's Ip Adress and the Port number is given to the server through the accept() method on our server side code and a new thread is started for this client.
Now as we have defined our protocol to first send the length of the message and then the actual message, we follow the same protocol to do so.

As you can see First we calculate the length of the message and then pad the length with white spaces to fill the remaining bytes as we have declared the size of the header. Now why are we padding the message that is because in our server we have passed the size of the receiving message as Header now the recv() method will wait until it has received that many bytes so we have to pass the exact same length message.

And the final one is the send() method which as the name suggests is used to send the data.

For those who are Wondering what is this encode and decode mentioned everywhere in the code. As we know python works in Unicode whereas the web and most of the places work in utf-8 encodings. Now when we need to transfer data over the web it should be in proper encodings that is why we encode it in utf-8 encoding standards using the encode method and when we receive the data it's in utf-8 encoding but python unbderstands Unicode so we decode it back to Normal.

Here is a screenshot of the clients connected on to our server:

Hope you liked it !! This was just a High Level overview just to get started with socket programming in Python.

Python Youtube Downloader.

Pratik Mishra — Sat, 20 Mar 2021 19:32:14 +0000

So, today let's write a Python Script to download videos from our favourite video streaming platform: Youtube.
NOTE: Please note that only the videos which are available for download only those can be downloaded.

Let's Begin:
First Let's Import all the required Modules:

pip install youtube_dl

Importing the installed Module in Python:

import youtube_dl

Now, let's make a list of all the youtube videos i.e their url's to download the videos also let's make a dictionary to specify all the options that we need for our video download as follows:

links = ['Link of your Video', 'Link of another video....',]
options = {

  "format" : "bestvideo+bestaudio"

}

Here, in the options you can apply more filter's but I like to keep it simple by just specifying the format of the video.
The ' bestaudio+bestvideo' will download the best available format of that video file.

The next part is the main one:

with youtube_dl.YoutubeDL(options) as ydl:
    ydl.download(links)

The youtube_dl.YoutubeDL.download() method will download all the videos from the links that you will provide to it with you desired options as declared earlier.
The Entire code is even less than 10 lines but using it you can easliy automate your task in Python.
Here is the entire code:

import youtube_dl 
links = ['https://www.youtube.com/watch?v=v4dROX2lRMw']
options = {

  "format" : "bestvideo+bestaudio"

}

with youtube_dl.YoutubeDL(options) as ydl:
    ydl.download(links)

Hope this was useful :)

Learn Python in 2021

Pratik Mishra — Sat, 20 Mar 2021 18:52:27 +0000

So, first let's get it clear that why you should consider learning python in 2021. Here are some of the points which I think will help you consider learning python:

Python is Open Source making it free to use
Python is the programming language that is growing the fastest.
Easy to Learn all thanks to it's simple syntax and english like commands.
Large User base and Large amount of available modules.
Python has wide range of applications such as:
1. Machine Learning.
2. Data Science.
3. Game Development.
4. Web Development.
5. Aritificial Intelligence.
6. Big Data.
Everyone's using it and it's in demand.

Here is a list of companies that use python:

Google
Facebook
Instagram
Spotify
Quora
Netflix
Dropbox
Reddit

Now this getting out of the way, Let's checkout some of the websites and courses that you can use to learn python.

FreeCodeCamp:

One of the best website to learn to code.
freeCodeCamp
1. Python for Everybody
Python for everybody is a free video course series that teaches the basics of using Python 3.
The courses were created by Dr. Charles Severance (also known as Dr. Chuck). He is a Clinical Professor at the University of Michigan School of Information, where he teaches various technology-oriented courses including programming, database,design, and web development.
Link for this course

2. Learn to Program by Building Projects:
Coding a project is a great way to improve your Python skills.
But why stop at one project? Why not go for an even dozen?

Link for the Post

Apart from these there are a ton of courses and posts which you can refer at freecodecamp.

Coursera:

I know Coursera is a paid platform but you do get some of the courses for free and apart from this you can always audit the courses to learn from them for free.
Now what do I mean bu auditing the course it simply means that you can access the video lectures and stuff but you'll not be getting the course completion certificate.

1. Crash Course on Python By Google
This is one of the best and well structured course for absolute beginner's in python. The Instructors are very good I mean you can learn from people who work at Google.
Also the final milestone project is very fun to do.
Google Python Crash Course

2. Python 3 Programming:
A. Python Basics:
This is a begginer friendly course for everyone and is part of
the python 3 programming specialisation.
This course introduces the basics of Python 3, including conditional execution and iteration as control structures, and strings and lists as data structures. You'll program an on-screen Turtle to draw pretty pictures. You'll also learn to draw reference diagrams as a way to reason about program executions, which will help to build up your debugging skills. The course has no prerequisites. It will cover Chapters 1-9 of the textbook "Fundamentals of Python Programming," which is the accompanying text (optional and free) for this course.
link for the course

B. Python Functions, Files and Dictionaries:
This is the second course of the python 3 programming specialisation.
This course introduces the dictionary data structure and user-defined functions. You’ll learn about local and global variables, optional and keyword parameter-passing, named functions and lambda expressions. You’ll also learn about Python’s sorted function and how to control the order in which it sorts by passing in another function as an input. For your final project, you’ll read in simulated social media data from a file, compute sentiment scores, and write out .csv files. It covers chapters 10-16 of the textbook “Fundamentals of Python Programming,” which is the accompanying text (optional and free) for this course.
Link

C. Data Processing in Python:
This course teaches you to fetch and process data from services on the Internet. It covers Python list comprehensions and provides opportunities to practice extracting from and processing deeply nested data. You'll also learn how to use the Python requests module to interact with REST APIs and what to look for in documentation of those APIs. For the final project, you will construct a “tag recommender” for the flickr photo sharing site.
Link

D. Python Classes and Inheritence:
This course introduces classes, instances, and inheritance. You will learn how to use classes to represent data in concise and natural ways. You'll also learn how to override built-in methods and how to create "inherited" classes that reuse functionality. You'll also learn about how to design classes. Finally, you will be introduced to the good programming habit of writing automated tests for their own code.
Link

E. Python Project: pillow, tesseract, and opencv:
This is the final project of the Python3 Programming Specialisation.
This course will walk you through a hands-on project suitable for a portfolio. You will be introduced to third-party APIs and will be shown how to manipulate images using the Python imaging library (pillow), how to apply optical character recognition to images to recognize text (tesseract and py-tesseract), and how to identify faces in images using the popular opencv library. By the end of the course you will have worked with three different libraries available for Python 3 to create a real-world data-analysis project.
Link

3. Edx:

Similar to Cousera you can learn for free by auditing these courses. These Cousrses are taught by Hravard and MIT and many more leading Universities.
Take real college Python programming courses from Harvard, MIT, and more of the world's leading universities. Become familiar with the basics of python including python syntax, conditionals, and much more. Learn python from the fundamentals to advanced subjects and topics now!
Link

4. RealPython:

If you want to learn some crazy tricks and make Real World applications in Python then look now where else, This website will surely help you with that.
From Discord Bots to Machine Learning, Deep Learning you can easily find here.
Link

5. Python Web Scrapping:

Python is a beautiful language to code in. This is because it has got a great package ecosystem, much less noise (characters) than a typical program in a different language, and is super easy to use.

Python is used for a number of things - from data analysis to server programming. However, there's another interesting use-case of Python - Web Scraping. In this classroom, we will cover how to use Python for web scraping with a complete hands-on classroom guide as we proceed.

*We will cover performing requests with requests package.
*We will install and configure BeautifulSoup package.
*We will extract data from a test site using bs4.
*We will also create a CSV in the last lab of extracted data.
Link

Apart from these there are ample of free resources such as booksn hands on labs, and many more available to learn python for free.
I hope this will help those who want to learn but don't know where !!