hydraflow 0.3.2__tar.gz → 0.3.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hydraflow
-Version: 0.3.2
+Version: 0.3.4
 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 → hydraflow-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.3.2"
+version = "0.3.4"
 description = "Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments."
 readme = "README.md"
 license = "MIT"

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

@@ -1,19 +1,27 @@
 """Integrate Hydra and MLflow to manage and track machine learning experiments."""
 
-from .context import chdir_artifact, chdir_hydra, log_run, start_run, watch
+from .context import chdir_artifact, chdir_hydra_output, 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 .utils import get_artifact_dir, get_hydra_output_dir, load_config
+from .utils import (
+    get_artifact_dir,
+    get_hydra_output_dir,
+    get_overrides,
+    load_config,
+    load_overrides,
+)
 
 __all__ = [
     "RunCollection",
     "chdir_artifact",
-    "chdir_hydra",
+    "chdir_hydra_output",
     "get_artifact_dir",
     "get_hydra_output_dir",
+    "get_overrides",
     "list_runs",
     "load_config",
+    "load_overrides",
     "log_run",
     "multi_tasks_progress",
     "parallel_progress",

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

@@ -44,12 +44,25 @@ def iter_params(config: object, prefix: str = "") -> Iterator[tuple[str, Any]]:
     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)  # type: ignore
 
     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: object, prefix: str = "") -> Iterator[tuple[str, Any]]:
     if isinstance(config, DictConfig):
         for key, value in config.items():

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

@@ -239,7 +239,7 @@ class Handler(PatternMatchingEventHandler):
 
 
 @contextmanager
-def chdir_hydra() -> Iterator[Path]:
+def chdir_hydra_output() -> Iterator[Path]:
     """Change the current working directory to the hydra output directory.
 
     This context manager changes the current working directory to the hydra output

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

@@ -34,7 +34,10 @@ def match(param: str, value: Any) -> bool:
     if isinstance(value, tuple) and (m := _match_tuple(param, value)) is not None:
         return m
 
-    if isinstance(value, int | float | str):
+    if isinstance(value, str):
+        return param == value
+
+    if isinstance(value, int | float):
         return type(value)(param) == value
 
     return param == str(value)

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

@@ -24,12 +24,12 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Concatenate, ParamSpec, TypeVar, overload
 
 from mlflow.entities import RunStatus
-from polars.dataframe import DataFrame
 
 import hydraflow.param
-from hydraflow.config import collect_params, iter_params
+from hydraflow.config import iter_params
 from hydraflow.run_data import RunCollectionData
 from hydraflow.run_info import RunCollectionInfo
+from hydraflow.utils import load_config
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
@@ -516,7 +516,7 @@ class RunCollection:
             in the collection.
 
         """
