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

pico_ioc/interceptors.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-import inspect
-from typing import Any, Callable, Protocol, Sequence
-
-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.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 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: ...
-
-def _dispatch_method(interceptors: Sequence[MethodInterceptor], ctx: MethodCtx, i: int = 0):
-    if i >= len(interceptors):
-        return ctx.method(*ctx.args, **ctx.kwargs)
-    cur = interceptors[i]
-    return cur.invoke(ctx, lambda nxt: _dispatch_method(interceptors, nxt, i + 1))
-
-async def _dispatch_method_async(interceptors: Sequence[MethodInterceptor], ctx: MethodCtx, i: int = 0):
-    if i >= len(interceptors):
-        return await ctx.method(*ctx.args, **ctx.kwargs)
-    cur = interceptors[i]
-    res = cur.invoke(ctx, lambda nxt: _dispatch_method_async(interceptors, nxt, i + 1))
-    return await res if inspect.isawaitable(res) else 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)
-
-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/plugins.py

@@ -1,28 +0,0 @@
-# pico_ioc/plugins.py
-from typing import Protocol, Any, Tuple
-from .container import Binder, PicoContainer
-import logging
-
-class PicoPlugin(Protocol):
-    def before_scan(self, package: Any, binder: Binder) -> None: ...
-    def visit_class(self, module: Any, cls: type, binder: Binder) -> None: ...
-    def after_scan(self, package: Any, binder: Binder) -> None: ...
-    def after_bind(self, container: PicoContainer, binder: Binder) -> None: ...
-    def before_eager(self, container: PicoContainer, binder: Binder) -> None: ...
-    def after_ready(self, container: PicoContainer, binder: Binder) -> None: ...
-
-def run_plugin_hook(
-    plugins: Tuple[PicoPlugin, ...],
-    hook_name: str,
-    *args,
-    **kwargs,
-) -> None:
-    """Run a lifecycle hook across all plugins, logging (but not raising) exceptions."""
-    for pl in plugins:
-        try:
-            fn = getattr(pl, hook_name, None)
-            if fn:
-                fn(*args, **kwargs)
-        except Exception:
-            logging.exception("Plugin %s failed", hook_name)
-

pico_ioc/policy.py

