`hyfi.utils`

`CONFs`

Source code in hyfi/utils/conf.py

class CONFs:
    @staticmethod
    def select(
        cfg: Any,
        key: str,
        default: Any = None,
        throw_on_resolution_failure: bool = True,
        throw_on_missing: bool = False,
    ):
        """
        Wrapper for OmegaConf. select value from a config object using a key.

        Args:
            cfg: Config node to select from
            key: Key to select
            default: Default value to return if key is not found
            throw_on_resolution_failure: Raise an exception if an interpolation
                resolution error occurs, otherwise return None
            throw_on_missing: Raise an exception if an attempt to select a missing key (with the value '???')
                is made, otherwise return None

        Returns:
            selected value or None if not found.
        """
        key = key.replace("/", ".")
        return OmegaConf.select(
            cfg,
            key=key,
            default=default,
            throw_on_resolution_failure=throw_on_resolution_failure,
            throw_on_missing=throw_on_missing,
        )

    @staticmethod
    def to_dict(cfg: Any) -> Any:
        """
        Convert a config to a dict

        Args:
            cfg: The config to convert.

        Returns:
            The dict representation of the config.
        """
        # Convert a config object to a config object.
        if isinstance(cfg, dict):
            cfg = CONFs.to_config(cfg)
        # Returns a container for the given config.
        if isinstance(cfg, (DictConfig, ListConfig)):
            return OmegaConf.to_container(
                cfg,
                resolve=True,
                throw_on_missing=False,
                structured_config_mode=SCMode.DICT,
            )
        return cfg

    @staticmethod
    def to_config(cfg: Any) -> Union[DictConfig, ListConfig]:
        """
        Convert a config object to OmegaConf

        Args:
            cfg: The config to convert.

        Returns:
            A Config object that corresponds to the given config.
        """
        return OmegaConf.create(cfg)

    @staticmethod
    def print(cfg: Any, resolve: bool = True, **kwargs):
        """
        Prints the configuration object in a human-readable format.

        Args:
            cfg (Any): The configuration object to print.
            resolve (bool, optional): Whether to resolve the configuration object before printing. Defaults to True.
            **kwargs: Additional keyword arguments to pass to the pprint.pprint function.

        Returns:
            None
        """
        import pprint

        if CONFs.is_config(cfg):
            if resolve:
                pprint.pprint(CONFs.to_dict(cfg), **kwargs)
            else:
                pprint.pprint(cfg, **kwargs)
        else:
            print(cfg)

    @staticmethod
    def is_dictlike(cfg: Any):
        """
        Determines whether the input object is a valid dictionary configuration object.

        Args:
            cfg (Any): The object to check.

        Returns:
            bool: True if the object is a valid dictionary configuration object, False otherwise.
        """
        return isinstance(cfg, DictLike)

    @staticmethod
    def is_listlike(cfg: Any):
        """
        Determines whether the input object is a valid list configuration object.

        Args:
            cfg (Any): The object to check.

        Returns:
            bool: True if the object is a valid list configuration object, False otherwise.
        """
        return isinstance(cfg, ListLike)

    @staticmethod
    def is_config(cfg: Any):
        """
        Determines whether the input object is a valid configuration object.

        Args:
            cfg (Any): The object to check.

        Returns:
            bool: True if the object is a valid configuration object, False otherwise.
        """
        return isinstance(cfg, (DictConfig, dict))

    @staticmethod
    def is_list(cfg: Any):
        """
        Determines whether the input object is a valid list configuration object.

        Args:
            cfg (Any): The object to check.

        Returns:
            bool: True if the object is a valid list configuration object, False otherwise.
        """
        return isinstance(cfg, (ListConfig, list))

    @staticmethod
    def load(file_: Union[str, Path, IO[Any]]) -> Union[DictConfig, ListConfig]:
        """
        Load a configuration file and return a configuration object.

        Args:
            file_ (Union[str, Path, IO[Any]]): The path to the configuration file or a file-like object.

        Returns:
            Union[DictConfig, ListConfig]: The configuration object.
        """
        return OmegaConf.load(file_)

    @staticmethod
    def save(config: Any, f: Union[str, Path, IO[Any]], resolve: bool = False) -> None:
        """
        Save a configuration object to a file.

        Args:
            config (Any): The configuration object to save.
            f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
            resolve (bool, optional): Whether to resolve the configuration object before saving. Defaults to False.
        """
        os.makedirs(os.path.dirname(str(f)), exist_ok=True)
        OmegaConf.save(config, f, resolve=resolve)

    @staticmethod
    def save_json(
        json_dict: dict,
        f: Union[str, Path, IO[Any]],
        indent=4,
        ensure_ascii=False,
        default=None,
        encoding="utf-8",
        **kwargs,
    ):
        """
        Save a dictionary to a JSON file.

        Args:
            json_dict (dict): The dictionary to save.
            f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
            indent (int, optional): The number of spaces to use for indentation. Defaults to 4.
            ensure_ascii (bool, optional): Whether to escape non-ASCII characters. Defaults to False.
            default (Any, optional): A function to convert non-serializable objects. Defaults to None.
            encoding (str, optional): The encoding to use. Defaults to "utf-8".
            **kwargs: Additional arguments to pass to json.dump().
        """
        f = str(f)
        os.makedirs(os.path.dirname(f), exist_ok=True)
        with open(f, "w", encoding=encoding) as f:
            json.dump(
                json_dict,
                f,
                indent=indent,
                ensure_ascii=ensure_ascii,
                default=default,
                **kwargs,
            )

    @staticmethod
    def load_json(f: Union[str, Path, IO[Any]], encoding="utf-8", **kwargs) -> dict:
        """
        Load a JSON file into a dictionary.

        Args:
            f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
            encoding (str, optional): The encoding to use. Defaults to "utf-8".
            **kwargs: Additional arguments to pass to json.load().

        Returns:
            dict: The dictionary loaded from the JSON file.
        """
        f = str(f)
        with open(f, "r", encoding=encoding) as f:
            return json.load(f, **kwargs)

    @staticmethod
    def update(_dict: Mapping[str, Any], _overrides: Mapping[str, Any]) -> Mapping:
        """
        Update a dictionary with overrides.

        Args:
            _dict (Mapping[str, Any]): The dictionary to update.
            _overrides (Mapping[str, Any]): The dictionary with overrides.

        Returns:
            Mapping: The updated dictionary.
        """
        for k, v in _overrides.items():
            if isinstance(v, collections.abc.Mapping):
                _dict[k] = CONFs.update((_dict.get(k) or {}), v)  # type: ignore
            else:
                _dict[k] = v  # type: ignore
        return _dict

    @staticmethod
    def replace_keys(_dict: Mapping[str, Any], old_key: str, new_key: str) -> Mapping:
        """
        Replace a key in a dictionary.

        Args:
            _dict (Mapping[str, Any]): The dictionary to update.
            old_key (str): The old key to replace.
            new_key (str): The new key to use.

        Returns:
            Mapping: The updated dictionary.
        """
        _new_dict = {}
        for k, v in _dict.items():
            key = new_key if k == old_key else k
            if isinstance(v, collections.abc.Mapping):
                _new_dict[key] = CONFs.replace_keys(v, old_key, new_key)
            else:
                _new_dict[key] = v
        return _new_dict

    @staticmethod
    def merge(
        *configs: Union[
            DictConfig,
            ListConfig,
            Dict[DictKeyType, Any],
            List[Any],
            Tuple[Any, ...],
            Any,
        ],
    ) -> Union[ListConfig, DictConfig]:
        """
        Merge a list of previously created configs into a single one.

        Args:
            *configs: Input configs.

        Returns:
            Union[ListConfig, DictConfig]: The merged config object.
        """
        return OmegaConf.merge(*configs)

    @staticmethod
    def merge_as_dict(
        *configs: Union[
            DictConfig,
            ListConfig,
            Dict[DictKeyType, Any],
            List[Any],
            Tuple[Any, ...],
            Any,
        ],
    ) -> Union[ListConfig, DictConfig]:
        """
        Merge a list of previously created configs into a single dictionary.

        Args:
            *configs: Input configs.

        Returns:
            Union[ListConfig, DictConfig]: The merged config object as a dictionary.
        """
        return CONFs.to_dict(OmegaConf.merge(*configs))

    @staticmethod
    def to_yaml(cfg: Any, resolve: bool = False, sort_keys: bool = False) -> str:
        """
        Convert the input config object to a YAML string.

        Args:
            cfg (Any): The input config object.
            resolve (bool, optional): Whether to resolve the config object before converting it to YAML. Defaults to False.
            sort_keys (bool, optional): Whether to sort the keys in the resulting YAML string. Defaults to False.

        Returns:
            str: The YAML string representation of the input config object.
        """
        if resolve:
            cfg = CONFs.to_dict(cfg)
        return OmegaConf.to_yaml(cfg, resolve=resolve, sort_keys=sort_keys)

    @staticmethod
    def to_container(
        cfg: Any,
        resolve: bool = False,
        throw_on_missing: bool = False,
        enum_to_str: bool = False,
        structured_config_mode: SCMode = SCMode.DICT,
    ):
        """
        Convert the input config object to a nested container (e.g. dictionary).

        Args:
            cfg (Any): The input config object.
            resolve (bool, optional): Whether to resolve the config object before converting it to a container. Defaults to False.
            throw_on_missing (bool, optional): Whether to throw an exception if a missing key is encountered. Defaults to False.
            enum_to_str (bool, optional): Whether to convert enum values to strings. Defaults to False.
            structured_config_mode (SCMode, optional): The structured config mode to use. Defaults to SCMode.DICT.

        Returns:
            The nested container (e.g. dictionary) representation of the input config object.
        """
        return OmegaConf.to_container(
            cfg,
            resolve=resolve,
            throw_on_missing=throw_on_missing,
            enum_to_str=enum_to_str,
            structured_config_mode=structured_config_mode,
        )

    @staticmethod
    def ensure_list(value):
        """
        Ensure that the given value is a list. If the value is None or an empty string, an empty list is returned.
        If the value is already a list, it is returned as is. If the value is a string, it is returned as a list
        containing only that string. Otherwise, the value is converted to a dictionary using the CONF.to_dict method
        and the resulting dictionary is returned as a list.

        Args:
            value (Any): The value to ensure as a list.

        Returns:
            List: The value as a list.
        """
        if not value:
            return []
        elif isinstance(value, str):
            return [value]
        return CONFs.to_dict(value)

    @staticmethod
    def ensure_kwargs(_kwargs, _fn):
        """
        Ensure that the given keyword arguments are valid for the given function.

        Args:
            _kwargs (dict): The keyword arguments to validate.
            _fn (callable): The function to validate the keyword arguments against.

        Returns:
            dict: The valid keyword arguments for the given function.
        """
        from inspect import getfullargspec as getargspec

        if callable(_fn):
            args = getargspec(_fn).args
            logger.info(f"args of {_fn}: {args}")
            return {k: v for k, v in _kwargs.items() if k in args}
        return _kwargs

    @staticmethod
    def pprint(cfg: Any, resolve: bool = True, **kwargs):
        CONFs.print(cfg, resolve=resolve, **kwargs)

