liblaf-cherries 0.0.0__py3-none-any.whl → 0.0.1__py3-none-any.whl

liblaf/cherries/__init__.pyi

@@ -1,23 +1,34 @@
 from . import git, integration, plugin, utils
-from ._start import current_run, end, set_current_run, start
+from ._config import BaseConfig
+from ._env import ENV_PREFIX, env
+from ._experiment import Experiment, current_experiment, set_current_experiment
+from ._main import main
+from ._start import end, start
 from .git import entrypoint
-from .integration import Run, RunNeptune
-from .plugin import Plugin, PluginGit, PluginLogging, default_plugins
+from .integration import Backend, BackendNeptune, backend_factory
+from .plugin import Plugin, PluginGit, PluginLogging, PluginRestic, default_plugins
 
 __all__ = [
+    "ENV_PREFIX",
+    "Backend",
+    "BackendNeptune",
+    "BaseConfig",
+    "Experiment",
     "Plugin",
     "PluginGit",
     "PluginLogging",
-    "Run",
-    "RunNeptune",
-    "current_run",
+    "PluginRestic",
+    "backend_factory",
+    "current_experiment",
     "default_plugins",
     "end",
     "entrypoint",
+    "env",
     "git",
     "integration",
+    "main",
     "plugin",
-    "set_current_run",
+    "set_current_experiment",
     "start",
     "utils",
 ]

liblaf/cherries/_config.py

@@ -0,0 +1,22 @@
+import pydantic_settings as ps
+
+
+class BaseConfig(ps.BaseSettings):
+    model_config = ps.SettingsConfigDict(cli_parse_args=True, yaml_file="params.yaml")
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: type[ps.BaseSettings],
+        init_settings: ps.PydanticBaseSettingsSource,
+        env_settings: ps.PydanticBaseSettingsSource,
+        dotenv_settings: ps.PydanticBaseSettingsSource,
+        file_secret_settings: ps.PydanticBaseSettingsSource,
+    ) -> tuple[ps.PydanticBaseSettingsSource, ...]:
+        return (
+            init_settings,
+            env_settings,
+            dotenv_settings,
+            file_secret_settings,
+            ps.YamlConfigSettingsSource(settings_cls),
+        )

liblaf/cherries/_env.py

@@ -0,0 +1,4 @@
+from environs import Env
+
+ENV_PREFIX: str = "LIBLAF_CHERRIES_"
+env = Env(prefix=ENV_PREFIX)

liblaf/cherries/_experiment.py

@@ -0,0 +1,111 @@
+import atexit
+import dataclasses
+import datetime
+import os
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from environs import env
+from loguru import logger
+
+from liblaf import cherries
+
+
+@dataclasses.dataclass(kw_only=True)
+class Experiment:
+    backend: cherries.Backend = dataclasses.field(
+        default_factory=cherries.backend_factory
+    )
+    enabled: bool = dataclasses.field(
+        default_factory=lambda: env.bool("LIBLAF_CHERRIES_ENABLED", True)
+    )
+    plugins: Sequence[cherries.Plugin] = dataclasses.field(
+        default_factory=cherries.default_plugins
+    )
+
+    @property
+    def entrypoint(self) -> Path:
+        return self.backend.entrypoint
+
+    @property
+    def id(self) -> str:
+        return self.backend.id
+
+    @property
+    def name(self) -> str:
+        return self.backend.name
+
+    @property
+    def start_time(self) -> datetime.datetime:
+        return self.backend.start_time
+
+    @property
+    def url(self) -> str:
+        return self.backend.url
+
+    def start(self) -> None:
+        if not self.enabled:
+            return
+        self.plugins = sorted(self.plugins, key=lambda plugin: plugin.priority)
+        for plugin in self.plugins:
+            plugin.pre_start()
+        self.backend.start()
+        cherries.set_current_experiment(self)
+        for plugin in self.plugins:
+            plugin.post_start(self)
+        self.log_other("cherries/entrypoint", self.entrypoint)
+        self.log_other("cherries/start_time", self.start_time)
+        atexit.register(self.end)
+
+    def end(self) -> None:
+        if not self.enabled:
+            return
+        for plugin in reversed(self.plugins):
+            plugin.pre_end(self)
+        self.backend.end()
+        for plugin in reversed(self.plugins):
+            plugin.post_end(self)
+        self.enabled = False  # prevent `end()` from being called multiple times
+
+    def log_metric(
+        self,
+        key: str,
+        value: float,
+        *,
+        step: float | None = None,
+        timestamp: float | None = None,
+        **kwargs,
+    ) -> None:
+        if not self.enabled:
+            return
+        logger.opt(depth=1).debug("{}: {}", key, value)
+        self.backend.log_metric(key, value, step=step, timestamp=timestamp, **kwargs)
+
+    def log_other(self, key: str, value: Any, **kwargs) -> None:
+        if not self.enabled:
+            return
+        logger.opt(depth=1).info("{}: {}", key, value)
+        self.backend.log_other(key, value, **kwargs)
+
+    def upload_file(self, key: str, path: str | os.PathLike[str], **kwargs) -> None:
+        if not self.enabled:
+            return
+        path = Path(path)
+        logger.opt(depth=1).info("Uploading file: {}", path)
+        self.backend.upload_file(key, path, **kwargs)
+
+
+_current_experiment: Experiment | None = None
+
+
+def current_experiment() -> Experiment:
+    global _current_experiment  # noqa: PLW0603
+    if _current_experiment is None:
+        _current_experiment = Experiment()
+    return _current_experiment
+
+
+def set_current_experiment(experiment: Experiment) -> None:
+    global _current_experiment  # noqa: PLW0603
+    _current_experiment = experiment

