hydraflow 0.18.1__tar.gz → 0.18.3__tar.gz

{hydraflow-0.18.1 → hydraflow-0.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.18.1
+Version: 0.18.3
 Summary: HydraFlow seamlessly integrates Hydra and MLflow to streamline ML experiment management, combining Hydra's configuration management with MLflow's tracking capabilities.
 Project-URL: Documentation, https://daizutabi.github.io/hydraflow/
 Project-URL: Source, https://github.com/daizutabi/hydraflow

{hydraflow-0.18.1 → hydraflow-0.18.3}/docs/part3-analysis/run-class.md

@@ -207,6 +207,36 @@ runs = Run.load(run_dirs)
 runs = Run.load(run_dirs, n_jobs=4)  # Use 4 parallel jobs for loading
 runs = Run.load(run_dirs, n_jobs=-1)  # Use all available CPU cores
 ```
+## Converting to DataFrame
+
+To convert a Run instance to a Polars DataFrame, use the
+[`to_frame`][hydraflow.core.run.Run.to_frame] method.
+This method adds the Run's information as columns to the DataFrame.
+
+```python
+# Basic usage
+df = run.to_frame(
+    lambda r: DataFrame({"value": [1, 2, 3]}),
+    "run_id",
+    "experiment_name"
+)
+
+# With default values
+df = run.to_frame(
+    lambda r: DataFrame({"value": [1, 2, 3]}),
+    "run_id",
+    ("status", lambda r: "completed")
+)
+```
+
+The `to_frame` method accepts the following parameters:
+
+- `func`: A function that takes a Run instance and returns a DataFrame
+- `*keys`: Keys for the Run's information to add. Accepts the following formats:
+  - String: A simple key (e.g., "run_id")
+  - Tuple: A tuple of (key, default value or function returning default value)
+
+
 
 ### Finding Runs with `iter_run_dirs`
 

{hydraflow-0.18.1 → hydraflow-0.18.3}/docs/part3-analysis/run-collection.md

@@ -303,6 +303,35 @@ filled_df = missing_values_df.with_columns(
 )
 ```
 
+## Concatenating Multiple Runs
+
+To convert and concatenate multiple Run instances into a DataFrame,
+use the [`concat`][hydraflow.core.run_collection.RunCollection.concat] method.
+This method adds each Run's information as columns to the DataFrame and concatenates them.
+
+```python
+# Basic usage
+df = run_collection.concat(
+    lambda r: DataFrame({"value": [1, 2, 3]}),
+    "run_id",
+    "experiment_name"
+)
+
+# With default values
+df = run_collection.concat(
+    lambda r: DataFrame({"value": [1, 2, 3]}),
+    "run_id",
+    ("status", lambda r: "completed")
+)
+```
+
+The `concat` method accepts the following parameters:
+
+- `func`: A function that takes each Run instance and returns a DataFrame
+- `*keys`: Keys for the Run's information to add. Accepts the following formats:
+  - String: A simple key (e.g., "run_id")
+  - Tuple: A tuple of (key, default value or function returning default value)
+
 ## Grouping Runs
 
 The `group_by` method allows you to organize runs based on parameter values:

{hydraflow-0.18.1 → hydraflow-0.18.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.18.1"
+version = "0.18.3"
 description = "HydraFlow seamlessly integrates Hydra and MLflow to streamline ML experiment management, combining Hydra's configuration management with MLflow's tracking capabilities."
 readme = "README.md"
 license = { file = "LICENSE" }

{hydraflow-0.18.1 → hydraflow-0.18.3}/src/hydraflow/core/collection.py

@@ -17,6 +17,7 @@ from .group_by import GroupBy
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
+    from re import Pattern, _FlagsType
     from typing import Any, Self
 
     from numpy.typing import NDArray
@@ -807,9 +808,10 @@ class Collection[I](Sequence[I]):
     def match(
         self,
         key: str,
-        pattern: str | re.Pattern,
+        pattern: str | Pattern[str],
         *,
         default: Any | Callable[[I], Any] = MISSING,
+        flags: _FlagsType = 0,
     ) -> Callable[[I], bool]:
         """Create a predicate function that checks if an attribute matches a pattern.
 
@@ -817,12 +819,16 @@ class Collection[I](Sequence[I]):
             key (str): The name of the attribute to check.
             pattern (str | re.Pattern): The pattern to check for.
             default (Any | Callable[[I], Any], optional): The default value.
+            flags (re.RegexFlag, optional): Flags for the regex pattern.
 
         Returns:
             Callable[[I], bool]: A predicate function for filtering.
 
         """
-        return lambda i: re.match(pattern, str(self._get(i, key, default))) is not None
+        return (
+            lambda i: re.match(pattern, str(self._get(i, key, default)), flags)
+            is not None
+        )
 
 
 def to_hashable(value: Any) -> Hashable:

{hydraflow-0.18.1 → hydraflow-0.18.3}/src/hydraflow/core/run.py

@@ -40,7 +40,7 @@ if TYPE_CHECKING:
     from collections.abc import Iterator
     from typing import Any, Self
 
-    from polars import Expr
+    from polars import DataFrame, Expr
     from polars._typing import PolarsDataType
 
     from .run_collection import RunCollection
@@ -341,6 +341,27 @@ class Run[C, I = None]:
         value = self.get(key, default)
         return pl.lit(value, dtype).alias(key)
 
+    def to_frame(
+        self,
+        func: Callable[[Self], DataFrame],
+        *keys: str | tuple[str, Any | Callable[[Self], Any]],
+    ) -> DataFrame:
+        """Convert the Run to a DataFrame.
+
+        Args:
+            func (Callable[[Run], DataFrame]): A function that takes a Run
+                instance and returns a DataFrame.
+            keys (str | tuple[str, Any | Callable[[Run], Any]]): The keys to
+                add to the DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame representation of the Run.
+
+        """
+        return func(self).with_columns(
+            self.lit(k) if isinstance(k, str) else self.lit(k[0], k[1]) for k in keys
+        )
+
     def to_dict(self, flatten: bool = True) -> dict[str, Any]:
         """Convert the Run to a dictionary.
 

{hydraflow-0.18.1 → hydraflow-0.18.3}/src/hydraflow/core/run_collection.py

@@ -43,6 +43,8 @@ from __future__ import annotations
 from functools import cached_property
 from typing import TYPE_CHECKING, overload
 
+import polars as pl
+
 from .collection import Collection
 from .run import Run
 
@@ -51,6 +53,8 @@ if TYPE_CHECKING:
     from pathlib import Path
     from typing import Any, Self
 
+    from polars import DataFrame
+
 
 class RunCollection[R: Run[Any, Any], I = None](Collection[R]):
     """A collection of Run instances that implements the Sequence protocol.
@@ -168,6 +172,28 @@ class RunCollection[R: Run[Any, Any], I = None](Collection[R]):
         for run in self:
             run.update(key, value, force=force)
 
+    def concat(
+        self,
+        func: Callable[[R], DataFrame],
+        *keys: str | tuple[str, Any | Callable[[R], Any]],
+    ) -> DataFrame:
+        """Concatenate the results of a function applied to all runs in the collection.
+
+        This method applies the provided function to each run in the collection
+        and concatenates the resulting DataFrames along the specified keys.
+
+        Args:
+            func (Callable[[R], DataFrame]): A function that takes a Run
+                instance and returns a DataFrame.
+            keys (str | tuple[str, Any | Callable[[R], Any]]): The keys to
+                add to the DataFrame.
+
+        Returns:
+            DataFrame: A DataFrame representation of the Run.
+
+        """
+        return pl.concat(run.to_frame(func, *keys) for run in self)
+
     @cached_property
     def impls(self) -> Collection[I]:
         """Get the implementation objects for all runs in the collection.

{hydraflow-0.18.1 → hydraflow-0.18.3}/tests/core/run/test_run.py

@@ -138,6 +138,20 @@ def test_lit(run: Run[Config]):
     assert df.item(2, "db.b") == 100
 
 
+def test_to_frame(run: Run[Config]):
+    def func(run: Run[Config]) -> pl.DataFrame:
+        return pl.DataFrame({"a": [run.get("a"), 20]})
+
+    run.update("a", 10)
+    run.update("db.b", 100)
+    df = run.to_frame(func, "db.b", ("x", 123), ("y", lambda r: r.get("a")))
+    assert df.shape == (2, 4)
+    assert df["a"].to_list() == [10, 20]
+    assert df["db.b"].to_list() == [100, 100]
+    assert df["x"].to_list() == [123, 123]
+    assert df["y"].to_list() == [10, 10]
+
+
 def test_to_dict(run: Run[Config]):
     run.update("a", 10)
     run.update("db.name", "abc")

{hydraflow-0.18.1 → hydraflow-0.18.3}/tests/core/run/test_run_collection.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 import numpy as np
 import pytest
+from polars import DataFrame
 
 from hydraflow.core.run import Run
 from hydraflow.core.run_collection import RunCollection
@@ -278,7 +279,19 @@ def test_group_by(rc: Rc):
     assert isinstance(gp, GroupBy)
 
 
-def test_impl(rc: Rc):
+def test_concat(rc: Rc):
+    def func(r: Run[Config, Impl]) -> DataFrame:
+        return DataFrame({"a": [r.get("count"), 20]})
+
+    df = rc.concat(func, "size.width", ("z", lambda r: r.get("count") * 20))
+    assert df.shape == (24, 3)
+    assert df["a"].to_list()[:4] == [1, 20, 1, 20]
+    assert df["size.width"].to_list()[-6:] == [10, 10, 20, 20, 30, 30]
+    assert df["z"].to_list()[:6] == [20, 20, 20, 20, 20, 20]
+    assert df["z"].to_list()[-6:] == [40, 40, 40, 40, 40, 40]
+
+
+def test_impls(rc: Rc):
     impls = rc.impls
     assert len(impls) == 12
     assert len(impls.filter(lambda i: i.y[0] == "1")) == 6

{hydraflow-0.18.1 → hydraflow-0.18.3}/tests/core/test_collection.py

@@ -1,3 +1,4 @@
+import re
 from collections.abc import Callable
 from dataclasses import dataclass
 from itertools import product
@@ -414,3 +415,7 @@ def test_endswith(rcd: Collection):
 
 def test_match(rcd: Collection):
     assert len(rcd.filter(rcd.match("z", r".*ac.*"))) == 2
+
+
+def test_match_flags(rcd: Collection):
+    assert len(rcd.filter(rcd.match("z", r".*AC.*", flags=re.IGNORECASE))) == 2