def test_accepts_only_upper():
"""Only upper case names are allowed if lowercase_read=False
lower case are converted"""
settings = LazySettings(debug=True, lowercase_read=False)
assert settings.DEBUG is True
assert settings.get("debug") is True
assert settings.get("DEBUG") is True
assert settings.get("Debug") is True
assert settings.exists("debug")
with pytest.raises(AttributeError):
# access in lower case is not allowed
assert settings.debug is True
def test_py_loader_from_file_dunder(clean_env, tmpdir):
"""Test load with dunder settings"""
settings = LazySettings(
DATABASES={
"default": {
"NAME": "db",
"ENGINE": "module.foo.engine",
"ARGS": {
"timeout": 30
},
"PORTS": [123, 456],
}
})
dummy_path = tmpdir.join("dummy_module.py")
with open(str(dummy_path),
"w",
encoding=default_settings.ENCODING_FOR_DYNACONF) as f:
f.write('F = "bar"')
f.write("\n")
f.write('COLORS__white__code = "#FFFFFF"')
f.write("\n")
f.write('DATABASES__default__ENGINE = "other.module"')
load(settings, "dummy_module.py")
os.remove("dummy_module.py")
load(settings, "dummy_module.py") # will be ignored not found
assert settings.get("F") == "bar"
assert settings.COLORS == {"white": {"code": "#FFFFFF"}}
assert settings.DATABASES.default.NAME == "db"
assert settings.DATABASES.default.ENGINE == "other.module"
def test_load_from_redis_with_key(docker_redis):
os.environ["REDIS_ENABLED_FOR_DYNACONF"] = "1"
os.environ["REDIS_HOST_FOR_DYNACONF"] = "localhost"
os.environ["REDIS_PORT_FOR_DYNACONF"] = "6379"
settings = LazySettings(environments=True)
load(settings, key="SECRET")
assert settings.get("SECRET") == "redis_works_with_docker"
def test_write_to_vault(docker_vault):
os.environ["VAULT_ENABLED_FOR_DYNACONF"] = "1"
os.environ["VAULT_TOKEN_FOR_DYNACONF"] = "myroot"
settings = LazySettings(environments=True)
write(settings, {"SECRET": "vault_works_with_docker"})
load(settings, key="SECRET")
assert settings.get("SECRET") == "vault_works_with_docker"
def test_write_and_load_from_vault_without_key(docker_vault):
os.environ["VAULT_ENABLED_FOR_DYNACONF"] = "1"
os.environ["VAULT_TOKEN_FOR_DYNACONF"] = "myroot"
settings = LazySettings(environments=True)
write(settings, {"SECRET": "vault_works_perfectly"})
load(settings)
assert settings.get("SECRET") == "vault_works_perfectly"
def test_write_and_load_from_redis_without_key(docker_redis):
os.environ["REDIS_ENABLED_FOR_DYNACONF"] = "1"
os.environ["REDIS_HOST_FOR_DYNACONF"] = "localhost"
os.environ["REDIS_PORT_FOR_DYNACONF"] = "6379"
settings = LazySettings(environments=True)
write(settings, {"SECRET": "redis_works_perfectly"})
load(settings)
assert settings.get("SECRET") == "redis_works_perfectly"
def test_dynaconf_namespace_renamed(tmpdir, recwarn, deprecated, value, new):
settings = LazySettings(**{deprecated: value})
assert len(recwarn) == 1
assert issubclass(recwarn[0].category, DeprecationWarning)
assert deprecated in str(recwarn[0].message)
assert new in str(recwarn[0].message)
assert settings.get(new) == value
def test_write_to_redis(docker_redis):
os.environ["REDIS_ENABLED_FOR_DYNACONF"] = "1"
os.environ["REDIS_HOST_FOR_DYNACONF"] = "localhost"
os.environ["REDIS_PORT_FOR_DYNACONF"] = "6379"
settings = LazySettings()
write(settings, {"SECRET": "redis_works_with_docker"})
load(settings, key="SECRET")
assert settings.get("SECRET") == "redis_works_with_docker"
def test_delete_from_redis(docker_redis):
os.environ["REDIS_ENABLED_FOR_DYNACONF"] = "1"
os.environ["REDIS_HOST_FOR_DYNACONF"] = "localhost"
os.environ["REDIS_PORT_FOR_DYNACONF"] = "6379"
settings = LazySettings(environments=True)
write(settings, {"OTHER_SECRET": "redis_works"})
load(settings)
assert settings.get("OTHER_SECRET") == "redis_works"
delete(settings, key="OTHER_SECRET")
assert load(settings, key="OTHER_SECRET") is None
def test_explicit_local_files(tmpdir):
settings_file_yaml = """
default:
name: Bruno
colors:
- green
- blue
data:
link: brunorocha.org
other:
foo: bar
music:
current:
volume: 10
title: The Beatles - Strawberry Fields
"""
tmpdir.join("foo.yaml").write(settings_file_yaml)
local_file_yaml = """
default:
name: Bruno Rocha
colors:
- red
- dynaconf_merge
data:
city: Guarulhos
dynaconf_merge: true
other:
baz: zaz
music__current__volume: 100
music__current__title: Led Zeppelin - Immigrant Song
music__current__even__inner__element: true
"""
tmpdir.join("foo.local.yaml").write(local_file_yaml)
conf = LazySettings(
environments=True,
SETTINGS_FILE_FOR_DYNACONF=["foo.yaml", "foo.local.yaml"],
)
assert conf.NAME == "Bruno Rocha"
assert set(conf.COLORS) == {"red", "green", "blue"}
assert conf.DATA.link == "brunorocha.org"
assert conf.DATA.city == "Guarulhos"
assert conf.OTHER == {"baz": "zaz"}
assert conf.MUSIC.current.volume == 100
assert conf.MUSIC.current.title == "Led Zeppelin - Immigrant Song"
assert conf.get("music.current.even.inner.element") is True
def test_from_env_method_with_prefix(clean_env, tmpdir):
data = {
"default": {
"prefix_a_default": "From default env"
},
"development": {
"prefix_value": "From development env",
"prefix_only_in_development": True,
},
"other": {
"prefix_value": "From other env",
"prefix_only_in_other": True,
"not_prefixed": "no prefix",
},
}
toml_path = str(tmpdir.join("base_settings.toml"))
toml_loader.write(toml_path, data, merge=False)
settings = LazySettings(
settings_file=toml_path,
environments=True,
filter_strategy=PrefixFilter("prefix"),
)
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):
other_settings.not_prefixed
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")
from __future__ import annotations
from dynaconf import LazySettings
# No prefix.
settings = LazySettings(
settings_file="settings.toml",
load_dotenv=True,
ignore_unknown_envvars=True,
envvar_prefix=False,
)
assert settings.VAR1 == "bar"
assert not settings.get("SECRET")
# MYAPP_ prefix.
settings = LazySettings(
settings_file="settings.toml",
load_dotenv=True,
ignore_unknown_envvars=True,
envvar_prefix="MYAPP",
)
assert settings.VAR1 == "ham"
assert not settings.get("SECRET")
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"
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import os
from contextlib import suppress
from importlib import import_module
from pkg_resources import iter_entry_points
from dynaconf import LazySettings
# https://github.com/rochacbruno/dynaconf/issues/89
settings = LazySettings(GLOBAL_ENV_FOR_DYNACONF='PULP',
ENVVAR_FOR_DYNACONF='PULP_SETTINGS',
SETTINGS_MODULE_FOR_DYNACONF='/etc/pulp/settings.py')
GLOBAL_ENV_FOR_DYNACONF = settings.get('GLOBAL_ENV_FOR_DYNACONF', 'PULP')
SETTINGS_MODULE_FOR_DYNACONF = settings.get('SETTINGS_MODULE_FOR_DYNACONF',
'/etc/pulp/settings.py')
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = settings.get('BASE_DIR', os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = settings.get('DEBUG', False, '@bool')
ALLOWED_HOSTS = settings.get('ALLOWED_HOSTS', ['*'])
MEDIA_ROOT = settings.get('MEDIA_ROOT', '/var/lib/pulp/')
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):
@wraps(fn)
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'galaxy_api.wsgi.application'
# Database
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': settings.get('DB_NAME', 'galaxy'),
'USER': settings.get('DB_USER', 'galaxy'),
'PASSWORD': settings.get('DB_PASSWORD', ''),
'HOST': settings.get('DB_HOST', 'localhost'),
'PORT': settings.get('DB_PORT', ''),
}
}
# Internationalization
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
from dynaconf import LazySettings
from dynaconf.utils import RENAMED_VARS
# 0 given a bare settings
settings = LazySettings(environments=True)
# 1 Ensure all renamed vars exists in object
for old, new in RENAMED_VARS.items():
assert old in settings
assert new in settings
# 2 Ensure pairs has the same value
for old, new in RENAMED_VARS.items():
assert settings.get(old) == settings.get(new)
assert getattr(settings, new) == getattr(settings, old)
# 0 given a full old-style configured setting
settings = LazySettings(
environments=True,
DYNACONF_NAMESPACE="FOO",
DYNACONF_SETTINGS_MODULE="/tmp/foo.toml",
PROJECT_ROOT="/tmp/",
DYNACONF_SILENT_ERRORS=False,
DYNACONF_ALWAYS_FRESH_VARS=["baz", "zaz", "caz"],
BASE_NAMESPACE_FOR_DYNACONF="original",
GLOBAL_ENV_FOR_DYNACONF="RAZAMANAZ",
)
# 1 Ensure all renamed vars exists in object
for old, new in RENAMED_VARS.items():
assert old in settings, old
def test_load_from_vault_with_key(docker_vault):
os.environ["VAULT_ENABLED_FOR_DYNACONF"] = "1"
os.environ["VAULT_TOKEN_FOR_DYNACONF"] = "myroot"
settings = LazySettings()
load(settings, key="SECRET")
assert settings.get("SECRET") == "vault_works_with_docker"
from dynaconf import LazySettings
settings = LazySettings(environments=True)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = "3vm%5!55xe4rm7_6!v8cp)ne*g-#!d2&_ow*l39-bi54(leh9r"
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = settings.get("debug.enabled", False)
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
]
MIDDLEWARE = [
SETTINGS_FILE_FOR_DYNACONF += glob(os.path.join(directory, "*.ini"))
SETTINGS_FILE_FOR_DYNACONF += glob(os.path.join(directory, "*.yaml"))
SETTINGS_FILE_FOR_DYNACONF += glob(os.path.join(directory, "*.toml"))
_settings = LazySettings(
ENVVAR_PREFIX_FOR_DYNACONF=ENVVAR_PREFIX_FOR_DYNACONF,
SETTINGS_FILE_FOR_DYNACONF=SETTINGS_FILE_FOR_DYNACONF,
)
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SILENCED_SYSTEM_CHECKS = []
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = _settings.get("secret_key", "DoNotUseInProduction")
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = _settings.get("maintenance.debug", False)
INTERNAL_IPS = _settings.get("maintenance.internal_ips", [])
DEBUG_TOOLBAR_CONFIG = {
"RENDER_PANELS": True,
"SHOW_COLLAPSED": True,
"JQUERY_URL": "",
"SHOW_TOOLBAR_CALLBACK": "aleksis.core.util.core_helpers.dt_show_toolbar",
"DISABLE_PANELS": {},
}
DEBUG_TOOLBAR_PANELS = [
"debug_toolbar.panels.versions.VersionsPanel",
"debug_toolbar.panels.timer.TimerPanel",
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'galaxy_api.wsgi.application'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': settings.get('DB_NAME', 'galaxy'),
'USER': settings.get('DB_USER', 'galaxy'),
'PASSWORD': settings.get('DB_PASSWORD', ''),
'HOST': settings.get('DB_HOST', 'localhost'),
'PORT': settings.get('DB_PORT', ''),
}
}
# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
settings = LazySettings(ENV_FOR_DYNACONF="example",
ENVVAR_PREFIX_FOR_DYNACONF="PROGRAM")
print(settings.USERNAME)
print(settings.SERVER)
print(settings.PASSWORD)
assertions = {
"SERVER": "fromenv.com",
"USERNAME": "******",
"PASSWORD": "******",
}
for key, value in assertions.items():
found = settings.get(key)
assert found == getattr(settings, key)
assert found == value, f"expected: {key}: [{value}] found: [{found}]"
assertions = {"SERVER": "fromenv.com", "USERNAME": "******"}
for key, value in assertions.items():
found = settings.from_env("development").get(key)
assert found == getattr(settings.from_env("development"), key)
assert found == value, f"expected: {key}: [{value}] found: [{found}]"
assertions = {
"SERVER": "fromenv.com",
"USERNAME": "******",
"PASSWORD": "******", # keep=True will keep it from [example] env
}
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 ruamel import yaml as yaml
except ImportError:
import yaml
BASE_DIR = os.environ.get("ARA_BASE_DIR", os.path.expanduser("~/.ara/server"))
DEFAULT_SETTINGS = os.path.join(BASE_DIR, "settings.yaml")
settings = LazySettings(
environments=True,
GLOBAL_ENV_FOR_DYNACONF="ARA",
ENVVAR_FOR_DYNACONF="ARA_SETTINGS",
SETTINGS_MODULE_FOR_DYNACONF=DEFAULT_SETTINGS,
)
# reread BASE_DIR since it might have gotten changed in the config file.
BASE_DIR = settings.get("BASE_DIR", BASE_DIR)
# Django doesn't set up logging until it's too late to use it in settings.py.
# Set it up from the configuration so we can use it.
DEBUG = settings.get("DEBUG", False, "@bool")
LOG_LEVEL = settings.get("LOG_LEVEL", "INFO")
# fmt: off
LOGGING = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {
"normal": {
"format": "%(asctime)s %(levelname)s %(name)s: %(message)s"
}
},