liblaf/cherries/_main.py

@@ -0,0 +1,38 @@
+import functools
+import inspect
+from collections.abc import Callable, Sequence
+from typing import ParamSpec, TypeVar
+
+from liblaf import cherries
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+
+def main(
+    *,
+    backend: cherries.Backend | None = None,
+    enabled: bool | None = None,
+    plugins: Sequence[cherries.Plugin] | None = None,
+) -> Callable[[Callable[_P, _T]], Callable[_P, _T]]:
+    def wrapper(fn: Callable[_P, _T]) -> Callable[_P, _T]:
+        @functools.wraps(fn)
+        def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+            exp: cherries.Experiment = cherries.start(
+                backend=backend, enabled=enabled, plugins=plugins
+            )
+            sig: inspect.Signature = inspect.signature(fn)
+            bound_args: inspect.BoundArguments = sig.bind(*args, **kwargs)
+            if len(bound_args.arguments) == 1:
+                exp.log_other(
+                    "cherries/config", next(iter(bound_args.arguments.values()))
+                )
+            elif len(bound_args.arguments) > 1:
+                exp.log_other("cherries/args", bound_args.arguments)
+            ret: _T = fn(*args, **kwargs)
+            exp.end()
+            return ret
+
+        return wrapped
+
+    return wrapper

liblaf/cherries/_start.py

@@ -1,48 +1,26 @@
 from collections.abc import Sequence
 
-from liblaf import cherries
-
-_current_run: cherries.Run | None = None
-
-
-def current_run() -> cherries.Run | None:
-    return _current_run
+from environs import Env
 
-
-def set_current_run(run: cherries.Run) -> None:
-    global _current_run  # noqa: PLW0603
-    _current_run = run
+from liblaf import cherries
 
 
 def start(
-    backend: type[cherries.Run],
-    plugins: Sequence[cherries.Plugin] = [],
     *,
-    enabled: bool = True,
-) -> cherries.Run | None:
-    if not enabled:
-        return None
-    plugins = sorted(plugins, key=lambda plugin: plugin.priority)
-    for plugin in plugins:
-        if plugin.enabled:
-            plugin.pre_start()
-    run: cherries.Run = backend()
-    run.plugins = plugins
-    set_current_run(run)
-    for plugin in plugins:
-        if plugin.enabled:
-            plugin.post_start(run)
-    return run
-
-
-def end(run: cherries.Run | None = None) -> None:
-    run = run or current_run()
-    if run is None:
-        return
-    for plugin in reversed(run.plugins):
-        if plugin.enabled:
-            plugin.pre_end(run)
-    run.end()
-    for plugin in reversed(run.plugins):
-        if plugin.enabled:
-            plugin.post_end(run)
+    backend: cherries.Backend | None = None,
+    enabled: bool | None = None,
+    plugins: Sequence[cherries.Plugin] | None = None,
+) -> cherries.Experiment:
+    backend = backend or cherries.backend_factory()
+    if enabled is None:
+        enabled = Env().bool("LIBLAF_CHERRIES_ENABLED", True)
+    if plugins is None:
+        plugins = cherries.default_plugins()
+    exp = cherries.Experiment(backend=backend, enabled=enabled, plugins=plugins)
+    exp.start()
+    return exp
+
+
+def end() -> None:
+    exp: cherries.Experiment = cherries.current_experiment()
+    exp.end()

