liblaf-cherries 0.4.3__py3-none-any.whl → 0.5.1__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, paths, 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,17 +15,16 @@ from .core import (
     log_parameter,
     log_parameters,
 )
-from .paths import (
+from .path_utils import (
     as_os_path,
     as_path,
     as_posix,
     data,
     entrypoint,
     exp_dir,
-    git_root,
-    git_root_safe,
     params,
     path,
+    project_dir,
     src,
 )
 
@@ -43,8 +42,6 @@ __all__ = [
     "end",
     "entrypoint",
     "exp_dir",
-    "git_root",
-    "git_root_safe",
     "input",
     "log_asset",
     "log_input",
@@ -59,8 +56,9 @@ __all__ = [
     "output",
     "params",
     "path",
-    "paths",
+    "path_utils",
     "plugins",
+    "project_dir",
     "run",
     "src",
     "start",

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(
@@ -40,8 +41,8 @@ def start(
 ) -> core.Run:
     run: core.Run = profiles.factory(profile).init()
     run.start()
-    run.log_other("cherries.entrypoint", run.entrypoint.relative_to(run.root_dir))
-    run.log_other("cherries.exp_dir", run.exp_dir.relative_to(run.root_dir))
+    run.log_other("cherries.entrypoint", run.entrypoint.relative_to(run.project_dir))
+    run.log_other("cherries.exp_dir", run.exp_dir.relative_to(run.project_dir))
     run.log_other("cherries.start_time", run.start_time)
     return run
 

liblaf/cherries/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.4.3'
-__version_tuple__ = version_tuple = (0, 4, 3)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
 
 __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,7 +1,14 @@
-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,
@@ -9,13 +16,18 @@ from ._asset import (
     model_dump_without_assets,
     output,
 )
-from ._config import BaseConfig
 
 __all__ = [
     "AssetKind",
+    "AssetResolver",
+    "AssetResolverRegistry",
+    "AssetResolverSeries",
+    "AssetResolverVtk",
     "BaseConfig",
+    "Extra",
     "MetaAsset",
-    "PathGenerator",
+    "asset",
+    "asset_resolver_registry",
     "get_assets",
     "get_inputs",
     "get_outputs",

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/{paths → 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,30 +1,29 @@
-from collections.abc import Mapping, MutableMapping, Sequence
+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
+from ._impl import ImplInfo, collect_impls, get_impl_info
+from .typing import MethodName, PluginId
 
 
 @attrs.define
 class Plugin:
-    plugins: dict[str, "Plugin"] = attrs.field(factory=dict, kw_only=True)
+    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: MutableMapping[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
+        )