hydraflow 0.14.3__py3-none-any.whl → 0.15.0__py3-none-any.whl

hydraflow/core/config.py

@@ -1,122 +0,0 @@
-"""Provide functionality for working with configuration objects using the OmegaConf."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from omegaconf import DictConfig, ListConfig, OmegaConf
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-    from typing import Any
-
-
-def iter_params(config: Any, prefix: str = "") -> Iterator[tuple[str, Any]]:
-    """Recursively iterate over the parameters in the given configuration object.
-
-    This function traverses the configuration object and yields key-value pairs
-    representing the parameters. The keys are prefixed with the provided prefix.
-
-    Args:
-        config (Any): The configuration object to iterate over. This can be a
-            dictionary, list, DictConfig, or ListConfig.
-        prefix (str): The prefix to prepend to the parameter keys.
-            Defaults to an empty string.
-
-    Yields:
-        Key-value pairs representing the parameters in the configuration object.
-
-    """
-    if config is None:
-        return
-
-    if isinstance(config, list) and all(isinstance(x, str) for x in config):
-        config = _from_dotlist(config)
-
-    if not isinstance(config, DictConfig | ListConfig):
-        config = OmegaConf.create(config)
-
-    yield from _iter_params(config, prefix)
-
-
-def _from_dotlist(config: list[str]) -> dict[str, str]:
-    result = {}
-    for item in config:
-        if "=" in item:
-            key, value = item.split("=", 1)
-            result[key.strip()] = value.strip()
-
-    return result
-
-
-def _iter_params(config: Any, prefix: str = "") -> Iterator[tuple[str, Any]]:
-    if isinstance(config, DictConfig):
-        for key, value in config.items():
-            if _is_param(value):
-                yield f"{prefix}{key}", _convert(value)
-
-            else:
-                yield from _iter_params(value, f"{prefix}{key}.")
-
-    elif isinstance(config, ListConfig):
-        for index, value in enumerate(config):
-            if _is_param(value):
-                yield f"{prefix}{index}", _convert(value)
-
-            else:
-                yield from _iter_params(value, f"{prefix}{index}.")
-
-
-def _is_param(value: Any) -> bool:
-    """Check if the given value is a parameter."""
-    if isinstance(value, DictConfig):
-        return False
-
-    if isinstance(value, ListConfig):
-        if any(isinstance(v, DictConfig | ListConfig) for v in value):
-            return False
-
-    return True
-
-
-def _convert(value: Any) -> Any:
-    """Convert the given value to a Python object."""
-    if isinstance(value, ListConfig):
-        return list(value)
-
-    return value
-
-
-def select_config(config: Any, names: list[str]) -> dict[str, Any]:
-    """Select the given parameters from the configuration object.
-
-    This function selects the given parameters from the configuration object
-    and returns a new configuration object containing only the selected parameters.
-
-    Args:
-        config (Any): The configuration object to select parameters from.
-        names (list[str]): The names of the parameters to select.
-
-    Returns:
-        DictConfig: A new configuration object containing only the selected parameters.
-
-    """
-    if not isinstance(config, DictConfig):
-        config = OmegaConf.structured(config)
-
-    return {name: _get(config, name) for name in names}
-
-
-def _get(config: DictConfig, name: str) -> Any:
-    """Get the value of the given parameter from the configuration object."""
-    if "." not in name:
-        return config.get(name)
-
-    prefix, name = name.split(".", 1)
-    return _get(config.get(prefix), name)
-
-
-def select_overrides(config: object, overrides: list[str]) -> dict[str, Any]:
-    """Select the given overrides from the configuration object."""
-    names = [override.split("=")[0].strip() for override in overrides]
-    return select_config(config, names)

hydraflow/core/mlflow.py

@@ -1,174 +0,0 @@
-"""Integration of MLflow experiment tracking with Hydra configuration management.
-
-This module provides functions to log parameters from Hydra configuration objects
-to MLflow, set experiments, and manage tracking URIs. It integrates Hydra's
-configuration management with MLflow's experiment tracking capabilities.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import joblib
-
-from hydraflow.core.io import file_uri_to_path, get_artifact_dir
-from hydraflow.entities.run_collection import RunCollection
-
-from .config import iter_params
-
-if TYPE_CHECKING:
-    from pathlib import Path
-    from typing import Any
-
-
-def log_params(config: Any, *, synchronous: bool | None = None) -> None:
-    """Log the parameters from the given configuration object.
-
-    This method logs the parameters from the provided configuration object
-    using MLflow. It iterates over the parameters and logs them using the
-    `mlflow.log_param` method.
-
-    Args:
-        config (Any): The configuration object to log the parameters from.
-        synchronous (bool | None): Whether to log the parameters synchronously.
-            Defaults to None.
-
-    """
-    import mlflow
-
-    for key, value in iter_params(config):
-        mlflow.log_param(key, value, synchronous=synchronous)
-
-
-def log_text(from_dir: Path, pattern: str = "*.log") -> None:
-    """Log text files in the given directory as artifacts.
-
-    Append the text files to the existing text file in the artifact directory.
-
-    Args:
-        from_dir (Path): The directory to find the logs in.
-        pattern (str): The pattern to match the logs.
-
-    """
-    import mlflow
-
-    artifact_dir = get_artifact_dir()
-
-    for file in from_dir.glob(pattern):
-        if not file.is_file():
-            continue
-
-        file_artifact = artifact_dir / file.name
-        if file_artifact.exists():
-            text = file_artifact.read_text()
-            if not text.endswith("\n"):
-                text += "\n"
-        else:
-            text = ""
-
-        text += file.read_text()
-        mlflow.log_text(text, file.name)
-
-
-def list_run_paths(
-    experiment_names: str | list[str] | None = None,
-    *other: str,
-) -> list[Path]:
-    """List all run paths for the specified experiments.
-
-    This function retrieves all run paths for the given list of experiment names.
-    If no experiment names are provided (None), the function will search all runs
-    for all experiments except the "Default" experiment.
-
-    Args:
-        experiment_names (list[str] | None): List of experiment names to search
-            for runs. If None is provided, the function will search all runs
-            for all experiments except the "Default" experiment.
-        *other (str): The parts of the run directory to join.
-
-    Returns:
-        list[Path]: A list of run paths for the specified experiments.
-
-    """
-    import mlflow
-
-    if isinstance(experiment_names, str):
-        experiment_names = [experiment_names]
-
-    elif experiment_names is None:
-        experiments = mlflow.search_experiments()
-        experiment_names = [e.name for e in experiments if e.name != "Default"]
-
-    run_paths: list[Path] = []
-
-    for name in experiment_names:
-        if experiment := mlflow.get_experiment_by_name(name):
-            uri = experiment.artifact_location
-
-            if isinstance(uri, str):
-                path = file_uri_to_path(uri)
-                run_paths.extend(p for p in path.iterdir() if p.is_dir())
-
-    if other:
-        return [p.joinpath(*other) for p in run_paths]
-
-    return run_paths
-
-
-def list_run_ids(experiment_names: str | list[str] | None = None) -> list[str]:
-    """List all run IDs for the specified experiments.
-
-    This function retrieves all runs for the given list of experiment names.
-    If no experiment names are provided (None), the function will search all
-    runs for all experiments except the "Default" experiment.
-
-    Args:
-        experiment_names (list[str] | None): List of experiment names to search
-            for runs. If None is provided, the function will search all runs
-            for all experiments except the "Default" experiment.
-
-    Returns:
-        list[str]: A list of run IDs for the specified experiments.
-
-    """
-    return [run_path.stem for run_path in list_run_paths(experiment_names)]
-
-
-def list_runs(
-    experiment_names: str | list[str] | None = None,
-    n_jobs: int = 0,
-) -> RunCollection:
-    """List all runs for the specified experiments.
-
-    This function retrieves all runs for the given list of experiment names.
-    If no experiment names are provided (None), the function will search all runs
-    for all experiments except the "Default" experiment.
-    The function returns the results as a `RunCollection` object.
-
-    Note:
-        The returned runs are sorted by their start time in ascending order.
-
-    Args:
-        experiment_names (list[str] | None): List of experiment names to search
-            for runs. If None is provided, the function will search all runs
-            for all experiments except the "Default" experiment.
-        n_jobs (int): The number of jobs to retrieve runs in parallel.
-
-    Returns:
-        RunCollection: A `RunCollection` instance containing the runs for the
-        specified experiments.
-
-    """
-    import mlflow
-
-    run_ids = list_run_ids(experiment_names)
-
-    if n_jobs == 0:
-        runs = [mlflow.get_run(run_id) for run_id in run_ids]
-
-    else:
-        it = (joblib.delayed(mlflow.get_run)(run_id) for run_id in run_ids)
-        runs = joblib.Parallel(n_jobs, backend="threading")(it)
-
-    runs = sorted(runs, key=lambda run: run.info.start_time)  # type: ignore
-    return RunCollection(runs)  # type: ignore

