DEV Community: Akash R Chandran

How to create REST API using Django REST framework

Akash R Chandran — Mon, 29 May 2023 11:55:47 +0000

Let me introduce you to Steve, a banana farmer who cultivates a diverse range of bananas, from Apple bananas to Lady Fingers bananas. And steve love's his bananas and wants to sell them to the online market. Let's say he already has a website to list your bananas on. As of now static you have stock available hardcore written to HTML file. Every time he wants to update you have to edit the HTML file which is sad🤕. He finally decide to make the website dynamic by creating an API to get stock information from the database.

He takes his Banana Book laptop and starts coding. He chooses Django paired with the Django REST framework as we want to make the banana website robust. But he gets get stuck and couldn't figure out what to do next. He reaches burnout and feels like he cannot do it. Then he remembers his bananas and his love for bananas gave him more determination. He remembers an old friend Akash😎, who can help him to complete this task. So he asks the guy and that guy writes a tutorial for him.

Let's help Steve to make a REST API using the Django REST framework.

Let's help Steve

Steve is a great guy and his love for bananas is immeasurable, so let's help Steve by building him a REST API using the Django REST framework. Firstly we require a laptop that has Python3 installed on it. You can download it from Python.org. Different versions of Python are available but be careful and choose any version >= 3.8.

We will be building a Rest API to fetch banana stocks from the database. Let's not connect the database, it may get confusing to call it in one tutorial. Here instead we can use a JSON file which stores data and parse it to get the values of the stock. We are trying to learn how to use the Django rest framework and create a REST API using it. So we won't be learning much about database connection here.

Setting up Django

It's better to use a dedicated environment for each Django project. Even Django team suggests using a virtual environment. Python itself comes with venv for managing environments which we will use for this guide.

Setting up environment

You can give any name to the virtual environment, but here I am going with djangoproject.

Windows

Make sure you have installed Python before continuing to the next instructions.

Next, create a folder in your preferred directory and name it whatever you like I am going with Django REST API framework. Next to set up the virtual environment enter the command opening terminal or CMD.

py -3 -m venv djangoproject
.venv\scripts\activate

Linux or Mac OS

Most of the Linux Distributions come with python3 installed by default, just check if it exists by using the command.

python3 --version

For Mac users just head to python.org and download the .pkg file and start installing.

Next to setting up a virtual environment, on Linux sometimes we need to install the extra library. To do the same, just enter the command in your terminal.

sudo apt-get install python3-venv

Next, to initialize and activate a virtual environment on Mac and Linux, use the commands below.

python3 -m venv djangoproject
source .venv/bin/activate

Installing Django

Next, we need to install Django on our virtual environment. To do that we can simply use the command below. Make sure you have activated the virtual environment before executing this command.

pip install Django

After that, we have to start a project in our directory to get started. Django provides a template for the project and we can use that to create our app. To get the template in our current working directory you can use the command below.

django-admin startproject django_rest_trial .

django_rest_trial is the name of the project which I choose, but you're free to use whatever name you prefer. After running that some files and folders should appear on the file explorer.

Now we need to create an app inside our Django project. The apps are like parts of a website which manage a certain task. for example, we can have an app for handling payment on the website or we can have an app that verifies login and sign-up. This is one of the pros of using Django as different teams can manage different apps yet they can make them work together.

To create a Django app you can use the below command. Here rest_api is my app name as it manages the REST APIs on our website. Feel free to choose a different name if you want to.

py manage.py startapp rest_api #windows

python3 manage.py startapp rest_api # Linux and MAc

After executing this command a new folder should appear with the name of the app that was created using the above command.

Even though we don't require a database, Django sessions and other values like admin, users etc. need a database. By default, Django comes with SQLite, which is a great option as it doesn't need much of any configuration. Django needs to migrate the required tables and values to the database to do that we have to use the below command.

py manage.py migrate # Windows

python manage.py migrate # Linux

We have finished setting up our Django project, you can even try running it by just running the server using the runserver command. Go to http://127.0.0.1:8000/ and you should see the standard Django greeting page.

py manage.py runserver # Windows

python3 manage.py runserver # Linux

Setting up the Django REST framework

Next, we have to install the Django REST framework, to do the same we can use pip. To install it use the command below:

pip install djangorestframework

Then we need to edit the settings.py of our Django project and include rest_framework in our project. You can find the settings file inside the main project folder which is the django_rest_trial for me.

And that's it we have completed the setup of the Django REST framework. We also need to install whitenoise which helps in simplifying static file serving for Python web apps. You may think that we don't have any static files for our API, but Django has it for the admin panel, debug panel etc.

pip install whitenoise[brotli]

You have to set up whitenoise as well, to do that you have to add whitenoise to your middleware in the setting.py file.

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware', #Added
    'django.contrib.sessions.middleware.SessionMiddleware',
    ...
]

You need also setup static files root to that copy and paste the below line after STATIC_URL variable. And add the lines below

if not DEBUG:
    STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
    STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

Let's start coding

First of all, we need to get the JSON file on which we are going to store the data on. I will provide it below, just copy and paste it into a file named database.json and keep it the in the root folder with the manage.py file.

{
  "bananaTypes": ["Apple Banana", "Cavendish", "Lady Finger", "Red Dacca"],
  "availableStock": [100, 200, 300, 400]
}

Next, we need to configure routes or endpoints which our REST APIs will use. Let the rest_api app uses the route /rest/. That is over API endpoints will be starting with the rest keyword.

To configure this we need to create urls.py file in the rest_api app folder. Keeping it aside we will need it later, open the main project folder and open the urls.py file inside it and add the following element to the urlpatterns list. You may need to import the include function from the django.urls. Finally, the file would look like this,

from django.contrib import admin
from django.urls import include, path # include was also imported

urlpatterns = [
    path('admin/', admin.site.urls),
    path('rest/', include('rest_api.urls')), # added
]

Next, we will start coding the main part of the project. Open the views.py file in the app folder and continue the part.

Coding the main part

Let's start by creating a function that reads our database which is the database.json file. I need to parse JSON so we import json library also. And create a read_database() function. which somewhat looks like,

