hydraflow 0.4.0__tar.gz → 0.4.2__tar.gz

hydraflow-0.4.2/.devcontainer/devcontainer.json

@@ -0,0 +1,18 @@
+{
+  "image": "mcr.microsoft.com/vscode/devcontainers/base:ubuntu24.04",
+  "features": {
+    "ghcr.io/devcontainers-contrib/features/starship:1": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "charliermarsh.ruff",
+        "fill-labs.dependi",
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "tamasfe.even-better-toml"
+      ]
+    }
+  },
+  "postCreateCommand": ".devcontainer/postCreate.sh"
+}

hydraflow-0.4.2/.devcontainer/postCreate.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+echo 'eval "$(starship init bash)"' >> ~/.bashrc
+echo "alias ll='ls -alF'" >> ~/.bashrc
+mkdir -p ~/.config
+cp .devcontainer/starship.toml ~/.config
+
+curl -LsSf https://astral.sh/uv/install.sh | sh
+source $HOME/.cargo/env
+echo 'eval "$(uv generate-shell-completion bash)"' >> ~/.bashrc

{hydraflow-0.4.0 → hydraflow-0.4.2}/PKG-INFO

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

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

{hydraflow-0.4.0 → hydraflow-0.4.2}/src/hydraflow/context.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import mlflow
+import mlflow.artifacts
 from hydra.core.hydra_config import HydraConfig
 from watchdog.events import FileModifiedEvent, PatternMatchingEventHandler
 from watchdog.observers import Observer

{hydraflow-0.4.0 → hydraflow-0.4.2}/src/hydraflow/mlflow.py

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING
 
 import joblib
 import mlflow
+import mlflow.artifacts
 from hydra.core.hydra_config import HydraConfig
 from mlflow.entities import ViewType
 from mlflow.tracking.fluent import SEARCH_MAX_RESULTS_PANDAS, _get_experiment_id

hydraflow-0.4.2/src/hydraflow/param.py

@@ -0,0 +1,162 @@
+"""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 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:  # noqa: PLR2004
+        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)

{hydraflow-0.4.0 → hydraflow-0.4.2}/src/hydraflow/run_collection.py

@@ -27,6 +27,7 @@ from mlflow.entities import RunStatus
 
 import hydraflow.param
 from hydraflow.config import iter_params, select_config, select_overrides
+from hydraflow.param import get_params, get_values
 from hydraflow.run_data import RunCollectionData
 from hydraflow.run_info import RunCollectionInfo
 from hydraflow.utils import load_config
@@ -132,25 +133,6 @@ class RunCollection:
 
         return self.__class__(self._runs[:n])
 
-    def sort(
-        self,
-        key: Callable[[Run], Any] | None = None,
-        *,
-        reverse: bool = False,
-    ) -> None:
-        """Sort the runs in the collection.
-
-        Sort the runs in the collection according to the provided key function
-        and optional reverse flag.
-
-        Args:
-            key (Callable[[Run], Any] | None): A function that takes a run and returns
-                a value to sort by.
-            reverse (bool): If True, sort in descending order.
-
-        """
-        self._runs.sort(key=key or (lambda x: x.info.start_time), reverse=reverse)
-
     def one(self) -> Run:
         """Get the only `Run` instance in the collection.
 
@@ -599,6 +581,73 @@ class RunCollection:
 
         return {key: RunCollection(runs) for key, runs in grouped_runs.items()}
 
+    def sort(
+        self,
+        key: Callable[[Run], Any] | None = None,
+        *,
+        reverse: bool = False,
+    ) -> None:
+        """Sort the runs in the collection.
+
+        Sort the runs in the collection according to the provided key function
+        and optional reverse flag.
+
+        Args:
+            key (Callable[[Run], Any] | None): A function that takes a run and returns
+                a value to sort by.
+            reverse (bool): If True, sort in descending order.
+
+        """
+        self._runs.sort(key=key or (lambda x: x.info.start_time), reverse=reverse)
+
+    def values(self, names: str | list[str]) -> list[Any]:
+        """Get the values of specified parameters from the runs.
+
+        Args:
+            names (str | list[str]): The names of the parameters to get the values.
+                This can be a single parameter name or multiple names provided
+                as separate arguments or as a list.
+
+        Returns:
+            A list of values for the specified parameters.
+
+        """
+        is_list = isinstance(names, list)
+
+        if isinstance(names, str):
+            names = [names]
+
+        config = load_config(self.first())
+        types = [type(v) for v in select_config(config, names).values()]
+        values = [get_values(run, names, types) for run in self]
+
+        if is_list:
+            return values
+
+        return [v[0] for v in values]
+
+    def sort_by(
+        self,
+        names: str | list[str],
+        *,
+        reverse: bool = False,
+    ) -> RunCollection:
+        """Sort the runs in the collection by specified parameter names.
+
+        Sort the runs in the collection based on the values of the specified
+        parameters.
+
+        Args:
+            names (str | list[str]): The names of the parameters to sort by.
+                This can be a single parameter name or multiple names provided
+                as separate arguments or as a list.
+            reverse (bool): If True, sort in descending order.
+
+        """
+        values = self.values(names)
+        index = sorted(range(len(self)), key=lambda i: values[i], reverse=reverse)
+        return RunCollection([self[i] for i in index])
+
 
 def _param_matches(run: Run, key: str, value: Any) -> bool:
     params = run.data.params
