hydraflow 0.3.6__tar.gz → 0.4.1__tar.gz

{hydraflow-0.3.6 → hydraflow-0.4.1}/PKG-INFO

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

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

hydraflow-0.4.1/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 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
+
+
+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.3.6 → hydraflow-0.4.1}/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,11 +581,78 @@ 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
     if key not in params:
-        return True
+        return False
 
     param = params[key]
     if param == "None":
@@ -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.3.6 → hydraflow-0.4.1}/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.3.6 → hydraflow-0.4.1}/tests/test_app.py

@@ -179,3 +179,18 @@ 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)]

{hydraflow-0.3.6 → hydraflow-0.4.1}/tests/test_param.py

@@ -76,3 +76,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.3.6 → hydraflow-0.4.1}/tests/test_run_collection.py

@@ -101,9 +101,9 @@ def test_filter_invalid_param(run_list: list[Run]):
     from hydraflow.run_collection import filter_runs
 
     x = filter_runs(run_list, {"invalid": 0})
-    assert len(x) == 6
+    assert len(x) == 0
     x = filter_runs(run_list, ["invalid=0"])
-    assert len(x) == 6
+    assert len(x) == 0
 
 
 def test_filter_status(run_list: list[Run]):
@@ -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.3.6/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