DEV Community: Kaushal Sharma

A simple guide to using the Useless Facts API

Kaushal Sharma — Fri, 01 Jul 2022 12:02:20 +0000

So, over the course of two weeks filled with pain and despair due to sickness, I created a simple API in django rest framework
to learn about itself and also apply concepts like Token Authentication, Scoped Rate Limiting, and how to document APIs to name a few.

Now, realizing that getting data is not so cheap and also scraping someone else's website can put unnessesary load on their website
and their wallet, I'm making whatever data I've collected available to everyone else through these APIs.

Steps to using these APIs

Step 1: Call the /auth/login/ endpoint, or /auth/registration/ if you are a new user, to get back a Token

Note- All demonstration done using httpie, but you can see how to do it using curl in the swagger doc here

http POST https://uselessfacts.fly.dev/auth/login/ username=<your-registered-username> password=<your-registered-password>

http POST https://uselessfacts.fly.dev/auth/registration/ username=<your-choice-of-username> password1=<your-choice-of-password>  password2=<same-as-password1>

You'll get back the following response -

{
    "key": "c596a03fd15783e14d512c843a7ee4ba84ea77eb"
}

This is the token we were talking about

Step 2: Send this Token as Authorization while calling the v1 APIs to get back the useless facts!

http POST https://uselessfacts.fly.dev/v1/random-fact/ 'Authorization: Token c596a03fd15783e14d512c843a7ee4ba84ea77eb'

http POST https://uselessfacts.fly.dev/v1/fact/145/ 'Authorization: Token c596a03fd15783e14d512c843a7ee4ba84ea77eb'

And upon successful request you'll get back the useless fact like below

{
    "data": {
        "fact": "California consumes more bottled water than any other product.",
        "id": 145
    },
    "status": "success"
}

You can check out other respones in the swagger documentation here

Now the most important step, like a good person make sure you logout as well!

Step 3: To logout call the /auth/logout/ endpoint with no body with sending the Token in authorization just like we did in the previous step

http POST https://uselessfacts.fly.dev/auth/logout/ 'Authorization: Token c596a03fd15783e14d512c843a7ee4ba84ea77eb'

Upon successful request you should get the following response -

{
    "detail": "Successfully logged out."
}

You can explore all the other available endpoints as well as the models in the swagger documentation mentioned above.

You can get in touch with me here or on LinkedIn OR Instagram !

Create and Deploy your first Flask app

Kaushal Sharma — Tue, 17 May 2022 10:31:43 +0000

So, you’ve been banging your head for some time now trying to understand -

what is this Flask framework and how do I use it

I know, I’ve been there too. But don’t worry, you don’t have to go through all the pain of searching articles for days to understand it’s functionalities.

Here, we’ll make a simple weather application using Flask to understand it’s functionalities and also cover some core concepts like -

Creating and maintaining virtual environments using pipenv
How does routes work in Flask
How to render HTML Templates in Flask
Interacting with public APIs
Passing data from Python to HTML
How to get and process user input
How to serve static files(CSS, JS, images etc) in Flask
How to work with environment variables in python
Deploying your ****Flask app on Heroku

Right, the list seems quite a bit for a simple app but trust me, you’ll zoom past it in no time!

Here’s what we’re gonna build - Live app

And let’s get right into it!

Creating and maintaining virtual environments using pipenv

First, we’ll create a new folder for our project, I’ll name it “SimpleFlaskWeatherApp”, and then initialise a virtual environment.

For creating a virtual environment i’ll be using pipenv rather than virtualenv or pyenv. pipenv was first released in 2018 and it aims to simply the workflow by bringing the packaging concepts from bundlers, npm, yarn etc to python!

It automatically creates and manages the virtualenv for your projects by creating a Pipfile and Pipfile.lock without you having to do anything except installing the packages you need!

First install pipenv by entering the command in your terminal-

pip install pipenv

if you have multiple versions of python then type the command,

python3.x -m pip install pipenv

where x would be your choice of python version installed on your system