import json

def read_database():
    with open('database.json', 'r') as f:
        return json.load(f)

After that, we create a function which accepts both GET and POST request and respond with the available stock of each banana variety. To do that we need to import app_view and Response from Django REST framework.

The app_view is a decorator which is used to denote what type of requests it can accept in our case we accept both GET and POST requests. It almost acts the same way as the app.route in Flask, we mention methods in the same if you know.

The Response object allows you to easily serialize data into the appropriate format (such as JSON or XML) and set the appropriate HTTP status code for the response. It also provides several convenient methods for setting headers, cookies, and other response metadata.

The views.py file would be like after all changes,

import json

from rest_framework.decorators import api_view
from rest_framework.response import Response

def read_database():
    with open('daabase.json', 'r') as f:
        return json.load(f)

@api_view(['GET', 'POST'])
def get_stocks(request):
    try:
        database = read_database()
        banana_type = database['bananaTypes']
        avail_stock = database['availableStock']
        response = {}
        for banana,stock in zip(banana_type,avail_stock):
            response[banana] = stock
        return Response({'error':False, 'bananaStock': response}, status=200)
    except Exception as e:
        return Response({'error':True, 'message': str(e)}, status=500)

If you remember we have to still route the function get_stocks to one of the endpoints. To do that open the urls.py in the rest_api or app folder and paste the below code,

from django.urls import path
from . import views


urlpatterns = [
    path('get_stock/', views.get_stocks, name='available stocks'),
]

Now our Django REST API is successfully created. You can try running it on localhost by using the command python manage.py runserver and heading to http://127.0.0.1:8000/rest/get_stocks/ to see the API working in real-time.

You can even use Postman or Hoppscotch to test the API to check if it's working correctly.

Hosting API on render.com

You need an account on render.com. You can signup for one here. And connect your GitHub account to it. You can find all the instructions in detail on my old blog, I will link it below

Deploying FastAPI application to Render

Akash R Chandran ・ Nov 2 '22 ・ 5 min read

#python #beginners #programming #productivity

Creating Requirements.txt

Usually, I use external library pipreqs, but you can just simply type django, djangorestframework, gunicorn and whitenoise[brotli] in the requirements.txt file. When deploying, render will install the latest version of these modules.

Creating a .gitignore file

.gitignore file helps to avoid uploading unwanted or private files to the git clients such as GitHub or GitLab. When sharing your code with others, there are often files or parts of your project, you do not want to share. So these files or folders can be mentioned in the .gitignore file.

For this Django project, we don't want to upload djangoproject, __pycache__ and db.sqlite3to GitHub. So we mention them in the .gitignore file like this.

Upload to GitHub or GitLab

I am using GitHub here, but you can use GitLab as well. I have installed git, and I have connected it to my GitHub account. You'll find many articles on how to do it, just google it. If you're using Visual Studio then it has an built GitHub plugin which makes it way easier. I have successfully uploaded it to GitHub, you can find mine at

akashrchandran / Django-REST-API-framework

A example repository for my blog at https://blog.akashrchandran.in/how-to-create-rest-api-using-django-rest-framework.

Django-REST-API-framework

A example repository for my blog at https://blog.akashrchandran.in/how-to-create-rest-api-using-django-rest-framework.

View on GitHub

Make the app production ready

We will need to change some parts of the settings of Django to make it production ready.

Find the declaration of the SECRET_KEY setting by opening settings.py. We don't want to keep production secrets in source code, so we'll get them via an environment variable we'll set later:

# Add this to begining of the file
import os

Next change SECRET_KEY to be equal to the environmental variable we are going to provide later.

SECRET_KEY = os.environ.get('SECRET_KEY', default='thisisahugesecret')

Also, change DEBUG to dynamically change based on environment variables

DEBUG = 'RENDER' not in os.environ

We need to change allowed hosts also, as we are hosting. Rather than directly giving the host id after deployment we can also make it dynamic

# https://docs.djangoproject.com/en/3.0/ref/settings/#allowed-hosts
ALLOWED_HOSTS = []

RENDER_EXTERNAL_HOSTNAME = os.environ.get('RENDER_EXTERNAL_HOSTNAME') 
if RENDER_EXTERNAL_HOSTNAME:
    ALLOWED_HOSTS.append(RENDER_EXTERNAL_HOSTNAME)

And we are done our project is now production ready. Now let's push changes to GitHub and continue.

Create a Build Script

We need to run a series of commands to build our app. We can accomplish this with a build script. Create a script called build.sh at the root of your repository:

#!/usr/bin/env bash
# exit on error
set -o errexit

pip install -r requirements.txt

python manage.py collectstatic --no-input
python manage.py migrate

Make sure the script is executable before checking it into Git:

chmod a+x build.sh

We completed the build script as well, and now push it to GitHub.

Deploying to Render.com

As we are not deploying a static site, we should choose the option Web Service.

If you have connected your GitHub account, then you can just search the repository name and find it there.

Give a name to your web service, then select the region which is nearest to you, for me in Singapore. Leave all other values default. For the Build command, copy and paste the below:

./build.sh

For the Start command, copy and paste the below:

gunicorn django_rest_trial.wsgi:application

where django_rest_trial is the name of the Django project. Do change this as per your project name.

Next, scroll down and click the Advance button and add the environment variables. Here we only require SECRET_KEY. You can also use the generate button which is provided by render. After adding click the Create Web Service button.

After clicking the button you should see a log with events happening, wait till it finishes deploying.

After the site is live visit the route /rest/get_stocks and you should see the API working.

And here we have done it and we have successfully deployed our REST API to render.com. Now sit back and relax by eating as many bananas as you can. The deployed version is available here.

Steve is partying

Thanks for helping Steve to complete his REST API, he is now partying🥳. You can get more information on how to use the Django REST framework to best way read the documentation. There are many alternatives to the Django REST framework, you can give them a try if you want,

They are good alternatives but some hardly maintained any more. Django REST framework is more powerful with authentication and stuff, you can learn about it in the docs.

That's all we have completed the tutorial. Looking forward to meet you in the next one. Meanwhile you can follow me on dev and other platforms,

