environment-variables

Environment variables

Enum style access to environment variables with type annotations

~ Av vars och env efter förmåga, åt vars och env efter behov ~

The package is hosted at PyPI

Documentation

The documentation can be found on ReadTheDocs

Requirements

This package supports Python 3.7 or later

Installation

Install using pip:

$ pip install environment-variables

Usage

Define your environment variables as class attributes with type annotation:

from environment_variables import environment_variables


@environment_variables
class Environment:
    MY_VARIABLE: str
    MY_INTEGER: int = 10
    MY_FEATURE_FLAG: bool = False

When accessing a class attribute, the class will automatically check the system for a environment variable of the same name and return its value cast to the annotated type. If it is not defined, the default value will be used instead.

It is also possible to annotate a class attribute with any class using the variables function:

from environment_variables import environment_variables, variable


@environment_variables
class Environment:
    MY_VARIABLE: CustomClass = variable(
        CustomClass,
        default='some default value',
        default_factory=custom_class_factory,
        args=(1, 2, 3,),
        kwargs={'more_custom': True},
    )

The problem this is trying to solve

When configuring a python program with environment variables, one would typically access them in a fashion similar to this:

import os

my_value = os.getenv('MY_VALUE', default=123)

This leaves a lot of strings lying around in the code, and it gets hard to keep track on which values are being used and what variables are needed to be set when. A better approach would be to collect everything in a config file:

import os

class MyConfig:
    @classmethod
    def get_my_value(cls, default):
        return os.getenv('MY_VALUE', default=default)

This makes it slightly easier to keep track of, but we are still using strings that we have to keep track of. An even better approach would be to use Enums:

import os
import enum

class MyVariables(enum.Enum):
    MY_VALUE = 'MY_VALUE'

class MyConfig:
    @classmethod
    def get_my_value(cls, default):
        return os.getenv(MyVariables.MY_VALUE.value, default=default)

Much better, now we can just look at the enum to see what variables we have, but there is a lot of boilerplate code. For instance, do we really have to write out 'MY_VALUE' twice in the enum definition? It would be much more convenient to have the 'MyVaribles' class understand that the attribute name should be the environment variable to look for, instead of having to specify the string name of the variable again.

On top of that, os.getenv always returns strings, so we would have to take care of the type casting ourselves if we want to have server ports as integers or feature flags as booleans.