liblaf-cherries 0.0.9__py3-none-any.whl → 0.0.10__py3-none-any.whl

liblaf/cherries/__init__.pyi

@@ -1,36 +1,87 @@
-from . import git, integration, plugin, utils
+from . import info, pathutils, plugin, presets, utils
 from ._config import BaseConfig
-from ._env import ENV_PREFIX, env
-from ._experiment import Experiment, current_experiment, set_current_experiment
-from ._main import main
 from ._run import run
-from ._start import end, start
-from .git import entrypoint
-from .integration import Backend, BackendNeptune, backend_factory
-from .plugin import Plugin, PluginGit, PluginLogging, PluginRestic, default_plugins
+from .pathutils import (
+    as_os_path,
+    as_path,
+    as_posix,
+    config,
+    data,
+    entrypoint,
+    exp_dir,
+    git_root,
+    git_root_safe,
+    inputs,
+    outputs,
+    params,
+    path,
+    src,
+)
+from .plugin import (
+    End,
+    LogArtifact,
+    LogArtifacts,
+    LoggingEnd,
+    LoggingStart,
+    LogMetric,
+    LogParam,
+    Plugin,
+    Run,
+    Start,
+    end,
+    log_artifact,
+    log_artifacts,
+    log_input,
+    log_inputs,
+    log_metric,
+    log_output,
+    log_outputs,
+    log_param,
+    set_tag,
+    start,
+)
 
 __all__ = [
-    "ENV_PREFIX",
-    "Backend",
-    "BackendNeptune",
     "BaseConfig",
-    "Experiment",
+    "End",
+    "LogArtifact",
+    "LogArtifacts",
+    "LogMetric",
+    "LogParam",
+    "LoggingEnd",
+    "LoggingStart",
     "Plugin",
-    "PluginGit",
-    "PluginLogging",
-    "PluginRestic",
-    "backend_factory",
-    "current_experiment",
-    "default_plugins",
+    "Run",
+    "Start",
+    "as_os_path",
+    "as_path",
+    "as_posix",
+    "config",
+    "data",
     "end",
     "entrypoint",
-    "env",
-    "git",
-    "integration",
-    "main",
+    "exp_dir",
+    "git_root",
+    "git_root_safe",
+    "info",
+    "inputs",
+    "log_artifact",
+    "log_artifacts",
+    "log_input",
+    "log_inputs",
+    "log_metric",
+    "log_output",
+    "log_outputs",
+    "log_param",
+    "outputs",
+    "params",
+    "path",
+    "pathutils",
     "plugin",
+    "presets",
     "run",
-    "set_current_experiment",
+    "set_tag",
+    "src",
     "start",
     "utils",
 ]

liblaf/cherries/_run.py

@@ -1,26 +1,31 @@
-from collections.abc import Sequence
-from typing import Protocol, get_type_hints
-
-from liblaf import cherries
-
-
-class MainFunction[T: cherries.BaseConfig](Protocol):
-    def __call__(self, cfg: T) -> None: ...
-
-
-def run[T: cherries.BaseConfig](
-    main: MainFunction[T],
-    *,
-    backend: cherries.Backend | None = None,
-    enabled: bool | None = None,
-    plugins: Sequence[cherries.Plugin] | None = None,
-) -> None:
-    exp: cherries.Experiment = cherries.start(
-        backend=backend, enabled=enabled, plugins=plugins
-    )
-    type_hints: dict[str, type[T]] = get_type_hints(main)
-    cls: type[T] = next(iter(type_hints.values()))
-    cfg: T = cls()
-    exp.log_other("cherries/config", cfg)
-    main(cfg)
-    exp.end()
+from collections.abc import Callable
+from typing import get_type_hints
+
+import pydantic
+
+from liblaf.cherries import pathutils as _path
+from liblaf.cherries import plugin, presets
+
+
+def run[C: pydantic.BaseModel, T](main: Callable[[C], T]) -> T:
+    run: plugin.Run = start()
+    type_hints: dict[str, type[C]] = get_type_hints(main)
+    cls: type[C] = next(iter(type_hints.values()))
+    cfg: C = cls()
+    run.log_param("cherries.config", cfg.model_dump(mode="json"))
+    ret: T = main(cfg)
+    run.end()
+    return ret
+
+
+def start() -> plugin.Run:
+    run: plugin.Run = presets.default()
+    run.start()
+    run.log_src(_path.entrypoint(absolute=True))
+    run.set_tag("cherries.entrypoint", _path.entrypoint(absolute=False))
+    run.set_tag("cherries.exp-dir", _path.exp_dir(absolute=False))
+    return plugin.run
+
+
+def end() -> None:
+    plugin.run.end()