Akash R ChandranFollow

A python developer who likes automation, creating bots and writing blogs. I also know other languages like JavaScript, Java, Dart etc.

Thanks for reading patiently.

Vercel Launches 3 New Storage Options for Your Next Project!

Akash R Chandran — Tue, 16 May 2023 13:44:21 +0000

If you have tried manually deploying apps to production, then you may know how nerve-wracking things can be. Even the slightest mistake could cause the production database to be deleted, leading the company to lose billions of dollars, making you freak out and flee the country before your boss finds out, and start living in the Himalayas as a goat farmer.

That's why most of the developers use Vercel, Netlify, Heroku, and Firebase as they handle deployment for you and prevent you from making any big mistakes. Anyways vercel just introduced 3 new databases or storage options. And let's see them in brief.

What is vercel?

Well, Vercel is a cloud platform which enables developers to host their websites and web apps that deploy and scale automatically. Vercel is the favourite choice for the deployment of Next.js apps as they have more efficient support for the framework. That's not that big as vercel also maintains the Next.js.

But the best part is that they support almost every language framework though they specialize in javascript frameworks. I have hosted many Python frameworks like Flask, FastAPI and even Django. They even support PHP, I have hosted my app there and haven't got any issues with speed or rendering.

They have a crazy awesome user interface and experience that makes it so user-friendly. It provides a free tier named Hobby for developers to experiment and try their platform. Its against Vercels TOS to run a commercial app on the free tier. Even though you technically could, they will shut down your site if caught in violation. So you'll have to go with a paid plan and it's a bit expensive when compared to other platforms.

Introduction

Vercel introduced 3 new additions to their storage solutions. They did it on 1st May and you can find the announcement on the website. The new additions are:

Vercel KV (Beta)
Vercel Postgres (Beta)
Vercel Blob (Private Beta)

We will be talking about them individually one by one below. This is a huge thing as they are trying to control users from using any other third-party database solution and managing it themselves. The database was the only thing missing on vercel but now it's kind of complete at least it is in beta for public use. They are not yet available for enterprise usage, mostly they will be available soon.

https://www.youtube.com/watch?v=gA8cHj3w5XI&ab_channel=Vercel

Vercel KV

It's key-value storage like Redis, in fact exactly like Redis as it is powered by Upstash. If you didn't know Upstash is a Serverless in-memory cloud database from Upstash Inc, a California-based company. It is a Serverless Redis Service. It can be used for caching layer or as a database. You can more details about it here.

For now, I am more interested in the speed at which it works, let's try to create a simple free tier vercel KV storage. The creation is pretty straightforward, they just ask you for the name and the region. I went with Singapore as my region, as it seems to be the nearest one.

They also provide CLI to set and get values directly from the database.

I copied the Template that they provide for the testing, you can get the template source on GitHub. I modified its page.tsx file just to set and get a value from the database.

import kv from "@vercel/kv"

export default async function Home() {
  console.time("res");
  await kv.set("message", "Hello World!");
  const msg = await kv.get("message");
  console.timeEnd("res");
  return <p>{msg}</p>;
}

When I first ran it took more than 200 ms to load, as it was the first request server took time to warm up and respond. Even 2nd and 3rd try still resulted in more than 100 ms, but after that, it came down under to 25 - 50 ms range.

Keep in mind that this was both reading and writing. But when I tested reading from the database alone it was a little above 15 ms.

The storage supports all the operations that can be done on Redis. There are limitations applied on creation, requests, record size etc you can find them here. The pricing seems to be a little above the expected but it may drop in the future.

Vercel Postgres

This was the part for which I was most excited. They introduced Postgres one of the most advanced general-purpose object-relational database management systems. I have been using it for my projects. It's powered by Neon a fully managed serverless PostgreSQL. Neon separates storage and computing to offer modern developer features such as serverless, branching, bottomless storage, and more.

Coincidentally I used Neon for a freelancing project and it was amazing as it provide a web interface to edit, give analytics and view tables which made the development of my Django app super easy. I will have to try it to be sure if it is as good as Neon. The creation of Postgres is simply the same as that of Vercel KV and only requires a name and region ( Singapore is available so I choose that ).

I copied the Template that they provide for the testing, you can get the template source at GitHub. I modified its page.tsx file just to create, insert and select a value from the database.

import { sql } from "@vercel/postgres";

export default async function Home() {
  console.time("create");
  await sql`CREATE TABLE IF NOT EXISTS PERSON (name varchar(255), age int)`;
  console.timeEnd("insert");
  console.time("create");
  await sql`INSERT INTO PERSON (name, age) VALUES ('Akash', 21)`;
  console.timeEnd("insert");
  console.time("select");
  const { rows } = await sql`SELECT * FROM PERSON`;
  console.timeEnd("select");
  return (
    <div>
      {rows.map((row) => (
        <div key={row.age}>
          {row.name} - {row.age}
        </div>
      ))}
    </div>
  );
}


create: 474.285ms
insert: 102.999ms
select: 103.254ms

I have tested it for like 10 times and I think the time averages out nearest to these values. It's pretty good and fast for me at least. Vercel also has a web interface to view tables and execute queries same as Neon.

The pricing is almost the same as that of Vercel KV. And also include the same limitations as of the same. You can view the pricing here.

Vercel Blob

This is something that can be very useful. Vercel Blob allows you to upload and serve files via a global network through unique and unguessable URLs. it's based on Cloudflare R2 which allows you to store large amounts of unstructured data like images and PDF files on the edge in other words it's a replacement for storage buckets like S3 and that could be a game changer if your app does file uploads. It is still in private beta but you can sign up for the waiting list to try it. To signup head to this link.

They say it is users can upload files of any size. But for the private beta phase, the upload size is limited to 4 MB, but soon they will release its full potential and will be available for public beta.

The SDK is pretty simple for developers to use same as the other storage. I don't have access to it so I can't test it for myself but I would say it would be good as the other two. As per the doc, the snippet given is

import { put } from '@vercel/blob';
import { NextResponse } from 'next/server';

