{"id":13468461,"url":"https://github.com/drgarcia1986/simple-settings","last_synced_at":"2025-04-12T14:56:03.677Z","repository":{"id":31956336,"uuid":"35526217","full_name":"drgarcia1986/simple-settings","owner":"drgarcia1986","description":"A simple way to manage your project settings.","archived":false,"fork":false,"pushed_at":"2024-08-17T16:29:18.000Z","size":370,"stargazers_count":217,"open_issues_count":10,"forks_count":35,"subscribers_count":8,"default_branch":"main","last_synced_at":"2025-04-03T13:18:56.315Z","etag":null,"topics":["config","configuration","configuration-management","consul","django-configuration","flask-configuration","json","memcached","python","redis","settings","toml","yaml"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/drgarcia1986.png","metadata":{"files":{"readme":"README.rst","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2015-05-13T03:28:35.000Z","updated_at":"2025-03-29T22:43:11.000Z","dependencies_parsed_at":"2024-10-29T21:55:19.852Z","dependency_job_id":null,"html_url":"https://github.com/drgarcia1986/simple-settings","commit_stats":{"total_commits":341,"total_committers":17,"mean_commits":"20.058823529411764","dds":"0.36363636363636365","last_synced_commit":"5e38f2fd76cd1a275a01104c9c044b2ce8d5d5cd"},"previous_names":[],"tags_count":28,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/drgarcia1986%2Fsimple-settings","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/drgarcia1986%2Fsimple-settings/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/drgarcia1986%2Fsimple-settings/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/drgarcia1986%2Fsimple-settings/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/drgarcia1986","download_url":"https://codeload.github.com/drgarcia1986/simple-settings/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248586244,"owners_count":21128996,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["config","configuration","configuration-management","consul","django-configuration","flask-configuration","json","memcached","python","redis","settings","toml","yaml"],"created_at":"2024-07-31T15:01:11.391Z","updated_at":"2025-04-12T14:56:03.638Z","avatar_url":"https://github.com/drgarcia1986.png","language":"Python","funding_links":[],"categories":["Python"],"sub_categories":[],"readme":"Python Simple Settings\n======================\n.. _badges:\n\n.. image:: https://badge.fury.io/py/simple-settings.svg\n    :target: https://badge.fury.io/py/simple-settings\n    :alt: Package version\n\n.. image:: https://github.com/drgarcia1986/simple-settings/actions/workflows/main.yml/badge.svg\n    :target: https://github.com/drgarcia1986/simple-settings\n    :alt: Build Status\n\n.. image:: https://coveralls.io/repos/drgarcia1986/simple-settings/badge.svg\n    :target: https://coveralls.io/r/drgarcia1986/simple-settings\n    :alt: Coverage Status\n\n.. _description:\n\nA simple way to manage your project settings.\n\n**simple-settings** is inspired by Django's settings system but is\ngeneric for any python project.\n\nWith simple-settings you just need to specify your settings module using\nthe ``--settings`` command line arg when invoking your python script (or\n``SIMPLE_SETTINGS`` environment var) and all settings will be exposed as\nproperties of the ``simple_settings.settings`` module.\n\n.. code:: python\n\n    \u003e\u003e\u003e from simple_settings import settings\n    \u003e\u003e\u003e print(settings.FOO)\n    'some value in foo'\n\nInstallation\n------------\n\nsimple-settings is available on\n`Pypi \u003chttps://pypi.python.org/pypi/simple-settings\u003e`__.\n\n.. code:: bash\n\n    $ pip install simple-settings\n\n..\n\n    To install simple-settings with all dependencies use ``pip install simple-settings[all]``\n\n**simple-settings** is tested with Python 2.7, 3.4, 3.5, 3.6 and PyPy.\n\nHow this works\n--------------\n\nsimple-settings reads and stores all variables (or constants if you\nprefer) of a python module that you specify. To store your settings you\nneed at least one setting file (in any of supported formats).\n\nTo specify your settings module you have two approaches: with command\nline or environment.\n\nFor example, imagine that you have a python module for your project\nsettings and this file is in \"*settings/development.py*\\ \" (a common\nexample). To load settings of this file you can run your project with\ncommand line arg ``--settings``:\n\n.. code:: bash\n\n    $ python app.py --settings=settings.development\n\nsimple-settings accepts ``--simple-settings`` command line arg also.\nOr set the environment variable ``SIMPLE_SETTINGS``:\n\n.. code:: bash\n\n    $ export SIMPLE_SETTINGS=settings.development\n    $ python app.py\n\n..\n\n    the ``settings`` environment variable is deprecated\n\nThe ``simple_settings.settings`` object reads both the command line and\nenvironment in this order (but simple-settings takes the first value it\nencounters), to know which file to load.\n\nAnother option is use class ``LazySettings`` instead of singleton object\n``settings``. With ``LazySettings`` class is possible to determine\nsettings files in object create:\n\n.. code:: python\n\n    from simple_settings import LazySettings\n\n\n    settings = LazySettings('settings.development')\n\nIf you don't pass any value in *LazySettings* init argument, this class\nfollow the same behavior of *settings* object.\n\nExample\n-------\n\nThis is a very dummy example, in real world you would use\nsimple-settings in more complex cases.\n\n**project\\_settings.py**\n~~~~~~~~~~~~~~~~~~~~~~~~\n\nIn this example we just store a simple string but any python type is\naccepted.\n\n.. code:: python\n\n    SIMPLE_CONF = 'simple'\n\n**app.py**\n~~~~~~~~~~\n\nYou don't need specify which setting *simple-settings* must load, you\ncan do this with command line or environment.\n\n.. code:: python\n\n    from simple_settings import settings\n\n    print(settings.SIMPLE_CONF)\n\n**Run**\n~~~~~~~\n\nYou can specify your settings module with command line:\n\n.. code:: bash\n\n    $ python app.py --settings=project_settings\n    simple\n\nOr environment:\n\n.. code:: bash\n\n    $ export SIMPLE_SETTINGS=project_settings\n    $ python app.py\n    simple\n\nCheck\n`examples \u003chttps://github.com/drgarcia1986/simple-settings/tree/master/examples\u003e`__,\nin project repository for more usage samples.\n\nas\\_dict()\n----------\n\nYou can check the loaded settings through method ``settings.as_dict()``\n\n.. code:: python\n\n    \u003e\u003e\u003e settings.as_dict()\n    {'SIMPLE_CONF': 'simple'}\n\nconfigure\n---------\n\nYou can change any settings (and add new settings) in runtime with\nmethod ``configure``:\n\n.. code:: python\n\n    \u003e\u003e\u003e settings.SOME_CONF\n    foo\n    \u003e\u003e\u003e settings.configure(SOME_CONF='bar')\n    \u003e\u003e\u003e settings.SOME_CONF\n    bar\n\n\nKeep in mind that this only modifies the settings during runtime, and any\nmodifications using configure will be lost on program exit.\n\n..\n\n    If you're using ``dynamic settings`` the *configure* method will update the setting value in dynamic storage as well.\n\nTypes of settings\n-----------------\n\nThe simple-settings is prepared to play with the following files types:\n\n-  python modules.\n-  cfg files (simple ``key=value`` files).\n-  yaml files.\n-  json files.\n-  toml files.\n\n..\n\n    To simple-settings load settings of yaml files is necessary to install with extra require *yaml*, e.g.: ``pip install simple-settings[yaml]``\n\n..\n\n    For toml files is necessary to install with extras require *toml*, e.g.: ``pip install simple-settings[toml]``\n\n\nLoading settings from environment variables\n-------------------------------------------\n\nsimple-settings can load all environment variables, e.g. ``python app.py --settings=.environ`` or only environment variables that start with a certain prefix, e.g. ``python app.py --settings=MYPREFIX_.environ``.\n\n\nLoad multiple settings modules\n------------------------------\n\nsimple-settings can load more than one setting module without use import\napproach, just specify yours settings modules separated by comma. For\nexample:\n\n.. code:: bash\n\n    $ python app.py --settings=production,amazon,new_relic,PREFIX_.environ\n\nsimple-setting will load all settings modules in order that was\nspecified (``production``-\u003e ``amazon`` -\u003e ``new_relic`` -\u003e ``PREFIX_.environ``) overriding\npossibles conflicts.\n\nThis also works with *LazySettings* class:\n\n.. code:: python\n\n    from simple_settings import LazySettings\n\n\n    settings = LazySettings('production', 'amazon', 'new_relic', 'PREFIX_.environ')\n\nYou can combine any type of settings (*python modules*, *yaml*, etc.).\n\nIgnored settings\n----------------\n\n-  Python modules:\n\n   -  Variables starting with ``_``.\n\n-  Cfg files:\n\n   -  Keys starting with ``#``.\n\nSpecial Settings\n----------------\n\nsimple-settings has a list of *special settings* that change how\nsimple-settings will load settings. This *special settings* are specified using\na ``SIMPLE_SETTINGS`` dict in the settings module.\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'OVERRIDE_BY_ENV': True,\n        'CONFIGURE_LOGGING': True,\n        'REQUIRED_SETTINGS': ('API_TOKEN', 'DB_USER'),\n        'DYNAMIC_SETTINGS': {\n            'backend': 'redis',\n            'pattern': 'DYNAMIC_*',\n            'auto_casting': True,\n            'prefix': 'MYAPP_'\n        }\n    }\n\nConfigure logging\n~~~~~~~~~~~~~~~~~\n\nIf you set the *special setting* ``CONFIGURE_LOGGING`` with ``True``,\n*simple-settings* will configure the python logging to you. You just need\nto define your logging configuration with\n`Python dictConfig format \u003chttps://docs.python.org/3.5/library/logging.config.html#configuration-dictionary-schema\u003e`__\nand place in ``LOGGING`` setting, e.g.\n\n.. code:: python\n\n    LOGGING = {\n        'version': 1,\n        'disable_existing_loggers': False,\n        'formatters': {\n            'default': {\n                'format': '%(asctime)s %(levelname)s %(name)s %(message)s'\n            },\n        },\n        'handlers': {\n            'logfile': {\n                'level': 'DEBUG',\n                'class': 'logging.handlers.RotatingFileHandler',\n                'filename': 'my_log.log',\n                'maxBytes': 50 * 1024 * 1024,\n                'backupCount': 10,\n                'formatter': 'default'\n            },\n        },\n        'loggers': {\n            '': {\n                'handlers': ['logfile'],\n                'level': 'ERROR'\n            },\n            'my_project': {\n                'level': 'INFO',\n                'propagate': True,\n            },\n        }\n    }\n\nTo use just get logger with ``logging.getLogger()``, e.g.\n\n.. code:: python\n\n    import logging\n    logger = logging.getLogger('my_project')\n\n\n    logger.info('Hello')\n\n..\n\n    Don't forget, *simple-settings* is lazy and it only configures logging after runs ``setup()`` method or after reads some setting.\n\nOverride settings value\n~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can override the values of your settings module with environment\nvariables. You just need set the *special setting* ``OVERRIDE_BY_ENV``\nwith ``True`` as value.\n\n.. code:: bash\n\n    $ export SIMPLE_CONF=\"simple from env\"\n    $ python app.py --settings=project_settings\n    simple from env\n\n..\n\n    This is not a dynamic behavior, because settings are only overriden at\n    *\"settings setup\"* time; see ``dynamic settings`` for a real dynamic\n    behavior.\n\nRequired Settings\n~~~~~~~~~~~~~~~~~\n\nYou can determine a list of mandatory settings, i.e. settings that\nrequire a valid value. For this, set the *special setting*\n``REQUIRED_SETTINGS`` to a list (or any iterable) of your required\nsettings. If any setting in this list has an invalid value (or is not\npresent in setting file) then a ``ValueError`` is raised with a list of\nrequired settings not satified in the settings file.\n\nRequired Not None Settings\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can also determine a list of settings that must have a not none value, i.e.\nsettings that cannot be set as none. For this, set the *special setting*\n``REQUIRED_NOT_NONE_SETTINGS`` to a list (or any iterable) of the settings that\nyou require to not be none. If any setting in this list has a value of none,\nthen a ``ValueError`` is raised with a list of settings that must be set to not\nnone.\n\nRequired Settings Types\n~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can enforce that settings must have a particular type. For this, set the\n*special setting* ``REQUIRED_SETTINGS_TYPES`` to a dictionary with the keys\nbeing the name of the setting and the value being the type of the setting (see\nlist below for supported values).\n\nIf any of these settings has a value that is not of the type specified, or is a\nstring that cannot be parsed to the type specified, a ``ValueError`` is raised\nwith a list of settings that are of the wrong type. If there are no errors, the\nsetting value will be converted into that type. If any of the values are none,\ntheir type is not evaluated.\n\nThe supported types are listed below. If you attempt to set a type that is not\none of these types, then a ``ValueError`` will be raised with any unsupported\ntypes.\n\n    - ``\"bool\"`` - python's native boolean type, True values are ``y``, ``yes``, ``t``, ``true``, ``on`` and ``1``; false values are ``n``, ``no``, ``f``, ``false``, ``off`` and ``0``\n    - ``\"int\"`` - python's native integer type, parsed from a string using ``int(value)``\n    - ``\"float\"`` - python's native float type, parsed from a string using ``float(value)``\n    - ``\"str\"`` - python's native string type, not parsed from a string\n    - ``\"json.loads\"`` - Can be some types resulted of python's ``json.loads(value)`` function (e.g. dict: '{\"foo\": \"bar\"} -\u003e {'foo': 'bar'}, int: '1' -\u003e 1, bool: 'true' -\u003e True, list: '[1, 2]' -\u003e [1, 2], etc.)\n\nDynamic Settings\n~~~~~~~~~~~~~~~~\n\nsimple-settings has a list of *dynamic settings* mechanisms that change\na value of setting dynamically. If dynamic setting is activate, for all\nsetting the dynamic reader is called. The current dynamic mechanisms\nsuported is:\n\nDefault Dynamic Settings Configuration\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nFor all *dynamic settings* backends *simple-settings* accept this\noptional parameters:\n\n-  ``pattern``: if you set some regex pattern the dynamic settings\n   reader only get settings that match with this pattern. (Note that the\n   pattern will be applied to key as entered, ignoring any configured\n   ``prefix`` setting.)\n-  ``auto_casting``: if you set this conf to ``True`` (default is\n   ``False``) *simple settings* use\n   `jsonpickle \u003chttps://github.com/jsonpickle/jsonpickle\u003e`__ to encode\n   settings value before save in dynamic storage and decode after read\n   from dynamic storage. With this bahavior you can use complex types\n   (like *dict* and *list*) in dynamic settings.\n-  ``prefix``: if you set a prefix this value will be prepended to the\n   keys when looked up on the backend. The value is prepended without\n   any interpretation, so the key\n   ``key=\"MYKEY\" and prefix=\"my/namespace/\"`` would resolve to\n   ``key=\"my/namespace/MYKEY\"`` and\n   ``key=\"MYKEY\" and prefix=\"MY_NAMESPACE_\"`` would resolve to\n   ``key=\"MY_NAMESPACE_MYKEY\"``.\n\nRedis\n^^^^^\n\nYou can read your settings dynamically in redis if you activate the\n``DYNAMIC_SETTINGS`` special setting with ``redis`` backend:\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'DYNAMIC_SETTINGS': {\n            'backend': 'redis',\n            'host': 'locahost',\n            'port': 6379,\n        }\n    }\n\n..\n\n    for ``redis`` backend ``localhost`` is default value for ``host`` and ``6379`` is the default value for ``port``.\n\nIn redis dynamic reader the binary types is automatically decoded.\n\n    To install with redis dependencies use:\n    ``pip install simple-settings[redis]``\n\nConsul - Deprecated\n^^^^^^^^^^^^^^^^^^^\n\nYou can read your settings dynamically from a consul server if you\nactivate the ``DYNAMIC_SETTINGS`` special setting with the ``consul``\nbackend (uses `consulate \u003chttps://github.com/gmr/consulate\u003e`__ library):\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'DYNAMIC_SETTINGS': {\n            'backend': 'consul',\n            'host': 'locahost',\n            'port': 8500,\n            'prefix': 'mynamespace/'\n        }\n    }\n\n..\n\n    for ``consul`` backend ``localhost`` is default value for ``host`` and ``8500`` is the default value for ``port``.\n\nAdditional attributes for consul backend: ``datacenter``, ``token``,\n``scheme``.\n\n    To install with consul dependencies use:\n    ``pip install simple-settings[consul]``\n\nDATABASE\n^^^^^^^^\n\nYou can read your settings dynamically form a database if you activate\nthe ``DYNAMIC_SETTINGS`` special setting with the ``database`` backend\n(uses `sqlalchemy \u003chttp://docs.sqlalchemy.org/\u003e`__ library)\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'DYNAMIC_SETTINGS': {\n            'backend': 'database',\n            'sqlalchemy.url': 'sqlite:///:memory:',\n            ...\n        }\n    }\n\n..\n\n    To install with database dependencies use: ``pip install simple-settings[database]``\n\n\nAWS S3\n^^^^^^\n\nYou can read your settings dynamically form a AWS S3 bucket if you activate\nthe ``DYNAMIC_SETTINGS`` special setting with the ``s3`` backend\n(uses `boto3 \u003chttp://boto3.readthedocs.io/en/latest/\u003e`__ library)\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'DYNAMIC_SETTINGS': {\n            'backend': 's3',\n            'bucket_name': 'simple-settings',\n            'region': 'us-east-1'\n            ...\n        }\n    }\n\n..\n\n    To install with s3 dependencies use: ``pip install simple-settings[s3]``\n\n\nMemcached\n^^^^^^^^^\n\nYou can read your settings dynamically with memcached if you activate\nthe ``DYNAMIC_SETTINGS`` special setting with the ``memcached`` backend\n(uses `pymemcached \u003chttps://pymemcache.readthedocs.io/en/latest/index.html\u003e`__ library)\n\n.. code:: python\n\n    SIMPLE_SETTINGS = {\n        'DYNAMIC_SETTINGS': {\n            'backend': 'memcached',\n            'host': 'localhost',\n            'port': 11211\n            ...\n        }\n    }\n\n..\n\n    To install with memcached dependencies use: ``pip install simple-settings[memcached]``\n\n\nUtils\n-----\n\nSettings Stub\n~~~~~~~~~~~~~\n\nA simple context manager (and decorator) class useful in tests which is\nnecessary to change some setting in the safe way.\n\nContext Manager example\n^^^^^^^^^^^^^^^^^^^^^^^\n\n.. code:: python\n\n    from simple_settings import settings\n    from simple_settings.utils import settings_stub\n\n\n    with settings_stub(SOME_SETTING='foo'):\n        assert settings.SOME_SETTING == 'foo'\n    assert settings.SOME_SETTING == 'bar'\n\nDecorator example\n^^^^^^^^^^^^^^^^^\n\n.. code:: python\n\n    from simple_settings import settings\n    from simple_settings.utils import settings_stub\n\n\n    @settings_stub(SOME_SETTING='foo')\n    def get_some_setting():\n        return settings.SOME_SETTING\n\n    assert get_some_setting() == 'foo'\n    assert settings.SOME_SETTING == 'bar'\n\n\nAdvanced Usage\n--------------\n\nCustom Strategy\n~~~~~~~~~~~~~~~\n\nTo implement a custom strategy:\n\n.. code:: python\n\n    from simple_settings import settings\n\n    class SettingsCustomStrategy:\n        \"\"\"\n        See `/simple_settings/strategies` for sample strategies (e.g. python, json, cfg)\n        \"\"\"\n\n    settings.add_strategy(SettingsCustomStrategy)\n\n\nCustom Dynamic Settings Reader\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nYou can easily create your own dynamic settings reader. To do that you need to\ncreate a class than inherit from ``simple_settings.dynamic_settings.base.BaseReader``\nand implement ``_get`` and ``_set`` methods, f.ex:\n\n.. code:: python\n\n   from simple_settings.dynamic_settings.base import BaseReader\n\n\n   class Reader(BaseReader):\n\n       def __init__(self, conf):\n           super(Reader, self).__init__(conf)\n           self._dict = {}\n\n       def _get(self, key):\n           return self._dict.get(key)\n\n       def _set(self, key, value):\n           self._dict[key] = value\n\n..\n\nTo use it, just configure ``SIMPLE_SETINGS`` special setting with the full path\nof the reader, f.ex:\n\n.. code:: python\n\n   'SIMPLE_SETTINGS': {\n       'DYNAMIC_SETTINGS': {\n         'backend': 'path.of.module.ClassName'\n       }\n   }\n..\n\nAny other config of dynamic settings will be pass to reader backend on argument ``conf``\n\n\nChangelog\n---------\n[1.2.0] - 2021-12-30\n~~~~~~~~~~~~~~~~~~~~\n\n- Update dependencies\n- Deprecated Consul Dynamic Settings Reader\n- Implement `strtobool` function (and remove distutils dependency)\n\n\n[1.1.0] - 2021-10-26\n~~~~~~~~~~~~~~~~~~~~\n\n- Fix ``TypeError`` when load an empty config file.\n- Update dependencies.\n- Add log on Python Load Strategy to logging when an exception raises on import process.\n\n[1.0.0] - 2020-09-29\n~~~~~~~~~~~~~~~~~~~~\n\n- Drop support to python \u003c 3.6.\n- Update dependencies.\n\n\n[0.19.1] - 2019-10-21\n~~~~~~~~~~~~~~~~~~~~~\n\n- Load dynamic settings reader with both ways, full class path and module path\n  (assuming the reader class is called ``Reader``)\n\n[0.19.0] - 2019-10-18\n~~~~~~~~~~~~~~~~~~~~~\n\n- Change import dynamic reader mechanism to using full class path with dot notation\n- Update several dependencies\n- ``json.loads`` of ``REQUIRED_SETTINGS_TYPES`` now converts and validate lists\n\n[0.18.0] - 2019-07-14\n~~~~~~~~~~~~~~~~~~~~~\n\n- Fix ``TypeError`` on ``jsonpickle.decode`` when ``auto_casting`` is True and\n  dynamic backend returns None.\n- Raise exception containing ``settings_file`` information when an error occurs\n  in ``strategy.load_settings_file`` call from ``_load_settings_pipeline``.\n- If dynamic settings is enabled, query first the dynamic backend before\n  raising an AttributeError.\n\n[0.17.0] - 2019-07-10\n~~~~~~~~~~~~~~~~~~~~~\n\n- Allow settings to be loaded from environment variables via ``.environ`` or ``PREFIX_.environ``\n- Allow ``LazySettings.strategies`` to be easily overridden.\n- Using ``strtobool`` from standard library on ``Required Settings Type`` feature.\n\n[0.16.0] - 2019-02-23\n~~~~~~~~~~~~~~~~~~~~~\n\n- ``json.loads`` as new ``REQUIRED_SETTINGS_TYPES``\n\n[0.15.0] - 2019-02-23\n~~~~~~~~~~~~~~~~~~~~~\n\n- Enforce ordering of special settings being applied\n- Dynamic settings behaviors with ``memcached``.\n- Fix ``TypeError`` on load settings by YAML file with a relative path\n\n[0.14.0] - 2019-01-31\n~~~~~~~~~~~~~~~~~~~~~\n\n- Required not none special setting\n- Required types special setting and type conversion\n\n[0.13.0] - 2018-03-28\n~~~~~~~~~~~~~~~~~~~~~\n\n- Dynamic settings behaviors with ``AWS S3``.\n\n[0.12.1] - 2017-10-27\n~~~~~~~~~~~~~~~~~~~~~\n\n- Fix dynamic settings read behavior to ignore only ``None`` values and not ``zeros`` values ( `#68 \u003chttps://github.com/drgarcia1986/simple-settings/issues/68\u003e`__)\n\n[0.12.0] - 2017-03-07\n~~~~~~~~~~~~~~~~~~~~~\n\n-  Load settings from *toml* files.\n\n[0.11.0] - 2017-02-17\n~~~~~~~~~~~~~~~~~~~~~\n\n-  Autoconfigure python logging with ``CONFIGURE_LOGGING`` *special\n   setting*.\n\n[0.10.0] - 2016-10-28\n~~~~~~~~~~~~~~~~~~~~~\n\n-  Support configuring dynamic backends with an optional *prefix*.\n\n[0.9.1] - 2016-09-15\n~~~~~~~~~~~~~~~~~~~~\n\n-  ``configure`` method now works even called before the LazySettings\n   setup.\n\n[0.9.0] - 2016-08-12\n~~~~~~~~~~~~~~~~~~~~\n\n-  ``configure`` method now update settings in dynamic settings.\n-  On get setting value in dynamic setting update local settings with\n   this value.\n-  Auto casting value in dynamic storage to using complex types.\n\n[0.8.1] - 2016-06-04\n~~~~~~~~~~~~~~~~~~~~\n\n-  Fix instalation with ``database`` extra requires.\n\n[0.8.0] - 2016-06-04\n~~~~~~~~~~~~~~~~~~~~\n\n-  Better ``ImportError`` message if using a dynamic reader without your\n   lib dependencies.\n-  Refactor in Settings Stub.\n-  Dynamic settings behaviors with ``SQLAlchemy`` (``database``\n   backend).\n-  Load settings of *json* files.\n\n[0.7.0] - 2016-06-02\n~~~~~~~~~~~~~~~~~~~~\n\n-  Nice python *REPR* for *LazySettings* objects.\n-  Dynamic settings behaviors with ``Redis``.\n-  Dynamic settings behaviors with ``Consul``.\n-  Generate package with python wheel.\n\n[0.6.0] - 2016-05-17\n~~~~~~~~~~~~~~~~~~~~\n\n-  Some refactors.\n-  Determine settings files and modules directly in LazySettings object\n   (to avoid use env or command line argument).\n-  ``configure`` method to update settings.\n-  Use ``safe_load`` instead ``load`` in yaml strategy.\n\n[0.5.0] - 2016-02-03\n~~~~~~~~~~~~~~~~~~~~\n\n-  Some refactors.\n-  Load settings of *yaml* files.\n-  New ``SIMPLE_SETTINGS`` environment variable.\n-  New ``--simple-settings`` command line arg.\n\n[0.4.0] - 2016-01-03\n~~~~~~~~~~~~~~~~~~~~\n\n-  Lazy settings load.\n\n[0.3.1] - 2015-07-23\n~~~~~~~~~~~~~~~~~~~~\n\n-  Avoid to load python modules (as settings) in python files (with\n   this, fix ``deepcopy`` bug in ``as_dict()`` method).\n\n[0.3.0] - 2015-07-19\n~~~~~~~~~~~~~~~~~~~~\n\n-  Deepcopy in ``as_dict`` method to anticipate unexpected changes.\n-  Special Settings Behaviors.\n\n   -  Override settings values by environment.\n   -  Required settings validation.\n\n-  Remove default behavior of override settings values by environment\n   (now it's a special settings).\n-  Settings Stub (useful for tests)\n-  Change bahavior of settings ``__getattr__`` (before may raise\n   ``KeyError`` if simple-settings do not locate the setting, now raise\n   ``AttributeError``)\n\n[0.2.0] - 2015-06-19\n~~~~~~~~~~~~~~~~~~~~\n\n-  Load multiple settings separated by comma (like a pipeline).\n-  Load settings of *cfg* files.\n-  Filter python module attributes to read only user settings.\n\n[0.1.1] - 2015-05-19\n~~~~~~~~~~~~~~~~~~~~\n\n-  Fix parser\\_args error if using simple-settings with others command\n   line arguments.\n\n[0.1.0] - 2015-05-14\n~~~~~~~~~~~~~~~~~~~~\n\n-  First release.\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdrgarcia1986%2Fsimple-settings","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdrgarcia1986%2Fsimple-settings","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdrgarcia1986%2Fsimple-settings/lists"}