hydraflow 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

hydraflow/__init__.py

@@ -1,27 +1,35 @@
 from .context import Info, chdir_artifact, log_run, watch
 from .mlflow import set_experiment
-from .run import (
-    filter_by_config,
+from .runs import (
+    Run,
+    Runs,
+    drop_unique_params,
+    filter_runs,
     get_artifact_dir,
     get_artifact_path,
     get_artifact_uri,
-    get_by_config,
     get_param_dict,
     get_param_names,
+    get_run,
     get_run_id,
+    load_config,
 )
 
 __all__ = [
     "Info",
+    "Run",
+    "Runs",
     "chdir_artifact",
-    "filter_by_config",
+    "drop_unique_params",
+    "filter_runs",
     "get_artifact_dir",
     "get_artifact_path",
     "get_artifact_uri",
-    "get_by_config",
     "get_param_dict",
     "get_param_names",
+    "get_run",
     "get_run_id",
+    "load_config",
     "log_run",
     "set_experiment",
     "watch",

hydraflow/context.py

@@ -13,7 +13,7 @@ from watchdog.events import FileModifiedEvent, FileSystemEventHandler
 from watchdog.observers import Observer
 
 from hydraflow.mlflow import log_params
-from hydraflow.run import get_artifact_path
+from hydraflow.runs import get_artifact_path
 from hydraflow.util import uri_to_path
 
 if TYPE_CHECKING:
@@ -40,14 +40,19 @@ def log_run(
     hc = HydraConfig.get()
     output_dir = Path(hc.runtime.output_dir)
     uri = mlflow.get_artifact_uri()
-    location = Info(output_dir, uri_to_path(uri))
+    info = Info(output_dir, uri_to_path(uri))
 
     # Save '.hydra' config directory first.
     output_subdir = output_dir / (hc.output_subdir or "")
     mlflow.log_artifacts(output_subdir.as_posix(), hc.output_subdir)
 
+    def log_artifact(path: Path) -> None:
+        local_path = (output_dir / path).as_posix()
+        mlflow.log_artifact(local_path)
+
     try:
-        yield location
+        with watch(log_artifact, output_dir):
+            yield info
 
     finally:
         # Save output_dir including '.hydra' config directory.
@@ -55,11 +60,7 @@ def log_run(
 
 
 @contextmanager
-def watch(
-    func: Callable[[Path], None],
-    dir: Path | str = "",
-    timeout: int = 600,
-) -> Iterator[None]:
+def watch(func: Callable[[Path], None], dir: Path | str = "", timeout: int = 60) -> Iterator[None]:
     if not dir:
         uri = mlflow.get_artifact_uri()
         dir = uri_to_path(uri)

hydraflow/mlflow.py

@@ -6,10 +6,13 @@ from hydra.core.hydra_config import HydraConfig
 from hydraflow.config import iter_params
 
 
-def set_experiment() -> None:
+def set_experiment(prefix: str = "", suffix: str = "", uri: str | None = None) -> None:
+    if uri:
+        mlflow.set_tracking_uri(uri)
+
     hc = HydraConfig.get()
-    mlflow.set_tracking_uri("")
-    mlflow.set_experiment(hc.job.name)
+    name = f"{prefix}{hc.job.name}{suffix}"
+    mlflow.set_experiment(name)
 
 
 def log_params(config: object, *, synchronous: bool | None = None) -> None:

hydraflow/runs.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import mlflow
+import numpy as np
+from mlflow.entities.run import Run as Run_
+from mlflow.tracking import artifact_utils
+from omegaconf import DictConfig, OmegaConf
+from pandas import DataFrame, Series
+
+from hydraflow.config import iter_params
+from hydraflow.util import uri_to_path
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+@dataclass
+class Runs:
+    runs: list[Run_] | DataFrame
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({len(self)})"
+
+    def __len__(self) -> int:
+        return len(self.runs)
+
+    def filter(self, config: object) -> Runs:
+        return Runs(filter_runs(self.runs, config))
+
+    def get(self, config: object) -> Run:
+        return Run(get_run(self.runs, config))
+
+    def drop_unique_params(self) -> Runs:
+        if isinstance(self.runs, DataFrame):
+            return Runs(drop_unique_params(self.runs))
+
+        raise NotImplementedError
+
+    def get_param_names(self) -> list[str]:
+        if isinstance(self.runs, DataFrame):
+            return get_param_names(self.runs)
+
+        raise NotImplementedError
+
+    def get_param_dict(self) -> dict[str, list[str]]:
+        if isinstance(self.runs, DataFrame):
+            return get_param_dict(self.runs)
+
+        raise NotImplementedError
+
+
+def filter_runs(runs: list[Run_] | DataFrame, config: object) -> list[Run_] | DataFrame:
+    if isinstance(runs, list):
+        return filter_runs_list(runs, config)
+
+    return filter_runs_dataframe(runs, config)
+
+
+def _is_equal(run: Run_, key: str, value: Any) -> bool:
+    param = run.data.params.get(key, value)
+
+    if param is None:
+        return False
+
+    return type(value)(param) == value
+
+
+def filter_runs_list(runs: list[Run_], config: object) -> list[Run_]:
+    for key, value in iter_params(config):
+        runs = [run for run in runs if _is_equal(run, key, value)]
+
+    return runs
+
+
+def filter_runs_dataframe(runs: DataFrame, config: object) -> DataFrame:
+    index = np.ones(len(runs), dtype=bool)
+
+    for key, value in iter_params(config):
+        name = f"params.{key}"
+
+        if name in runs:
+            series = runs[name]
+            is_value = -series.isna()
+            param = series.fillna(value).astype(type(value))
+            index &= is_value & (param == value)
+
+    return runs[index]
+
+
+def get_run(runs: list[Run_] | DataFrame, config: object) -> Run_ | Series:
+    runs = filter_runs(runs, config)
+
+    if len(runs) == 1:
+        return runs[0] if isinstance(runs, list) else runs.iloc[0]
+
+    msg = f"number of filtered runs is not 1: got {len(runs)}"
+    raise ValueError(msg)
+
+
+def drop_unique_params(runs: DataFrame) -> DataFrame:
+    def select(column: str) -> bool:
+        return not column.startswith("params.") or len(runs[column].unique()) > 1
+
+    columns = [select(column) for column in runs.columns]
+    return runs.iloc[:, columns]
+
+
+def get_param_names(runs: DataFrame) -> list[str]:
+    def get_name(column: str) -> str:
+        if column.startswith("params."):
+            return column.split(".", maxsplit=1)[-1]
+
+        return ""
+
+    columns = [get_name(column) for column in runs.columns]
+    return [column for column in columns if column]
+
+
+def get_param_dict(runs: DataFrame) -> dict[str, list[str]]:
+    params = {}
+    for name in get_param_names(runs):
+        params[name] = list(runs[f"params.{name}"].unique())
+
+    return params
+
+
+@dataclass
+class Run:
+    run: Run_ | Series | str
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.run_id!r})"
+
+    @property
+    def run_id(self) -> str:
+        return get_run_id(self.run)
+
+    def artifact_uri(self, artifact_path: str | None = None) -> str:
+        return get_artifact_uri(self.run, artifact_path)
+
+    @property
+    def artifact_dir(self) -> Path:
+        return get_artifact_dir(self.run)
+
+    def artifact_path(self, artifact_path: str | None = None) -> Path:
+        return get_artifact_path(self.run, artifact_path)
+
+    @property
+    def config(self) -> DictConfig:
+        return load_config(self.run)
+
+    def log_hydra_output_dir(self) -> None:
+        log_hydra_output_dir(self.run)
+
+
+def get_run_id(run: Run_ | Series | str) -> str:
+    if isinstance(run, str):
+        return run
+
+    if isinstance(run, Run_):
+        return run.info.run_id
+
+    return run.run_id
+
+
+def get_artifact_uri(run: Run_ | Series | str, artifact_path: str | None = None) -> str:
+    run_id = get_run_id(run)
+    return artifact_utils.get_artifact_uri(run_id, artifact_path)
+
+
+def get_artifact_dir(run: Run_ | Series | str) -> Path:
+    uri = get_artifact_uri(run)
+    return uri_to_path(uri)
+
+
+def get_artifact_path(run: Run_ | Series | str, artifact_path: str | None = None) -> Path:
+    artifact_dir = get_artifact_dir(run)
+    return artifact_dir / artifact_path if artifact_path else artifact_dir
+
+
+def load_config(run: Run_ | Series | str) -> DictConfig:
+    run_id = get_run_id(run)
+    return _load_config(run_id)
+
+
+@cache
+def _load_config(run_id: str) -> DictConfig:
+    try:
+        path = mlflow.artifacts.download_artifacts(
+            run_id=run_id,
+            artifact_path=".hydra/config.yaml",
+        )
+    except OSError:
+        return DictConfig({})
+
+    return OmegaConf.load(path)  # type: ignore
+
+
+def get_hydra_output_dir(run: Run_ | Series | str) -> Path:
+    path = get_artifact_dir(run) / ".hydra/hydra.yaml"
+
+    if path.exists():
+        hc = OmegaConf.load(path)
+        return Path(hc.hydra.runtime.output_dir)
+
+    raise FileNotFoundError
+
+
+def log_hydra_output_dir(run: Run_ | Series | str) -> None:
+    output_dir = get_hydra_output_dir(run)
+    run_id = run if isinstance(run, str) else run.info.run_id
+    mlflow.log_artifacts(output_dir.as_posix(), run_id=run_id)

{hydraflow-0.1.1.dist-info → hydraflow-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hydraflow
-Version: 0.1.1
+Version: 0.1.4
 Summary: Hydra with MLflow
 Project-URL: Documentation, https://github.com/daizutabi/hydraflow
 Project-URL: Source, https://github.com/daizutabi/hydraflow

hydraflow-0.1.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+hydraflow/__init__.py,sha256=e1Q0Sskx39jaU2zkGNXjFWNC5xugEz_hDERTN_6Mzy8,666
+hydraflow/config.py,sha256=b3Plh_lmq94loZNw9QP2asd6thCLyTzzYSutH0cONXA,964
+hydraflow/context.py,sha256=3vejDbRYQBuBwlhpBpOv5aoyZ-yS8UUzpbCFK1V1uvw,2720
+hydraflow/mlflow.py,sha256=unBP3Y7ujTM3E_Hq_eYvRVFZoGfTA7B0h4FkOZtPPqc,566
+hydraflow/runs.py,sha256=127YykWzmiNUUuJSGPOCZasXmd6tcE15HU32j8x71ck,5864
+hydraflow/util.py,sha256=_BdOMq5tKPm8HOehb2s2ZIBpJYyVpvO_yaAIxbSj51I,253
+hydraflow-0.1.4.dist-info/METADATA,sha256=Xw-xcDKdzkHa7bKDZUI6MXpOKekcyFbMyBy1yANjNQs,1903
+hydraflow-0.1.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+hydraflow-0.1.4.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
+hydraflow-0.1.4.dist-info/RECORD,,

hydraflow/run.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, overload
-
-import mlflow
-import numpy as np
-from mlflow.entities.run import Run
-from mlflow.tracking import artifact_utils
-from omegaconf import DictConfig, OmegaConf
-
-from hydraflow.config import iter_params
-from hydraflow.util import uri_to_path
-
-if TYPE_CHECKING:
-    from typing import Any
-
-    from pandas import DataFrame, Series
-
-
-@overload
-def filter_by_config(runs: list[Run], config: object) -> list[Run]: ...
-
-
-@overload
-def filter_by_config(runs: DataFrame, config: object) -> DataFrame: ...
-
-
-def filter_by_config(runs: list[Run] | DataFrame, config: object):
-    if isinstance(runs, list):
-        return filter_by_config_list(runs, config)
-
-    return filter_by_config_dataframe(runs, config)
-
-
-def _is_equal(run: Run, key: str, value: Any) -> bool:
-    param = run.data.params.get(key, value)
-    if param is None:
-        return False
-
-    return type(value)(param) == value
-
-
-def filter_by_config_list(runs: list[Run], config: object) -> list[Run]:
-    for key, value in iter_params(config):
-        runs = [run for run in runs if _is_equal(run, key, value)]
-
-    return runs
-
-
-def filter_by_config_dataframe(runs: DataFrame, config: object) -> DataFrame:
-    index = np.ones(len(runs), dtype=bool)
-
-    for key, value in iter_params(config):
-        name = f"params.{key}"
-        if name in runs:
-            series = runs[name]
-            is_value = -series.isna()
-            param = series.fillna(value).astype(type(value))
-            index &= is_value & (param == value)
-
-    return runs[index]
-
-
-@overload
-def get_by_config(runs: list[Run], config: object) -> Run: ...
-
-
-@overload
-def get_by_config(runs: DataFrame, config: object) -> Series: ...
-
-
-def get_by_config(runs: list[Run] | DataFrame, config: object):
-    runs = filter_by_config(runs, config)
-
-    if len(runs) == 1:
-        return runs[0] if isinstance(runs, list) else runs.iloc[0]
-
-    msg = f"filtered runs has not length of 1.: {len(runs)}"
-    raise ValueError(msg)
-
-
-def drop_unique_params(runs: DataFrame) -> DataFrame:
-    def select(column: str) -> bool:
-        return not column.startswith("params.") or len(runs[column].unique()) > 1
-
-    columns = [select(column) for column in runs.columns]
-    return runs.iloc[:, columns]
-
-
-def get_param_names(runs: DataFrame) -> list[str]:
-    def get_name(column: str) -> str:
-        if column.startswith("params."):
-            return column.split(".", maxsplit=1)[-1]
-
-        return ""
-
-    columns = [get_name(column) for column in runs.columns]
-    return [column for column in columns if column]
-
-
-def get_param_dict(runs: DataFrame) -> dict[str, list[str]]:
-    params = {}
-    for name in get_param_names(runs):
-        params[name] = list(runs[f"params.{name}"].unique())
-
-    return params
-
-
-def get_run_id(run: Run | Series | str) -> str:
-    if isinstance(run, Run):
-        return run.info.run_id
-    if isinstance(run, str):
-        return run
-    return run.run_id
-
-
-def get_artifact_uri(run: Run | Series | str, artifact_path: str | None = None) -> str:
-    if isinstance(run, Run):
-        uri = run.info.artifact_uri
-    elif isinstance(run, str):
-        uri = artifact_utils.get_artifact_uri(run_id=run)
-    else:
-        uri = run.artifact_uri
-
-    if artifact_path:
-        uri = f"{uri}/{artifact_path}"
-
-    return uri  # type: ignore
-
-
-def get_artifact_dir(run: Run | Series | str) -> Path:
-    uri = get_artifact_uri(run)
-    return uri_to_path(uri)
-
-
-def get_artifact_path(
-    run: Run | Series | str,
-    artifact_path: str | None = None,
-) -> Path:
-    artifact_dir = get_artifact_dir(run)
-    return artifact_dir / artifact_path if artifact_path else artifact_dir
-
-
-def load_config(run: Run | Series | str, output_subdir: str = ".hydra") -> DictConfig:
-    run_id = get_run_id(run)
-
-    try:
-        path = mlflow.artifacts.download_artifacts(
-            run_id=run_id,
-            artifact_path=f"{output_subdir}/config.yaml",
-        )
-    except OSError:
-        return DictConfig({})
-
-    return OmegaConf.load(path)  # type: ignore
-
-
-def get_hydra_output_dir(run: Run | Series | str) -> Path:
-    path = get_artifact_dir(run) / ".hydra/hydra.yaml"
-
-    if path.exists():
-        hc = OmegaConf.load(path)
-        return Path(hc.hydra.runtime.output_dir)
-
-    raise FileNotFoundError
-
-
-def log_hydra_output_dir(run: Run | Series | str) -> None:
-    output_dir = get_hydra_output_dir(run)
-    run_id = run if isinstance(run, str) else run.info.run_id
-    mlflow.log_artifacts(output_dir.as_posix(), run_id=run_id)

hydraflow-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-hydraflow/__init__.py,sha256=9RaHPTloOOJYPUKKfPuK_wxKDr_J9A3rJ_gr-bLABD0,559
-hydraflow/config.py,sha256=b3Plh_lmq94loZNw9QP2asd6thCLyTzzYSutH0cONXA,964
-hydraflow/context.py,sha256=zBmbZWNLxUF2IDDPregPnR_sh3utmFwFJaneSsBsLDM,2558
-hydraflow/mlflow.py,sha256=yDZ_oB1IZdCNNqHm_0LxdZ1Nld28IkW8Xl7NMhWLApE,453
-hydraflow/run.py,sha256=XTAD_fd-ivvZ4tbjQLHrf6u5eAGRrrhqvExiZQcFnX8,4591
-hydraflow/util.py,sha256=_BdOMq5tKPm8HOehb2s2ZIBpJYyVpvO_yaAIxbSj51I,253
-hydraflow-0.1.1.dist-info/METADATA,sha256=4QeC8CONrWskor7MylsUtq5lUMr1L33wQiFAn10urfI,1903
-hydraflow-0.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-hydraflow-0.1.1.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
-hydraflow-0.1.1.dist-info/RECORD,,