pico-ioc 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

pico_ioc/infra.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+import re
+from typing import Any, Callable, Iterable, Optional, Sequence, Tuple
+
+class Select:
+    def __init__(self):
+        self._tags: set[str] = set()
+        self._profiles: set[str] = set()
+        self._class_name_regex: Optional[re.Pattern[str]] = None
+        self._method_name_regex: Optional[re.Pattern[str]] = None
+
+    def has_tag(self, *tags: str) -> "Select":
+        self._tags.update(t for t in tags if t)
+        return self
+
+    def profile_in(self, *profiles: str) -> "Select":
+        self._profiles.update(p for p in profiles if p)
+        return self
+
+    def class_name(self, regex: str) -> "Select":
+        self._class_name_regex = re.compile(regex)
+        return self
+
+    def method_name(self, regex: str) -> "Select":
+        self._method_name_regex = re.compile(regex)
+        return self
+
+    def is_effectively_empty(self) -> bool:
+        return not (self._tags or self._profiles or self._class_name_regex or self._method_name_regex)
+
+    def match_provider(self, key: Any, meta: dict, *, active_profiles: Sequence[str]) -> bool:
+        if self.is_effectively_empty():
+            return False
+        if self._tags:
+            tags = set(meta.get("tags", ()))
+            if not tags.intersection(self._tags):
+                return False
+        if self._profiles:
+            if not set(active_profiles).intersection(self._profiles):
+                return False
+        if self._class_name_regex and isinstance(key, type):
+            if not self._class_name_regex.search(getattr(key, "__name__", "")):
+                return False
+        return True
+
+    def match_method_name(self, method: str) -> bool:
+        if self._method_name_regex is None:
+            return True
+        return bool(self._method_name_regex.search(method))
+
+
+class InfraQuery:
+    def __init__(self, container, profiles: Tuple[str, ...]):
+        self.c = container
+        self.profiles = profiles
+
+    def providers(self, where: Optional[Select] = None, *, limit: Optional[int] = None) -> list[tuple[Any, dict]]:
+        sel = where or Select()
+        items: list[tuple[Any, dict]] = []
+        for k, m in self.c._providers.items():
+            if sel.match_provider(k, m, active_profiles=self.profiles):
+                items.append((k, m))
+                if limit is not None and len(items) >= limit:
+                    break
+        return items
+
+    def components(self, where: Optional[Select] = None, *, limit: Optional[int] = None) -> list[type]:
+        out: list[type] = []
+        for k, _m in self.providers(where=where, limit=limit):
+            if isinstance(k, type):
+                out.append(k)
+        return out
+
+
+class InfraIntercept:
+    def __init__(self, container, profiles: Tuple[str, ...]):
+        self.c = container
+        self.profiles = profiles
+        self._per_method_cap: Optional[int] = None
+
+    def _collect_target_classes(self, where: Select) -> tuple[set[type], set[Any]]:
+        classes: set[type] = set()
+        keys: set[Any] = set()
+        for key, meta in self.c._providers.items():
+            if where.match_provider(key, meta, active_profiles=self.profiles):
+                keys.add(key)
+                if isinstance(key, type):
+                    classes.add(key)
+        return classes, keys
+
+    def _guard_method_interceptor(self, interceptor, where: Select):
+        target_classes, _keys = self._collect_target_classes(where)
+        class_names = {cls.__name__ for cls in target_classes}
+        class Guarded:
+            def invoke(self, ctx, call_next):
+                tgt_cls = type(ctx.instance)
+                ok_class = any(isinstance(ctx.instance, cls) for cls in target_classes) or (getattr(tgt_cls, "__name__", "") in class_names)
+                ok_method = where.match_method_name(ctx.name)
+                if ok_class and ok_method:
+                    return interceptor.invoke(ctx, call_next) if hasattr(interceptor, "invoke") else interceptor(ctx, call_next)
+                return call_next(ctx)
+        return Guarded()
+
+    def _guard_container_interceptor(self, interceptor, where: Select):
+        target_classes, keys = self._collect_target_classes(where)
+        class_names = {cls.__name__ for cls in target_classes}
+        def _ok(key: Any) -> bool:
+            if key in keys:
+                return True
+            if isinstance(key, type) and (key in target_classes or getattr(key, "__name__", "") in class_names):
+                return True
+            return False
+        class GuardedCI:
+            def around_resolve(self, ctx, call_next):
+                if _ok(ctx.key):
+                    return interceptor.around_resolve(ctx, call_next)
+                return call_next(ctx)
+            def around_create(self, ctx, call_next):
+                if _ok(ctx.key):
+                    return interceptor.around_create(ctx, call_next)
+                return call_next(ctx)
+        return GuardedCI()
+
+    def add(self, *, interceptor, where: Select) -> None:
+        sel = where or Select()
+        if sel.is_effectively_empty():
+            raise ValueError("empty selector for interceptor")
+        is_container = all(hasattr(interceptor, m) for m in ("around_resolve", "around_create"))
+        if is_container:
+            guarded = self._guard_container_interceptor(interceptor, sel)
+            self.c.add_container_interceptor(guarded)
+            return
+        guarded = self._guard_method_interceptor(interceptor, sel)
+        self.c.add_method_interceptor(guarded)
+
+    def limit_per_method(self, max_n: int) -> None:
+        self._per_method_cap = int(max_n)
+
+
+class InfraMutate:
+    def __init__(self, container, profiles: Tuple[str, ...]):
+        self.c = container
+        self.profiles = profiles
+
+    def add_tags(self, component_or_key: Any, tags: Iterable[str]) -> None:
+        key = component_or_key
+        if key in self.c._providers:
+            meta = self.c._providers[key]
+            cur = tuple(meta.get("tags", ()))
+            new = tuple(dict.fromkeys(list(cur) + [t for t in tags if t]))
+            meta["tags"] = new
+            self.c._providers[key] = meta
+
+    def set_qualifiers(self, provider_key: Any, qualifiers: dict[str, Any]) -> None:
+        if provider_key in self.c._providers:
+            meta = self.c._providers[provider_key]
+            meta["qualifiers"] = tuple(qualifiers or ())
+            self.c._providers[provider_key] = meta
+
+    def replace_provider(self, *, key: Any, with_factory: Callable[[], object]) -> None:
+        if key in self.c._providers:
+            lazy = bool(self.c._providers[key].get("lazy", False))
+            self.c.bind(key, with_factory, lazy=lazy, tags=self.c._providers[key].get("tags", ()))
+
+    def wrap_provider(self, *, key: Any, around: Callable[[Callable[[], object]], Callable[[], object]]) -> None:
+        if key in self.c._providers:
+            meta = self.c._providers[key]
+            base_factory = meta.get("factory")
+            if callable(base_factory):
+                wrapped = around(base_factory)
+                self.c.bind(key, wrapped, lazy=bool(meta.get("lazy", False)), tags=meta.get("tags", ()))
+
+    def rename_key(self, *, old: Any, new: Any) -> None:
+        if old in self.c._providers and new not in self.c._providers:
+            self.c._providers[new] = self.c._providers.pop(old)
+
+class Infra:
+    def __init__(self, *, container, profiles: Tuple[str, ...]):
+        self._c = container
+        self._profiles = profiles
+        self._query = InfraQuery(container, profiles)
+        self._intercept = InfraIntercept(container, profiles)
+        self._mutate = InfraMutate(container, profiles)
+
+    @property
+    def query(self) -> InfraQuery:
+        return self._query
+
+    @property
+    def intercept(self) -> InfraIntercept:
+        return self._intercept
+
+    @property
+    def mutate(self) -> InfraMutate:
+        return self._mutate
+

