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

pico_ioc/proxy.py

@@ -1,18 +1,25 @@
-# pico_ioc/proxy.py
+# 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 typing import Any, Callable
 
 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)
 
     def _get_real_object(self) -> Any:
-        real_obj = object.__getattribute__(self, "__real_object")
-        if real_obj is None:
-            real_obj = object.__getattribute__(self, "_object_creator")()
-            object.__setattr__(self, "__real_object", real_obj)
-        return real_obj
+        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):
@@ -24,6 +31,8 @@ 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
@@ -31,6 +40,8 @@ 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
@@ -45,6 +56,8 @@ 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()
@@ -59,6 +72,8 @@ 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())
@@ -71,7 +86,44 @@ 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")
+
+    def __init__(self, target: object, interceptors: Sequence[MethodInterceptor]):
+        self._target = target
+        self._interceptors = tuple(interceptors)
+
+    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):
+                    inv = Invocation(self._target, name, fn, args, kwargs)
+                    return await dispatch(self._interceptors, inv)
+                return aw
+            else:
+                def sw(*args, **kwargs):
+                    inv = Invocation(self._target, name, fn, args, kwargs)
+                    res = dispatch(self._interceptors, inv)
+                    if inspect.isawaitable(res):
+                        raise RuntimeError(f"Async interceptor on sync method: {name}")
+                    return res
+                return sw
+        return _wrap(bound_fn)
+

pico_ioc/resolver.py

@@ -1,14 +1,16 @@
-# pico_ioc/resolver.py (Python 3.10+)
-
+# src/pico_ioc/resolver.py
 from __future__ import annotations
+
 import inspect
-from typing import Any, Annotated, get_args, get_origin, get_type_hints
+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:
-    """type hints with include_extras=True and correct globals/locals."""
+    """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
@@ -16,15 +18,14 @@ def _get_hints(obj, owner_cls=None) -> dict:
 
 
 def _is_collection_hint(tp) -> bool:
-    """True if tp is a list[...] or tuple[...]."""
     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 collection hint.
-    Supports list[T] / tuple[T] and Annotated[T, "qual1", ...].
+    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 ()
@@ -47,78 +48,85 @@ class Resolver:
         self.c = container
         self._prefer_name_first = bool(prefer_name_first)
 
-    def create_instance(self, cls):
-        sig = inspect.signature(cls.__init__)
-        hints = _get_hints(cls.__init__, owner_cls=cls)
-        kwargs = {}
-        for name, param in sig.parameters.items():
-            if name == "self" or param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
-                continue
-            ann = hints.get(name, param.annotation)
-            st = _path.get()
-            _path.set(st + [(cls.__name__, name)])
-            try:
-                value = self._resolve_param(name, ann)
-            except NameError as e:
-                # ⬅️ Important: skip if parameter has a default
-                if param.default is not inspect._empty:
-                    continue
-                chain = " -> ".join(f"{c}.__init__.{p}" for c, p in _path.get())
-                raise NameError(f"{e} (required by {chain})") from e
-            finally:
-                cur = _path.get()
-                _path.set(cur[:-1] if cur else [])
-            kwargs[name] = value
-        return cls(**kwargs)
+    # --- core resolution ---
 
-    def kwargs_for_callable(self, fn, *, owner_cls=None):
+    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 = {}
-        owner_name = getattr(owner_cls, "__name__", getattr(fn, "__qualname__", "callable"))
+
+        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 name == "self" or param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            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 + [(owner_name, name)])
+            _path.set(st + [(path_owner, name)])
             try:
-                value = self._resolve_param(name, ann)
+                kwargs[name] = self._resolve_param(name, ann)
             except NameError as e:
-                # ⬅️ Important: skip if parameter has a default
-                if param.default is not inspect._empty:
-                    # do not include in kwargs
-                    _path.set(st)  # pop before continue
+                if param.default is not inspect.Parameter.empty:
+                    _path.set(st)
                     continue
-                chain = " -> ".join(f"{c}.__init__.{p}" for c, p in _path.get())
+                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()
-                _path.set(cur[:-1] if cur else [])
-            kwargs[name] = value
+                if cur:
+                    _path.set(cur[:-1])
         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
+
     def _resolve_param(self, name: str, ann: Any):
-        # collections (list/tuple) with optional qualifiers via Annotated
+        # collections
         if _is_collection_hint(ann):
-            base, quals, container_kind = _base_and_qualifiers_from_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 container_kind is list else tuple(items)
+            return list(items) if kind is list else tuple(items)
 
-        # precedence: by name > by exact annotation > by MRO > by name again
+        # 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}")
+

pico_ioc/scanner.py

@@ -1,4 +1,6 @@
-# pico_ioc/scanner.py
+# src/pico_ioc/scanner.py
+from __future__ import annotations
+
 import importlib
 import inspect
 import logging
@@ -6,6 +8,7 @@ import pkgutil
 from types import ModuleType
 from typing import Any, Callable, Optional, Tuple, List, Iterable
 
+from .plugins import run_plugin_hook, PicoPlugin
 from .container import PicoContainer, Binder
 from .decorators import (
     COMPONENT_FLAG,
@@ -14,13 +17,15 @@ from .decorators import (
     FACTORY_FLAG,
     PROVIDES_KEY,
     PROVIDES_LAZY,
-    COMPONENT_TAGS, 
+    COMPONENT_TAGS,
     PROVIDES_TAGS,
+    INTERCEPTOR_META,
 )
 from .proxy import ComponentProxy
 from .resolver import Resolver
-from .plugins import PicoPlugin
 from . import _state
+from .utils import _provider_from_class, _provider_from_callable
+from .config import is_config_component, build_component_instance, ConfigRegistry
 
 
 def scan_and_configure(
@@ -29,15 +34,15 @@ def scan_and_configure(
     *,
     exclude: Optional[Callable[[str], bool]] = None,
     plugins: Tuple[PicoPlugin, ...] = (),
-) -> None:
+) -> tuple[int, int, list[tuple[Any, dict]]]:
     """
