hydraflow 0.1.0__tar.gz

hydraflow-0.1.0/.devcontainer/devcontainer.json

@@ -0,0 +1,16 @@
+{
+  "name": "hydraflow",
+  "image": "mcr.microsoft.com/devcontainers/python:3.10-bookworm",
+  "features": {
+    "ghcr.io/devcontainers-contrib/features/ruff:1": {},
+    "ghcr.io/devcontainers-contrib/features/hatch:2": {},
+    "ghcr.io/devcontainers-contrib/features/starship:1": {},
+    "ghcr.io/va-h/devcontainers-features/uv:1": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": ["charliermarsh.ruff"]
+    }
+  },
+  "postCreateCommand": ".devcontainer/postCreate.sh"
+}

hydraflow-0.1.0/.devcontainer/postCreate.sh

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

hydraflow-0.1.0/.devcontainer/starship.toml

@@ -0,0 +1,29 @@
+"$schema" = 'https://starship.rs/config-schema.json'
+
+add_newline = false
+
+[username]
+disabled = true
+
+[hostname]
+disabled = true
+
+[package]
+format = '[$symbol$version]($style) '
+symbol = "󰏗 "
+style = 'bold blue'
+
+[git_branch]
+format = '[$symbol$branch(:$remote_branch)]($style)'
+symbol = ' '
+style = 'bold green'
+
+[git_status]
+style = 'red'
+modified = '*'
+format = '([$modified]($style)) '
+
+[python]
+format = '[${symbol}${pyenv_prefix}(${version} )(\($virtualenv\) )]($style)'
+symbol = ' '
+style = 'yellow'

hydraflow-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+.coverage
+.venv/
+__pycache__/
+lcov.info

hydraflow-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Daizu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hydraflow-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.3
+Name: hydraflow
+Version: 0.1.0
+Summary: Hydra with MLflow
+Project-URL: Source, https://github.com/daizutabi/hydraflow
+Project-URL: Issues, https://github.com/daizutabi/hydraflow/issues
+Author-email: daizutabi <daizutabi@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.10
+Requires-Dist: hydra-core
+Requires-Dist: mlflow
+Requires-Dist: watchdog
+Provides-Extra: dev
+Requires-Dist: pytest-clarity; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-randomly; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Requires-Dist: setuptools; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# hydraflow

hydraflow-0.1.0/README.md

@@ -0,0 +1 @@
+# hydraflow