pico_ioc/interceptors.py

@@ -1,50 +1,76 @@
-# pico_ioc/interceptors.py
 from __future__ import annotations
-from typing import Any, Callable, Protocol, Sequence
 import inspect
+from typing import Any, Callable, Protocol, Sequence
 
-class Invocation:
-    __slots__ = ("target", "method_name", "call", "args", "kwargs", "is_async")
-
-    def __init__(self, target: object, method_name: str, call: Callable[..., Any],
-                 args: tuple, kwargs: dict):
-        self.target = target
-        self.method_name = method_name
-        self.call = call
+class MethodCtx:
+    __slots__ = ("instance", "cls", "method", "name", "args", "kwargs", "container", "tags", "qualifiers", "request_key", "local")
+    def __init__(self, *, instance: object, cls: type, method: Callable[..., Any], name: str, args: tuple, kwargs: dict, container: Any, tags: set[str] | None = None, qualifiers: dict[str, Any] | None = None, request_key: Any = None):
+        self.instance = instance
+        self.cls = cls
+        self.method = method
+        self.name = name
         self.args = args
         self.kwargs = kwargs
-        self.is_async = inspect.iscoroutinefunction(call)
+        self.container = container
+        self.tags = set(tags or ())
+        self.qualifiers = dict(qualifiers or {})
+        self.request_key = request_key
+        self.local: dict[str, Any] = {}
+
+class ResolveCtx:
+    __slots__ = ("key", "qualifiers", "requested_by", "profiles", "local")
+    def __init__(self, *, key: Any, qualifiers: dict[str, Any] | None, requested_by: Any, profiles: Sequence[str]):
+        self.key = key
+        self.qualifiers = dict(qualifiers or {})
+        self.requested_by = requested_by
+        self.profiles = tuple(profiles or ())
+        self.local: dict[str, Any] = {}
+
+class CreateCtx:
+    __slots__ = ("key", "component", "provider", "profiles", "local")
+    def __init__(self, *, key: Any, component: type | None, provider: Callable[[], object], profiles: Sequence[str]):
+        self.key = key
+        self.component = component
+        self.provider = provider
+        self.profiles = tuple(profiles or ())
+        self.local: dict[str, Any] = {}
 
 class MethodInterceptor(Protocol):
