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

pico_ioc/decorators.py

@@ -1,11 +1,6 @@
-# src/pico_ioc/decorators.py
 from __future__ import annotations
-
 import functools
-from typing import Any, Iterable, Optional, Callable, Tuple, Literal
-
-
-# ---- marker attributes (read by scanner/policy) ----
+from typing import Any, Iterable, Optional, Callable, Tuple
 
 COMPONENT_FLAG = "_is_component"
 COMPONENT_KEY = "_component_key"
@@ -25,19 +20,13 @@ ON_MISSING_META = "_pico_on_missing"
 PRIMARY_FLAG = "_pico_primary"
 CONDITIONAL_META = "_pico_conditional"
 
-INTERCEPTOR_META = "__pico_interceptor__"
-
-
-# ---- core decorators ----
+INFRA_META = "__pico_infrastructure__"
 
 def factory_component(cls):
-    """Mark a class as a factory component (its methods can @provides)."""
     setattr(cls, FACTORY_FLAG, True)
     return cls
 
-
 def component(cls=None, *, name: Any = None, lazy: bool = False, tags: Iterable[str] = ()):
-    """Mark a class as a component. Optional: custom key, lazy instantiation, tags."""
     def dec(c):
         setattr(c, COMPONENT_FLAG, True)
         setattr(c, COMPONENT_KEY, name if name is not None else c)