Now, to create a virtual env, go into your project folder and type -

pipenv shell

this should create a virtualenv for your project with the name of your project folder followed by some random characters.

In my case, you can see it on the right of the image, it’s “SimpleFlaskWeatherApp-0rR_1i25”

If you list the contents of your directory, you would see that pipenv has created a Pipfile which it would use to manage your entire project dependency. It looks something like this -

If you now want to install any python package, simple type the following command

pipenv install flask

This would install and make the package available to your project and also add it to your Pipfile automatically!

If you later want to pass this environment to someone else then you don’t have to create a requirements.txt, just give them your Pipfile.lock file. Then all they have to do is run the command pipenv install and pipenv will automatically create a virtualenv and install all the packages that are required and re-create the exact same environment.

How cool is that!

After installing flask, our Pipfile looks something like this -

If you want to exit your virtual environment, simply type exit and press enter. And to activate it again, type pipenv shell

Since we’ve covered pipenv, let’s move on to creating our project!

For context, this is what our project directory looks like -

How does routes work in Flask

Go ahead and create a file called app.py, we’ll write a starter code for a basic flask application like below -

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "<h1>This is working!</h1>"

if __name__ == '__main__':
    app.run()

and run the python file

python app.py

you should get the following output -

In a flask application, the function following the app.route is the logic that should be run if a user open the route specified in the @app.route decorator

Since we wrote @app.route('/') , where “/” means the index route, if the user opens localhost:5000, the index function logic would be executed and whatever the function returns would be returned to the user.

How to render HTML Templates in Flask

We’ve returned the html as a string for now just to test whether our application works or not, but this is not practical if you want to render more complex pages with data that will be returned by us later in this article.

So, instead of writing the html as a string we will create HTML files and return them instead.

Go ahead and create a templates folder in your project directory and inside this templates directory create an html file called index.html

Our directory structure looks something like this -

Inside the index.html, write a simple html code as follows -

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask Weather App</title>
</head>

<body>
    <h1>This template is working</h1>
</body>

</html>

Now, in our app.py, along with Flask module also import render_template module which will allow us to serve html files to the users.

And in the index function, simply type return render_template('index.html')

So our code looks like this now -

from flask import Flask, render_template # new

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html') # new

if __name__ == '__main__':
    app.run()

Now, if you run your application, you should see the output as below -

The render_template function looks for the html template specified inside the templates folder that we created earlier.

Interacting with public APIs

Now that we have our flask application set up to render html templates, let’s start working with public APIs.

We’ll be using the Current Weather Data of openweathermap.org to get weather data for free

They should provide you with an API key to access that API. You can find it here. We’ll be using this API Key to make API calls to get the current weather data!

First, Let’s do a simple call to the API and make sure that the API is returning data as expected.

We’ll call the API using the requests library in python as follows -

API = 'http://api.openweathermap.org/data/2.5/weather?q={city}&units=imperial&appid={api_key}'
city = 'Mumbai'
api_key = "<your_openweather_api_key>"
try:
    weather = requests.get(API.format(
        city=city, api_key=api_key)).json()
except Exception as e:
    print(f"Error in fetching data")

It is always a good idea to use try except blocks wherever you are not sure about the output

Now this piece of code will make a call to the API using the city and api_key variables and store the result in weather variable

but before we can display this result to the user, we must first check that infact, we have got back a correct result!

In HTTP status codes, 200 means that the API call was success and you have received some data and 404 means there was some error when you sent the API request.

We’ll be checking the status code of our API call by checking the key value cod that would be present in the weather variable after the API call was made. if the value of cod is 200, that means we have correct data, if it is 404 or if we did not receive an output from the API, then it means we made a mistake while calling the API.

The code for that would be like this -

if weather["cod"] == 200:
                # We got correct result
        return render_template('index.html')
    else:
            # We got incorrect/no result
        return render_template('error.html')

Create an error.html file alongside your index.html file in the templates folder, and just write a simple code to let you know that some error has occured