liblaf/cherries/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.0.9'
-__version_tuple__ = version_tuple = (0, 0, 9)
+__version__ = version = '0.0.10'
+__version_tuple__ = version_tuple = (0, 0, 10)

liblaf/cherries/info/__init__.pyi

@@ -0,0 +1,11 @@
+from ._exp_name import exp_name
+from ._git import git_auto_commit, git_branch, git_commit_sha, git_commit_url, git_info
+
+__all__ = [
+    "exp_name",
+    "git_auto_commit",
+    "git_branch",
+    "git_commit_sha",
+    "git_commit_url",
+    "git_info",
+]

liblaf/cherries/info/_exp_name.py

@@ -0,0 +1,19 @@
+import git.exc
+from environs import env
+
+from liblaf import grapes
+
+from ._git import git_info
+
+
+def exp_name() -> str:
+    if name := env.str("LIBLAF_CHERRIES_EXPERIMENT_NAME", "").strip():
+        return name
+    if name := env.str("MLFLOW_EXPERIMENT_NAME", "").strip():
+        return name
+    try:
+        info: grapes.git.GitInfo = git_info()
+    except git.exc.InvalidGitRepositoryError:
+        return "Default"
+    else:
+        return info.repo

liblaf/cherries/info/_git.py

@@ -0,0 +1,49 @@
+import subprocess as sp
+
+import git
+
+from liblaf import grapes
+from liblaf.cherries import pathutils as _path
+
+
+def git_auto_commit(
+    message: str = "chore(cherries): auto commit", *, dry_run: bool = False
+) -> None:
+    repo: git.Repo = _repo()
+    if not repo.is_dirty(untracked_files=True):
+        return
+    repo.git.add(all=True, dry_run=dry_run)
+    sp.run(["git", "status"], check=False)
+    if dry_run:
+        return
+    repo.git.commit(message=message)
+
+
+def git_branch() -> str:
+    repo: git.Repo = _repo()
+    return repo.active_branch.name
+
+
+def git_commit_sha() -> str:
+    repo: git.Repo = _repo()
+    return repo.head.commit.hexsha
+
+
+def git_commit_url(sha: str | None = None) -> str:
+    if sha is None:
+        sha = git_commit_sha()
+    info: grapes.git.GitInfo = git_info()
+    if info.platform == "github":
+        return f"https://github.com/{info.owner}/{info.repo}/commit/{sha}"
+    raise NotImplementedError
+
+
+def git_info() -> grapes.git.GitInfo:
+    info: grapes.git.GitInfo = grapes.git.info(
+        _path.entrypoint(absolute=True), search_parent_directories=True
+    )
+    return info
+
+
+def _repo() -> git.Repo:
+    return git.Repo(_path.entrypoint(absolute=True), search_parent_directories=True)

liblaf/cherries/pathutils/__init__.pyi

@@ -0,0 +1,20 @@
+from ._convert import as_os_path, as_path, as_posix
+from ._path import entrypoint, exp_dir, git_root, git_root_safe
+from ._special import config, data, inputs, outputs, params, path, src
+
+__all__ = [
+    "as_os_path",
+    "as_path",
+    "as_posix",
+    "config",
+    "data",
+    "entrypoint",
+    "exp_dir",
+    "git_root",
+    "git_root_safe",
+    "inputs",
+    "outputs",
+    "params",
+    "path",
+    "src",
+]

liblaf/cherries/pathutils/_convert.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from typing import overload
+
+from liblaf.cherries.typed import PathLike
+
+
+@overload
+def as_os_path(path: PathLike) -> str: ...
+@overload
+def as_os_path(path: None) -> None: ...
+def as_os_path(path: PathLike | None) -> str | None:
+    if path is None:
+        return None
+    if isinstance(path, str):
+        return path
+    return str(path)
+
+
+@overload
+def as_path(path: PathLike) -> Path: ...
+@overload
+def as_path(path: None) -> None: ...
+
+
+def as_path(path: PathLike | None) -> Path | None:
+    if path is None:
+        return None
+    return Path(path)
+
+
+@overload
+def as_posix(path: PathLike) -> str: ...
+@overload
+def as_posix(path: None) -> None: ...
+def as_posix(path: PathLike | None) -> str | None:
+    if path is None:
+        return None
+    if isinstance(path, str):
+        return path
+    return Path(path).as_posix()

liblaf/cherries/pathutils/_path.py