export default async function upload(request) {
  const form = await request.formData();
  const file = form.get('file') as File;
  const blob = await put(file.name, file, { access: 'public' });

  return NextResponse.json(blob);
}

The pricing is available here. It will be good for companies looking for storage that has some simplicity yet advanced technologies and have loads of money to waste.

Is it worth it?

Without much of a surprise No, it's not worth it as they are priced insanely high. As it's vercel they have a bit high pricing as always but the products are also somehow astonishingly good and have a good user interface. To phrase it they are Apple of the web industry. But that doesn't justify the pricing,

Vercel KV is 1.5x the price of Upstash scaling without the way more generous free tier.
Vercel Postgres is 2x the price of Neon scaling without the way more generous free tier. The free tier of Neon has 3GB of storage compared to 256MB of Vercel, no limit of storage on its pro plans compared to 512MB of storage for Vercel, no limit on read and write data compared to Vercel, no limit on compute time compared to Vercel.
Vercel Blob is 2 times the price of Cloudflare R2 without the way more generous free tier.

The prices may change later. The VP of Developer Experience at Vercel commented on Reddit that the prices may change with the feedback of the beta users and the pricing of vercel blob isn't final yet.

This is still good for developers who don't want to use other applications just for the database instead they can find all the things in a single place which makes it easier to maintain and use.

Conclusion

Vercel is an amazing platform for hosting web applications without a doubt. And I am sure I am going to use Vercel Postgres for future projects for sure. You should try it for sure as all the storage options are available for the Hobby plan. Vercel is trying new Server Actions an alpha feature in Next.js, built on top of React Actions. They enable server-side data mutations, reduced client-side JavaScript, and progressively enhanced forms. This would be a great feature for web developers.

Lastly thank you for reading this patiently and please follow me on Linkedin, you can find the link at Akash R. Chandran | LinkedIn.

How to host FastAPI application on Deta Space

Akash R Chandran — Tue, 28 Mar 2023 02:30:39 +0000

Almost 2 years ago while browsing through the FastAPI docs, I came across their sponsors one of which was deta.sh and it is still there you can view it at FastAPI Docs. As a curious person, I opened the link and browsed through their website. At that time they had a minimalist design.

They didn't have a GUI to manage apps only CLI to deploy and manipulate apps, the only thing they provided was the register/login and docs if I remember correctly. I tried deploying some apps but failed for some I don't remember. So let the deta cloud and tried something else.

But yesterday I came across the same site and was amazed that they are shifting to a new better version called Deta Space. This is in still beta but it has everything a modern platform has like GUI to manage apps, view logs, better docs and even a page to find user-build apps that are deployed on Deta Space. So I decided to test it out by deploying a sample FastAPI application. We will use the same repository as I used in my old blog showing the deployment of the FastAPI application on Render.

https://blog.akashrchandran.in/deploying-fastapi-application-to-render

Creating Deta Space Account

As with any other site, you will need an account to host apps on Deta Space. They don't provide any third-party signup method so you will have to have to use a good old email password. You are required to choose a unique username, I think it's for subdomain assignment not sure yet though. You can sign up using this link.

After login, you should be redirected to the dashboard and you should look something like this

Setting Up CLI

Although the site has more GUI-rich features it still lacks a deployment option. So we have to set up our CLI tool if we want to continue. Setting up the CLI - Space Docs (deta.space) here you can find the instructions to do so. After installation login can be done by using the command

space login

If installed correctly it should show something like this. Next, we need is the authentication token from Deta space.

Getting token from Deta Space

After you log in you will be redirected to the dashboard, use the command palette. Just search for the settings and then click generate a new token.

After that copy the token and come back to the terminal page. And paste it onto the terminal

we have successfully set up CLI. Now let's move on to the next part which is pushing the code to Deta Space.

I am not going to show to how to code or install FastAPI for that you can read my old blog post.

https://blog.akashrchandran.in/deploying-fastapi-application-to-render#heading-lets-make-a-simple-api-using-fastapi

You can also view the code project at my GitHub repository at akashrchandran/simple-api (github.com ).

Creating .spaceignore file

To exclude certain files and directories from being uploaded during space push, use the .spaceignore file. It acts similarly to a .gitignore file, where each line in the file specifies a pattern. All files and directories matching the patterns will be excluded from the push.

For example, a .spaceignore file with the following content space push will ignore the test and docs paths.

test
docs

For our project, we will be ignoring the folders

venv
__pycache__

Deploying to Deta Space

After all the hard work we have done here is going to pay off, let's make the app accessible from anywhere on the planet. Open up the code in visual studio code or any other IDE or Notepad your wish. And open the terminal on the side or use the integrated terminal option in VS code.

Make sure you have the Space CLI installed & authenticated, then run the following command to create a new Space project in the current directory.

space new

Editing the Spacefile

This will create a Spacefile in the root directory. And it will only have the version v:0 as text and comment to the docs. This is where we define our runtime engine and other requirements. To get a clear idea about it you can visit the Spacefile - Space Docs (deta.space ). To run the FastAPI app we need to define some requirements in the Spacefile. Here's what the file looks like after adding the required lines.

## Spacefile Docs: https://go.deta.dev/docs/spacefile/v0
v: 0
icon: ./icon.png
app_name: "Simple FastAPI APP"
micros:
  - name: simple-fastapi
    src: ./
    engine: python3.9
    dev: .venv/bin/uvicorn main:app --reload

I ran into a few troubles while making the Spacefile, it seems python apps don't support run commands. Use dev to specify a command which starts your Micro in development mode. This command will be used to start your micro when you run.

You can specify the version of python you need using the key engine. There are only two versions available currently python3.9 and python3.8.

src is the directory where the main.py file resides. You can keep it inside another folder and then specify the path to that folder.

for the icon I am using the logo of FastAPI, you can check it out at logo-teal.png (1023369) (tiangolo.com ).

PS: You are required to keep the file main.py as the entry file or it will not work. Make sure you use main.py for any python project.

Deploying the app

To deploy we just need to give the command, and it should automatically deploy and give the output URL.

space push