<h1>Some error ocurred while making the API call</h1>

Ideally, you should have proper error handling for all the status codes like 4xx and 5xx , but for the context of this article is should suffice.

Our code for app.py looks something like this now -

import requests
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    URL = 'http://api.openweathermap.org/data/2.5/weather?q={city}&units=imperial&appid={api_key}'
    city = 'Mumbai'
    api_key = "<your_openweather_api_key>"
    try:
        weather = requests.get(URL.format(
            city=city, api_key=api_key)).json()
    except Exception as e:
        print(f"Error in fetching data")
    if weather["cod"] == 200:
        return render_template('index.html')
    else:
        return render_template('error.html')

if __name__ == '__main__':
    app.run()

If you restart the app and open localhost:5000, you would still get the “This template is working” message which we wrote in the html.

Passing data from Python to HTML

You must be wondering

Why is the data that we received from the API call not showing in our template?

That’s because we have to pass that data, or infact any data that we want to show to the user, to the template in the render_template function

Here’s how we would do it -

return render_template('index.html', weather=weather)

And in your index.html file, simply write the variable name enclosed within two curly braces like below -

...
<body>
    <h1>This template is working</h1>
    <div>{{ weather }}</div>
</body>
...

Now if you restart your app and refresh the page, you should be able to see the data that is returned by the API we called!

Sweet! now we can pass data from our python code and show it to the user!

Python frameworks like Flask or Django use a templating language for html called Jinja2 which enables us to pass data from our python code and display it to the user and also get data from the html given by user and use it in our python logic, which is how we were able to pass the data from python to html.

But we do not want to show the user all of the data. how do we select only certain parts it?

Since it’s a dictionary, we can access it the way we acess a dictionary, but there is a twist to it.

we cannot access the dictionary like my_dict["key"] . To do it in html, or rather jinja, we would do my_dict.key, we have to use the dot notation!

Let’s filter out the raw weather data and keep only the useful bits! Our index.html after filtering would look like this -

...
<body>
    <h1>This template is working</h1>
    <div>
        <div>{{ weather.timeOfDay }}</div>
        <div>{{ weather.weather.0.main }}</div>
    </div>
    <div>
        <p>{{ weather.name }} <span>{{ weather.sys.country }}</span></p>
    </div>
    <div>
        <p>{{ weather.main.temp }}</p>
        <div>
            <div>
                <p>{{ weather.main.humidity }}</p>
            </div>
            <div>
                <p>{{ weather.wind.speed }}</p>
            </div>
        </div>
    </div>
</body>
...

We can also use control flow like if else or for loop in our html file! we’ll wrap all the divs containing reference to weather variable after our h1 tag under an if statement so that we only show the result from the API call if we have some data in the weather variable, else we do not show anything

<body>
    <h1>This template is working</h1>
    {% if weather %}  <!-- new -->
    <div>
        <div>{{ weather.timeOfDay }}</div>
        . . .
        </div>
    </div>
    {% endif %}  <!-- new -->
</body>

Now if you restart your app and refresh, you should see something like this -

This is all the data that we have to show the user!

How to get and process user input

Let’s now add a search box that will allow the user to search for places they like and get details of those places. Add a form and inside that form add a input search box to get input of city and a button to submit the query.

...
<h1>This template is working</h1>
    <div>
        <form method="post" action="{{ url_for('index') }}">
            <input type="search" name="city">
            <button type="submit">Submit</button>
        </form>
    </div>
    {% if weather %}
    ...

The form in html needs the action attribute which would typically be a url the html will redirect to once the form is submitted. Here, we provide the url for our index page itself using the url_for function inside double curly braces. Note inside the url_for we give the function name and not the route, that’s because in flask the route and function name should be identical!

This is also one of Jinja2’s features!

Since now are are submitting a post request from our page, we need to handle that in our function as well.

Flask let’s us identify whether a request is GET request or a POST request simply by doing request.method inside the function.

We will now update the index function in our app.py by checking the type of request the function is receiving.

