def settings(): mode = 'TRAVIS' if os.environ.get('TRAVIS') else 'TEST' os.environ['DYNA%s_HOSTNAME' % mode] = 'host.com' os.environ['DYNA%s_PORT' % mode] = '@int 5000' os.environ['DYNA%s_VALUE' % mode] = '@float 42.1' os.environ['DYNA%s_ALIST' % mode] = '@json ["item1", "item2", "item3"]' os.environ['DYNA%s_ADICT' % mode] = '@json {"key": "value"}' os.environ['DYNA%s_DEBUG' % mode] = '@bool true' os.environ['PROJECT1_HOSTNAME'] = 'otherhost.com' sets = LazySettings( LOADERS_FOR_DYNACONF=[ 'dynaconf.loaders.env_loader', 'dynaconf.loaders.redis_loader' ], DYNACONF_NAMESPACE="DYNA%s" % mode ) sets.configure() return sets
def test_no_reload_on_single_env(tmpdir, mocker): tmpfile = tmpdir.join("settings.toml") tmpfile.write(TOML) same_env_validator = Validator("VERSION", is_type_of=int, env="development") other_env_validator = Validator("NAME", must_exist=True, env="production") settings = LazySettings(ENV_FOR_DYNACONF="DEVELOPMENt", SETTINGS_FILE_FOR_DYNACONF=str(tmpfile)) using_env = mocker.patch.object(settings, "from_env") settings.validators.register(same_env_validator) settings.validators.validate() using_env.assert_not_called() settings.validators.register(other_env_validator) settings.validators.validate() using_env.assert_any_call("production") assert using_env.call_count == 1
def test_set_new_merge_issue_241_1(tmpdir): data = { "default": { "name": "Bruno", "colors": ["red", "green"], "data": { "links": { "twitter": "rochacbruno", "site": "brunorocha.org" } }, } } toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False) settings = LazySettings(environments=True, settings_file="settings.toml") assert settings.NAME == "Bruno" assert settings.COLORS == ["red", "green"] assert settings.DATA.links == { "twitter": "rochacbruno", "site": "brunorocha.org", }
def test_envless_mode_with_prefix(tmpdir): data = { "prefix_foo": "bar", "hello": "world", "prefix_default": 1, "prefix_databases": { "default": { "port": 8080 } }, } toml_loader.write(str(tmpdir.join("settings.toml")), data) settings = LazySettings( settings_file="settings.toml", filter_strategy=PrefixFilter("prefix")) # already the default assert settings.FOO == "bar" with pytest.raises(AttributeError): settings.HELLO assert settings.DEFAULT == 1 assert settings.DATABASES.default.port == 8080
def test_validator_custom_message(tmpdir): """Assert custom message is being processed by validator.""" tmpfile = tmpdir.join("settings.toml") tmpfile.write(TOML) settings = LazySettings(environments=True, SETTINGS_FILE_FOR_DYNACONF=str(tmpfile), silent=True) custom_msg = "You cannot set {name} to {value} in env {env}" settings.validators.register( Validator("MYSQL_HOST", eq="development.com", env="DEVELOPMENT"), Validator("MYSQL_HOST", ne="development.com", env="PRODUCTION"), Validator("VERSION", ne=1, messages={"operations": custom_msg}), ) with pytest.raises(ValidationError) as error: settings.validators.validate() assert custom_msg.format(name="VERSION", value="1", env="DEVELOPMENT") in str(error)
def test_config_aliases(tmpdir): data = { "hello": { "name": "Bruno", "passwd": 1234 }, "awesome": { "passwd": 5678 }, } toml_loader.write(str(tmpdir.join("blarg.toml")), data, merge=False) settings = LazySettings( envvar_prefix="BRUCE", core_loaders=["TOML"], loaders=["dynaconf.loaders.env_loader"], default_env="hello", env_switcher="BRUCE_ENV", prelaod=[], settings_file=["blarg.toml"], includes=[], ENV="awesome", environments=True, ) assert settings.NAME == "Bruno" assert settings.PASSWD == 5678 assert settings.ENVVAR_PREFIX_FOR_DYNACONF == "BRUCE" assert settings.CORE_LOADERS_FOR_DYNACONF == ["TOML"] assert settings.LOADERS_FOR_DYNACONF == ["dynaconf.loaders.env_loader"] assert len(settings._loaders) == 1 assert settings.DEFAULT_ENV_FOR_DYNACONF == "hello" assert settings.ENV_SWITCHER_FOR_DYNACONF == "BRUCE_ENV" assert settings.PRELOAD_FOR_DYNACONF == [] assert settings.SETTINGS_FILE_FOR_DYNACONF == ["blarg.toml"] assert settings.INCLUDES_FOR_DYNACONF == [] assert settings.ENV_FOR_DYNACONF == "awesome" assert settings.current_env == "awesome"
def test_lowercase_read_mode(tmpdir): """ Starting on 3.0.0 lowercase keys are enabled by default """ data = { "foo": "bar", "hello": "world", "default": 1, "databases": { "default": { "port": 8080 } }, } toml_loader.write(str(tmpdir.join("settings.toml")), data) # settings_files mispelled.. should be `settings_file` settings = LazySettings(settings_files="settings.toml") assert settings.FOO == "bar" assert settings.foo == "bar" assert settings.HELLO == "world" assert settings.hello == "world" assert settings.DEFAULT == 1 assert settings.default == 1 assert settings.DATABASES.default.port == 8080 assert settings.databases.default.port == 8080 assert "foo" in settings assert "FOO" in settings # test __dir__ results = dir(settings) assert "foo" in results assert "FOO" in results results = dir(settings.databases) assert "default" in results assert "DEFAULT" in results
def test_cast_before_validate(tmpdir): tmpfile = tmpdir.join("settings.toml") TOML = """ name = 'Bruno' colors = ['red', 'green', 'blue'] """ tmpfile.write(TOML) settings = LazySettings( settings_file=str(tmpfile), silent=True, lowercase_read=True, validators=[ Validator("name", len_eq=5), Validator("name", len_min=1), Validator("name", len_max=5), Validator("colors", len_eq=3), Validator("colors", len_eq=3), Validator("colors", len_eq=24, cast=str), ], ) assert settings.name == "Bruno" assert settings.colors == ["red", "green", "blue"]
def test_set_new_merge_issue_241_2(tmpdir): data = { "default": { "name": "Bruno", "colors": ["red", "green"], "data": { "links": { "twitter": "rochacbruno", "site": "brunorocha.org" } }, } } toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False) data = { "dynaconf_merge": True, "default": { "colors": ["blue"], "data": { "links": { "github": "rochacbruno.github.io" } }, }, } toml_loader.write(str(tmpdir.join("settings.local.toml")), data, merge=False) settings = LazySettings() assert settings.NAME == "Bruno" assert settings.COLORS == ["red", "green", "blue"] assert settings.DATA.links == { "twitter": "rochacbruno", "site": "brunorocha.org", "github": "rochacbruno.github.io", }
def test_preload(tmpdir): data = { "default": { "data": { "links": {"twitter": "rochacbruno", "site": "brunorocha.org"} } } } toml_loader.write(str(tmpdir.join("preload.toml")), data, merge=False) data = { "dynaconf_merge": True, "default": {"data": {"links": {"github": "rochacbruno.github.io"}}}, } toml_loader.write( str(tmpdir.join("main_settings.toml")), data, merge=False ) data = { "dynaconf_merge": True, "default": { "data": {"links": {"mastodon": "mastodon.social/@rochacbruno"}} }, } toml_loader.write(str(tmpdir.join("included.toml")), data, merge=False) settings = LazySettings( PRELOAD_FOR_DYNACONF=["preload.toml"], SETTINGS_FILE_FOR_DYNACONF="main_settings.toml", INCLUDES_FOR_DYNACONF=["included.toml"], ) assert settings.DATA.links == { "twitter": "rochacbruno", "site": "brunorocha.org", "github": "rochacbruno.github.io", "mastodon": "mastodon.social/@rochacbruno", }
def test_config_aliases(tmpdir): data = { "hello": { "name": "Bruno", "passwd": 1234 }, "awesome": { "passwd": 5678 }, } toml_loader.write(str(tmpdir.join("blarg.toml")), data, merge=False) settings = LazySettings( ENVVAR_PREFIX="BRUCE", CORE_LOADERS=["TOML"], LOADERS=["dynaconf.loaders.env_loader"], DEFAULT_ENV="hello", ENV_SWITCHER="BRUCE_ENV", PRELOAD=[], SETTINGS_FILE=["blarg.toml"], INCLUDES=[], ENV="awesome", ) assert settings.NAME == "Bruno" assert settings.PASSWD == 5678 assert settings.ENVVAR_PREFIX_FOR_DYNACONF == "BRUCE" assert settings.CORE_LOADERS_FOR_DYNACONF == ["TOML"] assert settings.LOADERS_FOR_DYNACONF == ["dynaconf.loaders.env_loader"] assert len(settings._loaders) == 1 assert settings.DEFAULT_ENV_FOR_DYNACONF == "hello" assert settings.ENV_SWITCHER_FOR_DYNACONF == "BRUCE_ENV" assert settings.PRELOAD_FOR_DYNACONF == [] assert settings.SETTINGS_FILE_FOR_DYNACONF == ["blarg.toml"] assert settings.INCLUDES_FOR_DYNACONF == [] assert settings.ENV_FOR_DYNACONF == "awesome" assert settings.current_env == "awesome"
def test_set_new_merge_issue_241_4(tmpdir): data = { "name": "Bruno", "colors": ["red", "green"], "data": { "links": {"twitter": "rochacbruno", "site": "brunorocha.org"} }, } toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False) data = {"data__links__telegram": "t.me/rochacbruno"} toml_loader.write( str(tmpdir.join("settings.local.toml")), data, merge=False ) settings = LazySettings(settings_file="settings.toml") assert settings.NAME == "Bruno" assert settings.COLORS == ["red", "green"] assert settings.DATA.links == { "twitter": "rochacbruno", "site": "brunorocha.org", "telegram": "t.me/rochacbruno", }
def test_set_new_merge_issue_241_3(tmpdir): data = { "name": "Bruno", "colors": ["red", "green"], "data": { "links": {"twitter": "rochacbruno", "site": "brunorocha.org"} }, } toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False) data = { "name": "Tommy Shelby", "colors": {"dynaconf_merge": ["yellow", "pink"]}, "data": {"links": {"site": "pb.com"}}, } toml_loader.write( str(tmpdir.join("settings.local.toml")), data, merge=False ) settings = LazySettings(settings_file="settings.toml") assert settings.NAME == "Tommy Shelby" assert settings.COLORS == ["red", "green", "yellow", "pink"] assert settings.DATA.links == {"site": "pb.com"}
def test_set_explicit_merge_token(tmpdir): data = { "a_list": [1, 2], "b_list": [1], "a_dict": { "name": "Bruno" }, } toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False) settings = LazySettings(settings_file="settings.toml") assert settings.A_LIST == [1, 2] assert settings.B_LIST == [1] assert settings.A_DICT == {"name": "Bruno"} assert settings.A_DICT.name == "Bruno" settings.set("a_list", [3], merge=True) assert settings.A_LIST == [1, 2, 3] settings.set("b_list", "@merge [2]") assert settings.B_LIST == [1, 2] settings.set("b_list", "@merge [3, 4]") assert settings.B_LIST == [1, 2, 3, 4] settings.set("b_list", "@merge 5") assert settings.B_LIST == [1, 2, 3, 4, 5] settings.set("b_list", "@merge 6.6") assert settings.B_LIST == [1, 2, 3, 4, 5, 6.6] settings.set("b_list", "@merge false") assert settings.B_LIST == [1, 2, 3, 4, 5, 6.6, False] settings.set("b_list", "@merge foo,bar") assert settings.B_LIST == [1, 2, 3, 4, 5, 6.6, False, "foo", "bar"] settings.set("b_list", "@merge zaz") assert settings.B_LIST == [1, 2, 3, 4, 5, 6.6, False, "foo", "bar", "zaz"] settings.set("a_dict", "@merge {city='Guarulhos'}") assert settings.A_DICT.name == "Bruno" assert settings.A_DICT.city == "Guarulhos" settings.set("a_dict", "@merge country=Brasil") assert settings.A_DICT.name == "Bruno" assert settings.A_DICT.city == "Guarulhos" assert settings.A_DICT.country == "Brasil" settings.set("new_key", "@merge foo=bar") assert settings.NEW_KEY == {"foo": "bar"}
def load( obj: dynaconf.LazySettings, env: str = None, silent: bool = True, key: str = None, filename: str = None, ) -> None: """ Read and load in to `obj` a single key or all keys from ARTIQ datasets. If you would like different name mappings, they need to be specified in a settings file (either set as an environment variable TODO, or defaults to TODO). This defaults to connecting to an ARTIQ master instance on the local machine, but can be changed with the environment variable: TODO Args: obj (dynaconf.LazySettings): the settings instance env (str): settings current env (upper case) default='DEVELOPMENT' silent (bool): if errors should raise key (str): if defined load a single key, else load all from `env` filename (str): Custom filename to load (useful for tests) Returns: None """ # pylint: disable=unused-argument # REQUIRED FILES: # ? ARTIQ config settings (master IP address)?? # ? ARTIQ dataset mappings to variable names?? Env var? # Load data from your custom data source (file, database, memory etc) # use `obj.set(key, value)` or `obj.update(dict)` to load data # use `obj.logger.debug` to log your loader activities # use `obj.find_file('filename.ext')` to find the file in search tree # Return nothing port = 3250 ip = "::1" # TODO: make ip, port, mapping_file to be dynamic-set mapping_file_path = pathlib.Path(obj.find_file("artiq_dataset_map.pyon")) if mapping_file_path.exists() and mapping_file_path.is_file(): obj.logger.debug("Using key mapping file `%s`") key_to_dataset_map = pyon.decode(obj.read_file(mapping_file_path)) dynaconf_keys = list(sorted(key_to_dataset_map.keys())) if key is not None and key in dynaconf_keys: dynaconf_keys = [key] elif key is not None: # TODO: handle silent raise KeyError( "Key {} not in ARTIQ mapping file {}".format(key, mapping_file_path) ) try: artiq_datasets = artiq_connection.Client( ip, port, "master_dataset_db", timeout=10 ) dynaconf_values = list(artiq_datasets.get(k) for k in dynaconf_keys) finally: artiq_datasets.close_rpc() obj.update(dict(zip(dynaconf_keys, dynaconf_values))) else: # TODO if silent: obj.logger.debug("Key mapping file not found. Cannot load ARTIQ datasets") else: raise NotImplementedError( "Loading ARTIQ datasets without mapping file isn't handled" ) obj._loaded_files.append(filename) # pylint: disable=protected-access return
import pytest from dynaconf import LazySettings from dynaconf.loaders.yaml_loader import load, clean settings = LazySettings( NAMESPACE_FOR_DYNACONF='EXAMPLE', ) YAML = """ # the bellow is just to ensure `,` will not break string YAML a: "a,b" example: password: 99999 host: server.com port: 8080 service: url: service.com port: 80 auth: password: qwerty test: 1234 development: password: 88888 host: dev_server.com """ YAML2 = """ example: # @float casting not needed, used only for testing secret: '@float 42'
import pytest from dynaconf import LazySettings from dynaconf.loaders.json_loader import load settings = LazySettings(ENV_FOR_DYNACONF="PRODUCTION") JSON = """ { "a": "a,b", "default": { "password": "******", "host": "server.com", "port": "@int 8080", "alist": ["item1", "item2", 23], "service": { "url": "service.com", "port": 80, "auth": { "password": "******", "test": 1234 } } }, "development": { "password": "******", "host": "devserver.com" }, "production": { "password": "******",
import time import json import pymysql import datetime as dt import pandas as pd import numpy as np from sqlalchemy import create_engine from functools import wraps from dynaconf import LazySettings # from common.config import SERVER_CONF from yzy_server.database import apis as db_api from yzy_server.database import models from common.utils import build_result from common import constants settings = LazySettings(ROOT_PATH_FOR_DYNACONF=constants.BASE_DIR) DATABASE_HOST = settings.get('HOST', '127.0.0.1') DATABASE_PORT = settings.get('PORT', 3306) DATABASE_USER = settings.get('USER', 'root') DATABASE_PASSWORD = settings.get('PASSWORD', '123qwe,.') DATABASE_NAME = settings.get('NAME', 'yzy_kvm_db') engine = create_engine("mysql+mysqlconnector://{user}:{password}@{host}:{port}/{db_name}?charset=utf8". format(**{"user": DATABASE_USER, "password": DATABASE_PASSWORD, "host": DATABASE_HOST, "port": DATABASE_PORT, "db_name": DATABASE_NAME})) # engine = create_engine( # SERVER_CONF.addresses.get_by_default('sqlalchemy_database_uri', # 'mysql+mysqlconnector://root:123qwe,.@localhost:3306/yzy_kvm_db?')) logger = logging.getLogger(__name__) def timefn(fn):
def test_post_load_hooks(clean_env, tmpdir): """Test post load hooks works This test uses 3 settings files PRELOAD = "plugin_folder/plugin.py" SETTINGS_FILE = "settings.py" HOOKFILES = ["plugin_folder/dynaconf_hooks.py", "dynaconf_hooks.py"] The hook file has a function called "post" which is called after loading the settings, that function accepts the argument `settings` which is a copy of the settings object, and returns a dictionary of settings to be merged. """ # Arrange plugin_folder = tmpdir.mkdir("plugin_folder") plugin_folder.join("__init__.py").write('print("initing plugin...")') plugin_path = plugin_folder.join("plugin.py") plugin_hook = plugin_folder.join("dynaconf_hooks.py") settings_path = tmpdir.join("settings.py") settings_hook = tmpdir.join("dynaconf_hooks.py") to_write = { str(plugin_path): ["PLUGIN_NAME = 'DummyPlugin'"], str(settings_path): [ "INSTALLED_APPS = ['admin']", "COLORS = ['red', 'green']", "DATABASES = {'default': {'NAME': 'db'}}", "BANDS = ['Rush', 'Yes']", ], str(plugin_hook): [ "post = lambda settings: " "{" "'PLUGIN_NAME': settings.PLUGIN_NAME.lower()," "'COLORS': '@merge blue'," "'DATABASES__default': '@merge PORT=5151'," "'DATABASES__default__VERSION': 42," "'DATABASES__default__FORCED_INT': '@int 12',", "'BANDS': ['Anathema', 'dynaconf_merge']" "}", ], str(settings_hook): [ "post = lambda settings: " "{" "'INSTALLED_APPS': [settings.PLUGIN_NAME]," "'dynaconf_merge': True," "}" ], } for path, lines in to_write.items(): with open(str(path), "w", encoding=default_settings.ENCODING_FOR_DYNACONF) as f: for line in lines: f.write(line) f.write("\n") # Act settings = LazySettings(preload=["plugin_folder.plugin"], settings_file="settings.py") # Assert assert settings.PLUGIN_NAME == "dummyplugin" assert settings.INSTALLED_APPS == ["admin", "dummyplugin"] assert settings.COLORS == ["red", "green", "blue"] assert settings.DATABASES.default.NAME == "db" assert settings.DATABASES.default.PORT == 5151 assert settings.DATABASES.default.VERSION == 42 assert settings.DATABASES.default.FORCED_INT == 12 assert settings.BANDS == ["Rush", "Yes", "Anathema"] assert settings._loaded_hooks[str(plugin_hook)] == { "post": { "PLUGIN_NAME": "dummyplugin", "COLORS": "@merge blue", "DATABASES__default": "@merge PORT=5151", "DATABASES__default__VERSION": 42, "DATABASES__default__FORCED_INT": "@int 12", "BANDS": ["Anathema", "dynaconf_merge"], } } assert settings._loaded_hooks[str(settings_hook)] == { "post": { "INSTALLED_APPS": ["dummyplugin"], } }
def test_validators(tmpdir): tmpfile = tmpdir.join("settings.toml") tmpfile.write(TOML) settings = LazySettings( ENV_FOR_DYNACONF="EXAMPLE", SETTINGS_FILE_FOR_DYNACONF=str(tmpfile), silent=True, ) settings.validators.register( Validator("VERSION", "AGE", "NAME", must_exist=True), Validator("AGE", lte=30, gte=10), Validator("PROJECT", eq="hello_world"), Validator("PRESIDENT", env="DEVELOPMENT", ne="Trump"), Validator("SALARY", lt=1000000, gt=1000), Validator("DEV_SERVERS", must_exist=True, is_type_of=(list, tuple)), Validator("MYSQL_HOST", env="DEVELOPMENT", is_in=settings.DEV_SERVERS), Validator("MYSQL_HOST", env="PRODUCTION", is_not_in=settings.DEV_SERVERS), Validator("NAME", condition=lambda x: x in ("BRUNO", "MIKE")), Validator( "IMAGE_1", "IMAGE_2", env="development", must_exist=True, when=Validator("BASE_IMAGE", must_exist=True, env=settings.ENV_FOR_DYNACONF), ), Validator( "IMAGE_4", "IMAGE_5", env=("development", "production"), must_exist=True, when=Validator("BASE_IMAGE", must_exist=False, env=settings.ENV_FOR_DYNACONF), ), Validator( "PORT", must_exist=True, ne=8000, when=Validator("MYSQL_HOST", eq="localhost"), ), # Validator("ZERO", is_type_of=int, eq=0), Validator("FALSE", is_type_of=bool, eq=False), ) assert settings.validators.validate() is None settings.validators.register( Validator("TESTVALUEZZ", env="development"), Validator("TESTVALUE", eq="hello_world"), ) with pytest.raises(ValidationError): settings.validators.validate() with pytest.raises(TypeError): Validator("A", condition=1) with pytest.raises(TypeError): Validator("A", when=1)
def test_from_env_method(clean_env, tmpdir): data = { "default": { "a_default": "From default env" }, "development": { "value": "From development env", "only_in_development": True, }, "other": { "value": "From other env", "only_in_other": True }, } toml_path = str(tmpdir.join("base_settings.toml")) toml_loader.write(toml_path, data, merge=False) settings = LazySettings(settings_file=toml_path, environments=True) settings.set("ARBITRARY_KEY", "arbitrary value") assert settings.VALUE == "From development env" assert settings.A_DEFAULT == "From default env" assert settings.ONLY_IN_DEVELOPMENT is True assert settings.ARBITRARY_KEY == "arbitrary value" assert settings.get("ONLY_IN_OTHER") is None # clone the settings object pointing to a new env other_settings = settings.from_env("other") assert other_settings.VALUE == "From other env" assert other_settings.A_DEFAULT == "From default env" assert other_settings.ONLY_IN_OTHER is True assert other_settings.get("ARBITRARY_KEY") is None assert other_settings.get("ONLY_IN_DEVELOPMENT") is None with pytest.raises(AttributeError): # values set programatically are not cloned other_settings.ARBITRARY_KEY with pytest.raises(AttributeError): # values set only in a specific env not cloned other_settings.ONLY_IN_DEVELOPMENT # assert it is cached not created twice assert other_settings is settings.from_env("other") # Now the same using keep=True other_settings = settings.from_env("other", keep=True) assert other_settings.VALUE == "From other env" assert other_settings.A_DEFAULT == "From default env" assert other_settings.ONLY_IN_OTHER is True assert other_settings.ONLY_IN_DEVELOPMENT is True assert settings.ARBITRARY_KEY == "arbitrary value" # assert it is created not cached assert other_settings is not settings.from_env("other") # settings remains the same assert settings.VALUE == "From development env" assert settings.A_DEFAULT == "From default env" assert settings.ONLY_IN_DEVELOPMENT is True assert settings.ARBITRARY_KEY == "arbitrary value" assert settings.get("ONLY_IN_OTHER") is None # additional kwargs data = { "default": { "a_default": "From default env" }, "production": { "value": "From prod env", "only_in_prod": True }, "other": { "value": "From other env", "only_in_other": True }, } toml_path = str(tmpdir.join("other_settings.toml")) toml_loader.write(toml_path, data, merge=False) new_other_settings = other_settings.from_env( "production", keep=True, SETTINGS_FILE_FOR_DYNACONF=toml_path) # production values assert new_other_settings.VALUE == "From prod env" assert new_other_settings.ONLY_IN_PROD is True # keep=True values assert new_other_settings.ONLY_IN_OTHER is True assert new_other_settings.ONLY_IN_DEVELOPMENT is True assert settings.A_DEFAULT == "From default env"
def init_app(self, app, **kwargs): """kwargs holds initial dynaconf configuration""" self.kwargs.update(kwargs) self.settings = self.dynaconf_instance or LazySettings(**self.kwargs) app.config = self.make_config(app) app.dynaconf = self.settings
from dynaconf import LazySettings settings = LazySettings(envless_mode=True, lowercase_read=True) assert settings.server == "foo.com" assert settings.SERVER == "foo.com" assert settings["SERVER"] == "foo.com" assert settings["server"] == "foo.com" assert settings("SERVER") == "foo.com" assert settings("server") == "foo.com" assert settings.get("SERVER") == "foo.com" assert settings.get("server") == "foo.com"
from pathlib import Path from dynaconf import LazySettings # Tell dynaconf to search in folder of this conf.py file first config = LazySettings(ROOT_PATH_FOR_DYNACONF=Path(__file__).parent, CORE_LOADERS_FOR_DYNACONF=('TOML', ), SETTINGS_FILE_FOR_DYNACONF=('settings.toml', '.secrets.toml')) config.DATABASES = { 'default': { 'engine': 'tortoise.backends.asyncpg', 'credentials': { 'host': None, 'port': 0, 'user': None, 'password': None, 'database': config.DB_NAME, } }, }
# coding: utf-8 from dynaconf import LazySettings, Validator settings = LazySettings(ENV_FOR_DYNACONF='EXAMPLE', silent=True) settings.validators.register( Validator('VERSION', 'AGE', 'NAME', must_exist=True), Validator( 'AGE', lte=30, gte=10, ), Validator( 'PROJECT', eq='hello_world', ), Validator( 'PRESIDENT', env='DEVELOPMENT', ne='Trump', ), Validator('SALARY', lt=1000000, gt=1000), Validator('DEV_SERVERS', must_exist=True, is_type_of=(list, tuple)), Validator('MYSQL_HOST', env='DEVELOPMENT', is_in=settings.DEV_SERVERS), Validator('MYSQL_HOST', env='PRODUCTION', is_not_in=settings.DEV_SERVERS), Validator('NAME', condition=lambda x: x in ('BRUNO', 'MIKE')), Validator('IMAGE_1', 'IMAGE_2', env='development', must_exist=True, when=Validator('BASE_IMAGE', must_exist=True, env=settings.ENV_FOR_DYNACONF)), Validator('IMAGE_4',
# -*- coding: utf-8 -*- import multiprocessing import os from dynaconf import LazySettings from common.utils import _ConfigParser from common import constants basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) settings = LazySettings(ROOT_PATH_FOR_DYNACONF=constants.BASE_DIR) class BaseConfig: """ 生产配置 """ DEBUG = False _LOCALES = ['en_US', 'zh_Hans_CN'] BABEL_DEFAULT_LOCALE = _LOCALES[0] SECRET_KEY = os.getenv('SECRET_KEY', 'a secret string') # 数据库配置 DATABASE_HOST = settings.get('HOST', '127.0.0.1') DATABASE_PORT = settings.get('PORT', 3306) DATABASE_USER = settings.get('USER', 'root') DATABASE_PASSWORD = settings.get('PASSWORD', '123qwe,.') DATABASE_NAME = settings.get('NAME', 'yzy_kvm_db') # DATABASE_HOST = '127.0.0.1' # DATABASE_PORT = 3306 # DATABASE_USER = '******' # DATABASE_PASSWORD = '******'
# return os.environ["APPDATA"] def get_home(): return os.path.join(get_user_home(), '.omc') settings_file = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'settings.yaml') module_setting_files = [] for finder, name, ispkg in pkgutil.iter_modules(): if name.startswith('omc_'): resource_type = name.replace('omc_', '').lower() try: module_setting_file = pkg_resources.resource_filename( 'omc_%(resource_type)s.config' % locals(), 'settings.yaml') if os.path.exists(module_setting_file): module_setting_files.append(module_setting_file) except Exception as error: pass settings = LazySettings( # PRELOAD_FOR_DYNACONF=[os.path.join(os.environ['HOME'], '.omw', 'config', '*')] SETTINGS_FILE_FOR_DYNACONF= settings_file, # <-- Loaded second (the main file) INCLUDES_FOR_DYNACONF=[ *module_setting_files, os.path.join(get_home(), 'config', '*.yaml') ])
import sys import json from typing import Dict from dynaconf import LazySettings from opa.core.logger import log config = LazySettings() from opa.core.plugin import ( HookDefinition, Hook, Driver, Setup, get_plugin_manager, get_util, get_component, get_instance, get_router, call_hook, call_hook_async, ) def init_configuration(): config.configure( ENV_SWITCHER_FOR_DYNACONF='ENV', ENVVAR_PREFIX_FOR_DYNACONF='OPA', ROOT_PATH_FOR_DYNACONF='/data/settings', ENVIRONMENTS_FOR_DYNACONF=True,
# -*- coding: utf-8 -*- import os from dynaconf import LazySettings from common.utils import _ConfigParser from common.constants import BASE_DIR basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__))) settings = LazySettings(ROOT_PATH_FOR_DYNACONF=BASE_DIR) class BaseConfig: """ 生产配置 """ DEBUG = False _LOCALES = ['en_US', 'zh_Hans_CN'] BABEL_DEFAULT_LOCALE = _LOCALES[0] SECRET_KEY = os.getenv('SECRET_KEY', 'a secret string') # 数据库配置 DATABASE_HOST = settings.get('HOST', '127.0.0.1') DATABASE_PORT = settings.get('PORT', 3306) DATABASE_USER = settings.get('USER', 'root') DATABASE_PASSWORD = settings.get('PASSWORD', '123qwe,.') DATABASE_NAME = settings.get('NAME', 'yzy_kvm_db') # DATABASE_HOST = '127.0.0.1' # DATABASE_PORT = 3306 # DATABASE_USER = '******' # DATABASE_PASSWORD = '******' # DATABASE_NAME = 'yzy_kvm_db'
from dynaconf import LazySettings, Validator from uptimer import ROOT_PATH settings = LazySettings( DEBUG_LEVEL_FOR_DYNACONF="DEBUG", CORE_LOADERS_FOR_DYNACONF=["TOML", "ENV"], ENV_SWITCHER_FOR_DYNACONF="UPTIMER_ENV", ENVVAR_PREFIX_FOR_DYNACONF=False, LOADERS_FOR_DYNACONF=["dynaconf.loaders.env_loader"], ROOT_PATH_FOR_DYNACONF=ROOT_PATH, SETTINGS_FILE_FOR_DYNACONF="settings.toml,.secrets.toml", ) settings.validators.register( # Ensure writer plugin exists Validator("WRITER_PLUGIN", must_exist=True), # Ensure reader plugin exists, but only when queue plugin does not Validator("READER_PLUGIN", must_exist=True, when=Validator("QUEUE_PLUGIN", eq="")), ) settings.validators.validate()
from __future__ import annotations from dynaconf import LazySettings from dynaconf import Validator from dynaconf.utils.parse_conf import Lazy settings = LazySettings( environments=True, ENV="EXAMPLE", load_dotenv=True, settings_files="settings.py", ) settings.validators.register( Validator("VERSION", "AGE", "NAME", must_exist=True), Validator("AGE", lte=30, gte=10), Validator("PROJECT", eq="hello_world"), Validator("PRESIDENT", env="DEVELOPMENT", ne="Trump"), Validator("SALARY", lt=1000000, gt=1000), Validator("DEV_SERVERS", must_exist=True, is_type_of=(list, tuple)), Validator("MYSQL_HOST", env="DEVELOPMENT", is_in=settings.DEV_SERVERS), Validator("MYSQL_HOST", env="PRODUCTION", is_not_in=settings.DEV_SERVERS), Validator("NAME", condition=lambda x: x in ("BRUNO", "MIKE")), Validator( "IMAGE_1", "IMAGE_2", env="development", must_exist=True, when=Validator("BASE_IMAGE", must_exist=True, env=settings.ENV_FOR_DYNACONF),