-        return (func(config, *args, **kwargs) for config in self.data.config)
+        return (func(load_config(run), *args, **kwargs) for run in self)
 
     def map_uri(
         self,
@@ -599,16 +599,6 @@ class RunCollection:
 
         return {key: RunCollection(runs) for key, runs in grouped_runs.items()}
 
-    @property
-    def config(self) -> DataFrame:
-        """Get the runs' configurations as a polars DataFrame.
-
-        Returns:
-            A polars DataFrame containing the runs' configurations.
-
-        """
-        return DataFrame(self.map_config(collect_params))
-
 
 def _param_matches(run: Run, key: str, value: Any) -> bool:
     params = run.data.params

hydraflow-0.3.4/src/hydraflow/run_data.py

@@ -0,0 +1,57 @@
+"""Provide data about `RunCollection` instances."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from polars.dataframe import DataFrame
+
+from hydraflow.config import collect_params
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import Any
+
+    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) -> dict[str, list[str]]:
+        """Get the parameters for each run in the collection."""
+        return _to_dict(run.data.params for run in self._runs)
+
+    @property
+    def metrics(self) -> dict[str, list[float]]:
+        """Get the metrics for each run in the collection."""
+        return _to_dict(run.data.metrics for run in self._runs)
+
+    @property
+    def config(self) -> DataFrame:
+        """Get the runs' configurations as a polars DataFrame.
+
+        Returns:
+            A polars DataFrame containing the runs' configurations.
+
+        """
+        return DataFrame(self._runs.map_config(collect_params))
+
+
+def _to_dict(it: Iterable[dict[str, Any]]) -> dict[str, list[Any]]:
+    """Convert an iterable of dictionaries to a dictionary of lists."""
+    data = list(it)
+    if not data:
+        return {}
+
+    keys = []
+    for d in data:
+        for key in d:
+            if key not in keys:
+                keys.append(key)
+
+    return {key: [x.get(key) for x in data] for key in keys}

{hydraflow-0.3.2 → hydraflow-0.3.4}/src/hydraflow/utils.py

@@ -86,3 +86,28 @@ def load_config(run: Run) -> DictConfig:
     """
     path = get_artifact_dir(run) / ".hydra/config.yaml"
     return OmegaConf.load(path)  # type: ignore
+
+
+def get_overrides() -> list[str]:
+    """Retrieve the overrides for the current run."""
+    return HydraConfig.get().overrides.task
+
+
+def load_overrides(run: Run) -> list[str]:
+    """Load the overrides for a given run.
+
+    This function loads the overrides for the provided Run instance
+    by downloading the overrides file from the MLflow artifacts and
+    loading it using OmegaConf. It returns an empty config if
+    `.hydra/overrides.yaml` is not found in the run's artifact directory.
+
+    Args:
+        run (Run): The Run instance for which to load the overrides.
+
+    Returns:
+        The loaded overrides as a list of strings. Returns an empty list
+        if the overrides file is not found.
+
+    """
+    path = get_artifact_dir(run) / ".hydra/overrides.yaml"
+    return [str(x) for x in OmegaConf.load(path)]

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

@@ -27,11 +27,11 @@ cs.store(name="config", node=MySQLConfig)
 
 @hydra.main(version_base=None, config_name="config")
 def app(cfg: MySQLConfig):
-    with hydraflow.chdir_hydra() as path:
+    with hydraflow.chdir_hydra_output() as path:
         Path("chdir_hydra.txt").write_text(path.as_posix())
 
     hydraflow.set_experiment(prefix="_", suffix="_")
-    with hydraflow.start_run(cfg):
+    with hydraflow.start_run(cfg) as run:
         log.info(f"START, {cfg.host}, {cfg.port} ")
 
         artifact_dir = hydraflow.get_artifact_dir()
@@ -50,6 +50,8 @@ def app(cfg: MySQLConfig):
         if cfg.host == "x":
             mlflow.log_metric("m", cfg.port + 10, 2)
 
+        assert hydraflow.get_overrides() == hydraflow.load_overrides(run)
+
         log.info("END")
 
 

{hydraflow-0.3.2 → hydraflow-0.3.4}/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 ListConfig, OmegaConf
+from omegaconf import OmegaConf
 
 if TYPE_CHECKING:
     from omegaconf import DictConfig
@@ -92,33 +92,30 @@ def test_app_info_run_id(rc: RunCollection):
 
 def test_app_data_params(rc: RunCollection):
     params = rc.data.params
-    assert params[0] == {"port": "1", "host": "x", "values": "[1, 2, 3]"}
-    assert params[1] == {"port": "2", "host": "x", "values": "[1, 2, 3]"}
-    assert params[2] == {"port": "1", "host": "y", "values": "[1, 2, 3]"}
-    assert params[3] == {"port": "2", "host": "y", "values": "[1, 2, 3]"}
+    assert params["port"] == ["1", "2", "1", "2"]
+    assert params["host"] == ["x", "x", "y", "y"]
+    assert params["values"] == ["[1, 2, 3]", "[1, 2, 3]", "[1, 2, 3]", "[1, 2, 3]"]
 
 
 def test_app_data_metrics(rc: RunCollection):
     metrics = rc.data.metrics
-    assert metrics[0] == {"m": 11, "watch": 3}
-    assert metrics[1] == {"m": 12, "watch": 3}
-    assert metrics[2] == {"m": 2, "watch": 3}
-    assert metrics[3] == {"m": 3, "watch": 3}
+    assert metrics["m"] == [11, 12, 2, 3]
+    assert metrics["watch"] == [3, 3, 3, 3]
 
 
 def test_app_data_config(rc: RunCollection):
     config = rc.data.config
-    assert config[0].port == 1
-    assert config[1].port == 2
-    assert config[2].host == "y"
-    assert config[3].host == "y"
+    assert config["port"].to_list() == [1, 2, 1, 2]
+    assert config["host"].to_list() == ["x", "x", "y", "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]
+    values = config["values"].to_list()
+    assert str(config.select("values").dtypes) == "[List(Int64)]"
+    for x in values:
+        assert isinstance(x, list)
+        assert x == [1, 2, 3]
 
 
 def test_app_info_artifact_uri(rc: RunCollection):
@@ -160,14 +157,12 @@ def test_app_map_config(rc: RunCollection):
 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
-    x = {"port": "2", "host": "x", "values": "[1, 2, 3]"}
-    assert grouped["x"].data.params[1] == x
-    x = {"port": "1", "host": "y", "values": "[1, 2, 3]"}
-    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["x"].data.params["port"] == ["1", "2"]
+    assert grouped["x"].data.params["host"] == ["x", "x"]
+    assert grouped["x"].data.params["values"] == ["[1, 2, 3]", "[1, 2, 3]"]
+    assert grouped["y"].data.params["port"] == ["1", "2"]
+    assert grouped["y"].data.params["host"] == ["y", "y"]
+    assert grouped["y"].data.params["values"] == ["[1, 2, 3]", "[1, 2, 3]"]
 
 
 def test_app_group_by_list(rc: RunCollection):
@@ -184,18 +179,3 @@ def test_app_filter_list(rc: RunCollection):
     assert len(filtered) == 4
     filtered = rc.filter(values=[1])
     assert not filtered
-
-
-def test_config(rc: RunCollection):
-    df = rc.config
-    assert df.columns == ["host", "port", "values"]
-    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.2 → hydraflow-0.3.4}/tests/test_config.py

@@ -205,3 +205,24 @@ def test_list_config_str(s):
     assert isinstance(b, ListConfig)
     t = OmegaConf.create(json.loads(s))
     assert b == t
+
+
+@pytest.mark.parametrize("x", [{"a": 1}, {"a": [1, 2, 3]}])
+def test_collect_params_dict(x):
+    from hydraflow.config import collect_params
+
+    assert collect_params(x) == x
+
+
+def test_collect_params_dict_dot():
+    from hydraflow.config import collect_params
+
+    assert collect_params({"a": {"b": 1}}) == {"a.b": 1}
+    assert collect_params({"a.b": 1}) == {"a.b": 1}
+
+
+def test_collect_params_list_dot():
+    from hydraflow.config import collect_params
+
+    assert collect_params(["a=1"]) == {"a": "1"}
+    assert collect_params(["a.b=2", "c"]) == {"a.b": "2"}

{hydraflow-0.3.2 → hydraflow-0.3.4}/tests/test_log_run.py

@@ -50,7 +50,7 @@ def read_log(run_id: str, path: str) -> str:
 
 
 def test_load_config(run: Run):
-    from hydraflow.run_data import load_config
+    from hydraflow.utils import load_config
 
     log = read_log(run.info.run_id, "log_run.log")
     assert "START" in log
@@ -63,6 +63,18 @@ def test_load_config(run: Run):
     assert cfg.port == int(port)
 
 
+def test_load_overrides(run: Run):
+    from hydraflow.utils import load_overrides
+
+    log = read_log(run.info.run_id, "log_run.log")
+    assert "START" in log
+    assert "END" in log
+
+    host, port = log.splitlines()[0].split("START,")[-1].split(",")
+
+    assert load_overrides(run) == [f"host={host.strip()}", f"port={port.strip()}"]
+
+
 def test_info(run: Run):
     log = read_log(run.info.run_id, "artifact_dir.txt")
     a, b = log.split(" ")

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

@@ -67,6 +67,8 @@ def test_filter_one(run_list: list[Run]):
     assert len(x) == 1
     x = filter_runs(run_list, p=1)
     assert len(x) == 1
+    x = filter_runs(run_list, ["p=1"])
+    assert len(x) == 1
 
 
 def test_filter_all(run_list: list[Run]):
@@ -77,6 +79,8 @@ def test_filter_all(run_list: list[Run]):
     assert len(x) == 5
     x = filter_runs(run_list, q=0)
     assert len(x) == 5
+    x = filter_runs(run_list, ["q=0"])
+    assert len(x) == 5
 
 
 def test_filter_list(run_list: list[Run]):
@@ -98,6 +102,8 @@ def test_filter_invalid_param(run_list: list[Run]):
 
     x = filter_runs(run_list, {"invalid": 0})
     assert len(x) == 6
+    x = filter_runs(run_list, ["invalid=0"])
+    assert len(x) == 6
 
 
 def test_filter_status(run_list: list[Run]):
@@ -181,15 +187,20 @@ def test_filter(rc: RunCollection):
     assert len(rc.filter()) == 6
     assert len(rc.filter({})) == 6
     assert len(rc.filter({"p": 1})) == 1
+    assert len(rc.filter(["p=1"])) == 1
     assert len(rc.filter({"q": 0})) == 5
+    assert len(rc.filter(["q=0"])) == 5
     assert len(rc.filter({"q": -1})) == 0
+    assert len(rc.filter(["q=-1"])) == 0
     assert not rc.filter({"q": -1})
     assert len(rc.filter(p=5)) == 1
     assert len(rc.filter(q=0)) == 5
     assert len(rc.filter(q=-1)) == 0
     assert not rc.filter(q=-1)
     assert len(rc.filter({"r": 2})) == 2
+    assert len(rc.filter(["r=2"])) == 2
     assert len(rc.filter(r=0)) == 2
+    assert len(rc.filter(["r=0"])) == 2
 
 
 def test_get(rc: RunCollection):
@@ -197,15 +208,21 @@ def test_get(rc: RunCollection):
     assert isinstance(run, Run)
     run = rc.get(p=2)
     assert isinstance(run, Run)
+    run = rc.get(["p=3"])
+    assert isinstance(run, Run)
 
 
 def test_try_get(rc: RunCollection):
     run = rc.try_get({"p": 5})
     assert isinstance(run, Run)
+    run = rc.try_get(["p=2"])
+    assert isinstance(run, Run)
     run = rc.try_get(p=1)
     assert isinstance(run, Run)
     run = rc.try_get(p=-1)
     assert run is None
+    run = rc.try_get(["p=-2"])
+    assert run is None
 
 
 def test_get_param_names(rc: RunCollection):

{hydraflow-0.3.2 → hydraflow-0.3.4}/tests/test_run_data.py

@@ -26,18 +26,17 @@ def runs(monkeypatch, tmp_path):
 
 
 def test_data_params(runs: RunCollection):
-    assert runs.data.params == [{"p": "0"}, {"p": "1"}, {"p": "2"}]
+    assert runs.data.params["p"] == ["0", "1", "2"]
 
 
 def test_data_metrics(runs: RunCollection):
     m = runs.data.metrics
-    assert m[0] == {"metric1": 1, "metric2": 2}
-    assert m[1] == {"metric1": 2, "metric2": 3}
-    assert m[2] == {"metric1": 3, "metric2": 4}
+    assert m["metric1"] == [1, 2, 3]
+    assert m["metric2"] == [2, 3, 4]
 
 
 def test_data_empty_run_collection():
     rc = RunCollection([])
-    assert rc.data.params == []
-    assert rc.data.metrics == []
-    assert rc.data.config == []
+    assert rc.data.params == {}
+    assert rc.data.metrics == {}
+    assert len(rc.data.config) == 0

hydraflow-0.3.2/src/hydraflow/run_data.py

@@ -1,34 +0,0 @@
-"""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]