`ensure_kwargs(_kwargs, _fn)` `staticmethod`

Ensure that the given keyword arguments are valid for the given function.

Parameters:

Name	Type	Description	Default
`_kwargs`	`dict`	The keyword arguments to validate.	required
`_fn`	`callable`	The function to validate the keyword arguments against.	required

Returns:

Name	Type	Description
`dict`		The valid keyword arguments for the given function.

Source code in hyfi/utils/conf.py

@staticmethod
def ensure_kwargs(_kwargs, _fn):
    """
    Ensure that the given keyword arguments are valid for the given function.

    Args:
        _kwargs (dict): The keyword arguments to validate.
        _fn (callable): The function to validate the keyword arguments against.

    Returns:
        dict: The valid keyword arguments for the given function.
    """
    from inspect import getfullargspec as getargspec

    if callable(_fn):
        args = getargspec(_fn).args
        logger.info(f"args of {_fn}: {args}")
        return {k: v for k, v in _kwargs.items() if k in args}
    return _kwargs

`ensure_list(value)` `staticmethod`

Ensure that the given value is a list. If the value is None or an empty string, an empty list is returned. If the value is already a list, it is returned as is. If the value is a string, it is returned as a list containing only that string. Otherwise, the value is converted to a dictionary using the CONF.to_dict method and the resulting dictionary is returned as a list.