liblaf/cherries/integration/__init__.pyi

@@ -1,4 +1,5 @@
-from ._abc import Run, current_run, set_current_run
-from ._neptune import RunNeptune
+from ._backend import Backend
+from ._factory import backend_factory
+from ._neptune import BackendNeptune
 
-__all__ = ["Run", "RunNeptune", "current_run", "set_current_run"]
+__all__ = ["Backend", "BackendNeptune", "backend_factory"]

liblaf/cherries/integration/_backend.py

@@ -0,0 +1,53 @@
+import datetime
+import functools
+from pathlib import Path
+from typing import Any
+
+import pydantic_settings as ps
+
+from liblaf import cherries
+
+
+class Backend(ps.BaseSettings):
+    model_config = ps.SettingsConfigDict(
+        frozen=True, env_prefix=cherries.ENV_PREFIX + "DUMMY_"
+    )
+    enabled: bool = True
+
+    @property
+    def backend(self) -> str:
+        return "dummy"
+
+    @functools.cached_property
+    def entrypoint(self) -> Path:
+        return cherries.entrypoint()
+
+    @property
+    def id(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError
+
+    @functools.cached_property
+    def start_time(self) -> datetime.datetime:
+        return datetime.datetime.now().astimezone()
+
+    @property
+    def url(self) -> str:
+        raise NotImplementedError
+
+    def start(self) -> None: ...
+    def end(self) -> None: ...
+    def log_metric(
+        self,
+        key: str,
+        value: float,
+        *,
+        step: float | None = None,
+        timestamp: float | None = None,
+        **kwargs,
+    ) -> None: ...
+    def log_other(self, key: str, value: Any, **kwargs) -> None: ...
+    def upload_file(self, key: str, path: Path, **kwargs) -> None: ...

liblaf/cherries/integration/_factory.py

@@ -0,0 +1,13 @@
+from liblaf import cherries
+
+
+def backend_factory(backend: str | None = None) -> cherries.Backend:
+    backend = backend or cherries.env.str("BACKEND", "dummy")
+    match backend:
+        case "neptune":
+            return cherries.BackendNeptune()
+        case "dummy":
+            return cherries.Backend()
+        case _:
+            msg: str = f"Unknown backend: {backend}"
+            raise ValueError(msg)

liblaf/cherries/integration/_neptune.py

@@ -1,13 +1,21 @@
-import datetime
+import os
 from pathlib import Path
+from typing import Any
 
 import neptune
 import neptune.common.exceptions
+import neptune.utils
+import pydantic
+import pydantic_settings as ps
 
 from liblaf import cherries
 
 
-class RunNeptune(cherries.Run[neptune.Run]):
+class BackendNeptune(cherries.Backend):
+    model_config = ps.SettingsConfigDict(frozen=True, env_prefix="NEPTUNE_")
+    monitoring_namespace: str | None = None
+    _backend: neptune.Run = pydantic.PrivateAttr()
+
     @property
     def backend(self) -> str:
         return "neptune"
@@ -24,30 +32,35 @@ class RunNeptune(cherries.Run[neptune.Run]):
     def url(self) -> str:
         return self._backend.get_url()
 
-    def _start(self) -> neptune.Run:
-        return neptune.init_run()
+    def start(self) -> None:
+        neptune.common.exceptions.STYLES.update(neptune.common.exceptions.EMPTY_STYLES)
+        self._backend = neptune.init_run(monitoring_namespace=self.monitoring_namespace)
 
-    def _end(self) -> None:
-        return self._backend.stop()
+    def end(self) -> None:
+        self._backend.stop()
 
-    def _log_metric(
+    def log_metric(
         self,
         key: str,
         value: float,
         *,
         step: float | None = None,
         timestamp: float | None = None,
-        **kwargs,  # noqa: ARG002
+        **kwargs,
     ) -> None:
-        self._backend[key].append(value, step=step, timestamp=timestamp)
+        self._backend[key].append(value, step=step, timestamp=timestamp, **kwargs)
+
+    def log_other(self, key: str, value: Any, **kwargs) -> None:
+        value = stringify_unsupported(value)
+        self._backend[key].assign(value, **kwargs)
+
+    def upload_file(self, key: str, path: Path, **kwargs) -> None:
+        return self._backend[key].upload(str(path), **kwargs)
 
-    def _log_other(
-        self,
-        key: str,
-        value: bool | float | str | datetime.datetime,
-        **kwargs,  # noqa: ARG002
-    ) -> None:
-        self._backend[key] = value
 
-    def _upload_file(self, key: str, path: Path, **kwargs) -> None:
-        return self._backend[key].upload(path, **kwargs)
+def stringify_unsupported(value: Any) -> Any:
+    if isinstance(value, pydantic.BaseModel):
+        return value.model_dump()
+    if isinstance(value, os.PathLike):
+        return str(value)
+    return value

liblaf/cherries/plugin/__init__.pyi

@@ -2,5 +2,6 @@ from ._abc import Plugin
 from ._default import default_plugins
 from ._git import PluginGit
 from ._logging import PluginLogging
+from ._restic import PluginRestic
 
-__all__ = ["Plugin", "PluginGit", "PluginLogging", "default_plugins"]
+__all__ = ["Plugin", "PluginGit", "PluginLogging", "PluginRestic", "default_plugins"]

liblaf/cherries/plugin/_abc.py

@@ -13,19 +13,19 @@ class Plugin(ps.BaseSettings):
         if self.enabled:
             self._pre_start()
 
-    def post_start(self, run: cherries.Run) -> None:
+    def post_start(self, run: cherries.Experiment) -> None:
         if self.enabled:
             self._post_start(run)
 
-    def pre_end(self, run: cherries.Run) -> None:
+    def pre_end(self, run: cherries.Experiment) -> None:
         if self.enabled:
             self._pre_end(run)
 
-    def post_end(self, run: cherries.Run) -> None:
+    def post_end(self, run: cherries.Experiment) -> None:
         if self.enabled:
             self._post_end(run)
 
     def _pre_start(self) -> None: ...
-    def _post_start(self, run: cherries.Run) -> None: ...
-    def _pre_end(self, run: cherries.Run) -> None: ...
-    def _post_end(self, run: cherries.Run) -> 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: ...

liblaf/cherries/plugin/_default.py

@@ -2,4 +2,8 @@ from liblaf import cherries
 
 
 def default_plugins() -> list[cherries.Plugin]:
-    return [cherries.plugin.PluginLogging(), cherries.plugin.PluginGit()]
+    return [
+        cherries.plugin.PluginLogging(),
+        cherries.plugin.PluginGit(),
+        cherries.plugin.PluginRestic(),
+    ]

liblaf/cherries/plugin/_git.py

@@ -5,7 +5,7 @@ from liblaf import cherries
 
 
 class PluginGit(cherries.Plugin):
-    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_GIT_")
+    model_config = ps.SettingsConfigDict(env_prefix=cherries.ENV_PREFIX + "GIT_")
     auto_commit: bool = True
     auto_commit_message: str = cherries.git.DEFAULT_COMMIT_MESSAGE
 
@@ -13,7 +13,7 @@ class PluginGit(cherries.Plugin):
         if self.auto_commit:
             cherries.git.commit(self.auto_commit_message)
 
-    def _post_start(self, run: cherries.Run) -> None:
+    def _post_start(self, run: cherries.Experiment) -> None:
         r = git.Repo(search_parent_directories=True)
         sha: str = r.head.commit.hexsha
         run.log_other("cherries/git/sha", sha)

liblaf/cherries/plugin/_logging.py

@@ -1,20 +1,58 @@
+import loguru
 import pydantic_settings as ps
 from loguru import logger
+from rich.logging import RichHandler
 
+# TODO: fix PLR0402
 # make pyright happy
 import liblaf.grapes as grapes  # noqa: PLR0402
 from liblaf import cherries
 
+DEFAULT_FILTER: "loguru.FilterDict" = {
+    "": "INFO",
+    "__main__": "TRACE",
+    "liblaf": "DEBUG",
+}
+DEFAULT_FILE_FILTER: "loguru.FilterDict" = {
+    **DEFAULT_FILTER,
+    "liblaf.cherries": "SUCCESS",
+}
+
 
 class PluginLogging(cherries.Plugin):
-    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_LOGGING_")
+    model_config = ps.SettingsConfigDict(env_prefix=cherries.ENV_PREFIX + "LOGGING_")
 
     def _pre_start(self) -> None:
-        grapes.init_logging()
-        logger.add("run.log", enqueue=True, mode="w")
-        logger.add("run.log.jsonl", serialize=True, enqueue=True, mode="w")
+        grapes.init_logging(
+            handlers=[
+                {
+                    "sink": RichHandler(
+                        console=grapes.logging.logging_console(),
+                        omit_repeated_times=False,
+                        markup=True,
+                        log_time_format="[%Y-%m-%d %H:%M:%S]",
+                    ),
+                    "format": "{message}",
+                    "filter": DEFAULT_FILTER,
+                    "enqueue": True,
+                },
+                {
+                    "sink": "run.log",
+                    "filter": DEFAULT_FILE_FILTER,
+                    "enqueue": True,
+                    "mode": "w",
+                },
+                {
+                    "sink": "run.log.jsonl",
+                    "filter": DEFAULT_FILE_FILTER,
+                    "serialize": True,
+                    "enqueue": True,
+                    "mode": "w",
+                },
+            ]
+        )
 
-    def _pre_end(self, run: cherries.Run) -> None:
+    def _pre_end(self, run: cherries.Experiment) -> None:
         logger.complete()
         run.upload_file("cherries/logging/run.log", "run.log")
         run.upload_file("cherries/logging/run.log.jsonl", "run.log.jsonl")

liblaf/cherries/plugin/_restic.py

@@ -1,6 +1,9 @@
+import contextlib
+import json
 import os
 import subprocess as sp
 from pathlib import Path
+from typing import Any
 
 import pydantic
 import pydantic_settings as ps
@@ -21,12 +24,12 @@ def default_config() -> Path:
 
 
 class PluginRestic(cherries.Plugin):
-    model_config = ps.SettingsConfigDict(env_prefix="LIBLAF_CHERRIES_RESTIC_")
+    model_config = ps.SettingsConfigDict(env_prefix=cherries.ENV_PREFIX + "RESTIC_")
     config: Path = pydantic.Field(default_factory=default_config)
     name: str | None = None
     dry_run: bool = False
 
-    def _pre_end(self, run: cherries.Run) -> None:
+    def _pre_end(self, run: cherries.Experiment) -> None:
         if not self.config.exists():
             logger.warning("configuration file '{}' was not found", self.config)
             return
@@ -35,11 +38,23 @@ class PluginRestic(cherries.Plugin):
             "--config",
             self.config,
             "backup",
+            "--json",
         ]
         if self.name:
             args += ["--name", self.name]
         if self.dry_run:
             args.append("--dry-run")
-        args += ["--time", run.creation_time.strftime("%Y-%m-%d %H:%M:%S")]
-        proc: sp.CompletedProcess[bytes] = sp.run(args, check=False)
-        run.log_other("cherries/restic/returncode", proc.returncode)
+        args += ["--time", run.start_time.strftime("%Y-%m-%d %H:%M:%S")]
+        proc: sp.Popen[str] = sp.Popen(
+            args, stdout=sp.PIPE, cwd=cherries.git.root(), text=True
+        )
+        assert proc.stdout is not None
+        for line_ in proc.stdout:
+            line: str = line_.rstrip()
+            logger.debug("{}", line)
+            with contextlib.suppress(json.JSONDecodeError):
+                log: dict[str, Any] = json.loads(line)
+                if log["message_type"] == "summary":
+                    run.log_other("cherries/restic", log)
+        returncode: int = proc.wait()
+        run.log_other("cherries/restic/returncode", returncode)

{liblaf_cherries-0.0.0.dist-info → liblaf_cherries-0.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liblaf-cherries
-Version: 0.0.0
+Version: 0.0.1
 Summary: Add your description here
 Project-URL: Changelog, https://github.com/liblaf/cherries/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://github.com/liblaf/cherries
@@ -11,6 +11,7 @@ Author-email: liblaf <30631553+liblaf@users.noreply.github.com>
 License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.12
+Requires-Dist: comet-ml<4,>=3.47.6
 Requires-Dist: gitpython<4,>=3.1.44
 Requires-Dist: lazy-loader<0.5,>=0.4
 Requires-Dist: liblaf-grapes<0.0.1,>=0.0.0

liblaf_cherries-0.0.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+liblaf/cherries/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/__init__.pyi,sha256=u-eKDd-6imkzIue3LmuJJmpjLDV1yGfV0XP9aN0VdWQ,827
+liblaf/cherries/_config.py,sha256=rm-Y6roi8hBvQYdH-VQh_ovWCyVsX_7R0x1jokBPCDM,741
+liblaf/cherries/_env.py,sha256=RK9NMHIok-AkCLMqW44cXLl0d_daLjpEcjhreSP1vm0,92
+liblaf/cherries/_experiment.py,sha256=E6r5DyojfY75lKsIDxYpyaCgXFXMJTaUIglIk9Xs-Sw,3181
+liblaf/cherries/_main.py,sha256=R8vWc9e94MViqCzMiG257--QtSoOU50lmR59oIRc6nw,1237
+liblaf/cherries/_start.py,sha256=iGAhDm8sF_JCaWPWdMIFL0d5nODFU8IcBPdNihhiSp4,685
+liblaf/cherries/git/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/git/__init__.pyi,sha256=p52L1d1kuiwyc9tBz648Bm76C9DJLbgleE8EKRJM4Lg,371
+liblaf/cherries/git/_commit.py,sha256=jnAtCKljNnzhXK90cj3adAYkPvcnLnOrHWA8YWhtZF4,482
+liblaf/cherries/git/_entrypoint.py,sha256=My_TmLqpGX4NJV4qjQvmHtnwhxX_B2ilfuYvpj2ftaM,262
+liblaf/cherries/git/_repo.py,sha256=bE8apxawGie8KuEjQCDAVRSGTP7Qt6jDDtoXMhfWy4w,907
+liblaf/cherries/git/github/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/git/github/__init__.pyi,sha256=jspOamBde7EtGOqsIzWg75jFToVHRhG4hfiEw1MDz80,96
+liblaf/cherries/git/github/_link.py,sha256=f_AcdKMhukUZ2fgBtC0usBrwnpAHaLYo9EhkZYesZuQ,693
+liblaf/cherries/git/github/_repo.py,sha256=I3vjgonI_SPrytf68qzLAej880Zn7cPryaK4PPoVZpU,627
+liblaf/cherries/integration/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/integration/__init__.pyi,sha256=n2QqtCl9oTVJatyt8LhiTJVnr_uoyYgfrN8virEqezQ,165
+liblaf/cherries/integration/_backend.py,sha256=iwpwTB3NgAI9oUCdWYMmH8qI8xYmUsZmES0pyw9_6D0,1241
+liblaf/cherries/integration/_factory.py,sha256=KJPse2efpOLv6s4sPQAPnzh9vwYcIQVsOg1ucxzTmIo,412
+liblaf/cherries/integration/_neptune.py,sha256=MhvPZUblAae6vmGRjgDELl_2wcOhrb90nCIsg8xpRMs,1789
+liblaf/cherries/plugin/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/plugin/__init__.pyi,sha256=3wmkKoe27SI3q5zbyejf3KmaBRUhAu-OEefJAxxbECs,248
+liblaf/cherries/plugin/_abc.py,sha256=kMDFzDAEDifpxWbnQhp4M4sr24-D55x-B6MPIZW_1jA,848
+liblaf/cherries/plugin/_default.py,sha256=H7_vym_uxxba41xR2ERBeBt0kBX4s4tjzjifyKjXxS0,215
+liblaf/cherries/plugin/_git.py,sha256=Gyv8Uc2AnPpZul23oGm6Dba2YOaiFx6WAytrQ8ylSsk,866
+liblaf/cherries/plugin/_logging.py,sha256=wLIDlVk9_A-lbI64obEzyIFjLgIRR-rmjNvmli3T3O4,1779
+liblaf/cherries/plugin/_restic.py,sha256=4ArmgD42ZUotkVdCwdMvlmJF0Z8PuKe8EukzRoWyQK8,1926
+liblaf/cherries/utils/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
+liblaf/cherries/utils/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+liblaf_cherries-0.0.1.dist-info/METADATA,sha256=_AX57D2yYC5gv-e41pONNTuXduXIpv_FukvhY8R2gFs,925
+liblaf_cherries-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+liblaf_cherries-0.0.1.dist-info/licenses/LICENSE,sha256=Ph4NzyU3lGVDeYv-mf8aRmImH8v9rVL9F362FV4G6Ow,1063
+liblaf_cherries-0.0.1.dist-info/RECORD,,

liblaf/cherries/integration/_abc.py

@@ -1,134 +0,0 @@
-from __future__ import annotations
-
-import datetime
-import functools
-import os
-import sys
-from collections.abc import Sequence
-from pathlib import Path
-from typing import Generic, TypeVar
-
-from loguru import logger
-
-from liblaf import cherries
-
-_T = TypeVar("_T")
-
-
-class Run(Generic[_T]):
-    enabled: bool = True
-    plugins: list[cherries.Plugin]
-    _backend: _T
-
-    def __init__(
-        self,
-        plugins: Sequence[cherries.Plugin] | None = None,
-        *,
-        enabled: bool = True,
-    ) -> None:
-        if plugins is None:
-            plugins = cherries.default_plugins()
-        self.plugins = sorted(plugins, key=lambda plugin: plugin.priority)
-        self.enabled = enabled
-        set_current_run(self)
-        if self.enabled:
-            self.start()
-
-    @property
-    def backend(self) -> str:
-        return "dummy"
-
-    @property
-    def id(self) -> str:
-        raise NotImplementedError
-
-    @functools.cached_property
-    def creation_time(self) -> datetime.datetime:
-        return datetime.datetime.now().astimezone()
-
-    @functools.cached_property
-    def entrypoint(self) -> Path:
-        return Path(sys.argv[0]).absolute()
-
-    @property
-    def name(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def url(self) -> str:
-        raise NotImplementedError
-
-    def start(self) -> None:
-        for plugin in self.plugins:
-            plugin.pre_start()
-        self._backend = self._start()
-        for plugin in self.plugins:
-            plugin.post_start(self)
-        self.log_other("cherries/creation_time", self.creation_time)
-
-    def end(self) -> None:
-        for plugin in reversed(self.plugins):
-            plugin.pre_end(self)
-        self._end()
-        for plugin in reversed(self.plugins):
-            plugin.post_end(self)
-
-    def log_metric(
-        self,
-        key: str,
-        value: float,
-        *,
-        step: float | None = None,
-        timestamp: float | None = None,
-        **kwargs,
-    ) -> None:
-        logger.opt(depth=1).debug("{}: {}", key, value)
-        if self.enabled:
-            self._log_metric(key, value, step=step, timestamp=timestamp, **kwargs)
-
-    def log_other(
-        self,
-        key: str,
-        value: bool | float | str | datetime.datetime,
-        **kwargs,
-    ) -> None:
-        logger.opt(depth=1).info("{}: {}", key, value)
-        if self.enabled:
-            self._log_other(key, value, **kwargs)
-
-    def upload_file(self, key: str, path: str | os.PathLike[str], **kwargs) -> None:
-        path = Path(path)
-        logger.opt(depth=1).info("Uploading file: {}", path)
-        if self.enabled:
-            self._upload_file(key, path, **kwargs)
-
-    def _start(self) -> _T: ...
-    def _end(self) -> None: ...
-    def _log_metric(
-        self,
-        key: str,
-        value: float,
-        *,
-        step: float | None = None,
-        timestamp: float | None = None,
-        **kwargs,
-    ) -> None: ...
-    def _log_other(
-        self, key: str, value: bool | float | str | datetime.datetime, **kwargs
-    ) -> None: ...
-    def _upload_file(self, key: str, path: Path, **kwargs) -> None: ...
-
-
-_current_run: Run | None = None
-
-
-def current_run() -> Run:
-    global _current_run  # noqa: PLW0603
-    if _current_run is None:
-        _current_run = Run()
-    return _current_run
-
-
-def set_current_run(run: Run) -> None:
-    global _current_run  # noqa: PLW0603
-    _current_run = run

liblaf_cherries-0.0.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-liblaf/cherries/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/__init__.pyi,sha256=Qt8P1Fgtt2bC-5KnSjF0ruTKAtT9p4dGmnEfCbsdeR0,506
-liblaf/cherries/_start.py,sha256=VF2TyYcX6jWPxLA4wtLoNLIjMRhwXt3XQlR7xwnTdGI,1153
-liblaf/cherries/git/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/git/__init__.pyi,sha256=p52L1d1kuiwyc9tBz648Bm76C9DJLbgleE8EKRJM4Lg,371
-liblaf/cherries/git/_commit.py,sha256=jnAtCKljNnzhXK90cj3adAYkPvcnLnOrHWA8YWhtZF4,482
-liblaf/cherries/git/_entrypoint.py,sha256=My_TmLqpGX4NJV4qjQvmHtnwhxX_B2ilfuYvpj2ftaM,262
-liblaf/cherries/git/_repo.py,sha256=bE8apxawGie8KuEjQCDAVRSGTP7Qt6jDDtoXMhfWy4w,907
-liblaf/cherries/git/github/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/git/github/__init__.pyi,sha256=jspOamBde7EtGOqsIzWg75jFToVHRhG4hfiEw1MDz80,96
-liblaf/cherries/git/github/_link.py,sha256=f_AcdKMhukUZ2fgBtC0usBrwnpAHaLYo9EhkZYesZuQ,693
-liblaf/cherries/git/github/_repo.py,sha256=I3vjgonI_SPrytf68qzLAej880Zn7cPryaK4PPoVZpU,627
-liblaf/cherries/integration/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/integration/__init__.pyi,sha256=jSy9QJwmUTygGUNeOdkP5sk_thCJfXwYH9TMKJHfvhI,152
-liblaf/cherries/integration/_abc.py,sha256=se7Jf89HHs4Ssf1W7F_RTJDcPLIYkOJftmmVFRpytZA,3418
-liblaf/cherries/integration/_neptune.py,sha256=zpV5MN7_0Cqb-_t0vX2rXlHs-j5hDgH7FdwUczDo0Qc,1232
-liblaf/cherries/plugin/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/plugin/__init__.pyi,sha256=oDd9fUqu2YRb2EP-15j6YgHT40MH22O_jJbt9goPb3s,198
-liblaf/cherries/plugin/_abc.py,sha256=2ILWpFNLz7dCo-YL_UNzg3BaWoYyTuFOv98xBZZvyZE,806
-liblaf/cherries/plugin/_default.py,sha256=VrFEW2AQqsBNALPNzLBlStRk_2XcyMu1XwzhjRGNr8Q,152
-liblaf/cherries/plugin/_git.py,sha256=_t9lEAQOzEHV2qwzHwirdYg1t1br11Lp3hO4ArjVrXI,853
-liblaf/cherries/plugin/_logging.py,sha256=AGE9HZsRm-Z8hQn0HBSuu77PulF-_EN_Y29QvSMC4Bk,686
-liblaf/cherries/plugin/_restic.py,sha256=qW48Q043xZTB3xces9EJn-sFF4whnSlgVAjq2FnUoC4,1383
-liblaf/cherries/utils/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/utils/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-liblaf_cherries-0.0.0.dist-info/METADATA,sha256=DVW58aVJrIPxiuHFMWXUD73Ncyq0_6cJjy_TMR1Pwo8,890
-liblaf_cherries-0.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-liblaf_cherries-0.0.0.dist-info/licenses/LICENSE,sha256=Ph4NzyU3lGVDeYv-mf8aRmImH8v9rVL9F362FV4G6Ow,1063
-liblaf_cherries-0.0.0.dist-info/RECORD,,