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

pico_ioc-2.0.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: pico-ioc
+Version: 2.0.0
+Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
+Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 David Pérez Cabrera
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/dperezcabrera/pico-ioc
+Project-URL: Repository, https://github.com/dperezcabrera/pico-ioc
+Project-URL: Issue Tracker, https://github.com/dperezcabrera/pico-ioc/issues
+Keywords: ioc,di,dependency injection,inversion of control,decorator
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 📦 Pico-IoC: A Robust, Async-Native IoC Container for Python
+
+[![PyPI](https://img.shields.io/pypi/v/pico-ioc.svg)](https://pypi.org/project/pico-ioc/)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/dperezcabrera/pico-ioc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+![CI (tox matrix)](https://github.com/dperezcabrera/pico-ioc/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/dperezcabrera/pico-ioc/branch/main/graph/badge.svg)](https://codecov.io/gh/dperezcabrera/pico-ioc)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+[![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+
+**pico-ioc** is a **robust, async-native, decorator-based IoC container for Python**.
+It helps you build loosely-coupled, testable, enterprise-grade applications without manual wiring. Inspired by the Spring ecosystem, but fully Pythonic.
+
+> ⚠️ **Requires Python 3.10+** (due to extensive use of modern `typing` features).
+
+---
+
+## ⚖️ Principles
+
+* **Focus & Simplicity**: A declarative API for one job: managing dependencies. It avoids accidental complexity by doing one thing well.
+* **Declarative & Explicit**: No magic. Behavior is deterministic, relying on explicit decorators (`@component`, `@factory`) and type hints.
+* **Unified Composition Root**: The application is assembled from a single entry point (`init`) which defines a clear, predictable boundary.
+* **Fail-Fast by Design**: Catches **circular dependencies** and **missing bindings** at startup, not at runtime. If the application runs, it's wired correctly.
+* **Testability First**: Features like `@conditional`, profiles, and `overrides` are first-class citizens, enabling fast and isolated testing.
+* **Async Native & Extensible**: Full `async`/`await` support, AOP (`@intercepted_by`), and a built-in `EventBus` are available out-of-the-box.
+* **Framework Agnostic**: Zero hard dependencies (standard library only). It works with any Python application, from simple scripts to complex web servers.
+
+---
+
+## ✨ Why Pico-IoC?
+
+`pico-ioc` exists to solve a common problem that arises as Python applications grow: managing how objects are created and connected becomes complex and brittle. This manual wiring, where a change deep in the application can cause a cascade of updates, makes the code hard to test and maintain.
+
+`pico-ioc` introduces the principle of Inversion of Control (IoC) in a simple, Pythonic way. Instead of you creating and connecting every object, you declare your components with a simple `@component` decorator, and the container automatically wires them together based on their type hints. It brings the architectural robustness and testability of mature frameworks like Spring to the Python ecosystem, allowing you to build complex, loosely-coupled applications that remain simple to manage.
+
+| Feature | Manual Wiring | With Pico-IoC |
+| :--- | :--- | :--- |
+| **Object Creation** | `service = Service(Repo(Config()))` | `svc = container.get(Service)` |
+| **Testing** | Manual replacement or monkey-patching | `overrides={Repo: FakeRepo()}` |
+| **Coupling** | High (code knows about constructors) | Low (code just asks for a type) |
+| **Maintenance** | Brittle (changing a constructor breaks consumers) | Robust (changes are isolated) |
+| **Learning Curve** | Ad-hoc, implicit patterns | Uniform, explicit, documented |
+
+---
+
+## 🧩 Features
+
+### Core
+
+* **Zero external dependencies** — pure Python, framework-agnostic.
+* **Decorator-based API** — `@component`, `@factory`, `@provides`, `@configuration`.
+* **Fail-fast Bootstrap** — Detects **circular dependencies** and **missing bindings** at startup.
+* **Async-Native Resolution** — Full `async`/`await` support with `container.aget()`.
+* **Sophisticated Scopes** — `singleton`, `prototype`, and `ContextVar`-based scopes (e.g., `request`, `session`).
+* **Typed Configuration** — Injects `dataclasses` from environment/files via `@configuration`.
+* **Test-Driven** — Built-in `overrides` and `profiles` for easy mocking.
+
+### Advanced
+
+* **AOP / Interceptors** — Intercept method calls with `@intercepted_by`.
+* **Qualifiers** — Inject subsets of components with `Annotated[List[T], Qualifier(...)]`.
+* **Async Event Bus** — Built-in `EventBus` for decoupled, event-driven architecture.
+* **Conditional Registration** — `@conditional` (by profile, env var) and `@on_missing` (fallbacks).
+* **Lifecycle Hooks** — `@configure` (post-init) and `@cleanup` (on shutdown).
+* **Health Checks** — Built-in `@health` decorator and `container.health_check()`.
+* **Serializable Proxies** — Lazy (`@lazy`) and AOP proxies are `pickle`-safe.
+
+---
+
+## 📦 Installation
+
+```bash
+# Requires Python 3.10+
+pip install pico-ioc
+````
+
+-----
+
+## 🚀 Quick Start
+
+```python
+from pico_ioc import component, init, configuration
+from dataclasses import dataclass
+
+@configuration
+@dataclass
+class Config:
+    url: str = "sqlite:///demo.db"
+
+@component
+class Repo:
+    def __init__(self, cfg: Config):
+        self.url = cfg.url
+    def fetch(self): 
+        return f"fetching from {self.url}"
+
+@component
+class Service:
+    def __init__(self, repo: Repo):
+        self.repo = repo
+    def run(self): 
+        return self.repo.fetch()
+
+# Bootstrap the container by scanning modules
+# We use __name__ to scan the current module
+container = init(modules=[__name__])
+
+# Resolve the service and run
+svc = container.get(Service)
+print(svc.run())
+```
+
+**Output:**
+
+```
+fetching from sqlite:///demo.db
+```
+
+-----
+
+### Quick Overrides for Testing
+
+The `init` function accepts `overrides` to replace any component for testing.
+
+```python
+import my_app_module
+from pico_ioc import init
+
+# Define a fake repository
+class FakeRepo:
+    def fetch(self): 
+        return "fake-data"
+
+# Initialize the container, overriding the real Repo
+container = init(
+    modules=[my_app_module],
+    overrides={
+        Repo: FakeRepo()  # Override by type
+    }
+)
+
+# The service now receives FakeRepo instead of the real one
+svc = container.get(Service)
+assert svc.run() == "fake-data"
+```
+
+-----
+
+## 📖 Documentation
+
+  * **🚀 New to pico-ioc? Start with the User Guide.**
+
+      * [**guide.md**](.docs/guide.md) — Learn with practical examples: testing, configuration, AOP, async, and web framework integration.
+
+  * **🏗️ Want to understand the internals? See the Architecture.**
+
+      * [**architecture.md**](./docs/architecture.md) — A deep dive into the resolution algorithm, lifecycle, and internal design.
+
+-----
+
+## 🧪 Development
+
+```bash
+pip install tox
+tox
+```
+
+-----
+
+## 📜 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+-----
+
+## 📜 License
+
+MIT — see [LICENSE](https://opensource.org/licenses/MIT)
+
+```
+```
+
+

pico_ioc-2.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pico_ioc/__init__.py,sha256=sfAtaueMwYKztdJOmU_0-lkMQ_1Lr196KOZE__mzQXI,2373
+pico_ioc/_version.py,sha256=hwOJuFUEKtsgiOt4l6op9s-hviovM6TK1uCdtRNWY4E,22
+pico_ioc/aop.py,sha256=YBvwPwSw8lbXxr_zGbJ8SyxSMh_1kwTFmaB9ezKIDrM,11602
+pico_ioc/api.py,sha256=iu61f3RAqGZ6W4B8JtF3CVkGVukF708O41rx46Q29Ro,32685
+pico_ioc/config_runtime.py,sha256=z1cHDb5PbM8PMLYRFf5c2dmze8V22xwEzpWcBhtmMpA,11950
+pico_ioc/constants.py,sha256=AhIt0ieDZ9Turxb_YbNzj11wUbBbzjKfWh1BDlSx2Nw,183
+pico_ioc/container.py,sha256=xNO1boVXuiMxjJGk8uZdFpLPGugQn1Hyvk1OO0ZcUBk,12509
+pico_ioc/event_bus.py,sha256=0u-uAvniNWk22r3IRqONyeR74SH4Ekc6zb2ZlIJ4HFE,8348
+pico_ioc/exceptions.py,sha256=IwhK7q28_cubG6yiD2mlBYwYPl5I4JAPyt4nss7WFJw,2254
+pico_ioc/factory.py,sha256=Q3aLwZ-MWbXKjm8unr871vlWSeVUDmzFQZ1mXzPkY5I,1557
+pico_ioc/locator.py,sha256=PBxZYO_xCOxG7aJZ0adDtINrJass_ZDNYmPD2O_oNqM,2401
+pico_ioc/scope.py,sha256=BZVEklggnpiKBlE07Ec9NNhJQ6Wg5cnS7IYRAiDB3-E,4473
+pico_ioc-2.0.0.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_ioc-2.0.0.dist-info/METADATA,sha256=ubMhg9j-hhpzo3Ok5ySrfRMudhgnJol-7SIDKgCbNsE,9624
+pico_ioc-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pico_ioc-2.0.0.dist-info/top_level.txt,sha256=_7_RLu616z_dtRw16impXn4Mw8IXe2J4BeX5912m5dQ,9
+pico_ioc-2.0.0.dist-info/RECORD,,

pico_ioc/_state.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from threading import RLock
-from contextvars import ContextVar
-from contextlib import contextmanager
-from typing import Optional, TYPE_CHECKING
-
-# Type-only import to avoid cycles
-if TYPE_CHECKING:
-    from .container import PicoContainer
-
-
-# ---- Task/process context for the active container ----
-
-@dataclass(frozen=True, slots=True)
-class ContainerContext:
-    """Immutable snapshot for the active container state."""
-    container: "PicoContainer"
-    fingerprint: tuple
-    root_name: Optional[str]
-
-
-# Process-wide fallback (for non-async code) guarded by a lock
-_lock = RLock()
-_current_context: Optional[ContainerContext] = None
-
-# Task-local context (for async isolation)
-_ctxvar: ContextVar[Optional[ContainerContext]] = ContextVar("pico_ioc_ctx", default=None)
-
-
-def get_context() -> Optional[ContainerContext]:
-    """Return the current context (task-local first, then process-global)."""
-    ctx = _ctxvar.get()
-    return ctx if ctx is not None else _current_context
-
-
-def set_context(ctx: Optional[ContainerContext]) -> None:
-    """Atomically set both task-local and process-global context."""
-    with _lock:
-        _ctxvar.set(ctx)
-        globals()["_current_context"] = ctx
-
-
-# Optional compatibility helpers (only used by legacy API paths)
-def get_fingerprint() -> Optional[tuple]:
-    ctx = get_context()
-    return ctx.fingerprint if ctx else None
-
-
-def set_fingerprint(fp: Optional[tuple]) -> None:
-    """Compatibility shim: setting None clears the active context."""
-    if fp is None:
-        set_context(None)
-        return
-    ctx = get_context()
-    if ctx is not None:
-        set_context(ContainerContext(container=ctx.container, fingerprint=fp, root_name=ctx.root_name))
-
-
-# ---- Scan/resolve guards (kept as-is) ----
-
-_scanning: ContextVar[bool] = ContextVar("pico_scanning", default=False)
-_resolving: ContextVar[bool] = ContextVar("pico_resolving", default=False)
-
-
-@contextmanager
-def scanning_flag():
-    """Mark scanning=True within the block."""
-    tok = _scanning.set(True)
-    try:
-        yield
-    finally:
-        _scanning.reset(tok)
-

pico_ioc/builder.py

@@ -1,294 +0,0 @@
-# src/pico_ioc/builder.py
-from __future__ import annotations
-
-import inspect as _inspect
-import logging
-import os
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
-from typing import get_origin, get_args, Annotated
-
-from .interceptors import MethodInterceptor, ContainerInterceptor
-from .container import PicoContainer, _is_compatible
-from .policy import apply_policy, _conditional_active
-from .plugins import PicoPlugin, run_plugin_hook
-from .scanner import scan_and_configure
-from .resolver import Resolver, _get_hints
-from . import _state
-from .config import ConfigRegistry
-
-class PicoContainerBuilder:
-    """Configures and builds a PicoContainer. Does not touch global context."""
-
-    def __init__(self):
-        self._scan_plan: List[Tuple[Any, Optional[Callable[[str], bool]], Tuple[PicoPlugin, ...]]] = []
-        self._overrides: Dict[Any, Any] = {}
-        self._profiles: Optional[List[str]] = None
-        self._plugins: Tuple[PicoPlugin, ...] = ()
-        self._include_tags: Optional[set[str]] = None
-        self._exclude_tags: Optional[set[str]] = None
-        self._roots: Iterable[type] = ()
-        self._providers: Dict[Any, Dict] = {}
-        self._interceptor_decls: List[Tuple[Any, dict]] = []
-        self._eager: bool = True
-        self._config_registry: ConfigRegistry | None = None
-
-    # -------- fluent config --------
-
-    def with_config(self, registry: ConfigRegistry) -> "PicoContainerBuilder":
-        self._config_registry = registry
-        return self
-
-    def with_plugins(self, plugins: Tuple[PicoPlugin, ...]) -> "PicoContainerBuilder":
-        self._plugins = plugins or ()
-        return self
-
-    def with_profiles(self, profiles: Optional[List[str]]) -> "PicoContainerBuilder":
-        self._profiles = profiles
-        return self
-
-    def add_scan_package(self, package: Any, exclude: Optional[Callable[[str], bool]] = None) -> "PicoContainerBuilder":
-        self._scan_plan.append((package, exclude, self._plugins))
-        return self
-
-    def with_overrides(self, overrides: Optional[Dict[Any, Any]]) -> "PicoContainerBuilder":
-        self._overrides = overrides or {}
-        return self
-
-    def with_tag_filters(self, include: Optional[set[str]], exclude: Optional[set[str]]) -> "PicoContainerBuilder":
-        self._include_tags = include
-        self._exclude_tags = exclude
-        return self
-
-    def with_roots(self, roots: Iterable[type]) -> "PicoContainerBuilder":
-        self._roots = roots or ()
-        return self
-
-    def with_eager(self, eager: bool) -> "PicoContainerBuilder":
-        self._eager = bool(eager)
-        return self
-
-    # -------- build --------
-
-    def build(self) -> PicoContainer:
-        """Build and return a fully configured container."""
-        requested_profiles = _resolve_profiles(self._profiles)
-
-        container = PicoContainer(providers=self._providers)
-        container._active_profiles = tuple(requested_profiles)
-        setattr(container, "_config_registry", self._config_registry)
-        
-        for pkg, exclude, scan_plugins in self._scan_plan:
-            with _state.scanning_flag():
-                c, f, decls = scan_and_configure(pkg, container, exclude=exclude, plugins=scan_plugins)
-                logging.info("Scanned '%s' (components: %d, factories: %d)", getattr(pkg, "__name__", pkg), c, f)
-                self._interceptor_decls.extend(decls)
-
-        _activate_and_build_interceptors(
-            container=container,
-            interceptor_decls=self._interceptor_decls,
-            profiles=requested_profiles,
-        )
-
-        binder = container.binder()
-
-        if self._overrides:
-            _apply_overrides(container, self._overrides)
-
-        run_plugin_hook(self._plugins, "after_bind", container, binder)
-        run_plugin_hook(self._plugins, "before_eager", container, binder)
-
-        apply_policy(container, profiles=requested_profiles)
-        _filter_by_tags(container, self._include_tags, self._exclude_tags)
-
-        if self._roots:
-            _restrict_to_subgraph(container, self._roots, self._overrides)
-
-        run_plugin_hook(self._plugins, "after_ready", container, binder)
-
-        if self._eager:
-            container.eager_instantiate_all()
-        logging.info("Container configured and ready.")
-        return container
-
-
-# ---------------- helpers ----------------
-
-def _resolve_profiles(profiles: Optional[List[str]]) -> List[str]:
-    if profiles is not None:
-        return list(profiles)
-    env_val = os.getenv("PICO_PROFILE", "")
-    return [p.strip() for p in env_val.split(",") if p.strip()]
-
-
-def _as_provider(val):
-    if isinstance(val, tuple) and len(val) == 2 and callable(val[0]) and isinstance(val[1], bool):
-        return val[0], val[1]
-    if callable(val):
-        return val, False
-    return (lambda v=val: v), False
-
-
-def _apply_overrides(container: PicoContainer, overrides: Dict[Any, Any]) -> None:
-    for key, val in overrides.items():
-        provider, lazy = _as_provider(val)
-        container.bind(key, provider, lazy=lazy)
-
-
-def _filter_by_tags(container: PicoContainer, include_tags: Optional[set[str]], exclude_tags: Optional[set[str]]) -> None:
-    if not include_tags and not exclude_tags:
-        return
-
-    def _tag_ok(meta: dict) -> bool:
-        tags = set(meta.get("tags", ()))
-        if include_tags and not tags.intersection(include_tags):
-            return False
-        if exclude_tags and tags.intersection(exclude_tags):
-            return False
-        return True
-
-    container._providers = {k: v for k, v in container._providers.items() if _tag_ok(v)}
-
-
-def _compute_allowed_subgraph(container: PicoContainer, roots: Iterable[type]) -> set:
-    allowed: set[Any] = set(roots)
-    stack = list(roots or ())
-
-    def _add_impls_for_base(base_t):
-        for prov_key, meta in container._providers.items():
-            cls = prov_key if isinstance(prov_key, type) else None
-            if cls is not None and _is_compatible(cls, base_t):
-                if prov_key not in allowed:
-                    allowed.add(prov_key)
-                    stack.append(prov_key)
-
-    while stack:
-        k = stack.pop()
-        allowed.add(k)
-        if isinstance(k, type):
-            _add_impls_for_base(k)
-
-        cls = k if isinstance(k, type) else None
-        if cls is None or not container.has(k):
-            continue
-
-        try:
-            sig = _inspect.signature(cls.__init__)
-            hints = _get_hints(cls.__init__, owner_cls=cls)
-        except Exception:
-            continue
-
-        for pname, param in sig.parameters.items():
-            if pname == "self":
-                continue
-            ann = hints.get(pname, param.annotation)
-            origin = get_origin(ann) or ann
-            if origin in (list, tuple):
-                inner = (get_args(ann) or (object,))[0]
-                if get_origin(inner) is Annotated:
-                    inner = (get_args(inner) or (object,))[0]
-                if isinstance(inner, type):
-                    if inner not in allowed:
-                        stack.append(inner)
-                continue
-            if isinstance(ann, type) and ann not in allowed:
-                stack.append(ann)
-            elif container.has(pname) and pname not in allowed:
-                stack.append(pname)
-    return allowed
-
-
-def _restrict_to_subgraph(container: PicoContainer, roots: Iterable[type], overrides: Optional[Dict[Any, Any]]) -> None:
-    allowed = _compute_allowed_subgraph(container, roots)
-    keep_keys: set[Any] = allowed | (set(overrides.keys()) if overrides else set())
-    container._providers = {k: v for k, v in container._providers.items() if k in keep_keys}
-
-
-def _activate_and_build_interceptors(
-    *, container: PicoContainer, interceptor_decls: List[Tuple[Any, dict]], profiles: List[str],
-) -> None:
-    resolver = Resolver(container)
-    active: List[Tuple[int, str, str, Any]] = []
-    activated_method_names: List[str] = []
-    activated_container_names: List[str] = []
-    skipped_debug: List[str] = []
-
-    def _interceptor_meta_active(meta: dict) -> bool:
-        profs = tuple(meta.get("profiles", ())) or ()
-        if profs and (not profiles or not any(p in profs for p in profiles)):
-            return False
-        req_env = tuple(meta.get("require_env", ())) or ()
-        if req_env and not all(os.getenv(k) not in (None, "") for k in req_env):
-            return False
-        pred = meta.get("predicate", None)
-        if callable(pred):
-            try:
-                if not bool(pred()):
-                    return False
-            except Exception:
-                logging.exception("Interceptor predicate failed; skipping")
-                return False
-        return True
-
-    def _looks_like_container_interceptor(inst: Any) -> bool:
-        return all(
-            hasattr(inst, m) for m in ("on_resolve", "on_before_create", "on_after_create", "on_exception")
-        )
-
-    for raw_obj, meta in interceptor_decls:
-        owner_cls, obj = (raw_obj[0], raw_obj[1]) if isinstance(raw_obj, tuple) and len(raw_obj) == 2 else (None, raw_obj)
-        qn = getattr(obj, "__qualname__", repr(obj))
-
-        if not _conditional_active(obj, profiles=profiles) or not _interceptor_meta_active(meta):
-            skipped_debug.append(f"skip:{qn}")
-            continue
-
-        try:
-            if isinstance(obj, type):
-                inst = resolver.create_instance(obj)
-            elif owner_cls is not None:
-                owner_inst = resolver.create_instance(owner_cls)
-                bound = obj.__get__(owner_inst, owner_cls)
-                kwargs = resolver.kwargs_for_callable(bound, owner_cls=owner_cls)
-                inst = bound(**kwargs)
-            else:
-                kwargs = resolver.kwargs_for_callable(obj, owner_cls=None)
-                inst = obj(**kwargs)
-        except Exception:
-            logging.exception("Failed to construct interceptor %r", obj)
-            continue
-
-        kind = meta.get("kind", "method")
-        if kind == "method" and not callable(inst):
-            logging.error("Interceptor %s is not valid for kind %s; skipping", qn, kind)
-            continue
-        if kind == "container" and not _looks_like_container_interceptor(inst):
-            logging.error("Container interceptor %s lacks required methods; skipping", qn)
-            continue
-
-        order = int(meta.get("order", 0))
-        active.append((order, qn, kind, inst))
-
-    active.sort(key=lambda t: (t[0], t[1]))
-
-    for _order, _qn, kind, inst in active:
-        if kind == "container":
-            container.add_container_interceptor(inst)  # type: ignore[arg-type]
-            activated_container_names.append(_qn)
-        else:
-            container.add_method_interceptor(inst)  # type: ignore[arg-type]
-            activated_method_names.append(_qn)
-
-    if activated_method_names or activated_container_names:
-        logging.info(
-            "Interceptors activated: method=%d, container=%d",
-            len(activated_method_names),
-            len(activated_container_names),
-        )
-        logging.debug(
-            "Activated method=%s; Activated container=%s",
-            ", ".join(activated_method_names) or "-",
-            ", ".join(activated_container_names) or "-",
-        )
-    if skipped_debug:
-        logging.debug("Skipped interceptors: %s", ", ".join(skipped_debug))
-