Parameters:

Name	Type	Description	Default
`value`	`Any`	The value to ensure as a list.	required

Returns:

Name	Type	Description
`List`		The value as a list.

Source code in hyfi/utils/conf.py

@staticmethod
def ensure_list(value):
    """
    Ensure that the given value is a list. If the value is None or an empty string, an empty list is returned.
    If the value is already a list, it is returned as is. If the value is a string, it is returned as a list
    containing only that string. Otherwise, the value is converted to a dictionary using the CONF.to_dict method
    and the resulting dictionary is returned as a list.

    Args:
        value (Any): The value to ensure as a list.

    Returns:
        List: The value as a list.
    """
    if not value:
        return []
    elif isinstance(value, str):
        return [value]
    return CONFs.to_dict(value)

`is_config(cfg)` `staticmethod`

Determines whether the input object is a valid configuration object.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The object to check.	required

Returns:

Name	Type	Description
`bool`		True if the object is a valid configuration object, False otherwise.

Source code in hyfi/utils/conf.py

@staticmethod
def is_config(cfg: Any):
    """
    Determines whether the input object is a valid configuration object.

    Args:
        cfg (Any): The object to check.

    Returns:
        bool: True if the object is a valid configuration object, False otherwise.
    """
    return isinstance(cfg, (DictConfig, dict))

`is_dictlike(cfg)` `staticmethod`

Determines whether the input object is a valid dictionary configuration object.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The object to check.	required

Returns:

Name	Type	Description
`bool`		True if the object is a valid dictionary configuration object, False otherwise.

Source code in hyfi/utils/conf.py

@staticmethod
def is_dictlike(cfg: Any):
    """
    Determines whether the input object is a valid dictionary configuration object.

    Args:
        cfg (Any): The object to check.

    Returns:
        bool: True if the object is a valid dictionary configuration object, False otherwise.
    """
    return isinstance(cfg, DictLike)

`is_list(cfg)` `staticmethod`

Determines whether the input object is a valid list configuration object.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The object to check.	required

Returns:

Name	Type	Description
`bool`		True if the object is a valid list configuration object, False otherwise.

Source code in hyfi/utils/conf.py

@staticmethod
def is_list(cfg: Any):
    """
    Determines whether the input object is a valid list configuration object.

    Args:
        cfg (Any): The object to check.

    Returns:
        bool: True if the object is a valid list configuration object, False otherwise.
    """
    return isinstance(cfg, (ListConfig, list))

`is_listlike(cfg)` `staticmethod`

Determines whether the input object is a valid list configuration object.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The object to check.	required

Returns:

Name	Type	Description
`bool`		True if the object is a valid list configuration object, False otherwise.

Source code in hyfi/utils/conf.py

@staticmethod
def is_listlike(cfg: Any):
    """
    Determines whether the input object is a valid list configuration object.

    Args:
        cfg (Any): The object to check.

    Returns:
        bool: True if the object is a valid list configuration object, False otherwise.
    """
    return isinstance(cfg, ListLike)

`load(file_)` `staticmethod`

Load a configuration file and return a configuration object.

Parameters:

Name	Type	Description	Default
`file_`	`Union[str, Path, IO[Any]]`	The path to the configuration file or a file-like object.	required

Returns:

Type	Description
`Union[DictConfig, ListConfig]`	Union[DictConfig, ListConfig]: The configuration object.

Source code in hyfi/utils/conf.py

@staticmethod
def load(file_: Union[str, Path, IO[Any]]) -> Union[DictConfig, ListConfig]:
    """
    Load a configuration file and return a configuration object.

    Args:
        file_ (Union[str, Path, IO[Any]]): The path to the configuration file or a file-like object.

    Returns:
        Union[DictConfig, ListConfig]: The configuration object.
    """
    return OmegaConf.load(file_)

`load_json(f, encoding='utf-8', **kwargs)` `staticmethod`

Load a JSON file into a dictionary.

Parameters:

Name	Type	Description	Default
`f`	`Union[str, Path, IO[Any]]`	The path to the file or a file-like object.	required
`encoding`	`str`	The encoding to use. Defaults to "utf-8".	`'utf-8'`
`**kwargs`		Additional arguments to pass to json.load().	`{}`

Returns:

Name	Type	Description
`dict`	`dict`	The dictionary loaded from the JSON file.

Source code in hyfi/utils/conf.py

@staticmethod
def load_json(f: Union[str, Path, IO[Any]], encoding="utf-8", **kwargs) -> dict:
    """
    Load a JSON file into a dictionary.

    Args:
        f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
        encoding (str, optional): The encoding to use. Defaults to "utf-8".
        **kwargs: Additional arguments to pass to json.load().

    Returns:
        dict: The dictionary loaded from the JSON file.
    """
    f = str(f)
    with open(f, "r", encoding=encoding) as f:
        return json.load(f, **kwargs)

`merge(*configs)` `staticmethod`

Merge a list of previously created configs into a single one.

Parameters:

Name	Type	Description	Default
`*configs`	`Union[DictConfig, ListConfig, Dict[DictKeyType, Any], List[Any], Tuple[Any, ...], Any]`	Input configs.	`()`

Returns:

Type	Description
`Union[ListConfig, DictConfig]`	Union[ListConfig, DictConfig]: The merged config object.

Source code in hyfi/utils/conf.py

@staticmethod
def merge(
    *configs: Union[
        DictConfig,
        ListConfig,
        Dict[DictKeyType, Any],
        List[Any],
        Tuple[Any, ...],
        Any,
    ],
) -> Union[ListConfig, DictConfig]:
    """
    Merge a list of previously created configs into a single one.

    Args:
        *configs: Input configs.

    Returns:
        Union[ListConfig, DictConfig]: The merged config object.
    """
    return OmegaConf.merge(*configs)

`merge_as_dict(*configs)` `staticmethod`

Merge a list of previously created configs into a single dictionary.

Parameters:

Name	Type	Description	Default
`*configs`	`Union[DictConfig, ListConfig, Dict[DictKeyType, Any], List[Any], Tuple[Any, ...], Any]`	Input configs.	`()`

Returns:

Type	Description
`Union[ListConfig, DictConfig]`	Union[ListConfig, DictConfig]: The merged config object as a dictionary.

Source code in hyfi/utils/conf.py