@@ -703,31 +752,3 @@ def _to_lower(status: str | int) -> str:
         return status.lower()
 
     return RunStatus.to_string(status).lower()
-
-
-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)
-
-    return tuple(run.data.params.get(name) for name in names_)

{hydraflow-0.4.0 → hydraflow-0.4.2}/src/hydraflow/utils.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import mlflow
+import mlflow.artifacts
 from hydra.core.hydra_config import HydraConfig
 from mlflow.entities import Run
 from mlflow.tracking import artifact_utils

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/integ/app.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
+from enum import Enum, auto
 
 import hydra
 from hydra.core.config_store import ConfigStore
@@ -11,6 +12,11 @@ import hydraflow
 log = logging.getLogger(__name__)
 
 
+class E(Enum):
+    A = auto()
+    B = auto()
+
+
 @dataclass
 class B:
     z: float = 0.0
@@ -20,6 +26,7 @@ class B:
 class A:
     y: str = "y"
     b: B = field(default_factory=B)
+    e: E = E.A
 
 
 @dataclass
@@ -38,12 +45,13 @@ def app(cfg: Config):
     hydraflow.set_experiment()
     rc = hydraflow.list_runs()
     log.info(rc)
+    log.info(cfg)
+    log.info(hydraflow.get_overrides())
     log.info(hydraflow.select_overrides(cfg))
     log.info(rc.filter(cfg, override=True))
-    log.info(rc.filter(cfg, select=["x"]))
-    log.info(rc.try_find_last(cfg, override=True))
-    log.info(rc.try_find_last(cfg, select=["x"]))
-    log.info(rc.filter(cfg))
+    for r in rc:
+        log.info(r.data.params)
+        log.info(hydraflow.load_config(r))
 
     cfg.y = 2 * cfg.x
     with hydraflow.start_run(cfg):

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/scripts/app.py

@@ -30,6 +30,16 @@ def app(cfg: MySQLConfig):
     with hydraflow.chdir_hydra_output() as path:
         Path("chdir_hydra.txt").write_text(path.as_posix())
 
+    o = hydraflow.select_overrides(cfg)
+    if "host" in o:
+        assert o["host"] == cfg.host
+
+    if "port" not in o:
+        assert cfg.port == 3306
+
+    if "values" not in o:
+        assert cfg.get("values") == [1, 2, 3]  # type: ignore
+
     hydraflow.set_experiment(prefix="_", suffix="_")
     with hydraflow.start_run(cfg) as run:
         log.info(f"START, {cfg.host}, {cfg.port} ")
@@ -52,6 +62,9 @@ def app(cfg: MySQLConfig):
 
         assert hydraflow.get_overrides() == hydraflow.load_overrides(run)
 
+        if cfg.host == "error":
+            raise Exception("error")
+
         log.info("END")
 
 

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/test_app.py

@@ -179,3 +179,37 @@ def test_app_filter_list(rc: RunCollection):
     assert len(filtered) == 4
     filtered = rc.filter(values=[1])
     assert not filtered
+
+
+def test_values(rc: RunCollection):
+    values = rc.values("host")
+    assert values == ["x", "x", "y", "y"]
+    values = rc.values(["host", "port"])
+    assert values == [("x", 1), ("x", 2), ("y", 1), ("y", 2)]
+
+
+def test_sort_by(rc: RunCollection):
+    sorted = rc.sort_by("host", reverse=True)
+    assert sorted.values(["host", "port"]) == [("y", 1), ("y", 2), ("x", 1), ("x", 2)]
+
+    sorted = rc.sort_by(["host", "port"], reverse=True)
+    assert sorted.values(["host", "port"]) == [("y", 2), ("y", 1), ("x", 2), ("x", 1)]
+
+
+def test_log_run_error(monkeypatch, tmp_path):
+    file = Path("tests/scripts/app.py").absolute()
+    monkeypatch.chdir(tmp_path)
+
+    args = [sys.executable, file.as_posix()]
+    args += ["host=error", "hydra.job.name=error"]
+    cp = subprocess.run(args, check=False, capture_output=True)
+    assert cp.returncode == 1
+    assert b"Error during log_run: error" in cp.stdout
+
+
+def test_chdir_artifact(rc: RunCollection):
+    from hydraflow.context import chdir_artifact
+
+    with chdir_artifact(rc[0]):
+        assert Path.cwd().stem == "artifacts"
+        assert Path.cwd().parent.stem == rc[0].info.run_id

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/test_asyncio.py

@@ -164,3 +164,58 @@ def test_run(tmp_path: Path):
     assert stderr_lines == ["world"]
     assert Path(path).read_text() == "hello world"
     assert len(changes_detected) >= 2
