django-environ-0.4.0/0000775000175000017500000000000012600547736015043 5ustar joke2kjoke2k00000000000000django-environ-0.4.0/PKG-INFO0000664000175000017500000003116712600547736016150 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.0 Summary: Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. Home-page: http://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| |downloads| |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** :: 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:: 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:: 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` :: >>> 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' Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) - 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:// - 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:// 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 for details Changelog ========= `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 .. |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 .. |downloads| image:: https://img.shields.io/pypi/dm/django-environ.svg?style=flat-square :target: https://pypi.python.org/pypi/django-environ :alt: Monthly downloads .. |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: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt Keywords: d,j,a,n,g,o, ,e,n,v,i,r,o,n,m,e,n,t, ,v,a,r,i,a,b,l,e,s, ,1,2,f,a,c,t,o,r Platform: any Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Information Technology Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Utilities Classifier: License :: OSI Approved :: MIT License Classifier: Framework :: Django django-environ-0.4.0/README.rst0000664000175000017500000002245112600547041016523 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| |downloads| |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** :: 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:: 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:: 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` :: >>> 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' Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) - 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:// - 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:// 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 for details Changelog ========= `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 .. |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 .. |downloads| image:: https://img.shields.io/pypi/dm/django-environ.svg?style=flat-square :target: https://pypi.python.org/pypi/django-environ :alt: Monthly downloads .. |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: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt django-environ-0.4.0/LICENSE.txt0000664000175000017500000000205112600547041016651 0ustar joke2kjoke2k00000000000000Copyright (c) 2013-2015, 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.0/django_environ.egg-info/0000775000175000017500000000000012600547736021537 5ustar joke2kjoke2k00000000000000django-environ-0.4.0/django_environ.egg-info/top_level.txt0000664000175000017500000000001012600547736024260 0ustar joke2kjoke2k00000000000000environ django-environ-0.4.0/django_environ.egg-info/PKG-INFO0000664000175000017500000003116712600547736022644 0ustar joke2kjoke2k00000000000000Metadata-Version: 1.1 Name: django-environ Version: 0.4.0 Summary: Django-environ allows you to utilize 12factor inspired environment variables to configure your Django application. Home-page: http://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| |downloads| |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** :: 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:: 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:: 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` :: >>> 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' Supported Types =============== - str - bool - int - float - json - list (FOO=a,b,c) - tuple (FOO=(a,b,c)) - dict (BAR=key=val,foo=bar) - 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:// - 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:// 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 for details Changelog ========= `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 .. |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 .. |downloads| image:: https://img.shields.io/pypi/dm/django-environ.svg?style=flat-square :target: https://pypi.python.org/pypi/django-environ :alt: Monthly downloads .. |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: https://github.com/joke2k/django-environ/blob/master/LICENSE.txt Keywords: d,j,a,n,g,o, ,e,n,v,i,r,o,n,m,e,n,t, ,v,a,r,i,a,b,l,e,s, ,1,2,f,a,c,t,o,r Platform: any Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Information Technology Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Utilities Classifier: License :: OSI Approved :: MIT License Classifier: Framework :: Django django-environ-0.4.0/django_environ.egg-info/dependency_links.txt0000664000175000017500000000000112600547736025605 0ustar joke2kjoke2k00000000000000 django-environ-0.4.0/django_environ.egg-info/not-zip-safe0000664000175000017500000000000112342712735023761 0ustar joke2kjoke2k00000000000000 django-environ-0.4.0/django_environ.egg-info/requires.txt0000664000175000017500000000001212600547736024130 0ustar joke2kjoke2k00000000000000django sixdjango-environ-0.4.0/django_environ.egg-info/SOURCES.txt0000664000175000017500000000051612600547736023425 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.pydjango-environ-0.4.0/setup.cfg0000664000175000017500000000025412600547736016665 0ustar joke2kjoke2k00000000000000[bumpversion] current_version = 0.4.0 commit = True tag = True files = setup.py environ/environ.py docs/conf.py [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 django-environ-0.4.0/environ/0000775000175000017500000000000012600547736016523 5ustar joke2kjoke2k00000000000000django-environ-0.4.0/environ/environ.py0000664000175000017500000006132712600547041020553 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_parse as urlparse from six import string_types logger = logging.getLogger(__file__) VERSION = '0.4.0' __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 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'): ... """ NOTSET = NoValue() BOOLEAN_TRUE_STRINGS = ('true', 'on', 'ok', 'y', 'yes', '1') URL_CLASS = urlparse.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', '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': 'django_redis.cache.RedisCache', 'redis': 'django_redis.cache.RedisCache', } _CACHE_BASE_OPTIONS = ['TIMEOUT', 'KEY_PREFIX', 'VERSION', 'KEY_FUNCTION'] 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=urlparse.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 = os.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 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': None, 'NAME': '/full/path/to/your/file.sqlite', 'PASSWORD': None, 'PORT': None, 'USER': None} >>> 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 = urlparse.urlparse(url) config = {} # Remove query strings. path = url.path[1:] path = 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, 'USER': url.username, 'PASSWORD': url.password, 'HOST': url.hostname, 'PORT': _cast_int(url.port), }) if url.query: config_options = {} for k, v in urlparse.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 = urlparse.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, } if url.scheme == 'filecache': config.update({ 'LOCATION': url.netloc + url.path, }) if url.path and url.scheme in ['memcache', 'pymemcache', 'rediscache']: config.update({ 'LOCATION': 'unix:' + url.path, }) if url.query: config_options = {} for k, v in urlparse.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 = urlparse.urlparse(url) if not isinstance(url, cls.URL_CLASS) else url # Remove query strings path = url.path[1:] path = path.split('?', 2)[0] # Update with environment configuration config.update({ 'EMAIL_FILE_PATH': path, 'EMAIL_HOST_USER': url.username, 'EMAIL_HOST_PASSWORD': 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 urlparse.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 = urlparse.urlparse(url) if not isinstance(url, cls.URL_CLASS) else url # Remove query strings. path = url.path[1:] path = 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 = urlparse.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'] = urlparse.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'] = urlparse.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 @staticmethod def read_env(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("not reading %s - it doesn't exist." % 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("not reading %s - it doesn't exist." % 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)) os.environ.setdefault(key, str(val)) # set defaults for key, value in overrides.items(): os.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(urlparse): if method.startswith('uses_'): getattr(urlparse, 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.0/environ/__init__.py0000664000175000017500000000002712343342366020627 0ustar joke2kjoke2k00000000000000from .environ import * django-environ-0.4.0/environ/test.py0000664000175000017500000006125312600547041020050 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 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' 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, 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.env = Env() self.environ = self.generateData() self._orig_environ = os.environ os.environ = self.environ def tearDown(self): os.environ = self._orig_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])))) 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_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'], None) 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'], None) 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'], '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): self.env = Env() self._orig_environ = os.environ os.environ = {} 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 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'], None) 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'], None) 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'], 'django_redis.cache.RedisCache') self.assertEqual(url['LOCATION'], '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_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() for case in [ EnvTests, FileEnvTests, SchemaEnvTests, PathTests, DatabaseTestSuite, CacheTestSuite, EmailTests, SearchTestSuite ]: 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.0/setup.py0000664000175000017500000000275712600547041016555 0ustar joke2kjoke2k00000000000000from __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.0' 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', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 3', '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='http://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.0/MANIFEST.in0000664000175000017500000000003312342717134016567 0ustar joke2kjoke2k00000000000000include *.rst include *.txt