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}",