@@ -1,245 +0,0 @@
-# src/pico_ioc/policy.py
-from __future__ import annotations
-
-import inspect
-import os
-from collections import defaultdict
-from typing import Any, Dict, List, Optional, Tuple
-
-from .utils import create_alias_provider
-from .decorators import CONDITIONAL_META, PRIMARY_FLAG, ON_MISSING_META
-from . import _state
-
-
-# ------------------- helpers -------------------
-
-def _target_from_provider(provider):
-    """Try to resolve the 'real' target behind a provider closure (class, function or bound method)."""
-    fn = provider
-    try:
-        cells = getattr(fn, "__closure__", None) or ()
-        first_func, first_cls = None, None
-        for cell in cells:
-            cc = getattr(cell, "cell_contents", None)
-            if inspect.ismethod(cc):
-                return cc
-            if first_func is None and inspect.isfunction(cc):
-                first_func = cc
-            elif first_cls is None and inspect.isclass(cc):
-                first_cls = cc
-        return first_func or first_cls or fn
-    except Exception:
-        return fn
-
-
-def _owner_func(obj):
-    """If obj is a bound method, return the unbound function on its owner class."""
-    try:
-        if inspect.ismethod(obj) and getattr(obj, "__self__", None) is not None:
-            owner = obj.__self__.__class__
-            name = getattr(obj, "__name__", None)
-            if name and hasattr(owner, name):
-                cand = getattr(owner, name)
-                if inspect.isfunction(cand):
-                    return cand
-    except Exception:
-        pass
-    return None
-
-
-def _find_attribute_on_target(target: Any, attr_name: str) -> Any:
-    """Look for metadata on object, its underlying function, or owner class method."""
-    val = getattr(target, attr_name, None)
-    if val is not None:
-        return val
-    base_func = getattr(target, "__func__", None)
-    if base_func:
-        val = getattr(base_func, attr_name, None)
-        if val is not None:
-            return val
-    of = _owner_func(target)
-    if of:
-        val = getattr(of, attr_name, None)
-        if val is not None:
-            return val
-    return None
-
-
-def _has_flag(obj, flag_name: str) -> bool:
-    return bool(_find_attribute_on_target(obj, flag_name))
-
-
-def _get_meta(obj, meta_name: str) -> Any:
-    return _find_attribute_on_target(obj, meta_name)
-
-
-def _on_missing_meta(target):
-    """Normalize @on_missing metadata."""
-    meta = _get_meta(target, ON_MISSING_META)
-    if not meta:
-        return None
-    return (meta.get("selector"), int(meta.get("priority", 0)))
-
-
-def _conditional_active(target, *, profiles: List[str]) -> bool:
-    """Check if target is active given profiles/env/predicate."""
-    meta = _get_meta(target, CONDITIONAL_META)
-    if not meta:
-        return True
-
-    profs = tuple(meta.get("profiles", ()))
-    req_env = tuple(meta.get("require_env", ()))
-    pred = meta.get("predicate")
-
-    if profs and (not profiles or not any(p in profs for p in profiles)):
-        return False
-    if req_env and not all(os.getenv(k) not in (None, "") for k in req_env):
-        return False
-    if callable(pred):
-        try:
-            if not bool(pred()):
-                return False
-        except Exception:
-            return False
-    return True
-
-
-# ------------------- public API -------------------
-
-def apply_policy(container, *, profiles: Optional[List[str]] = None) -> None:
-    """Run all policy stages on the given container."""
-    profiles = list(profiles or [])
-
-    _filter_inactive_factory_candidates(container, profiles=profiles)
-    _collapse_identical_keys_preferring_primary(container)
-    _create_active_component_base_aliases(container, profiles=profiles)
-    apply_defaults(container)
-
-
-def apply_defaults(container) -> None:
-    """Bind defaults declared with @on_missing if no binding exists for selector."""
-    defaults: dict[Any, list[tuple[int, Any]]] = {}
-
-    # class components
-    for prov_key, meta in list(container._providers.items()):  # type: ignore
-        if not isinstance(prov_key, type):
-            continue
-        target = _target_from_provider(meta.get("factory"))
-        om = _on_missing_meta(target)
-        if om:
-            selector, prio = om
-            defaults.setdefault(selector, []).append((prio, prov_key))
-
-    # factory provides
-    for prov_key, meta in list(container._providers.items()):  # type: ignore
-        prov = meta.get("factory")
-        base = getattr(prov, "_pico_alias_for", None)
-        if base is None:
-            continue
-        target = _target_from_provider(prov)
-        om = _on_missing_meta(target)
-        if om:
-            _sel, prio = om
-            defaults.setdefault(base, []).append((prio, prov_key))
-
-    # bind highest priority candidate
-    for base, cands in defaults.items():
-        if container.has(base):
-            continue
-        cands.sort(key=lambda t: t[0], reverse=True)
-        chosen_key = cands[0][1]
-
-        def _delegate(_k=chosen_key):
-            def _f():
-                return container.get(_k)
-            return _f
-
-        container.bind(base, _delegate(), lazy=True)
-
-
-# ------------------- stages -------------------
-
-def _filter_inactive_factory_candidates(container, *, profiles: List[str]) -> None:
-    """Remove factories inactive under profiles/env/predicate."""
-    to_delete = []
-    for prov_key, meta in list(container._providers.items()):  # type: ignore
-        prov = meta.get("factory")
-        base = getattr(prov, "_pico_alias_for", None)
-        if base is None:
-            continue
-        target = _target_from_provider(prov)
-        if not _conditional_active(target, profiles=profiles):
-            to_delete.append(prov_key)
-    for k in to_delete:
-        container._providers.pop(k, None)  # type: ignore
-
-
-def _collapse_identical_keys_preferring_primary(container) -> None:
-    """For multiple factory candidates of same base, keep one (prefer @primary)."""
-    groups: dict[Any, list[tuple[Any, dict]]] = defaultdict(list)
-    for k, m in list(container._providers.items()):  # type: ignore
-        prov = m.get("factory")
-        base = getattr(prov, "_pico_alias_for", None)
-        if base is not None:
-            groups[base].append((k, m))
-
-    for base, entries in groups.items():
-        if not entries:
-            continue
-        if len(entries) == 1:
-            keep, _ = entries[0]
-            if (not container.has(base)) or (base != keep):
-                factory = create_alias_provider(container, keep)
-                container.bind(base, factory, lazy=True)
-            continue
-
-        prims = [(kk, mm) for (kk, mm) in entries if _has_flag(_target_from_provider(mm["factory"]), PRIMARY_FLAG)]
-        if prims:
-            keep, _ = prims[0]
-            if (not container.has(base)) or (base != keep):
-                factory = create_alias_provider(container, keep)
-                container.bind(base, factory, lazy=True)
-            for kk, _mm in entries:
-                if kk != keep and kk != base:
-                    container._providers.pop(kk, None)  # type: ignore
-
-
-def _create_active_component_base_aliases(container, *, profiles: List[str]) -> None:
-    """For active class components, create base->impl aliases (prefer @primary)."""
-    impls: List[Tuple[type, dict]] = []
-    for key, meta in list(container._providers.items()):  # type: ignore
-        if not isinstance(key, type):
-            continue
-        tgt = _target_from_provider(meta.get("factory"))
-        if _conditional_active(tgt, profiles=profiles):
-            impls.append((key, meta))
-
-    base_to_impls: Dict[Any, List[Tuple[Any, dict]]] = defaultdict(list)
-    for impl_key, impl_meta in impls:
-        for base in getattr(impl_key, "__mro__", ())[1:]:
-            if base is object:
-                break
-            base_to_impls[base].append((impl_key, impl_meta))
-
-    for base, impl_list in base_to_impls.items():
-        if container.has(base) or not impl_list:
-            continue
-
-        regular, fallbacks = [], []
-        for ik, im in impl_list:
-            tgt = _target_from_provider(im["factory"])
-            (fallbacks if _on_missing_meta(tgt) else regular).append((ik, im))
-
-        def pick(cands: List[Tuple[Any, dict]]) -> Optional[Any]:
-            if not cands:
-                return None
-            prims = [(ik, im) for ik, im in cands if _has_flag(_target_from_provider(im["factory"]), PRIMARY_FLAG)]
-            return prims[0][0] if prims else cands[0][0]
-
-        chosen = pick(regular) or pick(fallbacks)
-        if not chosen:
-            continue
-
-        factory = create_alias_provider(container, chosen)
-        container.bind(base, factory, lazy=True)
-