@@ -46,9 +35,7 @@ def component(cls=None, *, name: Any = None, lazy: bool = False, tags: Iterable[
         return c
     return dec(cls) if cls else dec
 
-
 def provides(key: Any, *, lazy: bool = False, tags: Iterable[str] = ()):
-    """Declare a factory method that provides a binding for `key`."""
     def dec(fn):
         @functools.wraps(fn)
         def w(*a, **k):
@@ -59,22 +46,14 @@ def provides(key: Any, *, lazy: bool = False, tags: Iterable[str] = ()):
         return w
     return dec
 
-
 def plugin(cls):
-    """Mark a class as a Pico plugin (scanner lifecycle)."""
     setattr(cls, PLUGIN_FLAG, True)
     return cls
 
-
-# ---- qualifiers ----
-
 class Qualifier(str):
-    """String qualifier type used with Annotated[T, 'q1', ...]."""
     __slots__ = ()
 
-
 def qualifier(*qs: Qualifier):
-    """Attach one or more qualifiers to a component class key."""
     def dec(cls):
         current: Iterable[Qualifier] = getattr(cls, QUALIFIERS_KEY, ())
         seen = set(current)
@@ -87,30 +66,22 @@ def qualifier(*qs: Qualifier):
         return cls
     return dec
 
-
-# ---- defaults / selection ----
-
 def on_missing(selector: object, *, priority: int = 0):
-    """Declare this target as a default for `selector` when no binding exists."""
     def dec(obj):
         setattr(obj, ON_MISSING_META, {"selector": selector, "priority": int(priority)})
         return obj
     return dec
 
-
 def primary(obj):
-    """Hint this candidate should be preferred among equals."""
     setattr(obj, PRIMARY_FLAG, True)
     return obj
 
-
 def conditional(
     *,
     profiles: Tuple[str, ...] = (),
     require_env: Tuple[str, ...] = (),
     predicate: Optional[Callable[[], bool]] = None,
 ):
-    """Activate only when profiles/env/predicate conditions pass."""
     def dec(obj):
         setattr(obj, CONDITIONAL_META, {
             "profiles": tuple(profiles),
@@ -120,39 +91,30 @@ def conditional(
         return obj
     return dec
 
-
-# ---- interceptors ----
-
-def interceptor(
-    _obj=None,
-    *,
-    kind: Literal["method", "container"] = "method",
-    order: int = 0,
+def infrastructure(
+    _cls=None, *, order: int = 0,
     profiles: Tuple[str, ...] = (),
     require_env: Tuple[str, ...] = (),
-    predicate: Callable[[], bool] | None = None,
+    predicate: Optional[Callable[[], bool]] = None,
 ):
-    """Declare an interceptor (method or container) with optional activation metadata."""
-    def dec(obj):
-        setattr(obj, INTERCEPTOR_META, {
-            "kind": kind,
+    def dec(cls):
+        setattr(cls, INFRA_META, {
             "order": int(order),
             "profiles": tuple(profiles),
             "require_env": tuple(require_env),
             "predicate": predicate,
         })
-        return obj
-    return dec if _obj is None else dec(_obj)
-
+        return cls
+    return dec if _cls is None else dec(_cls)
 
 __all__ = [
     "component", "factory_component", "provides", "plugin",
     "Qualifier", "qualifier",
-    "on_missing", "primary", "conditional", "interceptor",
+    "on_missing", "primary", "conditional", "infrastructure",
     "COMPONENT_FLAG", "COMPONENT_KEY", "COMPONENT_LAZY",
     "FACTORY_FLAG", "PROVIDES_KEY", "PROVIDES_LAZY",
     "PLUGIN_FLAG", "QUALIFIERS_KEY", "COMPONENT_TAGS", "PROVIDES_TAGS",
     "ON_MISSING_META", "PRIMARY_FLAG", "CONDITIONAL_META",
-    "INTERCEPTOR_META",
+    "INFRA_META",
 ]
 

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,56 +1,76 @@
-# src/pico_ioc/interceptors.py
 from __future__ import annotations
-
 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: ...
 
+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: ...
 
-async def _chain_async(interceptors: Sequence[MethodInterceptor], inv: Invocation, i: int = 0):
+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]
+    return cur.invoke(ctx, lambda nxt: _dispatch_method(interceptors, nxt, i + 1))
 
-    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
-
-
-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))
-
-
-def dispatch(interceptors: Sequence[MethodInterceptor], inv: Invocation):
-    """Dispatch invocation through a chain of interceptors."""
-    if inv.is_async:
-        return _chain_async(interceptors, inv, 0)  # coroutine
-    return _chain_sync(interceptors, inv, 0)       # value
-
+    res = cur.invoke(ctx, lambda nxt: _dispatch_method_async(interceptors, nxt, i + 1))
+    return await res if inspect.isawaitable(res) else res
 
-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 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)
+
+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)
 

pico_ioc/proxy.py

@@ -1,15 +1,12 @@
-# src/pico_ioc/proxy.py
 from __future__ import annotations
 
 import inspect
 from functools import lru_cache
 from typing import Any, Callable, Sequence
 
-from .interceptors import Invocation, dispatch, MethodInterceptor
-
+from .interceptors import MethodCtx, MethodInterceptor, dispatch_method
 
 class ComponentProxy:
-    """Proxy for lazy components. Creates the real object only when accessed."""
     def __init__(self, object_creator: Callable[[], Any]):
         object.__setattr__(self, "_object_creator", object_creator)
         object.__setattr__(self, "__real_object", None)
@@ -31,8 +28,6 @@ class ComponentProxy:
     def __str__(self): return str(self._get_real_object())
     def __repr__(self): return repr(self._get_real_object())
     def __dir__(self): return dir(self._get_real_object())
-
-    # container-like behavior
     def __len__(self): return len(self._get_real_object())
     def __getitem__(self, key): return self._get_real_object()[key]
     def __setitem__(self, key, value): self._get_real_object()[key] = value
@@ -40,8 +35,6 @@ class ComponentProxy:
     def __iter__(self): return iter(self._get_real_object())
     def __reversed__(self): return reversed(self._get_real_object())
     def __contains__(self, item): return item in self._get_real_object()
-
-    # operators
     def __add__(self, other): return self._get_real_object() + other
     def __sub__(self, other): return self._get_real_object() - other
     def __mul__(self, other): return self._get_real_object() * other
@@ -56,8 +49,6 @@ class ComponentProxy:
     def __and__(self, other): return self._get_real_object() & other
     def __xor__(self, other): return self._get_real_object() ^ other
     def __or__(self, other): return self._get_real_object() | other
-
-    # reflected operators
     def __radd__(self, other): return other + self._get_real_object()
     def __rsub__(self, other): return other - self._get_real_object()
     def __rmul__(self, other): return other * self._get_real_object()
@@ -72,8 +63,6 @@ class ComponentProxy:
     def __rand__(self, other): return other & self._get_real_object()
     def __rxor__(self, other): return other ^ self._get_real_object()
     def __ror__(self, other): return other | self._get_real_object()
-
-    # misc
     def __neg__(self): return -self._get_real_object()
     def __pos__(self): return +self._get_real_object()
     def __abs__(self): return abs(self._get_real_object())
@@ -86,20 +75,18 @@ class ComponentProxy:
     def __ge__(self, other): return self._get_real_object() >= other
     def __hash__(self): return hash(self._get_real_object())
     def __bool__(self): return bool(self._get_real_object())
-
-    # callables & context
     def __call__(self, *args, **kwargs): return self._get_real_object()(*args, **kwargs)
     def __enter__(self): return self._get_real_object().__enter__()
     def __exit__(self, exc_type, exc_val, exc_tb): return self._get_real_object().__exit__(exc_type, exc_val, exc_tb)
 
-
 class IoCProxy:
-    """Proxy that wraps an object and applies MethodInterceptors on method calls."""
-    __slots__ = ("_target", "_interceptors")
+    __slots__ = ("_target", "_interceptors", "_container", "_request_key")
 
-    def __init__(self, target: object, interceptors: Sequence[MethodInterceptor]):
+    def __init__(self, target: object, interceptors: Sequence[MethodInterceptor], container: Any = None, request_key: Any = None):
         self._target = target
         self._interceptors = tuple(interceptors)
+        self._container = container
+        self._request_key = request_key
 
     def __getattr__(self, name: str) -> Any:
         attr = getattr(self._target, name)
@@ -109,18 +96,17 @@ class IoCProxy:
             bound_fn = attr.__get__(self._target, type(self._target))
         else:
             bound_fn = attr
-
         @lru_cache(maxsize=None)
         def _wrap(fn: Callable[..., Any]):
             if inspect.iscoroutinefunction(fn):
                 async def aw(*args, **kwargs):
-                    inv = Invocation(self._target, name, fn, args, kwargs)
-                    return await dispatch(self._interceptors, inv)
+                    ctx = MethodCtx(instance=self._target, cls=type(self._target), method=fn, name=name, args=args, kwargs=kwargs, container=self._container, request_key=self._request_key)
+                    return await dispatch_method(self._interceptors, ctx)
                 return aw
             else:
                 def sw(*args, **kwargs):
-                    inv = Invocation(self._target, name, fn, args, kwargs)
-                    res = dispatch(self._interceptors, inv)
+                    ctx = MethodCtx(instance=self._target, cls=type(self._target), method=fn, name=name, args=args, kwargs=kwargs, container=self._container, request_key=self._request_key)
+                    res = dispatch_method(self._interceptors, ctx)
                     if inspect.isawaitable(res):
                         raise RuntimeError(f"Async interceptor on sync method: {name}")
                     return res

pico_ioc/resolver.py

@@ -1,68 +1,49 @@
-# src/pico_ioc/resolver.py
 from __future__ import annotations
 
 import inspect
 from typing import Any, Annotated, Callable, get_args, get_origin, get_type_hints
 from contextvars import ContextVar
 
-
 _path: ContextVar[list[tuple[str, str]]] = ContextVar("pico_resolve_path", default=[])
 
-
 def _get_hints(obj, owner_cls=None) -> dict:
-    """Return type hints with include_extras=True, using correct globals/locals."""
     mod = inspect.getmodule(obj)
     g = getattr(mod, "__dict__", {})
     l = vars(owner_cls) if owner_cls is not None else None
     return get_type_hints(obj, globalns=g, localns=l, include_extras=True)
 
-
 def _is_collection_hint(tp) -> bool:
     origin = get_origin(tp) or tp
     return origin in (list, tuple)
 
-
 def _base_and_qualifiers_from_hint(tp):
-    """
-    Extract (base, qualifiers, container_kind) from a type hint.
-    Supports list[T], tuple[T], Annotated[T, "qual1", ...].
-    """
     origin = get_origin(tp) or tp
     args = get_args(tp) or ()
     container_kind = list if origin is list else tuple
-
     if not args:
         return (object, (), container_kind)
-
     inner = args[0]
     if get_origin(inner) is Annotated:
         base, *extras = get_args(inner)
         quals = tuple(a for a in extras if isinstance(a, str))
         return (base, quals, container_kind)
-
     return (inner, (), container_kind)
 
-
 class Resolver:
     def __init__(self, container, *, prefer_name_first: bool = True):
         self.c = container
         self._prefer_name_first = bool(prefer_name_first)
 
-    # --- core resolution ---
-
     def _resolve_dependencies_for_callable(self, fn: Callable, owner_cls: Any = None) -> dict:
         sig = inspect.signature(fn)
         hints = _get_hints(fn, owner_cls=owner_cls)
         kwargs = {}
-
         path_owner = getattr(owner_cls, "__name__", getattr(fn, "__qualname__", "callable"))
         if fn.__name__ == "__init__" and owner_cls:
             path_owner = f"{path_owner}.__init__"
-
         for name, param in sig.parameters.items():
             if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD) or name == "self":
                 continue
-
             ann = hints.get(name, param.annotation)
             st = _path.get()
             _path.set(st + [(path_owner, name)])
@@ -83,50 +64,38 @@ class Resolver:
         return kwargs
 
     def create_instance(self, cls: type) -> Any:
-        """Instantiate a class by resolving its __init__ dependencies."""
         ctor_kwargs = self._resolve_dependencies_for_callable(cls.__init__, owner_cls=cls)
         return cls(**ctor_kwargs)
 
     def kwargs_for_callable(self, fn: Callable, *, owner_cls: Any = None) -> dict:
-        """Resolve all keyword arguments for any callable."""
         return self._resolve_dependencies_for_callable(fn, owner_cls=owner_cls)
 
-    # --- param resolution ---
-
     def _notify_resolve(self, key, ann, quals=()):
-        for ci in getattr(self.c, "_container_interceptors", ()):
-            try:
-                ci.on_resolve(key, ann, tuple(quals) if quals else ())
-            except Exception:
-                pass
+        try:
+            self.c._notify_resolve(key, ann, quals)
+        except Exception:
+            pass
 
     def _resolve_param(self, name: str, ann: Any):
-        # collections
         if _is_collection_hint(ann):
             base, quals, kind = _base_and_qualifiers_from_hint(ann)
             self._notify_resolve(base, ann, quals)
             items = self.c._resolve_all_for_base(base, qualifiers=quals)
             return list(items) if kind is list else tuple(items)
-
-        # precedence
         if self._prefer_name_first and self.c.has(name):
             self._notify_resolve(name, ann, ())
             return self.c.get(name)
-
         if ann is not inspect._empty and self.c.has(ann):
             self._notify_resolve(ann, ann, ())
             return self.c.get(ann)
-
         if ann is not inspect._empty and isinstance(ann, type):
             for base in ann.__mro__[1:]:
                 if self.c.has(base):
                     self._notify_resolve(base, ann, ())
                     return self.c.get(base)
-
         if self.c.has(name):
             self._notify_resolve(name, ann, ())
             return self.c.get(name)
-
         missing = ann if ann is not inspect._empty else name
         raise NameError(f"No provider found for key {missing!r}")