hydraflow-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hydraflow"
+version = "0.1.0"
+description = "Hydra with MLflow"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "daizutabi", email = "daizutabi@gmail.com" }]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Documentation",
+  "Topic :: Software Development :: Documentation",
+]
+requires-python = ">=3.10"
+dependencies = ["hydra-core", "mlflow", "watchdog"]
+
+[project.optional-dependencies]
+dev = [
+  "pytest-clarity",
+  "pytest-cov",
+  "pytest-randomly",
+  "pytest-xdist",
+  "setuptools",
+]
+
+[project.urls]
+# Documentation = "https://daizutabi.github.io/hydraflow/"
+Source = "https://github.com/daizutabi/hydraflow"
+Issues = "https://github.com/daizutabi/hydraflow/issues"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["/.github", "/docs"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hydraflow"]
+
+[tool.pytest.ini_options]
+addopts = [
+  "--doctest-modules",
+  "--cov=hydraflow",
+  "--cov-report=lcov:lcov.info",
+]
+
+doctest_optionflags = ["NORMALIZE_WHITESPACE", "IGNORE_EXCEPTION_DETAIL"]
+filterwarnings = ['ignore:pkg_resources is deprecated:DeprecationWarning']
+
+[tool.coverage.report]
+exclude_lines = ["no cov", "raise NotImplementedError", "if TYPE_CHECKING:"]
+
+[tool.hatch.envs.docs.scripts]
+build = "mkdocs build --clean --strict {args}"
+serve = "mkdocs serve --dev-addr localhost:8000 {args}"
+deploy = "mkdocs gh-deploy --force"
+
+[tool.ruff]
+line-length = 88
+target-version = "py312"
+
+[tool.ruff.lint]
+unfixable = ["F401", "RUF100"]

hydraflow-0.1.0/src/hydraflow/__init__.py

@@ -0,0 +1,28 @@
+from .context import Info, chdir_artifact, log_run, watch
+from .mlflow import set_experiment
+from .run import (
+    filter_by_config,
+    get_artifact_dir,
+    get_artifact_path,
+    get_artifact_uri,
+    get_by_config,
+    get_param_dict,
+    get_param_names,
+    get_run_id,
+)
+
+__all__ = [
+    "Info",
+    "chdir_artifact",
+    "filter_by_config",
+    "get_artifact_dir",
+    "get_artifact_path",
+    "get_artifact_uri",
+    "get_by_config",
+    "get_param_dict",
+    "get_param_names",
+    "get_run_id",
+    "log_run",
+    "set_experiment",
+    "watch",
+]

hydraflow-0.1.0/src/hydraflow/config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from omegaconf import DictConfig, ListConfig, OmegaConf
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Any
+
+
+def iter_params(config: object, prefix: str = "") -> Iterator[tuple[str, Any]]:
+    if not isinstance(config, DictConfig | ListConfig):
+        config = OmegaConf.create(config)  # type: ignore
+
+    if isinstance(config, DictConfig):
+        for key, value in config.items():
+            if isinstance(value, (DictConfig, ListConfig)):
+                yield from iter_params(value, f"{prefix}{key}.")
+
+            else:
+                yield f"{prefix}{key}", value
+
+    elif isinstance(config, ListConfig):
+        for index, value in enumerate(config):
+            if isinstance(value, (DictConfig, ListConfig)):
+                yield from iter_params(value, f"{prefix}{index}.")
+
+            else:
+                yield f"{prefix}{index}", value

hydraflow-0.1.0/src/hydraflow/context.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+import time
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import mlflow
+from hydra.core.hydra_config import HydraConfig
+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.util import uri_to_path
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+    from mlflow.entities.run import Run
+    from pandas import Series
+
+
+@dataclass
+class Info:
+    output_dir: Path
+    artifact_dir: Path
+
+
+@contextmanager
+def log_run(
+    config: object,
+    *,
+    synchronous: bool | None = None,
+) -> Iterator[Info]:
+    log_params(config, synchronous=synchronous)
+
+    hc = HydraConfig.get()
+    output_dir = Path(hc.runtime.output_dir)
+    uri = mlflow.get_artifact_uri()
+    location = 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)
+
+    try:
+        yield location
+
+    finally:
+        # Save output_dir including '.hydra' config directory.
+        mlflow.log_artifacts(output_dir.as_posix())
+
+
+@contextmanager
+def watch(
+    func: Callable[[Path], None],
+    dir: Path | str = "",
+    timeout: int = 600,
+) -> Iterator[None]:
+    if not dir:
+        uri = mlflow.get_artifact_uri()
+        dir = uri_to_path(uri)
+
+    handler = Handler(func)
+    observer = Observer()
+    observer.schedule(handler, dir, recursive=True)
+    observer.start()
+
+    try:
+        yield
+
+    finally:
+        elapsed = 0
+        while not observer.event_queue.empty():
+            time.sleep(0.2)
+            elapsed += 0.2
+            if elapsed > timeout:
+                break
+
+        observer.stop()
+        observer.join()
+
+
+class Handler(FileSystemEventHandler):
+    def __init__(self, func: Callable[[Path], None]) -> None:
+        self.func = func
+
+    def on_modified(self, event: FileModifiedEvent) -> None:
+        file = Path(event.src_path)
+        if file.is_file():
+            self.func(file)
+
+
+@contextmanager
+def chdir_artifact(
+    run: Run | Series | str,
+    artifact_path: str | None = None,
+) -> Iterator[Path]:
+    curdir = Path.cwd()
+
+    artifact_dir = get_artifact_path(run, artifact_path)
+
+    os.chdir(artifact_dir)
+    try:
+        yield artifact_dir
+    finally:
+        os.chdir(curdir)

hydraflow-0.1.0/src/hydraflow/mlflow.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import mlflow
+from hydra.core.hydra_config import HydraConfig
+
+from hydraflow.config import iter_params
+
+
+def set_experiment() -> None:
+    hc = HydraConfig.get()
+    mlflow.set_tracking_uri("")
+    mlflow.set_experiment(hc.job.name)
+
+
+def log_params(config: object, *, synchronous: bool | None = None) -> None:
+    for key, value in iter_params(config):
+        mlflow.log_param(key, value, synchronous=synchronous)