Congratulations the app is live🥳🥳. And you will be able to see the application in your dashboard. You can find my deployed version at https://simplefastapi-1-h6036723.deta.app.

Conclusion

This was a simple blog explaining the way to deploy the FastAPI application on Deta Space. There are many more things you can add to the project, I am just setting an example. The documentation is pretty amazing and you can find almost all the parts documented, do give it a read at Getting started - Space Docs (deta.space ).

Overall I would say it's pretty easy compared to other services, even though some services are popular yet it's hard to get the app deployed on the service. The Deta Space is not that famous but it was easy to deploy apps. I am sure that I will use the service again to host my apps.

The Deta Space is still under construction and it's developed and updated daily. This makes it vulnerable to bugs and other problems. If you are stuck at some place, first read the docs. If you're still stuck after that then you can join their Discord server and post your queries and problems.

https://discord.com/invite/K3gYNqHXUU

The community may be small but they are active and almost answers every single query raised. Giving feedback will help build the platform faster and better, do share your review on Discord.

Finally thank you for reading this blog, it was a good experience to share my view and knowledge about the platform. Have a great day!

Top 10 Python Packages Every Developer Should Know About

Akash R Chandran — Fri, 10 Mar 2023 17:04:08 +0000

Python is undoubtedly one of the most popular programming languages in today's tech industry. With an ever-increasing number of developers turning to it, Python has established itself as a must-know skill for any aspiring programmer or software engineer. One reason behind its massive popularity is the vast collection of python packages that make coding more efficient and seamless. If you're looking to take your Python development skills to the next level, we've got you covered. In this post, we'll be discussing ten essential python packages every developer should know about to boost their productivity and streamline their workflow. Whether you're building web applications, performing data analysis tasks or developing machine learning models, these packages are guaranteed to simplify your work and enhance your code quality. So buckle up and get ready to dive into our top 10 list!

Introduction to Python Packages

Python is a widely used high-level interpreted language. Python's design philosophy emphasizes code readability with its notable use of significant whitespace. Its syntax allows programmers to express concepts in fewer lines of code than would be possible in languages such as C++ or Java. The language provides constructs intended to enable clear programs on both a small and large scale.

Python packages are collections of modules that you can import into your scripts to make use of their functionality. In this article, we'll take a look at some of the most popular Python packages that every developer should know about.

What is a Python Package?

Python packages are modules that contain code written in the Python programming language. Packages can be used to extend the functionality of Python or to add new features to existing Python code. Python packages can be installed from a variety of sources, including the Python Package Index (PyPI), or third-party repositories. Once installed, packages can be imported into your Python code using the import statement.

Packages can contain a variety of different types of content, including:

Modules: A module is a single Python file that contains code. Modules can be imported into other modules, or the main Python interpreter, using the import statement.

Classes: A class is a template for creating objects. Classes can be defined in modules and then imported into other modules, or the main Python interpreter, using the from...import statement.

Functions: A function is a block of code that performs a specific task. Functions can be defined in modules and then imported into other modules, or the main Python interpreter, using the from...import statement.

Data: Data is any information that can be stored in computer memory. Data can be stored in variables, and passed to functions as arguments.

The Packages are:

Pandas

The Python package Pandas is a free and open-source library that provides high-performance data structures and data analysis tools. It is built on the popular Python libraries NumPy and matplotlib, which allow for efficient data manipulation and analysis. Data structures and operations for manipulating numerical tables and time series data are available in Pandas. It is a must-have for data manipulation and data science tasks. Pandas is a highly effective data analysis, manipulation, and visualisation tool. It is used in many industries, including finance, analytics, and data science, for data cleaning, preparation, and analysis. Pandas make it simple to work with large datasets, allowing users to summarise, manipulate, and visualise data quickly and easily.

NumPy

NumPy is a robust and effective module for doing scientific computations. It offers quick mathematical operations on these massive, multi-dimensional arrays and matrices for which it is developed. Many mathematical operations are offered by NumPy, such as Fourier analysis, linear algebra, and random number creation. For manipulating arrays, it also offers sophisticated indexing and slicing features. In disciplines including data science, machine learning, and computational physics, NumPy is extensively employed. Its popularity is a result of the performance and usability it combines, making it a crucial Python tool for scientific computing.

Matplotlib

Matplotlib is a Python package that offers a range of tools to developers for making interactive visualisations, such as graphs and charts, that can be used for data analysis. It is a commonly used library in science, and it works particularly well for making static 2D and 3D plots that may be highly customised and detailed. Also, it offers assistance with story interactivity and animation creation. After you grasp the fundamentals of charting, Matplotlib's simple syntax makes it simple to use. For everyone who wishes to extract amazing images from their data, it offers a necessary tool.

TensorFlow

Popular open-source software called TensorFlow is used to create and train machine learning models. It was created by Google and is one of the most used deep learning frameworks. Because TensorFlow is built on a dataflow graph, users can see how data flows through a neural network model. It offers a versatile and effective language for creating and refining models on huge datasets. Applications supported by this package include natural language processing, picture and speech recognition, and more. You may quickly scale sophisticated models to huge datasets with TensorFlow.

Scikit-learn

Built on top of NumPy, SciPy, and matplotlib, Scikit-learn is a free and open-source machine learning framework. It offers straightforward and effective tools for data analysis and mining. Scikit-learn offers tools for model selection and evaluation, data preprocessing, feature selection, and model visualisation in addition to several algorithms for classification, regression, clustering, and dimensionality reduction. Classification, regression, natural language processing, image processing, and other machine learning tasks are only a few of the many machine learning tasks for which it is frequently employed in both industry and research. Scikit-learn is a vital tool for anyone interested in machine learning because of its simplicity of use and extensive capability.

PyTorch

A well-liked open-source machine-learning library for Python is called Pytorch. Because of its adaptability, clarity, and scalability, it is widely used. Using the capabilities of graphics processing units (GPUs) to speed up training, Pytorch offers a simple interface for creating deep learning algorithms. The software is widely used in research, education, and business for a range of tasks including speech recognition, computer vision, natural language processing, and more. Pytorch has developed into a vital toolkit for machine learning enthusiasts and engineers alike thanks to its comprehensive collection of tools and community support.