+
+
+@pytest.mark.asyncio
+async def test_execute_command_nonexistent():
+    from hydraflow.asyncio import execute_command
+
+    stop_event = asyncio.Event()
+
+    rc = await execute_command("nonexistent_command", stop_event=stop_event)
+    assert rc == 1
+    assert stop_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_process_stream_none():
+    from hydraflow.asyncio import process_stream
+
+    assert await process_stream(None, None) is None
+
+
+@pytest.mark.asyncio
+async def test_monitor_file_changes_error():
+    from hydraflow.asyncio import monitor_file_changes
+
+    stop_event = asyncio.Event()
+
+    with pytest.raises(FileNotFoundError):
+        await monitor_file_changes(["nonexistent_path"], lambda _: None, stop_event)
+
+
+@pytest.mark.asyncio
+async def test_run_and_monitor_none():
+    from hydraflow.asyncio import run_and_monitor
+
+    assert await run_and_monitor("echo", "hello") == 0
+
+
+@pytest.mark.asyncio
+async def test_run_and_monitor_error():
+    from hydraflow.asyncio import run_and_monitor
+
+    with pytest.raises(FileNotFoundError):
+        await run_and_monitor(
+            "nonexistent_command",
+            watch=lambda _: None,
+            paths=["nonexistent_path"],
+        )
+
+
+def test_run_cwd():
+    from hydraflow.asyncio import run
+
+    return_code = run(sys.executable, "--version", watch=lambda _: None)
+
+    assert return_code == 0

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/test_param.py

@@ -49,6 +49,22 @@ def test_param(param, x, y):
     assert match(p, x)
 
 
+def test_param_float():
+    from hydraflow.param import match
+
+    assert match("1.0", 1.0)
+    assert match("1.0", 1)
+    assert match("0.0", 0)
+    assert match("0.0", 0.0)
+
+
+def test_param_bool():
+    from hydraflow.param import match
+
+    assert not match("1", True)
+    assert not match("0", False)
+
+
 def test_match_list():
     from hydraflow.param import _match_list
 
@@ -76,3 +92,26 @@ def test_match_tuple():
     assert _match_tuple("1", (True, False)) is None
     assert _match_tuple("1", (None, None)) is None
     assert _match_tuple("1", (1, 3.2)) is None
+
+
+def test_to_value():
+    from hydraflow.param import to_value
+
+    assert to_value("1", int) == 1
+    assert to_value("1", float) == 1.0
+    assert to_value("1.0", float) == 1.0
+    assert to_value("True", bool) is True
+    assert to_value("False", bool) is False
+    assert to_value("None", int) is None
+    assert to_value("a", str) == "a"
+
+
+def test_to_value_list():
+    from hydraflow.param import to_value
+
+    x = "[1, 2, 3]"
+    assert to_value(x, list) == [1, 2, 3]
+    x = "[1.2, 2.3, 3.4]"
+    assert to_value(x, list) == [1.2, 2.3, 3.4]
+    x = "[a, b, c]"
+    assert to_value(x, list) == ["a", "b", "c"]

{hydraflow-0.4.0 → hydraflow-0.4.2}/tests/test_run_collection.py

@@ -126,7 +126,7 @@ def test_filter_status_enum(run_list: list[Run]):
 
 
 def test_get_params(run_list: list[Run]):
-    from hydraflow.run_collection import get_params
+    from hydraflow.param import get_params
 
     assert get_params(run_list[1], "p") == ("1",)
     assert get_params(run_list[2], "p", "q") == ("2", "0")
@@ -135,6 +135,12 @@ def test_get_params(run_list: list[Run]):
     assert get_params(run_list[5], ["a", "q"], "r") == (None, "None", "2")
 
 
+def test_get_values(run_list: list[Run]):
+    from hydraflow.param import get_values
+
+    assert get_values(run_list[3], ["p", "q"], [int, int]) == (3, 0)
+
+
 @pytest.mark.parametrize("i", range(6))
 def test_chdir_artifact_list(i: int, run_list: list[Run]):
     from hydraflow.context import chdir_artifact

hydraflow-0.4.0/.devcontainer/devcontainer.json

@@ -1,17 +0,0 @@
-{
-  "image": "mcr.microsoft.com/vscode/devcontainers/python:3.12",
-  "features": {
-    "ghcr.io/devcontainers-contrib/features/starship:1": {},
-    "ghcr.io/va-h/devcontainers-features/uv:1": {}
-  },
-  "customizations": {
-    "vscode": {
-      "extensions": [
-        "charliermarsh.ruff",
-        "ms-python.python",
-        "ms-python.vscode-pylance"
-      ]
-    }
-  },
-  "postCreateCommand": ".devcontainer/postCreate.sh"
-}

hydraflow-0.4.0/.devcontainer/postCreate.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-echo 'eval "$(starship init bash)"' >> ~/.bashrc
-mkdir -p ~/.config
-cp .devcontainer/starship.toml ~/.config

hydraflow-0.4.0/src/hydraflow/param.py

@@ -1,78 +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 Any
-
-
-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 value 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, str):
-        return param == value
-
-    if isinstance(value, int | float):
-        return type(value)(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:  # noqa: PLR2004
-        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