@staticmethod
def merge_as_dict(
    *configs: Union[
        DictConfig,
        ListConfig,
        Dict[DictKeyType, Any],
        List[Any],
        Tuple[Any, ...],
        Any,
    ],
) -> Union[ListConfig, DictConfig]:
    """
    Merge a list of previously created configs into a single dictionary.

    Args:
        *configs: Input configs.

    Returns:
        Union[ListConfig, DictConfig]: The merged config object as a dictionary.
    """
    return CONFs.to_dict(OmegaConf.merge(*configs))

`print(cfg, resolve=True, **kwargs)` `staticmethod`

Prints the configuration object in a human-readable format.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The configuration object to print.	required
`resolve`	`bool`	Whether to resolve the configuration object before printing. Defaults to True.	`True`
`**kwargs`		Additional keyword arguments to pass to the pprint.pprint function.	`{}`

Returns:

Type	Description
	None

Source code in hyfi/utils/conf.py

@staticmethod
def print(cfg: Any, resolve: bool = True, **kwargs):
    """
    Prints the configuration object in a human-readable format.

    Args:
        cfg (Any): The configuration object to print.
        resolve (bool, optional): Whether to resolve the configuration object before printing. Defaults to True.
        **kwargs: Additional keyword arguments to pass to the pprint.pprint function.

    Returns:
        None
    """
    import pprint

    if CONFs.is_config(cfg):
        if resolve:
            pprint.pprint(CONFs.to_dict(cfg), **kwargs)
        else:
            pprint.pprint(cfg, **kwargs)
    else:
        print(cfg)

`replace_keys(_dict, old_key, new_key)` `staticmethod`

Replace a key in a dictionary.

Parameters:

Name	Type	Description	Default
`_dict`	`Mapping[str, Any]`	The dictionary to update.	required
`old_key`	`str`	The old key to replace.	required
`new_key`	`str`	The new key to use.	required

Returns:

Name	Type	Description
`Mapping`	`Mapping`	The updated dictionary.

Source code in hyfi/utils/conf.py

@staticmethod
def replace_keys(_dict: Mapping[str, Any], old_key: str, new_key: str) -> Mapping:
    """
    Replace a key in a dictionary.

    Args:
        _dict (Mapping[str, Any]): The dictionary to update.
        old_key (str): The old key to replace.
        new_key (str): The new key to use.

    Returns:
        Mapping: The updated dictionary.
    """
    _new_dict = {}
    for k, v in _dict.items():
        key = new_key if k == old_key else k
        if isinstance(v, collections.abc.Mapping):
            _new_dict[key] = CONFs.replace_keys(v, old_key, new_key)
        else:
            _new_dict[key] = v
    return _new_dict

`save(config, f, resolve=False)` `staticmethod`

Save a configuration object to a file.

Parameters:

Name	Type	Description	Default
`config`	`Any`	The configuration object to save.	required
`f`	`Union[str, Path, IO[Any]]`	The path to the file or a file-like object.	required
`resolve`	`bool`	Whether to resolve the configuration object before saving. Defaults to False.	`False`

Source code in hyfi/utils/conf.py

@staticmethod
def save(config: Any, f: Union[str, Path, IO[Any]], resolve: bool = False) -> None:
    """
    Save a configuration object to a file.

    Args:
        config (Any): The configuration object to save.
        f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
        resolve (bool, optional): Whether to resolve the configuration object before saving. Defaults to False.
    """
    os.makedirs(os.path.dirname(str(f)), exist_ok=True)
    OmegaConf.save(config, f, resolve=resolve)

`save_json(json_dict, f, indent=4, ensure_ascii=False, default=None, encoding='utf-8', **kwargs)` `staticmethod`

Save a dictionary to a JSON file.

Parameters:

Name	Type	Description	Default
`json_dict`	`dict`	The dictionary to save.	required
`f`	`Union[str, Path, IO[Any]]`	The path to the file or a file-like object.	required
`indent`	`int`	The number of spaces to use for indentation. Defaults to 4.	`4`
`ensure_ascii`	`bool`	Whether to escape non-ASCII characters. Defaults to False.	`False`
`default`	`Any`	A function to convert non-serializable objects. Defaults to None.	`None`
`encoding`	`str`	The encoding to use. Defaults to "utf-8".	`'utf-8'`
`**kwargs`		Additional arguments to pass to json.dump().	`{}`

Source code in hyfi/utils/conf.py

@staticmethod
def save_json(
    json_dict: dict,
    f: Union[str, Path, IO[Any]],
    indent=4,
    ensure_ascii=False,
    default=None,
    encoding="utf-8",
    **kwargs,
):
    """
    Save a dictionary to a JSON file.

    Args:
        json_dict (dict): The dictionary to save.
        f (Union[str, Path, IO[Any]]): The path to the file or a file-like object.
        indent (int, optional): The number of spaces to use for indentation. Defaults to 4.
        ensure_ascii (bool, optional): Whether to escape non-ASCII characters. Defaults to False.
        default (Any, optional): A function to convert non-serializable objects. Defaults to None.
        encoding (str, optional): The encoding to use. Defaults to "utf-8".
        **kwargs: Additional arguments to pass to json.dump().
    """
    f = str(f)
    os.makedirs(os.path.dirname(f), exist_ok=True)
    with open(f, "w", encoding=encoding) as f:
        json.dump(
            json_dict,
            f,
            indent=indent,
            ensure_ascii=ensure_ascii,
            default=default,
            **kwargs,
        )

`select(cfg, key, default=None, throw_on_resolution_failure=True, throw_on_missing=False)` `staticmethod`

Wrapper for OmegaConf. select value from a config object using a key.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	Config node to select from	required
`key`	`str`	Key to select	required
`default`	`Any`	Default value to return if key is not found	`None`
`throw_on_resolution_failure`	`bool`	Raise an exception if an interpolation resolution error occurs, otherwise return None	`True`
`throw_on_missing`	`bool`	Raise an exception if an attempt to select a missing key (with the value '???') is made, otherwise return None	`False`

Returns:

Type	Description
	selected value or None if not found.

Source code in hyfi/utils/conf.py