If the request is a GET request then just render the index.html form without any processing or API calls since it’s the first time user is loading the page.

If the request is a POST request, then we would read the city name that was submitted by the user and make the API call to get the weather data for that city and return the data to our index.html so that we can show the data to the user

Let’s update the index function to handle different types of requests,

from crypt import methods
import requests
from flask import Flask, render_template, request # new

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST']) # new
def index():
    if request.method == 'POST': # new
        URL = 'http://api.openweathermap.org/data/2.5/weather?q={city}&units=imperial&appid={api_key}'
                city = request.form.get('city') # new
        api_key = '<your_openweather_api_key>'
        try:
            weather = requests.get(URL.format(
                city=city, api_key=api_key)).json()
        except Exception as e:
            print(f"Error in fetching data")
        if weather["cod"] == 200:
            return render_template('index.html', weather=weather)
        else:
            return render_template('error.html')
    else:
        return render_template('index.html')

if __name__ == '__main__':
    app.run()

Now, if you restart the app and refresh the page, you’ll get an empty page because when the page is first loaded the form is not submitted hence it is a GET request.

If you now enter a city name and press submit, you should get weather data for that city!

But this page looks a bit dull to be honest, let’s add some CSS styling and make it come alive!

How to serve static files(CSS, JS, images etc) in Flask

First, create a static folder in your project root directory alongside the templates folder, and add a style.css to it

Add some basic code in your style.css

@import url("https://fonts.googleapis.com/css2?family=Source+Sans+Pro:ital,wght@0,300;0,400;0,600;1,400&display=swap");

*,
*::before,
*::after {
  -webkit-box-sizing: border-box;
          box-sizing: border-box;
}

body {
  height: 100vh;
  width: 100vw;
  font-family: "Source Sans Pro", sans-serif;
  margin: 0;
    background: linear-gradient(blueviolet, skyblue);
}

And to load this CSS in your html file, add a link tag to your html

...
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}"> <!-- new -->
    <title>Flask Weather App</title>
</head>
...

To load the CSS input html, we again use url_for but this time we give it two arguments.

The first is the name of our static folder which is static and second we give it a filename which in our case is style.css

You should see something like this,

And now you can customise your page however you like!

Since styling a page is very subjective, i’ll leave it upto you now. However, if you want to style it like how it is in the video at the start, i’ll link my github repo at the end of this article!

How to work with environment variables in python

Remember how we are using an API key to make the API calls. Well that API key is specific to you and should always be hidden from others. You should also never upload this key anywhere, even on github.

But then you might ask,

How can we use it in out project, without having it in our project ?!

Well, we can make use of something called environment variables. We can add some variables to the environment that is running our code, and access those variables in our code whenever we want!

To accomplish this, first create a .env file in our project root directory

And inside this .env file, assign your API key to a variable like so

Make sure you don’t add any quotes, just paste your key right after the equals to sign

Now to access this API key in our project, we need to install a library called python-dotenv

pipenv install python-dotenv

And we now import and initialize the packages we just installed in our project

import os #new
from crypt import methods
import requests
from flask import Flask, render_template, request
from dotenv import load_dotenv, find_dotenv # new

load_dotenv(find_dotenv()) # new

app = Flask(__name__)

...

The find_dotenv function will find the .env file located in our project and the load_dotenv function will load it into our project so we can use it

Now, to reference the api key variable in our .env file in your project we will make use of the os library that we imported,

...
if request.method == 'POST':
        URL = 'http://api.openweathermap.org/data/2.5/weather?q={city}&units=imperial&appid={api_key}'
        city = request.form.get('city')
        api_key = os.getenv("OPENW_API_KEY") # new
        try:
            weather = requests.get(URL.format(
                city=city, api_key=api_key)).json()
        except Exception as e:
            print(f"Error in fetching data")
...

Restart your app and you would see your application is working just like before!

You can add any number of environment variables in the .env file and use them anywhere in your project!

By using environment variables, we can secure information that is private to us so that no other person can misuse it

