liblaf-cherries 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

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/__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/_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/_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/config/__init__.py

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

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/config/_config.py

@@ -2,5 +2,4 @@ import pydantic_settings as ps
 
 
 class BaseConfig(ps.BaseSettings):
-    model_config = ps.SettingsConfigDict(cli_parse_args=True)
-    # TODO: add support for config files
+    model_config = ps.SettingsConfigDict()

liblaf/cherries/{pathutils → 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/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/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/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/config/asset/resolvers/__init__.py

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

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/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/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/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/core/__init__.py

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

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/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/core/_plugin.py

@@ -1,12 +1,15 @@
+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, get_impl_info
-from ._spec import SpecInfo, collect_specs
-from .typed import MethodName, PluginId
+from ._impl import ImplInfo, collect_impls, get_impl_info
+from .typing import MethodName, PluginId
 
 
 @attrs.define
@@ -14,17 +17,13 @@ class Plugin:
     plugins: dict[PluginId, "Plugin"] = attrs.field(factory=dict, kw_only=True)
 
     _plugin_parent: Self | None = attrs.field(default=None, kw_only=True)
-    _sort_plugins_cache: dict[MethodName, Sequence["Plugin"]] = attrs.field(
-        factory=dict, init=False
+    _cache_sort_plugins: cachetools.Cache[MethodName, Sequence["Plugin"]] = attrs.field(
+        factory=lambda: cachetools.Cache(math.inf), init=False
     )
 
-    @classmethod
-    def plugin_id_cls(cls) -> str:
-        return cls.__name__
-
     @property
     def plugin_id(self) -> str:
-        return self.plugin_id_cls()
+        return type(self).__name__
 
     @property
     def plugin_root(self) -> Self:
@@ -47,50 +46,54 @@ class Plugin:
             return []
         results: list[Any] = []
         for plugin in plugins:
-            result: Any = getattr(plugin, method)(*args, **kwargs)
-            if result is None:
-                continue
-            if first_result:
-                return result
-            results.append(result)
+            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_prepare(self) -> None:
-        specs: dict[str, SpecInfo] = collect_specs(self)
-        for method in specs:
-            self._sort_plugins_cache[method] = self._plugins_sort(
-                method, refresh_cache=True
-            )
+    def _plugins_sort_cache_key(self, method: MethodName) -> MethodName:
+        return method
 
-    def _plugins_sort(
-        self, method: str, *, refresh_cache: bool = False
-    ) -> Sequence["Plugin"]:
-        if refresh_cache or method not in self._sort_plugins_cache:
-            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
-            }
+    @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
+        def key_fn(node: str) -> int:
+            return plugin_infos[node].priority
 
-            graph = 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)
-            self._sort_plugins_cache[method] = tuple(
-                plugin
-                for plugin_id in nx.lexicographical_topological_sort(graph, key=key_fn)
-                if (plugin := self.plugins.get(plugin_id)) is not None
-            )
-        return self._sort_plugins_cache[method]
+        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
+        )

liblaf/cherries/core/_run.py

@@ -1,17 +1,17 @@
 import contextlib
 import datetime
-import functools
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
 import attrs
 
-from liblaf.cherries import pathutils
+from liblaf.cherries import path_utils
 from liblaf.cherries.typing import PathLike
 
 from ._plugin import Plugin
 from ._spec import spec
+from ._utils import plugin_cached_property, plugin_property
 
 
 @attrs.define