@staticmethod
def select(
    cfg: Any,
    key: str,
    default: Any = None,
    throw_on_resolution_failure: bool = True,
    throw_on_missing: bool = False,
):
    """
    Wrapper for OmegaConf. select value from a config object using a key.

    Args:
        cfg: Config node to select from
        key: Key to select
        default: Default value to return if key is not found
        throw_on_resolution_failure: Raise an exception if an interpolation
            resolution error occurs, otherwise return None
        throw_on_missing: Raise an exception if an attempt to select a missing key (with the value '???')
            is made, otherwise return None

    Returns:
        selected value or None if not found.
    """
    key = key.replace("/", ".")
    return OmegaConf.select(
        cfg,
        key=key,
        default=default,
        throw_on_resolution_failure=throw_on_resolution_failure,
        throw_on_missing=throw_on_missing,
    )

`to_config(cfg)` `staticmethod`

Convert a config object to OmegaConf

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The config to convert.	required

Returns:

Type	Description
`Union[DictConfig, ListConfig]`	A Config object that corresponds to the given config.

Source code in hyfi/utils/conf.py

@staticmethod
def to_config(cfg: Any) -> Union[DictConfig, ListConfig]:
    """
    Convert a config object to OmegaConf

    Args:
        cfg: The config to convert.

    Returns:
        A Config object that corresponds to the given config.
    """
    return OmegaConf.create(cfg)

`to_container(cfg, resolve=False, throw_on_missing=False, enum_to_str=False, structured_config_mode=SCMode.DICT)` `staticmethod`

Convert the input config object to a nested container (e.g. dictionary).

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The input config object.	required
`resolve`	`bool`	Whether to resolve the config object before converting it to a container. Defaults to False.	`False`
`throw_on_missing`	`bool`	Whether to throw an exception if a missing key is encountered. Defaults to False.	`False`
`enum_to_str`	`bool`	Whether to convert enum values to strings. Defaults to False.	`False`
`structured_config_mode`	`SCMode`	The structured config mode to use. Defaults to SCMode.DICT.	`DICT`

Returns:

Type	Description
	The nested container (e.g. dictionary) representation of the input config object.

Source code in hyfi/utils/conf.py

@staticmethod
def to_container(
    cfg: Any,
    resolve: bool = False,
    throw_on_missing: bool = False,
    enum_to_str: bool = False,
    structured_config_mode: SCMode = SCMode.DICT,
):
    """
    Convert the input config object to a nested container (e.g. dictionary).

    Args:
        cfg (Any): The input config object.
        resolve (bool, optional): Whether to resolve the config object before converting it to a container. Defaults to False.
        throw_on_missing (bool, optional): Whether to throw an exception if a missing key is encountered. Defaults to False.
        enum_to_str (bool, optional): Whether to convert enum values to strings. Defaults to False.
        structured_config_mode (SCMode, optional): The structured config mode to use. Defaults to SCMode.DICT.

    Returns:
        The nested container (e.g. dictionary) representation of the input config object.
    """
    return OmegaConf.to_container(
        cfg,
        resolve=resolve,
        throw_on_missing=throw_on_missing,
        enum_to_str=enum_to_str,
        structured_config_mode=structured_config_mode,
    )

`to_dict(cfg)` `staticmethod`

Convert a config to a dict

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The config to convert.	required

Returns:

Type	Description
`Any`	The dict representation of the config.

Source code in hyfi/utils/conf.py

@staticmethod
def to_dict(cfg: Any) -> Any:
    """
    Convert a config to a dict

    Args:
        cfg: The config to convert.

    Returns:
        The dict representation of the config.
    """
    # Convert a config object to a config object.
    if isinstance(cfg, dict):
        cfg = CONFs.to_config(cfg)
    # Returns a container for the given config.
    if isinstance(cfg, (DictConfig, ListConfig)):
        return OmegaConf.to_container(
            cfg,
            resolve=True,
            throw_on_missing=False,
            structured_config_mode=SCMode.DICT,
        )
    return cfg

`to_yaml(cfg, resolve=False, sort_keys=False)` `staticmethod`

Convert the input config object to a YAML string.

Parameters:

Name	Type	Description	Default
`cfg`	`Any`	The input config object.	required
`resolve`	`bool`	Whether to resolve the config object before converting it to YAML. Defaults to False.	`False`
`sort_keys`	`bool`	Whether to sort the keys in the resulting YAML string. Defaults to False.	`False`

Returns:

Name	Type	Description
`str`	`str`	The YAML string representation of the input config object.

Source code in hyfi/utils/conf.py

@staticmethod
def to_yaml(cfg: Any, resolve: bool = False, sort_keys: bool = False) -> str:
    """
    Convert the input config object to a YAML string.

    Args:
        cfg (Any): The input config object.
        resolve (bool, optional): Whether to resolve the config object before converting it to YAML. Defaults to False.
        sort_keys (bool, optional): Whether to sort the keys in the resulting YAML string. Defaults to False.

    Returns:
        str: The YAML string representation of the input config object.
    """
    if resolve:
        cfg = CONFs.to_dict(cfg)
    return OmegaConf.to_yaml(cfg, resolve=resolve, sort_keys=sort_keys)

`update(_dict, _overrides)` `staticmethod`

Update a dictionary with overrides.

Parameters:

Name	Type	Description	Default
`_dict`	`Mapping[str, Any]`	The dictionary to update.	required
`_overrides`	`Mapping[str, Any]`	The dictionary with overrides.	required

Returns:

Name	Type	Description
`Mapping`	`Mapping`	The updated dictionary.

Source code in hyfi/utils/conf.py

@staticmethod
def update(_dict: Mapping[str, Any], _overrides: Mapping[str, Any]) -> Mapping:
    """
    Update a dictionary with overrides.

    Args:
        _dict (Mapping[str, Any]): The dictionary to update.
        _overrides (Mapping[str, Any]): The dictionary with overrides.

    Returns:
        Mapping: The updated dictionary.
    """
    for k, v in _overrides.items():
        if isinstance(v, collections.abc.Mapping):
            _dict[k] = CONFs.update((_dict.get(k) or {}), v)  # type: ignore
        else:
            _dict[k] = v  # type: ignore
    return _dict

`DATASETs`

Bases: DSAggregate, DSBasic, DSCombine, DSLoad, DSPlot, DSReshape, DSSave, DSSlice, DSUtils

A class representing a collection of datasets.

This class inherits from various dataset utility classes and provides a convenient way to access and manipulate datasets.

Source code in hyfi/utils/datasets/__init__.py