-    Scan a package, discover component classes/factories, and bind them into the container.
+    Scan a package, bind components/factories, and collect interceptor declarations.
 
-    Args:
-        package_or_name: Package module or importable package name (str).
-        container: Target PicoContainer to receive bindings.
-        exclude: Optional predicate that receives a module name and returns True to skip it.
-        plugins: Optional lifecycle plugins that receive scan/bind events.
+    Returns: (component_count, factory_count, interceptor_decls)
+      - interceptor_decls entries:
+          (cls, meta)                        for @interceptor class
+          (fn, meta)                         for @interceptor function
+          ((owner_cls, fn), meta)            for @interceptor methods
     """
     package = _as_module(package_or_name)
     logging.info("Scanning in '%s'...", getattr(package, "__name__", repr(package)))
@@ -45,34 +50,26 @@ def scan_and_configure(
     binder = Binder(container)
     resolver = Resolver(container)
 
-    _run_plugin_hook(plugins, "before_scan", package, binder)
+    run_plugin_hook(plugins, "before_scan", package, binder)
 
-    comp_classes, factory_classes = _collect_decorated_classes(
+    comp_classes, factory_classes, interceptor_decls = _collect_decorated(
         package=package,
         exclude=exclude,
         plugins=plugins,
         binder=binder,
     )
 
-    _run_plugin_hook(plugins, "after_scan", package, binder)
+    run_plugin_hook(plugins, "after_scan", package, binder)
 
-    _register_component_classes(
-        classes=comp_classes,
-        container=container,
-        resolver=resolver,
-    )
+    _register_component_classes(classes=comp_classes, container=container, resolver=resolver)
+    _register_factory_classes(factory_classes=factory_classes, container=container, resolver=resolver)
 
-    _register_factory_classes(
-        factory_classes=factory_classes,
-        container=container,
-        resolver=resolver,
-    )
+    return len(comp_classes), len(factory_classes), interceptor_decls
 
 
-# -------------------- Helpers (private) --------------------
+# -------------------- helpers --------------------
 
 def _as_module(package_or_name: Any) -> ModuleType:
-    """Return a module from either a module object or an importable string name."""
     if isinstance(package_or_name, str):
         return importlib.import_module(package_or_name)
     if hasattr(package_or_name, "__spec__"):
@@ -80,84 +77,68 @@ def _as_module(package_or_name: Any) -> ModuleType:
     raise TypeError("package_or_name must be a module or importable package name (str).")
 
 
-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)
-
-
-def _iter_package_modules(
-    package: ModuleType,
-) -> Iterable[str]:
-    """
-    Yield fully qualified module names under the given package.
-
-    Requires the package to have a __path__ (i.e., be a package, not a single module).
-    """
+def _iter_package_modules(package: ModuleType) -> Iterable[str]:
+    """Yield fully-qualified module names under a package (recursive)."""
     try:
         pkg_path = package.__path__  # type: ignore[attr-defined]
     except Exception:
-        return  # not a package; nothing to iterate
-
+        return
     prefix = package.__name__ + "."
     for _finder, name, _is_pkg in pkgutil.walk_packages(pkg_path, prefix):
         yield name
 
 
-def _collect_decorated_classes(
+def _collect_decorated(
     *,
     package: ModuleType,
     exclude: Optional[Callable[[str], bool]],
     plugins: Tuple[PicoPlugin, ...],
     binder: Binder,
-) -> Tuple[List[type], List[type]]:
-    """
-    Import modules under `package`, visit classes, and collect those marked with
-    @component or @factory_component decorators.
-    """
-    comp_classes: List[type] = []
-    factory_classes: List[type] = []
+) -> Tuple[List[type], List[type], List[tuple[Any, dict]]]:
+    comps: List[type] = []
+    facts: List[type] = []
+    interceptors: List[tuple[Any, dict]] = []
+
+    def _collect_from_class(cls: type):
+        if getattr(cls, COMPONENT_FLAG, False):
+            comps.append(cls)
+        elif getattr(cls, FACTORY_FLAG, False):
+            facts.append(cls)
+
+        meta_class = getattr(cls, INTERCEPTOR_META, None)
+        if meta_class:
+            interceptors.append((cls, dict(meta_class)))
+
+        for _nm, fn in inspect.getmembers(cls, predicate=inspect.isfunction):
+            meta_m = getattr(fn, INTERCEPTOR_META, None)
+            if meta_m:
+                interceptors.append(((cls, fn), dict(meta_m)))
 
     def _visit_module(module: ModuleType):
         for _name, obj in inspect.getmembers(module, inspect.isclass):
-            # Allow plugins to inspect/transform/record classes
-            _run_plugin_hook(plugins, "visit_class", module, obj, binder)
+            run_plugin_hook(plugins, "visit_class", module, obj, binder)
+            _collect_from_class(obj)
 
-            # Collect decorated classes
-            if getattr(obj, COMPONENT_FLAG, False):
-                comp_classes.append(obj)
-            elif getattr(obj, FACTORY_FLAG, False):
-                factory_classes.append(obj)
+        for _name, fn in inspect.getmembers(module, predicate=inspect.isfunction):
+            meta = getattr(fn, INTERCEPTOR_META, None)
+            if meta:
+                interceptors.append((fn, dict(meta)))
 
-    # 1) Si es un paquete, recorrer submódulos
     for mod_name in _iter_package_modules(package):
         if exclude and exclude(mod_name):
             logging.info("Skipping module %s (excluded)", mod_name)
             continue
-
         try:
             module = importlib.import_module(mod_name)
         except Exception as e:
             logging.warning("Module %s not processed: %s", mod_name, e)
             continue
-
         _visit_module(module)
 
-    # 2) Si el “paquete” raíz es un módulo (sin __path__), también hay que visitarlo.
     if not hasattr(package, "__path__"):
         _visit_module(package)
 
-    return comp_classes, factory_classes
+    return comps, facts, interceptors
 
 
 def _register_component_classes(
@@ -166,23 +147,20 @@ def _register_component_classes(
     container: PicoContainer,
     resolver: Resolver,
 ) -> None:
-    """
-    Register @component classes into the container.
-
-    Binding key:
-        - If the class has COMPONENT_KEY, use it; otherwise, bind by the class itself.
-    Laziness:
-        - If COMPONENT_LAZY is True, provide a proxy that defers instantiation.
-    """
     for cls in classes:
         key = getattr(cls, COMPONENT_KEY, cls)
         is_lazy = bool(getattr(cls, COMPONENT_LAZY, False))
         tags = tuple(getattr(cls, COMPONENT_TAGS, ()))
-        def _provider_factory(c=cls, lazy=is_lazy):
-            def _factory():
-                return ComponentProxy(lambda: resolver.create_instance(c)) if lazy else resolver.create_instance(c)
-            return _factory
-        container.bind(key, _provider_factory(), lazy=is_lazy, tags=tags)
+        if is_config_component(cls):
+            registry: ConfigRegistry | None = getattr(container, "_config_registry", None)
+            def _prov(_c=cls, _reg=registry):
+                if _reg is None:
+                    raise RuntimeError(f"No config registry found to build {_c.__name__}")
+                return build_component_instance(_c, _reg)
+            provider = (lambda p=_prov: ComponentProxy(p)) if is_lazy else _prov
+        else:
+            provider = _provider_from_class(cls, resolver=resolver, lazy=is_lazy)
+        container.bind(key, provider, lazy=is_lazy, tags=tags)
 
 
 def _register_factory_classes(
@@ -191,19 +169,8 @@ def _register_factory_classes(
     container: PicoContainer,
     resolver: Resolver,
 ) -> None:
-    """
-    Register products of @factory_component classes.
-
-    For each factory class:
-        - Instantiate the factory via the resolver.
-        - For each method with @provides:
-            - Bind the provided key to a callable that calls the factory method.
-            - If PROVIDES_LAZY is True, bind a proxy that defers the method call.
-    """
     for fcls in factory_classes:
         try:
-            # Durante el escaneo, permitir la resolución de dependencias de la factory
-            # elevando temporalmente el flag `_resolving` para no chocar con la guardia.
             tok_res = _state._resolving.set(True)
             try:
                 finst = resolver.create_instance(fcls)
@@ -217,14 +184,20 @@ def _register_factory_classes(
             provided_key = getattr(func, PROVIDES_KEY, None)
             if provided_key is None:
                 continue
+
             is_lazy = bool(getattr(func, PROVIDES_LAZY, False))
             tags = tuple(getattr(func, PROVIDES_TAGS, ()))
+
             bound = getattr(finst, attr_name, func.__get__(finst, fcls))
-            def _make_provider(m=bound, owner=fcls, lazy=is_lazy):
-                def _factory():
-                    kwargs = resolver.kwargs_for_callable(m, owner_cls=owner)
-                    def _call(): return m(**kwargs)
-                    return ComponentProxy(lambda: _call()) if lazy else _call()
-                return _factory
-            container.bind(provided_key, _make_provider(), lazy=is_lazy, tags=tags)
+            prov = _provider_from_callable(bound, owner_cls=fcls, resolver=resolver, lazy=is_lazy)
+
+            if isinstance(provided_key, type):
+                try:
+                    setattr(prov, "_pico_alias_for", provided_key)
+                except Exception:
+                    pass
+                unique_key = (provided_key, f"{fcls.__name__}.{attr_name}")
+                container.bind(unique_key, prov, lazy=is_lazy, tags=tags)
+            else:
+                container.bind(provided_key, prov, lazy=is_lazy, tags=tags)
 

pico_ioc/scope.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .container import PicoContainer
+
+class ScopedContainer(PicoContainer):
+    def __init__(self, built_container: PicoContainer, base: Optional[PicoContainer], strict: bool):
+        super().__init__(providers=getattr(built_container, "_providers", {}).copy())
+        
+        self._active_profiles = getattr(built_container, "_active_profiles", ())
+        
+        base_method_its = getattr(base, "_method_interceptors", ()) if base else ()
+        base_container_its = getattr(base, "_container_interceptors", ()) if base else ()
+        
+        self._method_interceptors = base_method_its
+        self._container_interceptors = base_container_its
+        self._seen_interceptor_types = {type(it) for it in (base_method_its + base_container_its)}
+
+        for it in getattr(built_container, "_method_interceptors", ()):
+            self.add_method_interceptor(it)
+        for it in getattr(built_container, "_container_interceptors", ()):
+            self.add_container_interceptor(it)
+
+        self._base = base
+        self._strict = strict
+
+        if base:
+            self._singletons.update(getattr(base, "_singletons", {}))
+
+    def __enter__(self): return self
+    def __exit__(self, exc_type, exc, tb): return False
+
+    def has(self, key: Any) -> bool:
+        if super().has(key): return True
+        if not self._strict and self._base is not None:
+            return self._base.has(key)
+        return False
+
+    def get(self, key: Any):
+        try:
+            return super().get(key)
+        except NameError as e:
+            if not self._strict and self._base is not None and self._base.has(key):
+                return self._base.get(key)
+            raise e

pico_ioc/utils.py

@@ -0,0 +1,25 @@
+# src/pico_ioc/utils.py
+from typing import Any, Callable
+from .container import PicoContainer
+from .proxy import ComponentProxy
+
+def _wrap_if_lazy(provider: Callable, is_lazy: bool) -> Callable:
+    """Wraps a provider in a ComponentProxy if it's marked as lazy."""
+    return (lambda: ComponentProxy(provider)) if is_lazy else provider
+
+def _provider_from_class(cls: type, *, resolver, lazy: bool):
+    def _new():
+        return resolver.create_instance(cls)
+    return _wrap_if_lazy(_new, lazy)
+
+def _provider_from_callable(fn, *, owner_cls, resolver, lazy: bool):
+    def _invoke():
+        kwargs = resolver.kwargs_for_callable(fn, owner_cls=owner_cls)
+        return fn(**kwargs)
+    return _wrap_if_lazy(_invoke, lazy)
+        
+def create_alias_provider(container: PicoContainer, target_key: Any) -> Callable[[], Any]:
+    """Creates a provider that delegates the get() call to the container for another key."""
+    def _provider():
+        return container.get(target_key)
+    return _provider