def each_constructor(loader: SafeLoader, node: Node) -> list: input_list, attr, is_required = loader.construct_sequence(node, deep=True) result = [] for item in input_list: try: result.append(attrgetter(attr)(attr_wrap(item))) except KeyError: if is_required: raise return result
def join_constructor(loader: SafeLoader, node: Node) -> str: info = loader.construct_sequence(node, deep=True) separator, input_list = info[0], info[1] format = info[2] if len(info) == 3 else '{l}' def flatten(l: list) -> list: return sum(map(flatten, l), []) if isinstance(l, list) else [l] input_list = flatten(input_list) return separator.join(value for item in input_list if (value := formatter.format(format, l=item)))
def insert_constructor(loader: SafeLoader, node: Node) -> list: if isinstance(node.value[0], ScalarNode): info = InsertInfo( sequence=loader.construct_object(node.value[0], deep=True)) else: info = InsertInfo( *loader.construct_sequence(node.value[0], deep=True)) current_list: List[Any] = info.sequence # already constructed input_list: List[Any] = [ loader.construct_object(n, deep=True) for n in node.value[1:] ] if info.replace_format is None and info.positions is None: return current_list + input_list def item_id(item: Any, idx: int) -> int: return idx if info.replace_format is None else formatter.format( info.replace_format, l=item) # ordered result_dict = { item_id(item, idx): item for idx, item in enumerate(current_list) } input_dict = { item_id(item, idx + len(result_dict)): item for idx, item in enumerate(input_list) } to_pos = {} to_end = [] for input_pos, (input_id, input_item) in zip_longest(info.positions or [], input_dict.items()): if input_pos is not None: result_dict.pop(input_id, None) to_pos[input_pos] = input_item elif input_id in result_dict: result_dict[input_id] = input_item else: to_end.append(input_item) result_list = list(result_dict.values()) + to_end for item in sorted(to_pos): result_list.insert(item, to_pos[item]) return result_list
def get_constructor(loader: SafeLoader, node: Node): input_list, attr = loader.construct_sequence(node, deep=True) return attrgetter(attr)(attr_wrap(input_list))
def concat_constructor(loader: SafeLoader, node: Node) -> list: input_list: List[list] = loader.construct_sequence(node, deep=True) result = [item for list_ in input_list for item in list_] return result
which case, it must end in ``.yaml`` or ``.yml``. """ import sys import os import configparser from logging.config import fileConfig, dictConfig from pathlib import Path import yaml from yaml import SafeLoader as sf _here = Path(__file__).parent _config_files = [_here / 'defaults.ini', '/etc/ega/conf.ini'] sf.add_constructor('tag:yaml.org,2002:python/tuple', lambda self, node: tuple(sf.construct_sequence(self, node))) class Configuration(configparser.ConfigParser): """Configuration from config_files or environment variables or config server (e.g. Spring Cloud Config).""" log_conf = None def _load_conf(self, args=None, encoding='utf-8'): """Load a configuration file from `args`.""" # Finding the --conf file try: conf_file = Path(args[args.index('--conf') + 1]).expanduser() if conf_file not in _config_files: _config_files.append(conf_file) print(f"Overriding configuration settings with {conf_file}",