def dumps(data, ac_parser=None, **options): """ Return string representation of `data` in forced type format. :param data: Config data object to dump :param ac_parser: Forced parser type or parser object :param options: see :func:`dump` :return: Backend-specific string representation for the given data """ if anyconfig.mdicts.is_namedtuple(data): data = to_container(data, **options) return _find_dumper(None, ac_parser).dumps(data, **options)
def dump(data, path_or_stream, ac_parser=None, **options): """ Save `data` as `path_or_stream`. :param data: Config data object (dict[-like] or namedtuple) to dump :param path_or_stream: Output file path or file / file-like object :param ac_parser: Forced parser type or parser object :param options: Backend specific optional arguments, e.g. {"indent": 2} for JSON loader/dumper backend """ dumper = _find_dumper(path_or_stream, ac_parser) LOGGER.info("Dumping: %s", anyconfig.utils.get_path_from_stream(path_or_stream)) if anyconfig.mdicts.is_namedtuple(data): data = to_container(data, **options) # namedtuple -> dict-like dumper.dump(data, path_or_stream, **options)
def multi_load(paths, ac_parser=None, ac_template=False, ac_context=None, **options): """ Load multiple config files. The first argument `paths` may be a list of config file paths or a glob pattern specifying that. That is, if a.yml, b.yml and c.yml are in the dir /etc/foo/conf.d/, the followings give same results:: multi_load(["/etc/foo/conf.d/a.yml", "/etc/foo/conf.d/b.yml", "/etc/foo/conf.d/c.yml", ]) multi_load("/etc/foo/conf.d/*.yml") :param paths: List of config file paths or a glob pattern to list paths, or a list of file/file-like objects :param ac_parser: Forced parser type or parser object :param ac_template: Assume configuration file may be a template file and try to compile it AAR if True :param ac_context: A dict presents context to instantiate template :param options: Optional keyword arguments: - Common options: - ac_merge (merge): Specify strategy of how to merge results loaded from multiple configuration files. See the doc of :mod:`m9dicts` for more details of strategies. The default is m9dicts.MS_DICTS. - ac_marker (marker): Globbing marker to detect paths patterns. - ac_namedtuple: Convert result to nested namedtuple object if True - ac_schema: JSON schema file path to validate given config file - Common backend options: - ignore_missing: Ignore and just return empty result if given file (``path_or_stream``) does not exist. - Backend specific options such as {"indent": 2} for JSON backend :return: dict or dict-like object supports merge operations """ marker = options.setdefault("ac_marker", options.get("marker", '*')) schema = _load_schema(ac_template=ac_template, ac_context=ac_context, **options) options["ac_schema"] = None # It's not needed now. cnf = to_container(ac_context, **options) same_type = anyconfig.utils.are_same_file_types(paths) if is_path(paths) and marker in paths: paths = anyconfig.utils.sglob(paths) for path in paths: opts = options.copy() opts["ac_namedtuple"] = False # Disabled within this loop. # Nested patterns like ['*.yml', '/a/b/c.yml']. if is_path(path) and marker in path: cups = multi_load(path, ac_parser=ac_parser, ac_template=ac_template, ac_context=cnf, **opts) else: if same_type: ac_parser = find_loader(path, ac_parser, is_path(path)) cups = single_load(path, ac_parser=ac_parser, ac_template=ac_template, ac_context=cnf, **opts) if cups: cnf.update(cups) return _maybe_validated(cnf, schema, **options)