def config_defaults(configurator, config, files=['config.yml']):
'''
Reads and extends/creates configuration from yaml source.
.. note::
If exists, this method extends config with defaults, so it will not override existing values,
merely add those, that were not defined already!
:param pyramid.config.Configurator configurator: pyramid's app configurator
:param string config: yaml file locations
:param list files: list of files to include from location
'''
# getting spec path
package_name, filename = resolve_asset_spec(config)
if not package_name:
path = filename
else:
__import__(package_name)
package = sys.modules[package_name]
path = os.path.join(package_path(package), filename)
config = ConfigManager(files=[os.path.join(path, f) for f in files])
# we could use this method both for creating and extending. Hence the checks to not override
if not 'config' in configurator.registry:
configurator.registry['config'] = config
else:
config.merge(configurator.registry['config'])
configurator.registry['config'] = config
def __init__(self,manifest_file):
ConfigManager.__init__(self, files=manifest_file)
manifest_dir = os.path.dirname(manifest_file)
for key in self.get_task_names():
manifest_config = self[key]
manifest_config.sources = \
[i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.sources]
if hasattr(manifest_config, 'libdirs'):
manifest_config.libdirs = \
[i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.libdirs]
else:
manifest_config.libdirs = ConfigList()
if isinstance(manifest_config.output, basestring):
manifest_config.output = ConfigDict({'normal': manifest_config.output})
if not hasattr(manifest_config, 'include'):
manifest_config.merge({'include':{'head':[],
'tail':[]}})
elif not hasattr(manifest_config.include, 'head'):
manifest_config.include.merge({'head':[]})
elif not hasattr(manifest_config.include, 'tail'):
manifest_config.include.merge({'tail':[]})
manifest_config.include.head = \
[i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.include.head]
manifest_config.include.tail = \
[i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.include.tail]
for k, v in manifest_config.output.items():
if not v.startswith('/'):
manifest_config.output[k] = os.path.abspath(os.path.join(manifest_dir, v))
def test_builtins(self):
cm = ConfigManager(init_value=self.builtin_config)
cm.version = 2.6
self.assertEqual(cm.version, 2.6)
self.assertEqual(cm.general.name, self.builtin_config['general']['name'])
self.assertIsInstance(cm.domains['coldon_ir'], ConfigDict)
self.assertEqual(cm.data.url, 'some uri')
def command(args):
"""Create a configuration file by asking for the settings"""
config = ConfigManager(DEFAULT_CONFIG)
for setting_dict in CONFIG_SETTINGS:
ask_for_setting(config, setting_dict)
contents = yaml.dump(dict(config.items()), default_flow_style=False)
home_dir.get().write_config_file(contents)
return 0
def init(config=None, directories=None, files=None, force=False):
"""
Initialize the configuration manager
:param config: `string` or `dict`
:param directories: semi-colon separated `string` or `list` of director(y|es)
:param files: semi-colon separated `string` or `list` of file(s)
:param force: force initialization even if it's already initialized
"""
global _settings
if not force and _settings is not None:
raise ConfigurationAlreadyInitializedException("Configuration manager object is already initialized.")
context = {
'user_config_dir': user_config_dir()
}
_settings = ConfigManager(__builtin_config, context=context)
if config:
_settings.merge(config)
local_config_file = join(user_config_dir(), 'myrpi.yaml')
if exists(local_config_file):
print('Loading config file: %s' % local_config_file)
_settings.load_files(local_config_file)
if directories:
_settings.load_dirs(directories)
if files:
_settings.load_files(files)
return _settings
def test_builtins(self):
a_date = '2014/12/01'
cm = ConfigManager(init_value=self.builtin_config, context=dict(date=a_date))
cm.merge("""
a_date: %(date)s
""")
cm.version = 2.6
self.assertEqual(cm.version, 2.6)
self.assertEqual(cm.a_date, a_date)
self.assertEqual(cm.general.name, self.builtin_config['general']['name'])
self.assertIsInstance(cm.domains['coldon_ir'], ConfigDict)
self.assertEqual(cm.data.url, 'some uri')
def test_issue9(self):
"""
Test just loading config files: https://github.com/pylover/pymlconf/issues/9
"""
files = [path.join(thisdir, 'files', 'pytest_sauce.conf')]
_cm = ConfigManager(files=files)
self.assertTrue(_cm != None)
_cm.merge("""
browsers:
- browsername: chrome
platform: linux
driver: chrome
""")
def test_issue9(self):
"""
Test just loading config files: https://github.com/pylover/pymlconf/issues/9
"""
files = [path.join(thisdir, 'files', 'pytest_sauce.conf')]
_cm = ConfigManager(files=files)
self.assertTrue(_cm != None)
_cm.merge("""
browsers:
- browsername: chrome
platform: linux
driver: chrome
""")
def get_config():
"""Return the current application config object.
:return: `ConfigManager`
"""
path = os.environ.get("KEYSTORE_CONFIG", None)
if path is None:
raise ValueError(
"No valid path found for configuration file. Either pass a path "
"to set_config() or set the KEYSTORE_CONFIG environment variable.")
path = os.path.abspath(os.path.expanduser(path))
config = ConfigManager()
config.load_files(path)
return config
def __init__(self,manifest_file):
ConfigManager.__init__(self, files=manifest_file)
manifest_dir = os.path.dirname(manifest_file)
for key in self.get_task_names():
manifest_config = self[key]
manifest_config.sources = [i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.sources]
if hasattr(manifest_config,'libdirs'):
manifest_config.libdirs = [i if i.startswith('/') else os.path.abspath(os.path.join(manifest_dir, i)) for i in manifest_config.libdirs]
else:
manifest_config.libdirs = ConfigList()
if not manifest_config.output.startswith('/'):
manifest_config.output = os.path.abspath(os.path.join(manifest_dir, manifest_config.output))
def test_dirs(self):
dirs = [conf_dir]
cm = ConfigManager(init_value=self.builtin_config, dirs=dirs)
# root.conf
self.assertEqual(cm.version, 2.5)
self.assertEqual(cm.domains['coldon_ir'].name, 'coldon')
self.assertEqual(cm.general.tcp_port, 5671)
# general.conf
self.assertEqual(cm.general.name, 'Vahid')
self.assertEqual(cm.domains['fangtooth_ir'].name, 'Fangtooth2')
# domains_coldon.ir.conf
self.assertEqual(cm.domains['coldon_ir'].path, '/home/local/coldon')
# domains_dobisel.com.conf
self.assertEqual(cm.domains['dobisel_com'].path, '/home/local/dobisel')
self.assertEqual(cm.domains['dobisel_com'].name, 'dobisel')
self.assertEqual(cm.domains['dobisel_com'].applications.app1.name, 'app1')
self.assertEqual(cm.domains['dobisel_com'].applications.app2.users.vahid.fullname, 'Vahid Mardani')
self.assertEqual(cm.domains['dobisel_com'].applications.app2.users.vahid.password, 'himopolxx')
# builtins
self.assertEqual(cm.data.url, 'some uri')
def got_postgresql():
# This contains copy-pasted code from the dbfixtures pytest module.
# I know this considered bad practice, but there was no way to obtain
# the information by using existing methods in the module, hence the
# duplication.
try:
importlib.import_module('psycopg2')
except ImportError:
return False
# Adapted from utils.get_config
config_name = pytest.config.getvalue('db_conf')
config = ConfigManager(files=[config_name])
# Adapted from factories.postgresql.postgresql_proc_fixture
postgresql_ctl = config.postgresql.postgresql_ctl
if not os.path.exists(postgresql_ctl):
try:
pg_bindir = subprocess.check_output(
['pg_config', '--bindir'], universal_newlines=True).strip()
except FileNotFoundError:
return False
postgresql_ctl = os.path.join(pg_bindir, 'pg_ctl')
return True
def config_defaults(configurator,
config_locations,
files=['config.yaml', 'config.yml']):
"""
Read and extends/creates configuration from yaml source.
.. note::
If exists, this method extends config with defaults,
so it will not override existing values, merely add those,
that were not defined already!
:param pyramid.config.Configurator configurator: pyramid's app configurator
:param list config_locations: list of yaml file locations
:param list files: list of files to include from location
"""
if not isinstance(config_locations, (list, tuple)):
config_locations = config_locations.split(',')
env = configurator.registry.settings.get('env', 'dev')
file_paths = []
for location in config_locations:
path = _translate_config_path(location)
current_files = files
if os.path.isfile(path):
path, current_files = os.path.split(path)
current_files = [current_files]
for config_path in [
os.path.join(path, f)
for f in _env_filenames(current_files, env)
]:
if os.path.isfile(config_path):
file_paths.append(config_path)
config = ConfigManager(files=file_paths)
# we could use this method both for creating and extending.
# Hence the checks to not override
if 'config' not in configurator.registry:
configurator.registry['config'] = config
else:
config.merge(configurator.registry['config'])
configurator.registry['config'] = config
def test_binary(self):
config = '''
app:
name: MyApp
secret: !!binary YWJj\n
'''
cm = ConfigManager(init_value=config)
self.assertEqual(cm.app.name, 'MyApp')
self.assertEqual(cm.secret, b'abc')
def get_config(request):
"""
Get config from ``db_conf`` param.
:param FixtureRequest request: fixture request object
:rtype: pymlconf.ConfigManager
:returns: :class:`pymlconf.ConfigManager`
"""
config_name = request.config.getvalue('db_conf')
return ConfigManager(files=[config_name])
def config_defaults(
configurator, config_locations, files=['config.yaml', 'config.yml']):
"""
Read and extends/creates configuration from yaml source.
.. note::
If exists, this method extends config with defaults,
so it will not override existing values, merely add those,
that were not defined already!
:param pyramid.config.Configurator configurator: pyramid's app configurator
:param list config_locations: list of yaml file locations
:param list files: list of files to include from location
"""
if not isinstance(config_locations, (list, tuple)):
config_locations = config_locations.split(',')
env = configurator.registry.settings.get('env', 'dev')
file_paths = []
for location in config_locations:
path = _translate_config_path(location)
current_files = files
if os.path.isfile(path):
path, current_files = os.path.split(path)
current_files = [current_files]
for config_path in [
os.path.join(path, f) for f in _env_filenames(current_files, env)
]:
if os.path.isfile(config_path):
file_paths.append(config_path)
config = ConfigManager(files=file_paths)
# we could use this method both for creating and extending.
# Hence the checks to not override
if 'config' not in configurator.registry:
configurator.registry['config'] = config
else:
config.merge(configurator.registry['config'])
configurator.registry['config'] = config
def test_overiding_branch(self):
"""
Testing Branch overriding
"""
cm = ConfigManager(init_value=self._builtin)
self.assertEqual(cm.background, [255, 255, 255])
# testing merge
additinal_config = """
my_section:
item1: hi
app:
listen:
sock3:
addr: 10.8.0.2
port: 9090
"""
cm.merge(additinal_config)
self.assertEqual(cm.app.name, "MyApp")
self.assertEqual(len(cm.app.listen), 3)
self.assertEqual(cm.app.listen.sock1.addr, "192.168.0.1")
self.assertEqual(cm.app.listen.sock1.port, 8080)
self.assertEqual(cm.app.listen.sock2.addr, "127.0.0.1")
self.assertEqual(cm.app.listen.sock2.port, '89')
self.assertEqual(cm.app.listen.sock3.addr, "10.8.0.2") # Issue 7
self.assertEqual(cm.app.listen.sock3.port, 9090) # Issue 7
self.assertEqual(cm.logging.logfile, "/var/log/myapp.log")
self.assertEqual(cm.my_section.item1, "hi")
# testing replace
additinal_config = """
my_section:
item1: hi
app:
listen: false
"""
cm.merge(additinal_config)
self.assertEqual(cm.my_section.item1, "hi")
self.assertEqual(cm.app.listen, False) # Issue 7
def test_builtins(self):
a_date = "2014/12/01"
builtin = """
builtin:
value1: built-in config value
"""
cm = ConfigManager(builtin=builtin, init_value=self.initial_config, context=dict(date=a_date))
self.assertEqual(cm.builtin.value1, "built-in config value")
cm.merge(
"""
a_date: %(date)s
"""
)
self.assertEqual(cm.version, 2.5)
cm.version = 2.6
self.assertEqual(cm.version, 2.6)
self.assertEqual(cm.a_date, a_date)
self.assertEqual(cm.general.name, self.initial_config["general"]["name"])
self.assertIsInstance(cm.domains["coldon_ir"], ConfigDict)
self.assertEqual(cm.data.url, "some uri")
def load(self, force=False, **kw):
"""
Initialize the configuration manager
:param force: force initialization even if it's already initialized
:return:
"""
instance = self._get_instance()
if not force and instance is not None:
raise ConfigurationAlreadyInitializedError(
"Configuration manager object is already initialized.")
self._set_instance(ConfigManager(**kw))
def load_config(args):
"""Tries to load the configuration file or throws ExitWithError."""
config = ConfigManager(DEFAULT_CONFIG)
config_dir = home_dir.get()
try:
if args.config_file is not None:
filename_override = os.path.abspath(args.config_file)
else:
filename_override = None
config_contents = config_dir.read_config_file(filename_override)
config.merge(ConfigManager(config_contents))
except Exception as ex:
print "Error reading configuration: %s" % ex.message
if not 'api_key' in config.keys() or not 'api_secret' in config.keys():
raise ExitWithError(
-1, ("Cosmos command is unconfigured. Use '%s configure' to " +
"create a valid configuration or use --config-file with a " +
"valid configuration file") % sys.argv[0])
config.credentials = (config.api_key, config.api_secret)
strip_config(config)
return config
def test_simple_syntax(self):
"""
Testing simple Yaml syntax
"""
cm = ConfigManager(init_value=self._builtin)
self.assertEqual(cm.app.name, "MyApp")
self.assertEqual(len(cm.app.listen), 2)
self.assertEqual(cm.app.listen.sock1.addr, "192.168.0.1")
self.assertEqual(cm.app.listen.sock1.port, 8080)
self.assertEqual(cm.app.listen.sock2.addr, "127.0.0.1")
self.assertEqual(cm.app.listen.sock2.port, '89')
self.assertEqual(cm.logging.logfile, "/var/log/myapp.log")
self.assertEqual(len(cm.app.languages), 2)
self.assertEqual(cm.app.languages[0], 'english')
self.assertEqual(cm.app.languages[1].language, 'persian')
self.assertEqual(cm.app.languages[1].country, 'iran')
self.assertEqual(cm.logging.formatter, str)
self.assertTrue(isinstance(cm.logging.writer, MyWriter))
def exec(self):
__builtin_config = '''
before_install:
- mkdir test_dir
- cd test_dir
install:
- touch test.txt
- ls
script:
- rm test.txt
after_success:
- ls
- cd ..
- rm -rf test_dir
'''
config = ConfigManager(__builtin_config)
commands = [config.before_install, config.install, config.script, config.after_success]
for command in commands:
for item in command:
yield self.popen(item)
def start(config_files=None):
global config
# Preparing config
config = ConfigManager(__default_config, files=config_files)
# Setting up cherrypy tools
CherrypyMako.setup()
from cherryblog.plugins.sqlalchemy_plugin import SAEnginePlugin
from cherryblog.tools.sqlalchemy_tool import SATool
SAEnginePlugin(cp.engine).subscribe()
cp.tools.db = SATool()
# Importing models and controllers
from cherryblog.controllers import Root
from cherryblog.models import Post
# Configuring cherrypy
cp_config = {
'global': {
'tools.mako.directories': [os.path.join(root_dir, 'views')],
'tools.staticdir.root': root_dir,
'tools.db.on': True,
'tools.sessions.on': True,
'tools.sessions.storage_type': 'ram',
#'tools.sessions.storage_path' : 'sessionsPath',
'tools.sessions.timeout': 60,
},
'/public': {
'tools.staticdir.on': True,
'tools.staticdir.dir': 'public'
}
}
# Starting the server
cp.quickstart(Root(), '', config=cp_config)
def test_overiding_branch(self):
"""
Testing Branch overriding
"""
cm = ConfigManager(init_value=self._builtin)
self.assertEqual(cm.background, [255, 255, 255])
# testing merge
additinal_config = """
my_section:
item1: hi
app:
listen:
sock3:
addr: 10.8.0.2
port: 9090
"""
cm.merge(additinal_config)
self.assertEqual(cm.app.name, "MyApp")
self.assertEqual(len(cm.app.listen), 3)
self.assertEqual(cm.app.listen.sock1.addr, "192.168.0.1")
self.assertEqual(cm.app.listen.sock1.port, 8080)
self.assertEqual(cm.app.listen.sock2.addr, "127.0.0.1")
self.assertEqual(cm.app.listen.sock2.port, '89')
self.assertEqual(cm.app.listen.sock3.addr, "10.8.0.2") # Issue 7
self.assertEqual(cm.app.listen.sock3.port, 9090) # Issue 7
self.assertEqual(cm.logging.logfile, "/var/log/myapp.log")
self.assertEqual(cm.my_section.item1, "hi")
# testing replace
additinal_config = """
my_section:
item1: hi
app:
listen: false
"""
cm.merge(additinal_config)
self.assertEqual(cm.my_section.item1, "hi")
self.assertEqual(cm.app.listen, False) # Issue 7
def getconf():
if Config._conf is None:
Config._conf = ConfigManager(init_value="", files="skynet.cfg", root_file_name="skynet.cfg")
return Config._conf
def init():
global settings
settings = ConfigManager(__builtin_config)
return settings
config_str = '''
app:
name: MyApp
listen:
sock1:
addr: 192.168.0.1
port: 8080
languages:
- english
- {language: persian, country: iran}
logfile: /var/log/myapp.log
'''
cfg = ConfigManager(init_value=config_str)
print(cfg.app.name)
print(cfg.app.listen.sock1.addr)
print(cfg.app.languages[0])
print(cfg.app.languages[1].country)
print(cfg.logfile)
# --------- Prints:
# MyApp
# 192.168.0.1
# english
# iran
# /var/log/myapp.log
def test_dot_in_config_key(self):
m = ConfigManager(self.sample_config)
self.assertEqual(m['server.token.salt'], 1345)
def test_files_with_list_root(self):
files = [path.join(thisdir, 'conf', 'browsers.yaml')]
self.assertRaises(ConfigurationMergeError,
callableObj=lambda: ConfigManager(files=files))