hydraflow-0.1.0/src/hydraflow/run.py

@@ -0,0 +1,172 @@
+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.0/src/hydraflow/util.py

@@ -0,0 +1,11 @@
+import platform
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+def uri_to_path(uri: str) -> Path:
+    path = urlparse(uri).path
+    if platform.system() == "Windows" and path.startswith("/"):
+        path = path[1:]
+
+    return Path(path)

hydraflow-0.1.0/tests/log_run.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+import hydra
+import mlflow
+from hydra.core.config_store import ConfigStore
+
+from hydraflow.context import log_run
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class MySQLConfig:
+    host: str = "localhost"
+    port: int = 3306
+
+
+cs = ConfigStore.instance()
+cs.store(name="config", node=MySQLConfig)
+
+
+@hydra.main(version_base=None, config_name="config")
+def app(cfg: MySQLConfig):
+    mlflow.set_experiment("log_run")
+    with mlflow.start_run(), log_run(cfg) as info:
+        log.info(f"START, {cfg.host}, {cfg.port} ")
+        mlflow.log_text(info.artifact_dir.as_posix(), "artifact_dir.txt")
+        mlflow.log_text(info.output_dir.as_posix(), "output_dir.txt")
+        (info.artifact_dir / "a.txt").write_text("abc")
+        log.info("END")
+
+
+if __name__ == "__main__":
+    app()

hydraflow-0.1.0/tests/test_config.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, field
+
+import pytest
+from omegaconf import OmegaConf
+
+
+def test_iter_params():
+    from hydraflow.config import iter_params
+
+    conf = OmegaConf.create({"k": "v", "l": [1, {"a": "1", "b": "2", 3: "c"}]})
+    it = iter_params(conf)
+    assert next(it) == ("k", "v")
+    assert next(it) == ("l.0", 1)
+    assert next(it) == ("l.1.a", "1")
+    assert next(it) == ("l.1.b", "2")
+    assert next(it) == ("l.1.3", "c")
+
+
+@dataclass
+class Size:
+    x: int = 1
+    y: int = 2
+
+
+@dataclass
+class Db:
+    name: str = "name"
+    port: int = 100
+
+
+@dataclass
+class Store:
+    items: list[str] = field(default_factory=lambda: ["a", "b"])
+
+
+@dataclass
+class Config:
+    size: Size = field(default_factory=Size)
+    db: Db = field(default_factory=Db)
+    store: Store = field(default_factory=Store)
+
+
+@pytest.fixture
+def cfg():
+    return Config()
+
+
+def test_config(cfg: Config):
+    assert cfg.size.x == 1
+    assert cfg.db.name == "name"
+    assert cfg.store.items == ["a", "b"]
+
+
+def test_iter_params_from_config(cfg):
+    from hydraflow.config import iter_params
+
+    it = iter_params(cfg)
+    assert next(it) == ("size.x", 1)
+    assert next(it) == ("size.y", 2)
+    assert next(it) == ("db.name", "name")
+    assert next(it) == ("db.port", 100)
+    assert next(it) == ("store.items.0", "a")
+    assert next(it) == ("store.items.1", "b")