class DATASETs(
    DSAggregate,
    DSBasic,
    DSCombine,
    DSLoad,
    DSPlot,
    DSReshape,
    DSSave,
    DSSlice,
    DSUtils,
):
    """
    A class representing a collection of datasets.

    This class inherits from various dataset utility classes and provides a convenient way to access and manipulate datasets.

    Attributes:
        None

    Methods:
        None
    """

`ENVs`

Source code in hyfi/utils/envs.py

class ENVs:
    @staticmethod
    def getcwd():
        """Get the original working directory before Hydra changed it.

        This function tries to call the `get_original_cwd` function from the `hydra.utils` module,
        which returns the original working directory if it exists. If the `get_original_cwd` function
        raises a `ValueError` exception, it means that Hydra did not change the working directory,
        so the function falls back to calling the `os.getcwd` function, which returns the current
        working directory.

        Returns:
            str: The original working directory before Hydra changed it.
        """
        try:
            return hydra.utils.get_original_cwd()
        except ValueError:
            return os.getcwd()

    @staticmethod
    def expand_posix_vars(posix_expr: str, context: dict = None) -> str:  # type: ignore
        # sourcery skip: dict-assign-update-to-union
        """
        Expand POSIX variables in a string.

        Args:
            posix_expr (str): The string containing POSIX variables to be expanded.
            context (dict, optional): A dictionary containing additional variables to be used in the expansion.
                Defaults to None.

        Returns:
            str: The expanded string.

        Examples:
            >>> expand_posix_vars("$HOME")
            '/home/user'
            >>> expand_posix_vars("$HOME/$USER", {"USER": "testuser"})
            '/home/user/testuser'

        """
        # Set the context to the default context.
        if context is None:
            context = {}
        env = defaultdict(str, os.environ.copy())
        env.update(context)
        return Template(posix_expr).substitute(env)

    @staticmethod
    def dotenv_values(dotenv_path: str = "", **kwargs):
        """
        Load dotenv file and return a dict of key / value pairs. This is a wrapper around : py : func : ` dotenv. dotenv_values `

        Args:
            dotenv_path: path to. env file

        Returns:
            dict of key / value pairs ( key = value )
        """
        config = dotenv.dotenv_values(dotenv_path=dotenv_path, **kwargs)
        return dict(config)

    @staticmethod
    def load_dotenv(
        override: bool = False,
        dotenv_file: str = ".env",
        raise_error_if_not_found: bool = False,
        usecwd: bool = False,
        verbose: bool = False,
        **kwargs,
    ) -> None:
        """
        Load. env file from given directory or from current directory. This is a convenience function for use in tests that want to run dotenv in a non - interactive environment

        Args:
            override: If True override existing. env file
            dotenv_file: Name of. env file to look for in given directory or current directory
            verbose: Print debug information to console

        Returns:
            None or a Path object for the. env file
        """
        dotenv_path = Path(dotenv_file)
        if not dotenv_path.is_absolute():
            dotenv_path = Path(ENVs.getcwd()) / dotenv_path
        dotenv_filename = dotenv_path.name
        dotenv_dir = str(dotenv_path.parent)
        # Load. env files and directories.
        if dotenv_path.is_file():
            dotenv.load_dotenv(
                dotenv_path=str(dotenv_path),
                verbose=verbose,
                override=override,
                **kwargs,
            )
            os.environ["DOTENV_FILENAME"] = dotenv_filename
            os.environ["DOTENV_FILE"] = str(dotenv_path)
            os.environ["DOTENV_DIR"] = dotenv_dir
            # Load. env from dotenv_path.
            logger.info("Loaded .env from [%s]", dotenv_path)
        else:
            # If verbose is true print out the. env file.
            logger.info("[%s] not found, finding .env in parent dirs", dotenv_path)
            # Find. env file in parent directories.
            if dotenv_path := ENVs.find_dotenv(
                filename=dotenv_filename,
                raise_error_if_not_found=raise_error_if_not_found,
                usecwd=usecwd,
            ):
                dotenv.load_dotenv(
                    dotenv_path=dotenv_path,
                    verbose=verbose,
                    override=override,
                    **kwargs,
                )
                dotenv_path = Path(dotenv_path)
                dotenv_filename = dotenv_path.name
                dotenv_dir = str(dotenv_path.parent)
                os.environ["DOTENV_FILENAME"] = dotenv_filename
                os.environ["DOTENV_FILE"] = str(dotenv_path)
                os.environ["DOTENV_DIR"] = dotenv_dir
                # Load. env from dotenv_path.
                logger.info("Loaded .env from [%s]", dotenv_path)
            else:
                os.environ["DOTENV_FILE"] = ""
                os.environ["DOTENV_DIR"] = ""
                # Print out the. env file if verbose is true.
                logger.info("No .env file found in the parent dirs of [%s]", dotenv_dir)

    @staticmethod
    def is_interactive():
        """Decide whether this is running in a REPL or IPython notebook"""
        main = __import__("__main__", None, None, fromlist=["__file__"])
        return not hasattr(main, "__file__")

    @staticmethod
    def find_dotenv(
        filename: str = ".env",
        raise_error_if_not_found: bool = False,
        usecwd: bool = False,
    ) -> str:
        """
        Search in increasingly higher folders for the given file

        Returns path to the file if found, or an empty string otherwise
        """

        if usecwd or ENVs.is_interactive() or getattr(sys, "frozen", False):
            # Should work without __file__, e.g. in REPL or IPython notebook.
            path = os.getcwd()
        else:
            # will work for .py files
            frame = sys._getframe()
            current_file = __file__

            while frame.f_code.co_filename == current_file:
                assert frame.f_back is not None
                frame = frame.f_back
            frame_filename = frame.f_code.co_filename
            path = os.path.dirname(os.path.abspath(frame_filename))

        logger.debug("Trying to find %s in %s", filename, path)
        for dirname in IOLIBs.walk_to_root(path):
            check_path = os.path.join(dirname, filename)
            if os.path.isfile(check_path):
                return check_path

        if raise_error_if_not_found:
            raise IOError("File not found")

        return ""

    @staticmethod
    def find_dotenv_dir(
        filename: str = ".env",
        raise_error_if_not_found: bool = False,
        usecwd: bool = False,
    ) -> str:
        """
        Search in increasingly higher folders for the given file

        Returns path to the file if found, or an empty string otherwise
        """
        if dotenv_path := ENVs.find_dotenv(
            filename=filename,
            raise_error_if_not_found=raise_error_if_not_found,
            usecwd=usecwd,
        ):
            return os.path.dirname(dotenv_path)
        return ""

    @staticmethod
    def get_osenv(key: str = "", default: Optional[str] = None) -> Any:
        """Get the value of an environment variable or return the default value"""
        ENVs.load_dotenv()
        return os.environ.get(key, default) if key else os.environ

    @staticmethod
    def set_osenv(key: str, value: Any) -> None:
        """Set the value of an environment variable"""
        if value and IOLIBs.is_dir(value):
            value = os.path.abspath(value)
        if pre_val := os.environ.get(key):
            logger.info("Overwriting %s=%s with %s", key, pre_val, value)
        else:
            logger.info("Setting %s=%s", key, value)
        os.setdefault(key, value)

    @staticmethod
    def check_and_set_osenv_var(key: str, value: Any) -> Any:
        """Check and set value to environment variable"""
        env_key = key.upper()
        if value is not None:
            old_value = os.getenv(env_key, "")
            if str(old_value).lower() != str(value).lower():
                os.environ[env_key] = str(value)
                logger.debug("Set environment variable %s=%s", env_key, str(value))
        elif env_key in os.environ and os.environ[env_key]:
            del os.environ[env_key]
            logger.debug("Deleted environment variable %s", env_key)
        return value

    @staticmethod
    def check_and_set_osenv_vars(values: Dict[str, Any]) -> Dict[str, Any]:
        for k, v in values.items():
            ENVs.check_and_set_osenv_var(k, v)
        return values

    @staticmethod
    def osenv():
        """
        Return the os environment variables as a dictionary.

        Returns:
            dict: A dictionary containing the os environment variables.
        """
        return os.environ