@@ -0,0 +1,68 @@
+import sys
+from pathlib import Path
+
+import git
+import git.exc
+from loguru import logger
+
+from liblaf.cherries import utils
+
+
+@utils.cache
+def entrypoint(*, absolute: bool = False) -> Path:
+    if absolute:
+        return _entrypoint_absolute()
+    return _entrypoint_relative()
+
+
+@utils.cache
+def exp_dir(*, absolute: bool = False) -> Path:
+    if absolute:
+        return _exp_dir_absolute()
+    return _exp_dir_relative()
+
+
+@utils.cache
+def git_root() -> Path:
+    entrypoint: Path = _entrypoint_absolute()
+    repo = git.Repo(entrypoint, search_parent_directories=True)
+    return Path(repo.working_dir)
+
+
+@utils.cache
+def git_root_safe() -> Path:
+    try:
+        return git_root()
+    except git.exc.InvalidGitRepositoryError:
+        logger.warning("Not in a git repository, using current directory")
+        return _entrypoint_absolute().parent
+
+
+@utils.cache
+def _entrypoint_absolute() -> Path:
+    path = Path(sys.argv[0])
+    return path.absolute()
+
+
+@utils.cache
+def _entrypoint_relative() -> Path:
+    path: Path = _entrypoint_absolute()
+    return path.relative_to(git_root_safe())
+
+
+@utils.cache
+def _exp_dir_absolute() -> Path:
+    entrypoint: Path = _entrypoint_absolute()
+    for path in entrypoint.parents:
+        if (path / "exp.cherries.toml").is_file():
+            return path
+        if (path / "src").is_dir():
+            return path
+    return git_root_safe()
+
+
+@utils.cache
+def _exp_dir_relative() -> Path:
+    absolute: Path = _exp_dir_absolute()
+    root: Path = git_root_safe()
+    return absolute.relative_to(root)

liblaf/cherries/pathutils/_special.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+from liblaf.grapes.typed import PathLike
+
+from ._path import exp_dir
+
+
+def config(
+    path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "config"
+) -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def data(path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "data") -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def inputs(
+    path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "data/inputs"
+) -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def outputs(
+    path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "data/outputs"
+) -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def params(
+    path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "params"
+) -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def path(path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "") -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def src(path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "src") -> Path:
+    return _path(path, mkdir=mkdir, prefix=prefix)
+
+
+def _path(path: PathLike = "", *, mkdir: bool = True, prefix: PathLike = "") -> Path:
+    path = Path(path)
+    if not path.is_absolute():
+        path = exp_dir(absolute=True) / prefix / path
+    if mkdir:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    return path

liblaf/cherries/plugin/__init__.pyi

@@ -1,7 +1,73 @@
-from ._abc import Plugin
-from ._default import default_plugins
-from ._git import PluginGit
-from ._logging import PluginLogging
-from ._restic import PluginRestic
+from ._abc import (
+    End,
+    LogArtifact,
+    LogArtifacts,
+    LogMetric,
+    LogParam,
+    Plugin,
+    Start,
+)
+from ._dvc import DvcEnd, DvcLogArtifact, DvcLogArtifacts
+from ._git import GitEnd, GitStart
+from ._logging import LoggingEnd, LoggingStart
+from ._mlflow import (
+    MlflowEnd,
+    MlflowLogArtifact,
+    MlflowLogArtifacts,
+    MlflowLogMetric,
+    MlflowLogParam,
+    MlflowSetTag,
+    MlflowStart,
+)
+from ._run import (
+    Run,
+    end,
+    log_artifact,
+    log_artifacts,
+    log_input,
+    log_inputs,
+    log_metric,
+    log_output,
+    log_outputs,
+    log_param,
+    run,
+    set_tag,
+    start,
+)
 
-__all__ = ["Plugin", "PluginGit", "PluginLogging", "PluginRestic", "default_plugins"]
+__all__ = [
+    "DvcEnd",
+    "DvcLogArtifact",
+    "DvcLogArtifacts",
+    "End",
+    "GitEnd",
+    "GitStart",
+    "LogArtifact",
+    "LogArtifacts",
+    "LogMetric",
+    "LogParam",
+    "LoggingEnd",
+    "LoggingStart",
+    "MlflowEnd",
+    "MlflowLogArtifact",
+    "MlflowLogArtifacts",
+    "MlflowLogMetric",
+    "MlflowLogParam",
+    "MlflowSetTag",
+    "MlflowStart",
+    "Plugin",
+    "Run",
+    "Start",
+    "end",
+    "log_artifact",
+    "log_artifacts",
+    "log_input",
+    "log_inputs",
+    "log_metric",
+    "log_output",
+    "log_outputs",
+    "log_param",
+    "run",
+    "set_tag",
+    "start",
+]