hydraflow-0.1.0/tests/test_log_run.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import mlflow
+import pytest
+from mlflow.artifacts import download_artifacts
+from mlflow.entities.run import Run
+
+
+@pytest.fixture
+def runs(monkeypatch, tmp_path):
+    file = Path("tests/log_run.py").absolute()
+    monkeypatch.chdir(tmp_path)
+
+    subprocess.check_call(
+        [sys.executable, file.as_posix(), "-m", "host=x,y", "port=1,2"]
+    )
+
+    mlflow.set_experiment("log_run")
+    runs = mlflow.search_runs(output_format="list")
+    assert len(runs) == 4
+    assert isinstance(runs, list)
+    yield runs
+
+
+@pytest.fixture(params=range(4))
+def run_id(runs, request):
+    run = runs[request.param]
+    assert isinstance(run, Run)
+    return run.info.run_id
+
+
+def test_output(run_id: str):
+    path = download_artifacts(run_id=run_id, artifact_path="a.txt")
+    text = Path(path).read_text()
+    assert text == "abc"
+
+
+def read_log(run_id: str) -> str:
+    path = download_artifacts(run_id=run_id, artifact_path="log_run.log")
+    text = Path(path).read_text()
+    assert "START" in text
+    assert "END" in text
+    return text
+
+
+def test_load_config(run_id: str):
+    from hydraflow.run import load_config
+
+    log = read_log(run_id)
+    host, port = log.splitlines()[0].split("START,")[-1].split(",")
+
+    cfg = load_config(run_id)
+    assert cfg.host == host.strip()
+    assert cfg.port == int(port)
+
+
+def test_load_config_err(run_id: str):
+    from hydraflow.run import load_config
+
+    assert not load_config(run_id, "a")