Flask

Flask is a lightweight and powerful web development framework for building Python-based web applications. It includes a comprehensive set of tools and libraries for developing a wide range of web applications, from simple static sites to more complex web applications with dynamic data. Flask has an easy-to-learn and-use API, as well as a flexible and extensible design that allows you to tailor it to your specific requirements. It also includes built-in unit testing support, simple error handling, and easy integration with other libraries and services. Because of its simplicity, flexibility, and ease of use, Flask is a popular choice for developing web applications.

Django

Django is a Python web framework that is open source and follows the Model-View-Controller (MVC) architecture. It is widely used to rapidly create high-quality web applications. Django's clean design encourages code reuse and employs object-oriented programming principles. Django includes a powerful URL routing system for creating clean URLs, an ORM for working with databases, and an HTML template engine. It also has an authentication system, security features, and middleware support built in. Django has a vibrant community that is constantly improving and contributing to the framework. Because of its scalability, flexibility, and ease of use, it is a popular choice among developers.

Requests

With the Python library Requests, HTTP requests are made easier. It was developed for usage with API requests and page scraping. Requests offer a straightforward and understandable interface for handling HTTP requests and responses. The package includes functions for managing cookies and sessions, authenticating users, and encoding data in several different forms. Moreover, Requests supports the HTTP/1.1 and HTTP/2 protocols and offers synchronous and asynchronous request handling. The programme is frequently used for tasks including automation, data extraction, and web development.

BeautifulSoup

Beautiful Soup is a popular Python package for parsing HTML and XML documents. This package enables programmers to easily extract data from HTML pages. It makes it simple to use web scraping functions in Python. Beautiful Soup parses HTML documents and allows users to extract the content they require. Beautiful Soup's extensive documentation allows it to work with HTML files in a variety of formats. To efficiently extract content, the package supports a variety of searching and filtering methods. It is the go-to Python package for extracting data from web pages.

Conclusion

In conclusion, the Python programming language is a very strong and flexible tool that can be applied to a wide range of projects, including web development and data analysis. The top 10 Python packages that every developer should be familiar with can help developers use Python to its best ability. These software packages offer strong tools and capabilities that can be utilised to create intricate applications and address intricate issues. These packages make it simple for developers to build dependable and effective apps. We trust that this article has helped you gain a better knowledge of the top 10 Python packages that every developer should be familiar with.

Deploying FastAPI application to Render

Akash R Chandran — Wed, 02 Nov 2022 06:09:37 +0000

Recently, I came to know that Heroku is going to stop supporting free services. I have almost all the projects running in Heroku and I never tried any services. Many people pointed out that Render is the best free alternative to the Heroku. So I am giving it a try by hosting a FastAPI application. Render seems to directly support python frameworks like Flask, Django etc as their documentation mentions them. But we should be able to host FastAPI app as it supports building any python app, we just need to change the starting command. Let's get into it without wasting another minute.

Creating Render Account

To host on Render, you'll need to sign up or create an account. It's free and supports direct login using google, GitHub and GitLab account. Or you can use email and password to signup. You need to verify your email to get full access to the platform. Just head to render/register.

Need for GitHub or GitLab account

It's easier to deploy an application that has its source code hosted on GitHub or GitLab. Render connects with GitHub or GitLab to deploy your apps and websites automatically on every push to your project. This is very useful, as you don't have to manually deploy every time you make a change. You can either connect GitHub or GitLab or both.

Let's make a simple API using FastAPI

We need an application to deploy to the Render. Let's build a simple API app which echos Hello World.

Setting up environment

You'll need to download and install Python3 to your local machine. It's better to set up a virtual environment for the application.

Windows

For windows, just head to python.org and download the latest EXE file and install. Installation is pretty well interactive, you just need to follow the instructions shown.

Next, create a folder in your preferred directory and name simple-api. Next to set up virtual environment enter the command opening terminal or CMD.

py -3 -m venv .venv
.venv\scripts\activate

Linux or Mac OS

Most of the Linux Distributions come with python3 be installed by default, just check if it exists by using command

python3 --version

For mac users just head to python.org and download the .pkg file and start installing.

Next to set up virtual environment, on Linux sometimes we need to install extra library. To do the same, just enter the command in your terminal.

sudo apt-get install python3-venv

Next, to initialize and activate a virtual environment on Mac and Linux, use the commands below.

python3 -m venv .venv
source .venv/bin/activate

Installing requirements

Make sure your package manager that is pip is up-to-date.

python -m pip install --upgrade pip

Now install FastAPI, using pip

pip install fastapi

FastAPI also requires an ASGI server, for production, such as Uvicorn or Hypercorn. I personally just use Uvicorn.

pip install "uvicorn[standard]"

Coding the API

Open the folder in any text editors, you can use notepad or advanced IDE's like VS Code or Sublime Text 4. Make a new file called main.py and we use this file to write the code in.

Just copy and paste the below lines to the file. If you're good with python or professional, then you can add or modify, making the API better.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

Save the file. Let's try out the simple-api using the command:

uvicorn main:app --reload

Head to localhost:8000 or http://127.0.0.1:8000. You should see the Hello World.

All done. Now we just need to create some extra files which are need by Render to identify it as a python application.

Creating Requirements.txt

Usually I use external library pipreqs, but you can just simply type fastapi and uvicorn in the requirements.txt file. When deploying, render will install the latest version of these modules.

Creating a .gitignore file

.gitignore file helps to avoid uploading of unwanted or private files to the git clients such as GitHub or GitLab. When sharing your code with others, there are often files or parts of your project, you do not want to share. So these files or folders can be mentioned in the .gitignore file.

For this simple-api we don't want to upload .venv and __pycache__ to the GitHub. So we mention them in the .gitignore file like this.

Upload to GitHub or GitLab

I am using the GitHub here, but you can use GitLab as well. I have installed git, and I have connected it to my GitHub account. You'll find many articles on how to do it, just google it. If you're using Visual Studio then it has in built GitHub plugin which makes it way easier.