Deploying your Flask app on Heroku

This project works fine on my laptop but -

what if i want to show it to the people online? How can I deploy my project?

That’s where heroku comes in

Heroku is a cloud platform that supports deployment of projects created in many different languages, even python!

So go ahead and create an account. After you login, you would see the screen something like this

To deploy our flask weather application, we’ll have to create a new app on heroku. So click on new

and select Create new app

after that, type in your App name and click Create app

After that scroll down to Deploying using Heroku Git section

and simply follow these steps,

Let’s deploy our app!

First log in to heroku in your terminal, When you type heroku login it will open a browser to log you in.

After you’ve logged in, make sure you are in your project root directory, type git init to initialise a git repository

Now add all the changes and commit to the main branch,

git add .
git commit -m 'pushing to heroku'

Now, set the remote as shown on the heroku website, and push your changes

heroku git:remote -a <name_of_you_app>
git push heroku main

Note: since we are using environment variables, any deployment platform does not support .env files

You’ll have to manually add your environment variables on the website in your app settings

In heroku, go over to the settings tab, you should be able to see Reveal Config Vars button, click on it.

It will now allow you to add your environment variables just as you did in your .env file!

Now if we open our app typing in the terminal,

heroku open

We see an application error!

This is because we have only pushed our application to the platform, we haven’t run it yet!

To run you python or any application on platform like these, you need to have a Procfile. **Inside a **Procfile you add all the process that you want the platform to execute.

Let’s add a Procfile to our root project folder

Note that the Procfile does not have any extension, this is super important!

And inside the procfile add this line,

Let’s also install gunicorn in our virtual environment by typing the following command in the terminal,

pipenv install gunicorn

Now follow the process to push the changes to heroku again,

git add .
git commit -m 'adding procfile'
git push heroku main

And now if you open your application,

TA-DA! our application is deployed and running online! 🥳

Now you can share what you’ve built over the course of this article with other people!

I know it was quite a long read but hope you got to learn something new, if not new then maybe a better way of doing things.

Likes and Shares would be deeply appreciated!

Please do not hesitate to message me, you can text/follow me on LinkedIn or Instagram or Twitter

Make sure you follow to not miss any future articles! 😉

And as promised, my github repository

Speed up your Code!!!

Kaushal Sharma — Tue, 05 Apr 2022 05:21:26 +0000

One of the methods to speed up your applications could be to implement Caching.

Caching not only speeds up the response time for the users but it also reduces the resourse usage on the system making them efficient.

But what is caching?

In simple terms, Caching means storing frequently demanded things closer to those asking for it

Let’s take a look at a simple analogy very beautifully depicted in this youtube video about caching.

Suppose you want to write an article about a certain topic and want to access books from the library for the content.

Now, you could go to the library every time you want to look at some piece of information from the books but that would be a very expensive operation. Travelling from your home to the library, searching for the book, noting down the content, travelling back to your home, and repeating this whole process again and again.

What you can do however, is that you can borrow these books from the library and take them home with you.

So now, everytime you need to lookup some content from the books, they are right there within an arm’s reach at your house.

In this analogy, the library sort of acts as a hard drive which has a lot of contents(books) saved in it but accessing it frequently would be rather expensive. And your house acts like a cache, where you have only the books you’ll need to look up frequently for information and accessing which is relatively cheap.

Python comes with a built-in module called functools which contains higher order functions which either take other functions as arguments or return other functions.

The functools module also contains some higher order functions like lru_cache for caching which we’ll take a look later in the article.

For now, let’s try to implement a simple cache all by ourselves in python!

Save the below code in a .py file and try executing it. Let’s see what output do we get.

import requests

cache = dict()

def get_article_from_server(url):
    print("Fetching article from server...")
    response = requests.get(url)
    return response.text

def get_article(url):
    print("Getting article...")
    if url not in cache:
        cache[url] = get_article_from_server(url)

    return cache[url]