pico_ioc/proxy.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from functools import lru_cache
-from typing import Any, Callable, Sequence
-
-from .interceptors import MethodCtx, MethodInterceptor, dispatch_method
-
-class ComponentProxy:
-    def __init__(self, object_creator: Callable[[], Any]):
-        object.__setattr__(self, "_object_creator", object_creator)
-        object.__setattr__(self, "__real_object", None)
-
-    def _get_real_object(self) -> Any:
-        real = object.__getattribute__(self, "__real_object")
-        if real is None:
-            real = object.__getattribute__(self, "_object_creator")()
-            object.__setattr__(self, "__real_object", real)
-        return real
-
-    @property
-    def __class__(self):
-        return self._get_real_object().__class__
-
-    def __getattr__(self, name): return getattr(self._get_real_object(), name)
-    def __setattr__(self, name, value): setattr(self._get_real_object(), name, value)
-    def __delattr__(self, name): delattr(self._get_real_object(), name)
-    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())
-    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
-    def __delitem__(self, key): del self._get_real_object()[key]
-    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()
-    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
-    def __matmul__(self, other): return self._get_real_object() @ other
-    def __truediv__(self, other): return self._get_real_object() / other
-    def __floordiv__(self, other): return self._get_real_object() // other
-    def __mod__(self, other): return self._get_real_object() % other
-    def __divmod__(self, other): return divmod(self._get_real_object(), other)
-    def __pow__(self, other, modulo=None): return pow(self._get_real_object(), other, modulo)
-    def __lshift__(self, other): return self._get_real_object() << other
-    def __rshift__(self, other): return self._get_real_object() >> other
-    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
-    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()
-    def __rmatmul__(self, other): return other @ self._get_real_object()
-    def __rtruediv__(self, other): return other / self._get_real_object()
-    def __rfloordiv__(self, other): return other // self._get_real_object()
-    def __rmod__(self, other): return other % self._get_real_object()
-    def __rdivmod__(self, other): return divmod(other, self._get_real_object())
-    def __rpow__(self, other): return pow(other, self._get_real_object())
-    def __rlshift__(self, other): return other << self._get_real_object()
-    def __rrshift__(self, other): return other >> self._get_real_object()
-    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()
-    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())
-    def __invert__(self): return ~self._get_real_object()
-    def __eq__(self, other): return self._get_real_object() == other
-    def __ne__(self, other): return self._get_real_object() != other
-    def __lt__(self, other): return self._get_real_object() < other
-    def __le__(self, other): return self._get_real_object() <= other
-    def __gt__(self, other): return self._get_real_object() > other
-    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())
-    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:
-    __slots__ = ("_target", "_interceptors", "_container", "_request_key")
-
-    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)
-        if not callable(attr):
-            return attr
-        if hasattr(attr, "__get__"):
-            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):
-                    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):
-                    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
-                return sw
-        return _wrap(bound_fn)
-