I have successfully uploaded to GitHub, you can find mine at akashrchandran/simple-api. You should definitely add a readme.md to the repo, I will do it later.

Deploying to Render.com

As we are not deploying a static site, we should choose the option Web Service.

If you have connected your GitHub account, then you can just search the repository name and find it there.

Give a name to your web-service, then to select the region which is nearest to you, for me is Singapore. Leave all other values default. For the Start command, copy and paste the below:

uvicorn main:app --host 0.0.0.0 --port 10000

Deploying may take some time, so patiently wait. After successful deployment, you should see the message like this below.

Congratulations, you have successfully deployed your FastAPI application to the render platform. You can view the site I deployed here.

Summary

It was so simple to deploy a FastAPI based application to render. If you don't want to code or waste time on making a FastAPI based app, then you can try deploying mine. It is available on GitHub.

Render may the Heroku alternative thing you're looking for, as it gives out almost the same free specifications as Heroku free tier. Do give it a try!

Thanks for reading...

Simple movies Telegram bot using PHP

Akash R Chandran — Wed, 26 Oct 2022 00:24:32 +0000

I have been using telegram for almost 4+ years and have made more than 30 bots during this period. I made the first one in PHP and the rest were build in Python and JavaScript. So today I thought why not make a simple telegram bot in PHP. That's why we are going to make a movie's bot in PHP. Let's begin without wasting time.

Gathering Requirements

Before we start making our bot, we need two things. It won't take much time, only few minutes. The things we need are:

Telegram Bot Token
TMDB API key

TMDB is the site from which we will pull the movie information from. It's free, you just need to register and fill some forms for an API key. So let's start gathering them.

Get Telegram Bot token

It's actually pretty simple to get the token from telegram. But first you need is a telegram account. I assume that you have one. Search for a bot named BotFather or use this link. It should have a verified emoji in its name.

Click on the bot and press start, or if you don't see that option, then type /start. I should greet you with a help message. You can read through that if you want to, it lists all details about what the bot can do. Next is, type /newbot and press send. It will ask for the name of the bot. After that it will ask for bot username which must be unique and should end in bot like mine here is phpmoviesbot.

Now you will receive a message which has a http API token. This was the token we were looking for, save it somewhere because we will need it later.

Get API key from TMDB

Head to TMDB and find register or join now. Then create an account. Then find settings and on the left side you will see an option named API, press that or use this link. You will need to fill a form about what you will be using the API for etc, just fill it yourself. After that you will get an API Key (v3 auth), save it somewhere we need it later.

Now that we have what we wanted, let's start with the programming side.

Setting up webhook

Setting up the webhook through which your Telegram bot will communicate is the next step in the creation process. In order to avoid having to query the API every few minutes (or seconds) to see whether, for example, a new message has been received, APIs use webhooks to notify you that something has occurred.

Telegram only makes use of one form of webhook, which delivers an update object each time something occurs. The webhook configuration is really simple.
There are only two things you must be aware of: your API token (which you should already have from step one), and the URL at which your bot will be hosted.
It will have a URL similar as https://yourdomain.com/yourbot.php.
To ensure that Telegram sends the webhook, insert https at the beginning of the URL.

Go to https://api.telegram.org/<TELEGRAM_BOT_TOKEN>/setwebhook?url=https://yourdomain.com/yourbot.php in a standard web browser now. Do replace <TELEGRAM_BOT_TOKEN> with your telegram bot token.

Coding part

For this, I am assuming you know basic PHP syntax, formattings etc. Let's start then, we know that PHP script start with <?php and ends with ?> and we write the code in between.
We are receiving webhook, therefore let's get input from the POST body:

$content = file_get_contents('php://input');
$update = json_decode ($content, true);

The received data is in JSON, to decode it to PHP based array, we have to use json_decode function. Now let's declare some variables which will store some, data from the update like username, chat ID etc.

$chat_id = $update['message']['chat']['id'];
$message = $update['message']['text'];
$username = $update['message']['from']['username'];

We would have to send many messages, so let's define it directly as a function to make it easier to reuse.

function send_message ($chat_id, $message) {
    $apiToken = <TELEGRAM_BOT_TOKEN>;
    $text = urlencode($message);
    file_get_contents("https://api.telegram.org/bot$apiToken/sendMessage?chat_id=$chat_id&text=$text");
}

Replace the <TELEGRAM_BOT_TOKEN> with the telegram bot token you made. Let's test the bot with a /start message, to do that we have to write some more code, just an if statement as below.

if ($message == '/start') 
{
    send_message ($chat_id, "Hey @$username  \nsend me any query to search for the movie.");
}

It seems to be working. Now let's complete it by adding the movie information fetching part. I want to make the bot search everything we text we send except /start. So we just add else to the pre-existing if statement. I am expecting you know how to parse JSON.