get_article("https://realpython.com/sorting-algorithms-python/")
get_article("https://realpython.com/sorting-algorithms-python/")
get_article("https://realpython.com/sorting-algorithms-python/")
get_article("https://realpython.com/sorting-algorithms-python/")

When we run the above code, we get the below output.

See how,

Fetching article from server. . .

is printed only one time and that is the first time?

That’s because once we have fetched the article, we are saving it in the cache we created before sending it as a response in the function get_article.

Hence for the subsequent calls to the same article, we don’t have to fetch it from the server/internet, we can just read the contents we saved in cache earlier and return the result.

But we can’t just build a cache from scratch everytime we need to use it. The cache we implemented above was relatively simple but what if we need more complex caching mechanisms? Thankfully python comes with some built-in functions/decorators that will help us do just that!

Let’s take the problem of calculating factorial of a number.
Below is what a simple code to calculate factorial will look like.

def factorial(n):
    return n * factorial(n-1) if n else 1

But the problem with this code is that, for each new value of n it will re-calculate the values.

What do I mean by that is that if i calculate the factorial of 7 then i get 5040 as the output which was calculated by 7x6x5x4x3x2x1

But now if I calculate factorial of 5, it will re-calculate 5x4x3x2x1 which it had already calculated earlier while calculating factorial of 7.

These calculations can be stored in the cache and retreived without having to re-calculate again thereby saving computing resource and time making the overall system efficient!

Let’s now modify the code to use cache instead.

from functools import cache

@cache
def factorial(n):
    return n * factorial(n-1) if n else 1

If we call factorial(10), the function will make 11 recursive calls since the cache is empty. But if we call factorial(5) after this, the code won’t do any calculations at all, it will just look up the value in the cache and return it.

And if we call factorial(12), the code will only make two recursive calls for 11 and 12 since the values up to 10 were already stored in the cache.

Great! now we know how we can create a cache and apply it to a function which does some expensive operations so that we can speed up our code and make it more computationally efficient.

Let’s take a little detour and revisit the library example . . .

You kept researching topics one after the other and as a result have bought home more books that you can keep!

In terms of caching, what has happened here is that your cache has grown indefinitely.

The purpose of cache is to be small and only store some of the data that is being frequently accessed by the users, having your cache grow as big as your hard disk defeats it’s purpose as it will be significantly expensive to maintain this cache.

So, what we need now is a mechanism or policy that would remove content/information from the cache which has lost it's relevance and is not accessed as frequently anymore. That is, we need some policy that would help us off-load some of the books stored in our house back to the library. This is where cache eviction policies come in.

Cache Eviction Policies

There are many such strategies defined that will clear out your cache and maintain it’s size keeping it from growing indefinitely. let’s look at a brief of some of those policies.

First-In First-Out (FIFO) - The entires that gets added to the cache first, gets deleted first. That is, it evicts the oldest entries.
Last-In First-Out (LIFO) - The entires that gets added to the cache last or the newest entries, gets deleted first. That is, it evicts the newest entries.
Least Recently Used (LRU) - The entries that haven’t been used in a long time gets evicted from the cache.
Most Recently Used (MRU) - The entry that was used most recently gets evicted from the cache.
Least Frequently Used (LFU) - The entries that don’t get accessed too often gets evicted from the cache.

Let’s take a look at the working of LRU in a bit of detail . . .

When you implement a cache with LRU strategy, it organises it’s items in the way they are being used by the users.

Everytime you access an entry in the cache, the LRU algorithm will move this entry to the top(most recently used) of the cache.

Now when the algorithm looks at the cache, it knows that the entries at the bottom are stale and not being used by the users anymore hence it can be safely removed from the cache to make way for newer entries.

Take a look at the below image.

Here, when the user fetches article 1, the cache stores the article as most recent then serves it to the user.

Now when the user request another article. . .

The cache assigns the article 2 as most recent and pushes the article 1 down the list.

In this way the LRU strategy identifies which entries need to be evicted from the cache so that the size of the cache can be managed.

Let’s try implementing LRU strategy with the example of calculating fibonacci numbers