@@ -24,59 +24,41 @@ class Run(Plugin):
         3. [MLflow Tracking APIs | MLflow](https://www.mlflow.org/docs/latest/ml/tracking/tracking-api/)
     """
 
-    @functools.cached_property
+    @plugin_cached_property
     def data_dir(self) -> Path:
-        if self._plugin_parent is not None:
-            return self.plugin_root.data_dir
-        return pathutils.data()
+        return path_utils.data()
 
-    @functools.cached_property
+    @plugin_cached_property
     def entrypoint(self) -> Path:
-        if self._plugin_parent is not None:
-            return self.plugin_root.entrypoint
-        return pathutils.entrypoint()
+        return path_utils.entrypoint()
 
-    @functools.cached_property
+    @plugin_cached_property
     def exp_dir(self) -> Path:
-        if self._plugin_parent is not None:
-            return self.plugin_root.exp_dir
-        return pathutils.exp_dir()
+        return path_utils.exp_dir()
 
-    @functools.cached_property
+    @plugin_cached_property
     def name(self) -> str:
-        if self._plugin_parent is not None:
-            return self.plugin_root.name
         return self.start_time.strftime("%Y-%m-%dT%H%M%S")
 
-    @property
+    @plugin_property
     def params(self) -> Mapping[str, Any]:
-        if self._plugin_parent is not None:
-            return self.plugin_root.params
-        return self.get_params()
+        return self.plugin_root.get_params()
 
-    @functools.cached_property
+    @plugin_cached_property
     def project_name(self) -> str | None:
-        if self._plugin_parent is not None:
-            return self.plugin_root.project_name
         return self.project_dir.name
 
-    @functools.cached_property
+    @plugin_cached_property
     def project_dir(self) -> Path:
-        if self._plugin_parent is not None:
-            return self.plugin_root.project_dir
-        return pathutils.project_dir()
+        return path_utils.project_dir()
 
-    @functools.cached_property
+    @plugin_cached_property
     def start_time(self) -> datetime.datetime:
-        if self._plugin_parent is not None:
-            return self.plugin_root.start_time
         return datetime.datetime.now().astimezone()
 
-    @functools.cached_property
+    @plugin_property
     def url(self) -> str:
-        if self._plugin_parent is not None:
-            return self.plugin_root.url
-        return self.get_url()
+        return self.plugin_root.get_url()
 
     @spec
     def end(self, *args, **kwargs) -> None: ...
@@ -170,7 +152,6 @@ class Run(Plugin):
 
     @spec(delegate=False)
     def start(self, *args, **kwargs) -> None:
-        self._plugins_prepare()
         self.delegate("start", args, kwargs)
 
 

liblaf/cherries/core/_spec.py

@@ -4,11 +4,10 @@ from collections.abc import Callable, Mapping, Sequence
 from typing import Any, Protocol, overload
 
 import attrs
-import wrapt
 
 from liblaf import grapes
 
-from .typed import MethodName
+from .typing import MethodName
 
 
 class Plugin(Protocol):
@@ -48,27 +47,27 @@ def spec(
 
     info = SpecInfo(delegate=delegate, first_result=first_result)
 
-    @wrapt.decorator
-    def wrapper(
-        wrapped: Callable, instance: Plugin, args: tuple, kwargs: dict[str, Any]
-    ) -> Any:
+    @grapes.decorator
+    def wrapper[**P, T](
+        wrapped: Callable[P, T], instance: Plugin, args: tuple, kwargs: dict[str, Any]
+    ) -> T:
         if info.delegate:
             return instance.delegate(
                 wrapped.__name__, args, kwargs, first_result=info.first_result
             )
         return wrapped(*args, **kwargs)
 
-    proxy: Any = wrapper(func)  # pyright: ignore[reportCallIssue]
-    proxy._self_spec = SpecInfo(delegate=delegate, first_result=first_result)  # noqa: SLF001
-    return proxy
+    func: Any = wrapper(func)
+    grapes.wrapt_setattr(func, "spec", info)
+    return func
 
 
 def collect_specs(cls: type[Plugin] | Plugin) -> dict[str, SpecInfo]:
     if isinstance(cls, type):
         cls = type(cls)
     return {
-        name: grapes.unbind_getattr(method, "_self_spec")
+        name: grapes.wrapt_getattr(method, "spec")
         for name, method in inspect.getmembers(
-            cls, lambda m: grapes.unbind_getattr(m, "_self_spec", None) is not None
+            cls, lambda m: grapes.wrapt_getattr(m, "spec", None) is not None
         )
     }

liblaf/cherries/core/_utils.py

@@ -1,5 +1,6 @@
+import functools
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Self, overload, override
 
 import wrapt
 
@@ -18,3 +19,45 @@ def delegate_property_to_root[C: Callable](func: C) -> C:
         return getattr(instance.plugin_root, wrapped.__name__)
 
     return func
+
+
+class PluginCachedProperty[T](functools.cached_property[T]):
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type | None = None) -> T: ...
+    @override
+    def __get__(self, instance: object | None, owner: type | None = None) -> Self | T:
+        if instance is None:
+            return super().__get__(instance, owner)
+        if (parent := getattr(instance, "_plugin_parent", None)) is not None:
+            instance = parent
+        return super().__get__(instance, owner)
+
+    @override
+    def __set__(self, instance: object, value: T) -> None:
+        assert self.attrname is not None
+        instance.__dict__[self.attrname] = value
+
+
+class PluginProperty[T](property):
+    @overload
+    def __get__(self, instance: None, owner: type, /) -> Self: ...
+    @overload
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __get__(
+        self, instance: object | None, owner: type | None = None, /
+    ) -> Self | T:
+        if instance is None:
+            return super().__get__(instance, owner)
+        if (parent := getattr(instance, "_plugin_parent", None)) is not None:
+            instance = parent
+        return super().__get__(instance, owner)
+
+
+def plugin_cached_property[T](func: Callable[[Any], T]) -> PluginCachedProperty[T]:
+    return PluginCachedProperty(func)
+
+
+def plugin_property[T](fget: Callable[[Any], T]) -> PluginProperty[T]:
+    return PluginProperty(fget)

liblaf/cherries/meta/__init__.py

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

liblaf/cherries/meta/_git.py

@@ -3,7 +3,7 @@ import subprocess as sp
 import git
 
 from liblaf import grapes
-from liblaf.cherries import pathutils
+from liblaf.cherries import path_utils
 
 
 def git_auto_commit(
@@ -40,10 +40,10 @@ def git_commit_url(sha: str | None = None) -> str:
 
 def git_info() -> grapes.git.GitInfo:
     info: grapes.git.GitInfo = grapes.git.info(
-        pathutils.exp_dir(absolute=True), search_parent_directories=True
+        path_utils.exp_dir(absolute=True), search_parent_directories=True
     )
     return info
 
 
 def _repo() -> git.Repo:
-    return git.Repo(pathutils.exp_dir(absolute=True), search_parent_directories=True)
+    return git.Repo(path_utils.exp_dir(absolute=True), search_parent_directories=True)

liblaf/cherries/meta/_name.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import git.exc
 
 from liblaf import grapes
-from liblaf.cherries import pathutils
+from liblaf.cherries import path_utils
 
 from ._git import git_info
 
@@ -18,8 +18,8 @@ def project_name() -> str | None:
 
 
 def exp_name() -> str:
-    exp_dir: Path = pathutils.exp_dir(absolute=False)
-    exp_name: str = pathutils.as_posix(exp_dir)
+    exp_dir: Path = path_utils.exp_dir(absolute=False)
+    exp_name: str = path_utils.as_posix(exp_dir)
     exp_name = exp_name.removeprefix("exp")
     exp_name = exp_name.removeprefix("/")
     return exp_name

liblaf/cherries/path_utils/__init__.py

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

liblaf/cherries/plugins/__init__.py

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

liblaf/cherries/plugins/comet.py

@@ -9,7 +9,7 @@ import dvc.api
 import dvc.exceptions
 
 from liblaf import grapes
-from liblaf.cherries import core, pathutils
+from liblaf.cherries import core, path_utils
 from liblaf.cherries.typing import PathLike
 
 
@@ -49,7 +49,7 @@ class Comet(core.Run):
         **kwargs,
     ) -> None:
         path = Path(path)
-        name = pathutils.as_posix(name)
+        name = path_utils.as_posix(name)
         try:
             # ? I don't know why, but `dvc.api.get_url` only works with this. Maybe a DVC bug?
             dvc_path: Path = path.absolute().relative_to(Path.cwd())
@@ -128,8 +128,8 @@ class Comet(core.Run):
     @core.impl(after=("Logging",))
     def start(self, *args, **kwargs) -> None:
         self.exp = comet_ml.start(
-            project_name=self.plugin_root.project_name,
+            project_name=self.project_name,
             experiment_config=comet_ml.ExperimentConfig(
-                disabled=self.disabled, name=self.plugin_root.name
+                disabled=self.disabled, name=self.name
             ),
         )

liblaf/cherries/plugins/git_.py

@@ -52,17 +52,19 @@ class Git(core.Run):
         self.repo = git.Repo(self.project_dir, search_parent_directories=True)
 
     def _make_commit_message(self) -> str:
-        name: str = self.plugin_root.name
+        name: str = self.name
         message: str = f"chore(cherries): {name}\n\n"
-        metadata: dict[str, Any] = {}
-        metadata["cmd"] = shlex.join(sys.orig_argv)
-        if url := self.plugin_root.url:
-            metadata["url"] = url
-        if params := self.plugin_root.get_params():
-            metadata["params"] = params
+        meta: dict[str, Any] = {}
+        if url := self.url:
+            meta["url"] = url
+        meta["exp_dir"] = self.exp_dir.relative_to(self.project_dir)
+        meta["cwd"] = Path.cwd().relative_to(self.project_dir)
+        meta["cmd"] = shlex.join(sys.orig_argv)
+        if params := self.params:
+            meta["params"] = params
         if inputs := self.inputs:
-            metadata["inputs"] = inputs
+            meta["inputs"] = inputs
         if outputs := self.outputs:
-            metadata["outputs"] = outputs
-        message += grapes.yaml.encode(metadata).decode()
+            meta["outputs"] = outputs
+        message += grapes.yaml.encode(meta).decode()
         return message

liblaf/cherries/plugins/logging.py

@@ -11,7 +11,7 @@ from liblaf.cherries import core
 class Logging(core.Run):
     @property
     def log_file(self) -> Path:
-        return self.plugin_root.exp_dir / "run.log"
+        return self.exp_dir / "run.log"
 
     @override
     @core.impl
@@ -21,4 +21,4 @@ class Logging(core.Run):
     @override
     @core.impl
     def end(self, *args, **kwargs) -> None:
-        self.plugin_root.log_asset(self.log_file)
+        self.log_asset(self.log_file)

liblaf/cherries/profiles/__init__.py

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

liblaf/cherries/profiles/_factory.py

@@ -8,16 +8,15 @@ from ._abc import Profile
 from ._default import ProfileDefault  # noqa: F401
 from ._playground import ProfilePlayground  # noqa: F401
 
-# for code-completion
 type ProfileName = Literal["default", "playground"] | str  # noqa: PYI051
 type ProfileLike = ProfileName | Profile | type[Profile]
 
 
 def factory(profile: ProfileLike | None = None) -> Profile:
-    if profile is None and env.bool("DEBUG", default=False):
+    if profile is None and env.bool("DEBUG", False):
         profile = "playground"
     if profile is None:
-        profile = env.str("PROFILE", default="default")
+        profile = env.str("PROFILE", "default")
     if isinstance(profile, str):
         return Profile[profile]()
     if isinstance(profile, Profile):

liblaf/cherries/utils/__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.dist-info → liblaf_cherries-0.5.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,56 @@
+liblaf/cherries/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/__init__.pyi,sha256=A7MFyMZodmbEPTCe44P1M8JoDYyFHJLjjWqwpoq8zGg,1047
+liblaf/cherries/_entrypoint.py,sha256=mUTxSaIztxgZbnqRjPJdZOepurdb8es6M3cb6T3vQns,2317
+liblaf/cherries/_version.py,sha256=LGYtjQ6cyPZC_N0AovMIeSYYDK21050nm3HYgDanQBM,704
+liblaf/cherries/_version.pyi,sha256=Pnv4Bxw13LHeuVkPLPsTtnp4N4jOGcAfFJw05uMMgBY,108
+liblaf/cherries/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+liblaf/cherries/typing.py,sha256=mim8QVtwczTSHyw5mhEdfFcXis9o32n0CZyu8BrEorE,50
+liblaf/cherries/config/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/config/__init__.pyi,sha256=T7qc9AMlDlI9tTLx2V-3FTeYV_CFGZoS74H9Zm1WoeY,686
+liblaf/cherries/config/_config.py,sha256=xqm-jDyo0aEQoiwx6P4TQiB1xGuwy01k8t8QjalzREw,111
+liblaf/cherries/config/asset/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/config/asset/__init__.pyi,sha256=B1aEmUTqzk4ItYd4oiQKJhJsJkEhY-ODeNNaeYSq-44,701
+liblaf/cherries/config/asset/_meta.py,sha256=Kc2IALf30PO5UOB3QGGS48ecJ51hsCtEV2sAiEiGi70,3076
+liblaf/cherries/config/asset/_registry.py,sha256=0oz_mFbKkVamWcgRUbrxLD5Y_KRzR7y91S76tIt3dcg,772
+liblaf/cherries/config/asset/resolvers/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/config/asset/resolvers/__init__.pyi,sha256=eqvh9oPwnQenPs5KvzoZWrTEXwf31fd0lGlFJkIM2FU,180
+liblaf/cherries/config/asset/resolvers/_abc.py,sha256=Z2JVGV1p4BJbftGJ3vVfGnHdlAWThWcMBimYdXT0f08,382
+liblaf/cherries/config/asset/resolvers/_series.py,sha256=KBJsgmbsck_8uyPNpA8ZhkK0K1bCWOPm3SAV4IqStkQ,492
+liblaf/cherries/config/asset/resolvers/_vtk.py,sha256=nOrUO9YwkmbV58zPf9xWw75sF9dWzH9YHcrn6mPrgso,722
+liblaf/cherries/core/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/core/__init__.pyi,sha256=L6acWsE350FQUx14RF94tttvrcvs5EpdA3WHVGmsOSo,1022
+liblaf/cherries/core/_impl.py,sha256=YdUR7Kf68z3JERHB3_2bYSMEe1OCqEwZL3bPP802jjs,1763
+liblaf/cherries/core/_plugin.py,sha256=hPdsKK_XwZSTNtIJwZIAlFgoelY7aqLXlBWsc5y6wIY,3297
+liblaf/cherries/core/_run.py,sha256=BzbGxNFsVhv5j2G8FcAXCwrQKl97wfVC9Xfo89R605M,4255
+liblaf/cherries/core/_spec.py,sha256=YyKQh6CJf3Yn2SuTnQXwCLN8OflnTh9t2FYP-tn5yEE,1850
+liblaf/cherries/core/_utils.py,sha256=ElNiHkrxhntmtF_6kgoCnIvSx1nJBt71XLfRTrYC9a4,2144
+liblaf/cherries/core/typing.py,sha256=razpiUtLAGFD9J4H5RbIEHKEXWzxFHFjtOBBRllhea4,42
+liblaf/cherries/meta/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/meta/__init__.pyi,sha256=kQFneP3IiV9rBIzpep_uX0z-5IRPrXkPmyNRt19j8fg,282
+liblaf/cherries/meta/_git.py,sha256=4EM8txj7HZ93VP-lkedxh6f7DxiZmjea65b9Y3U0AZM,1228
+liblaf/cherries/meta/_name.py,sha256=-uzzeXkjnKExm_xqsfOQPctwb6cZg7i-tR4fdXMYKjs,562
+liblaf/cherries/path_utils/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/path_utils/__init__.pyi,sha256=fxSfaa4GaYvlVbeXvdyavbrryeY7QjgPV6q1hLrQaA8,337
+liblaf/cherries/path_utils/_convert.py,sha256=aIrFYE3UoZ9m85-0uYaS_eXmBqZbeJbTgezstbUQrFM,808
+liblaf/cherries/path_utils/_path.py,sha256=PikGdRMF3b3ajrHCMIakXPaIwixC8ObMjXGa8n_ucvM,1102
+liblaf/cherries/path_utils/_special.py,sha256=HVmH6lCnj1TVzjAEmO93MGMTQi7JQWss4sHSNMieczY,1100
+liblaf/cherries/plugins/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/plugins/__init__.pyi,sha256=dyTB5ZS78Kg_7oWeChk_h7Ry_gU9k1sDiL5YOmnoG7I,177
+liblaf/cherries/plugins/comet.py,sha256=9nFk4QS7TFmp_8FNgUv0dwQD3DYmGEdDnhnUI3_LWZE,3994
+liblaf/cherries/plugins/dvc.py,sha256=1ktBxHIPhAYoN_Bto1c5BOn9VxKVBDK85s5rmlB2vvE,1053
+liblaf/cherries/plugins/git_.py,sha256=E8lPFEZjmiHy5CBADBvRa9eBHFz6BbvwL82Y_rOcP-w,2113
+liblaf/cherries/plugins/local.py,sha256=m01v9ifvoAza8z_LiIWlZNNK2b-69wcWS29N54X1Vio,1679
+liblaf/cherries/plugins/logging.py,sha256=lhs6Xm2WAh8t13mqjBs1su4gJMANFrKIm4vCqUz39xw,509
+liblaf/cherries/profiles/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/profiles/__init__.pyi,sha256=qXxy2LOG9hE0LKCnECdJSv2VoHhOTMVDE3sUKIuZKmw,292
+liblaf/cherries/profiles/_abc.py,sha256=1tpRrocBZNHonWaj3a264GnL5UoGS_HqU06aNZpruqY,193
+liblaf/cherries/profiles/_default.py,sha256=cfV003HBA5aGAZkgDDaHAyongFcxCWYsEFpSQNICcMs,440
+liblaf/cherries/profiles/_factory.py,sha256=OONaNS5cuHpPL-GwpkQp4jio9ce4fgAGr7pDB9JvOs0,720
+liblaf/cherries/profiles/_playground.py,sha256=Aru-7RVoxNhomPLUxDLiM5wD5ZCPLy5Eymw0xQL2F9g,384
+liblaf/cherries/utils/__init__.py,sha256=MfsYnXmbxgr6l1QHFkUgtppkaBNzkeRle6dMNcWGdxk,106
+liblaf/cherries/utils/__init__.pyi,sha256=F5aTcXpWVmUoctPbLfmQXKyuXYRspAIjaIzfL1_3Lrw,51
+liblaf/cherries/utils/_functools.py,sha256=0Puwvj1Wq4kp3S--hI-CXwUBZ56AtfkqIzFHllQtuug,181
+liblaf_cherries-0.5.2.dist-info/METADATA,sha256=2owxtYgSPs0Q85PG2aKeuuy1L22h9JthZRoW-FcnCLU,7055
+liblaf_cherries-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+liblaf_cherries-0.5.2.dist-info/licenses/LICENSE,sha256=Ph4NzyU3lGVDeYv-mf8aRmImH8v9rVL9F362FV4G6Ow,1063
+liblaf_cherries-0.5.2.dist-info/RECORD,,

liblaf/cherries/config/_asset.py

@@ -1,115 +0,0 @@
-import enum
-from collections.abc import Callable, Iterable
-from pathlib import Path
-from typing import Any, Literal
-
-import pydantic
-
-from liblaf import grapes
-from liblaf.cherries import pathutils
-from liblaf.cherries.typing import PathLike
-
-
-class AssetKind(enum.StrEnum):
-    INPUT = enum.auto()
-    OUTPUT = enum.auto()
-
-
-type PathGenerator = (
-    PathLike | Iterable[PathLike] | Callable[[PathLike], PathLike | Iterable[PathLike]]
-)
-
-
-path_generators: dict[str, PathGenerator] = {}
-
-
-def _path_generator_series(path: PathLike) -> list[Path]:
-    path = Path(path)
-    if (folder := path.with_suffix(".d")).exists():
-        return [folder]
-    if (folder := path.with_suffix("")).exists():
-        return [folder]
-    return []
-
-
-path_generators[".series"] = _path_generator_series
-
-
-class MetaAsset:
-    kind: AssetKind
-    _extra: PathGenerator | None = None
-
-    def __init__(self, kind: AssetKind, extra: PathGenerator | None = None) -> None:
-        self.kind = kind
-        self._extra = extra
-
-    def get_extra(self, value: Path) -> list[Path]:
-        extra: PathGenerator | None = self._extra
-        if extra is None:
-            extra = path_generators.get(value.suffix)
-        if extra is None:
-            return []
-        if callable(extra):
-            extra = extra(value)
-        extra = grapes.as_iterable(extra)
-        return [Path(p) for p in extra]
-
-
-def asset(
-    path: PathLike, extra: PathGenerator | None = None, *, kind: AssetKind, **kwargs
-) -> Path:
-    field_info: pydantic.fields.FieldInfo = pydantic.Field(
-        pathutils.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) -> list[Path]:
-    assets: list[Path] = []
-    for name, info in type(cfg).model_fields.items():
-        value: Any = getattr(cfg, name)
-        if isinstance(value, pydantic.BaseModel):
-            assets.extend(get_assets(value, kind))
-        for meta in info.metadata:
-            if isinstance(meta, MetaAsset) and meta.kind == kind:
-                value: Path = Path(value)
-                assets.append(value)
-                assets.extend(meta.get_extra(value))
-    return assets
-
-
-def get_inputs(cfg: pydantic.BaseModel) -> list[Path]:
-    return get_assets(cfg, AssetKind.INPUT)
-
-
-def get_outputs(cfg: pydantic.BaseModel) -> list[Path]:
-    return get_assets(cfg, AssetKind.OUTPUT)
-
-
-def input(path: PathLike, extra: PathGenerator | None = 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: PathGenerator | None = None, **kwargs) -> Path:
-    return asset(path, extra=extra, kind=AssetKind.OUTPUT, **kwargs)

liblaf_cherries-0.5.0.dist-info/RECORD

@@ -1,48 +0,0 @@
-liblaf/cherries/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/__init__.pyi,sha256=lbens0QYeWVUsnCHZ6fyAh51dXuUPX5nU_f-VUK16jo,1044
-liblaf/cherries/_entrypoint.py,sha256=6tUIM1SX__UcMonzPzqXMcbMhD1rif7Oc7FFtMKIM0Q,2268
-liblaf/cherries/_version.py,sha256=fvHpBU3KZKRinkriKdtAt3crenOyysELF-M9y3ozg3U,704
-liblaf/cherries/_version.pyi,sha256=Pnv4Bxw13LHeuVkPLPsTtnp4N4jOGcAfFJw05uMMgBY,108
-liblaf/cherries/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-liblaf/cherries/typing.py,sha256=mim8QVtwczTSHyw5mhEdfFcXis9o32n0CZyu8BrEorE,50
-liblaf/cherries/config/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/config/__init__.pyi,sha256=qD-iWfQVHg1vDcCpHg28LvHHxagMsS2bQT6CZE7mrH0,469
-liblaf/cherries/config/_asset.py,sha256=alEOKiXlYC6wnLZOARSmYMGjFFvGf0sXJ1_hBSK0cts,3463
-liblaf/cherries/config/_config.py,sha256=WPwwk-3O96FyHGb2W8__LDfHpXBHLQM44aOcrMPjDL4,171
-liblaf/cherries/core/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/core/__init__.pyi,sha256=jgmGgzlTDlyFKHnSjNw3g22ZBuBQ07NmeRiq4qKZFdg,727
-liblaf/cherries/core/_impl.py,sha256=LCd4f5oX5bEMa4uX37r0yiPntqZM1Lwqrd7vKL1oc7w,1459
-liblaf/cherries/core/_plugin.py,sha256=wv_G-cZK1WHPX5JSLPvKrnFJRnEwRxPuS5szN7DTRTc,3187
-liblaf/cherries/core/_run.py,sha256=kNU04SxQSpZzWvx_tCUlfR-7ll3-LuQqFJD2gfcWyhQ,5039
-liblaf/cherries/core/_spec.py,sha256=F73wxygkc_3v0hOKwfFSGaLRHEDhhENWLQZakruuRq8,1950
-liblaf/cherries/core/_utils.py,sha256=WpS79yqTH0Kl9ewzCIAiUcxamHKzJOB7ZWhjq_13bzY,572
-liblaf/cherries/core/typed.py,sha256=razpiUtLAGFD9J4H5RbIEHKEXWzxFHFjtOBBRllhea4,42
-liblaf/cherries/meta/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/meta/__init__.pyi,sha256=kQFneP3IiV9rBIzpep_uX0z-5IRPrXkPmyNRt19j8fg,282
-liblaf/cherries/meta/_git.py,sha256=89isF_ur7qvI4YSmiBTim8ds7DtCtHUfeiCkoK0g6G8,1225
-liblaf/cherries/meta/_name.py,sha256=igjQ8TLxQbTesvWKakQDpytAheNhZ-R1d1MRZhgMPxM,559
-liblaf/cherries/pathutils/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/pathutils/__init__.pyi,sha256=fxSfaa4GaYvlVbeXvdyavbrryeY7QjgPV6q1hLrQaA8,337
-liblaf/cherries/pathutils/_convert.py,sha256=aIrFYE3UoZ9m85-0uYaS_eXmBqZbeJbTgezstbUQrFM,808
-liblaf/cherries/pathutils/_path.py,sha256=PikGdRMF3b3ajrHCMIakXPaIwixC8ObMjXGa8n_ucvM,1102
-liblaf/cherries/pathutils/_special.py,sha256=HVmH6lCnj1TVzjAEmO93MGMTQi7JQWss4sHSNMieczY,1100
-liblaf/cherries/plugins/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/plugins/__init__.pyi,sha256=dyTB5ZS78Kg_7oWeChk_h7Ry_gU9k1sDiL5YOmnoG7I,177
-liblaf/cherries/plugins/comet.py,sha256=LquXaN4hTUhbSwKVeWtErWUeys5aoRK8nP38yETmJfU,4016
-liblaf/cherries/plugins/dvc.py,sha256=1ktBxHIPhAYoN_Bto1c5BOn9VxKVBDK85s5rmlB2vvE,1053
-liblaf/cherries/plugins/git_.py,sha256=UBXwEbU8FJ59aAZf99JPE6d56ULMXdkzRpUCyZKM7cM,2051
-liblaf/cherries/plugins/local.py,sha256=m01v9ifvoAza8z_LiIWlZNNK2b-69wcWS29N54X1Vio,1679
-liblaf/cherries/plugins/logging.py,sha256=A2-fd7H96Jtg1eOOmMYp7AmT3133vDHd4HAklhjH6n0,533
-liblaf/cherries/profiles/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/profiles/__init__.pyi,sha256=qXxy2LOG9hE0LKCnECdJSv2VoHhOTMVDE3sUKIuZKmw,292
-liblaf/cherries/profiles/_abc.py,sha256=1tpRrocBZNHonWaj3a264GnL5UoGS_HqU06aNZpruqY,193
-liblaf/cherries/profiles/_default.py,sha256=cfV003HBA5aGAZkgDDaHAyongFcxCWYsEFpSQNICcMs,440
-liblaf/cherries/profiles/_factory.py,sha256=d-PaE8JYllkzcqQDiyi5aP52lFJOkFdLai3XXgSKAE8,758
-liblaf/cherries/profiles/_playground.py,sha256=Aru-7RVoxNhomPLUxDLiM5wD5ZCPLy5Eymw0xQL2F9g,384
-liblaf/cherries/utils/__init__.py,sha256=OHb6Xou2v6u42swTgjRfzej4CIlRg4OmgOIQXUiRjKA,97
-liblaf/cherries/utils/__init__.pyi,sha256=F5aTcXpWVmUoctPbLfmQXKyuXYRspAIjaIzfL1_3Lrw,51
-liblaf/cherries/utils/_functools.py,sha256=0Puwvj1Wq4kp3S--hI-CXwUBZ56AtfkqIzFHllQtuug,181
-liblaf_cherries-0.5.0.dist-info/METADATA,sha256=rgnXriF6xt__GYW-nOb9K1ywv1irJJI7EWh9KFHa_gA,7023
-liblaf_cherries-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-liblaf_cherries-0.5.0.dist-info/licenses/LICENSE,sha256=Ph4NzyU3lGVDeYv-mf8aRmImH8v9rVL9F362FV4G6Ow,1063
-liblaf_cherries-0.5.0.dist-info/RECORD,,