else {
    $req = file_get_contents("https://api.themoviedb.org/3/search/movie?api_key=<TMDB_API_KEY>&language=en-US&page=1&query=$message" );
    $movie = json_decode ( $req, true )['results'];
    if ($movie) {
        $movie = $movie[0];
        $title = $movie['title'];
        $overview = $movie['overview'];
        $popularity = $movie['popularity'];
        $release_date = $movie['release_date'];
        $vote_count = $movie['vote_count'];
        send_message($chat_id, "
        Title: $title
        Description: $overview
        Popularity : $popularity
        Release Date : $release_date
        Votes: $vote_count");
    } 
    else {
        send_message($chat_id, "Couldn't find any movie with that name!");
    }

Replace <TMDB_API_KEY> with the TMDB API KEY we gathered. Now let's try the bot, by sending a movie name.

Works perfectly, You can add more functions to it, but for now I am stopping it here.

Summed up

We learnt to create a small bot using webhooks. I will add an article about host the bot, for free, on vercel. The entire code for the bot is available below.

<?php
$content = file_get_contents ('php://input');
$update = json_decode ($content, true);
$chat_id = $update['message']['chat']['id'];
$message = $update['message']['text'];
$username = $update['message']['from']['username'];

if ($message == '/start') {
    send_message ($chat_id, "Hey @$username  \nsend me any query to search for the movie.");
} else {
    $req = file_get_contents("https://api.themoviedb.org/3/search/movie?api_key=<TMDB_API_KEY>&language=en-US&page=1&query=$message" );
    $movie = json_decode ( $req, true )['results'];
    if ($movie) {
        $movie = $movie[0];
        $title = $movie['title'];
        $overview = $movie['overview'];
        $popularity = $movie['popularity'];
        $release_date = $movie['release_date'];
        $vote_count = $movie['vote_count'];
        send_message($chat_id, "
        Title: $title
        Description: $overview
        Popularity : $popularity
        Release Date : $release_date
        Votes: $vote_count");
    } 
    else {
        send_message($chat_id, "Couldn't find any movie with that name!");
    }
}

function send_message ($chat_id, $message) {
    $apiToken = <TELEGRAM_BOT_TOKEN>;
    $text = urlencode($message);
    file_get_contents("https://api.telegram.org/bot$apiToken/sendMessage?chat_id=$chat_id&text=$text");
}
?>

Thanks for reading.

Some less popular git commands

Akash R Chandran — Sun, 16 Oct 2022 02:38:48 +0000

Introduction

Git is pretty much used by every developer nowadays. Personally, even after using it for approximately two years, I continue to discover new git features. So here are some of the commands I discovered, and seems they aren't popular enough. Without wasting time, let's dive into it.

Check logs but in easier ways

git log a useful tool for looking back and reading the history of every action taken with a repository. A git log's multiple settings can be utilized to narrow down history. The git log typically contains a list of commits. And sometimes the list is so big it's hard to find anything we need. Let me show you an easier way to do the same, but the output is short yet brief.

git log --oneline

It's super helpful to check the latest commits. With the --oneline flag, each commit is reduced to a single line. It just shows the commit ID and the first line of the commit message by default. The output should look like:

1266f06 (origin/develop) updated readme
33bf5fb Merge branch 'develop'
bd99bba fixed error
19389a7 Merge pull request #5 from akashrchandran/develop
5a2258e added exceptions
9dbb9de updated readme

git shortlog

A modified version of the git log command called git shortlog is used mostly to make release notifications. It displays the first line of each commit message and groups each commit according to author. This makes it simple to determine who has been working on what.

Akash R Chandran (4):
      Initial commit
      fixed all errors
      added gitignore
      Added support for heroku deployment

Paulo Martini(3):
      added files via upload
      updated
      fixed requests errors

git log --graph

The branch structure of the commit history is represented via an ASCII graph when the --graph option is used. To make it simpler to determine which commit belongs to which branch, this is frequently used in conjunction with the --oneline and --decorate commands:

*   64f95a3 (HEAD -> main, origin/main, origin/HEAD) Merge pull request #6 from akashrchandran/develop
|\
| * 1266f06 (origin/develop) updated readme
* | 33bf5fb Merge branch 'develop'
|\|
| * bd99bba fixed error
* | 19389a7 Merge pull request #5 from akashrchandran/develop
|\|
| * 5a2258e added exceptions
|/
* 9dbb9de updated readme

To get more info on git log you can visit here.

Switching branches

The git checkout command can be used for a wide range of purposes. Because of this, the Git community has decided to release a new command: git switch. It was designed primarily for the process of switching branches, as the name suggests.

$ git switch develop
Switched to a new branch 'develop'
branch 'develop' set up to track 'origin/develop'.

Switch back and forth between two branches

git switch makes it very easy to switch between the same branches back to back. It doesn't even need the branch name to switch, just remove branch name and put a hyphen(-):

$ git switch -
Switched to branch 'main'
Your branch is up to date with 'origin/main'.

Using the same command again will switch back to develop.

Checking the changes made to file

The function of diffing outputs the differences between two input data sets. A diff operation is performed on Git data sources when the Git command git diff is invoked. Commits, branches, files, and other types of data sources are examples. This document will go over typical git diff commands and diffing work flow patterns. git diff, git status, and git log are frequently used to examine the present state of a Git repository.

$ git diff 
diff --git a/spotify.php b/spotify.php
index 6987fef..bc766cf 100644
--- a/spotify.php
+++ b/spotify.php
@@ -64,6 +64,7 @@ class Spotify
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
                curl_setopt($ch, CURLOPT_URL, $formated_url);
                $result = curl_exec($ch);
+               echo $result;
                return $result;
        }
 }

Restore to an older version of the file

Another extremely useful option available with the git restore command is "—source". You can quickly restore any earlier version of a particular file with the use of this option:

git restore --source 6bcf266b index.html

Adding comments to your commits

To preserve a better development history, developers typically write clear and self-explanatory commit notes. Thanks to well-liked commit conventions, some development teams even automatically produce release notes with commit messages. How can I include some extra notes in a commit? Commit message additions will be reflected on remote Git hosting GUIs. How can I record a message for a CI/CD server or add a hidden note to remember about any technical work? We can add extra comments for commits with the help of the built-in Git notes functionality.

To connect a note to the current commit, issue the following command:

$ git notes add -m "This is a test comment"

By omitting the -m option, you can use the editor programme to write a multiline, lengthy note. The git notes show command allows you to view the most recent note. Additionally, the git log command by default displays notes.
Git notes were previously supported by GitHub as comments, but they are now deprecated in favour of web-based comments.

Git does not automatically push or pull notes, but you can manage remote notes explicitly using the following commands:

git push <remote> refs/notes/*
git fetch origin refs/notes/*:refs/notes/*

Print the SHA1 hashes

git rev-parse is an ancillary plumbing command primarily used for manipulation.
One common usage of git rev-parse is to print the SHA1 hashes given a revision specifier. In addition, it has various options to format this output, such as --short for printing a shorter unique SHA1.

$ git rev-parse HEAD
64f95a3edf8ecaf1f874b9a25fb7312a722f463a

Conclusion

These commands are mostly for better productivity and simplicity. It's good if you know what they do. Git is well known these days, but many of its powers are still unknown to the public. It's true that you can "survive" with a handful of commands like commit, push, and pull.

Thanks for reading 😊.