pax_global_header00006660000000000000000000000064136461477060014530gustar00rootroot0000000000000052 comment=784102284471252f418e797c1874a00063426210 python-dotenv-0.13.0/000077500000000000000000000000001364614770600144275ustar00rootroot00000000000000python-dotenv-0.13.0/.editorconfig000066400000000000000000000003631364614770600171060ustar00rootroot00000000000000# 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.13.0/.gitignore000066400000000000000000000030251364614770600164170ustar00rootroot00000000000000.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.13.0/.travis.yml000066400000000000000000000017121364614770600165410ustar00rootroot00000000000000language: python cache: pip os: linux dist: xenial jobs: include: - python: "3.6" env: TOXENV=lint - python: "3.6" env: TOXENV=manifest - python: "2.7" env: TOXENV=py27 - python: "3.5" env: TOXENV=py35 - python: "3.6" env: TOXENV=py36 - python: "3.7" env: TOXENV=py37 - python: "3.8" env: TOXENV=py38 - python: "pypy" env: TOXENV=pypy - python: "pypy3" env: TOXENV=pypy3 install: - pip install tox script: - tox before_install: - pip install coveralls after_success: - tox -e coverage-report - coveralls deploy: provider: pypi username: theskumar password: secure: DXUkl4YSC2RCltChik1csvQulnVMQQpD/4i4u+6pEyUfBMYP65zFYSNwLh+jt+URyX+MpN/Er20+TZ/F/fu7xkru6/KBqKLugeXihNbwGhbHUIkjZT/0dNSo03uAz6s5fWgqr8EJk9Ll71GexAsBPx2yqsjc2BMgOjwcNly40Co= distributions: "sdist bdist_wheel" skip_existing: true on: tags: true repo: theskumar/python-dotenv python-dotenv-0.13.0/CHANGELOG.md000066400000000000000000000153471364614770600162520ustar00rootroot00000000000000# 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). ## [Unreleased] *No unreleased change at this time.* ## [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 [@cjauvin]: https://github.com/cjauvin [@earlbread]: https://github.com/earlbread [@gergelyk]: https://github.com/gergelyk [@greyli]: https://github.com/greyli [@qnighy]: https://github.com/qnighy [@techalchemy]: https://github.com/techalchemy [@theskumar]: https://github.com/theskumar [@ulyssessouza]: https://github.com/ulyssessouza [@venthur]: https://github.com/venthur [@yannham]: https://github.com/yannham [Unreleased]: https://github.com/theskumar/python-dotenv/compare/v0.13.0...HEAD [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.13.0/CONTRIBUTING.md000066400000000000000000000005321364614770600166600ustar00rootroot00000000000000Contributing ============ 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.13.0/LICENSE000066400000000000000000000107701364614770600154410ustar00rootroot00000000000000python-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.13.0/MANIFEST.in000066400000000000000000000003321364614770600161630ustar00rootroot00000000000000include 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.13.0/Makefile000066400000000000000000000012271364614770600160710ustar00rootroot00000000000000.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.13.0/README.md000066400000000000000000000212151364614770600157070ustar00rootroot00000000000000``` _______ .__ __. ____ ____ | ____|| \ | | \ \ / / | |__ | \| | \ \/ / | __| | . ` | \ / __ | |____ | |\ | \ / (__)|_______||__| \__| \__/ ``` python-dotenv | [![Build Status](https://travis-ci.org/theskumar/python-dotenv.svg?branch=master)](https://travis-ci.org/theskumar/python-dotenv) [![Coverage Status](https://coveralls.io/repos/theskumar/python-dotenv/badge.svg?branch=master)](https://coveralls.io/r/theskumar/python-dotenv?branch=master) [![PyPI version](https://badge.fury.io/py/python-dotenv.svg)](http://badge.fury.io/py/python-dotenv) [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/theskumar) =============================================================================== Reads the key-value pair from `.env` file and adds them to environment variable. It is great for managing app settings during development and in production using [12-factor](http://12factor.net/) principles. > Do one thing, do it well! ## Usages The easiest and most common usage consists on calling `load_dotenv` when the application starts, which will load environment variables from a file named `.env` in the current directory or any of its parents or from the path specificied; after that, you can just call the environment-related method you need as provided by `os.getenv`. `.env` looks like this: ```shell # a comment that will be ignored. REDIS_ADDRESS=localhost:6379 MEANING_OF_LIFE=42 MULTILINE_VAR="hello\nworld" ``` You can optionally prefix each line with the word `export`, which is totally ignored by this library, but might allow you to [`source`](https://bash.cyberciti.biz/guide/Source_command) the file in bash. ``` export S3_BUCKET=YOURS3BUCKET export SECRET_KEY=YOURSECRETKEYGOESHERE ``` Python-dotenv can interpolate variables using POSIX variable expansion. 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. Ensure that variables are surrounded with `{}` like `${HOME}` as bare variables such as `$HOME` are not expanded. ```shell CONFIG_PATH=${HOME}/.config/foo DOMAIN=example.org EMAIL=admin@${DOMAIN} DEBUG=${DEBUG:-false} ``` ## Getting started Install the latest version with: ```shell pip install -U python-dotenv ``` Assuming you have created the `.env` file along-side your settings module. . ├── .env └── settings.py Add the following code to your `settings.py`: ```python # settings.py from dotenv import load_dotenv load_dotenv() # OR, the same with increased verbosity load_dotenv(verbose=True) # OR, explicitly providing path to '.env' from pathlib import Path # python3 only env_path = Path('.') / '.env' load_dotenv(dotenv_path=env_path) ``` At this point, parsed key/value from the `.env` file is now present as system environment variable and they can be conveniently accessed via `os.getenv()`: ```python # settings.py import os SECRET_KEY = os.getenv("EMAIL") DATABASE_PASSWORD = os.getenv("DATABASE_PASSWORD") ``` `load_dotenv` does not override existing System environment variables. To override, pass `override=True` to `load_dotenv()`. `load_dotenv` also accepts `encoding` parameter to open the `.env` file. The default encoding is platform dependent (whatever `locale.getpreferredencoding()` returns), but any encoding supported by Python can be used. See the [codecs](https://docs.python.org/3/library/codecs.html#standard-encodings) module for the list of supported encodings. You can use `find_dotenv()` method that will try to find a `.env` file by (a) guessing where to start using `__file__` or the working directory -- allowing this to work in non-file contexts such as IPython notebooks and the REPL, and then (b) walking up the directory tree looking for the specified file -- called `.env` by default. ```python from dotenv import load_dotenv, find_dotenv load_dotenv(find_dotenv()) ``` ### In-memory filelikes It is possible to not rely on the filesystem to parse filelikes from other sources (e.g. from a network storage). `load_dotenv` and `dotenv_values` accepts a filelike `stream`. Just be sure to rewind it before passing. ```python >>> from io import StringIO # Python2: from StringIO import StringIO >>> from dotenv import dotenv_values >>> filelike = StringIO('SPAM=EGGS\n') >>> filelike.seek(0) >>> parsed = dotenv_values(stream=filelike) >>> parsed['SPAM'] 'EGGS' ``` The returned value is dictionary with key-value pairs. `dotenv_values` could be useful if you need to *consume* the envfile but not *apply* it directly into the system environment. ### Django If you are using Django, you should add the above loader script at the top of `wsgi.py` and `manage.py`. ## IPython Support You can use dotenv with IPython. You can either let the dotenv search for `.env` with `%dotenv` or provide the path to the `.env` file explicitly; see below for usages. %load_ext dotenv # Use find_dotenv to locate the file %dotenv # Specify a particular file %dotenv relative/or/absolute/path/to/.env # Use '-o' to indicate override of existing variables %dotenv -o # Use '-v' to turn verbose mode on %dotenv -v ## Command-line Interface For command-line support, use the CLI option during installation: ```shell pip install -U "python-dotenv[cli]" ``` A CLI interface `dotenv` is also included, which helps you manipulate the `.env` file without manually opening it. The same CLI installed on remote machine combined with fabric (discussed later) will enable you to update your settings on a remote server; handy, isn't it! ``` Usage: dotenv [OPTIONS] COMMAND [ARGS]... This script is used to set, get or unset values from a .env file. Options: -f, --file PATH Location of the .env file, defaults to .env file in current working directory. -q, --quote [always|never|auto] Whether to quote or not the variable values. Default mode is always. This does not affect parsing. --help Show this message and exit. Commands: get Retrive the value for the given key. list Display all the stored key/value. run Run command with environment variables from .env file present set Store the given key/value. unset Removes the given key. ``` ### Setting config on Remote Servers We make use of excellent [Fabric](http://www.fabfile.org/) to accomplish this. Add a config task to your local fabfile; `dotenv_path` is the location of the absolute path of `.env` file on the remote server. ```python # fabfile.py import dotenv from fabric.api import task, run, env # absolute path to the location of .env on remote server. env.dotenv_path = '/opt/myapp/.env' @task def config(action=None, key=None, value=None): '''Manage project configuration via .env e.g: fab config:set,, fab config:get, fab config:unset, fab config:list ''' run('touch %(dotenv_path)s' % env) command = dotenv.get_cli_string(env.dotenv_path, action, key, value) run(command) ``` Usage is designed to mirror the Heroku config API very closely. Get all your remote config info with `fab config`: $ fab config foo="bar" Set remote config variables with `fab config:set,,`: $ fab config:set,hello,world Get a single remote config variables with `fab config:get,`: $ fab config:get,hello Delete a remote config variables with `fab config:unset,`: $ fab config:unset,hello Thanks entirely to fabric and not one bit to this project, you can chain commands like so: `fab config:set,, config:set,,` $ fab config:set,hello,world config:set,foo,bar config:set,fizz=buzz ## 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). python-dotenv-0.13.0/pyproject.toml000066400000000000000000000001631364614770600173430ustar00rootroot00000000000000[tool.portray] modules = ["dotenv"] [tool.portray.mkdocs] repo_url = "https://github.com/theskumar/python-dotenv" python-dotenv-0.13.0/requirements.txt000066400000000000000000000002021364614770600177050ustar00rootroot00000000000000bumpversion 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.13.0/setup.cfg000066400000000000000000000010741364614770600162520ustar00rootroot00000000000000[bumpversion] current_version = 0.13.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.rst [tool:pytest] testpaths = tests [coverage:run] source = dotenv [coverage:paths] source = src/dotenv .tox/*/lib/python*/site-packages/dotenv .tox/pypy*/site-packages/dotenv [coverage:report] show_missing = True exclude_lines = if IS_TYPE_CHECKING: pragma: no cover python-dotenv-0.13.0/setup.py000066400000000000000000000040421364614770600161410ustar00rootroot00000000000000# -*- 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="Add .env support to your django/flask apps in development and deployments", long_description=long_description, long_description_content_type='text/markdown', version=meta['__version__'], author="Saurabh Kumar", author_email="me+github@saurabh-kumar.com", url="http://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 ''', 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 :: 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.13.0/src/000077500000000000000000000000001364614770600152165ustar00rootroot00000000000000python-dotenv-0.13.0/src/dotenv/000077500000000000000000000000001364614770600165155ustar00rootroot00000000000000python-dotenv-0.13.0/src/dotenv/__init__.py000066400000000000000000000024731364614770600206340ustar00rootroot00000000000000from .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.13.0/src/dotenv/cli.py000066400000000000000000000076721364614770600176520ustar00rootroot00000000000000import 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(exists=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.version_option(version=__version__) @click.pass_context def cli(ctx, file, quote): # type: (click.Context, Any, Any) -> None '''This script is used to set, get or unset values from a .env file.''' ctx.obj = {} ctx.obj['FILE'] = file ctx.obj['QUOTE'] = quote @cli.command() @click.pass_context def list(ctx): # type: (click.Context) -> None '''Display all the stored key/value.''' file = ctx.obj['FILE'] 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'] success, key, value = set_key(file, key, value, quote) 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'] stored_value = get_key(file, key) if stored_value: click.echo('%s=%s' % (key, 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.argument('commandline', nargs=-1, type=click.UNPROCESSED) def run(ctx, commandline): # type: (click.Context, List[str]) -> None """Run command with environment variables present.""" file = ctx.obj['FILE'] dotenv_as_dict = {to_env(k): to_env(v) for (k, v) in dotenv_values(file).items() if v is not None} 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.13.0/src/dotenv/compat.py000066400000000000000000000017041364614770600203540ustar00rootroot00000000000000import 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.13.0/src/dotenv/ipython.py000066400000000000000000000024761364614770600205720ustar00rootroot00000000000000from __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.13.0/src/dotenv/main.py000066400000000000000000000251161364614770600200200ustar00rootroot00000000000000# -*- coding: utf-8 -*- from __future__ import absolute_import, print_function, unicode_literals import io import logging import os import re 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 logger = logging.getLogger(__name__) if IS_TYPE_CHECKING: from typing import ( Dict, Iterator, Match, Optional, Pattern, Union, Text, IO, Tuple ) if sys.version_info >= (3, 6): _PathLike = os.PathLike else: _PathLike = Text if sys.version_info >= (3, 0): _StringIO = StringIO else: _StringIO = StringIO[Text] __posix_variable = re.compile( r""" \$\{ (?P[^\}:]*) (?::- (?P[^\}]*) )? \} """, re.VERBOSE, ) # type: Pattern[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): # type: (Union[Text, _PathLike, _StringIO], bool, Union[None, Text], 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 @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.warning("File doesn't exist %s", self.dotenv_path) yield StringIO('') def dict(self): # type: () -> Dict[Text, Optional[Text]] """Return dotenv as dict""" if self._dict: return self._dict values = OrderedDict(self.parse()) self._dict = resolve_nested_variables(values) if self.interpolate else 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, override=False): # type: (bool) -> bool """ Load the current dotenv as system environemt variable. """ for k, v in self.dict().items(): if k in os.environ and not 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: 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"): # type: (_PathLike, Text, Text, Text) -> 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 """ value_to_set = value_to_set.strip("'").strip('"') if not os.path.exists(dotenv_path): logger.warning("Can't write to %s - it doesn't exist.", dotenv_path) return None, key_to_set, value_to_set if " " in value_to_set: quote_mode = "always" if quote_mode == "always": value_out = '"{}"'.format(value_to_set.replace('"', '\\"')) else: value_out = value_to_set 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_nested_variables(values): # type: (Dict[Text, Optional[Text]]) -> Dict[Text, Optional[Text]] def _replacement(name, default): # type: (Text, Optional[Text]) -> Text """ get appropriate value for a variable name. first search in environ, if not found, then look into the dotenv variables """ default = default if default is not None else "" ret = os.getenv(name, new_values.get(name, default)) return ret # type: ignore def _re_sub_callback(match): # type: (Match[Text]) -> Text """ From a match object gets the variable name and returns the correct replacement """ matches = match.groupdict() return _replacement(name=matches["name"], default=matches["default"]) # type: ignore new_values = {} for k, v in values.items(): new_values[k] = __posix_variable.sub(_re_sub_callback, v) if v is not None else None 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, **kwargs): # type: (Union[Text, _PathLike, None], Optional[_StringIO], bool, bool, bool, Union[None, Text]) -> bool """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. - *verbose*: whether to output the warnings related to missing .env file etc. Defaults to `False`. - *override*: where to override the system environment variables with the variables in `.env` file. Defaults to `False`. """ f = dotenv_path or stream or find_dotenv() return DotEnv(f, verbose=verbose, interpolate=interpolate, **kwargs).set_as_environment_variables(override=override) def dotenv_values(dotenv_path=None, stream=None, verbose=False, interpolate=True, **kwargs): # type: (Union[Text, _PathLike, None], Optional[_StringIO], bool, bool, Union[None, Text]) -> Dict[Text, Optional[Text]] # noqa: E501 f = dotenv_path or stream or find_dotenv() return DotEnv(f, verbose=verbose, interpolate=interpolate, **kwargs).dict() python-dotenv-0.13.0/src/dotenv/parser.py000066400000000000000000000146061364614770600203720ustar00rootroot00000000000000import 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_part = 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: 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 value = u"" while True: (part,) = reader.read_regex(_unquoted_value_part) value += part after = reader.peek(2) if len(after) < 2 or after[0] in u"\r\n" or after[1] in u" #\r\n": return value value += reader.read(2) 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.13.0/src/dotenv/py.typed000066400000000000000000000000321364614770600202070ustar00rootroot00000000000000# Marker file for PEP 561 python-dotenv-0.13.0/src/dotenv/version.py000066400000000000000000000000271364614770600205530ustar00rootroot00000000000000__version__ = "0.13.0" python-dotenv-0.13.0/tests/000077500000000000000000000000001364614770600155715ustar00rootroot00000000000000python-dotenv-0.13.0/tests/__init__.py000066400000000000000000000000001364614770600176700ustar00rootroot00000000000000python-dotenv-0.13.0/tests/conftest.py000066400000000000000000000003401364614770600177650ustar00rootroot00000000000000import 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.13.0/tests/test_cli.py000066400000000000000000000103011364614770600177440ustar00rootroot00000000000000# -*- coding: utf-8 -*- 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 "Invalid value for '-f'" 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, "a=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 "Invalid value for '-f'" 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", "HELLO", "WORLD", 'HELLO="WORLD"\n'), ("never", "HELLO", "WORLD", 'HELLO=WORLD\n'), ("auto", "HELLO", "WORLD", 'HELLO=WORLD\n'), ("auto", "HELLO", "HELLO WORLD", 'HELLO="HELLO WORLD"\n'), ) ) def test_set_options(cli, dotenv_file, quote_mode, variable, value, expected): result = cli.invoke( dotenv_cli, ["--file", dotenv_file, "--quote", quote_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 "Invalid value for '-f'" 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 == "a=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_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.13.0/tests/test_ipython.py000066400000000000000000000024531364614770600207000ustar00rootroot00000000000000from __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.13.0/tests/test_main.py000066400000000000000000000225701364614770600201340ustar00rootroot00000000000000# -*- 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") as mock_warning: result = dotenv.set_key(nx_file, "foo", "bar") assert result == (None, "foo", "bar") assert not os.path.exists(nx_file) mock_warning.assert_called_once_with( "Can't write to %s - it doesn't exist.", 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, "warning") as mock_warning: result = dotenv.get_key(nx_file, "foo") assert result is None mock_warning.assert_has_calls( calls=[ mock.call("File doesn't exist %s", nx_file), 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, "warning") as mock_warning: dotenv.load_dotenv('.does_not_exist', verbose=True) mock_warning.assert_called_once_with("File doesn't exist %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, {}, 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"}), ], ) 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.13.0/tests/test_parser.py000066400000000000000000000150161364614770600205010ustar00rootroot00000000000000# -*- 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 # comment', [Binding(key=u"a", value=u"b", original=Original(string=u"a=b # comment", line=1), error=False)], ), ( u"a=b space ", [Binding(key=u"a", value=u"b space", original=Original(string=u"a=b space ", line=1), error=False)], ), ( u"a='b space '", [Binding(key=u"a", value=u"b space ", original=Original(string=u"a='b space '", line=1), error=False)], ), ( u'a="b space "', [Binding(key=u"a", value=u"b space ", original=Original(string=u'a="b space "', 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.13.0/tests/test_utils.py000066400000000000000000000012731364614770600203450ustar00rootroot00000000000000from 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.13.0/tox.ini000066400000000000000000000020141364614770600157370ustar00rootroot00000000000000[tox] envlist = lint,py{27,34,35,36,37,38,34-no-typing},pypy,pypy3,manifest,coverage-report [testenv] deps = mock pytest coverage sh click py{27,py}: ipython<6.0.0 py34{,-no-typing}: ipython<7.0.0 py{35,36,37,38,py3}: ipython commands = coverage run --parallel -m pytest {posargs} [testenv:py34-no-typing] commands = pip uninstall --yes typing coverage run --parallel -m pytest -k 'not test_ipython' {posargs} [testenv:lint] skip_install = true deps = flake8 mypy commands = flake8 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