Forem: Raghavendra Khare

What are environment variables and how to manage them in Python?

Raghavendra Khare — Fri, 04 Feb 2022 17:25:32 +0000

As beginner software developers, we often come accross term "environment variables". In this blog post, I will try to explain what are environment variables and how you can manage them in your Python project dev environment. Let's get started.
Note: The blog follows Ubuntu workflow which can be easily replicated in MacOS/Windows with slight variations.

What are environment variables?

A quick google search will land you up to this definition of environment variables from Wikipedia,

An environment variable is a dynamic-named value that can affect the way running processes will behave on a computer. They are part of the environment in which a process runs.

Think of environment variables as system-wide variables which may store location or values of resources held by the system. Environment variables can be system defined as well as user defined too.

If you are using MacOS/Linux open your terminal and run command,

$ printenv

which will quickly show you all environment variables present in your system. These are some resource values which are used by programs running on your system.

What is the use of environment variables?

While developing our projects, our projects can contain various confidential information which can not be made public to prevent integrity violation of our app. For example, if you have used Django you may know about secret key it uses for signing session cookies which is fundamental to application security. Secret keys/signatures are used while dealing with JWT tokens in web authorisation paradigm which should stay confidential.
These values should not be stored in codebase or program files as they might end up getting checked/committed into version control systems which poses a threat to system integrity.
In a production environment these varibles are set on the system/server running the app instance. We can set up these variables as environment variables in our local development system but it is an unnecessary hassle and can be avoided.

What is the way around?

There are various ways to managing environment variables in local development environment. Here, I will display one of the methods.

Create a .env file and store your secrets in it.
Include .env in your .gitignore to prevent it from getting checked into your version control system.
An example .env file might look like this:

ALGORITHM=HS256
SECRET_KEY=fajhfkaheufahfjbavaeua26472647yhf93h84go84g7fefaefavaegaebartttb
ACCESS_TOKEN_EXPIRE_MINUTES=30

Now we need a way to access these values in our Python program files. Here, we are going to use a Python library called Pydantic to manage our enviroment variables.
Go ahead and install "Pydantic" library by executing command pip install pydantic.
Create a file called config.py.
Inside config.py import BaseSettings from pydantic library and create a class Settings which inherits from BaseSettings.
Inside this class, type out the environment variable name and their datatype with a : in between.
Create a class inside class Settings with name Config and define a variable called env_file = ".env" which stores the name of your file containing values of secrets we created earlier. -An example config.py file would look like this:

from pydantic import BaseSettings

class Settings(BaseSettings):
    secret_key: str
    algorithm: str
    access_token_expire_minutes: int

    class Config:
        env_file = ".env"


settings = Settings()

You can also define a default values for these parameters too. Example: access_token_expire_minutes: int = 30
Instantiate the class Settings as shown in example above.
Now open the file which contains requires these secret values and import this settings object in that file by typing from .config import settings.
Now we can assign values of the variables as :

ALGORITHM = settings.algorithm

Similarly do this for all other variables present in your project.
You are done! Voila!

You have successfully avoided pushing your project secrets to version control system and have setup your local development enviroment without messing your OS installation.

Do leave a thumbs up if this was helpful. Suggestions are always welcome! Thanks for reading.

How to get started with Pipenv?

Raghavendra Khare — Sun, 29 Aug 2021 05:26:46 +0000

*This blog has been republished from Hashnode blog.
In this blog post I will discuss how to get started with Pipenv - a python packaging tool. The blog post follows Ubuntu workflow which can be easily replicated in MacOS and Windows. Let's get started.

What is Pipenv ?

Pipenv is a python packaging tool for Python and an upgrade over using Pip , Venv and requirements.txt . Pipenv is a great way to combine package management with virtual environments.

Why do we need Package Management and Virtual environments?

According to Wlkipedia ,

A package manager or package-management system is a collection of software tools that automates the process of installing, upgrading, configuring, and removing computer programs for a computer's operating system in a consistent manner.

A package manager automates the process of installing, uninstalling, maintaining a package. This helps developers easily manage a project's dependencies.

You can read more about package managers here.

Now let's discuss virtual environments,

A virtual environment is a self-contained directory tree that contains a Python installation for a particular version of Python, plus a number of additional packages.

A virtual environment enables us to have a specific unique python installation for each project. This prevents us from overloading the global python installation and enables us to use different versions of python for each project.
A python virtual environment also helps segregate individual dependencies for each project and prevents code from breaking in case if any project was specifically configured to a version of Python.
You can read about virtual environments in detail here.

Now, that we understand what are package managers and why we need them let's get started with installation of Pipenv.

How to install Pipenv?

To install pipenv, open a terminal window and run the following command:

$ pip install pipenv

How to create a virtual environment using PIpenv?

Navigate into the directory you want to create a virtual environment in and open a terminal window and type the following command.

$ mkdir my_project
$ cd my_project/
$ pipenv install

How to start a virtual environment using PIpenv?

To start a virtual environment, type the following command while being in the directory.

$ pipenv shell

You will see a project name within parenthesis indicating we have successfully entered the required python virtual environment.

To exit the virtual environment we can type,

$ exit

How to check the which Python installation is in active use ?

To check which python installation in use we can use the following 3 methods,

Method 1:

While the python shell is active type the following command,

$ which python

This will return the path of current python environment in active use.

Method 2:

Type this in an active python shell,

$ import sys
$ sys.executable

This will return the path of python installation in active use.

Method 3:

To find path of executable without activating shell following command can we used :

$ pipenv --venv

How to install packages using Pipenv?

Type the following code to install a package usign Pipenv.

$ pipenv install <package-name>

How to run a Python command without activating virtual environment within the current environment?

$ pipenv run python

To run a file, use the following command:

$ pipenv run  python <file-name>

How to use requirements.txt file with Pipenv?

To install dependencies and packages using pip's requirements.txt , use the following command:

$ pipenv install -r <path-of-requirements.txt>

How to create a requirements.txt using Pipenv?

Following command can be used to generate the content of requirements.txt :

$ pipenv lock -r

To create a requirements.txt we can redirect this output to our requirements.txt :

$ pipenv lock -r > requirements.txt

How to uninstall a package using Pipenv?

Following command can be used to uninstall a package using pipenv :

$ pipenv uninstall <package-name>

To uninstall all packages use -all flag.

How to remove a virtual environment using Pipenv?

Following command can be used to safely remove a package using pipenv :

$ pipenv -rm

Additional points to know about Pipenv :

By default, pipenv install virtual environments at ~/.local/share/virtualenvs/.
To install a package that shouldn't be included in production build we can use --dev flag at end of install command.
To check security vulnerabilities in a virtual environment we can use following command :
$ pipenv check .
All dependencies of project can be tracked using following command:
$ pipenv graph.

This was first blog on pipenv and I will be writing in detail on pipenv in a few more blogs.

Do leave a thumbs up if this was helpful.
You can follow me on twitter @raghavxk to stay posted about my future blogs.
Thanks for reading!