`check_and_set_osenv_var(key, value)` `staticmethod`

Check and set value to environment variable

Source code in hyfi/utils/envs.py

@staticmethod
def check_and_set_osenv_var(key: str, value: Any) -> Any:
    """Check and set value to environment variable"""
    env_key = key.upper()
    if value is not None:
        old_value = os.getenv(env_key, "")
        if str(old_value).lower() != str(value).lower():
            os.environ[env_key] = str(value)
            logger.debug("Set environment variable %s=%s", env_key, str(value))
    elif env_key in os.environ and os.environ[env_key]:
        del os.environ[env_key]
        logger.debug("Deleted environment variable %s", env_key)
    return value

`dotenv_values(dotenv_path='', **kwargs)` `staticmethod`

Load dotenv file and return a dict of key / value pairs. This is a wrapper around : py : func : dotenv. dotenv_values

Parameters:

Name	Type	Description	Default
`dotenv_path`	`str`	path to. env file	`''`

Returns:

Type	Description
	dict of key / value pairs ( key = value )

Source code in hyfi/utils/envs.py

@staticmethod
def dotenv_values(dotenv_path: str = "", **kwargs):
    """
    Load dotenv file and return a dict of key / value pairs. This is a wrapper around : py : func : ` dotenv. dotenv_values `

    Args:
        dotenv_path: path to. env file

    Returns:
        dict of key / value pairs ( key = value )
    """
    config = dotenv.dotenv_values(dotenv_path=dotenv_path, **kwargs)
    return dict(config)

`expand_posix_vars(posix_expr, context=None)` `staticmethod`

Expand POSIX variables in a string.

Parameters:

Name	Type	Description	Default
`posix_expr`	`str`	The string containing POSIX variables to be expanded.	required
`context`	`dict`	A dictionary containing additional variables to be used in the expansion. Defaults to None.	`None`

Returns:

Name	Type	Description
`str`	`str`	The expanded string.

Examples:

>>> expand_posix_vars("$HOME")
'/home/user'
>>> expand_posix_vars("$HOME/$USER", {"USER": "testuser"})
'/home/user/testuser'

Source code in hyfi/utils/envs.py

@staticmethod
def expand_posix_vars(posix_expr: str, context: dict = None) -> str:  # type: ignore
    # sourcery skip: dict-assign-update-to-union
    """
    Expand POSIX variables in a string.

    Args:
        posix_expr (str): The string containing POSIX variables to be expanded.
        context (dict, optional): A dictionary containing additional variables to be used in the expansion.
            Defaults to None.

    Returns:
        str: The expanded string.

    Examples:
        >>> expand_posix_vars("$HOME")
        '/home/user'
        >>> expand_posix_vars("$HOME/$USER", {"USER": "testuser"})
        '/home/user/testuser'

    """
    # Set the context to the default context.
    if context is None:
        context = {}
    env = defaultdict(str, os.environ.copy())
    env.update(context)
    return Template(posix_expr).substitute(env)

`find_dotenv(filename='.env', raise_error_if_not_found=False, usecwd=False)` `staticmethod`

Search in increasingly higher folders for the given file

Returns path to the file if found, or an empty string otherwise

Source code in hyfi/utils/envs.py

@staticmethod
def find_dotenv(
    filename: str = ".env",
    raise_error_if_not_found: bool = False,
    usecwd: bool = False,
) -> str:
    """
    Search in increasingly higher folders for the given file

    Returns path to the file if found, or an empty string otherwise
    """

    if usecwd or ENVs.is_interactive() or getattr(sys, "frozen", False):
        # Should work without __file__, e.g. in REPL or IPython notebook.
        path = os.getcwd()
    else:
        # will work for .py files
        frame = sys._getframe()
        current_file = __file__

        while frame.f_code.co_filename == current_file:
            assert frame.f_back is not None
            frame = frame.f_back
        frame_filename = frame.f_code.co_filename
        path = os.path.dirname(os.path.abspath(frame_filename))

    logger.debug("Trying to find %s in %s", filename, path)
    for dirname in IOLIBs.walk_to_root(path):
        check_path = os.path.join(dirname, filename)
        if os.path.isfile(check_path):
            return check_path

    if raise_error_if_not_found:
        raise IOError("File not found")

    return ""

`find_dotenv_dir(filename='.env', raise_error_if_not_found=False, usecwd=False)` `staticmethod`

Search in increasingly higher folders for the given file

Returns path to the file if found, or an empty string otherwise