pico_ioc/public_api.py

@@ -1,76 +0,0 @@
-# pico_ioc/public_api.py
-
-from __future__ import annotations
-import importlib
-import inspect
-import pkgutil
-import sys
-from types import ModuleType
-from typing import Dict, Iterable, Optional, Tuple
-
-from .decorators import COMPONENT_FLAG, FACTORY_FLAG, PLUGIN_FLAG
-
-
-def export_public_symbols_decorated(
-    *packages: str,
-    include_also: Optional[Iterable[str]] = None,
-    include_plugins: bool = True,
-):
-    index: Dict[str, Tuple[str, str]] = {}
-
-    def _collect(m: ModuleType):
-        names = getattr(m, "__all__", None)
-        if isinstance(names, (list, tuple, set)):
-            for n in names:
-                if hasattr(m, n):
-                    index.setdefault(n, (m.__name__, n))
-            return
-
-        for n, obj in m.__dict__.items():
-            if not inspect.isclass(obj):
-                continue
-            is_component = getattr(obj, COMPONENT_FLAG, False)
-            is_factory = getattr(obj, FACTORY_FLAG, False)
-            is_plugin = include_plugins and getattr(obj, PLUGIN_FLAG, False)
-            if is_component or is_factory or is_plugin:
-                index.setdefault(n, (m.__name__, n))
-
-    for pkg_name in packages:
-        try:
-            base = importlib.import_module(pkg_name)
-        except Exception:
-            continue
-        if hasattr(base, "__path__"):
-            prefix = base.__name__ + "."
-            for _, modname, _ in pkgutil.walk_packages(base.__path__, prefix):
-                try:
-                    m = importlib.import_module(modname)
-                except Exception:
-                    continue
-                _collect(m)
-        else:
-            _collect(base)
-
-    for qual in tuple(include_also or ()):
-        modname, _, attr = qual.partition(":")
-        if modname and attr:
-            try:
-                m = importlib.import_module(modname)
-                if hasattr(m, attr):
-                    index.setdefault(attr, (m.__name__, attr))
-            except Exception:
-                pass
-
-    def __getattr__(name: str):
-        try:
-            modname, attr = index[name]
-        except KeyError as e:
-            raise AttributeError(f"module has no attribute {name!r}") from e
-        mod = sys.modules.get(modname) or importlib.import_module(modname)
-        return getattr(mod, attr)
-
-    def __dir__():
-        return sorted(index.keys())
-
-    return __getattr__, __dir__
-

pico_ioc/resolver.py

@@ -1,101 +0,0 @@
-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:
-    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):
-    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)
-
-    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)])
-            try:
-                kwargs[name] = self._resolve_param(name, ann)
-            except NameError as e:
-                if param.default is not inspect.Parameter.empty:
-                    _path.set(st)
-                    continue
-                if "(required by" in str(e):
-                    raise
-                chain = " -> ".join(f"{owner}.{param}" for owner, param in _path.get())
-                raise NameError(f"{e} (required by {chain})") from e
-            finally:
-                cur = _path.get()
-                if cur:
-                    _path.set(cur[:-1])
-        return kwargs
-
-    def create_instance(self, cls: type) -> Any:
-        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:
-        return self._resolve_dependencies_for_callable(fn, owner_cls=owner_cls)
-
-    def _notify_resolve(self, key, ann, quals=()):
-        try:
-            self.c._notify_resolve(key, ann, quals)
-        except Exception:
-            pass
-
-    def _resolve_param(self, name: str, ann: Any):
-        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)
-        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}")
-