hydraflow/core/param.py

@@ -1,165 +0,0 @@
-"""Provide utility functions for parameter matching.
-
-The main function `match` checks if a given parameter matches a specified value.
-It supports various types of values including None, boolean, list, tuple, int,
-float, and str.
-
-Helper functions `_match_list` and `_match_tuple` are used internally to handle
-matching for list and tuple types respectively.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from omegaconf import ListConfig, OmegaConf
-
-if TYPE_CHECKING:
-    from mlflow.entities import Run
-
-
-def match(param: str, value: Any) -> bool:
-    """Check if the string matches the specified value.
-
-    Args:
-        param (str): The parameter to check.
-        value (Any): The value to check.
-
-    Returns:
-        True if the parameter matches the specified value,
-        False otherwise.
-
-    """
-    if callable(value):
-        return value(param)
-
-    if any(value is x for x in [None, True, False]):
-        return param == str(value)
-
-    if isinstance(value, list) and (m := _match_list(param, value)) is not None:
-        return m
-
-    if isinstance(value, tuple) and (m := _match_tuple(param, value)) is not None:
-        return m
-
-    if isinstance(value, int | float):
-        return float(param) == value
-
-    if isinstance(value, str):
-        return param == value
-
-    return param == str(value)
-
-
-def _match_list(param: str, value: list) -> bool | None:
-    if not value:
-        return None
-
-    if any(param.startswith(x) for x in ["[", "(", "{"]):
-        return None
-
-    if isinstance(value[0], bool):
-        return None
-
-    if not isinstance(value[0], int | float | str):
-        return None
-
-    return type(value[0])(param) in value
-
-
-def _match_tuple(param: str, value: tuple) -> bool | None:
-    if len(value) != 2:
-        return None
-
-    if any(param.startswith(x) for x in ["[", "(", "{"]):
-        return None
-
-    if isinstance(value[0], bool):
-        return None
-
-    if not isinstance(value[0], int | float | str):
-        return None
-
-    if type(value[0]) is not type(value[1]):
-        return None
-
-    return value[0] <= type(value[0])(param) <= value[1]  # type: ignore
-
-
-def to_value(param: str | None, type_: type) -> Any:
-    """Convert the parameter to the specified type.
-
-    Args:
-        param (str | None): The parameter to convert.
-        type_ (type): The type to convert to.
-
-    Returns:
-        The converted value.
-
-    """
-    if param is None or param == "None":
-        return None
-
-    if type_ is int:
-        return int(param)
-
-    if type_ is float:
-        return float(param)
-
-    if type_ is bool:
-        return param == "True"
-
-    if type_ is list or type_ is ListConfig:
-        return list(OmegaConf.create(param))
-
-    return param
-
-
-def get_params(run: Run, *names: str | list[str]) -> tuple[str | None, ...]:
-    """Retrieve the values of specified parameters from the given run.
-
-    This function extracts the values of the parameters identified by the
-    provided names from the specified run. It can accept both individual
-    parameter names and lists of parameter names.
-
-    Args:
-        run (Run): The run object from which to extract parameter values.
-        *names (str | list[str]): The names of the parameters to retrieve.
-            This can be a single parameter name or multiple names provided
-            as separate arguments or as a list.
-
-    Returns:
-        tuple[str | None, ...]: A tuple containing the values of the specified
-        parameters in the order they were provided.
-
-    """
-    names_ = []
-    for name in names:
-        if isinstance(name, list):
-            names_.extend(name)
-        else:
-            names_.append(name)
-
-    params = run.data.params
-    return tuple(params.get(name) for name in names_)
-
-
-def get_values(run: Run, names: list[str], types: list[type]) -> tuple[Any, ...]:
-    """Retrieve the values of specified parameters from the given run.
-
-    This function extracts the values of the parameters identified by the
-    provided names from the specified run.
-
-    Args:
-        run (Run): The run object from which to extract parameter values.
-        names (list[str]): The names of the parameters to retrieve.
-        types (list[type]): The types to convert to.
-
-    Returns:
-        tuple[Any, ...]: A tuple containing the values of the specified
-        parameters in the order they were provided.
-
-    """
-    params = get_params(run, names)
-    it = zip(params, types, strict=True)
-    return tuple(to_value(param, type_) for param, type_ in it)