Source code in hyfi/utils/envs.py

@staticmethod
def find_dotenv_dir(
    filename: str = ".env",
    raise_error_if_not_found: bool = False,
    usecwd: bool = False,
) -> str:
    """
    Search in increasingly higher folders for the given file

    Returns path to the file if found, or an empty string otherwise
    """
    if dotenv_path := ENVs.find_dotenv(
        filename=filename,
        raise_error_if_not_found=raise_error_if_not_found,
        usecwd=usecwd,
    ):
        return os.path.dirname(dotenv_path)
    return ""

`get_osenv(key='', default=None)` `staticmethod`

Get the value of an environment variable or return the default value

Source code in hyfi/utils/envs.py

@staticmethod
def get_osenv(key: str = "", default: Optional[str] = None) -> Any:
    """Get the value of an environment variable or return the default value"""
    ENVs.load_dotenv()
    return os.environ.get(key, default) if key else os.environ

`getcwd()` `staticmethod`

Get the original working directory before Hydra changed it.

This function tries to call the get_original_cwd function from the hydra.utils module, which returns the original working directory if it exists. If the get_original_cwd function raises a ValueError exception, it means that Hydra did not change the working directory, so the function falls back to calling the os.getcwd function, which returns the current working directory.

Returns:

Name	Type	Description
`str`		The original working directory before Hydra changed it.

Source code in hyfi/utils/envs.py

@staticmethod
def getcwd():
    """Get the original working directory before Hydra changed it.

    This function tries to call the `get_original_cwd` function from the `hydra.utils` module,
    which returns the original working directory if it exists. If the `get_original_cwd` function
    raises a `ValueError` exception, it means that Hydra did not change the working directory,
    so the function falls back to calling the `os.getcwd` function, which returns the current
    working directory.

    Returns:
        str: The original working directory before Hydra changed it.
    """
    try:
        return hydra.utils.get_original_cwd()
    except ValueError:
        return os.getcwd()

`is_interactive()` `staticmethod`

Decide whether this is running in a REPL or IPython notebook

Source code in hyfi/utils/envs.py

@staticmethod
def is_interactive():
    """Decide whether this is running in a REPL or IPython notebook"""
    main = __import__("__main__", None, None, fromlist=["__file__"])
    return not hasattr(main, "__file__")

`load_dotenv(override=False, dotenv_file='.env', raise_error_if_not_found=False, usecwd=False, verbose=False, **kwargs)` `staticmethod`

Load. env file from given directory or from current directory. This is a convenience function for use in tests that want to run dotenv in a non - interactive environment

Parameters:

Name	Type	Description	Default
`override`	`bool`	If True override existing. env file	`False`
`dotenv_file`	`str`	Name of. env file to look for in given directory or current directory	`'.env'`
`verbose`	`bool`	Print debug information to console	`False`

Returns:

Type	Description
`None`	None or a Path object for the. env file

Source code in hyfi/utils/envs.py

@staticmethod
def load_dotenv(
    override: bool = False,
    dotenv_file: str = ".env",
    raise_error_if_not_found: bool = False,
    usecwd: bool = False,
    verbose: bool = False,
    **kwargs,
) -> None:
    """
    Load. env file from given directory or from current directory. This is a convenience function for use in tests that want to run dotenv in a non - interactive environment

    Args:
        override: If True override existing. env file
        dotenv_file: Name of. env file to look for in given directory or current directory
        verbose: Print debug information to console

    Returns:
        None or a Path object for the. env file
    """
    dotenv_path = Path(dotenv_file)
    if not dotenv_path.is_absolute():
        dotenv_path = Path(ENVs.getcwd()) / dotenv_path
    dotenv_filename = dotenv_path.name
    dotenv_dir = str(dotenv_path.parent)
    # Load. env files and directories.
    if dotenv_path.is_file():
        dotenv.load_dotenv(
            dotenv_path=str(dotenv_path),
            verbose=verbose,
            override=override,
            **kwargs,
        )
        os.environ["DOTENV_FILENAME"] = dotenv_filename
        os.environ["DOTENV_FILE"] = str(dotenv_path)
        os.environ["DOTENV_DIR"] = dotenv_dir
        # Load. env from dotenv_path.
        logger.info("Loaded .env from [%s]", dotenv_path)
    else:
        # If verbose is true print out the. env file.
        logger.info("[%s] not found, finding .env in parent dirs", dotenv_path)
        # Find. env file in parent directories.
        if dotenv_path := ENVs.find_dotenv(
            filename=dotenv_filename,
            raise_error_if_not_found=raise_error_if_not_found,
            usecwd=usecwd,
        ):
            dotenv.load_dotenv(
                dotenv_path=dotenv_path,
                verbose=verbose,
                override=override,
                **kwargs,
            )
            dotenv_path = Path(dotenv_path)
            dotenv_filename = dotenv_path.name
            dotenv_dir = str(dotenv_path.parent)
            os.environ["DOTENV_FILENAME"] = dotenv_filename
            os.environ["DOTENV_FILE"] = str(dotenv_path)
            os.environ["DOTENV_DIR"] = dotenv_dir
            # Load. env from dotenv_path.
            logger.info("Loaded .env from [%s]", dotenv_path)
        else:
            os.environ["DOTENV_FILE"] = ""
            os.environ["DOTENV_DIR"] = ""
            # Print out the. env file if verbose is true.
            logger.info("No .env file found in the parent dirs of [%s]", dotenv_dir)

`osenv()` `staticmethod`

Return the os environment variables as a dictionary.

Returns:

Name	Type	Description
`dict`		A dictionary containing the os environment variables.

Source code in hyfi/utils/envs.py

@staticmethod
def osenv():
    """
    Return the os environment variables as a dictionary.

    Returns:
        dict: A dictionary containing the os environment variables.
    """
    return os.environ

`set_osenv(key, value)` `staticmethod`

Set the value of an environment variable

Source code in hyfi/utils/envs.py

@staticmethod
def set_osenv(key: str, value: Any) -> None:
    """Set the value of an environment variable"""
    if value and IOLIBs.is_dir(value):
        value = os.path.abspath(value)
    if pre_val := os.environ.get(key):
        logger.info("Overwriting %s=%s with %s", key, pre_val, value)
    else:
        logger.info("Setting %s=%s", key, value)
    os.setdefault(key, value)