hydraflow 0.3.0__tar.gz → 0.3.2__tar.gz

{hydraflow-0.3.0 → hydraflow-0.3.2}/.devcontainer/devcontainer.json

@@ -1,5 +1,4 @@
 {
-  "name": "hydraflow",
   "image": "mcr.microsoft.com/vscode/devcontainers/python:3.12",
   "features": {
     "ghcr.io/devcontainers-contrib/features/starship:1": {},

{hydraflow-0.3.0 → hydraflow-0.3.2}/.gitignore

@@ -1,7 +1,11 @@
+*.db
 .coverage
 .env
 .venv/
 __pycache__/
 dist/
 lcov.info
+mlruns/
+multirun/
+outputs/
 uv.lock

{hydraflow-0.3.0 → hydraflow-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hydraflow
-Version: 0.3.0
+Version: 0.3.2
 Summary: Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments.
 Project-URL: Documentation, https://github.com/daizutabi/hydraflow
 Project-URL: Source, https://github.com/daizutabi/hydraflow

hydraflow-0.3.2/apps/quickstart.py

@@ -0,0 +1,31 @@
+import logging
+from dataclasses import dataclass
+
+import hydra
+from hydra.core.config_store import ConfigStore
+
+import hydraflow
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Config:
+    width: int = 1024
+    height: int = 768
+
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=Config)
+
+
+@hydra.main(version_base=None, config_name="config")
+def app(cfg: Config) -> None:
+    hydraflow.set_experiment()
+
+    with hydraflow.start_run(cfg):
+        log.info(f"{cfg.width=}, {cfg.height=}")
+
+
+if __name__ == "__main__":
+    app()

{hydraflow-0.3.0 → hydraflow-0.3.2}/mkdocs.yml

@@ -38,6 +38,7 @@ theme:
     - navigation.tracking
 plugins:
   - search
+  - markdown-exec
   - mkapi
 markdown_extensions:
   - pymdownx.magiclink
@@ -50,4 +51,6 @@ markdown_extensions:
       alternate_style: true
 nav:
   - Home: index.md
+  - Usage:
+      - usage/quickstart.md
   - Reference: $api/hydraflow.**

{hydraflow-0.3.0 → hydraflow-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.3.0"
+version = "0.3.2"
 description = "Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments."
 readme = "README.md"
 license = "MIT"
@@ -34,6 +34,10 @@ Issues = "https://github.com/daizutabi/hydraflow/issues"
 
 [tool.uv]
 dev-dependencies = [
+  "markdown-exec[ansi]",
+  "mkapi",
+  "mkdocs-material",
+  "mkdocs>=1.6",
   "pytest-asyncio",
   "pytest-clarity",
   "pytest-cov",
@@ -97,3 +101,4 @@ exclude = ["tests/scripts/*.py"]
   "SIM117",
   "SLF",
 ]
+"apps/*.py" = ["INP", "D", "G", "T"]

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/__init__.py

@@ -1,19 +1,15 @@
-"""Provide a collection of MLflow runs."""
+"""Integrate Hydra and MLflow to manage and track machine learning experiments."""
 
-from .context import chdir_artifact, log_run, start_run, watch
-from .mlflow import (
-    list_runs,
-    search_runs,
-    set_experiment,
-)
+from .context import chdir_artifact, chdir_hydra, log_run, start_run, watch
+from .mlflow import list_runs, search_runs, set_experiment
 from .progress import multi_tasks_progress, parallel_progress
 from .run_collection import RunCollection
-from .run_data import load_config
-from .run_info import get_artifact_dir, get_hydra_output_dir
+from .utils import get_artifact_dir, get_hydra_output_dir, load_config
 
 __all__ = [
     "RunCollection",
     "chdir_artifact",
+    "chdir_hydra",
     "get_artifact_dir",
     "get_hydra_output_dir",
     "list_runs",

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/config.py

@@ -54,7 +54,7 @@ def _iter_params(config: object, prefix: str = "") -> Iterator[tuple[str, Any]]:
     if isinstance(config, DictConfig):
         for key, value in config.items():
             if _is_param(value):
-                yield f"{prefix}{key}", value
+                yield f"{prefix}{key}", _convert(value)
 
             else:
                 yield from _iter_params(value, f"{prefix}{key}.")
@@ -62,7 +62,7 @@ def _iter_params(config: object, prefix: str = "") -> Iterator[tuple[str, Any]]:
     elif isinstance(config, ListConfig):
         for index, value in enumerate(config):
             if _is_param(value):
-                yield f"{prefix}{index}", value
+                yield f"{prefix}{index}", _convert(value)
 
             else:
                 yield from _iter_params(value, f"{prefix}{index}.")
@@ -78,3 +78,11 @@ def _is_param(value: object) -> bool:
             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

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/context.py

@@ -238,6 +238,25 @@ class Handler(PatternMatchingEventHandler):
             self.func(file)
 
 
+@contextmanager
+def chdir_hydra() -> Iterator[Path]:
+    """Change the current working directory to the hydra output directory.
+
+    This context manager changes the current working directory to the hydra output
+    directory. It ensures that the directory is changed back to the original
+    directory after the context is exited.
+    """
+    curdir = Path.cwd()
+    path = HydraConfig.get().runtime.output_dir
+
+    os.chdir(path)
+    try:
+        yield Path(path)
+
+    finally:
+        os.chdir(curdir)
+
+
 @contextmanager
 def chdir_artifact(
     run: Run,

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/mlflow.py

@@ -207,8 +207,14 @@ def _list_runs(
         if experiment := mlflow.get_experiment_by_name(name):
             loc = experiment.artifact_location
 
-            if isinstance(loc, str) and loc.startswith("file://"):
-                path = Path(mlflow.artifacts.download_artifacts(loc))
+            if isinstance(loc, str):
+                if loc.startswith("file://"):
+                    path = Path(mlflow.artifacts.download_artifacts(loc))
+                elif Path(loc).is_dir():
+                    path = Path(loc)
+                else:
+                    continue
+
                 run_ids.extend(file.stem for file in path.iterdir() if file.is_dir())
 
     it = (joblib.delayed(mlflow.get_run)(run_id) for run_id in run_ids)

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/param.py

@@ -72,4 +72,4 @@ def _match_tuple(param: str, value: tuple) -> bool | None:
     if type(value[0]) is not type(value[1]):
         return None
 
-    return value[0] <= type(value[0])(param) < value[1]  # type: ignore
+    return value[0] <= type(value[0])(param) <= value[1]  # type: ignore

{hydraflow-0.3.0 → hydraflow-0.3.2}/src/hydraflow/run_collection.py

@@ -239,8 +239,8 @@ class RunCollection:
         The filtering supports:
         - Exact matches for single values.
         - Membership checks for lists of values.
-        - Range checks for tuples of two values (inclusive of the lower bound
-          and exclusive of the upper bound).
+        - Range checks for tuples of two values (inclusive of both the lower
+          and upper bound).
 
         Args:
             config (object | None): The configuration object to filter the runs.
@@ -476,7 +476,7 @@ class RunCollection:
         """
         return (func(run, *args, **kwargs) for run in self)
 
-    def map_run_id(
+    def map_id(
         self,
         func: Callable[Concatenate[str, P], T],
         *args: P.args,
@@ -569,8 +569,8 @@ class RunCollection:
 
     def group_by(
         self,
-        *names: str | list[str],
-    ) -> dict[tuple[str | None, ...], RunCollection]:
+        names: str | list[str],
+    ) -> dict[str | None | tuple[str | None, ...], RunCollection]:
         """Group runs by specified parameter names.
 
         Group the runs in the collection based on the values of the
@@ -578,19 +578,23 @@ class RunCollection:
         form a key in the returned dictionary.
 
         Args:
-            *names (str | list[str]): The names of the parameters to group by.
+            names (str | list[str]): The names of the parameters to group by.
                 This can be a single parameter name or multiple names provided
                 as separate arguments or as a list.
 
         Returns:
-            dict[tuple[str | None, ...], RunCollection]: A dictionary where the keys
-            are tuples of parameter values and the values are RunCollection objects
-            containing the runs that match those parameter values.
+            dict[str | None | tuple[str | None, ...], RunCollection]: A
+            dictionary where the keys are tuples of parameter values and the
+            values are `RunCollection` objects containing the runs that match
+            those parameter values.
 
         """
-        grouped_runs: dict[tuple[str | None, ...], list[Run]] = {}
+        grouped_runs: dict[str | None | tuple[str | None, ...], list[Run]] = {}
+        is_list = isinstance(names, list)
         for run in self._runs:
-            key = get_params(run, *names)
+            key = get_params(run, names)
+            if not is_list:
+                key = key[0]
             grouped_runs.setdefault(key, []).append(run)
 
         return {key: RunCollection(runs) for key, runs in grouped_runs.items()}
@@ -637,8 +641,8 @@ def filter_runs(
     The filtering supports:
     - Exact matches for single values.
     - Membership checks for lists of values.
-    - Range checks for tuples of two values (inclusive of the lower bound and
-      exclusive of the upper bound).
+    - Range checks for tuples of two values (inclusive of both the lower and
+      upper bound).
 
     Args:
         runs (list[Run]): The list of runs to filter.

hydraflow-0.3.2/src/hydraflow/run_data.py

@@ -0,0 +1,34 @@
+"""Provide data about `RunCollection` instances."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hydraflow.utils import load_config
+
+if TYPE_CHECKING:
+    from omegaconf import DictConfig
+
+    from hydraflow.run_collection import RunCollection
+
+
+class RunCollectionData:
+    """Provide data about a `RunCollection` instance."""
+
+    def __init__(self, runs: RunCollection) -> None:
+        self._runs = runs
+
+    @property
+    def params(self) -> list[dict[str, str]]:
+        """Get the parameters for each run in the collection."""
+        return [run.data.params for run in self._runs]
+
+    @property
+    def metrics(self) -> list[dict[str, float]]:
+        """Get the metrics for each run in the collection."""
+        return [run.data.metrics for run in self._runs]
+
+    @property
+    def config(self) -> list[DictConfig]:
+        """Get the configuration for each run in the collection."""
+        return [load_config(run) for run in self._runs]

hydraflow-0.3.2/src/hydraflow/run_info.py

@@ -0,0 +1,34 @@
+"""Provide information about `RunCollection` instances."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hydraflow.utils import get_artifact_dir
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from hydraflow.run_collection import RunCollection
+
+
+class RunCollectionInfo:
+    """Provide information about a `RunCollection` instance."""
+
+    def __init__(self, runs: RunCollection) -> None:
+        self._runs = runs
+
+    @property
+    def run_id(self) -> list[str]:
+        """Get the run ID for each run in the collection."""
+        return [run.info.run_id for run in self._runs]
+
+    @property
+    def artifact_uri(self) -> list[str | None]:
+        """Get the artifact URI for each run in the collection."""
+        return [run.info.artifact_uri for run in self._runs]
+
+    @property
+    def artifact_dir(self) -> list[Path]:
+        """Get the artifact directory for each run in the collection."""
+        return [get_artifact_dir(run) for run in self._runs]

hydraflow-0.3.0/src/hydraflow/run_info.py → hydraflow-0.3.2/src/hydraflow/utils.py

@@ -1,4 +1,4 @@
-"""Provide information about MLflow runs."""
+"""Provide utility functions for HydraFlow."""
 
 from __future__ import annotations
 
@@ -7,36 +7,13 @@ from typing import TYPE_CHECKING
 
 import mlflow
 from hydra.core.hydra_config import HydraConfig
+from mlflow.entities import Run
 from mlflow.tracking import artifact_utils
-from omegaconf import OmegaConf
+from omegaconf import DictConfig, OmegaConf
 
 if TYPE_CHECKING:
     from mlflow.entities import Run
 
-    from hydraflow.run_collection import RunCollection
-
-
-class RunCollectionInfo:
-    """Provide information about MLflow runs."""
-
-    def __init__(self, runs: RunCollection) -> None:
-        self._runs = runs
-
-    @property
-    def run_id(self) -> list[str]:
-        """Get the run ID for each run in the collection."""
-        return [run.info.run_id for run in self._runs]
-
-    @property
-    def artifact_uri(self) -> list[str | None]:
-        """Get the artifact URI for each run in the collection."""
-        return [run.info.artifact_uri for run in self._runs]
-
-    @property
-    def artifact_dir(self) -> list[Path]:
-        """Get the artifact directory for each run in the collection."""
-        return [get_artifact_dir(run) for run in self._runs]
-
 
 def get_artifact_dir(run: Run | None = None) -> Path:
     """Retrieve the artifact directory for the given run.
@@ -89,3 +66,23 @@ def get_hydra_output_dir(run: Run | None = None) -> Path:
         return Path(hc.hydra.runtime.output_dir)
 
     raise FileNotFoundError
+
+
+def load_config(run: Run) -> DictConfig:
+    """Load the configuration for a given run.
+
+    This function loads the configuration for the provided Run instance
+    by downloading the configuration file from the MLflow artifacts and
+    loading it using OmegaConf. It returns an empty config if
+    `.hydra/config.yaml` is not found in the run's artifact directory.
+
+    Args:
+        run (Run): The Run instance for which to load the configuration.
+
+    Returns:
+        The loaded configuration as a DictConfig object. Returns an empty
+        DictConfig if the configuration file is not found.
+
+    """
+    path = get_artifact_dir(run) / ".hydra/config.yaml"
+    return OmegaConf.load(path)  # type: ignore

{hydraflow-0.3.0 → hydraflow-0.3.2}/tests/scripts/app.py

@@ -27,6 +27,9 @@ cs.store(name="config", node=MySQLConfig)
 
 @hydra.main(version_base=None, config_name="config")
 def app(cfg: MySQLConfig):
+    with hydraflow.chdir_hydra() as path:
+        Path("chdir_hydra.txt").write_text(path.as_posix())
+
     hydraflow.set_experiment(prefix="_", suffix="_")
     with hydraflow.start_run(cfg):
         log.info(f"START, {cfg.host}, {cfg.port} ")
@@ -34,6 +37,8 @@ def app(cfg: MySQLConfig):
         artifact_dir = hydraflow.get_artifact_dir()
         output_dir = hydraflow.get_hydra_output_dir()
 
+        assert (output_dir / "chdir_hydra.txt").exists()
+
         mlflow.log_text("A " + artifact_dir.as_posix(), "artifact_dir.txt")
         mlflow.log_text("B " + output_dir.as_posix(), "output_dir.txt")
 

{hydraflow-0.3.0 → hydraflow-0.3.2}/tests/test_app.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 import mlflow
 import pytest
 from mlflow.entities import RunStatus
-from omegaconf import OmegaConf
+from omegaconf import ListConfig, OmegaConf
 
 if TYPE_CHECKING:
     from omegaconf import DictConfig
@@ -114,6 +114,13 @@ def test_app_data_config(rc: RunCollection):
     assert config[3].host == "y"
 
 
+def test_app_data_config_list(rc: RunCollection):
+    config = rc.data.config
+    assert isinstance(config[0]["values"], ListConfig)
+    assert not isinstance(config[0]["values"], list)
+    assert config[0]["values"] == [1, 2, 3]
+
+
 def test_app_info_artifact_uri(rc: RunCollection):
     uris = rc.info.artifact_uri
     assert all(uri.startswith("file://") for uri in uris)  # type: ignore
@@ -122,14 +129,14 @@ def test_app_info_artifact_uri(rc: RunCollection):
 
 
 def test_app_info_artifact_dir(rc: RunCollection):
-    from hydraflow.run_info import get_artifact_dir
+    from hydraflow.utils import get_artifact_dir
 
     dirs = list(rc.map(get_artifact_dir))
     assert rc.info.artifact_dir == dirs
 
 
 def test_app_hydra_output_dir(rc: RunCollection):
-    from hydraflow.run_info import get_hydra_output_dir
+    from hydraflow.utils import get_hydra_output_dir
 
     dirs = list(rc.map(get_hydra_output_dir))
     assert dirs[0].stem == "0"
@@ -154,13 +161,20 @@ def test_app_group_by(rc: RunCollection):
     grouped = rc.group_by("host")
     assert len(grouped) == 2
     x = {"port": "1", "host": "x", "values": "[1, 2, 3]"}
-    assert grouped[("x",)].data.params[0] == x
+    assert grouped["x"].data.params[0] == x
     x = {"port": "2", "host": "x", "values": "[1, 2, 3]"}
-    assert grouped[("x",)].data.params[1] == x
+    assert grouped["x"].data.params[1] == x
     x = {"port": "1", "host": "y", "values": "[1, 2, 3]"}
-    assert grouped[("y",)].data.params[0] == x
+    assert grouped["y"].data.params[0] == x
     x = {"port": "2", "host": "y", "values": "[1, 2, 3]"}
-    assert grouped[("y",)].data.params[1] == x
+    assert grouped["y"].data.params[1] == x
+
+
+def test_app_group_by_list(rc: RunCollection):
+    grouped = rc.group_by(["host"])
+    assert len(grouped) == 2
+    assert ("x",) in grouped
+    assert ("y",) in grouped
 
 
 def test_app_filter_list(rc: RunCollection):
@@ -178,3 +192,10 @@ def test_config(rc: RunCollection):
     assert df.shape == (4, 3)
     assert df.select("host").to_series().to_list() == ["x", "x", "y", "y"]
     assert df.select("port").to_series().to_list() == [1, 2, 1, 2]
+    assert str(df.select("values").dtypes) == "[List(Int64)]"
+    assert df.select("values").to_series().to_list() == [
+        [1, 2, 3],
+        [1, 2, 3],
+        [1, 2, 3],
+        [1, 2, 3],
+    ]

{hydraflow-0.3.0 → hydraflow-0.3.2}/tests/test_run_collection.py

@@ -28,12 +28,12 @@ def rc(monkeypatch, tmp_path):
     return x
 
 
-def test_run_collection_bool_false():
+def test_bool_false():
     assert not RunCollection([])
     assert bool(RunCollection.from_list([])) is False
 
 
-def test_run_collection_bool_true(rc: RunCollection):
+def test_bool_true(rc: RunCollection):
     assert rc
     assert bool(rc) is True
 
@@ -90,7 +90,7 @@ def test_filter_tuple(run_list: list[Run]):
     from hydraflow.run_collection import filter_runs
 
     x = filter_runs(run_list, p=(1, 3))
-    assert len(x) == 2
+    assert len(x) == 3
 
 
 def test_filter_invalid_param(run_list: list[Run]):
@@ -139,45 +139,45 @@ def test_chdir_artifact_list(i: int, run_list: list[Run]):
     assert not Path("abc.txt").exists()
 
 
-def test_runs_repr(rc: RunCollection):
+def test_repr(rc: RunCollection):
     assert repr(rc) == "RunCollection(6)"
 
 
-def test_runs_first(rc: RunCollection):
+def test_first(rc: RunCollection):
     run = rc.first()
     assert isinstance(run, Run)
     assert run.data.params["p"] == "0"
 
 
-def test_runs_first_empty(rc: RunCollection):
+def test_first_empty(rc: RunCollection):
     rc._runs = []
     with pytest.raises(ValueError):
         rc.first()
 
 
-def test_runs_try_first_none(rc: RunCollection):
+def test_try_first_none(rc: RunCollection):
     rc._runs = []
     assert rc.try_first() is None
 
 
-def test_runs_last(rc: RunCollection):
+def test_last(rc: RunCollection):
     run = rc.last()
     assert isinstance(run, Run)
     assert run.data.params["p"] == "5"
 
 
-def test_runs_last_empty(rc: RunCollection):
+def test_last_empty(rc: RunCollection):
     rc._runs = []
     with pytest.raises(ValueError):
         rc.last()
 
 
-def test_runs_try_last_none(rc: RunCollection):
+def test_try_last_none(rc: RunCollection):
     rc._runs = []
     assert rc.try_last() is None
 
 
-def test_runs_filter(rc: RunCollection):
+def test_filter(rc: RunCollection):
     assert len(rc.filter()) == 6
     assert len(rc.filter({})) == 6
     assert len(rc.filter({"p": 1})) == 1
@@ -192,14 +192,14 @@ def test_runs_filter(rc: RunCollection):
     assert len(rc.filter(r=0)) == 2
 
 
-def test_runs_get(rc: RunCollection):
+def test_get(rc: RunCollection):
     run = rc.get({"p": 4})
     assert isinstance(run, Run)
     run = rc.get(p=2)
     assert isinstance(run, Run)
 
 
-def test_runs_try_get(rc: RunCollection):
+def test_try_get(rc: RunCollection):
     run = rc.try_get({"p": 5})
     assert isinstance(run, Run)
     run = rc.try_get(p=1)
@@ -208,7 +208,7 @@ def test_runs_try_get(rc: RunCollection):
     assert run is None
 
 
-def test_runs_get_params_names(rc: RunCollection):
+def test_get_param_names(rc: RunCollection):
     names = rc.get_param_names()
     assert len(names) == 3
     assert "p" in names
@@ -216,14 +216,14 @@ def test_runs_get_params_names(rc: RunCollection):
     assert "r" in names
 
 
-def test_runs_get_params_dict(rc: RunCollection):
+def test_get_param_dict(rc: RunCollection):
     params = rc.get_param_dict()
     assert params["p"] == ["0", "1", "2", "3", "4", "5"]
     assert params["q"] == ["0", "None"]
     assert params["r"] == ["0", "1", "2"]
 
 
-def test_runs_get_params_dict_drop_const(rc: RunCollection):
+def test_get_param_dict_drop_const(rc: RunCollection):
     rc_ = rc.filter(q=0)
     params = rc_.get_param_dict(drop_const=True)
     assert len(params) == 2
@@ -232,7 +232,7 @@ def test_runs_get_params_dict_drop_const(rc: RunCollection):
     assert "r" in params
 
 
-def test_runs_find(rc: RunCollection):
+def test_find(rc: RunCollection):
     run = rc.find({"r": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "0"
@@ -241,17 +241,17 @@ def test_runs_find(rc: RunCollection):
     assert run.data.params["p"] == "2"
 
 
-def test_runs_find_none(rc: RunCollection):
+def test_find_none(rc: RunCollection):
     with pytest.raises(ValueError):
         rc.find({"r": 10})
 
 
-def test_runs_try_find_none(rc: RunCollection):
+def test_try_find_none(rc: RunCollection):
     run = rc.try_find({"r": 10})
     assert run is None
 
 
-def test_runs_find_last(rc: RunCollection):
+def test_find_last(rc: RunCollection):
     run = rc.find_last({"r": 0})
     assert isinstance(run, Run)
     assert run.data.params["p"] == "3"
@@ -260,12 +260,12 @@ def test_runs_find_last(rc: RunCollection):
     assert run.data.params["p"] == "5"
 
 
-def test_runs_find_last_none(rc: RunCollection):
+def test_find_last_none(rc: RunCollection):
     with pytest.raises(ValueError):
         rc.find_last({"p": 10})
 
 
-def test_runs_try_find_last_none(rc: RunCollection):
+def test_try_find_last_none(rc: RunCollection):
     run = rc.try_find_last({"p": 10})
     assert run is None
 
@@ -313,42 +313,42 @@ def test_list_runs_none(rc, runs2):
     assert not no_runs
 
 
-def test_run_collection_map(rc: RunCollection):
+def test_map(rc: RunCollection):
     results = list(rc.map(lambda run: run.info.run_id))
     assert len(results) == len(rc._runs)
     assert all(isinstance(run_id, str) for run_id in results)
 
 
-def test_run_collection_map_args(rc: RunCollection):
+def test_map_args(rc: RunCollection):
     results = list(rc.map(lambda run, x: run.info.run_id + x, "test"))
     assert all(x.endswith("test") for x in results)
 
 
-def test_run_collection_map_run_id(rc: RunCollection):
-    results = list(rc.map_run_id(lambda run_id: run_id))
+def test_map_id(rc: RunCollection):
+    results = list(rc.map_id(lambda run_id: run_id))
     assert len(results) == len(rc._runs)
     assert all(isinstance(run_id, str) for run_id in results)
 
 
-def test_run_collection_map_run_id_kwargs(rc: RunCollection):
-    results = list(rc.map_run_id(lambda run_id, x: x + run_id, x="test"))
+def test_map_id_kwargs(rc: RunCollection):
+    results = list(rc.map_id(lambda run_id, x: x + run_id, x="test"))
     assert all(x.startswith("test") for x in results)
 
 
-def test_run_collection_map_uri(rc: RunCollection):
+def test_map_uri(rc: RunCollection):
     results = list(rc.map_uri(lambda uri: uri))
     assert len(results) == len(rc._runs)
     assert all(isinstance(uri, str | type(None)) for uri in results)
 
 
-def test_run_collection_map_dir(rc: RunCollection):
+def test_map_dir(rc: RunCollection):
     results = list(rc.map_dir(lambda dir_path, x: dir_path / x, "a.csv"))
     assert len(results) == len(rc._runs)
     assert all(isinstance(dir_path, Path) for dir_path in results)
     assert all(dir_path.stem == "a" for dir_path in results)
 
 
-def test_run_collection_sort(rc: RunCollection):
+def test_sort(rc: RunCollection):
     rc.sort(key=lambda x: x.data.params["p"])
     assert [run.data.params["p"] for run in rc] == ["0", "1", "2", "3", "4", "5"]
 
@@ -356,7 +356,7 @@ def test_run_collection_sort(rc: RunCollection):
     assert [run.data.params["p"] for run in rc] == ["5", "4", "3", "2", "1", "0"]
 
 
-def test_run_collection_iter(rc: RunCollection):
+def test_iter(rc: RunCollection):
     assert list(rc) == rc._runs
 
 
@@ -366,39 +366,39 @@ def test_run_collection_getitem(rc: RunCollection, i: int):
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice(rc: RunCollection, i: int):
+def test_getitem_slice(rc: RunCollection, i: int):
     assert rc[i : i + 2]._runs == rc._runs[i : i + 2]
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice_step(rc: RunCollection, i: int):
+def test_getitem_slice_step(rc: RunCollection, i: int):
     assert rc[i::2]._runs == rc._runs[i::2]
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_getitem_slice_step_neg(rc: RunCollection, i: int):
+def test_getitem_slice_step_neg(rc: RunCollection, i: int):
     assert rc[i::-2]._runs == rc._runs[i::-2]
 
 
-def test_run_collection_take(rc: RunCollection):
+def test_take(rc: RunCollection):
     assert rc.take(3)._runs == rc._runs[:3]
     assert len(rc.take(4)) == 4
     assert rc.take(10)._runs == rc._runs
 
 
-def test_run_collection_take_neg(rc: RunCollection):
+def test_take_neg(rc: RunCollection):
     assert rc.take(-3)._runs == rc._runs[-3:]
     assert len(rc.take(-4)) == 4
     assert rc.take(-10)._runs == rc._runs
 
 
 @pytest.mark.parametrize("i", range(6))
-def test_run_collection_contains(rc: RunCollection, i: int):
+def test_contains(rc: RunCollection, i: int):
     assert rc[i] in rc
     assert rc._runs[i] in rc
 
 
-def test_run_collection_group_by(rc: RunCollection):
+def test_group_by(rc: RunCollection):
     grouped = rc.group_by(["p"])
     assert len(grouped) == 6
     assert all(isinstance(group, RunCollection) for group in grouped.values())

hydraflow-0.3.0/src/hydraflow/run_data.py

@@ -1,56 +0,0 @@
-"""Provide information about MLflow runs."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from omegaconf import DictConfig, OmegaConf
-
-from hydraflow.run_info import get_artifact_dir
-
-if TYPE_CHECKING:
-    from mlflow.entities import Run
-
-    from hydraflow.run_collection import RunCollection
-
-
-class RunCollectionData:
-    """Provide information about MLflow runs."""
-
-    def __init__(self, runs: RunCollection) -> None:
-        self._runs = runs
-
-    @property
-    def params(self) -> list[dict[str, str]]:
-        """Get the parameters for each run in the collection."""
-        return [run.data.params for run in self._runs]
-
-    @property
-    def metrics(self) -> list[dict[str, float]]:
-        """Get the metrics for each run in the collection."""
-        return [run.data.metrics for run in self._runs]
-
-    @property
-    def config(self) -> list[DictConfig]:
-        """Get the configuration for each run in the collection."""
-        return [load_config(run) for run in self._runs]
-
-
-def load_config(run: Run) -> DictConfig:
-    """Load the configuration for a given run.
-
-    This function loads the configuration for the provided Run instance
-    by downloading the configuration file from the MLflow artifacts and
-    loading it using OmegaConf. It returns an empty config if
-    `.hydra/config.yaml` is not found in the run's artifact directory.
-
-    Args:
-        run (Run): The Run instance for which to load the configuration.
-
-    Returns:
-        The loaded configuration as a DictConfig object. Returns an empty
-        DictConfig if the configuration file is not found.
-
-    """
-    path = get_artifact_dir(run) / ".hydra/config.yaml"
-    return OmegaConf.load(path)  # type: ignore