django-environ-0.4.3/0000775000175000017500000000000013075717060015042 5ustar joke2kjoke2k00000000000000django-environ-0.4.3/setup.cfg0000664000175000017500000000031113075717060016656 0ustar joke2kjoke2k00000000000000[bumpversion] current_version = 0.4.3 commit = True tag = True files = setup.py environ/environ.py docs/conf.py [bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 django-environ-0.4.3/LICENSE.txt0000664000175000017500000000205113075673012016661 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.3/PKG-INFO0000664000175000017500000003673613075717060016156 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.3 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:// - 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. 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.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.3/environ/0000775000175000017500000000000013075717060016522 5ustar joke2kjoke2k00000000000000django-environ-0.4.3/environ/test_env.txt0000664000175000017500000000230013075673012021103 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.3/environ/__init__.py0000664000175000017500000000002712646770142020635 0ustar joke2kjoke2k00000000000000from .environ import * django-environ-0.4.3/environ/test.py0000664000175000017500000007046313075673012020063 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_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_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.3/environ/tests/0000775000175000017500000000000013075717060017664 5ustar joke2kjoke2k00000000000000django-environ-0.4.3/environ/tests/__init__.py0000664000175000017500000000021112642263123021762 0ustar joke2kjoke2k00000000000000import os TESTS_DATA_PATH = os.path.dirname(__file__) def get_test_data_filepath(file): return os.path.join(TESTS_DATA_PATH, file)django-environ-0.4.3/environ/tests/test_environment.py0000664000175000017500000000425212643005726023643 0ustar joke2kjoke2k00000000000000from unittest import TestCase from environ import Environment, readers, EnvironmentException from environ.tests import get_test_data_filepath class EnvironmentTest(TestCase): def test_adding_a_source_new_dict_with_its_variables_is_loaded(self): source = {'foo': 'bar'} env = Environment() env.add_source(source) self.assertIn(source, env._sources) def test_dunder_call_method_returns_value_from_latest_source_added(self): first_source = {'name': 'Python'} last_source = {'name': 'Monty Python'} env = Environment() env.add_source(first_source) env.add_source(last_source) self.assertEqual('Monty Python', env('name')) def test_adding_a_file_path_source_loads_variables_with_provided_reader(self): env = Environment() env_filepath = get_test_data_filepath('test_environment.env') env.add_source(env_filepath, reader=readers.DotEnvFileReader()) self.assertIn({'NAME': 'Monty Python'}, env._sources) self.assertEqual('Monty Python', env('NAME')) def test_adding_a_file_path_source_raise_exception_if_no_compatible_reader_found(self): env = Environment() not_existing_file = get_test_data_filepath('file.with.invalid_extension') self.assertRaisesRegexp( EnvironmentException, "No compatible Reader found for source: '%s'" % not_existing_file, env.add_source, not_existing_file ) def test_adding_a_file_path_source_raise_exception_if_file_not_exists(self): env = Environment() not_existing_file = get_test_data_filepath('not_existing_file.env') self.assertRaisesRegexp( IOError, "No such file or directory: '%s'" % not_existing_file, env.add_source, not_existing_file ) def test_adding_a_dotenv_file_path_source_uses_DotEnvFileReader(self): env = Environment() env_filepath = get_test_data_filepath('test_environment.env') reader_instance = env.find_reader_for_source(env_filepath) self.assertIsInstance(reader_instance, readers.DotEnvFileReader) django-environ-0.4.3/environ/tests/functional_tests.py0000664000175000017500000000422412643001506023613 0ustar joke2kjoke2k00000000000000from unittest import TestCase from environ import Environment from environ.tests import get_test_data_filepath class EnvironmentTest(TestCase): def test_basic_usage(self): # Dan, a python developer, wants to load some environment variables to configure his application # to work in different modes. env = Environment() current_mode = env('MODE', default='DEBUG') # the `MODE` variable is not present into `env` Environment # then `current_mode` assumes the provided default value: self.assertEqual('DEBUG', current_mode) # Reading the documentation he learns that he can change the `MODE` value # using `os.environ` as variables provider. # Then he reload his application pre-pending the new value for `MODE` variable using this shell syntax: # `MODE=PRODUCTION python app.py` os_environ = {'MODE': 'PRODUCTION'} ## simulate the os.environ # And add a source into the current `env` env.add_source(os_environ) current_mode = env('MODE', default='DEBUG') self.assertEqual('PRODUCTION', current_mode) # Dan thinks that is not comfortable start its application using this shell-like syntax, # and reading the documentation he founds a smart way to do that using a simple .env file. # `echo TEST=on > .env` # Then he adds the source to current `env` env.add_source(get_test_data_filepath('functional_tests.env')) is_testing = env('TEST', default='off') self.assertEqual(is_testing, 'on', "TEST variable is not loaded from functional_tests.env") # Dan now wants to use the casting feature to avoid having to do manually. # He founds three method to do that: # 1: providing a caster function is_testing = env('TEST', cast=bool) self.assertIs(True, is_testing) # 2: calling the implicit method is_testing = env.bool('TEST') self.assertTrue(True, is_testing) # 3: using the smart-cast based on default value is_testing = env('TEST', default=bool) self.assertTrue(True, is_testing) self.fail("Finish the tests!")django-environ-0.4.3/environ/environ.py0000664000175000017500000006430213075717025020562 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.3' __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', 'mysqlgis': 'django.contrib.gis.db.backends.mysql', 'oracle': 'django.db.backends.oracle', '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", "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) # 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' config['LOCATION'] = scheme + '://' + url.netloc + url.path 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']: 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 == 'elasticsearch': 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): return Path(self.__root__.rstrip(other)) raise TypeError( "unsupported operand type(s) for -: '{0}' and '{1}'".format(self, 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.3/MANIFEST.in0000664000175000017500000000007013075673012016573 0ustar joke2kjoke2k00000000000000include *.rst include *.txt include environ/test_env.txtdjango-environ-0.4.3/setup.py0000664000175000017500000000376213075717025016565 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.3' 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.3/django_environ.egg-info/0000775000175000017500000000000013075717060021536 5ustar joke2kjoke2k00000000000000django-environ-0.4.3/django_environ.egg-info/requires.txt0000664000175000017500000000001313075717060024130 0ustar joke2kjoke2k00000000000000django six django-environ-0.4.3/django_environ.egg-info/not-zip-safe0000664000175000017500000000000112646772077024000 0ustar joke2kjoke2k00000000000000 django-environ-0.4.3/django_environ.egg-info/PKG-INFO0000664000175000017500000003673613075717060022652 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.3 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:// - 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. 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.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.3/django_environ.egg-info/dependency_links.txt0000664000175000017500000000000113075717060025604 0ustar joke2kjoke2k00000000000000 django-environ-0.4.3/django_environ.egg-info/top_level.txt0000664000175000017500000000001013075717060024257 0ustar joke2kjoke2k00000000000000environ django-environ-0.4.3/django_environ.egg-info/SOURCES.txt0000664000175000017500000000070113075717060023420 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.txt environ/tests/__init__.py environ/tests/functional_tests.py environ/tests/test_environment.pydjango-environ-0.4.3/README.rst0000664000175000017500000002633213075673012016535 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:// - 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. 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.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