liblaf/cherries/plugin/_abc.py

@@ -1,31 +1,122 @@
 from __future__ import annotations
 
-import pydantic_settings as ps
+import bisect
+import functools
+import operator
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any, override
 
-from liblaf import cherries
+import attrs
+from loguru import logger
 
+from liblaf.cherries import pathutils as _path
+from liblaf.cherries.typed import PathLike
 
-class Plugin(ps.BaseSettings):
-    enabled: bool = True
-    priority: float = 0.0
 
-    def pre_start(self) -> None:
-        if self.enabled:
-            self._pre_start()
+@functools.total_ordering
+@attrs.define
+class Plugin[**P, T]:
+    priority: int = attrs.field(default=0, kw_only=True, eq=True, order=True)
+    _children: list[Plugin] = attrs.field(
+        factory=list, eq=False, order=False, alias="children"
+    )
 
-    def post_start(self, run: cherries.Experiment) -> None:
-        if self.enabled:
-            self._post_start(run)
+    def __attrs_post_init__(self) -> None:
+        self._children.sort(key=operator.attrgetter("priority"))
 
-    def pre_end(self, run: cherries.Experiment) -> None:
-        if self.enabled:
-            self._pre_end(run)
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        ret: T | None = None
+        for child in self._children:
+            try:
+                ret = child(*args, **kwargs)
+            except BaseException as err:
+                if isinstance(err, (KeyboardInterrupt, SystemExit)):
+                    raise
+                logger.exception(child)
+        return ret  # pyright: ignore[reportReturnType]
 
-    def post_end(self, run: cherries.Experiment) -> None:
-        if self.enabled:
-            self._post_end(run)
+    def __lt__(self, other: Plugin) -> bool:
+        if not isinstance(other, Plugin):
+            return NotImplemented
+        return self.priority < other.priority
 
-    def _pre_start(self) -> None: ...
-    def _post_start(self, run: cherries.Experiment) -> None: ...
-    def _pre_end(self, run: cherries.Experiment) -> None: ...
-    def _post_end(self, run: cherries.Experiment) -> None: ...
+    def __eq__(self, other: Plugin) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
+        if not isinstance(other, Plugin):
+            return NotImplemented
+        return self.priority == other.priority
+
+    @property
+    def children(self) -> list[Plugin]:
+        return self._children
+
+    def add(self, *child: Plugin) -> None:
+        for c in child:
+            bisect.insort(self._children, c, key=operator.attrgetter("priority"))
+
+    def extend(self, children: Iterable[Plugin]) -> None:
+        self.add(*children)
+
+    def remove(self, child: Plugin) -> None:
+        self._children.remove(child)
+
+
+@attrs.define
+class End(Plugin):
+    @override
+    def __call__(self) -> None:
+        return super().__call__()
+
+
+@attrs.define
+class LogArtifact(Plugin):
+    @override
+    def __call__(
+        self, local_path: PathLike, artifact_path: PathLike | None = None, **kwargs
+    ) -> Path:
+        ret: Path | None = super().__call__(local_path, artifact_path, **kwargs)
+        if ret is None:
+            ret = _path.as_path(local_path)
+        return ret
+
+
+@attrs.define
+class LogArtifacts(Plugin):
+    @override
+    def __call__(
+        self, local_dir: PathLike, artifact_path: PathLike | None = None, **kwargs
+    ) -> Path:
+        ret: Path | None = super().__call__(local_dir, artifact_path, **kwargs)
+        if ret is None:
+            ret = _path.as_path(local_dir)
+        return ret
+
+
+@attrs.define
+class LogMetric(Plugin):
+    @override
+    def __call__(
+        self, key: str, value: float, step: int | None = None, **kwargs
+    ) -> None:
+        return super().__call__(key, value, step, **kwargs)
+
+
+@attrs.define
+class LogParam(Plugin):
+    @override
+    def __call__(self, key: str, value: Any, **kwargs) -> None:
+        return super().__call__(key, value, **kwargs)
+
+
+@attrs.define
+class SetTag(Plugin):
+    @override
+    def __call__(self, key: str, value: Any, **kwargs) -> None:
+        return super().__call__(key, value, **kwargs)
+
+
+@attrs.define
+class Start(Plugin):
+    @override
+    def __call__(self) -> None:
+        return super().__call__()