hydraflow-0.1.0/tests/test_run.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import mlflow
+import pytest
+from mlflow.entities import Run
+from pandas import DataFrame, Series
+
+
+@pytest.fixture
+def _runs(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+
+    mlflow.set_experiment("test_run")
+    for x in range(6):
+        with mlflow.start_run(run_name=f"{x}"):
+            mlflow.log_param("p", x)
+            mlflow.log_param("q", 0)
+            mlflow.log_text(f"{x}", "abc.txt")
+
+    x = mlflow.search_runs(output_format="list", order_by=["params.p"])
+    assert isinstance(x, list)
+    assert isinstance(x[0], Run)
+    y = mlflow.search_runs(output_format="pandas", order_by=["params.p"])
+    assert isinstance(y, DataFrame)
+    return x, y
+
+
+@pytest.fixture(params=["list", "pandas"])
+def runs(_runs: tuple[list[Run], DataFrame], request: pytest.FixtureRequest):
+    if request.param == "list":
+        return _runs[0]
+
+    return _runs[1]
+
+
+@pytest.fixture
+def runs_list(_runs: tuple[list[Run], DataFrame], request: pytest.FixtureRequest):
+    return _runs[0]
+
+
+@pytest.fixture
+def runs_df(_runs: tuple[list[Run], DataFrame], request: pytest.FixtureRequest):
+    return _runs[1]
+
+
+def test_filter_by_config_one(runs: list[Run] | DataFrame):
+    from hydraflow.run import filter_by_config
+
+    assert len(runs) == 6
+    x = filter_by_config(runs, {"p": 1})
+    assert len(x) == 1
+
+
+def test_filter_by_config_all(runs: list[Run] | DataFrame):
+    from hydraflow.run import filter_by_config
+
+    assert len(runs) == 6
+    x = filter_by_config(runs, {"q": 0})
+    assert len(x) == 6
+
+
+def test_get_by_config_list(runs_list: list[Run]):
+    from hydraflow.run import get_by_config
+
+    run = get_by_config(runs_list, {"p": 4})
+    assert isinstance(run, Run)
+    assert run.data.params["p"] == "4"
+
+
+def test_get_by_config_df(runs_df: DataFrame):
+    from hydraflow.run import get_by_config
+
+    run = get_by_config(runs_df, {"p": 2})
+    assert isinstance(run, Series)
+    assert run["params.p"] == "2"
+
+
+def test_get_by_config_error(runs: list[Run] | DataFrame):
+    from hydraflow.run import get_by_config
+
+    with pytest.raises(ValueError):
+        get_by_config(runs, {"q": 0})
+
+
+def test_drop_unique_params(runs_df):
+    from hydraflow.run import drop_unique_params
+
+    assert "params.p" in runs_df
+    assert "params.q" in runs_df
+    df = drop_unique_params(runs_df)
+    assert "params.p" in df
+    assert "params.q" not in df
+
+
+def test_get_param_names(runs_df: DataFrame):
+    from hydraflow.run import get_param_names
+
+    params = get_param_names(runs_df)
+    assert len(params) == 2
+    assert "p" in params
+    assert "q" in params
+
+
+def test_get_param_dict(runs_df: DataFrame):
+    from hydraflow.run import get_param_dict
+
+    params = get_param_dict(runs_df)
+    assert len(params["p"]) == 6
+    assert len(params["q"]) == 1
+
+
+@pytest.mark.parametrize("i", range(6))
+def test_get_run_id(i: int, runs_list: list[Run], runs_df: DataFrame):
+    from hydraflow.run import get_run_id
+
+    assert get_run_id(runs_list[i]) == get_run_id(runs_df.iloc[i])
+    assert get_run_id(runs_list[i]) == get_run_id(runs_df.iloc[i])
+
+    x = get_run_id(runs_list[i])
+    assert get_run_id(x) == runs_list[i].info.run_id
+
+
+@pytest.mark.parametrize("i", range(6))
+@pytest.mark.parametrize("path", [None, "a"])
+def test_get_artifact_uri(i: int, path, runs_list: list[Run], runs_df: DataFrame):
+    from hydraflow.run import get_artifact_uri, get_run_id
+
+    x = get_run_id(runs_list[i])
+    y = get_artifact_uri(runs_list[i], path)
+    assert get_artifact_uri(x, path) == y
+    assert get_artifact_uri(runs_df.iloc[i], path) == y
+
+
+@pytest.mark.parametrize("i", range(6))
+def test_chdir_artifact_list(i: int, runs_list: list[Run]):
+    from hydraflow.context import chdir_artifact
+
+    with chdir_artifact(runs_list[i]):
+        assert Path("abc.txt").read_text() == f"{i}"
+
+    assert not Path("abc.txt").exists()
+
+
+def test_hydra_output_dir_error(runs_list: list[Run]):
+    from hydraflow.run import get_hydra_output_dir
+
+    with pytest.raises(FileNotFoundError):
+        get_hydra_output_dir(runs_list[0])
+
+
+@pytest.fixture
+def df():
+    return DataFrame(
+        {
+            "a": [0, 0, 0, 0],
+            "params.x": [1, 1, 2, 2],
+            "params.y": [1, 2, 1, 2],
+            "params.z": [1, 1, 1, 1],
+        },
+    )
+
+
+def test_unique_params(df):
+    from hydraflow.run import drop_unique_params
+
+    df = drop_unique_params(df)
+    assert len(df.columns) == 3
+    assert "a" in df
+    assert "params.x" in df
+    assert "params.z" not in df
+
+
+def test_param_names(df):
+    from hydraflow.run import get_param_names
+
+    names = get_param_names(df)
+    assert names == ["x", "y", "z"]
+
+
+def test_param_dict(df):
+    from hydraflow.run import get_param_dict
+
+    x = get_param_dict(df)
+    assert x["x"] == [1, 2]
+    assert x["y"] == [1, 2]
+    assert x["z"] == [1]

hydraflow-0.1.0/tests/test_version.py

@@ -0,0 +1,5 @@
+from importlib.metadata import version
+
+
+def test_version():
+    assert version("hydraflow").count(".") == 2

hydraflow-0.1.0/tests/test_watch.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+
+
+@pytest.mark.parametrize("dir", [".", Path])
+def test_watch(dir, monkeypatch, tmp_path):
+    from hydraflow.context import watch
+
+    file = Path("tests/watch.py").absolute()
+    monkeypatch.chdir(tmp_path)
+
+    lines = []
+
+    def func(path: Path) -> None:
+        k, t = path.read_text().split(" ")
+        lines.append([int(k), float(t), time.time(), path.name])
+
+    with watch(func, dir if isinstance(dir, str) else dir()):
+        subprocess.check_call(["python", file])
+
+    for k in range(4):
+        assert lines[k][0] == k
+        assert lines[k][-1] == f"{k}.txt"
+        assert 0 <= lines[k][2] - lines[k][1] < 0.05

hydraflow-0.1.0/tests/watch.py

@@ -0,0 +1,19 @@
+import sys
+import time
+from pathlib import Path
+
+
+def run():
+    for k in range(2):
+        print(k, time.time(), flush=True)
+        Path(f"{k}.txt").write_text(f"{k} {time.time()}")
+        time.sleep(1)
+
+    for k in range(2, 4):
+        print(k, time.time(), file=sys.stderr, flush=True)
+        Path(f"{k}.txt").write_text(f"{k} {time.time()}")
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    run()