nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/pipeline/config.py

@@ -1,265 +0,0 @@
-from os import linesep
-from configparser import ConfigParser
-from ..utils import check_supported, deprecated
-
-#
-# option "type":
-#  - required: always visible, user must provide a valid value
-#  - optional: visible, but might be left blank
-#  - advanced: optional and not visible by default
-#  - unsupported: hidden (not implemented yet)
-_options_levels = {
-    "required": 0,
-    "optional": 1,
-    "advanced": 2,
-    "unsupported": 10,
-}
-
-
-class NabuConfigParser:
-    @deprecated(
-        "The class 'NabuConfigParser' is deprecated and will be removed in a future version. Please use parse_nabu_config_file instead",
-        do_print=True,
-    )
-    def __init__(self, fname):
-        """
-        Nabu configuration file parser.
-
-        Parameters
-        ----------
-        fname: str
-            File name of the configuration file
-        """
-        parser = ConfigParser(inline_comment_prefixes=("#",))  # allow in-line comments
-        with open(fname) as fid:
-            file_content = fid.read()
-        parser.read_string(file_content)
-        self.parser = parser
-        self.get_dict()
-        self.file_content = file_content.split(linesep)
-
-    def get_dict(self):
-        # Is there an officially supported way to do this ?
-        self.conf_dict = self.parser._sections
-        return self.conf_dict
-
-    def __str__(self):
-        return self.conf_dict.__str__()
-
-    def __repr__(self):
-        return self.conf_dict.__repr__()
-
-    def __getitem__(self, key):
-        return self.conf_dict[key]
-
-
-def parse_nabu_config_file(fname, allow_no_value=False):
-    """
-    Parse a configuration file and returns a dictionary.
-
-    Parameters
-    ----------
-    fname: str
-        File name of the configuration file
-
-    Returns
-    -------
-    conf_dict: dict
-        Dictionary with the configuration
-    """
-    parser = ConfigParser(
-        inline_comment_prefixes=("#",),  # allow in-line comments
-        allow_no_value=allow_no_value,
-    )
-    with open(fname) as fid:
-        file_content = fid.read()
-    parser.read_string(file_content)
-    conf_dict = parser._sections  # Is there an officially supported way to do this ?
-    return conf_dict
-
-
-def generate_nabu_configfile(
-    fname,
-    default_config,
-    config=None,
-    sections=None,
-    sections_comments=None,
-    comments=True,
-    options_level=None,
-    prefilled_values=None,
-):
-    """
-    Generate a nabu configuration file.
-
-    Parameters
-    -----------
-    fname: str
-        Output file path.
-    config: dict
-        Configuration to save. If section and / or key missing will store the
-        default value
-    sections: list of str, optional
-        Sections which should be included in the configuration file
-    comments: bool, optional
-        Whether to include comments in the configuration file
-    options_level: str, optional
-        Which "level" of options to embed in the file. Can be "required", "optional", "advanced".
-        Default is "optional".
-    """
-    if options_level is None:
-        options_level = "optional"
-    if prefilled_values is None:
-        prefilled_values = {}
-    check_supported(options_level, list(_options_levels.keys()), "options_level")
-    options_level = _options_levels[options_level]
-    if config is None:
-        config = {}
-    if sections is None:
-        sections = default_config.keys()
-
-    def dump_help(fid, help_sequence):
-        for help_line in help_sequence.split(linesep):
-            content = "# %s" % (help_line) if help_line.strip() != "" else ""
-            content = content + linesep
-            fid.write(content)
-
-    with open(fname, "w") as fid:
-        for section, section_content in default_config.items():
-            if section not in sections:
-                continue
-            if section != "dataset":
-                fid.write("%s%s" % (linesep, linesep))
-            fid.write("[%s]%s" % (section, linesep))
-            if sections_comments is not None and section in sections_comments:
-                dump_help(fid, sections_comments[section])
-
-            for key, values in section_content.items():
-                if options_level < _options_levels[values["type"]]:
-                    continue
-                if comments and values["help"].strip() != "":
-                    dump_help(fid, values["help"])
-
-                value = values["default"]
-                if section in prefilled_values and key in prefilled_values[section]:
-                    value = prefilled_values[section][key]
-                if section in config and key in config[section]:
-                    value = config[section][key]
-                fid.write("%s = %s%s" % (key, value, linesep))
-
-
-def _extract_nabuconfig_section(section, default_config):
-    res = {}
-    for key, val in default_config[section].items():
-        res[key] = val["default"]
-    return res
-
-
-def _extract_nabuconfig_keyvals(default_config):
-    res = {}
-    for section in default_config.keys():
-        res[section] = _extract_nabuconfig_section(section, default_config)
-    return res
-
-
-def get_default_nabu_config(default_config):
-    """
-    Return a dictionary with the default nabu configuration.
-    """
-    return _extract_nabuconfig_keyvals(default_config)
-
-
-def _handle_modified_key(key, val, section, default_config, renamed_keys):
-    if val is not None:
-        return key, val, section
-    if key in renamed_keys and renamed_keys[key]["section"] == section:
-        info = renamed_keys[key]
-        print(info["message"])
-        print("This is deprecated since version %s and will result in an error in futures versions" % (info["since"]))
-        section = info.get("new_section", section)
-        if info["new_name"] == "":
-            return None, None, section  # deleted key
-        val = default_config[section].get(info["new_name"], None)
-        return info["new_name"], val, section
-    else:
-        return key, None, section  # unhandled renamed/deleted key
-
-
-def validate_config(config, default_config, renamed_keys, errors="warn"):
-    """
-    Validate a configuration dictionary against a "default" configuration dict.
-
-    Parameters
-    ----------
-    config: dict
-        configuration dict to be validated
-    default_config: dict
-        Reference configuration. Missing keys/sections from 'config' will be updated with
-        keys from this dictionary.
-    errors: str, optional
-        What to do when an unknonw key/section is encountered. Possible actions are:
-          - "warn": throw a warning, continue the validation
-          - "raise": raise an error and exit
-    """
-
-    def error(msg):
-        if errors == "raise":
-            raise ValueError(msg)
-        else:
-            print("Error: %s" % msg)
-
-    res_config = {}
-    for section, section_content in config.items():
-        # Ignore the "other" section
-        if section.lower() == "other":
-            continue
-        if section not in default_config:
-            error("Unknown section [%s]" % section)
-            continue
-        res_config[section] = _extract_nabuconfig_section(section, default_config)
-        res_config[section].update(section_content)
-        for key, value in res_config[section].items():
-            opt = default_config[section].get(key, None)
-            key, opt, section_updated = _handle_modified_key(key, opt, section, default_config, renamed_keys)
-            if key is None:
-                continue  # deleted key
-            if opt is None:
-                error("Unknown option '%s' in section [%s]" % (key, section_updated))
-                continue
-            validator = default_config[section_updated][key]["validator"]
-            if section_updated not in res_config:  # missing section - handled later
-                continue
-            res_config[section_updated][key] = validator(section_updated, key, value)
-    # Handle sections missing in config
-    for section in set(default_config.keys()) - set(res_config.keys()):
-        res_config[section] = _extract_nabuconfig_section(section, default_config)
-        for key, value in res_config[section].items():
-            validator = default_config[section][key]["validator"]
-            res_config[section][key] = validator(section, key, value)
-    return res_config
-
-
-validate_nabu_config = deprecated("validate_nabu_config is renamed validate_config", do_print=True)(validate_config)
-
-
-def overwrite_config(conf, overwritten_params):
-    """
-    Overwrite a (validated) configuration with a new parameters dict.
-
-    Parameters
-    ----------
-    conf: dict
-        Configuration dictionary, usually output from validate_config()
-    overwritten_params: dict
-        Configuration dictionary with the same layout, containing parameters to overwrite
-    """
-    overwritten_params = overwritten_params or {}
-    for section, params in overwritten_params.items():
-        if section not in conf:
-            raise ValueError("Unknown section %s" % section)
-        current_section = conf[section]
-        for key in params.keys():
-            if key not in current_section:
-                raise ValueError("Unknown parameter '%s' in section '%s'" % (key, section))
-            conf[section][key] = overwritten_params[section][key]
-    # ---
-    return conf