Description
Reads the key,value pair from .env and adds them to environment variable. It is great of managing app settings during development and in production using 12-factor principles.
python-dotenv alternatives and similar packages
Based on the "Configuration" category.
Alternatively, view python-dotenv alternatives based on common mentions on social networks and blogs.
-
django-environ
Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. -
django-split-settings
Organize Django settings into multiple files and directories. Easily override and modify settings. Use wildcards and optional settings files. -
parse_it
A python library for parsing multiple types of config files, envvars & command line arguments that takes the headache out of setting app configurations.
InfluxDB - Power Real-Time Data Analytics at Scale
![InfluxDB Logo InfluxDB Logo](https://cdn-b.libhunt.com/images/promo-campaign-images/000/000/021/main.png?1663900378)
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of python-dotenv or a related project?
README
python-dotenv
Python-dotenv reads key-value pairs from a .env
file and can set them as environment
variables. It helps in the development of applications following the
12-factor principles.
- Getting Started
- Other Use Cases
- Command-line Interface
- File format
- Related Projects
- Acknowledgements
Getting Started
pip install python-dotenv
If your application takes its configuration from environment variables, like a 12-factor application, launching it in development is not very practical because you have to set those environment variables yourself.
To help you with that, you can add Python-dotenv to your application to make it load the
configuration from a .env
file when it is present (e.g. in development) while remaining
configurable via the environment:
from dotenv import load_dotenv
load_dotenv() # take environment variables from .env.
# Code of your application, which uses environment variables (e.g. from `os.environ` or
# `os.getenv`) as if they came from the actual environment.
By default, load_dotenv
doesn't override existing environment variables.
To configure the development environment, add a .env
in the root directory of your
project:
.
├── .env
└── foo.py
The syntax of .env
files supported by python-dotenv is similar to that of Bash:
# Development settings
DOMAIN=example.org
ADMIN_EMAIL=admin@${DOMAIN}
ROOT_URL=${DOMAIN}/app
If you use variables in values, ensure they are surrounded with {
and }
, like
${DOMAIN}
, as bare variables such as $DOMAIN
are not expanded.
You will probably want to add .env
to your .gitignore
, especially if it contains
secrets like a password.
See the section "File format" below for more information about what you can write in a
.env
file.
Other Use Cases
Load configuration without altering the environment
The function dotenv_values
works more or less the same way as load_dotenv
, except it
doesn't touch the environment, it just returns a dict
with the values parsed from the
.env
file.
from dotenv import dotenv_values
config = dotenv_values(".env") # config = {"USER": "foo", "EMAIL": "[email protected]"}
This notably enables advanced configuration management:
import os
from dotenv import dotenv_values
config = {
**dotenv_values(".env.shared"), # load shared development variables
**dotenv_values(".env.secret"), # load sensitive variables
**os.environ, # override loaded values with environment variables
}
Parse configuration as a stream
load_dotenv
and dotenv_values
accept streams via their stream
argument. It is thus possible to load the variables from sources other than the
filesystem (e.g. the network).
from io import StringIO
from dotenv import load_dotenv
config = StringIO("USER=foo\[email protected]")
load_dotenv(stream=config)
Load .env files in IPython
You can use dotenv in IPython. By default, it will use find_dotenv
to search for a
.env
file:
%load_ext dotenv
%dotenv
You can also specify a path:
%dotenv relative/or/absolute/path/to/.env
Optional flags:
-o
to override existing variables.-v
for increased verbosity.
Command-line Interface
A CLI interface dotenv
is also included, which helps you manipulate the .env
file
without manually opening it.
$ pip install "python-dotenv[cli]"
$ dotenv set USER foo
$ dotenv set EMAIL [email protected]
$ dotenv list
USER=foo
[email protected]
$ dotenv list --format=json
{
"USER": "foo",
"EMAIL": "[email protected]"
}
$ dotenv run -- python foo.py
Run dotenv --help
for more information about the options and subcommands.
File format
The format is not formally specified and still improves over time. That being said,
.env
files should mostly look like Bash files.
Keys can be unquoted or single-quoted. Values can be unquoted, single- or double-quoted.
Spaces before and after keys, equal signs, and values are ignored. Values can be followed
by a comment. Lines can start with the export
directive, which does not affect their
interpretation.
Allowed escape sequences:
- in single-quoted values:
\\
,\'
- in double-quoted values:
\\
,\'
,\"
,\a
,\b
,\f
,\n
,\r
,\t
,\v
Multiline values
It is possible for single- or double-quoted values to span multiple lines. The following examples are equivalent:
FOO="first line
second line"
FOO="first line\nsecond line"
Variable without a value
A variable can have no value:
FOO
It results in dotenv_values
associating that variable name with the value None
(e.g.
{"FOO": None}
. load_dotenv
, on the other hand, simply ignores such variables.
This shouldn't be confused with FOO=
, in which case the variable is associated with the
empty string.
Variable expansion
Python-dotenv can interpolate variables using POSIX variable expansion.
With load_dotenv(override=True)
or dotenv_values()
, the value of a variable is the
first of the values defined in the following list:
- Value of that variable in the
.env
file. - Value of that variable in the environment.
- Default value, if provided.
- Empty string.
With load_dotenv(override=False)
, the value of a variable is the first of the values
defined in the following list:
- Value of that variable in the environment.
- Value of that variable in the
.env
file. - Default value, if provided.
- Empty string.
Related Projects
- Honcho - For managing Procfile-based applications.
- django-dotenv
- django-environ
- django-environ-2
- django-configuration
- dump-env
- environs
- dynaconf
- parse_it
Acknowledgements
This project is currently maintained by Saurabh Kumar and Bertrand Bonnefoy-Claudet and would not have been possible without the support of these awesome people.