liblaf-cherries 0.5.0__tar.gz → 0.5.2__tar.gz

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liblaf-cherries
-Version: 0.5.0
+Version: 0.5.2
 Summary: 🍒 Sweet experiment tracking with Comet, DVC, and Git integration.
 Project-URL: Changelog, https://github.com/liblaf/cherries/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://cherries.readthedocs.io/
@@ -32,12 +32,13 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: attrs<26,>=25
+Requires-Dist: cachetools<7,>=6
 Requires-Dist: comet-ml<4,>=3
-Requires-Dist: dvc[all]<4,>=3
+Requires-Dist: dvc[ssh]<4,>=3
 Requires-Dist: environs<15,>=14
 Requires-Dist: gitpython<4,>=3
 Requires-Dist: lazy-loader<0.5,>=0.4
-Requires-Dist: liblaf-grapes<5,>=4
+Requires-Dist: liblaf-grapes<6,>=5
 Requires-Dist: loguru<0.8,>=0.7
 Requires-Dist: networkx<4,>=3
 Requires-Dist: pydantic-settings<3,>=2

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/pyproject.toml

@@ -34,12 +34,13 @@ classifiers = [
 ]
 dependencies = [
   "attrs>=25,<26",
+  "cachetools>=6,<7",
   "comet-ml>=3,<4",
-  "dvc[all]>=3,<4",
+  "dvc[ssh]>=3,<4",
   "environs>=14,<15",
   "gitpython>=3,<4",
   "lazy-loader>=0.4,<0.5",
-  "liblaf-grapes>=4,<5",
+  "liblaf-grapes>=5,<6",
   "loguru>=0.7,<0.8",
   "networkx>=3,<4",
   "pydantic>=2,<3",

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/__init__.py

@@ -1,3 +1,4 @@
 import lazy_loader as lazy
 
 __getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+del lazy

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/__init__.pyi

@@ -1,4 +1,4 @@
-from . import config, core, meta, pathutils, plugins
+from . import config, core, meta, path_utils, plugins
 from ._entrypoint import end, run, start
 from .config import BaseConfig, input, output  # noqa: A004
 from .core import (
@@ -15,7 +15,7 @@ from .core import (
     log_parameter,
     log_parameters,
 )
-from .pathutils import (
+from .path_utils import (
     as_os_path,
     as_path,
     as_posix,
@@ -56,7 +56,7 @@ __all__ = [
     "output",
     "params",
     "path",
-    "pathutils",
+    "path_utils",
     "plugins",
     "project_dir",
     "run",

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/_entrypoint.py

@@ -9,8 +9,8 @@ from liblaf.cherries import config as _config
 from liblaf.cherries import core, profiles
 
 
-def end() -> None:
-    core.active_run.end()
+def end(*args, **kwargs) -> None:
+    core.active_run.end(*args, **kwargs)
 
 
 def run[T](main: Callable[..., T], *, profile: profiles.ProfileLike | None = None) -> T:
@@ -27,12 +27,13 @@ def run[T](main: Callable[..., T], *, profile: profiles.ProfileLike | None = Non
         run.log_parameters(_config.model_dump_without_assets(config, mode="json"))
         for path in _config.get_inputs(config):
             run.log_input(path)
-    result: T = main(*args, **kwargs)
-    for config in configs:
-        for path in _config.get_outputs(config):
-            run.log_output(path)
-    run.end()
-    return result
+    try:
+        return main(*args, **kwargs)
+    finally:
+        for config in configs:
+            for path in _config.get_outputs(config):
+                run.log_output(path)
+        run.end()
 
 
 def start(

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)
 
 __commit_id__ = commit_id = None

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/config/__init__.py

@@ -1,3 +1,4 @@
 import lazy_loader as lazy
 
 __getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+del lazy

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/config/__init__.pyi

@@ -1,27 +1,37 @@
-from ._asset import (
+from ._config import BaseConfig
+from .asset import (
     AssetKind,
+    AssetResolver,
+    AssetResolverRegistry,
+    AssetResolverSeries,
+    AssetResolverVtk,
+    Extra,
     MetaAsset,
-    PathGenerator,
+    asset,
+    asset_resolver_registry,
     get_assets,
     get_inputs,
     get_outputs,
     input,  # noqa: A004
     model_dump_without_assets,
     output,
-    path_generators,
 )
-from ._config import BaseConfig
 
 __all__ = [
     "AssetKind",
+    "AssetResolver",
+    "AssetResolverRegistry",
+    "AssetResolverSeries",
+    "AssetResolverVtk",
     "BaseConfig",
+    "Extra",
     "MetaAsset",
-    "PathGenerator",
+    "asset",
+    "asset_resolver_registry",
     "get_assets",
     "get_inputs",
     "get_outputs",
     "input",
     "model_dump_without_assets",
     "output",
-    "path_generators",
 ]

liblaf_cherries-0.5.2/src/liblaf/cherries/config/_config.py

@@ -0,0 +1,5 @@
+import pydantic_settings as ps
+
+
+class BaseConfig(ps.BaseSettings):
+    model_config = ps.SettingsConfigDict()

{liblaf_cherries-0.5.0/src/liblaf/cherries/meta → liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset}/__init__.py

@@ -1,3 +1,4 @@
 import lazy_loader as lazy
 
 __getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+del lazy

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/__init__.pyi

@@ -0,0 +1,34 @@
+from . import resolvers
+from ._meta import (
+    AssetKind,
+    Extra,
+    MetaAsset,
+    asset,
+    get_assets,
+    get_inputs,
+    get_outputs,
+    input,  # noqa: A004
+    model_dump_without_assets,
+    output,
+)
+from ._registry import AssetResolverRegistry, asset_resolver_registry
+from .resolvers import AssetResolver, AssetResolverSeries, AssetResolverVtk
+
+__all__ = [
+    "AssetKind",
+    "AssetResolver",
+    "AssetResolverRegistry",
+    "AssetResolverSeries",
+    "AssetResolverVtk",
+    "Extra",
+    "MetaAsset",
+    "asset",
+    "asset_resolver_registry",
+    "get_assets",
+    "get_inputs",
+    "get_outputs",
+    "input",
+    "model_dump_without_assets",
+    "output",
+    "resolvers",
+]

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/_meta.py

@@ -0,0 +1,98 @@
+import enum
+import os
+from collections.abc import Callable, Generator, Iterable
+from pathlib import Path
+from typing import Any, Literal
+
+import attrs
+import pydantic
+
+import liblaf.cherries.path_utils as pu
+from liblaf import grapes
+from liblaf.cherries.typing import PathLike
+
+from ._registry import asset_resolver_registry
+
+type Extra = (
+    PathLike
+    | Iterable[PathLike]
+    | Callable[[PathLike], PathLike | Iterable[PathLike | None] | None]
+    | None
+)
+
+
+class AssetKind(enum.StrEnum):
+    INPUT = enum.auto()
+    OUTPUT = enum.auto()
+
+
+@attrs.define
+class MetaAsset:
+    kind: AssetKind
+    extra: Extra = None
+
+    def resolve(self, value: Path) -> Generator[Path]:
+        if self.extra is None:
+            yield from asset_resolver_registry.resolve(value)
+            return
+        extra: PathLike | Iterable[PathLike | None] | None = (
+            self.extra(value) if callable(self.extra) else self.extra  # noqa: S610
+        )
+        for p in grapes.as_iterable(extra, base_type=(str, bytes, os.PathLike)):
+            if p is None:
+                continue
+            yield Path(p)
+
+
+def asset(path: PathLike, extra: Extra = None, *, kind: AssetKind, **kwargs) -> Path:
+    field_info: pydantic.fields.FieldInfo = pydantic.Field(pu.data(path), **kwargs)  # pyright: ignore[reportAssignmentType]
+    field_info.metadata.append(MetaAsset(kind=kind, extra=extra))
+    return field_info  # pyright: ignore[reportReturnType]
+
+
+def get_assets(cfg: pydantic.BaseModel, kind: AssetKind) -> Generator[Path]:
+    for name, info in type(cfg).model_fields.items():
+        value: Any = getattr(cfg, name)
+        if isinstance(value, pydantic.BaseModel):
+            yield from get_assets(value, kind)
+        for meta in info.metadata:
+            if isinstance(meta, MetaAsset) and meta.kind == kind:
+                value: Path = Path(value)
+                yield value
+                yield from meta.resolve(value)
+
+
+def get_inputs(cfg: pydantic.BaseModel) -> Generator[Path]:
+    yield from get_assets(cfg, AssetKind.INPUT)
+
+
+def get_outputs(cfg: pydantic.BaseModel) -> Generator[Path]:
+    yield from get_assets(cfg, AssetKind.OUTPUT)
+
+
+def input(path: PathLike, extra: Extra = None, **kwargs) -> Path:  # noqa: A001
+    return asset(path, extra=extra, kind=AssetKind.INPUT, **kwargs)
+
+
+def model_dump_without_assets(
+    model: pydantic.BaseModel,
+    *,
+    mode: str | Literal["json", "python"] = "json",  # noqa: PYI051
+    **kwargs,
+) -> dict[str, Any]:
+    data: dict[str, Any] = model.model_dump(mode=mode, **kwargs)
+    for name, info in type(model).model_fields.items():
+        value: Any = getattr(model, name)
+        if isinstance(value, pydantic.BaseModel):
+            value = model_dump_without_assets(value)
+        for meta in info.metadata:
+            if isinstance(meta, MetaAsset):
+                del data[name]
+                break
+        else:
+            data[name] = value
+    return data
+
+
+def output(path: PathLike, extra: Extra = None, **kwargs) -> Path:
+    return asset(path, extra=extra, kind=AssetKind.OUTPUT, **kwargs)

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/_registry.py

@@ -0,0 +1,25 @@
+from collections.abc import Generator
+from pathlib import Path
+
+import attrs
+
+from .resolvers import AssetResolver, AssetResolverSeries, AssetResolverVtk
+
+
+@attrs.define
+class AssetResolverRegistry:
+    _registry: dict[str, AssetResolver] = attrs.field(factory=dict)
+
+    def register(self, resolver: AssetResolver) -> None:
+        self._registry[resolver.id] = resolver
+
+    def resolve(self, path: Path) -> Generator[Path]:
+        for resolver in self._registry.values():
+            if not resolver.match(path):
+                continue
+            yield from resolver.resolve(path)
+
+
+asset_resolver_registry: AssetResolverRegistry = AssetResolverRegistry()
+asset_resolver_registry.register(AssetResolverSeries())
+asset_resolver_registry.register(AssetResolverVtk())

{liblaf_cherries-0.5.0/src/liblaf/cherries/core → liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/resolvers}/__init__.py

@@ -1,3 +1,4 @@
 import lazy_loader as lazy
 
 __getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+del lazy

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/resolvers/__init__.pyi

@@ -0,0 +1,5 @@
+from ._abc import AssetResolver
+from ._series import AssetResolverSeries
+from ._vtk import AssetResolverVtk
+
+__all__ = ["AssetResolver", "AssetResolverSeries", "AssetResolverVtk"]

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/resolvers/_abc.py

@@ -0,0 +1,17 @@
+import abc
+from collections.abc import Iterable
+from pathlib import Path
+
+
+class AssetResolver:
+    @property
+    def id(self) -> str:
+        return type(self).__name__
+
+    @abc.abstractmethod
+    def match(self, path: Path) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def resolve(self, path: Path) -> Iterable[Path]:
+        raise NotImplementedError

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/resolvers/_series.py

@@ -0,0 +1,18 @@
+from collections.abc import Generator
+from pathlib import Path
+from typing import override
+
+from ._abc import AssetResolver
+
+
+class AssetResolverSeries(AssetResolver):
+    @override
+    def match(self, path: Path) -> bool:
+        return path.suffix == ".series"
+
+    @override
+    def resolve(self, path: Path) -> Generator[Path]:
+        if (folder := path.with_suffix(".d")).exists():
+            yield folder
+        if (folder := path.with_suffix("")).exists():
+            yield folder

liblaf_cherries-0.5.2/src/liblaf/cherries/config/asset/resolvers/_vtk.py

@@ -0,0 +1,33 @@
+from collections.abc import Generator
+from pathlib import Path
+from typing import override
+
+import attrs
+
+from ._abc import AssetResolver
+
+
+@attrs.define
+class AssetResolverVtk(AssetResolver):
+    SUFFIXES: set[str] = attrs.field(
+        factory=lambda: {
+            ".obj",
+            ".ply",
+            ".stl",
+            ".vti",
+            ".vtk",
+            ".vtp",
+            ".vtr",
+            ".vts",
+            ".vtu",
+        }
+    )
+
+    @override
+    def match(self, path: Path) -> bool:
+        return path.suffix in self.SUFFIXES
+
+    @override
+    def resolve(self, path: Path) -> Generator[Path]:
+        if (landmarks := path.with_suffix(".landmarks.json")).exists():
+            yield landmarks

liblaf_cherries-0.5.2/src/liblaf/cherries/core/__init__.py

@@ -0,0 +1,4 @@
+import lazy_loader as lazy
+
+__getattr__, __dir__, __all__ = lazy.attach_stub(__name__, __file__)
+del lazy

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/core/__init__.pyi

@@ -1,4 +1,4 @@
-from ._impl import ImplInfo, get_impl_info, impl
+from ._impl import ImplInfo, collect_impls, get_impl_info, impl
 from ._plugin import Plugin
 from ._run import (
     Run,
@@ -15,17 +15,27 @@ from ._run import (
     log_parameters,
     start,
 )
-from ._spec import SpecInfo, spec
-from .typed import MethodName, PluginId
+from ._spec import SpecInfo, collect_specs, spec
+from ._utils import (
+    PluginCachedProperty,
+    PluginProperty,
+    plugin_cached_property,
+    plugin_property,
+)
+from .typing import MethodName, PluginId
 
 __all__ = [
     "ImplInfo",
     "MethodName",
     "Plugin",
+    "PluginCachedProperty",
     "PluginId",
+    "PluginProperty",
     "Run",
     "SpecInfo",
     "active_run",
+    "collect_impls",
+    "collect_specs",
     "end",
     "get_impl_info",
     "impl",
@@ -38,6 +48,8 @@ __all__ = [
     "log_output",
     "log_parameter",
     "log_parameters",
+    "plugin_cached_property",
+    "plugin_property",
     "spec",
     "start",
 ]

{liblaf_cherries-0.5.0 → liblaf_cherries-0.5.2}/src/liblaf/cherries/core/_impl.py

@@ -1,13 +1,13 @@
 import functools
+import inspect
 from collections.abc import Callable, Iterable
 from typing import Any, overload
 
 import attrs
-import wrapt
 
 from liblaf import grapes
 
-from .typed import PluginId
+from .typing import MethodName, PluginId
 
 
 @attrs.define
@@ -43,18 +43,31 @@ def impl(
     if func is None:
         return functools.partial(impl, priority=priority, after=after, before=before)
 
-    @wrapt.decorator
+    info = ImplInfo(after=after, before=before, priority=priority)
+
+    @grapes.decorator
     def wrapper(
         wrapped: Callable, _instance: Any, args: tuple, kwargs: dict[str, Any]
     ) -> Any:
         return wrapped(*args, **kwargs)
 
-    proxy: Any = wrapper(func)  # pyright: ignore[reportCallIssue]
-    proxy._self_impl = ImplInfo(after=after, before=before, priority=priority)  # noqa: SLF001
-    return proxy
+    func = wrapper(func)
+    grapes.wrapt_setattr(func, "impl", info)
+    return func
+
+
+def collect_impls(cls: Any) -> dict[MethodName, ImplInfo]:
+    if isinstance(cls, type):
+        cls = type(cls)
+    return {
+        name: grapes.wrapt_getattr(method, "impl")
+        for name, method in inspect.getmembers(
+            cls, lambda m: grapes.wrapt_getattr(m, "impl", None) is not None
+        )
+    }
 
 
 def get_impl_info(func: Callable | None) -> ImplInfo | None:
     if func is None:
         return None
-    return grapes.unbind_getattr(func, "_self_impl", None)
+    return grapes.wrapt_getattr(func, "impl", None)

liblaf_cherries-0.5.2/src/liblaf/cherries/core/_plugin.py

@@ -0,0 +1,99 @@
+import math
+import operator
+from collections.abc import Mapping, Sequence
+from typing import Any, Self
+
+import attrs
+import cachetools
+import networkx as nx
+from loguru import logger
+
+from ._impl import ImplInfo, collect_impls, get_impl_info
+from .typing import MethodName, PluginId
+
+
+@attrs.define
+class Plugin:
+    plugins: dict[PluginId, "Plugin"] = attrs.field(factory=dict, kw_only=True)
+
+    _plugin_parent: Self | None = attrs.field(default=None, kw_only=True)
+    _cache_sort_plugins: cachetools.Cache[MethodName, Sequence["Plugin"]] = attrs.field(
+        factory=lambda: cachetools.Cache(math.inf), init=False
+    )
+
+    @property
+    def plugin_id(self) -> str:
+        return type(self).__name__
+
+    @property
+    def plugin_root(self) -> Self:
+        if self._plugin_parent is None:
+            return self
+        return self._plugin_parent.plugin_root
+
+    def delegate(
+        self,
+        method: MethodName,
+        args: Sequence[Any] = (),
+        kwargs: Mapping[str, Any] = {},
+        *,
+        first_result: bool = False,
+    ) -> Any:
+        plugins: Sequence[Plugin] = self._plugins_sort(method)
+        if not plugins:
+            if first_result:
+                return None
+            return []
+        results: list[Any] = []
+        for plugin in plugins:
+            try:
+                result: Any = getattr(plugin, method)(*args, **kwargs)
+            except BaseException as e:
+                if isinstance(e, (KeyboardInterrupt, SystemExit)):
+                    raise
+                logger.exception("Plugin {}", plugin.plugin_id)
+            else:
+                if result is None:
+                    continue
+                if first_result:
+                    return result
+                results.append(result)
+        return results
+
+    def register(self, plugin: "Plugin") -> None:
+        impls: dict[MethodName, ImplInfo] = collect_impls(plugin)
+        for name in impls:
+            self._cache_sort_plugins.pop(name, None)
+        plugin._plugin_parent = self  # noqa: SLF001
+        self.plugins[plugin.plugin_id] = plugin
+
+    def _plugins_sort_cache_key(self, method: MethodName) -> MethodName:
+        return method
+
+    @cachetools.cachedmethod(
+        operator.attrgetter("_cache_sort_plugins"), key=_plugins_sort_cache_key
+    )
+    def _plugins_sort(self, method: str) -> Sequence["Plugin"]:
+        plugin_infos: dict[str, ImplInfo] = {
+            plugin_id: info
+            for plugin_id, plugin in self.plugins.items()
+            if (info := get_impl_info(getattr(plugin, method, None))) is not None
+        }
+
+        def key_fn(node: str) -> int:
+            return plugin_infos[node].priority
+
+        graph: nx.DiGraph[str] = nx.DiGraph()
+        for plugin_id, impl_info in plugin_infos.items():
+            graph.add_node(plugin_id)
+            for after in impl_info.after:
+                if after in plugin_infos:
+                    graph.add_edge(after, plugin_id)
+            for before in impl_info.before:
+                if before in plugin_infos:
+                    graph.add_edge(plugin_id, before)
+        return tuple(
+            plugin
+            for plugin_id in nx.lexicographical_topological_sort(graph, key=key_fn)
+            if (plugin := self.plugins.get(plugin_id)) is not None
+        )