django-environ-0.4.4/0000775000175000017500000000000013146535252015043 5ustar joke2kjoke2k00000000000000django-environ-0.4.4/MANIFEST.in0000664000175000017500000000007013146517103016571 0ustar joke2kjoke2k00000000000000include *.rst include *.txt include environ/test_env.txtdjango-environ-0.4.4/LICENSE.txt0000664000175000017500000000205113146517103016657 0ustar joke2kjoke2k00000000000000Copyright (c) 2013-2017, Daniele Faraglia Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.django-environ-0.4.4/django_environ.egg-info/0000775000175000017500000000000013146535252021537 5ustar joke2kjoke2k00000000000000django-environ-0.4.4/django_environ.egg-info/not-zip-safe0000664000175000017500000000000113146520447023765 0ustar joke2kjoke2k00000000000000 django-environ-0.4.4/django_environ.egg-info/SOURCES.txt0000664000175000017500000000054313146535252023425 0ustar joke2kjoke2k00000000000000LICENSE.txt MANIFEST.in README.rst setup.cfg setup.py django_environ.egg-info/PKG-INFO django_environ.egg-info/SOURCES.txt django_environ.egg-info/dependency_links.txt django_environ.egg-info/not-zip-safe django_environ.egg-info/requires.txt django_environ.egg-info/top_level.txt environ/__init__.py environ/environ.py environ/test.py environ/test_env.txtdjango-environ-0.4.4/django_environ.egg-info/top_level.txt0000664000175000017500000000001013146535252024260 0ustar joke2kjoke2k00000000000000environ django-environ-0.4.4/django_environ.egg-info/dependency_links.txt0000664000175000017500000000000113146535252025605 0ustar joke2kjoke2k00000000000000 django-environ-0.4.4/django_environ.egg-info/requires.txt0000664000175000017500000000001313146535252024131 0ustar joke2kjoke2k00000000000000django six django-environ-0.4.4/django_environ.egg-info/PKG-INFO0000664000175000017500000004122213146535252022635 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.4 Summary: Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. Home-page: https://github.com/joke2k/django-environ Author: joke2k Author-email: joke2k@gmail.com License: MIT License Description: ============== Django-environ ============== Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. |pypi| |unix_build| |windows_build| |coverage| |license| This module is a merge of: * `envparse`_ * `honcho`_ * `dj-database-url`_ * `dj-search-url`_ * `dj-config-url`_ * `django-cache-url`_ and inspired by: * `12factor`_ * `12factor-django`_ * `Two Scoops of Django`_ This is your `settings.py` file before you have installed **django-environ** .. code-block:: python import os SITE_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) DEBUG = True TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'database', 'USER': 'user', 'PASSWORD': 'githubbedpassword', 'HOST': '127.0.0.1', 'PORT': '8458', }, 'extra': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(SITE_ROOT, 'database.sqlite') } } MEDIA_ROOT = os.path.join(SITE_ROOT, 'assets') MEDIA_URL = 'media/' STATIC_ROOT = os.path.join(SITE_ROOT, 'static') STATIC_URL = 'static/' SECRET_KEY = '...im incredibly still here...' CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '127.0.0.1:11211', '127.0.0.1:11212', '127.0.0.1:11213', ] }, 'redis': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': '127.0.0.1:6379/1', 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PASSWORD': 'redis-githubbed-password', } } } After: .. code-block:: python import environ root = environ.Path(__file__) - 3 # three folder back (/a/b/c/ - 3 = /) env = environ.Env(DEBUG=(bool, False),) # set default values and casting environ.Env.read_env() # reading .env file SITE_ROOT = root() DEBUG = env('DEBUG') # False if not in os.environ TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': env.db(), # Raises ImproperlyConfigured exception if DATABASE_URL not in os.environ 'extra': env.db('SQLITE_URL', default='sqlite:////tmp/my-tmp-sqlite.db') } public_root = root.path('public/') MEDIA_ROOT = public_root('media') MEDIA_URL = 'media/' STATIC_ROOT = public_root('static') STATIC_URL = 'static/' SECRET_KEY = env('SECRET_KEY') # Raises ImproperlyConfigured exception if SECRET_KEY not in os.environ CACHES = { 'default': env.cache(), 'redis': env.cache('REDIS_URL') } You can also pass ``read_env()`` an explicit path to the ``.env`` file. Create a ``.env`` file: .. code-block:: bash DEBUG=on # DJANGO_SETTINGS_MODULE=myapp.settings.dev SECRET_KEY=your-secret-key DATABASE_URL=psql://urser:un-githubbedpassword@127.0.0.1:8458/database # SQLITE_URL=sqlite:///my-local-sqlite.db CACHE_URL=memcache://127.0.0.1:11211,127.0.0.1:11212,127.0.0.1:11213 REDIS_URL=rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=redis-un-githubbed-password How to install ============== :: $ pip install django-environ How to use ========== There are only two classes, ``environ.Env`` and ``environ.Path`` .. code-block:: python >>> import environ >>> env = environ.Env( DEBUG=(bool, False), ) >>> env('DEBUG') False >>> env('DEBUG', default=True) True >>> open('.myenv', 'a').write('DEBUG=on') >>> environ.Env.read_env('.myenv') # or env.read_env('.myenv') >>> env('DEBUG') True >>> open('.myenv', 'a').write('\nINT_VAR=1010') >>> env.int('INT_VAR'), env.str('INT_VAR') 1010, '1010' >>> open('.myenv', 'a').write('\nDATABASE_URL=sqlite:///my-local-sqlite.db') >>> env.read_env('.myenv') >>> env.db() {'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'my-local-sqlite.db', 'HOST': '', 'USER': '', 'PASSWORD': '', 'PORT': ''} >>> root = env.path('/home/myproject/') >>> root('static') '/home/myproject/static' See `cookiecutter-django`_ for a concrete example on using with a django project. Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) #environ.Env(BAR=(dict, {})) - dict (BAR=key=val;foo=1.1;baz=True) #environ.Env(BAR=(dict(value=unicode, cast=dict(foo=float,baz=bool)), {})) - url - path (environ.Path) - db_url - PostgreSQL: postgres://, pgsql://, psql:// or postgresql:// - PostGIS: postgis:// - MySQL: mysql:// or mysql2:// - MySQL for GeoDjango: mysqlgis:// - SQLITE: sqlite:// - SQLITE with SPATIALITE for GeoDjango: spatialite:// - Oracle: oracle:// - PyODBC: pyodbc:// - Redshift: redshift:// - LDAP: ldap:// - cache_url - Database: dbcache:// - Dummy: dummycache:// - File: filecache:// - Memory: locmemcache:// - Memcached: memcache:// - Python memory: pymemcache:// - Redis: rediscache:// - search_url - ElasticSearch: elasticsearch:// - Solr: solr:// - Whoosh: whoosh:// - Xapian: xapian:// - Simple cache: simple:// - email_url - SMTP: smtp:// - SMTP+SSL: smtp+ssl:// - SMTP+TLS: smtp+tls:// - Console mail: consolemail:// - File mail: filemail:// - LocMem mail: memorymail:// - Dummy mail: dummymail:// Tips ==== Using unsafe characters in URLs ------------------------------- In order to use unsafe characters you have to encode with ``urllib.parse.encode`` before you set into ``.env`` file. .. code-block:: DATABASE_URL=mysql://user:%23password@127.0.0.1:3306/dbname See https://perishablepress.com/stop-using-unsafe-characters-in-urls/ for reference. Multiple redis cache locations ------------------------------ For redis cache, `multiple master/slave or shard locations `_ can be configured as follows: .. code-block:: CACHE_URL='rediscache://master:6379,slave1:6379,slave2:6379/1' Email settings -------------- In order to set email configuration for django you can use this code: .. code-block:: python EMAIL_CONFIG = env.email_url( 'EMAIL_URL', default='smtp://user@:password@localhost:25') vars().update(EMAIL_CONFIG) SQLite urls ----------- SQLite connects to file based databases. The same URL format is used, omitting the hostname, and using the "file" portion as the filename of the database. This has the effect of four slashes being present for an absolute file path: sqlite:////full/path/to/your/database/file.sqlite. Tests ===== :: $ git clone git@github.com:joke2k/django-environ.git $ cd django-environ/ $ python setup.py test License ======= Django-environ is licensed under the MIT License - see the `LICENSE_FILE`_ file for details Changelog ========= `0.4.4 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Support for django-redis multiple locations (master/slave, shards) - Support for Elasticsearch2 - Support for Mysql-connector - Support for pyodbc - Add __contains__ feature to Environ class - Fix Path subtracting `0.4.3 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Rollback the default Environ to os.environ `0.4.2 - 13-April-2017 `__ -------------------------------------------------------------------------------------------- - Confirm support for Django 1.11. - Support for Redshift database URL - Fix uwsgi settings reload problem (#55) - Update support for django-redis urls (#109) `0.4.1 - 13-November-2016 `__ --------------------------------------------------------------------------------------------- - Fix for unsafe characters into URLs - Clarifying warning on missing or unreadable file. Thanks to @nickcatal - Add support for Django 1.10. - Fix support for Oracle urls - Fix support for django-redis `0.4.0 - 23-September-2015 `__ -------------------------------------------------------------------------------------------- - Fix non-ascii values (broken in Python 2.x) - New email schemes - smtp+ssl and smtp+tls (smtps would be deprecated) - redis_cache replaced by django_redis - Add tuple support. Thanks to @anonymouzz - Add LDAP url support for database (django-ldapdb) - Fix psql/pgsql url `0.3 - 03-June-2014 `__ --------------------------------------------------------------------------------------- - Add cache url support - Add email url support - Add search url support - Rewriting README.rst 0.2.1 19-April-2013 ------------------- - environ/environ.py: Env.__call__ now uses Env.get_value instance method 0.2 16-April-2013 ----------------- - environ/environ.py, environ/test.py, environ/test_env.txt: add advanced float parsing (comma and dot symbols to separate thousands and decimals) - README.rst, docs/index.rst: fix TYPO in documentation 0.1 02-April-2013 ----------------- - initial release Credits ======= - `12factor`_ - `12factor-django`_ - `Two Scoops of Django`_ - `rconradharris`_ / `envparse`_ - `kennethreitz`_ / `dj-database-url`_ - `migonzalvar`_ / `dj-email-url`_ - `ghickman`_ / `django-cache-url`_ - `dstufft`_ / `dj-search-url`_ - `julianwachholz`_ / `dj-config-url`_ - `nickstenning`_ / `honcho`_ - `envparse`_ - `Distribute`_ - `modern-package-template`_ .. _rconradharris: https://github.com/rconradharris .. _envparse: https://github.com/rconradharris/envparse .. _kennethreitz: https://github.com/kennethreitz .. _dj-database-url: https://github.com/kennethreitz/dj-database-url .. _migonzalvar: https://github.com/migonzalvar .. _dj-email-url: https://github.com/migonzalvar/dj-email-url .. _ghickman: https://github.com/ghickman .. _django-cache-url: https://github.com/ghickman/django-cache-url .. _julianwachholz: https://github.com/julianwachholz .. _dj-config-url: https://github.com/julianwachholz/dj-config-url .. _dstufft: https://github.com/dstufft .. _dj-search-url: https://github.com/dstufft/dj-search-url .. _nickstenning: https://github.com/nickstenning .. _honcho: https://github.com/nickstenning/honcho .. _12factor: http://www.12factor.net/ .. _12factor-django: http://www.wellfireinteractive.com/blog/easier-12-factor-django/ .. _`Two Scoops of Django`: http://twoscoopspress.org/ .. _Distribute: http://pypi.python.org/pypi/distribute .. _`modern-package-template`: http://pypi.python.org/pypi/modern-package-template .. _cookiecutter-django: https://github.com/pydanny/cookiecutter-django .. |pypi| image:: https://img.shields.io/pypi/v/django-environ.svg?style=flat-square&label=version :target: https://pypi.python.org/pypi/django-environ :alt: Latest version released on PyPi .. |coverage| image:: https://img.shields.io/coveralls/joke2k/django-environ/master.svg?style=flat-square :target: https://coveralls.io/r/joke2k/django-environ?branch=master :alt: Test coverage .. |unix_build| image:: https://img.shields.io/travis/joke2k/django-environ/master.svg?style=flat-square&label=unix%20build :target: http://travis-ci.org/joke2k/django-environ :alt: Build status of the master branch on Mac/Linux .. |windows_build| image:: https://img.shields.io/appveyor/ci/joke2k/django-environ.svg?style=flat-square&label=windows%20build :target: https://ci.appveyor.com/project/joke2k/django-environ :alt: Build status of the master branch on Windows .. |license| image:: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square :target: https://raw.githubusercontent.com/joke2k/django-environ/master/LICENSE.txt :alt: Package license .. _LICENSE_FILE: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt Keywords: django environment variables 12factor Platform: any Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Information Technology Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Framework :: Django :: 1.10 Classifier: Framework :: Django :: 1.11 Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Utilities Classifier: License :: OSI Approved :: MIT License Classifier: Framework :: Django django-environ-0.4.4/environ/0000775000175000017500000000000013146535252016523 5ustar joke2kjoke2k00000000000000django-environ-0.4.4/environ/test.py0000664000175000017500000007154413146535210020061 0ustar joke2kjoke2k00000000000000from __future__ import print_function import json import os import sys import unittest from django.core.exceptions import ImproperlyConfigured from environ import Env, Path, REDIS_DRIVER class BaseTests(unittest.TestCase): URL = 'http://www.google.com/' POSTGRES = 'postgres://uf07k1:wegauwhg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722' MYSQL = 'mysql://bea6eb0:69772142@us-cdbr-east.cleardb.com/heroku_97681?reconnect=true' MYSQLGIS = 'mysqlgis://user:password@127.0.0.1/some_database' SQLITE = 'sqlite:////full/path/to/your/database/file.sqlite' ORACLE_TNS = 'oracle://user:password@sid/' ORACLE = 'oracle://user:password@host:1521/sid' REDSHIFT = 'redshift://user:password@examplecluster.abc123xyz789.us-west-2.redshift.amazonaws.com:5439/dev' MEMCACHE = 'memcache://127.0.0.1:11211' REDIS = 'rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=secret' EMAIL = 'smtps://user@domain.com:password@smtp.example.com:587' JSON = dict(one='bar', two=2, three=33.44) DICT = dict(foo='bar', test='on') PATH = '/home/dev' @classmethod def generateData(cls): return dict(STR_VAR='bar', INT_VAR='42', FLOAT_VAR='33.3', FLOAT_COMMA_VAR='33,3', FLOAT_STRANGE_VAR1='123,420,333.3', FLOAT_STRANGE_VAR2='123.420.333,3', BOOL_TRUE_VAR='1', BOOL_TRUE_VAR2='True', BOOL_FALSE_VAR='0', BOOL_FALSE_VAR2='False', PROXIED_VAR='$STR_VAR', INT_LIST='42,33', INT_TUPLE='(42,33)', STR_LIST_WITH_SPACES=' foo, bar', EMPTY_LIST='', DICT_VAR='foo=bar,test=on', DATABASE_URL=cls.POSTGRES, DATABASE_MYSQL_URL=cls.MYSQL, DATABASE_MYSQL_GIS_URL=cls.MYSQLGIS, DATABASE_SQLITE_URL=cls.SQLITE, DATABASE_ORACLE_URL=cls.ORACLE, DATABASE_ORACLE_TNS_URL=cls.ORACLE_TNS, DATABASE_REDSHIFT_URL=cls.REDSHIFT, CACHE_URL=cls.MEMCACHE, CACHE_REDIS=cls.REDIS, EMAIL_URL=cls.EMAIL, URL_VAR=cls.URL, JSON_VAR=json.dumps(cls.JSON), PATH_VAR=cls.PATH) def setUp(self): self._old_environ = os.environ os.environ = Env.ENVIRON = self.generateData() self.env = Env() def tearDown(self): os.environ = self._old_environ def assertTypeAndValue(self, type_, expected, actual): self.assertEqual(type_, type(actual)) self.assertEqual(expected, actual) class EnvTests(BaseTests): def test_not_present_with_default(self): self.assertEqual(3, self.env('not_present', default=3)) def test_not_present_without_default(self): self.assertRaises(ImproperlyConfigured, self.env, 'not_present') def test_contains(self): self.assertTrue('STR_VAR' in self.env) self.assertTrue('EMPTY_LIST' in self.env) self.assertFalse('I_AM_NOT_A_VAR' in self.env) def test_str(self): self.assertTypeAndValue(str, 'bar', self.env('STR_VAR')) self.assertTypeAndValue(str, 'bar', self.env.str('STR_VAR')) def test_int(self): self.assertTypeAndValue(int, 42, self.env('INT_VAR', cast=int)) self.assertTypeAndValue(int, 42, self.env.int('INT_VAR')) def test_int_with_none_default(self): self.assertTrue(self.env('NOT_PRESENT_VAR', cast=int, default=None) is None) def test_float(self): self.assertTypeAndValue(float, 33.3, self.env('FLOAT_VAR', cast=float)) self.assertTypeAndValue(float, 33.3, self.env.float('FLOAT_VAR')) self.assertTypeAndValue(float, 33.3, self.env('FLOAT_COMMA_VAR', cast=float)) self.assertTypeAndValue(float, 123420333.3, self.env('FLOAT_STRANGE_VAR1', cast=float)) self.assertTypeAndValue(float, 123420333.3, self.env('FLOAT_STRANGE_VAR2', cast=float)) def test_bool_true(self): self.assertTypeAndValue(bool, True, self.env('BOOL_TRUE_VAR', cast=bool)) self.assertTypeAndValue(bool, True, self.env('BOOL_TRUE_VAR2', cast=bool)) self.assertTypeAndValue(bool, True, self.env.bool('BOOL_TRUE_VAR')) def test_bool_false(self): self.assertTypeAndValue(bool, False, self.env('BOOL_FALSE_VAR', cast=bool)) self.assertTypeAndValue(bool, False, self.env('BOOL_FALSE_VAR2', cast=bool)) self.assertTypeAndValue(bool, False, self.env.bool('BOOL_FALSE_VAR')) def test_proxied_value(self): self.assertTypeAndValue(str, 'bar', self.env('PROXIED_VAR')) def test_int_list(self): self.assertTypeAndValue(list, [42, 33], self.env('INT_LIST', cast=[int])) self.assertTypeAndValue(list, [42, 33], self.env.list('INT_LIST', int)) def test_int_tuple(self): self.assertTypeAndValue(tuple, (42, 33), self.env('INT_LIST', cast=(int,))) self.assertTypeAndValue(tuple, (42, 33), self.env.tuple('INT_LIST', int)) self.assertTypeAndValue(tuple, ('42', '33'), self.env.tuple('INT_LIST')) def test_str_list_with_spaces(self): self.assertTypeAndValue(list, [' foo', ' bar'], self.env('STR_LIST_WITH_SPACES', cast=[str])) self.assertTypeAndValue(list, [' foo', ' bar'], self.env.list('STR_LIST_WITH_SPACES')) def test_empty_list(self): self.assertTypeAndValue(list, [], self.env('EMPTY_LIST', cast=[int])) def test_dict_value(self): self.assertTypeAndValue(dict, self.DICT, self.env.dict('DICT_VAR')) def test_dict_parsing(self): self.assertEqual({'a': '1'}, self.env.parse_value('a=1', dict)) self.assertEqual({'a': 1}, self.env.parse_value('a=1', dict(value=int))) self.assertEqual({'a': ['1', '2', '3']}, self.env.parse_value('a=1,2,3', dict(value=[str]))) self.assertEqual({'a': [1, 2, 3]}, self.env.parse_value('a=1,2,3', dict(value=[int]))) self.assertEqual({'a': 1, 'b': [1.1, 2.2], 'c': 3}, self.env.parse_value('a=1;b=1.1,2.2;c=3', dict(value=int, cast=dict(b=[float])))) self.assertEqual({'a': "uname", 'c': "http://www.google.com", 'b': True}, self.env.parse_value('a=uname;c=http://www.google.com;b=True', dict(value=str, cast=dict(b=bool)))) def test_url_value(self): url = self.env.url('URL_VAR') self.assertEqual(url.__class__, self.env.URL_CLASS) self.assertEqual(url.geturl(), self.URL) self.assertEqual(None, self.env.url('OTHER_URL', default=None)) def test_url_encoded_parts(self): from six.moves import urllib password_with_unquoted_characters = "#password" encoded_url = "mysql://user:%s@127.0.0.1:3306/dbname" % urllib.parse.quote(password_with_unquoted_characters) parsed_url = self.env.db_url_config(encoded_url) self.assertEqual(parsed_url['PASSWORD'], password_with_unquoted_characters) def test_db_url_value(self): pg_config = self.env.db() self.assertEqual(pg_config['ENGINE'], 'django.db.backends.postgresql_psycopg2') self.assertEqual(pg_config['NAME'], 'd8r82722') self.assertEqual(pg_config['HOST'], 'ec2-107-21-253-135.compute-1.amazonaws.com') self.assertEqual(pg_config['USER'], 'uf07k1') self.assertEqual(pg_config['PASSWORD'], 'wegauwhg') self.assertEqual(pg_config['PORT'], 5431) mysql_config = self.env.db('DATABASE_MYSQL_URL') self.assertEqual(mysql_config['ENGINE'], 'django.db.backends.mysql') self.assertEqual(mysql_config['NAME'], 'heroku_97681') self.assertEqual(mysql_config['HOST'], 'us-cdbr-east.cleardb.com') self.assertEqual(mysql_config['USER'], 'bea6eb0') self.assertEqual(mysql_config['PASSWORD'], '69772142') self.assertEqual(mysql_config['PORT'], '') mysql_gis_config = self.env.db('DATABASE_MYSQL_GIS_URL') self.assertEqual(mysql_gis_config['ENGINE'], 'django.contrib.gis.db.backends.mysql') self.assertEqual(mysql_gis_config['NAME'], 'some_database') self.assertEqual(mysql_gis_config['HOST'], '127.0.0.1') self.assertEqual(mysql_gis_config['USER'], 'user') self.assertEqual(mysql_gis_config['PASSWORD'], 'password') self.assertEqual(mysql_gis_config['PORT'], '') oracle_config = self.env.db('DATABASE_ORACLE_TNS_URL') self.assertEqual(oracle_config['ENGINE'], 'django.db.backends.oracle') self.assertEqual(oracle_config['NAME'], 'sid') self.assertEqual(oracle_config['HOST'], '') self.assertEqual(oracle_config['USER'], 'user') self.assertEqual(oracle_config['PASSWORD'], 'password') self.assertFalse('PORT' in oracle_config) oracle_config = self.env.db('DATABASE_ORACLE_URL') self.assertEqual(oracle_config['ENGINE'], 'django.db.backends.oracle') self.assertEqual(oracle_config['NAME'], 'sid') self.assertEqual(oracle_config['HOST'], 'host') self.assertEqual(oracle_config['USER'], 'user') self.assertEqual(oracle_config['PASSWORD'], 'password') self.assertEqual(oracle_config['PORT'], '1521') redshift_config = self.env.db('DATABASE_REDSHIFT_URL') self.assertEqual(redshift_config['ENGINE'], 'django_redshift_backend') self.assertEqual(redshift_config['NAME'], 'dev') self.assertEqual(redshift_config['HOST'], 'examplecluster.abc123xyz789.us-west-2.redshift.amazonaws.com') self.assertEqual(redshift_config['USER'], 'user') self.assertEqual(redshift_config['PASSWORD'], 'password') self.assertEqual(redshift_config['PORT'], 5439) sqlite_config = self.env.db('DATABASE_SQLITE_URL') self.assertEqual(sqlite_config['ENGINE'], 'django.db.backends.sqlite3') self.assertEqual(sqlite_config['NAME'], '/full/path/to/your/database/file.sqlite') def test_cache_url_value(self): cache_config = self.env.cache_url() self.assertEqual(cache_config['BACKEND'], 'django.core.cache.backends.memcached.MemcachedCache') self.assertEqual(cache_config['LOCATION'], '127.0.0.1:11211') redis_config = self.env.cache_url('CACHE_REDIS') self.assertEqual(redis_config['BACKEND'], 'django_redis.cache.RedisCache') self.assertEqual(redis_config['LOCATION'], 'redis://127.0.0.1:6379/1') self.assertEqual(redis_config['OPTIONS'], { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PASSWORD': 'secret', }) def test_email_url_value(self): email_config = self.env.email_url() self.assertEqual(email_config['EMAIL_BACKEND'], 'django.core.mail.backends.smtp.EmailBackend') self.assertEqual(email_config['EMAIL_HOST'], 'smtp.example.com') self.assertEqual(email_config['EMAIL_HOST_PASSWORD'], 'password') self.assertEqual(email_config['EMAIL_HOST_USER'], 'user@domain.com') self.assertEqual(email_config['EMAIL_PORT'], 587) self.assertEqual(email_config['EMAIL_USE_TLS'], True) def test_json_value(self): self.assertEqual(self.JSON, self.env.json('JSON_VAR')) def test_path(self): root = self.env.path('PATH_VAR') self.assertTypeAndValue(Path, Path(self.PATH), root) class FileEnvTests(EnvTests): def setUp(self): super(FileEnvTests, self).setUp() Env.ENVIRON = {} self.env = Env() file_path = Path(__file__, is_file=True)('test_env.txt') self.env.read_env(file_path, PATH_VAR=Path(__file__, is_file=True).__root__) class SubClassTests(EnvTests): def setUp(self): super(SubClassTests, self).setUp() self.CONFIG = self.generateData() class MyEnv(Env): ENVIRON = self.CONFIG self.env = MyEnv() def test_singleton_environ(self): self.assertTrue(self.CONFIG is self.env.ENVIRON) class SchemaEnvTests(BaseTests): def test_schema(self): env = Env(INT_VAR=int, NOT_PRESENT_VAR=(float, 33.3), STR_VAR=str, INT_LIST=[int], DEFAULT_LIST=([int], [2])) self.assertTypeAndValue(int, 42, env('INT_VAR')) self.assertTypeAndValue(float, 33.3, env('NOT_PRESENT_VAR')) self.assertTypeAndValue(str, 'bar', env('STR_VAR')) self.assertTypeAndValue(str, 'foo', env('NOT_PRESENT2', default='foo')) self.assertTypeAndValue(list, [42, 33], env('INT_LIST')) self.assertTypeAndValue(list, [2], env('DEFAULT_LIST')) # Override schema in this one case self.assertTypeAndValue(str, '42', env('INT_VAR', cast=str)) class DatabaseTestSuite(unittest.TestCase): def test_postgres_parsing(self): url = 'postgres://uf07k1i6d8ia0v:wegauwhgeuioweg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722r2kuvn' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.db.backends.postgresql_psycopg2') self.assertEqual(url['NAME'], 'd8r82722r2kuvn') self.assertEqual(url['HOST'], 'ec2-107-21-253-135.compute-1.amazonaws.com') self.assertEqual(url['USER'], 'uf07k1i6d8ia0v') self.assertEqual(url['PASSWORD'], 'wegauwhgeuioweg') self.assertEqual(url['PORT'], 5431) def test_postgis_parsing(self): url = 'postgis://uf07k1i6d8ia0v:wegauwhgeuioweg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722r2kuvn' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.contrib.gis.db.backends.postgis') self.assertEqual(url['NAME'], 'd8r82722r2kuvn') self.assertEqual(url['HOST'], 'ec2-107-21-253-135.compute-1.amazonaws.com') self.assertEqual(url['USER'], 'uf07k1i6d8ia0v') self.assertEqual(url['PASSWORD'], 'wegauwhgeuioweg') self.assertEqual(url['PORT'], 5431) def test_mysql_gis_parsing(self): url = 'mysqlgis://uf07k1i6d8ia0v:wegauwhgeuioweg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722r2kuvn' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.contrib.gis.db.backends.mysql') self.assertEqual(url['NAME'], 'd8r82722r2kuvn') self.assertEqual(url['HOST'], 'ec2-107-21-253-135.compute-1.amazonaws.com') self.assertEqual(url['USER'], 'uf07k1i6d8ia0v') self.assertEqual(url['PASSWORD'], 'wegauwhgeuioweg') self.assertEqual(url['PORT'], 5431) def test_cleardb_parsing(self): url = 'mysql://bea6eb025ca0d8:69772142@us-cdbr-east.cleardb.com/heroku_97681db3eff7580?reconnect=true' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.db.backends.mysql') self.assertEqual(url['NAME'], 'heroku_97681db3eff7580') self.assertEqual(url['HOST'], 'us-cdbr-east.cleardb.com') self.assertEqual(url['USER'], 'bea6eb025ca0d8') self.assertEqual(url['PASSWORD'], '69772142') self.assertEqual(url['PORT'], '') def test_mysql_no_password(self): url = 'mysql://travis@localhost/test_db' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.db.backends.mysql') self.assertEqual(url['NAME'], 'test_db') self.assertEqual(url['HOST'], 'localhost') self.assertEqual(url['USER'], 'travis') self.assertEqual(url['PASSWORD'], '') self.assertEqual(url['PORT'], '') def test_empty_sqlite_url(self): url = 'sqlite://' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.db.backends.sqlite3') self.assertEqual(url['NAME'], ':memory:') def test_memory_sqlite_url(self): url = 'sqlite://:memory:' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'django.db.backends.sqlite3') self.assertEqual(url['NAME'], ':memory:') def test_database_options_parsing(self): url = 'postgres://user:pass@host:1234/dbname?conn_max_age=600' url = Env.db_url_config(url) self.assertEqual(url['CONN_MAX_AGE'], 600) url = 'mysql://user:pass@host:1234/dbname?init_command=SET storage_engine=INNODB' url = Env.db_url_config(url) self.assertEqual(url['OPTIONS'], { 'init_command': 'SET storage_engine=INNODB', }) def test_database_ldap_url(self): url = 'ldap://cn=admin,dc=nodomain,dc=org:some_secret_password@ldap.nodomain.org/' url = Env.db_url_config(url) self.assertEqual(url['ENGINE'], 'ldapdb.backends.ldap') self.assertEqual(url['HOST'], 'ldap.nodomain.org') self.assertEqual(url['PORT'], '') self.assertEqual(url['NAME'], 'ldap://ldap.nodomain.org') self.assertEqual(url['USER'], 'cn=admin,dc=nodomain,dc=org') self.assertEqual(url['PASSWORD'], 'some_secret_password') class CacheTestSuite(unittest.TestCase): def test_memcache_parsing(self): url = 'memcache://127.0.0.1:11211' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.memcached.MemcachedCache') self.assertEqual(url['LOCATION'], '127.0.0.1:11211') def test_memcache_pylib_parsing(self): url = 'pymemcache://127.0.0.1:11211' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.memcached.PyLibMCCache') self.assertEqual(url['LOCATION'], '127.0.0.1:11211') def test_memcache_multiple_parsing(self): url = 'memcache://172.19.26.240:11211,172.19.26.242:11212' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.memcached.MemcachedCache') self.assertEqual(url['LOCATION'], ['172.19.26.240:11211', '172.19.26.242:11212']) def test_memcache_socket_parsing(self): url = 'memcache:///tmp/memcached.sock' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.memcached.MemcachedCache') self.assertEqual(url['LOCATION'], 'unix:/tmp/memcached.sock') def test_dbcache_parsing(self): url = 'dbcache://my_cache_table' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.db.DatabaseCache') self.assertEqual(url['LOCATION'], 'my_cache_table') def test_filecache_parsing(self): url = 'filecache:///var/tmp/django_cache' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.filebased.FileBasedCache') self.assertEqual(url['LOCATION'], '/var/tmp/django_cache') def test_filecache_windows_parsing(self): url = 'filecache://C:/foo/bar' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.filebased.FileBasedCache') self.assertEqual(url['LOCATION'], 'C:/foo/bar') def test_locmem_parsing(self): url = 'locmemcache://' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.locmem.LocMemCache') self.assertEqual(url['LOCATION'], '') def test_locmem_named_parsing(self): url = 'locmemcache://unique-snowflake' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.locmem.LocMemCache') self.assertEqual(url['LOCATION'], 'unique-snowflake') def test_dummycache_parsing(self): url = 'dummycache://' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.dummy.DummyCache') self.assertEqual(url['LOCATION'], '') def test_redis_parsing(self): url = 'rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=secret' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], REDIS_DRIVER) self.assertEqual(url['LOCATION'], 'redis://127.0.0.1:6379/1') self.assertEqual(url['OPTIONS'], { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PASSWORD': 'secret', }) def test_redis_socket_parsing(self): url = 'rediscache:///path/to/socket:1' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django_redis.cache.RedisCache') self.assertEqual(url['LOCATION'], 'unix:///path/to/socket:1') def test_redis_with_password_parsing(self): url = 'rediscache://:redispass@127.0.0.1:6379/0' url = Env.cache_url_config(url) self.assertEqual(REDIS_DRIVER, url['BACKEND']) self.assertEqual(url['LOCATION'], 'redis://:redispass@127.0.0.1:6379/0') def test_redis_multi_location_parsing(self): url = 'rediscache://host1:6379,host2:6379,host3:9999/1' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], REDIS_DRIVER) self.assertEqual(url['LOCATION'], [ 'redis://host1:6379/1', 'redis://host2:6379/1', 'redis://host3:9999/1', ]) def test_redis_socket_url(self): url = 'redis://:redispass@/path/to/socket.sock?db=0' url = Env.cache_url_config(url) self.assertEqual(REDIS_DRIVER, url['BACKEND']) self.assertEqual(url['LOCATION'], 'unix://:redispass@/path/to/socket.sock') self.assertEqual(url['OPTIONS'], { 'DB': 0 }) def test_options_parsing(self): url = 'filecache:///var/tmp/django_cache?timeout=60&max_entries=1000&cull_frequency=0' url = Env.cache_url_config(url) self.assertEqual(url['BACKEND'], 'django.core.cache.backends.filebased.FileBasedCache') self.assertEqual(url['LOCATION'], '/var/tmp/django_cache') self.assertEqual(url['TIMEOUT'], 60) self.assertEqual(url['OPTIONS'], { 'MAX_ENTRIES': 1000, 'CULL_FREQUENCY': 0, }) def test_custom_backend(self): url = 'memcache://127.0.0.1:5400?foo=option&bars=9001' backend = 'django_redis.cache.RedisCache' url = Env.cache_url_config(url, backend) self.assertEqual(url['BACKEND'], backend) self.assertEqual(url['LOCATION'], '127.0.0.1:5400') self.assertEqual(url['OPTIONS'], { 'FOO': 'option', 'BARS': 9001, }) class SearchTestSuite(unittest.TestCase): solr_url = 'solr://127.0.0.1:8983/solr' elasticsearch_url = 'elasticsearch://127.0.0.1:9200/index' whoosh_url = 'whoosh:///home/search/whoosh_index' xapian_url = 'xapian:///home/search/xapian_index' simple_url = 'simple:///' def test_solr_parsing(self): url = Env.search_url_config(self.solr_url) self.assertEqual(url['ENGINE'], 'haystack.backends.solr_backend.SolrEngine') self.assertEqual(url['URL'], 'http://127.0.0.1:8983/solr') def test_solr_multicore_parsing(self): timeout = 360 index = 'solr_index' url = '%s/%s?TIMEOUT=%s' % (self.solr_url, index, timeout) url = Env.search_url_config(url) self.assertEqual(url['ENGINE'], 'haystack.backends.solr_backend.SolrEngine') self.assertEqual(url['URL'], 'http://127.0.0.1:8983/solr/solr_index') self.assertEqual(url['TIMEOUT'], timeout) self.assertTrue('INDEX_NAME' not in url) self.assertTrue('PATH' not in url) def test_elasticsearch_parsing(self): timeout = 360 url = '%s?TIMEOUT=%s' % (self.elasticsearch_url, timeout) url = Env.search_url_config(url) self.assertEqual(url['ENGINE'], 'haystack.backends.elasticsearch_backend.ElasticsearchSearchEngine') self.assertTrue('INDEX_NAME' in url.keys()) self.assertEqual(url['INDEX_NAME'], 'index') self.assertTrue('TIMEOUT' in url.keys()) self.assertEqual(url['TIMEOUT'], timeout) self.assertTrue('PATH' not in url) def test_whoosh_parsing(self): storage = 'file' # or ram post_limit = 128 * 1024 * 1024 url = '%s?STORAGE=%s&POST_LIMIT=%s' % (self.whoosh_url, storage, post_limit) url = Env.search_url_config(url) self.assertEqual(url['ENGINE'], 'haystack.backends.whoosh_backend.WhooshEngine') self.assertTrue('PATH' in url.keys()) self.assertEqual(url['PATH'], '/home/search/whoosh_index') self.assertTrue('STORAGE' in url.keys()) self.assertEqual(url['STORAGE'], storage) self.assertTrue('POST_LIMIT' in url.keys()) self.assertEqual(url['POST_LIMIT'], post_limit) self.assertTrue('INDEX_NAME' not in url) def test_xapian_parsing(self): flags = 'myflags' url = '%s?FLAGS=%s' % (self.xapian_url, flags) url = Env.search_url_config(url) self.assertEqual(url['ENGINE'], 'haystack.backends.xapian_backend.XapianEngine') self.assertTrue('PATH' in url.keys()) self.assertEqual(url['PATH'], '/home/search/xapian_index') self.assertTrue('FLAGS' in url.keys()) self.assertEqual(url['FLAGS'], flags) self.assertTrue('INDEX_NAME' not in url) def test_simple_parsing(self): url = Env.search_url_config(self.simple_url) self.assertEqual(url['ENGINE'], 'haystack.backends.simple_backend.SimpleEngine') self.assertTrue('INDEX_NAME' not in url) self.assertTrue('PATH' not in url) def test_common_args_parsing(self): excluded_indexes = 'myapp.indexes.A,myapp.indexes.B' include_spelling = 1 batch_size = 100 params = 'EXCLUDED_INDEXES=%s&INCLUDE_SPELLING=%s&BATCH_SIZE=%s' % ( excluded_indexes, include_spelling, batch_size ) for url in [ self.solr_url, self.elasticsearch_url, self.whoosh_url, self.xapian_url, self.simple_url, ]: url = '?'.join([url, params]) url = Env.search_url_config(url) self.assertTrue('EXCLUDED_INDEXES' in url.keys()) self.assertTrue('myapp.indexes.A' in url['EXCLUDED_INDEXES']) self.assertTrue('myapp.indexes.B' in url['EXCLUDED_INDEXES']) self.assertTrue('INCLUDE_SPELLING'in url.keys()) self.assertTrue(url['INCLUDE_SPELLING']) self.assertTrue('BATCH_SIZE' in url.keys()) self.assertEqual(url['BATCH_SIZE'], 100) class EmailTests(unittest.TestCase): def test_smtp_parsing(self): url = 'smtps://user@domain.com:password@smtp.example.com:587' url = Env.email_url_config(url) self.assertEqual(url['EMAIL_BACKEND'], 'django.core.mail.backends.smtp.EmailBackend') self.assertEqual(url['EMAIL_HOST'], 'smtp.example.com') self.assertEqual(url['EMAIL_HOST_PASSWORD'], 'password') self.assertEqual(url['EMAIL_HOST_USER'], 'user@domain.com') self.assertEqual(url['EMAIL_PORT'], 587) self.assertEqual(url['EMAIL_USE_TLS'], True) class PathTests(unittest.TestCase): def test_path_class(self): root = Path(__file__, '..', is_file=True) root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '../')) self.assertEqual(root(), root_path) self.assertEqual(root.__root__, root_path) web = root.path('public') self.assertEqual(web(), os.path.join(root_path, 'public')) self.assertEqual(web('css'), os.path.join(root_path, 'public', 'css')) def test_required_path(self): self.assertRaises(ImproperlyConfigured, Path, '/not/existing/path/', required=True) self.assertRaises(ImproperlyConfigured, Path(__file__), 'not_existing_path', required=True) def test_comparison(self): self.assertTrue(Path('/home') in Path('/')) self.assertTrue(Path('/home') not in Path('/other/dir')) self.assertTrue(Path('/home') == Path('/home')) self.assertTrue(Path('/home') != Path('/home/dev')) self.assertEqual(Path('/home/foo/').rfind('/'), str(Path('/home/foo')).rfind('/')) self.assertEqual(Path('/home/foo/').find('/home'), str(Path('/home/foo/')).find('/home')) self.assertEqual(Path('/home/foo/')[1], str(Path('/home/foo/'))[1]) self.assertEqual(~Path('/home'), Path('/')) self.assertEqual(Path('/') + 'home', Path('/home')) self.assertEqual(Path('/') + '/home/public', Path('/home/public')) self.assertEqual(Path('/home/dev/public') - 2, Path('/home')) self.assertEqual(Path('/home/dev/public') - 'public', Path('/home/dev')) self.assertRaises(TypeError, lambda _: Path('/home/dev/') - 'not int') def load_suite(): test_suite = unittest.TestSuite() cases = [ EnvTests, FileEnvTests, SubClassTests, SchemaEnvTests, PathTests, DatabaseTestSuite, CacheTestSuite, EmailTests, SearchTestSuite ] for case in cases: test_suite.addTest(unittest.makeSuite(case)) return test_suite if __name__ == "__main__": try: if sys.argv[1] == '-o': for key, value in BaseTests.generateData().items(): print("{0}={1}".format(key, value)) sys.exit() except IndexError: pass unittest.TextTestRunner().run(load_suite()) django-environ-0.4.4/environ/__init__.py0000664000175000017500000000002713146517103020626 0ustar joke2kjoke2k00000000000000from .environ import * django-environ-0.4.4/environ/environ.py0000664000175000017500000006540213146535210020556 0ustar joke2kjoke2k00000000000000""" Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. """ import json import logging import os import re import sys import warnings try: from django.core.exceptions import ImproperlyConfigured except ImportError: class ImproperlyConfigured(Exception): pass from six.moves import urllib from six import string_types logger = logging.getLogger(__name__) VERSION = '0.4.4' __author__ = 'joke2k' __version__ = tuple(VERSION.split('.')) # return int if possible def _cast_int(v): return int(v) if hasattr(v, 'isdigit') and v.isdigit() else v def _cast_urlstr(v): return urllib.parse.unquote_plus(v) if isinstance(v, str) else v # back compatibility with redis_cache package DJANGO_REDIS_DRIVER = 'django_redis.cache.RedisCache' DJANGO_REDIS_CACHE_DRIVER = 'redis_cache.RedisCache' REDIS_DRIVER = DJANGO_REDIS_DRIVER try: import redis_cache REDIS_DRIVER = DJANGO_REDIS_CACHE_DRIVER except: pass class NoValue(object): def __repr__(self): return '<{0}>'.format(self.__class__.__name__) class Env(object): """Provide scheme-based lookups of environment variables so that each caller doesn't have to pass in `cast` and `default` parameters. Usage::: env = Env(MAIL_ENABLED=bool, SMTP_LOGIN=(str, 'DEFAULT')) if env('MAIL_ENABLED'): ... """ ENVIRON = os.environ NOTSET = NoValue() BOOLEAN_TRUE_STRINGS = ('true', 'on', 'ok', 'y', 'yes', '1') URL_CLASS = urllib.parse.ParseResult DEFAULT_DATABASE_ENV = 'DATABASE_URL' DB_SCHEMES = { 'postgres': 'django.db.backends.postgresql_psycopg2', 'postgresql': 'django.db.backends.postgresql_psycopg2', 'psql': 'django.db.backends.postgresql_psycopg2', 'pgsql': 'django.db.backends.postgresql_psycopg2', 'postgis': 'django.contrib.gis.db.backends.postgis', 'mysql': 'django.db.backends.mysql', 'mysql2': 'django.db.backends.mysql', 'mysql-connector': 'mysql.connector.django', 'mysqlgis': 'django.contrib.gis.db.backends.mysql', 'oracle': 'django.db.backends.oracle', 'pyodbc': 'sql_server.pyodbc', 'redshift': 'django_redshift_backend', 'spatialite': 'django.contrib.gis.db.backends.spatialite', 'sqlite': 'django.db.backends.sqlite3', 'ldap': 'ldapdb.backends.ldap', } _DB_BASE_OPTIONS = ['CONN_MAX_AGE', 'ATOMIC_REQUESTS', 'AUTOCOMMIT'] DEFAULT_CACHE_ENV = 'CACHE_URL' CACHE_SCHEMES = { 'dbcache': 'django.core.cache.backends.db.DatabaseCache', 'dummycache': 'django.core.cache.backends.dummy.DummyCache', 'filecache': 'django.core.cache.backends.filebased.FileBasedCache', 'locmemcache': 'django.core.cache.backends.locmem.LocMemCache', 'memcache': 'django.core.cache.backends.memcached.MemcachedCache', 'pymemcache': 'django.core.cache.backends.memcached.PyLibMCCache', 'rediscache': REDIS_DRIVER, 'redis': REDIS_DRIVER, } _CACHE_BASE_OPTIONS = ['TIMEOUT', 'KEY_PREFIX', 'VERSION', 'KEY_FUNCTION', 'BINARY'] DEFAULT_EMAIL_ENV = 'EMAIL_URL' EMAIL_SCHEMES = { 'smtp': 'django.core.mail.backends.smtp.EmailBackend', 'smtps': 'django.core.mail.backends.smtp.EmailBackend', 'smtp+tls': 'django.core.mail.backends.smtp.EmailBackend', 'smtp+ssl': 'django.core.mail.backends.smtp.EmailBackend', 'consolemail': 'django.core.mail.backends.console.EmailBackend', 'filemail': 'django.core.mail.backends.filebased.EmailBackend', 'memorymail': 'django.core.mail.backends.locmem.EmailBackend', 'dummymail': 'django.core.mail.backends.dummy.EmailBackend' } _EMAIL_BASE_OPTIONS = ['EMAIL_USE_TLS', 'EMAIL_USE_SSL'] DEFAULT_SEARCH_ENV = 'SEARCH_URL' SEARCH_SCHEMES = { "elasticsearch": "haystack.backends.elasticsearch_backend.ElasticsearchSearchEngine", "elasticsearch2": "haystack.backends.elasticsearch2_backend.Elasticsearch2SearchEngine", "solr": "haystack.backends.solr_backend.SolrEngine", "whoosh": "haystack.backends.whoosh_backend.WhooshEngine", "xapian": "haystack.backends.xapian_backend.XapianEngine", "simple": "haystack.backends.simple_backend.SimpleEngine", } def __init__(self, **scheme): self.scheme = scheme def __call__(self, var, cast=None, default=NOTSET, parse_default=False): return self.get_value(var, cast=cast, default=default, parse_default=parse_default) def __contains__(self, var): return var in self.ENVIRON # Shortcuts def str(self, var, default=NOTSET): """ :rtype: str """ return self.get_value(var, default=default) def unicode(self, var, default=NOTSET): """Helper for python2 :rtype: unicode """ return self.get_value(var, cast=str, default=default) def bool(self, var, default=NOTSET): """ :rtype: bool """ return self.get_value(var, cast=bool, default=default) def int(self, var, default=NOTSET): """ :rtype: int """ return self.get_value(var, cast=int, default=default) def float(self, var, default=NOTSET): """ :rtype: float """ return self.get_value(var, cast=float, default=default) def json(self, var, default=NOTSET): """ :returns: Json parsed """ return self.get_value(var, cast=json.loads, default=default) def list(self, var, cast=None, default=NOTSET): """ :rtype: list """ return self.get_value(var, cast=list if not cast else [cast], default=default) def tuple(self, var, cast=None, default=NOTSET): """ :rtype: tuple """ return self.get_value(var, cast=tuple if not cast else (cast,), default=default) def dict(self, var, cast=dict, default=NOTSET): """ :rtype: dict """ return self.get_value(var, cast=cast, default=default) def url(self, var, default=NOTSET): """ :rtype: urlparse.ParseResult """ return self.get_value(var, cast=urllib.parse.urlparse, default=default, parse_default=True) def db_url(self, var=DEFAULT_DATABASE_ENV, default=NOTSET, engine=None): """Returns a config dictionary, defaulting to DATABASE_URL. :rtype: dict """ return self.db_url_config(self.get_value(var, default=default), engine=engine) db = db_url def cache_url(self, var=DEFAULT_CACHE_ENV, default=NOTSET, backend=None): """Returns a config dictionary, defaulting to CACHE_URL. :rtype: dict """ return self.cache_url_config(self.url(var, default=default), backend=backend) cache = cache_url def email_url(self, var=DEFAULT_EMAIL_ENV, default=NOTSET, backend=None): """Returns a config dictionary, defaulting to EMAIL_URL. :rtype: dict """ return self.email_url_config(self.url(var, default=default), backend=backend) email = email_url def search_url(self, var=DEFAULT_SEARCH_ENV, default=NOTSET, engine=None): """Returns a config dictionary, defaulting to SEARCH_URL. :rtype: dict """ return self.search_url_config(self.url(var, default=default), engine=engine) def path(self, var, default=NOTSET, **kwargs): """ :rtype: Path """ return Path(self.get_value(var, default=default), **kwargs) def get_value(self, var, cast=None, default=NOTSET, parse_default=False): """Return value for given environment variable. :param var: Name of variable. :param cast: Type to cast return value as. :param default: If var not present in environ, return this instead. :param parse_default: force to parse default.. :returns: Value from environment or default (if set) """ logger.debug("get '{0}' casted as '{1}' with default '{2}'".format( var, cast, default )) if var in self.scheme: var_info = self.scheme[var] try: has_default = len(var_info) == 2 except TypeError: has_default = False if has_default: if not cast: cast = var_info[0] if default is self.NOTSET: try: default = var_info[1] except IndexError: pass else: if not cast: cast = var_info try: value = self.ENVIRON[var] except KeyError: if default is self.NOTSET: error_msg = "Set the {0} environment variable".format(var) raise ImproperlyConfigured(error_msg) value = default # Resolve any proxied values if hasattr(value, 'startswith') and value.startswith('$'): value = value.lstrip('$') value = self.get_value(value, cast=cast, default=default) if value != default or (parse_default and value): value = self.parse_value(value, cast) return value # Class and static methods @classmethod def parse_value(cls, value, cast): """Parse and cast provided value :param value: Stringed value. :param cast: Type to cast return value as. :returns: Casted value """ if cast is None: return value elif cast is bool: try: value = int(value) != 0 except ValueError: value = value.lower() in cls.BOOLEAN_TRUE_STRINGS elif isinstance(cast, list): value = list(map(cast[0], [x for x in value.split(',') if x])) elif isinstance(cast, tuple): val = value.strip('(').strip(')').split(',') value = tuple(map(cast[0], [x for x in val if x])) elif isinstance(cast, dict): key_cast = cast.get('key', str) value_cast = cast.get('value', str) value_cast_by_key = cast.get('cast', dict()) value = dict(map( lambda kv: ( key_cast(kv[0]), cls.parse_value(kv[1], value_cast_by_key.get(kv[0], value_cast)) ), [val.split('=') for val in value.split(';') if val] )) elif cast is dict: value = dict([val.split('=') for val in value.split(',') if val]) elif cast is list: value = [x for x in value.split(',') if x] elif cast is tuple: val = value.strip('(').strip(')').split(',') value = tuple([x for x in val if x]) elif cast is float: # clean string float_str = re.sub(r'[^\d,\.]', '', value) # split for avoid thousand separator and different locale comma/dot symbol parts = re.split(r'[,\.]', float_str) if len(parts) == 1: float_str = parts[0] else: float_str = "{0}.{1}".format(''.join(parts[0:-1]), parts[-1]) value = float(float_str) else: value = cast(value) return value @classmethod def db_url_config(cls, url, engine=None): """Pulled from DJ-Database-URL, parse an arbitrary Database URL. Support currently exists for PostgreSQL, PostGIS, MySQL, Oracle and SQLite. SQLite connects to file based databases. The same URL format is used, omitting the hostname, and using the "file" portion as the filename of the database. This has the effect of four slashes being present for an absolute file path: >>> from environ import Env >>> Env.db_url_config('sqlite:////full/path/to/your/file.sqlite') {'ENGINE': 'django.db.backends.sqlite3', 'HOST': '', 'NAME': '/full/path/to/your/file.sqlite', 'PASSWORD': '', 'PORT': '', 'USER': ''} >>> Env.db_url_config('postgres://uf07k1i6d8ia0v:wegauwhgeuioweg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722r2kuvn') {'ENGINE': 'django.db.backends.postgresql_psycopg2', 'HOST': 'ec2-107-21-253-135.compute-1.amazonaws.com', 'NAME': 'd8r82722r2kuvn', 'PASSWORD': 'wegauwhgeuioweg', 'PORT': 5431, 'USER': 'uf07k1i6d8ia0v'} """ if not isinstance(url, cls.URL_CLASS): if url == 'sqlite://:memory:': # this is a special case, because if we pass this URL into # urlparse, urlparse will choke trying to interpret "memory" # as a port number return { 'ENGINE': cls.DB_SCHEMES['sqlite'], 'NAME': ':memory:' } # note: no other settings are required for sqlite url = urllib.parse.urlparse(url) config = {} # Remove query strings. path = url.path[1:] path = urllib.parse.unquote_plus(path.split('?', 2)[0]) # if we are using sqlite and we have no path, then assume we # want an in-memory database (this is the behaviour of sqlalchemy) if url.scheme == 'sqlite' and path == '': path = ':memory:' if url.scheme == 'ldap': path = '{scheme}://{hostname}'.format(scheme=url.scheme, hostname=url.hostname) if url.port: path += ':{port}'.format(port=url.port) # Update with environment configuration. config.update({ 'NAME': path or '', 'USER': _cast_urlstr(url.username) or '', 'PASSWORD': _cast_urlstr(url.password) or '', 'HOST': url.hostname or '', 'PORT': _cast_int(url.port) or '', }) if url.scheme == 'oracle' and path == '': config['NAME'] = config['HOST'] config['HOST'] = '' if url.scheme == 'oracle': # Django oracle/base.py strips port and fails on non-string value if not config['PORT']: del(config['PORT']) else: config['PORT'] = str(config['PORT']) if url.query: config_options = {} for k, v in urllib.parse.parse_qs(url.query).items(): if k.upper() in cls._DB_BASE_OPTIONS: config.update({k.upper(): _cast_int(v[0])}) else: config_options.update({k: _cast_int(v[0])}) config['OPTIONS'] = config_options if engine: config['ENGINE'] = engine if url.scheme in Env.DB_SCHEMES: config['ENGINE'] = Env.DB_SCHEMES[url.scheme] if not config.get('ENGINE', False): warnings.warn("Engine not recognized from url: {0}".format(config)) return {} return config @classmethod def cache_url_config(cls, url, backend=None): """Pulled from DJ-Cache-URL, parse an arbitrary Cache URL. :param url: :param backend: :return: """ url = urllib.parse.urlparse(url) if not isinstance(url, cls.URL_CLASS) else url location = url.netloc.split(',') if len(location) == 1: location = location[0] config = { 'BACKEND': cls.CACHE_SCHEMES[url.scheme], 'LOCATION': location, } # Add the drive to LOCATION if url.scheme == 'filecache': config.update({ 'LOCATION': url.netloc + url.path, }) if url.path and url.scheme in ['memcache', 'pymemcache']: config.update({ 'LOCATION': 'unix:' + url.path, }) elif url.scheme.startswith('redis'): if url.hostname: scheme = url.scheme.replace('cache', '') else: scheme = 'unix' locations = [scheme + '://' + loc + url.path for loc in url.netloc.split(',')] config['LOCATION'] = locations[0] if len(locations) == 1 else locations if url.query: config_options = {} for k, v in urllib.parse.parse_qs(url.query).items(): opt = {k.upper(): _cast_int(v[0])} if k.upper() in cls._CACHE_BASE_OPTIONS: config.update(opt) else: config_options.update(opt) config['OPTIONS'] = config_options if backend: config['BACKEND'] = backend return config @classmethod def email_url_config(cls, url, backend=None): """Parses an email URL.""" config = {} url = urllib.parse.urlparse(url) if not isinstance(url, cls.URL_CLASS) else url # Remove query strings path = url.path[1:] path = urllib.parse.unquote_plus(path.split('?', 2)[0]) # Update with environment configuration config.update({ 'EMAIL_FILE_PATH': path, 'EMAIL_HOST_USER': _cast_urlstr(url.username), 'EMAIL_HOST_PASSWORD': _cast_urlstr(url.password), 'EMAIL_HOST': url.hostname, 'EMAIL_PORT': _cast_int(url.port), }) if backend: config['EMAIL_BACKEND'] = backend elif url.scheme not in cls.EMAIL_SCHEMES: raise ImproperlyConfigured('Invalid email schema %s' % url.scheme) elif url.scheme in cls.EMAIL_SCHEMES: config['EMAIL_BACKEND'] = cls.EMAIL_SCHEMES[url.scheme] if url.scheme in ('smtps', 'smtp+tls'): config['EMAIL_USE_TLS'] = True elif url.scheme == 'smtp+ssl': config['EMAIL_USE_SSL'] = True if url.query: config_options = {} for k, v in urllib.parse.parse_qs(url.query).items(): opt = {k.upper(): _cast_int(v[0])} if k.upper() in cls._EMAIL_BASE_OPTIONS: config.update(opt) else: config_options.update(opt) config['OPTIONS'] = config_options return config @classmethod def search_url_config(cls, url, engine=None): config = {} url = urllib.parse.urlparse(url) if not isinstance(url, cls.URL_CLASS) else url # Remove query strings. path = url.path[1:] path = urllib.parse.unquote_plus(path.split('?', 2)[0]) if url.scheme not in cls.SEARCH_SCHEMES: raise ImproperlyConfigured('Invalid search schema %s' % url.scheme) config["ENGINE"] = cls.SEARCH_SCHEMES[url.scheme] # check commons params params = {} if url.query: params = urllib.parse.parse_qs(url.query) if 'EXCLUDED_INDEXES' in params.keys(): config['EXCLUDED_INDEXES'] = params['EXCLUDED_INDEXES'][0].split(',') if 'INCLUDE_SPELLING' in params.keys(): config['INCLUDE_SPELLING'] = cls.parse_value(params['INCLUDE_SPELLING'][0], bool) if 'BATCH_SIZE' in params.keys(): config['BATCH_SIZE'] = cls.parse_value(params['BATCH_SIZE'][0], int) if url.scheme == 'simple': return config elif url.scheme in ['solr', 'elasticsearch', 'elasticsearch2']: if 'KWARGS' in params.keys(): config['KWARGS'] = params['KWARGS'][0] # remove trailing slash if path.endswith("/"): path = path[:-1] if url.scheme == 'solr': config['URL'] = urllib.parse.urlunparse(('http',) + url[1:2] + (path,) + ('', '', '')) if 'TIMEOUT' in params.keys(): config['TIMEOUT'] = cls.parse_value(params['TIMEOUT'][0], int) return config if url.scheme in ['elasticsearch', 'elasticsearch2']: split = path.rsplit("/", 1) if len(split) > 1: path = "/".join(split[:-1]) index = split[-1] else: path = "" index = split[0] config['URL'] = urllib.parse.urlunparse(('http',) + url[1:2] + (path,) + ('', '', '')) if 'TIMEOUT' in params.keys(): config['TIMEOUT'] = cls.parse_value(params['TIMEOUT'][0], int) config['INDEX_NAME'] = index return config config['PATH'] = '/' + path if url.scheme == 'whoosh': if 'STORAGE' in params.keys(): config['STORAGE'] = params['STORAGE'][0] if 'POST_LIMIT' in params.keys(): config['POST_LIMIT'] = cls.parse_value(params['POST_LIMIT'][0], int) elif url.scheme == 'xapian': if 'FLAGS' in params.keys(): config['FLAGS'] = params['FLAGS'][0] if engine: config['ENGINE'] = engine return config @classmethod def read_env(cls, env_file=None, **overrides): """Read a .env file into os.environ. If not given a path to a dotenv path, does filthy magic stack backtracking to find manage.py and then find the dotenv. http://www.wellfireinteractive.com/blog/easier-12-factor-django/ https://gist.github.com/bennylope/2999704 """ if env_file is None: frame = sys._getframe() env_file = os.path.join(os.path.dirname(frame.f_back.f_code.co_filename), '.env') if not os.path.exists(env_file): warnings.warn( "%s doesn't exist - if you're not configuring your " "environment separately, create one." % env_file) return try: with open(env_file) if isinstance(env_file, string_types) else env_file as f: content = f.read() except IOError: warnings.warn( "Error reading %s - if you're not configuring your " "environment separately, check this." % env_file) return logger.debug('Read environment variables from: {0}'.format(env_file)) for line in content.splitlines(): m1 = re.match(r'\A([A-Za-z_0-9]+)=(.*)\Z', line) if m1: key, val = m1.group(1), m1.group(2) m2 = re.match(r"\A'(.*)'\Z", val) if m2: val = m2.group(1) m3 = re.match(r'\A"(.*)"\Z', val) if m3: val = re.sub(r'\\(.)', r'\1', m3.group(1)) cls.ENVIRON.setdefault(key, str(val)) # set defaults for key, value in overrides.items(): cls.ENVIRON.setdefault(key, value) class Path(object): """Inspired to Django Two-scoops, handling File Paths in Settings. >>> from environ import Path >>> root = Path('/home') >>> root, root(), root('dev') (, '/home', '/home/dev') >>> root == Path('/home') True >>> root in Path('/'), root not in Path('/other/path') (True, True) >>> root('dev', 'not_existing_dir', required=True) Traceback (most recent call last): environ.environ.ImproperlyConfigured: Create required path: /home/not_existing_dir >>> public = root.path('public') >>> public, public.root, public('styles') (, '/home/public', '/home/public/styles') >>> assets, scripts = public.path('assets'), public.path('assets', 'scripts') >>> assets.root, scripts.root ('/home/public/assets', '/home/public/assets/scripts') >>> assets + 'styles', str(assets + 'styles'), ~assets (, '/home/public/assets/styles', ) """ def path(self, *paths, **kwargs): """Create new Path based on self.root and provided paths. :param paths: List of sub paths :param kwargs: required=False :rtype: Path """ return self.__class__(self.__root__, *paths, **kwargs) def file(self, name, *args, **kwargs): """Open a file. :param name: Filename appended to self.root :param args: passed to open() :param kwargs: passed to open() :rtype: file """ return open(self(name), *args, **kwargs) @property def root(self): """Current directory for this Path""" return self.__root__ def __init__(self, start='', *paths, **kwargs): super(Path, self).__init__() if kwargs.get('is_file', False): start = os.path.dirname(start) self.__root__ = self._absolute_join(start, *paths, **kwargs) def __call__(self, *paths, **kwargs): """Retrieve the absolute path, with appended paths :param paths: List of sub path of self.root :param kwargs: required=False """ return self._absolute_join(self.__root__, *paths, **kwargs) def __eq__(self, other): return self.__root__ == other.__root__ def __ne__(self, other): return not self.__eq__(other) def __add__(self, other): return Path(self.__root__, other if not isinstance(other, Path) else other.__root__) def __sub__(self, other): if isinstance(other, int): return self.path('../' * other) elif isinstance(other, string_types): if self.__root__.endswith(other): return Path(self.__root__.rstrip(other)) raise TypeError( "unsupported operand type(s) for -: '{self}' and '{other}' " "unless value of {self} ends with value of {other}".format( self=type(self), other=type(other) ) ) def __invert__(self): return self.path('..') def __contains__(self, item): base_path = self.__root__ if len(base_path) > 1: base_path = os.path.join(base_path, '') return item.__root__.startswith(base_path) def __repr__(self): return "".format(self.__root__) def __str__(self): return self.__root__ def __unicode__(self): return self.__str__() def __getitem__(self, *args, **kwargs): return self.__str__().__getitem__(*args, **kwargs) def rfind(self, *args, **kwargs): return self.__str__().rfind(*args, **kwargs) def find(self, *args, **kwargs): return self.__str__().find(*args, **kwargs) @staticmethod def _absolute_join(base, *paths, **kwargs): absolute_path = os.path.abspath(os.path.join(base, *paths)) if kwargs.get('required', False) and not os.path.exists(absolute_path): raise ImproperlyConfigured( "Create required path: {0}".format(absolute_path)) return absolute_path def register_scheme(scheme): for method in dir(urllib.parse): if method.startswith('uses_'): getattr(urllib.parse, method).append(scheme) def register_schemes(schemes): for scheme in schemes: register_scheme(scheme) # Register database and cache schemes in URLs. register_schemes(Env.DB_SCHEMES.keys()) register_schemes(Env.CACHE_SCHEMES.keys()) register_schemes(Env.SEARCH_SCHEMES.keys()) register_schemes(Env.EMAIL_SCHEMES.keys()) django-environ-0.4.4/environ/test_env.txt0000664000175000017500000000230013146517103021101 0ustar joke2kjoke2k00000000000000DICT_VAR=foo=bar,test=on BOOL_FALSE_VAR2=False DATABASE_MYSQL_URL=mysql://bea6eb0:69772142@us-cdbr-east.cleardb.com/heroku_97681?reconnect=true DATABASE_MYSQL_GIS_URL=mysqlgis://user:password@127.0.0.1/some_database CACHE_URL=memcache://127.0.0.1:11211 CACHE_REDIS=rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=secret EMAIL_URL=smtps://user@domain.com:password@smtp.example.com:587 URL_VAR=http://www.google.com/ PATH_VAR=/home/dev BOOL_FALSE_VAR=0 BOOL_TRUE_VAR2=True DATABASE_SQLITE_URL=sqlite:////full/path/to/your/database/file.sqlite JSON_VAR={"three": 33.44, "two": 2, "one": "bar"} BOOL_TRUE_VAR=1 DATABASE_URL=postgres://uf07k1:wegauwhg@ec2-107-21-253-135.compute-1.amazonaws.com:5431/d8r82722 FLOAT_VAR=33.3 FLOAT_COMMA_VAR=33,3 FLOAT_STRANGE_VAR1=123,420,333.3 FLOAT_STRANGE_VAR2=123.420.333,3 PROXIED_VAR=$STR_VAR EMPTY_LIST= INT_VAR=42 STR_LIST_WITH_SPACES= foo, bar STR_VAR=bar INT_LIST=42,33 CYRILLIC_VAR=фуубар INT_TUPLE=(42,33) DATABASE_ORACLE_TNS_URL=oracle://user:password@sid DATABASE_ORACLE_URL=oracle://user:password@host:1521/sid DATABASE_REDSHIFT_URL=redshift://user:password@examplecluster.abc123xyz789.us-west-2.redshift.amazonaws.com:5439/dev django-environ-0.4.4/setup.py0000664000175000017500000000376213146535210016557 0ustar joke2kjoke2k00000000000000#!/usr/bin/env python from __future__ import unicode_literals from setuptools import setup, find_packages import io import os here = os.path.abspath(os.path.dirname(__file__)) README = io.open(os.path.join(here, 'README.rst'), encoding="utf8").read() version = '0.4.4' author = 'joke2k' description = "Django-environ allows you to utilize 12factor inspired environment " \ "variables to configure your Django application." install_requires = ['django', 'six'] setup(name='django-environ', version=version, description=description, long_description=README, classifiers=[ # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers 'Development Status :: 3 - Alpha', 'Intended Audience :: Information Technology', 'Framework :: Django', 'Framework :: Django :: 1.8', 'Framework :: Django :: 1.9', 'Framework :: Django :: 1.10', 'Framework :: Django :: 1.11', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Utilities', 'License :: OSI Approved :: MIT License', 'Framework :: Django' ], keywords='django environment variables 12factor', author=author, author_email='joke2k@gmail.com', url='https://github.com/joke2k/django-environ', license='MIT License', packages=find_packages(), platforms=["any"], include_package_data=True, test_suite='environ.test.load_suite', zip_safe=False, install_requires=install_requires, ) django-environ-0.4.4/PKG-INFO0000664000175000017500000004122213146535252016141 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.4 Summary: Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. Home-page: https://github.com/joke2k/django-environ Author: joke2k Author-email: joke2k@gmail.com License: MIT License Description: ============== Django-environ ============== Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. |pypi| |unix_build| |windows_build| |coverage| |license| This module is a merge of: * `envparse`_ * `honcho`_ * `dj-database-url`_ * `dj-search-url`_ * `dj-config-url`_ * `django-cache-url`_ and inspired by: * `12factor`_ * `12factor-django`_ * `Two Scoops of Django`_ This is your `settings.py` file before you have installed **django-environ** .. code-block:: python import os SITE_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) DEBUG = True TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'database', 'USER': 'user', 'PASSWORD': 'githubbedpassword', 'HOST': '127.0.0.1', 'PORT': '8458', }, 'extra': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(SITE_ROOT, 'database.sqlite') } } MEDIA_ROOT = os.path.join(SITE_ROOT, 'assets') MEDIA_URL = 'media/' STATIC_ROOT = os.path.join(SITE_ROOT, 'static') STATIC_URL = 'static/' SECRET_KEY = '...im incredibly still here...' CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '127.0.0.1:11211', '127.0.0.1:11212', '127.0.0.1:11213', ] }, 'redis': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': '127.0.0.1:6379/1', 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PASSWORD': 'redis-githubbed-password', } } } After: .. code-block:: python import environ root = environ.Path(__file__) - 3 # three folder back (/a/b/c/ - 3 = /) env = environ.Env(DEBUG=(bool, False),) # set default values and casting environ.Env.read_env() # reading .env file SITE_ROOT = root() DEBUG = env('DEBUG') # False if not in os.environ TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': env.db(), # Raises ImproperlyConfigured exception if DATABASE_URL not in os.environ 'extra': env.db('SQLITE_URL', default='sqlite:////tmp/my-tmp-sqlite.db') } public_root = root.path('public/') MEDIA_ROOT = public_root('media') MEDIA_URL = 'media/' STATIC_ROOT = public_root('static') STATIC_URL = 'static/' SECRET_KEY = env('SECRET_KEY') # Raises ImproperlyConfigured exception if SECRET_KEY not in os.environ CACHES = { 'default': env.cache(), 'redis': env.cache('REDIS_URL') } You can also pass ``read_env()`` an explicit path to the ``.env`` file. Create a ``.env`` file: .. code-block:: bash DEBUG=on # DJANGO_SETTINGS_MODULE=myapp.settings.dev SECRET_KEY=your-secret-key DATABASE_URL=psql://urser:un-githubbedpassword@127.0.0.1:8458/database # SQLITE_URL=sqlite:///my-local-sqlite.db CACHE_URL=memcache://127.0.0.1:11211,127.0.0.1:11212,127.0.0.1:11213 REDIS_URL=rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=redis-un-githubbed-password How to install ============== :: $ pip install django-environ How to use ========== There are only two classes, ``environ.Env`` and ``environ.Path`` .. code-block:: python >>> import environ >>> env = environ.Env( DEBUG=(bool, False), ) >>> env('DEBUG') False >>> env('DEBUG', default=True) True >>> open('.myenv', 'a').write('DEBUG=on') >>> environ.Env.read_env('.myenv') # or env.read_env('.myenv') >>> env('DEBUG') True >>> open('.myenv', 'a').write('\nINT_VAR=1010') >>> env.int('INT_VAR'), env.str('INT_VAR') 1010, '1010' >>> open('.myenv', 'a').write('\nDATABASE_URL=sqlite:///my-local-sqlite.db') >>> env.read_env('.myenv') >>> env.db() {'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'my-local-sqlite.db', 'HOST': '', 'USER': '', 'PASSWORD': '', 'PORT': ''} >>> root = env.path('/home/myproject/') >>> root('static') '/home/myproject/static' See `cookiecutter-django`_ for a concrete example on using with a django project. Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) #environ.Env(BAR=(dict, {})) - dict (BAR=key=val;foo=1.1;baz=True) #environ.Env(BAR=(dict(value=unicode, cast=dict(foo=float,baz=bool)), {})) - url - path (environ.Path) - db_url - PostgreSQL: postgres://, pgsql://, psql:// or postgresql:// - PostGIS: postgis:// - MySQL: mysql:// or mysql2:// - MySQL for GeoDjango: mysqlgis:// - SQLITE: sqlite:// - SQLITE with SPATIALITE for GeoDjango: spatialite:// - Oracle: oracle:// - PyODBC: pyodbc:// - Redshift: redshift:// - LDAP: ldap:// - cache_url - Database: dbcache:// - Dummy: dummycache:// - File: filecache:// - Memory: locmemcache:// - Memcached: memcache:// - Python memory: pymemcache:// - Redis: rediscache:// - search_url - ElasticSearch: elasticsearch:// - Solr: solr:// - Whoosh: whoosh:// - Xapian: xapian:// - Simple cache: simple:// - email_url - SMTP: smtp:// - SMTP+SSL: smtp+ssl:// - SMTP+TLS: smtp+tls:// - Console mail: consolemail:// - File mail: filemail:// - LocMem mail: memorymail:// - Dummy mail: dummymail:// Tips ==== Using unsafe characters in URLs ------------------------------- In order to use unsafe characters you have to encode with ``urllib.parse.encode`` before you set into ``.env`` file. .. code-block:: DATABASE_URL=mysql://user:%23password@127.0.0.1:3306/dbname See https://perishablepress.com/stop-using-unsafe-characters-in-urls/ for reference. Multiple redis cache locations ------------------------------ For redis cache, `multiple master/slave or shard locations `_ can be configured as follows: .. code-block:: CACHE_URL='rediscache://master:6379,slave1:6379,slave2:6379/1' Email settings -------------- In order to set email configuration for django you can use this code: .. code-block:: python EMAIL_CONFIG = env.email_url( 'EMAIL_URL', default='smtp://user@:password@localhost:25') vars().update(EMAIL_CONFIG) SQLite urls ----------- SQLite connects to file based databases. The same URL format is used, omitting the hostname, and using the "file" portion as the filename of the database. This has the effect of four slashes being present for an absolute file path: sqlite:////full/path/to/your/database/file.sqlite. Tests ===== :: $ git clone git@github.com:joke2k/django-environ.git $ cd django-environ/ $ python setup.py test License ======= Django-environ is licensed under the MIT License - see the `LICENSE_FILE`_ file for details Changelog ========= `0.4.4 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Support for django-redis multiple locations (master/slave, shards) - Support for Elasticsearch2 - Support for Mysql-connector - Support for pyodbc - Add __contains__ feature to Environ class - Fix Path subtracting `0.4.3 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Rollback the default Environ to os.environ `0.4.2 - 13-April-2017 `__ -------------------------------------------------------------------------------------------- - Confirm support for Django 1.11. - Support for Redshift database URL - Fix uwsgi settings reload problem (#55) - Update support for django-redis urls (#109) `0.4.1 - 13-November-2016 `__ --------------------------------------------------------------------------------------------- - Fix for unsafe characters into URLs - Clarifying warning on missing or unreadable file. Thanks to @nickcatal - Add support for Django 1.10. - Fix support for Oracle urls - Fix support for django-redis `0.4.0 - 23-September-2015 `__ -------------------------------------------------------------------------------------------- - Fix non-ascii values (broken in Python 2.x) - New email schemes - smtp+ssl and smtp+tls (smtps would be deprecated) - redis_cache replaced by django_redis - Add tuple support. Thanks to @anonymouzz - Add LDAP url support for database (django-ldapdb) - Fix psql/pgsql url `0.3 - 03-June-2014 `__ --------------------------------------------------------------------------------------- - Add cache url support - Add email url support - Add search url support - Rewriting README.rst 0.2.1 19-April-2013 ------------------- - environ/environ.py: Env.__call__ now uses Env.get_value instance method 0.2 16-April-2013 ----------------- - environ/environ.py, environ/test.py, environ/test_env.txt: add advanced float parsing (comma and dot symbols to separate thousands and decimals) - README.rst, docs/index.rst: fix TYPO in documentation 0.1 02-April-2013 ----------------- - initial release Credits ======= - `12factor`_ - `12factor-django`_ - `Two Scoops of Django`_ - `rconradharris`_ / `envparse`_ - `kennethreitz`_ / `dj-database-url`_ - `migonzalvar`_ / `dj-email-url`_ - `ghickman`_ / `django-cache-url`_ - `dstufft`_ / `dj-search-url`_ - `julianwachholz`_ / `dj-config-url`_ - `nickstenning`_ / `honcho`_ - `envparse`_ - `Distribute`_ - `modern-package-template`_ .. _rconradharris: https://github.com/rconradharris .. _envparse: https://github.com/rconradharris/envparse .. _kennethreitz: https://github.com/kennethreitz .. _dj-database-url: https://github.com/kennethreitz/dj-database-url .. _migonzalvar: https://github.com/migonzalvar .. _dj-email-url: https://github.com/migonzalvar/dj-email-url .. _ghickman: https://github.com/ghickman .. _django-cache-url: https://github.com/ghickman/django-cache-url .. _julianwachholz: https://github.com/julianwachholz .. _dj-config-url: https://github.com/julianwachholz/dj-config-url .. _dstufft: https://github.com/dstufft .. _dj-search-url: https://github.com/dstufft/dj-search-url .. _nickstenning: https://github.com/nickstenning .. _honcho: https://github.com/nickstenning/honcho .. _12factor: http://www.12factor.net/ .. _12factor-django: http://www.wellfireinteractive.com/blog/easier-12-factor-django/ .. _`Two Scoops of Django`: http://twoscoopspress.org/ .. _Distribute: http://pypi.python.org/pypi/distribute .. _`modern-package-template`: http://pypi.python.org/pypi/modern-package-template .. _cookiecutter-django: https://github.com/pydanny/cookiecutter-django .. |pypi| image:: https://img.shields.io/pypi/v/django-environ.svg?style=flat-square&label=version :target: https://pypi.python.org/pypi/django-environ :alt: Latest version released on PyPi .. |coverage| image:: https://img.shields.io/coveralls/joke2k/django-environ/master.svg?style=flat-square :target: https://coveralls.io/r/joke2k/django-environ?branch=master :alt: Test coverage .. |unix_build| image:: https://img.shields.io/travis/joke2k/django-environ/master.svg?style=flat-square&label=unix%20build :target: http://travis-ci.org/joke2k/django-environ :alt: Build status of the master branch on Mac/Linux .. |windows_build| image:: https://img.shields.io/appveyor/ci/joke2k/django-environ.svg?style=flat-square&label=windows%20build :target: https://ci.appveyor.com/project/joke2k/django-environ :alt: Build status of the master branch on Windows .. |license| image:: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square :target: https://raw.githubusercontent.com/joke2k/django-environ/master/LICENSE.txt :alt: Package license .. _LICENSE_FILE: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt Keywords: django environment variables 12factor Platform: any Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Information Technology Classifier: Framework :: Django Classifier: Framework :: Django :: 1.8 Classifier: Framework :: Django :: 1.9 Classifier: Framework :: Django :: 1.10 Classifier: Framework :: Django :: 1.11 Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Utilities Classifier: License :: OSI Approved :: MIT License Classifier: Framework :: Django django-environ-0.4.4/setup.cfg0000664000175000017500000000026413146535252016666 0ustar joke2kjoke2k00000000000000[bumpversion] current_version = 0.4.4 commit = True tag = True files = setup.py environ/environ.py docs/conf.py [bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 django-environ-0.4.4/README.rst0000664000175000017500000003026613146535210016533 0ustar joke2kjoke2k00000000000000============== Django-environ ============== Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. |pypi| |unix_build| |windows_build| |coverage| |license| This module is a merge of: * `envparse`_ * `honcho`_ * `dj-database-url`_ * `dj-search-url`_ * `dj-config-url`_ * `django-cache-url`_ and inspired by: * `12factor`_ * `12factor-django`_ * `Two Scoops of Django`_ This is your `settings.py` file before you have installed **django-environ** .. code-block:: python import os SITE_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))) DEBUG = True TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'database', 'USER': 'user', 'PASSWORD': 'githubbedpassword', 'HOST': '127.0.0.1', 'PORT': '8458', }, 'extra': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(SITE_ROOT, 'database.sqlite') } } MEDIA_ROOT = os.path.join(SITE_ROOT, 'assets') MEDIA_URL = 'media/' STATIC_ROOT = os.path.join(SITE_ROOT, 'static') STATIC_URL = 'static/' SECRET_KEY = '...im incredibly still here...' CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache', 'LOCATION': [ '127.0.0.1:11211', '127.0.0.1:11212', '127.0.0.1:11213', ] }, 'redis': { 'BACKEND': 'django_redis.cache.RedisCache', 'LOCATION': '127.0.0.1:6379/1', 'OPTIONS': { 'CLIENT_CLASS': 'django_redis.client.DefaultClient', 'PASSWORD': 'redis-githubbed-password', } } } After: .. code-block:: python import environ root = environ.Path(__file__) - 3 # three folder back (/a/b/c/ - 3 = /) env = environ.Env(DEBUG=(bool, False),) # set default values and casting environ.Env.read_env() # reading .env file SITE_ROOT = root() DEBUG = env('DEBUG') # False if not in os.environ TEMPLATE_DEBUG = DEBUG DATABASES = { 'default': env.db(), # Raises ImproperlyConfigured exception if DATABASE_URL not in os.environ 'extra': env.db('SQLITE_URL', default='sqlite:////tmp/my-tmp-sqlite.db') } public_root = root.path('public/') MEDIA_ROOT = public_root('media') MEDIA_URL = 'media/' STATIC_ROOT = public_root('static') STATIC_URL = 'static/' SECRET_KEY = env('SECRET_KEY') # Raises ImproperlyConfigured exception if SECRET_KEY not in os.environ CACHES = { 'default': env.cache(), 'redis': env.cache('REDIS_URL') } You can also pass ``read_env()`` an explicit path to the ``.env`` file. Create a ``.env`` file: .. code-block:: bash DEBUG=on # DJANGO_SETTINGS_MODULE=myapp.settings.dev SECRET_KEY=your-secret-key DATABASE_URL=psql://urser:un-githubbedpassword@127.0.0.1:8458/database # SQLITE_URL=sqlite:///my-local-sqlite.db CACHE_URL=memcache://127.0.0.1:11211,127.0.0.1:11212,127.0.0.1:11213 REDIS_URL=rediscache://127.0.0.1:6379/1?client_class=django_redis.client.DefaultClient&password=redis-un-githubbed-password How to install ============== :: $ pip install django-environ How to use ========== There are only two classes, ``environ.Env`` and ``environ.Path`` .. code-block:: python >>> import environ >>> env = environ.Env( DEBUG=(bool, False), ) >>> env('DEBUG') False >>> env('DEBUG', default=True) True >>> open('.myenv', 'a').write('DEBUG=on') >>> environ.Env.read_env('.myenv') # or env.read_env('.myenv') >>> env('DEBUG') True >>> open('.myenv', 'a').write('\nINT_VAR=1010') >>> env.int('INT_VAR'), env.str('INT_VAR') 1010, '1010' >>> open('.myenv', 'a').write('\nDATABASE_URL=sqlite:///my-local-sqlite.db') >>> env.read_env('.myenv') >>> env.db() {'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'my-local-sqlite.db', 'HOST': '', 'USER': '', 'PASSWORD': '', 'PORT': ''} >>> root = env.path('/home/myproject/') >>> root('static') '/home/myproject/static' See `cookiecutter-django`_ for a concrete example on using with a django project. Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) #environ.Env(BAR=(dict, {})) - dict (BAR=key=val;foo=1.1;baz=True) #environ.Env(BAR=(dict(value=unicode, cast=dict(foo=float,baz=bool)), {})) - url - path (environ.Path) - db_url - PostgreSQL: postgres://, pgsql://, psql:// or postgresql:// - PostGIS: postgis:// - MySQL: mysql:// or mysql2:// - MySQL for GeoDjango: mysqlgis:// - SQLITE: sqlite:// - SQLITE with SPATIALITE for GeoDjango: spatialite:// - Oracle: oracle:// - PyODBC: pyodbc:// - Redshift: redshift:// - LDAP: ldap:// - cache_url - Database: dbcache:// - Dummy: dummycache:// - File: filecache:// - Memory: locmemcache:// - Memcached: memcache:// - Python memory: pymemcache:// - Redis: rediscache:// - search_url - ElasticSearch: elasticsearch:// - Solr: solr:// - Whoosh: whoosh:// - Xapian: xapian:// - Simple cache: simple:// - email_url - SMTP: smtp:// - SMTP+SSL: smtp+ssl:// - SMTP+TLS: smtp+tls:// - Console mail: consolemail:// - File mail: filemail:// - LocMem mail: memorymail:// - Dummy mail: dummymail:// Tips ==== Using unsafe characters in URLs ------------------------------- In order to use unsafe characters you have to encode with ``urllib.parse.encode`` before you set into ``.env`` file. .. code-block:: DATABASE_URL=mysql://user:%23password@127.0.0.1:3306/dbname See https://perishablepress.com/stop-using-unsafe-characters-in-urls/ for reference. Multiple redis cache locations ------------------------------ For redis cache, `multiple master/slave or shard locations `_ can be configured as follows: .. code-block:: CACHE_URL='rediscache://master:6379,slave1:6379,slave2:6379/1' Email settings -------------- In order to set email configuration for django you can use this code: .. code-block:: python EMAIL_CONFIG = env.email_url( 'EMAIL_URL', default='smtp://user@:password@localhost:25') vars().update(EMAIL_CONFIG) SQLite urls ----------- SQLite connects to file based databases. The same URL format is used, omitting the hostname, and using the "file" portion as the filename of the database. This has the effect of four slashes being present for an absolute file path: sqlite:////full/path/to/your/database/file.sqlite. Tests ===== :: $ git clone git@github.com:joke2k/django-environ.git $ cd django-environ/ $ python setup.py test License ======= Django-environ is licensed under the MIT License - see the `LICENSE_FILE`_ file for details Changelog ========= `0.4.4 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Support for django-redis multiple locations (master/slave, shards) - Support for Elasticsearch2 - Support for Mysql-connector - Support for pyodbc - Add __contains__ feature to Environ class - Fix Path subtracting `0.4.3 - 21-August-2017 `__ --------------------------------------------------------------------------------------------- - Rollback the default Environ to os.environ `0.4.2 - 13-April-2017 `__ -------------------------------------------------------------------------------------------- - Confirm support for Django 1.11. - Support for Redshift database URL - Fix uwsgi settings reload problem (#55) - Update support for django-redis urls (#109) `0.4.1 - 13-November-2016 `__ --------------------------------------------------------------------------------------------- - Fix for unsafe characters into URLs - Clarifying warning on missing or unreadable file. Thanks to @nickcatal - Add support for Django 1.10. - Fix support for Oracle urls - Fix support for django-redis `0.4.0 - 23-September-2015 `__ -------------------------------------------------------------------------------------------- - Fix non-ascii values (broken in Python 2.x) - New email schemes - smtp+ssl and smtp+tls (smtps would be deprecated) - redis_cache replaced by django_redis - Add tuple support. Thanks to @anonymouzz - Add LDAP url support for database (django-ldapdb) - Fix psql/pgsql url `0.3 - 03-June-2014 `__ --------------------------------------------------------------------------------------- - Add cache url support - Add email url support - Add search url support - Rewriting README.rst 0.2.1 19-April-2013 ------------------- - environ/environ.py: Env.__call__ now uses Env.get_value instance method 0.2 16-April-2013 ----------------- - environ/environ.py, environ/test.py, environ/test_env.txt: add advanced float parsing (comma and dot symbols to separate thousands and decimals) - README.rst, docs/index.rst: fix TYPO in documentation 0.1 02-April-2013 ----------------- - initial release Credits ======= - `12factor`_ - `12factor-django`_ - `Two Scoops of Django`_ - `rconradharris`_ / `envparse`_ - `kennethreitz`_ / `dj-database-url`_ - `migonzalvar`_ / `dj-email-url`_ - `ghickman`_ / `django-cache-url`_ - `dstufft`_ / `dj-search-url`_ - `julianwachholz`_ / `dj-config-url`_ - `nickstenning`_ / `honcho`_ - `envparse`_ - `Distribute`_ - `modern-package-template`_ .. _rconradharris: https://github.com/rconradharris .. _envparse: https://github.com/rconradharris/envparse .. _kennethreitz: https://github.com/kennethreitz .. _dj-database-url: https://github.com/kennethreitz/dj-database-url .. _migonzalvar: https://github.com/migonzalvar .. _dj-email-url: https://github.com/migonzalvar/dj-email-url .. _ghickman: https://github.com/ghickman .. _django-cache-url: https://github.com/ghickman/django-cache-url .. _julianwachholz: https://github.com/julianwachholz .. _dj-config-url: https://github.com/julianwachholz/dj-config-url .. _dstufft: https://github.com/dstufft .. _dj-search-url: https://github.com/dstufft/dj-search-url .. _nickstenning: https://github.com/nickstenning .. _honcho: https://github.com/nickstenning/honcho .. _12factor: http://www.12factor.net/ .. _12factor-django: http://www.wellfireinteractive.com/blog/easier-12-factor-django/ .. _`Two Scoops of Django`: http://twoscoopspress.org/ .. _Distribute: http://pypi.python.org/pypi/distribute .. _`modern-package-template`: http://pypi.python.org/pypi/modern-package-template .. _cookiecutter-django: https://github.com/pydanny/cookiecutter-django .. |pypi| image:: https://img.shields.io/pypi/v/django-environ.svg?style=flat-square&label=version :target: https://pypi.python.org/pypi/django-environ :alt: Latest version released on PyPi .. |coverage| image:: https://img.shields.io/coveralls/joke2k/django-environ/master.svg?style=flat-square :target: https://coveralls.io/r/joke2k/django-environ?branch=master :alt: Test coverage .. |unix_build| image:: https://img.shields.io/travis/joke2k/django-environ/master.svg?style=flat-square&label=unix%20build :target: http://travis-ci.org/joke2k/django-environ :alt: Build status of the master branch on Mac/Linux .. |windows_build| image:: https://img.shields.io/appveyor/ci/joke2k/django-environ.svg?style=flat-square&label=windows%20build :target: https://ci.appveyor.com/project/joke2k/django-environ :alt: Build status of the master branch on Windows .. |license| image:: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square :target: https://raw.githubusercontent.com/joke2k/django-environ/master/LICENSE.txt :alt: Package license .. _LICENSE_FILE: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt