pax_global_header00006660000000000000000000000064140636674720014531gustar00rootroot0000000000000052 comment=97615cdcd0b6c6ffcf18b272598e82bfa3a18938 python-dotenv-0.18.0/000077500000000000000000000000001406366747200144355ustar00rootroot00000000000000python-dotenv-0.18.0/.editorconfig000066400000000000000000000003631406366747200171140ustar00rootroot00000000000000# see: http://editorconfig.org root = true [*] charset = utf-8 end_of_line = lf insert_final_newline = true trim_trailing_whitespace = true [*.{py,rst,ini}] indent_style = space indent_size = 4 [*.yml] indent_style = space indent_size = 2 python-dotenv-0.18.0/.github/000077500000000000000000000000001406366747200157755ustar00rootroot00000000000000python-dotenv-0.18.0/.github/workflows/000077500000000000000000000000001406366747200200325ustar00rootroot00000000000000python-dotenv-0.18.0/.github/workflows/release.yml000066400000000000000000000010721406366747200221750ustar00rootroot00000000000000name: Upload Python Package on: release: types: [created] jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: '3.x' - name: Install dependencies run: | python -m pip install --upgrade pip pip install setuptools wheel twine - name: Build and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | make release python-dotenv-0.18.0/.github/workflows/test.yml000066400000000000000000000011451406366747200215350ustar00rootroot00000000000000name: Run Tests on: [push, pull_request] jobs: test: runs-on: ${{ matrix.os }} strategy: max-parallel: 8 matrix: os: - ubuntu-latest python-version: [2.7, 3.5, 3.6, 3.7, 3.8, 3.9, pypy2, pypy3] steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install tox tox-gh-actions - name: Test with tox run: tox python-dotenv-0.18.0/.gitignore000066400000000000000000000030251406366747200164250ustar00rootroot00000000000000.DS_Store .idea # Created by https://www.gitignore.io/api/python # Edit at https://www.gitignore.io/?templates=python ### Python ### # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ ### Python Patch ### .venv/ # End of https://www.gitignore.io/api/python python-dotenv-0.18.0/CHANGELOG.md000066400000000000000000000225161406366747200162540ustar00rootroot00000000000000# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [0.18.0] - 2021-06-20 ### Changed - Raise `ValueError` if `quote_mode` isn't one of `always`, `auto` or `never` in `set_key` (#330 by [@bbc2]). - When writing a value to a .env file with `set_key` or `dotenv set ` (#330 by [@bbc2]): - Use single quotes instead of double quotes. - Don't strip surrounding quotes. - In `auto` mode, don't add quotes if the value is only made of alphanumeric characters (as determined by `string.isalnum`). ## [0.17.1] - 2021-04-29 ### Fixed - Fixed tests for build environments relying on `PYTHONPATH` (#318 by [@befeleme]). ## [0.17.0] - 2021-04-02 ### Changed - Make `dotenv get ` only show the value, not `key=value` (#313 by [@bbc2]). ### Added - Add `--override`/`--no-override` option to `dotenv run` (#312 by [@zueve] and [@bbc2]). ## [0.16.0] - 2021-03-27 ### Changed - The default value of the `encoding` parameter for `load_dotenv` and `dotenv_values` is now `"utf-8"` instead of `None` (#306 by [@bbc2]). - Fix resolution order in variable expansion with `override=False` (#287 by [@bbc2]). ## [0.15.0] - 2020-10-28 ### Added - Add `--export` option to `set` to make it prepend the binding with `export` (#270 by [@jadutter]). ### Changed - Make `set` command create the `.env` file in the current directory if no `.env` file was found (#270 by [@jadutter]). ### Fixed - Fix potentially empty expanded value for duplicate key (#260 by [@bbc2]). - Fix import error on Python 3.5.0 and 3.5.1 (#267 by [@gongqingkui]). - Fix parsing of unquoted values containing several adjacent space or tab characters (#277 by [@bbc2], review by [@x-yuri]). ## [0.14.0] - 2020-07-03 ### Changed - Privilege definition in file over the environment in variable expansion (#256 by [@elbehery95]). ### Fixed - Improve error message for when file isn't found (#245 by [@snobu]). - Use HTTPS URL in package meta data (#251 by [@ekohl]). ## [0.13.0] - 2020-04-16 ### Added - Add support for a Bash-like default value in variable expansion (#248 by [@bbc2]). ## [0.12.0] - 2020-02-28 ### Changed - Use current working directory to find `.env` when bundled by PyInstaller (#213 by [@gergelyk]). ### Fixed - Fix escaping of quoted values written by `set_key` (#236 by [@bbc2]). - Fix `dotenv run` crashing on environment variables without values (#237 by [@yannham]). - Remove warning when last line is empty (#238 by [@bbc2]). ## [0.11.0] - 2020-02-07 ### Added - Add `interpolate` argument to `load_dotenv` and `dotenv_values` to disable interpolation (#232 by [@ulyssessouza]). ### Changed - Use logging instead of warnings (#231 by [@bbc2]). ### Fixed - Fix installation in non-UTF-8 environments (#225 by [@altendky]). - Fix PyPI classifiers (#228 by [@bbc2]). ## [0.10.5] - 2020-01-19 ### Fixed - Fix handling of malformed lines and lines without a value (#222 by [@bbc2]): - Don't print warning when key has no value. - Reject more malformed lines (e.g. "A: B", "a='b',c"). - Fix handling of lines with just a comment (#224 by [@bbc2]). ## [0.10.4] - 2020-01-17 ### Added - Make typing optional (#179 by [@techalchemy]). - Print a warning on malformed line (#211 by [@bbc2]). - Support keys without a value (#220 by [@ulyssessouza]). ## 0.10.3 - Improve interactive mode detection ([@andrewsmith])([#183]). - Refactor parser to fix parsing inconsistencies ([@bbc2])([#170]). - Interpret escapes as control characters only in double-quoted strings. - Interpret `#` as start of comment only if preceded by whitespace. ## 0.10.2 - Add type hints and expose them to users ([@qnighy])([#172]) - `load_dotenv` and `dotenv_values` now accept an `encoding` parameter, defaults to `None` ([@theskumar])([@earlbread])([#161]) - Fix `str`/`unicode` inconsistency in Python 2: values are always `str` now. ([@bbc2])([#121]) - Fix Unicode error in Python 2, introduced in 0.10.0. ([@bbc2])([#176]) ## 0.10.1 - Fix parsing of variable without a value ([@asyncee])([@bbc2])([#158]) ## 0.10.0 - Add support for UTF-8 in unquoted values ([@bbc2])([#148]) - Add support for trailing comments ([@bbc2])([#148]) - Add backslashes support in values ([@bbc2])([#148]) - Add support for newlines in values ([@bbc2])([#148]) - Force environment variables to str with Python2 on Windows ([@greyli]) - Drop Python 3.3 support ([@greyli]) - Fix stderr/-out/-in redirection ([@venthur]) ## 0.9.0 - Add `--version` parameter to cli ([@venthur]) - Enable loading from current directory ([@cjauvin]) - Add 'dotenv run' command for calling arbitrary shell script with .env ([@venthur]) ## 0.8.1 - Add tests for docs ([@Flimm]) - Make 'cli' support optional. Use `pip install python-dotenv[cli]`. ([@theskumar]) ## 0.8.0 - `set_key` and `unset_key` only modified the affected file instead of parsing and re-writing file, this causes comments and other file entact as it is. - Add support for `export` prefix in the line. - Internal refractoring ([@theskumar]) - Allow `load_dotenv` and `dotenv_values` to work with `StringIO())` ([@alanjds])([@theskumar])([#78]) ## 0.7.1 - Remove hard dependency on iPython ([@theskumar]) ## 0.7.0 - Add support to override system environment variable via .env. ([@milonimrod](https://github.com/milonimrod)) ([\#63](https://github.com/theskumar/python-dotenv/issues/63)) - Disable ".env not found" warning by default ([@maxkoryukov](https://github.com/maxkoryukov)) ([\#57](https://github.com/theskumar/python-dotenv/issues/57)) ## 0.6.5 - Add support for special characters `\`. ([@pjona](https://github.com/pjona)) ([\#60](https://github.com/theskumar/python-dotenv/issues/60)) ## 0.6.4 - Fix issue with single quotes ([@Flimm]) ([\#52](https://github.com/theskumar/python-dotenv/issues/52)) ## 0.6.3 - Handle unicode exception in setup.py ([\#46](https://github.com/theskumar/python-dotenv/issues/46)) ## 0.6.2 - Fix dotenv list command ([@ticosax](https://github.com/ticosax)) - Add iPython Suport ([@tillahoffmann](https://github.com/tillahoffmann)) ## 0.6.0 - Drop support for Python 2.6 - Handle escaped charaters and newlines in quoted values. (Thanks [@iameugenejo](https://github.com/iameugenejo)) - Remove any spaces around unquoted key/value. (Thanks [@paulochf](https://github.com/paulochf)) - Added POSIX variable expansion. (Thanks [@hugochinchilla](https://github.com/hugochinchilla)) ## 0.5.1 - Fix find\_dotenv - it now start search from the file where this function is called from. ## 0.5.0 - Add `find_dotenv` method that will try to find a `.env` file. (Thanks [@isms](https://github.com/isms)) ## 0.4.0 - cli: Added `-q/--quote` option to control the behaviour of quotes around values in `.env`. (Thanks [@hugochinchilla](https://github.com/hugochinchilla)). - Improved test coverage. [#78]: https://github.com/theskumar/python-dotenv/issues/78 [#121]: https://github.com/theskumar/python-dotenv/issues/121 [#148]: https://github.com/theskumar/python-dotenv/issues/148 [#158]: https://github.com/theskumar/python-dotenv/issues/158 [#170]: https://github.com/theskumar/python-dotenv/issues/170 [#172]: https://github.com/theskumar/python-dotenv/issues/172 [#176]: https://github.com/theskumar/python-dotenv/issues/176 [#183]: https://github.com/theskumar/python-dotenv/issues/183 [@Flimm]: https://github.com/Flimm [@alanjds]: https://github.com/alanjds [@altendky]: https://github.com/altendky [@andrewsmith]: https://github.com/andrewsmith [@asyncee]: https://github.com/asyncee [@bbc2]: https://github.com/bbc2 [@befeleme]: https://github.com/befeleme [@cjauvin]: https://github.com/cjauvin [@earlbread]: https://github.com/earlbread [@ekohl]: https://github.com/ekohl [@elbehery95]: https://github.com/elbehery95 [@gergelyk]: https://github.com/gergelyk [@gongqingkui]: https://github.com/gongqingkui [@greyli]: https://github.com/greyli [@jadutter]: https://github.com/jadutter [@qnighy]: https://github.com/qnighy [@snobu]: https://github.com/snobu [@techalchemy]: https://github.com/techalchemy [@theskumar]: https://github.com/theskumar [@ulyssessouza]: https://github.com/ulyssessouza [@venthur]: https://github.com/venthur [@x-yuri]: https://github.com/x-yuri [@yannham]: https://github.com/yannham [@zueve]: https://github.com/zueve [Unreleased]: https://github.com/theskumar/python-dotenv/compare/v0.18.0...HEAD [0.18.0]: https://github.com/theskumar/python-dotenv/compare/v0.17.1...v0.18.0 [0.17.1]: https://github.com/theskumar/python-dotenv/compare/v0.17.0...v0.17.1 [0.17.0]: https://github.com/theskumar/python-dotenv/compare/v0.16.0...v0.17.0 [0.16.0]: https://github.com/theskumar/python-dotenv/compare/v0.15.0...v0.16.0 [0.15.0]: https://github.com/theskumar/python-dotenv/compare/v0.14.0...v0.15.0 [0.14.0]: https://github.com/theskumar/python-dotenv/compare/v0.13.0...v0.14.0 [0.13.0]: https://github.com/theskumar/python-dotenv/compare/v0.12.0...v0.13.0 [0.12.0]: https://github.com/theskumar/python-dotenv/compare/v0.11.0...v0.12.0 [0.11.0]: https://github.com/theskumar/python-dotenv/compare/v0.10.5...v0.11.0 [0.10.5]: https://github.com/theskumar/python-dotenv/compare/v0.10.4...v0.10.5 [0.10.4]: https://github.com/theskumar/python-dotenv/compare/v0.10.3...v0.10.4 python-dotenv-0.18.0/CONTRIBUTING.md000066400000000000000000000005321406366747200166660ustar00rootroot00000000000000Contributing ============ All the contributions are welcome! Please open [an issue](https://github.com/theskumar/python-dotenv/issues/new) or send us a pull request. Executing the tests: $ pip install -r requirements.txt $ pip install -e . $ flake8 $ pytest or with [tox](https://pypi.org/project/tox/) installed: $ tox python-dotenv-0.18.0/LICENSE000066400000000000000000000107701406366747200154470ustar00rootroot00000000000000python-dotenv Copyright (c) 2014, Saurabh Kumar All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of python-dotenv nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. django-dotenv-rw Copyright (c) 2013, Ted Tieken All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of django-dotenv nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Original django-dotenv Copyright (c) 2013, Jacob Kaplan-Moss All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of django-dotenv nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. python-dotenv-0.18.0/MANIFEST.in000066400000000000000000000003321406366747200161710ustar00rootroot00000000000000include LICENSE *.md *.yml *.toml include tox.ini recursive-include tests *.py include .bumpversion.cfg include .coveragerc include .editorconfig include Makefile include requirements.txt include src/dotenv/py.typed python-dotenv-0.18.0/Makefile000066400000000000000000000012271406366747200160770ustar00rootroot00000000000000.PHONY: clean-pyc clean-build test clean: clean-build clean-pyc clean-build: rm -fr build/ rm -fr dist/ rm -fr src/*.egg-info clean-pyc: find . -name '*.pyc' -exec rm -f {} + find . -name '*.pyo' -exec rm -f {} + find . -name '*~' -exec rm -f {} + release: sdist twine check dist/* twine upload dist/* release-test: sdist twine upload --repository-url https://test.pypi.org/legacy/ dist/* sdist: clean python setup.py sdist bdist_wheel ls -l dist test: pip install -e . flake8 . py.test tests/ coverage: coverage run --source=dotenv --omit='*tests*' -m py.test tests/ -v --tb=native coverage report coverage-html: coverage coverage html python-dotenv-0.18.0/README.md000066400000000000000000000153221406366747200157170ustar00rootroot00000000000000# python-dotenv [![Build Status][build_status_badge]][build_status_link] [![PyPI version][pypi_badge]][pypi_link] 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](http://12factor.net/) principles. - [Getting Started](#getting-started) - [Other Use Cases](#other-use-cases) * [Load configuration without altering the environment](#load-configuration-without-altering-the-environment) * [Parse configuration as a stream](#parse-configuration-as-a-stream) * [Load .env files in IPython](#load-env-files-in-ipython) - [Command-line Interface](#command-line-interface) - [File format](#file-format) * [Multiline values](#multiline-values) * [Variable expansion](#variable-expansion) - [Related Projects](#related-projects) - [Acknowledgements](#acknowledgements) ## Getting Started ```shell 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: ```python 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: ```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. ```python from dotenv import dotenv_values config = dotenv_values(".env") # config = {"USER": "foo", "EMAIL": "foo@example.org"} ``` This notably enables advanced configuration management: ```python 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][python_streams] via their `stream` argument. It is thus possible to load the variables from sources other than the filesystem (e.g. the network). ```python from io import StringIO from dotenv import load_dotenv config = StringIO("USER=foo\nEMAIL=foo@example.org") 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: ```python %load_ext dotenv %dotenv ``` You can also specify a path: ```python %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. ```shell $ pip install "python-dotenv[cli]" $ dotenv set USER=foo $ dotenv set EMAIL=foo@example.org $ dotenv list USER=foo EMAIL=foo@example.org $ 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 has no effect on 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: ```bash FOO="first line second line" ``` ```bash FOO="first line\nsecond line" ``` ### 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](https://github.com/nickstenning/honcho) - For managing Procfile-based applications. - [django-dotenv](https://github.com/jpadilla/django-dotenv) - [django-environ](https://github.com/joke2k/django-environ) - [django-configuration](https://github.com/jezdez/django-configurations) - [dump-env](https://github.com/sobolevn/dump-env) - [environs](https://github.com/sloria/environs) - [dynaconf](https://github.com/rochacbruno/dynaconf) ## Acknowledgements This project is currently maintained by [Saurabh Kumar](https://saurabh-kumar.com) and [Bertrand Bonnefoy-Claudet](https://github.com/bbc2) and would not have been possible without the support of these [awesome people](https://github.com/theskumar/python-dotenv/graphs/contributors). [build_status_badge]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml/badge.svg [build_status_link]: https://github.com/theskumar/python-dotenv/actions/workflows/test.yml [pypi_badge]: https://badge.fury.io/py/python-dotenv.svg [pypi_link]: http://badge.fury.io/py/python-dotenv [python_streams]: https://docs.python.org/3/library/io.html python-dotenv-0.18.0/pyproject.toml000066400000000000000000000001631406366747200173510ustar00rootroot00000000000000[tool.portray] modules = ["dotenv"] [tool.portray.mkdocs] repo_url = "https://github.com/theskumar/python-dotenv" python-dotenv-0.18.0/requirements.txt000066400000000000000000000002021406366747200177130ustar00rootroot00000000000000bumpversion typing; python_version<"3.5" click flake8>=2.2.3 ipython mock pytest-cov pytest>=3.9 sh>=1.09 tox wheel twine portray python-dotenv-0.18.0/setup.cfg000066400000000000000000000011641406366747200162600ustar00rootroot00000000000000[bumpversion] current_version = 0.18.0 commit = True tag = True [bumpversion:file:src/dotenv/version.py] [bdist_wheel] universal = 1 [flake8] max-line-length = 120 exclude = .tox,.git,docs,venv,.venv [mypy] ignore_missing_imports = true [metadata] description_file = README.md [tool:pytest] testpaths = tests [coverage:run] relative_files = True source = dotenv [coverage:paths] source = src/dotenv .tox/*/lib/python*/site-packages/dotenv .tox/pypy*/site-packages/dotenv [coverage:report] show_missing = True include = */site-packages/dotenv/* exclude_lines = if IS_TYPE_CHECKING: pragma: no cover python-dotenv-0.18.0/setup.py000066400000000000000000000041621406366747200161520ustar00rootroot00000000000000# -*- coding: utf-8 -*- import io from setuptools import setup def read_files(files): data = [] for file in files: with io.open(file, encoding='utf-8') as f: data.append(f.read()) return "\n".join(data) long_description = read_files(['README.md', 'CHANGELOG.md']) meta = {} with io.open('./src/dotenv/version.py', encoding='utf-8') as f: exec(f.read(), meta) setup( name="python-dotenv", description="Read key-value pairs from a .env file and set them as environment variables", long_description=long_description, long_description_content_type='text/markdown', version=meta['__version__'], author="Saurabh Kumar", author_email="me+github@saurabh-kumar.com", url="https://github.com/theskumar/python-dotenv", keywords=['environment variables', 'deployments', 'settings', 'env', 'dotenv', 'configurations', 'python'], packages=['dotenv'], package_dir={'': 'src'}, package_data={ 'dotenv': ['py.typed'], }, install_requires=[ "typing; python_version<'3.5'", ], extras_require={ 'cli': ['click>=5.0', ], }, entry_points=''' [console_scripts] dotenv=dotenv.cli:cli ''', license='BSD-3-Clause', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: Implementation :: PyPy', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Topic :: System :: Systems Administration', 'Topic :: Utilities', 'Environment :: Web Environment', ] ) python-dotenv-0.18.0/src/000077500000000000000000000000001406366747200152245ustar00rootroot00000000000000python-dotenv-0.18.0/src/dotenv/000077500000000000000000000000001406366747200165235ustar00rootroot00000000000000python-dotenv-0.18.0/src/dotenv/__init__.py000066400000000000000000000024731406366747200206420ustar00rootroot00000000000000from .compat import IS_TYPE_CHECKING from .main import load_dotenv, get_key, set_key, unset_key, find_dotenv, dotenv_values if IS_TYPE_CHECKING: from typing import Any, Optional def load_ipython_extension(ipython): # type: (Any) -> None from .ipython import load_ipython_extension load_ipython_extension(ipython) def get_cli_string(path=None, action=None, key=None, value=None, quote=None): # type: (Optional[str], Optional[str], Optional[str], Optional[str], Optional[str]) -> str """Returns a string suitable for running as a shell script. Useful for converting a arguments passed to a fabric task to be passed to a `local` or `run` command. """ command = ['dotenv'] if quote: command.append('-q %s' % quote) if path: command.append('-f %s' % path) if action: command.append(action) if key: command.append(key) if value: if ' ' in value: command.append('"%s"' % value) else: command.append(value) return ' '.join(command).strip() __all__ = ['get_cli_string', 'load_dotenv', 'dotenv_values', 'get_key', 'set_key', 'unset_key', 'find_dotenv', 'load_ipython_extension'] python-dotenv-0.18.0/src/dotenv/cli.py000066400000000000000000000115431406366747200176500ustar00rootroot00000000000000import os import sys from subprocess import Popen try: import click except ImportError: sys.stderr.write('It seems python-dotenv is not installed with cli option. \n' 'Run pip install "python-dotenv[cli]" to fix this.') sys.exit(1) from .compat import IS_TYPE_CHECKING, to_env from .main import dotenv_values, get_key, set_key, unset_key from .version import __version__ if IS_TYPE_CHECKING: from typing import Any, List, Dict @click.group() @click.option('-f', '--file', default=os.path.join(os.getcwd(), '.env'), type=click.Path(file_okay=True), help="Location of the .env file, defaults to .env file in current working directory.") @click.option('-q', '--quote', default='always', type=click.Choice(['always', 'never', 'auto']), help="Whether to quote or not the variable values. Default mode is always. This does not affect parsing.") @click.option('-e', '--export', default=False, type=click.BOOL, help="Whether to write the dot file as an executable bash script.") @click.version_option(version=__version__) @click.pass_context def cli(ctx, file, quote, export): # type: (click.Context, Any, Any, Any) -> None '''This script is used to set, get or unset values from a .env file.''' ctx.obj = {} ctx.obj['QUOTE'] = quote ctx.obj['EXPORT'] = export ctx.obj['FILE'] = file @cli.command() @click.pass_context def list(ctx): # type: (click.Context) -> None '''Display all the stored key/value.''' file = ctx.obj['FILE'] if not os.path.isfile(file): raise click.BadParameter( 'Path "%s" does not exist.' % (file), ctx=ctx ) dotenv_as_dict = dotenv_values(file) for k, v in dotenv_as_dict.items(): click.echo('%s=%s' % (k, v)) @cli.command() @click.pass_context @click.argument('key', required=True) @click.argument('value', required=True) def set(ctx, key, value): # type: (click.Context, Any, Any) -> None '''Store the given key/value.''' file = ctx.obj['FILE'] quote = ctx.obj['QUOTE'] export = ctx.obj['EXPORT'] success, key, value = set_key(file, key, value, quote, export) if success: click.echo('%s=%s' % (key, value)) else: exit(1) @cli.command() @click.pass_context @click.argument('key', required=True) def get(ctx, key): # type: (click.Context, Any) -> None '''Retrieve the value for the given key.''' file = ctx.obj['FILE'] if not os.path.isfile(file): raise click.BadParameter( 'Path "%s" does not exist.' % (file), ctx=ctx ) stored_value = get_key(file, key) if stored_value: click.echo(stored_value) else: exit(1) @cli.command() @click.pass_context @click.argument('key', required=True) def unset(ctx, key): # type: (click.Context, Any) -> None '''Removes the given key.''' file = ctx.obj['FILE'] quote = ctx.obj['QUOTE'] success, key = unset_key(file, key, quote) if success: click.echo("Successfully removed %s" % key) else: exit(1) @cli.command(context_settings={'ignore_unknown_options': True}) @click.pass_context @click.option( "--override/--no-override", default=True, help="Override variables from the environment file with those from the .env file.", ) @click.argument('commandline', nargs=-1, type=click.UNPROCESSED) def run(ctx, override, commandline): # type: (click.Context, bool, List[str]) -> None """Run command with environment variables present.""" file = ctx.obj['FILE'] if not os.path.isfile(file): raise click.BadParameter( 'Invalid value for \'-f\' "%s" does not exist.' % (file), ctx=ctx ) dotenv_as_dict = { to_env(k): to_env(v) for (k, v) in dotenv_values(file).items() if v is not None and (override or to_env(k) not in os.environ) } if not commandline: click.echo('No command given.') exit(1) ret = run_command(commandline, dotenv_as_dict) exit(ret) def run_command(command, env): # type: (List[str], Dict[str, str]) -> int """Run command in sub process. Runs the command in a sub process with the variables from `env` added in the current environment variables. Parameters ---------- command: List[str] The command and it's parameters env: Dict The additional environment variables Returns ------- int The return code of the command """ # copy the current environment variables and add the vales from # `env` cmd_env = os.environ.copy() cmd_env.update(env) p = Popen(command, universal_newlines=True, bufsize=0, shell=False, env=cmd_env) _, _ = p.communicate() return p.returncode if __name__ == "__main__": cli() python-dotenv-0.18.0/src/dotenv/compat.py000066400000000000000000000017041406366747200203620ustar00rootroot00000000000000import sys PY2 = sys.version_info[0] == 2 # type: bool if PY2: from StringIO import StringIO # noqa else: from io import StringIO # noqa def is_type_checking(): # type: () -> bool try: from typing import TYPE_CHECKING except ImportError: return False return TYPE_CHECKING IS_TYPE_CHECKING = is_type_checking() if IS_TYPE_CHECKING: from typing import Text def to_env(text): # type: (Text) -> str """ Encode a string the same way whether it comes from the environment or a `.env` file. """ if PY2: return text.encode(sys.getfilesystemencoding() or "utf-8") else: return text def to_text(string): # type: (str) -> Text """ Make a string Unicode if it isn't already. This is useful for defining raw unicode strings because `ur"foo"` isn't valid in Python 3. """ if PY2: return string.decode("utf-8") else: return string python-dotenv-0.18.0/src/dotenv/ipython.py000066400000000000000000000024761406366747200206000ustar00rootroot00000000000000from __future__ import print_function from IPython.core.magic import Magics, line_magic, magics_class # type: ignore from IPython.core.magic_arguments import (argument, magic_arguments, # type: ignore parse_argstring) # type: ignore from .main import find_dotenv, load_dotenv @magics_class class IPythonDotEnv(Magics): @magic_arguments() @argument( '-o', '--override', action='store_true', help="Indicate to override existing variables" ) @argument( '-v', '--verbose', action='store_true', help="Indicate function calls to be verbose" ) @argument('dotenv_path', nargs='?', type=str, default='.env', help='Search in increasingly higher folders for the `dotenv_path`') @line_magic def dotenv(self, line): args = parse_argstring(self.dotenv, line) # Locate the .env file dotenv_path = args.dotenv_path try: dotenv_path = find_dotenv(dotenv_path, True, True) except IOError: print("cannot find .env file") return # Load the .env file load_dotenv(dotenv_path, verbose=args.verbose, override=args.override) def load_ipython_extension(ipython): """Register the %dotenv magic.""" ipython.register_magics(IPythonDotEnv) python-dotenv-0.18.0/src/dotenv/main.py000066400000000000000000000266301406366747200200300ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import, print_function, unicode_literals import io import logging import os import shutil import sys import tempfile from collections import OrderedDict from contextlib import contextmanager from .compat import IS_TYPE_CHECKING, PY2, StringIO, to_env from .parser import Binding, parse_stream from .variables import parse_variables logger = logging.getLogger(__name__) if IS_TYPE_CHECKING: from typing import (IO, Dict, Iterable, Iterator, Mapping, Optional, Text, Tuple, Union) if sys.version_info >= (3, 6): _PathLike = os.PathLike else: _PathLike = Text if sys.version_info >= (3, 0): _StringIO = StringIO else: _StringIO = StringIO[Text] def with_warn_for_invalid_lines(mappings): # type: (Iterator[Binding]) -> Iterator[Binding] for mapping in mappings: if mapping.error: logger.warning( "Python-dotenv could not parse statement starting at line %s", mapping.original.line, ) yield mapping class DotEnv(): def __init__(self, dotenv_path, verbose=False, encoding=None, interpolate=True, override=True): # type: (Union[Text, _PathLike, _StringIO], bool, Union[None, Text], bool, bool) -> None self.dotenv_path = dotenv_path # type: Union[Text,_PathLike, _StringIO] self._dict = None # type: Optional[Dict[Text, Optional[Text]]] self.verbose = verbose # type: bool self.encoding = encoding # type: Union[None, Text] self.interpolate = interpolate # type: bool self.override = override # type: bool @contextmanager def _get_stream(self): # type: () -> Iterator[IO[Text]] if isinstance(self.dotenv_path, StringIO): yield self.dotenv_path elif os.path.isfile(self.dotenv_path): with io.open(self.dotenv_path, encoding=self.encoding) as stream: yield stream else: if self.verbose: logger.info("Python-dotenv could not find configuration file %s.", self.dotenv_path or '.env') yield StringIO('') def dict(self): # type: () -> Dict[Text, Optional[Text]] """Return dotenv as dict""" if self._dict: return self._dict raw_values = self.parse() if self.interpolate: self._dict = OrderedDict(resolve_variables(raw_values, override=self.override)) else: self._dict = OrderedDict(raw_values) return self._dict def parse(self): # type: () -> Iterator[Tuple[Text, Optional[Text]]] with self._get_stream() as stream: for mapping in with_warn_for_invalid_lines(parse_stream(stream)): if mapping.key is not None: yield mapping.key, mapping.value def set_as_environment_variables(self): # type: () -> bool """ Load the current dotenv as system environment variable. """ for k, v in self.dict().items(): if k in os.environ and not self.override: continue if v is not None: os.environ[to_env(k)] = to_env(v) return True def get(self, key): # type: (Text) -> Optional[Text] """ """ data = self.dict() if key in data: return data[key] if self.verbose: logger.warning("Key %s not found in %s.", key, self.dotenv_path) return None def get_key(dotenv_path, key_to_get): # type: (Union[Text, _PathLike], Text) -> Optional[Text] """ Gets the value of a given key from the given .env If the .env path given doesn't exist, fails """ return DotEnv(dotenv_path, verbose=True).get(key_to_get) @contextmanager def rewrite(path): # type: (_PathLike) -> Iterator[Tuple[IO[Text], IO[Text]]] try: if not os.path.isfile(path): with io.open(path, "w+") as source: source.write("") with tempfile.NamedTemporaryFile(mode="w+", delete=False) as dest: with io.open(path) as source: yield (source, dest) # type: ignore except BaseException: if os.path.isfile(dest.name): os.unlink(dest.name) raise else: shutil.move(dest.name, path) def set_key(dotenv_path, key_to_set, value_to_set, quote_mode="always", export=False): # type: (_PathLike, Text, Text, Text, bool) -> Tuple[Optional[bool], Text, Text] """ Adds or Updates a key/value to the given .env If the .env path given doesn't exist, fails instead of risking creating an orphan .env somewhere in the filesystem """ if quote_mode not in ("always", "auto", "never"): raise ValueError("Unknown quote_mode: {}".format(quote_mode)) quote = ( quote_mode == "always" or (quote_mode == "auto" and not value_to_set.isalnum()) ) if quote: value_out = "'{}'".format(value_to_set.replace("'", "\\'")) else: value_out = value_to_set if export: line_out = 'export {}={}\n'.format(key_to_set, value_out) else: line_out = "{}={}\n".format(key_to_set, value_out) with rewrite(dotenv_path) as (source, dest): replaced = False for mapping in with_warn_for_invalid_lines(parse_stream(source)): if mapping.key == key_to_set: dest.write(line_out) replaced = True else: dest.write(mapping.original.string) if not replaced: dest.write(line_out) return True, key_to_set, value_to_set def unset_key(dotenv_path, key_to_unset, quote_mode="always"): # type: (_PathLike, Text, Text) -> Tuple[Optional[bool], Text] """ Removes a given key from the given .env If the .env path given doesn't exist, fails If the given key doesn't exist in the .env, fails """ if not os.path.exists(dotenv_path): logger.warning("Can't delete from %s - it doesn't exist.", dotenv_path) return None, key_to_unset removed = False with rewrite(dotenv_path) as (source, dest): for mapping in with_warn_for_invalid_lines(parse_stream(source)): if mapping.key == key_to_unset: removed = True else: dest.write(mapping.original.string) if not removed: logger.warning("Key %s not removed from %s - key doesn't exist.", key_to_unset, dotenv_path) return None, key_to_unset return removed, key_to_unset def resolve_variables(values, override): # type: (Iterable[Tuple[Text, Optional[Text]]], bool) -> Mapping[Text, Optional[Text]] new_values = {} # type: Dict[Text, Optional[Text]] for (name, value) in values: if value is None: result = None else: atoms = parse_variables(value) env = {} # type: Dict[Text, Optional[Text]] if override: env.update(os.environ) # type: ignore env.update(new_values) else: env.update(new_values) env.update(os.environ) # type: ignore result = "".join(atom.resolve(env) for atom in atoms) new_values[name] = result return new_values def _walk_to_root(path): # type: (Text) -> Iterator[Text] """ Yield directories starting from the given directory up to the root """ if not os.path.exists(path): raise IOError('Starting path not found') if os.path.isfile(path): path = os.path.dirname(path) last_dir = None current_dir = os.path.abspath(path) while last_dir != current_dir: yield current_dir parent_dir = os.path.abspath(os.path.join(current_dir, os.path.pardir)) last_dir, current_dir = current_dir, parent_dir def find_dotenv(filename='.env', raise_error_if_not_found=False, usecwd=False): # type: (Text, bool, bool) -> Text """ Search in increasingly higher folders for the given file Returns path to the file if found, or an empty string otherwise """ def _is_interactive(): """ Decide whether this is running in a REPL or IPython notebook """ main = __import__('__main__', None, None, fromlist=['__file__']) return not hasattr(main, '__file__') if usecwd or _is_interactive() or getattr(sys, 'frozen', False): # Should work without __file__, e.g. in REPL or IPython notebook. path = os.getcwd() else: # will work for .py files frame = sys._getframe() # find first frame that is outside of this file if PY2 and not __file__.endswith('.py'): # in Python2 __file__ extension could be .pyc or .pyo (this doesn't account # for edge case of Python compiled for non-standard extension) current_file = __file__.rsplit('.', 1)[0] + '.py' else: current_file = __file__ while frame.f_code.co_filename == current_file: assert frame.f_back is not None frame = frame.f_back frame_filename = frame.f_code.co_filename path = os.path.dirname(os.path.abspath(frame_filename)) for dirname in _walk_to_root(path): check_path = os.path.join(dirname, filename) if os.path.isfile(check_path): return check_path if raise_error_if_not_found: raise IOError('File not found') return '' def load_dotenv( dotenv_path=None, stream=None, verbose=False, override=False, interpolate=True, encoding="utf-8", ): # type: (Union[Text, _PathLike, None], Optional[_StringIO], bool, bool, bool, Optional[Text]) -> bool # noqa """Parse a .env file and then load all the variables found as environment variables. - *dotenv_path*: absolute or relative path to .env file. - *stream*: `StringIO` object with .env content, used if `dotenv_path` is `None`. - *verbose*: whether to output a warning the .env file is missing. Defaults to `False`. - *override*: whether to override the system environment variables with the variables in `.env` file. Defaults to `False`. - *encoding*: encoding to be used to read the file. If both `dotenv_path` and `stream`, `find_dotenv()` is used to find the .env file. """ f = dotenv_path or stream or find_dotenv() dotenv = DotEnv( f, verbose=verbose, interpolate=interpolate, override=override, encoding=encoding, ) return dotenv.set_as_environment_variables() def dotenv_values( dotenv_path=None, stream=None, verbose=False, interpolate=True, encoding="utf-8", ): # type: (Union[Text, _PathLike, None], Optional[_StringIO], bool, bool, Optional[Text]) -> Dict[Text, Optional[Text]] # noqa: E501 """ Parse a .env file and return its content as a dict. - *dotenv_path*: absolute or relative path to .env file. - *stream*: `StringIO` object with .env content, used if `dotenv_path` is `None`. - *verbose*: whether to output a warning the .env file is missing. Defaults to `False`. in `.env` file. Defaults to `False`. - *encoding*: encoding to be used to read the file. If both `dotenv_path` and `stream`, `find_dotenv()` is used to find the .env file. """ f = dotenv_path or stream or find_dotenv() return DotEnv( f, verbose=verbose, interpolate=interpolate, override=True, encoding=encoding, ).dict() python-dotenv-0.18.0/src/dotenv/parser.py000066400000000000000000000143401406366747200203730ustar00rootroot00000000000000import codecs import re from .compat import IS_TYPE_CHECKING, to_text if IS_TYPE_CHECKING: from typing import ( # noqa:F401 IO, Iterator, Match, NamedTuple, Optional, Pattern, Sequence, Text, Tuple ) def make_regex(string, extra_flags=0): # type: (str, int) -> Pattern[Text] return re.compile(to_text(string), re.UNICODE | extra_flags) _newline = make_regex(r"(\r\n|\n|\r)") _multiline_whitespace = make_regex(r"\s*", extra_flags=re.MULTILINE) _whitespace = make_regex(r"[^\S\r\n]*") _export = make_regex(r"(?:export[^\S\r\n]+)?") _single_quoted_key = make_regex(r"'([^']+)'") _unquoted_key = make_regex(r"([^=\#\s]+)") _equal_sign = make_regex(r"(=[^\S\r\n]*)") _single_quoted_value = make_regex(r"'((?:\\'|[^'])*)'") _double_quoted_value = make_regex(r'"((?:\\"|[^"])*)"') _unquoted_value = make_regex(r"([^\r\n]*)") _comment = make_regex(r"(?:[^\S\r\n]*#[^\r\n]*)?") _end_of_line = make_regex(r"[^\S\r\n]*(?:\r\n|\n|\r|$)") _rest_of_line = make_regex(r"[^\r\n]*(?:\r|\n|\r\n)?") _double_quote_escapes = make_regex(r"\\[\\'\"abfnrtv]") _single_quote_escapes = make_regex(r"\\[\\']") try: # this is necessary because we only import these from typing # when we are type checking, and the linter is upset if we # re-import import typing Original = typing.NamedTuple( "Original", [ ("string", typing.Text), ("line", int), ], ) Binding = typing.NamedTuple( "Binding", [ ("key", typing.Optional[typing.Text]), ("value", typing.Optional[typing.Text]), ("original", Original), ("error", bool), ], ) except (ImportError, AttributeError): from collections import namedtuple Original = namedtuple( # type: ignore "Original", [ "string", "line", ], ) Binding = namedtuple( # type: ignore "Binding", [ "key", "value", "original", "error", ], ) class Position: def __init__(self, chars, line): # type: (int, int) -> None self.chars = chars self.line = line @classmethod def start(cls): # type: () -> Position return cls(chars=0, line=1) def set(self, other): # type: (Position) -> None self.chars = other.chars self.line = other.line def advance(self, string): # type: (Text) -> None self.chars += len(string) self.line += len(re.findall(_newline, string)) class Error(Exception): pass class Reader: def __init__(self, stream): # type: (IO[Text]) -> None self.string = stream.read() self.position = Position.start() self.mark = Position.start() def has_next(self): # type: () -> bool return self.position.chars < len(self.string) def set_mark(self): # type: () -> None self.mark.set(self.position) def get_marked(self): # type: () -> Original return Original( string=self.string[self.mark.chars:self.position.chars], line=self.mark.line, ) def peek(self, count): # type: (int) -> Text return self.string[self.position.chars:self.position.chars + count] def read(self, count): # type: (int) -> Text result = self.string[self.position.chars:self.position.chars + count] if len(result) < count: raise Error("read: End of string") self.position.advance(result) return result def read_regex(self, regex): # type: (Pattern[Text]) -> Sequence[Text] match = regex.match(self.string, self.position.chars) if match is None: raise Error("read_regex: Pattern not found") self.position.advance(self.string[match.start():match.end()]) return match.groups() def decode_escapes(regex, string): # type: (Pattern[Text], Text) -> Text def decode_match(match): # type: (Match[Text]) -> Text return codecs.decode(match.group(0), 'unicode-escape') # type: ignore return regex.sub(decode_match, string) def parse_key(reader): # type: (Reader) -> Optional[Text] char = reader.peek(1) if char == "#": return None elif char == "'": (key,) = reader.read_regex(_single_quoted_key) else: (key,) = reader.read_regex(_unquoted_key) return key def parse_unquoted_value(reader): # type: (Reader) -> Text (part,) = reader.read_regex(_unquoted_value) return re.sub(r"\s+#.*", "", part).rstrip() def parse_value(reader): # type: (Reader) -> Text char = reader.peek(1) if char == u"'": (value,) = reader.read_regex(_single_quoted_value) return decode_escapes(_single_quote_escapes, value) elif char == u'"': (value,) = reader.read_regex(_double_quoted_value) return decode_escapes(_double_quote_escapes, value) elif char in (u"", u"\n", u"\r"): return u"" else: return parse_unquoted_value(reader) def parse_binding(reader): # type: (Reader) -> Binding reader.set_mark() try: reader.read_regex(_multiline_whitespace) if not reader.has_next(): return Binding( key=None, value=None, original=reader.get_marked(), error=False, ) reader.read_regex(_export) key = parse_key(reader) reader.read_regex(_whitespace) if reader.peek(1) == "=": reader.read_regex(_equal_sign) value = parse_value(reader) # type: Optional[Text] else: value = None reader.read_regex(_comment) reader.read_regex(_end_of_line) return Binding( key=key, value=value, original=reader.get_marked(), error=False, ) except Error: reader.read_regex(_rest_of_line) return Binding( key=None, value=None, original=reader.get_marked(), error=True, ) def parse_stream(stream): # type: (IO[Text]) -> Iterator[Binding] reader = Reader(stream) while reader.has_next(): yield parse_binding(reader) python-dotenv-0.18.0/src/dotenv/py.typed000066400000000000000000000000321406366747200202150ustar00rootroot00000000000000# Marker file for PEP 561 python-dotenv-0.18.0/src/dotenv/variables.py000066400000000000000000000052321406366747200210470ustar00rootroot00000000000000import re from abc import ABCMeta from .compat import IS_TYPE_CHECKING if IS_TYPE_CHECKING: from typing import Iterator, Mapping, Optional, Pattern, Text _posix_variable = re.compile( r""" \$\{ (?P[^\}:]*) (?::- (?P[^\}]*) )? \} """, re.VERBOSE, ) # type: Pattern[Text] class Atom(): __metaclass__ = ABCMeta def __ne__(self, other): # type: (object) -> bool result = self.__eq__(other) if result is NotImplemented: return NotImplemented return not result def resolve(self, env): # type: (Mapping[Text, Optional[Text]]) -> Text raise NotImplementedError class Literal(Atom): def __init__(self, value): # type: (Text) -> None self.value = value def __repr__(self): # type: () -> str return "Literal(value={})".format(self.value) def __eq__(self, other): # type: (object) -> bool if not isinstance(other, self.__class__): return NotImplemented return self.value == other.value def __hash__(self): # type: () -> int return hash((self.__class__, self.value)) def resolve(self, env): # type: (Mapping[Text, Optional[Text]]) -> Text return self.value class Variable(Atom): def __init__(self, name, default): # type: (Text, Optional[Text]) -> None self.name = name self.default = default def __repr__(self): # type: () -> str return "Variable(name={}, default={})".format(self.name, self.default) def __eq__(self, other): # type: (object) -> bool if not isinstance(other, self.__class__): return NotImplemented return (self.name, self.default) == (other.name, other.default) def __hash__(self): # type: () -> int return hash((self.__class__, self.name, self.default)) def resolve(self, env): # type: (Mapping[Text, Optional[Text]]) -> Text default = self.default if self.default is not None else "" result = env.get(self.name, default) return result if result is not None else "" def parse_variables(value): # type: (Text) -> Iterator[Atom] cursor = 0 for match in _posix_variable.finditer(value): (start, end) = match.span() name = match.groupdict()["name"] default = match.groupdict()["default"] if start > cursor: yield Literal(value=value[cursor:start]) yield Variable(name=name, default=default) cursor = end length = len(value) if cursor < length: yield Literal(value=value[cursor:length]) python-dotenv-0.18.0/src/dotenv/version.py000066400000000000000000000000271406366747200205610ustar00rootroot00000000000000__version__ = "0.18.0" python-dotenv-0.18.0/tests/000077500000000000000000000000001406366747200155775ustar00rootroot00000000000000python-dotenv-0.18.0/tests/__init__.py000066400000000000000000000000001406366747200176760ustar00rootroot00000000000000python-dotenv-0.18.0/tests/conftest.py000066400000000000000000000003401406366747200177730ustar00rootroot00000000000000import pytest from click.testing import CliRunner @pytest.fixture def cli(): yield CliRunner() @pytest.fixture def dotenv_file(tmp_path): file_ = tmp_path / '.env' file_.write_bytes(b'') yield str(file_) python-dotenv-0.18.0/tests/test_cli.py000066400000000000000000000126661406366747200177720ustar00rootroot00000000000000# -*- coding: utf-8 -*- import os import pytest import sh import dotenv from dotenv.cli import cli as dotenv_cli from dotenv.version import __version__ def test_list(cli, dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'list']) assert (result.exit_code, result.output) == (0, result.output) def test_list_non_existent_file(cli): result = cli.invoke(dotenv_cli, ['--file', 'nx_file', 'list']) assert result.exit_code == 2, result.output assert "does not exist" in result.output def test_list_no_file(cli): result = cli.invoke(dotenv.cli.list, []) assert (result.exit_code, result.output) == (1, "") def test_get_existing_value(cli, dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'get', 'a']) assert (result.exit_code, result.output) == (0, "b\n") def test_get_non_existent_value(cli, dotenv_file): result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'get', 'a']) assert (result.exit_code, result.output) == (1, "") def test_get_no_file(cli): result = cli.invoke(dotenv_cli, ['--file', 'nx_file', 'get', 'a']) assert result.exit_code == 2 assert "does not exist" in result.output def test_unset_existing_value(cli, dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'a']) assert (result.exit_code, result.output) == (0, "Successfully removed a\n") assert open(dotenv_file, "r").read() == "" def test_unset_non_existent_value(cli, dotenv_file): result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'a']) assert (result.exit_code, result.output) == (1, "") assert open(dotenv_file, "r").read() == "" @pytest.mark.parametrize( "quote_mode,variable,value,expected", ( ("always", "a", "x", "a='x'\n"), ("never", "a", "x", 'a=x\n'), ("auto", "a", "x", "a=x\n"), ("auto", "a", "x y", "a='x y'\n"), ("auto", "a", "$", "a='$'\n"), ) ) def test_set_quote_options(cli, dotenv_file, quote_mode, variable, value, expected): result = cli.invoke( dotenv_cli, ["--file", dotenv_file, "--export", "false", "--quote", quote_mode, "set", variable, value] ) assert (result.exit_code, result.output) == (0, "{}={}\n".format(variable, value)) assert open(dotenv_file, "r").read() == expected @pytest.mark.parametrize( "dotenv_file,export_mode,variable,value,expected", ( (".nx_file", "true", "a", "x", "export a='x'\n"), (".nx_file", "false", "a", "x", "a='x'\n"), ) ) def test_set_export(cli, dotenv_file, export_mode, variable, value, expected): result = cli.invoke( dotenv_cli, ["--file", dotenv_file, "--quote", "always", "--export", export_mode, "set", variable, value] ) assert (result.exit_code, result.output) == (0, "{}={}\n".format(variable, value)) assert open(dotenv_file, "r").read() == expected def test_set_non_existent_file(cli): result = cli.invoke(dotenv.cli.set, ["a", "b"]) assert (result.exit_code, result.output) == (1, "") def test_set_no_file(cli): result = cli.invoke(dotenv_cli, ["--file", "nx_file", "set"]) assert result.exit_code == 2 assert "Missing argument" in result.output def test_get_default_path(tmp_path): sh.cd(str(tmp_path)) with open(str(tmp_path / ".env"), "w") as f: f.write("a=b") result = sh.dotenv("get", "a") assert result == "b\n" def test_run(tmp_path): sh.cd(str(tmp_path)) dotenv_file = str(tmp_path / ".env") with open(dotenv_file, "w") as f: f.write("a=b") result = sh.dotenv("run", "printenv", "a") assert result == "b\n" def test_run_with_existing_variable(tmp_path): sh.cd(str(tmp_path)) dotenv_file = str(tmp_path / ".env") with open(dotenv_file, "w") as f: f.write("a=b") env = dict(os.environ) env.update({"LANG": "en_US.UTF-8", "a": "c"}) result = sh.dotenv("run", "printenv", "a", _env=env) assert result == "b\n" def test_run_with_existing_variable_not_overridden(tmp_path): sh.cd(str(tmp_path)) dotenv_file = str(tmp_path / ".env") with open(dotenv_file, "w") as f: f.write("a=b") env = dict(os.environ) env.update({"LANG": "en_US.UTF-8", "a": "c"}) result = sh.dotenv("run", "--no-override", "printenv", "a", _env=env) assert result == "c\n" def test_run_with_none_value(tmp_path): sh.cd(str(tmp_path)) dotenv_file = str(tmp_path / ".env") with open(dotenv_file, "w") as f: f.write("a=b\nc") result = sh.dotenv("run", "printenv", "a") assert result == "b\n" def test_run_with_other_env(dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = sh.dotenv("--file", dotenv_file, "run", "printenv", "a") assert result == "b\n" def test_run_without_cmd(cli): result = cli.invoke(dotenv_cli, ['run']) assert result.exit_code == 2 assert "Invalid value for '-f'" in result.output def test_run_with_invalid_cmd(cli): result = cli.invoke(dotenv_cli, ['run', 'i_do_not_exist']) assert result.exit_code == 2 assert "Invalid value for '-f'" in result.output def test_run_with_version(cli): result = cli.invoke(dotenv_cli, ['--version']) assert result.exit_code == 0 assert result.output.strip().endswith(__version__) python-dotenv-0.18.0/tests/test_ipython.py000066400000000000000000000024531406366747200207060ustar00rootroot00000000000000from __future__ import unicode_literals import os import mock @mock.patch.dict(os.environ, {}, clear=True) def test_ipython_existing_variable_no_override(tmp_path): from IPython.terminal.embed import InteractiveShellEmbed dotenv_file = tmp_path / ".env" dotenv_file.write_text("a=b\n") os.chdir(str(tmp_path)) os.environ["a"] = "c" ipshell = InteractiveShellEmbed() ipshell.magic("load_ext dotenv") ipshell.magic("dotenv") assert os.environ == {"a": "c"} @mock.patch.dict(os.environ, {}, clear=True) def test_ipython_existing_variable_override(tmp_path): from IPython.terminal.embed import InteractiveShellEmbed dotenv_file = tmp_path / ".env" dotenv_file.write_text("a=b\n") os.chdir(str(tmp_path)) os.environ["a"] = "c" ipshell = InteractiveShellEmbed() ipshell.magic("load_ext dotenv") ipshell.magic("dotenv -o") assert os.environ == {"a": "b"} @mock.patch.dict(os.environ, {}, clear=True) def test_ipython_new_variable(tmp_path): from IPython.terminal.embed import InteractiveShellEmbed dotenv_file = tmp_path / ".env" dotenv_file.write_text("a=b\n") os.chdir(str(tmp_path)) ipshell = InteractiveShellEmbed() ipshell.magic("load_ext dotenv") ipshell.magic("dotenv") assert os.environ == {"a": "b"} python-dotenv-0.18.0/tests/test_main.py000066400000000000000000000244621406366747200201440ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import unicode_literals import logging import os import sys import textwrap import mock import pytest import sh import dotenv from dotenv.compat import PY2, StringIO def test_set_key_no_file(tmp_path): nx_file = str(tmp_path / "nx") logger = logging.getLogger("dotenv.main") with mock.patch.object(logger, "warning"): result = dotenv.set_key(nx_file, "foo", "bar") assert result == (True, "foo", "bar") assert os.path.exists(nx_file) @pytest.mark.parametrize( "before,key,value,expected,after", [ ("", "a", "", (True, "a", ""), "a=''\n"), ("", "a", "b", (True, "a", "b"), "a='b'\n"), ("", "a", "'b'", (True, "a", "'b'"), "a='\\'b\\''\n"), ("", "a", "\"b\"", (True, "a", '"b"'), "a='\"b\"'\n"), ("", "a", "b'c", (True, "a", "b'c"), "a='b\\'c'\n"), ("", "a", "b\"c", (True, "a", "b\"c"), "a='b\"c'\n"), ("a=b", "a", "c", (True, "a", "c"), "a='c'\n"), ("a=b\n", "a", "c", (True, "a", "c"), "a='c'\n"), ("a=b\n\n", "a", "c", (True, "a", "c"), "a='c'\n\n"), ("a=b\nc=d", "a", "e", (True, "a", "e"), "a='e'\nc=d"), ("a=b\nc=d\ne=f", "c", "g", (True, "c", "g"), "a=b\nc='g'\ne=f"), ("a=b\n", "c", "d", (True, "c", "d"), "a=b\nc='d'\n"), ], ) def test_set_key(dotenv_file, before, key, value, expected, after): logger = logging.getLogger("dotenv.main") with open(dotenv_file, "w") as f: f.write(before) with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.set_key(dotenv_file, key, value) assert result == expected assert open(dotenv_file, "r").read() == after mock_warning.assert_not_called() def test_set_key_permission_error(dotenv_file): os.chmod(dotenv_file, 0o000) with pytest.raises(Exception): dotenv.set_key(dotenv_file, "a", "b") os.chmod(dotenv_file, 0o600) with open(dotenv_file, "r") as fp: assert fp.read() == "" def test_get_key_no_file(tmp_path): nx_file = str(tmp_path / "nx") logger = logging.getLogger("dotenv.main") with mock.patch.object(logger, "info") as mock_info, \ mock.patch.object(logger, "warning") as mock_warning: result = dotenv.get_key(nx_file, "foo") assert result is None mock_info.assert_has_calls( calls=[ mock.call("Python-dotenv could not find configuration file %s.", nx_file) ], ) mock_warning.assert_has_calls( calls=[ mock.call("Key %s not found in %s.", "foo", nx_file) ], ) def test_get_key_not_found(dotenv_file): logger = logging.getLogger("dotenv.main") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.get_key(dotenv_file, "foo") assert result is None mock_warning.assert_called_once_with("Key %s not found in %s.", "foo", dotenv_file) def test_get_key_ok(dotenv_file): logger = logging.getLogger("dotenv.main") with open(dotenv_file, "w") as f: f.write("foo=bar") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.get_key(dotenv_file, "foo") assert result == "bar" mock_warning.assert_not_called() def test_get_key_none(dotenv_file): logger = logging.getLogger("dotenv.main") with open(dotenv_file, "w") as f: f.write("foo") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.get_key(dotenv_file, "foo") assert result is None mock_warning.assert_not_called() def test_unset_with_value(dotenv_file): logger = logging.getLogger("dotenv.main") with open(dotenv_file, "w") as f: f.write("a=b\nc=d") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.unset_key(dotenv_file, "a") assert result == (True, "a") with open(dotenv_file, "r") as f: assert f.read() == "c=d" mock_warning.assert_not_called() def test_unset_no_value(dotenv_file): logger = logging.getLogger("dotenv.main") with open(dotenv_file, "w") as f: f.write("foo") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.unset_key(dotenv_file, "foo") assert result == (True, "foo") with open(dotenv_file, "r") as f: assert f.read() == "" mock_warning.assert_not_called() def test_unset_non_existent_file(tmp_path): nx_file = str(tmp_path / "nx") logger = logging.getLogger("dotenv.main") with mock.patch.object(logger, "warning") as mock_warning: result = dotenv.unset_key(nx_file, "foo") assert result == (None, "foo") mock_warning.assert_called_once_with( "Can't delete from %s - it doesn't exist.", nx_file, ) def prepare_file_hierarchy(path): """ Create a temporary folder structure like the following: test_find_dotenv0/ └── child1 ├── child2 │   └── child3 │   └── child4 └── .env Then try to automatically `find_dotenv` starting in `child4` """ curr_dir = path dirs = [] for f in ['child1', 'child2', 'child3', 'child4']: curr_dir /= f dirs.append(curr_dir) curr_dir.mkdir() return (dirs[0], dirs[-1]) def test_find_dotenv_no_file_raise(tmp_path): (root, leaf) = prepare_file_hierarchy(tmp_path) os.chdir(str(leaf)) with pytest.raises(IOError): dotenv.find_dotenv(raise_error_if_not_found=True, usecwd=True) def test_find_dotenv_no_file_no_raise(tmp_path): (root, leaf) = prepare_file_hierarchy(tmp_path) os.chdir(str(leaf)) result = dotenv.find_dotenv(usecwd=True) assert result == "" def test_find_dotenv_found(tmp_path): (root, leaf) = prepare_file_hierarchy(tmp_path) os.chdir(str(leaf)) dotenv_file = root / ".env" dotenv_file.write_bytes(b"TEST=test\n") result = dotenv.find_dotenv(usecwd=True) assert result == str(dotenv_file) @mock.patch.dict(os.environ, {}, clear=True) def test_load_dotenv_existing_file(dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = dotenv.load_dotenv(dotenv_file) assert result is True assert os.environ == {"a": "b"} def test_load_dotenv_no_file_verbose(): logger = logging.getLogger("dotenv.main") with mock.patch.object(logger, "info") as mock_info: dotenv.load_dotenv('.does_not_exist', verbose=True) mock_info.assert_called_once_with("Python-dotenv could not find configuration file %s.", ".does_not_exist") @mock.patch.dict(os.environ, {"a": "c"}, clear=True) def test_load_dotenv_existing_variable_no_override(dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = dotenv.load_dotenv(dotenv_file, override=False) assert result is True assert os.environ == {"a": "c"} @mock.patch.dict(os.environ, {"a": "c"}, clear=True) def test_load_dotenv_existing_variable_override(dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = dotenv.load_dotenv(dotenv_file, override=True) assert result is True assert os.environ == {"a": "b"} @mock.patch.dict(os.environ, {"a": "c"}, clear=True) def test_load_dotenv_redefine_var_used_in_file_no_override(dotenv_file): with open(dotenv_file, "w") as f: f.write('a=b\nd="${a}"') result = dotenv.load_dotenv(dotenv_file) assert result is True assert os.environ == {"a": "c", "d": "c"} @mock.patch.dict(os.environ, {"a": "c"}, clear=True) def test_load_dotenv_redefine_var_used_in_file_with_override(dotenv_file): with open(dotenv_file, "w") as f: f.write('a=b\nd="${a}"') result = dotenv.load_dotenv(dotenv_file, override=True) assert result is True assert os.environ == {"a": "b", "d": "b"} @mock.patch.dict(os.environ, {}, clear=True) def test_load_dotenv_utf_8(): stream = StringIO("a=à") result = dotenv.load_dotenv(stream=stream) assert result is True if PY2: assert os.environ == {"a": "à".encode(sys.getfilesystemencoding())} else: assert os.environ == {"a": "à"} def test_load_dotenv_in_current_dir(tmp_path): dotenv_path = tmp_path / '.env' dotenv_path.write_bytes(b'a=b') code_path = tmp_path / 'code.py' code_path.write_text(textwrap.dedent(""" import dotenv import os dotenv.load_dotenv(verbose=True) print(os.environ['a']) """)) os.chdir(str(tmp_path)) result = sh.Command(sys.executable)(code_path) assert result == 'b\n' def test_dotenv_values_file(dotenv_file): with open(dotenv_file, "w") as f: f.write("a=b") result = dotenv.dotenv_values(dotenv_file) assert result == {"a": "b"} @pytest.mark.parametrize( "env,string,interpolate,expected", [ # Defined in environment, with and without interpolation ({"b": "c"}, "a=$b", False, {"a": "$b"}), ({"b": "c"}, "a=$b", True, {"a": "$b"}), ({"b": "c"}, "a=${b}", False, {"a": "${b}"}), ({"b": "c"}, "a=${b}", True, {"a": "c"}), ({"b": "c"}, "a=${b:-d}", False, {"a": "${b:-d}"}), ({"b": "c"}, "a=${b:-d}", True, {"a": "c"}), # Defined in file ({}, "b=c\na=${b}", True, {"a": "c", "b": "c"}), # Undefined ({}, "a=${b}", True, {"a": ""}), ({}, "a=${b:-d}", True, {"a": "d"}), # With quotes ({"b": "c"}, 'a="${b}"', True, {"a": "c"}), ({"b": "c"}, "a='${b}'", True, {"a": "c"}), # With surrounding text ({"b": "c"}, "a=x${b}y", True, {"a": "xcy"}), # Self-referential ({"a": "b"}, "a=${a}", True, {"a": "b"}), ({}, "a=${a}", True, {"a": ""}), ({"a": "b"}, "a=${a:-c}", True, {"a": "b"}), ({}, "a=${a:-c}", True, {"a": "c"}), # Reused ({"b": "c"}, "a=${b}${b}", True, {"a": "cc"}), # Re-defined and used in file ({"b": "c"}, "b=d\na=${b}", True, {"a": "d", "b": "d"}), ({}, "a=b\na=c\nd=${a}", True, {"a": "c", "d": "c"}), ({}, "a=b\nc=${a}\nd=e\nc=${d}", True, {"a": "b", "c": "e", "d": "e"}), ], ) def test_dotenv_values_stream(env, string, interpolate, expected): with mock.patch.dict(os.environ, env, clear=True): stream = StringIO(string) stream.seek(0) result = dotenv.dotenv_values(stream=stream, interpolate=interpolate) assert result == expected python-dotenv-0.18.0/tests/test_parser.py000066400000000000000000000162051406366747200205100ustar00rootroot00000000000000# -*- coding: utf-8 -*- import pytest from dotenv.compat import StringIO from dotenv.parser import Binding, Original, parse_stream @pytest.mark.parametrize("test_input,expected", [ (u"", []), (u"a=b", [Binding(key=u"a", value=u"b", original=Original(string=u"a=b", line=1), error=False)]), (u"'a'=b", [Binding(key=u"a", value=u"b", original=Original(string=u"'a'=b", line=1), error=False)]), (u"[=b", [Binding(key=u"[", value=u"b", original=Original(string=u"[=b", line=1), error=False)]), (u" a = b ", [Binding(key=u"a", value=u"b", original=Original(string=u" a = b ", line=1), error=False)]), (u"export a=b", [Binding(key=u"a", value=u"b", original=Original(string=u"export a=b", line=1), error=False)]), ( u" export 'a'=b", [Binding(key=u"a", value=u"b", original=Original(string=u" export 'a'=b", line=1), error=False)], ), (u"# a=b", [Binding(key=None, value=None, original=Original(string=u"# a=b", line=1), error=False)]), (u"a=b#c", [Binding(key=u"a", value=u"b#c", original=Original(string=u"a=b#c", line=1), error=False)]), ( u'a=b #c', [Binding(key=u"a", value=u"b", original=Original(string=u"a=b #c", line=1), error=False)], ), ( u'a=b\t#c', [Binding(key=u"a", value=u"b", original=Original(string=u"a=b\t#c", line=1), error=False)], ), ( u"a=b c", [Binding(key=u"a", value=u"b c", original=Original(string=u"a=b c", line=1), error=False)], ), ( u"a=b\tc", [Binding(key=u"a", value=u"b\tc", original=Original(string=u"a=b\tc", line=1), error=False)], ), ( u"a=b c", [Binding(key=u"a", value=u"b c", original=Original(string=u"a=b c", line=1), error=False)], ), ( u"a=b\u00a0 c", [Binding(key=u"a", value=u"b\u00a0 c", original=Original(string=u"a=b\u00a0 c", line=1), error=False)], ), ( u"a=b c ", [Binding(key=u"a", value=u"b c", original=Original(string=u"a=b c ", line=1), error=False)], ), ( u"a='b c '", [Binding(key=u"a", value=u"b c ", original=Original(string=u"a='b c '", line=1), error=False)], ), ( u'a="b c "', [Binding(key=u"a", value=u"b c ", original=Original(string=u'a="b c "', line=1), error=False)], ), ( u"export export_a=1", [ Binding(key=u"export_a", value=u"1", original=Original(string=u"export export_a=1", line=1), error=False) ], ), ( u"export port=8000", [Binding(key=u"port", value=u"8000", original=Original(string=u"export port=8000", line=1), error=False)], ), (u'a="b\nc"', [Binding(key=u"a", value=u"b\nc", original=Original(string=u'a="b\nc"', line=1), error=False)]), (u"a='b\nc'", [Binding(key=u"a", value=u"b\nc", original=Original(string=u"a='b\nc'", line=1), error=False)]), (u'a="b\nc"', [Binding(key=u"a", value=u"b\nc", original=Original(string=u'a="b\nc"', line=1), error=False)]), (u'a="b\\nc"', [Binding(key=u"a", value=u'b\nc', original=Original(string=u'a="b\\nc"', line=1), error=False)]), (u"a='b\\nc'", [Binding(key=u"a", value=u'b\\nc', original=Original(string=u"a='b\\nc'", line=1), error=False)]), (u'a="b\\"c"', [Binding(key=u"a", value=u'b"c', original=Original(string=u'a="b\\"c"', line=1), error=False)]), (u"a='b\\'c'", [Binding(key=u"a", value=u"b'c", original=Original(string=u"a='b\\'c'", line=1), error=False)]), (u"a=à", [Binding(key=u"a", value=u"à", original=Original(string=u"a=à", line=1), error=False)]), (u'a="à"', [Binding(key=u"a", value=u"à", original=Original(string=u'a="à"', line=1), error=False)]), ( u'no_value_var', [Binding(key=u'no_value_var', value=None, original=Original(string=u"no_value_var", line=1), error=False)], ), (u'a: b', [Binding(key=None, value=None, original=Original(string=u"a: b", line=1), error=True)]), ( u"a=b\nc=d", [ Binding(key=u"a", value=u"b", original=Original(string=u"a=b\n", line=1), error=False), Binding(key=u"c", value=u"d", original=Original(string=u"c=d", line=2), error=False), ], ), ( u"a=b\rc=d", [ Binding(key=u"a", value=u"b", original=Original(string=u"a=b\r", line=1), error=False), Binding(key=u"c", value=u"d", original=Original(string=u"c=d", line=2), error=False), ], ), ( u"a=b\r\nc=d", [ Binding(key=u"a", value=u"b", original=Original(string=u"a=b\r\n", line=1), error=False), Binding(key=u"c", value=u"d", original=Original(string=u"c=d", line=2), error=False), ], ), ( u'a=\nb=c', [ Binding(key=u"a", value=u'', original=Original(string=u'a=\n', line=1), error=False), Binding(key=u"b", value=u'c', original=Original(string=u"b=c", line=2), error=False), ] ), ( u"\n\n", [ Binding(key=None, value=None, original=Original(string=u"\n\n", line=1), error=False), ] ), ( u"a=b\n\n", [ Binding(key=u"a", value=u"b", original=Original(string=u"a=b\n", line=1), error=False), Binding(key=None, value=None, original=Original(string=u"\n", line=2), error=False), ] ), ( u'a=b\n\nc=d', [ Binding(key=u"a", value=u"b", original=Original(string=u"a=b\n", line=1), error=False), Binding(key=u"c", value=u"d", original=Original(string=u"\nc=d", line=2), error=False), ] ), ( u'a="\nb=c', [ Binding(key=None, value=None, original=Original(string=u'a="\n', line=1), error=True), Binding(key=u"b", value=u"c", original=Original(string=u"b=c", line=2), error=False), ] ), ( u'# comment\na="b\nc"\nd=e\n', [ Binding(key=None, value=None, original=Original(string=u"# comment\n", line=1), error=False), Binding(key=u"a", value=u"b\nc", original=Original(string=u'a="b\nc"\n', line=2), error=False), Binding(key=u"d", value=u"e", original=Original(string=u"d=e\n", line=4), error=False), ], ), ( u'a=b\n# comment 1', [ Binding(key="a", value="b", original=Original(string=u"a=b\n", line=1), error=False), Binding(key=None, value=None, original=Original(string=u"# comment 1", line=2), error=False), ], ), ( u'# comment 1\n# comment 2', [ Binding(key=None, value=None, original=Original(string=u"# comment 1\n", line=1), error=False), Binding(key=None, value=None, original=Original(string=u"# comment 2", line=2), error=False), ], ), ( u'uglyKey[%$=\"S3cr3t_P4ssw#rD\" #\na=b', [ Binding(key=u'uglyKey[%$', value=u'S3cr3t_P4ssw#rD', original=Original(string=u"uglyKey[%$=\"S3cr3t_P4ssw#rD\" #\n", line=1), error=False), Binding(key=u"a", value=u"b", original=Original(string=u'a=b', line=2), error=False), ], ), ]) def test_parse_stream(test_input, expected): result = parse_stream(StringIO(test_input)) assert list(result) == expected python-dotenv-0.18.0/tests/test_utils.py000066400000000000000000000012731406366747200203530ustar00rootroot00000000000000from dotenv import get_cli_string as c def test_to_cli_string(): assert c() == 'dotenv' assert c(path='/etc/.env') == 'dotenv -f /etc/.env' assert c(path='/etc/.env', action='list') == 'dotenv -f /etc/.env list' assert c(action='list') == 'dotenv list' assert c(action='get', key='DEBUG') == 'dotenv get DEBUG' assert c(action='set', key='DEBUG', value='True') == 'dotenv set DEBUG True' assert c(action='set', key='SECRET', value='=@asdfasf') == 'dotenv set SECRET =@asdfasf' assert c(action='set', key='SECRET', value='a b') == 'dotenv set SECRET "a b"' assert c(action='set', key='SECRET', value='a b', quote="always") == 'dotenv -q always set SECRET "a b"' python-dotenv-0.18.0/tests/test_variables.py000066400000000000000000000015631406366747200211650ustar00rootroot00000000000000import pytest from dotenv.variables import Literal, Variable, parse_variables @pytest.mark.parametrize( "value,expected", [ ("", []), ("a", [Literal(value="a")]), ("${a}", [Variable(name="a", default=None)]), ("${a:-b}", [Variable(name="a", default="b")]), ( "${a}${b}", [ Variable(name="a", default=None), Variable(name="b", default=None), ], ), ( "a${b}c${d}e", [ Literal(value="a"), Variable(name="b", default=None), Literal(value="c"), Variable(name="d", default=None), Literal(value="e"), ], ), ] ) def test_parse_variables(value, expected): result = parse_variables(value) assert list(result) == expected python-dotenv-0.18.0/tox.ini000066400000000000000000000022511406366747200157500ustar00rootroot00000000000000[tox] envlist = lint,py{27,35,36,37,38,39},pypy,pypy3,manifest,coverage-report [gh-actions] python = 2.7: py27, coverage-report 3.5: py35, coverage-report 3.6: py36, coverage-report 3.7: py37, coverage-report 3.8: py38, coverage-report 3.9: py39, lint, manifest, coverage-report pypy2: pypy, coverage-report pypy3: pypy3, coverage-report [testenv] deps = mock pytest coverage sh click py{27,py}: ipython<6.0.0 py{35,36,37,38,39,py3}: ipython commands = coverage run --parallel -m pytest {posargs} [testenv:lint] skip_install = true deps = flake8 mypy<0.900 commands = flake8 src tests mypy --python-version=3.9 src tests mypy --python-version=3.8 src tests mypy --python-version=3.7 src tests mypy --python-version=3.6 src tests mypy --python-version=3.5 src tests mypy --python-version=3.4 src tests mypy --python-version=2.7 src tests [testenv:manifest] deps = check-manifest skip_install = true commands = check-manifest [testenv:coverage-clean] deps = coverage skip_install = true commands = coverage erase [testenv:coverage-report] deps = coverage skip_install = true commands = coverage combine coverage report