-    def __call__(self, inv: Invocation, proceed: Callable[[], Any]) -> Any: ...
+    def invoke(self, ctx: MethodCtx, call_next: Callable[[MethodCtx], Any]) -> Any: ...
 
-async def _chain_async(interceptors: Sequence[MethodInterceptor], inv: Invocation, i: int = 0):
+class ContainerInterceptor(Protocol):
+    def around_resolve(self, ctx: ResolveCtx, call_next: Callable[[ResolveCtx], Any]) -> Any: ...
+    def around_create(self, ctx: CreateCtx, call_next: Callable[[CreateCtx], Any]) -> Any: ...
+
+def _dispatch_method(interceptors: Sequence[MethodInterceptor], ctx: MethodCtx, i: int = 0):
     if i >= len(interceptors):
-        return await inv.call(*inv.args, **inv.kwargs)
+        return ctx.method(*ctx.args, **ctx.kwargs)
     cur = interceptors[i]
-    async def next_step():
-        return await _chain_async(interceptors, inv, i + 1)
-    res = cur(inv, next_step)
-    return await res if inspect.isawaitable(res) else res
+    return cur.invoke(ctx, lambda nxt: _dispatch_method(interceptors, nxt, i + 1))
 
-def _chain_sync(interceptors: Sequence[MethodInterceptor], inv: Invocation, i: int = 0):
+async def _dispatch_method_async(interceptors: Sequence[MethodInterceptor], ctx: MethodCtx, i: int = 0):
     if i >= len(interceptors):
-        return inv.call(*inv.args, **inv.kwargs)
+        return await ctx.method(*ctx.args, **ctx.kwargs)
     cur = interceptors[i]
-    return cur(inv, lambda: _chain_sync(interceptors, inv, i + 1))
+    res = cur.invoke(ctx, lambda nxt: _dispatch_method_async(interceptors, nxt, i + 1))
+    return await res if inspect.isawaitable(res) else res
 
-def dispatch(interceptors: Sequence[MethodInterceptor], inv: Invocation):
-    if inv.is_async:
-        # return a coroutine that the caller will await
-        return _chain_async(interceptors, inv, 0)
-    # return the final value directly for sync methods
-    res = _chain_sync(interceptors, inv, 0)
-    return res
+def dispatch_method(interceptors: Sequence[MethodInterceptor], ctx: MethodCtx):
+    if inspect.iscoroutinefunction(ctx.method):
+        return _dispatch_method_async(interceptors, ctx, 0)
+    return _dispatch_method(interceptors, ctx, 0)
 
+def run_resolve_chain(interceptors: Sequence[ContainerInterceptor], ctx: ResolveCtx):
+    def call(i: int, c: ResolveCtx):
+        if i >= len(interceptors):
+            return None
+        return interceptors[i].around_resolve(c, lambda nxt: call(i + 1, nxt))
+    return call(0, ctx)
 
-class ContainerInterceptor(Protocol):
-    def on_resolve(self, key: Any, annotation: Any, qualifiers: tuple[str, ...] | tuple()) -> None: ...
-    def on_before_create(self, key: Any) -> None: ...
-    def on_after_create(self, key: Any, instance: Any) -> Any: ...
-    def on_exception(self, key: Any, exc: BaseException) -> None: ...
+def run_create_chain(interceptors: Sequence[ContainerInterceptor], ctx: CreateCtx):
+    def call(i: int, c: CreateCtx):
+        if i >= len(interceptors):
+            return c.provider()
+        return interceptors[i].around_create(c, lambda nxt: call(i + 1, nxt))
+    return call(0, ctx)