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

pico_ioc/infra.py

@@ -1,196 +0,0 @@
-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,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)
-