Below is what a simple code to calculate fibonacci numbers would look like

def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Since this is a recursive function, for a large value of n this function would become computationally heavy.

Let’s implement a cache on this function with LRU strategy.

from functools import lru_cache

@lru_cache(maxsize=16)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Similar to what we saw earlier, we can use the lru_cache decorator from functools built-in library to implement cache with the LRU eviction strategy.

Here maxsize parameter defines the maximum size the cache can grow to.

Now, if we call this function and get it’s cache info, we would get the output something like this.

Here,

hits - the number of call that were returned from the cache

misses - the number of calls that didn’t exist in the cache and had to be calculated

maxsize - the maximum size of the cache. Since we defined out maxsize to be 16 it shows the same in the output

currsize - the current size of the cache. Here we can see the cache is full

To sum up

caching not only reduces the computing resource on your system but also makes your code run faster.

Implementing caching in your code can drastically improve the user experience by giving the quick and optimal results.

Sources

Write clean, reusable, and modular code

Kaushal Sharma — Thu, 17 Mar 2022 11:28:40 +0000

If you’ve ever searched for a job in tech or you’re just starting to code and looking for your first job and see -

Must be able to write clean, maintainable and reusable code

In the top one or two bullet points of the requirements and not know how to do it?
What recruiters are basically asking is, “Can you write modular code”

But what is Modular Programming and why should you care about it?

Modular programming means breaking up your code into small chunks, that often repeat itself over the lifetime of your code execution, into small and manageable modules which can be split across different files.

And to answer why should you care about it?

Well, Apart from breaking up one large problem into smaller, more feasible problems, additional reasons to make your code modular are -

It makes your code more Maintainable - Ideally each module you create would be designed to tackle a certain singular problem, hence reducing the interdependency between each module. Therefore, if you were to make some changes in Module1, Module2 or the rest of your code would remain unaffected for the most part. This also facilitates collaboration between a team of programmer where each programmer can focus on one module at a time and making debugging a whole lot easier!

You can Reuse your code across different modules, even projects! - Since your module would tackle a single problem independently, it is possible to use this module in other modules or even projects where you face the same problem statement making your code DRY(Do not Repeat Yourself), one of the many important software engineering principles.

Variable Scoping - Creating different modules and splitting them into different functions or even files allows you to use the same variable name, avoiding a debugging nightmare from spaghetti code!

But wait, you’ve already tried and it did not work? here’s why

Because you may have forgotten to add your project directory to the list of directories the python interpreter searches for modules in!
Which brings us to the next topic -

Module Search Path

One thing to note is that, the location of the module that you have created, should be present in the PYTHONPATH environment variable.
The reason for this is whenever you “import” a module, the python interpreter will search for that module in list of directories. This list of directories contains
- the current script’s directory,
- all the directories present in the PYTHONPATH variable
- the installation dependent directories which would’ve been configured at the time of python installation.

Let’s see what we’ve read till now in action

Project Root -

Go to your project root directory

Checking all the directories present in the list of directories of sys module. We see that our project root is missing here.

Adding Project Root to sys.path

Using the os built-in module, since we are already in our project root, we add the current working directory to the list of directories present in sys

Now we’ve added our project root to the list of directories and we can proceed to import the modules!

Now, when you type import, the interpreter should automatically show you the modules/directories available to import. Here we see both the directories we created(dir1 and dir2) which contain their respective modules.

After selecting dir1 and adding a period(.), you should be able to see all the modules/directories contained in this directory. Here we see two modules, main and module1.

Using the module

After importing the module1 from dir1 and giving it an alias as mod1, we can use all of the module1’s objects in our current script!

We can use the string object defined by variable a, as well as the function defined in the module1

Similarly, we can import another module and use all of it’s objects in our current code

In such a way, we can structure our code better so changing or update in any single module does not breaks other modules.

Creating different modules for your code instead of just blurting it out in a single script also allows for ease in unit testing, which is also a primary requirement in many places.

Now off you go writing clean and maintainable code!