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 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 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))