hydraflow 0.18.2__tar.gz → 0.18.4__tar.gz

{hydraflow-0.18.2 → hydraflow-0.18.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.18.2
+Version: 0.18.4
 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.2 → hydraflow-0.18.4}/docs/part3-analysis/run-class.md

@@ -191,6 +191,35 @@ run = Run[Config, AdvancedModelLoader](run_dir, AdvancedModelLoader)
 model = run.impl.load_model()  # Uses configuration information
 ```
 
+## 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:
+
+- `function`: 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)
+
 ## Loading Multiple Runs
 
 The `load` class method can load both individual runs and collections of runs:
@@ -264,4 +293,4 @@ based on experiment names or custom filtering criteria.
 The [`Run`][hydraflow.core.run.Run] class provides a powerful interface for
 working with experiment runs in HydraFlow. Its type-safe configuration access,
 custom implementation support, and convenient loading mechanisms make it easy
-to analyze and compare experiment results effectively.
+to analyze and compare experiment results effectively.

{hydraflow-0.18.2 → hydraflow-0.18.4}/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:
+
+- `function`: 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:
@@ -439,4 +468,4 @@ filtering, grouping, and data extraction capabilities enable efficient extractio
 of insights from large sets of experiments, helping you identify optimal
 configurations and understand performance trends.
 
-[hydraflow.core.collection.Collection]: ../../api/hydraflow/core/collection.html#hydraflow.core.collection.Collection
+[hydraflow.core.collection.Collection]: ../../api/hydraflow/core/collection.html#hydraflow.core.collection.Collection

{hydraflow-0.18.2 → hydraflow-0.18.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hydraflow"
-version = "0.18.2"
+version = "0.18.4"
 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" }
@@ -62,7 +62,7 @@ dev = [
   "pytest-xdist",
   "ruff>=0.11",
 ]
-docs = ["markdown-exec[ansi]", "mkapi", "mkdocs-material"]
+docs = ["markdown-exec[ansi]", "mkapi>=4.4", "mkdocs-material"]
 
 [tool.pytest.ini_options]
 addopts = [

{hydraflow-0.18.2 → hydraflow-0.18.4}/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,
+        function: Callable[[Self], DataFrame],
+        *keys: str | tuple[str, Any | Callable[[Self], Any]],
+    ) -> DataFrame:
+        """Convert the Run to a DataFrame.
+
+        Args:
+            function (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 function(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.2 → hydraflow-0.18.4}/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,
+        function: 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:
+            function (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 collection.
+
+        """
+        return pl.concat(run.to_frame(function, *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.2 → hydraflow-0.18.4}/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.2 → hydraflow-0.18.4}/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