hydraflow 0.5.1__tar.gz → 0.5.2__tar.gz

{hydraflow-0.5.1 → hydraflow-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.5.1
+Version: 0.5.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.5.1 → hydraflow-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.5.1"
+version = "0.5.2"
 description = "Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -32,10 +32,7 @@ dev-dependencies = [
   "mkapi",
   "mkdocs-material",
   "mkdocs>=1.6",
-  "pytest-clarity",
   "pytest-cov",
-  "pytest-randomly",
-  "pytest-xdist",
 ]
 
 [tool.hatch.build.targets.sdist]
@@ -96,6 +93,7 @@ exclude = ["tests/scripts/*.py"]
   "PT",
   "S",
   "SIM117",
+  "TID",
   "SLF",
 ]
 "apps/*.py" = ["INP", "D", "G", "T"]

{hydraflow-0.5.1 → hydraflow-0.5.2}/src/hydraflow/__init__.py

@@ -6,6 +6,7 @@ from .mlflow import list_runs, search_runs, set_experiment
 from .run_collection import RunCollection
 from .utils import (
     get_artifact_dir,
+    get_artifact_path,
     get_hydra_output_dir,
     get_overrides,
     load_config,
@@ -18,6 +19,7 @@ __all__ = [
     "chdir_artifact",
     "chdir_hydra_output",
     "get_artifact_dir",
+    "get_artifact_path",
     "get_hydra_output_dir",
     "get_overrides",
     "list_runs",

{hydraflow-0.5.1 → hydraflow-0.5.2}/src/hydraflow/mlflow.py

@@ -37,6 +37,7 @@ def set_experiment(
     prefix: str = "",
     suffix: str = "",
     uri: str | Path | None = None,
+    name: str | None = None,
 ) -> Experiment:
     """Set the experiment name and tracking URI optionally.
 
@@ -48,6 +49,7 @@ def set_experiment(
         prefix (str): The prefix to prepend to the experiment name.
         suffix (str): The suffix to append to the experiment name.
         uri (str | Path | None): The tracking URI to use. Defaults to None.
+        name (str | None): The name of the experiment. Defaults to None.
 
     Returns:
         Experiment: An instance of `mlflow.entities.Experiment` representing
@@ -57,6 +59,9 @@ def set_experiment(
     if uri is not None:
         mlflow.set_tracking_uri(uri)
 
+    if name is not None:
+        return mlflow.set_experiment(name)
+
     hc = HydraConfig.get()
     name = f"{prefix}{hc.job.name}{suffix}"
     return mlflow.set_experiment(name)
@@ -214,7 +219,7 @@ def _list_runs(
                 elif Path(loc).is_dir():
                     path = Path(loc)
                 else:
-                    continue
+                    continue  # no cov
 
                 run_ids.extend(file.stem for file in path.iterdir() if file.is_dir())
 

{hydraflow-0.5.1 → hydraflow-0.5.2}/src/hydraflow/run_info.py

@@ -15,6 +15,8 @@ if TYPE_CHECKING:
 class RunCollectionInfo:
     """Provide information about a `RunCollection` instance."""
 
+    _runs: RunCollection
+
     def __init__(self, runs: RunCollection) -> None:
         self._runs = runs
 

{hydraflow-0.5.1 → hydraflow-0.5.2}/src/hydraflow/utils.py

@@ -30,10 +30,32 @@ def get_artifact_dir(run: Run | None = None) -> Path:
     """
     uri = mlflow.get_artifact_uri() if run is None else run.info.artifact_uri
 
-    if not (isinstance(uri, str) and uri.startswith("file://")):
+    if not isinstance(uri, str):
         raise NotImplementedError
 
-    return Path(mlflow.artifacts.download_artifacts(uri))
+    if uri.startswith("file://"):
+        return Path(mlflow.artifacts.download_artifacts(uri))
+
+    if Path(uri).is_dir():
+        return Path(uri)
+
+    raise NotImplementedError
+
+
+def get_artifact_path(run: Run | None, path: str) -> Path:
+    """Retrieve the artifact path for the given run and path.
+
+    This function uses MLflow to get the artifact path for the given run and path.
+
+    Args:
+        run (Run | None): The run object. Defaults to None.
+        path (str): The path to the artifact.
+
+    Returns:
+        The local path to the artifact.
+
+    """
+    return get_artifact_dir(run) / path
 
 
 def get_hydra_output_dir(run: Run | None = None) -> Path:

hydraflow-0.5.2/tests/config/config.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import hydra
+import mlflow
+from hydra.core.config_store import ConfigStore
+
+import hydraflow
+
+
+@dataclass
+class Config:
+    name: str = "a"
+    age: int = 1
+    height: float = 1.7
+
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=Config)
+
+
+@hydra.main(version_base=None, config_name="config")
+def app(cfg: Config):
+    hydraflow.set_experiment()
+
+    with hydraflow.start_run(cfg):
+        overrides = hydraflow.select_overrides(Config(name="x", height=2))
+        mlflow.log_text(str(overrides), "overrides.txt")
+
+
+if __name__ == "__main__":
+    app()

hydraflow-0.5.2/tests/config/test_config.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class C:
+    z: int = 3
+
+
+@dataclass
+class B:
+    y: int = 2
+    c: C = field(default_factory=C)
+
+
+@dataclass
+class A:
+    x: int = 1
+    b: B = field(default_factory=B)
+
+
+def test_select_config():
+    from hydraflow.config import select_config
+
+    a = A()
+    assert select_config(a, ["x"]) == {"x": 1}
+    assert select_config(a, ["b.y"]) == {"b.y": 2}
+    assert select_config(a, ["b.c.z"]) == {"b.c.z": 3}
+    assert select_config(a, ["b.c.z", "x"]) == {"b.c.z": 3, "x": 1}
+    assert select_config(a, ["b.c.z", "b.y"]) == {"b.c.z": 3, "b.y": 2}

hydraflow-0.5.2/tests/config/test_hydra.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+import pytest
+from mlflow.artifacts import download_artifacts
+from mlflow.entities import Run
+
+from hydraflow.run_collection import RunCollection
+
+
+@pytest.fixture(scope="module")
+def rc(collect):
+    args = ["-m", "name=a,b", "height=3"]
+    return collect("config/config.py", args)
+
+
+@pytest.fixture(scope="module")
+def run(rc: RunCollection):
+    return rc.first()
+
+
+def test_select_overrides(run: Run):
+    path = download_artifacts(f"{run.info.artifact_uri}/overrides.txt")
+    assert Path(path).read_text() == "{'name': 'x', 'height': 2.0}"

hydraflow-0.5.1/tests/test_config.py → hydraflow-0.5.2/tests/config/test_params.py

@@ -4,10 +4,10 @@ from dataclasses import dataclass, field
 import pytest
 from omegaconf import ListConfig, OmegaConf
 
+from hydraflow.config import _is_param, collect_params, iter_params
 
-def test_is_param_with_simple_values():
-    from hydraflow.config import _is_param
 
+def test_is_param_with_simple_values():
     assert _is_param(1) is True
     assert _is_param("string") is True
     assert _is_param(3.14) is True
@@ -15,69 +15,49 @@ def test_is_param_with_simple_values():
 
 
 def test_is_param_with_dictconfig_containing_simple_values():
-    from hydraflow.config import _is_param
-
     dict_conf = OmegaConf.create({"a": 1, "b": "string", "c": 3.14, "d": True})
     assert _is_param(dict_conf) is False
 
 
 def test_is_param_with_listconfig_containing_simple_values():
-    from hydraflow.config import _is_param
-
     list_conf = OmegaConf.create([1, "string", 3.14, True])
     assert _is_param(list_conf) is True
 
 
 def test_is_param_with_listconfig_containing_nested_dictconfig():
-    from hydraflow.config import _is_param
-
     nested_list_conf = OmegaConf.create([1, {"a": 1}, 3.14])
     assert _is_param(nested_list_conf) is False
 
 
 def test_is_param_with_listconfig_containing_nested_listconfig():
-    from hydraflow.config import _is_param
-
     nested_list_conf_2 = OmegaConf.create([1, [2, 3], 3.14])
     assert _is_param(nested_list_conf_2) is False
 
 
 def test_is_param_with_empty_dictconfig():
-    from hydraflow.config import _is_param
-
     empty_dict_conf = OmegaConf.create({})
     assert _is_param(empty_dict_conf) is False
 
 
 def test_is_param_with_empty_listconfig():
-    from hydraflow.config import _is_param
-
     empty_list_conf = OmegaConf.create([])
     assert _is_param(empty_list_conf) is True
 
 
 def test_is_param_with_none():
-    from hydraflow.config import _is_param
-
     assert _is_param(None) is True
 
 
 def test_is_param_with_complex_nested_structure():
-    from hydraflow.config import _is_param
-
     complex_conf = OmegaConf.create({"a": [1, {"b": 2}], "c": {"d": 3}})
     assert _is_param(complex_conf) is False
 
 
 def test_iter_params_with_none():
-    from hydraflow.config import iter_params
-
     assert not list(iter_params(None))
 
 
 def test_iter_params():
-    from hydraflow.config import iter_params
-
     conf = OmegaConf.create({"k": "v", "l": [1, {"a": "1", "b": "2", 3: "c"}]})
     it = iter_params(conf)
     assert next(it) == ("k", "v")
@@ -88,8 +68,6 @@ def test_iter_params():
 
 
 def test_collect_params():
-    from hydraflow.config import collect_params
-
     conf = OmegaConf.create({"k": "v", "l": [1, {"a": "1", "b": "2", 3: "c"}]})
     params = collect_params(conf)
     assert params == {"k": "v", "l.0": 1, "l.1.a": "1", "l.1.b": "2", "l.1.3": "c"}
@@ -131,8 +109,6 @@ def test_config(cfg: Config):
 
 
 def test_iter_params_from_config(cfg):
-    from hydraflow.config import iter_params
-
     it = iter_params(cfg)
     assert next(it) == ("size.x", 1)
     assert next(it) == ("size.y", 2)
@@ -142,8 +118,6 @@ def test_iter_params_from_config(cfg):
 
 
 def test_iter_params_with_empty_config():
-    from hydraflow.config import iter_params
-
     empty_cfg = Config(
         size=Size(x=0, y=0),
         db=Db(name="", port=0),
@@ -158,8 +132,6 @@ def test_iter_params_with_empty_config():
 
 
 def test_iter_params_with_nested_config():
-    from hydraflow.config import iter_params
-
     @dataclass
     class Nested:
         level1: Config = field(default_factory=Config)
@@ -174,8 +146,6 @@ def test_iter_params_with_nested_config():
 
 
 def test_iter_params_with_mixed_types_in_list():
-    from hydraflow.config import iter_params
-
     @dataclass
     class MixedStore:
         items: list = field(default_factory=lambda: ["a", 1, {"key": "value"}])
@@ -209,48 +179,14 @@ def test_list_config_str(s):
 
 @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"}
-
-
-@dataclass
-class C:
-    z: int = 3
-
-
-@dataclass
-class B:
-    y: int = 2
-    c: C = field(default_factory=C)
-
-
-@dataclass
-class A:
-    x: int = 1
-    b: B = field(default_factory=B)
-
-
-def test_select_config():
-    from hydraflow.config import select_config
-
-    a = A()
-    assert select_config(a, ["x"]) == {"x": 1}
-    assert select_config(a, ["b.y"]) == {"b.y": 2}
-    assert select_config(a, ["b.c.z"]) == {"b.c.z": 3}
-    assert select_config(a, ["b.c.z", "x"]) == {"b.c.z": 3, "x": 1}
-    assert select_config(a, ["b.c.z", "b.y"]) == {"b.c.z": 3, "b.y": 2}

hydraflow-0.5.2/tests/conftest.py

@@ -0,0 +1,81 @@
+import importlib
+import os
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+import pytest
+from hydra import compose, initialize
+from hydra.core.config_store import ConfigStore
+
+
+@pytest.fixture(scope="module")
+def experiment_name(tmp_path_factory: pytest.TempPathFactory):
+    cwd = Path.cwd()
+    name = str(uuid.uuid4())
+
+    os.chdir(tmp_path_factory.mktemp(name))
+
+    yield name
+
+    os.chdir(cwd)
+
+
+@pytest.fixture(scope="module")
+def run_script(experiment_name: str):
+    parent = Path(__file__).parent
+
+    def run_script(filename: str, args: list[str]):
+        file = parent / filename
+        job_name = f"hydra.job.name={experiment_name}"
+
+        args = [sys.executable, file.as_posix(), *args, job_name]
+        subprocess.run(args, check=False)
+
+        return experiment_name
+
+    return run_script
+
+
+@pytest.fixture(scope="module")
+def collect(run_script):
+    from hydraflow.mlflow import search_runs
+
+    def collect(filename: str, args: list[str]):
+        experiment_name = run_script(filename, args)
+        return search_runs(experiment_names=[experiment_name])
+
+    return collect
+
+
+@pytest.fixture(scope="module")
+def get_config_class():
+    parent = Path(__file__).parent
+
+    def get_config_class(filename: str):
+        file = parent / filename
+
+        sys.path.insert(0, file.parent.as_posix())
+        module = importlib.import_module(file.stem)
+        del sys.path[0]
+
+        return module.Config
+
+    return get_config_class
+
+
+@pytest.fixture
+def get_config(get_config_class):
+    cs = ConfigStore.instance()
+
+    def get_config(filename: str, overrides: list[str] | None = None):
+        cls = get_config_class(filename)
+
+        name = str(uuid.uuid4())
+        cs.store(name=name, node=cls)
+
+        with initialize(version_base=None):
+            return compose(config_name=name, overrides=overrides)
+
+    return get_config

hydraflow-0.5.2/tests/context/context.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+import hydra
+from hydra.core.config_store import ConfigStore
+
+import hydraflow
+
+
+@dataclass
+class Config:
+    name: str = "a"
+
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=Config)
+
+
+@hydra.main(version_base=None, config_name="config")
+def app(cfg: Config):
+    hydraflow.set_experiment()
+
+    with hydraflow.start_run(cfg) as run:
+        with hydraflow.chdir_hydra_output():
+            Path("a.txt").write_text("chdir_hydra_output")
+
+        with hydraflow.chdir_artifact(run):
+            Path("b.txt").write_text("chdir_artifact")
+
+        if cfg.name == "b":
+            raise ValueError
+
+        if cfg.name == "c":
+            sys.exit(1)
+
+    with hydraflow.start_run(cfg, run_id=run.info.run_id):  # Skip log config
+        pass
+
+
+if __name__ == "__main__":
+    app()

hydraflow-0.5.2/tests/context/test_hydra.py

@@ -0,0 +1,31 @@
+import pytest
+from mlflow.entities import Run
+
+from hydraflow.run_collection import RunCollection
+from hydraflow.utils import get_artifact_path, get_hydra_output_dir
+
+
+@pytest.fixture(scope="module")
+def rc(collect):
+    args = ["-m", "name=a,b,c"]
+    return collect("context/context.py", args)
+
+
+@pytest.fixture(scope="module", params=range(3))
+def run(rc: RunCollection, request: pytest.FixtureRequest):
+    return rc[request.param]
+
+
+def test_chdir_hydra_output(run: Run):
+    path = get_hydra_output_dir(run)
+    assert (path / "a.txt").read_text() == "chdir_hydra_output"
+
+
+def test_chdir_artifact(run: Run):
+    path = get_artifact_path(run, "b.txt")
+    assert path.read_text() == "chdir_artifact"
+
+
+def test_log_run(run: Run):
+    path = get_artifact_path(run, "a.txt")
+    assert path.read_text() == "chdir_hydra_output"

hydraflow-0.5.2/tests/param/param.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import hydra
+from hydra.core.config_store import ConfigStore
+
+import hydraflow
+
+
+@dataclass
+class Data:
+    x: list[int] = field(default_factory=lambda: [1, 2, 3])
+    y: list[int] = field(default_factory=lambda: [4, 5, 6])
+
+
+@dataclass
+class Config:
+    host: str = "localhost"
+    port: int = 3306
+    data: Data = field(default_factory=Data)
+
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=Config)
+
+
+@hydra.main(version_base=None, config_name="config")
+def app(cfg: Config):
+    hydraflow.set_experiment()
+
+    with hydraflow.start_run(cfg):
+        pass
+
+
+if __name__ == "__main__":
+    app()

hydraflow-0.5.2/tests/param/test_hydra.py

@@ -0,0 +1,33 @@
+import pytest
+from mlflow.entities import Run
+
+from hydraflow.run_collection import RunCollection
+
+
+@pytest.fixture(scope="module")
+def rc(collect):
+    args = ["host=a"]
+    return collect("param/param.py", args)
+
+
+@pytest.fixture(scope="module")
+def run(rc: RunCollection):
+    return rc.first()
+
+
+def test_get_params_str(run: Run):
+    from hydraflow.param import get_params
+
+    assert get_params(run, "host") == ("a",)
+
+
+def test_get_params_list(run: Run):
+    from hydraflow.param import get_params
+
+    assert get_params(run, ["host"], ["port"]) == ("a", "3306")
+
+
+def test_get_values(run: Run):
+    from hydraflow.param import get_values
+
+    assert get_values(run, ["host", "port"], [str, int]) == ("a", 3306)