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

pico_ioc/container.py

@@ -13,6 +13,75 @@ from .aop import UnifiedComponentProxy, ContainerObserver
 KeyT = Union[str, type]
 _resolve_chain: contextvars.ContextVar[Tuple[KeyT, ...]] = contextvars.ContextVar("pico_resolve_chain", default=())
 
+class _TracerFrame:
+    __slots__ = ("parent_key", "via")
+    def __init__(self, parent_key: KeyT, via: str):
+        self.parent_key = parent_key
+        self.via = via
+
+class ResolutionTracer:
+    def __init__(self, container: "PicoContainer") -> None:
+        self._container = container
+        self._stack_var: contextvars.ContextVar[List[_TracerFrame]] = contextvars.ContextVar("pico_tracer_stack", default=[])
+        self._edges: Dict[Tuple[KeyT, KeyT], Tuple[str, str]] = {}
+
+    def enter(self, parent_key: KeyT, via: str) -> contextvars.Token:
+        stack = list(self._stack_var.get())
+        stack.append(_TracerFrame(parent_key, via))
+        return self._stack_var.set(stack)
+
+    def leave(self, token: contextvars.Token) -> None:
+        self._stack_var.reset(token)
+
+    def override_via(self, new_via: str) -> Optional[str]:
+        stack = self._stack_var.get()
+        if not stack:
+            return None
+        prev = stack[-1].via
+        stack[-1].via = new_via
+        return prev
+
+    def restore_via(self, previous: Optional[str]) -> None:
+        if previous is None:
+            return
+        stack = self._stack_var.get()
+        if not stack:
+            return
+        stack[-1].via = previous
+
+    def note_param(self, child_key: KeyT, param_name: str) -> None:
+        stack = self._stack_var.get()
+        if not stack:
+            return
+        parent = stack[-1].parent_key
+        via = stack[-1].via
+        self._edges[(parent, child_key)] = (via, param_name)
+
+    def describe_cycle(self, chain: Tuple[KeyT, ...], current: KeyT, locator: Optional[ComponentLocator]) -> str:
+        def name_of(k: KeyT) -> str:
+            return getattr(k, "__name__", str(k))
+        def scope_of(k: KeyT) -> str:
+            if not locator:
+                return "singleton"
+            md = locator._metadata.get(k)
+            return md.scope if md else "singleton"
+        lines: List[str] = []
+        lines.append("Circular dependency detected.")
+        lines.append("")
+        lines.append("Resolution chain:")
+        full = tuple(chain) + (current,)
+        for idx, k in enumerate(full, 1):
+            mark = "  ❌" if idx == len(full) else ""
+            lines.append(f"  {idx}. {name_of(k)} [scope={scope_of(k)}]{mark}")
+            if idx < len(full):
+                parent = k
+                child = full[idx]
+                via, param = self._edges.get((parent, child), ("provider", "?"))
+                lines.append(f"     └─ via {via} param '{param}' → {name_of(child)}")
+        lines.append("")
+        lines.append("Hint: break the cycle with a @configure setter or use a factory/provider.")
+        return "\n".join(lines)
+
 class PicoContainer:
     _container_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("pico_container_id", default=None)
     _container_registry: Dict[str, "PicoContainer"] = {}
@@ -35,6 +104,7 @@ class PicoContainer:
         import time as _t
         self.context = PicoContainer._Ctx(container_id=self.container_id, profiles=profiles, created_at=_t.time())
         PicoContainer._container_registry[self.container_id] = self
+        self._tracer = ResolutionTracer(self)
 
     @staticmethod
     def _generate_container_id() -> str:
@@ -80,11 +150,35 @@ class PicoContainer:
         cache = self._cache_for(key)
         return cache.get(key) is not None or self._factory.has(key)
 
+    def _canonical_key(self, key: KeyT) -> KeyT:
+        if self._factory.has(key):
+            return key
+        if isinstance(key, type) and self._locator:
+            cands: List[Tuple[bool, Any]] = []
+            for k, md in self._locator._metadata.items():
+                typ = md.provided_type or md.concrete_class
+                if not isinstance(typ, type):
+                    continue
+                try:
+                    if typ is not key and issubclass(typ, key):
+                        cands.append((md.primary, k))
+                except Exception:
+                    continue
+            if cands:
+                prim = [k for is_p, k in cands if is_p]
+                return prim[0] if prim else cands[0][1]
+        if isinstance(key, str) and self._locator:
+            for k, md in self._locator._metadata.items():
+                if md.pico_name == key:
+                    return k
+        return key
+
     @overload
     def get(self, key: type) -> Any: ...
     @overload
     def get(self, key: str) -> Any: ...
     def get(self, key: KeyT) -> Any:
+        key = self._canonical_key(key)
         cache = self._cache_for(key)
         cached = cache.get(key)
         if cached is not None:
@@ -96,28 +190,19 @@ class PicoContainer:
         chain = list(_resolve_chain.get())
         for k in chain:
             if k == key:
-                raise CircularDependencyError(chain, key)
+                details = self._tracer.describe_cycle(tuple(chain), key, self._locator)
+                raise ComponentCreationError(key, CircularDependencyError(chain, key, details=details))
         token_chain = _resolve_chain.set(tuple(chain + [key]))
         token_container = self.activate()
+        token_tracer = self._tracer.enter(key, via="provider")
         try:
-            if not self._factory.has(key):
-                alt = None
-                if isinstance(key, type):
-                    alt = self._resolve_type_key(key)
-                elif isinstance(key, str) and self._locator:
-                    for k, md in self._locator._metadata.items():
-                        if md.pico_name == key:
-                            alt = k
-                            break
-                if alt is not None:
-                    self._factory.bind(key, lambda a=alt: self.get(a))
             provider = self._factory.get(key)
             try:
                 instance = provider()
             except ProviderNotFoundError as e:
                 raise
             except Exception as e:
-                raise ComponentCreationError(key, e)
+                raise ComponentCreationError(key, e) from e
             instance = self._maybe_wrap_with_aspects(key, instance)
             cache.put(key, instance)
             self.context.resolve_count += 1
@@ -125,10 +210,12 @@ class PicoContainer:
             for o in self._observers: o.on_resolve(key, took_ms)
             return instance
         finally:
+            self._tracer.leave(token_tracer)
             _resolve_chain.reset(token_chain)
             self.deactivate(token_container)
 
     async def aget(self, key: KeyT) -> Any:
+        key = self._canonical_key(key)
         cache = self._cache_for(key)
         cached = cache.get(key)
         if cached is not None:
@@ -140,21 +227,12 @@ class PicoContainer:
         chain = list(_resolve_chain.get())
         for k in chain:
             if k == key:
-                raise CircularDependencyError(chain, key)
+                details = self._tracer.describe_cycle(tuple(chain), key, self._locator)
+                raise ComponentCreationError(key, CircularDependencyError(chain, key, details=details))
         token_chain = _resolve_chain.set(tuple(chain + [key]))
         token_container = self.activate()
+        token_tracer = self._tracer.enter(key, via="provider")
         try:
-            if not self._factory.has(key):
-                alt = None
-                if isinstance(key, type):
-                    alt = self._resolve_type_key(key)
-                elif isinstance(key, str) and self._locator:
-                    for k, md in self._locator._metadata.items():
-                        if md.pico_name == key:
-                            alt = k
-                            break
-                if alt is not None:
-                    self._factory.bind(key, lambda a=alt: self.get(a))
             provider = self._factory.get(key)
             try:
                 instance = provider()
@@ -163,7 +241,7 @@ class PicoContainer:
             except ProviderNotFoundError as e:
                 raise
             except Exception as e:
-                raise ComponentCreationError(key, e)
+                raise ComponentCreationError(key, e) from e
             instance = self._maybe_wrap_with_aspects(key, instance)
             cache.put(key, instance)
             self.context.resolve_count += 1
@@ -171,6 +249,7 @@ class PicoContainer:
             for o in self._observers: o.on_resolve(key, took_ms)
             return instance
         finally:
+            self._tracer.leave(token_tracer)
             _resolve_chain.reset(token_chain)
             self.deactivate(token_container)
 
@@ -303,3 +382,59 @@ class PicoContainer:
         self.cleanup_all()
         PicoContainer._container_registry.pop(self.container_id, None)
 
+    def export_graph(
+        self,
+        path: str,
+        *,
+        include_scopes: bool = True,
+        include_qualifiers: bool = False,
+        rankdir: str = "LR",
+        title: Optional[str] = None,
+    ) -> None:
+
+        if not self._locator:
+            raise RuntimeError("No locator attached; cannot export dependency graph.")
+
+        from .api import _build_resolution_graph
+
+        md_by_key = self._locator._metadata
+        graph = _build_resolution_graph(self)
+
+        lines: List[str] = []
+        lines.append("digraph Pico {")
+        lines.append(f'  rankdir="{rankdir}";')
+        lines.append("  node [shape=box, fontsize=10];")
+        if title:
+            lines.append(f'  labelloc="t";')
+            lines.append(f'  label="{title}";')
+
+        def _node_id(k: KeyT) -> str:
+            return f'n_{abs(hash(k))}'
+
+        def _node_label(k: KeyT) -> str:
+            name = getattr(k, "__name__", str(k))
+            md = md_by_key.get(k)
+            parts = [name]
+            if md is not None and include_scopes:
+                parts.append(f"[scope={md.scope}]")
+            if md is not None and include_qualifiers and md.qualifiers:
+                q = ",".join(sorted(md.qualifiers))
+                parts.append(f"\\n⟨{q}⟩")
+            return "\\n".join(parts)
+
+        for key in md_by_key.keys():
+            nid = _node_id(key)
+            label = _node_label(key)
+            lines.append(f'  {nid} [label="{label}"];')
+
+        for parent, deps in graph.items():
+            pid = _node_id(parent)
+            for child in deps:
+                cid = _node_id(child)
+                lines.append(f"  {pid} -> {cid};")
+
+        lines.append("}")
+
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))
+

pico_ioc/event_bus.py

@@ -6,7 +6,7 @@ import threading
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Tuple, Type
-from .api import factory, provides, configure, cleanup, primary
+from .api import factory, provides, configure, cleanup
 from .exceptions import EventBusClosedError, EventBusError, EventBusQueueFullError, EventBusHandlerError
 
 log = logging.getLogger(__name__)
@@ -204,10 +204,9 @@ class AutoSubscriberMixin:
             for evt_t, pr, pol, once in subs:
                 event_bus.subscribe(evt_t, attr, priority=pr, policy=pol, once=once)
 
-@factory
-@primary
+@factory()
 class PicoEventBusProvider:
-    @provides(EventBus)
+    @provides(EventBus, primary=True)
     def build(self) -> EventBus:
         return EventBus()
     @cleanup

pico_ioc/exceptions.py

@@ -1,4 +1,3 @@
-# src/pico_ioc/exceptions.py
 from typing import Any, Iterable
 
 class PicoError(Exception):
@@ -10,12 +9,19 @@ class ProviderNotFoundError(PicoError):
         self.key = key
 
 class CircularDependencyError(PicoError):
-    def __init__(self, chain: Iterable[Any], current: Any):
+    def __init__(self, chain: Iterable[Any], current: Any, details: str | None = None, hint: str | None = None):
         chain_str = " -> ".join(getattr(k, "__name__", str(k)) for k in chain)
         cur_str = getattr(current, "__name__", str(current))
-        super().__init__(f"Circular dependency detected: {chain_str} -> {cur_str}")
+        base = f"Circular dependency detected: {chain_str} -> {cur_str}"
+        if details:
+            base += f"\n\n{details}"
+        if hint:
+            base += f"\n\nHint: {hint}"
+        super().__init__(base)
         self.chain = tuple(chain)
         self.current = current
+        self.details = details
+        self.hint = hint
 
 class ComponentCreationError(PicoError):
     def __init__(self, key: Any, cause: Exception):

pico_ioc/scope.py

@@ -1,4 +1,6 @@
+# src/pico_ioc/scope.py
 import contextvars
+import inspect
 from typing import Any, Dict, Optional, Tuple
 from collections import OrderedDict
 
@@ -87,6 +89,35 @@ class ScopedCaches:
         self._by_scope: Dict[str, OrderedDict[Any, ComponentContainer]] = {}
         self._max = int(max_scopes_per_type)
         self._no_cache = _NoCacheContainer()
+    def _cleanup_object(self, obj: Any) -> None:
+        try:
+            from .constants import PICO_META
+        except Exception:
+            PICO_META = "_pico_meta"
+        try:
+            for _, m in inspect.getmembers(obj, predicate=inspect.ismethod):
+                meta = getattr(m, PICO_META, {})
+                if meta.get("cleanup", False):
+                    try:
+                        m()
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+            
+    def cleanup_scope(self, scope_name: str, scope_id: Any) -> None:
+        bucket = self._by_scope.get(scope_name)
+        if bucket and scope_id in bucket:
+            container = bucket.pop(scope_id)
+            self._cleanup_container(container)
+
+    def _cleanup_container(self, container: "ComponentContainer") -> None:
+        try:
+            for _, obj in container.items():
+                self._cleanup_object(obj)
+        except Exception:
+            pass
+
     def for_scope(self, scopes: ScopeManager, scope: str) -> ComponentContainer:
         if scope == "singleton":
             return self._singleton
@@ -99,14 +130,28 @@ class ScopedCaches:
             bucket[sid] = c
             return c
         if len(bucket) >= self._max:
-            bucket.popitem(last=False)
+            _, old = bucket.popitem(last=False)
+            self._cleanup_container(old)
         c = ComponentContainer()
         bucket[sid] = c
         return c
+
     def all_items(self):
         for item in self._singleton.items():
             yield item
         for b in self._by_scope.values():
             for c in b.values():
                 for item in c.items():
-                    yield item
+                    yield item
+
+    def shrink(self, scope: str, keep: int) -> None:
+        if scope in ("singleton", "prototype"):
+            return
+        bucket = self._by_scope.get(scope)
+        if not bucket:
+            return
+        k = max(0, int(keep))
+        while len(bucket) > k:
+            _, old = bucket.popitem(last=False)
+            self._cleanup_container(old)
+

pico_ioc-2.0.1.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: pico-ioc
+Version: 2.0.1
+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
+Provides-Extra: yaml
+Requires-Dist: PyYAML; extra == "yaml"
+Provides-Extra: graphviz
+Requires-Dist: graphviz; extra == "graphviz"
+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 **lightweight, async-ready, decorator-driven IoC container** built for clarity, testability, and performance.
+It brings *Inversion of Control* and *dependency injection* to Python in a deterministic, modern, and framework-agnostic way.
+
+> 🐍 Requires **Python 3.10+**
+
+---
+
+## ⚖️ Core Principles
+
+-   **Single Purpose** – Do one thing: dependency management.
+-   **Declarative** – Use simple decorators (`@component`, `@factory`, `@configuration`) instead of config files or YAML magic.
+-   **Deterministic** – No hidden scanning or side-effects; everything flows from an explicit `init()`.
+-   **Async-Native** – Fully supports async providers, async lifecycle hooks, and async interceptors.
+-   **Fail-Fast** – Detects missing bindings and circular dependencies at bootstrap.
+-   **Testable by Design** – Use `overrides` and `profiles` to swap components instantly.
+-   **Zero Core Dependencies** – Built entirely on the Python standard library. Optional features may require external packages (see Installation).
+
+---
+
+## 🚀 Why Pico-IoC?
+
+As Python systems evolve, wiring dependencies by hand becomes fragile and unmaintainable.
+**Pico-IoC** eliminates that friction by letting you declare how components relate — not how they’re created.
+
+| Feature        | Manual Wiring              | With Pico-IoC                   |
+| :------------- | :------------------------- | :------------------------------ |
+| Object creation| `svc = Service(Repo(Config()))` | `svc = container.get(Service)`  |
+| Replacing deps | Monkey-patch               | `overrides={Repo: FakeRepo()}`  |
+| Coupling       | Tight                      | Loose                           |
+| Testing        | Painful                    | Instant                         |
+| Async support  | Manual                     | Built-in                        |
+
+---
+
+## 🧩 Highlights (v2.0.0)
+
+-   **Full redesign:** unified architecture with simpler, more powerful APIs.
+-   **Async-aware AOP system** — method interceptors via `@intercepted_by`.
+-   **Typed configuration** — dataclasses with JSON/YAML/env sources.
+-   **Scoped resolution** — singleton, prototype, request, session, transaction.
+-   **UnifiedComponentProxy** — transparent lazy/AOP proxy supporting serialization.
+-   **Tree-based configuration runtime** with reusable adapters and discriminators.
+-   **Observable container context** with stats, health checks, and async cleanup.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install pico-ioc
+```
+
+For optional features, you can install extras:
+
+  * **YAML Configuration:**
+
+    ```bash
+    pip install pico-ioc[yaml]
+    ```
+
+    (Requires `PyYAML`)
+
+  * **Dependency Graph Export:**
+
+    ```bash
+    pip install pico-ioc[graphviz]
+    ```
+
+    (Requires the `graphviz` Python package and the Graphviz command-line tools)
+
+-----
+
+## ⚙️ Quick Example
+
+```python
+from dataclasses import dataclass
+from pico_ioc import component, configuration, init
+
+@configuration
+@dataclass
+class Config:
+    db_url: str = "sqlite:///demo.db"
+
+@component
+class Repo:
+    def __init__(self, cfg: Config):
+        self.cfg = cfg
+    def fetch(self):
+        return f"fetching from {self.cfg.db_url}"
+
+@component
+class Service:
+    def __init__(self, repo: Repo):
+        self.repo = repo
+    def run(self):
+        return self.repo.fetch()
+
+container = init(modules=[__name__])
+svc = container.get(Service)
+print(svc.run())
+```
+
+**Output:**
+
+```
+fetching from sqlite:///demo.db
+```
+
+-----
+
+## 🧪 Testing with Overrides
+
+```python
+class FakeRepo:
+    def fetch(self): return "fake-data"
+
+container = init(modules=[__name__], overrides={Repo: FakeRepo()})
+svc = container.get(Service)
+assert svc.run() == "fake-data"
+```
+
+-----
+
+## 🩺 Lifecycle & AOP
+
+```python
+from pico_ioc import intercepted_by, MethodInterceptor, MethodCtx
+
+class LogInterceptor(MethodInterceptor):
+    def invoke(self, ctx: MethodCtx, call_next):
+        print(f"→ calling {ctx.name}")
+        res = call_next(ctx)
+        print(f"← {ctx.name} done")
+        return res
+
+@component
+class Demo:
+    @intercepted_by(LogInterceptor)
+    def work(self):
+        return "ok"
+
+c = init(modules=[__name__])
+c.get(Demo).work()
+```
+
+-----
+
+## 📖 Documentation
+
+The full documentation is available within the `docs/` directory of the project repository. Start with `docs/README.md` for navigation.
+
+  * **Getting Started:** `docs/getting-started.md`
+  * **User Guide:** `docs/user-guide/README.md`
+  * **Advanced Features:** `docs/advanced-features/README.md`
+  * **Observability:** `docs/observability/README.md`
+  * **Integrations:** `docs/integrations/README.md`
+  * **Cookbook (Patterns):** `docs/cookbook/README.md`
+  * **Architecture:** `docs/architecture/README.md`
+  * **API Reference:** `docs/api-reference/README.md`
+  * **ADR Index:** `docs/adr/README.md`
+
+-----
+
+## 🧩 Development
+
+```bash
+pip install tox
+tox
+```
+
+-----
+
+## 🧾 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) — *Full redesign for v2.0.0.*
+
+-----
+
+## 📜 License
+
+MIT — [LICENSE](https://opensource.org/licenses/MIT)
+

pico_ioc-2.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+pico_ioc/__init__.py,sha256=AfHqcDJaXLChLJhxej_0gMClHUThUrKABFlIKYVrVtc,2198
+pico_ioc/_version.py,sha256=HVx0XJJ9OYFWBBPBCUFYb8Nm43ChPg9GZLh_dkxh9qI,22
+pico_ioc/aop.py,sha256=prFSlZC6vJYUfTbkMvlSc1T9UvvdEHr94Z0HAvjZ1fg,12985
+pico_ioc/api.py,sha256=Be3bFMPKtkFpHUuToEhDtSriVwyuBg1-b3vUs6WpsQ8,45753
+pico_ioc/config_runtime.py,sha256=z1cHDb5PbM8PMLYRFf5c2dmze8V22xwEzpWcBhtmMpA,11950
+pico_ioc/constants.py,sha256=AhIt0ieDZ9Turxb_YbNzj11wUbBbzjKfWh1BDlSx2Nw,183
+pico_ioc/container.py,sha256=5hLPwoVNY_PsN6XYbbZ6_j1I8IBnteCcahus1vCI_JY,17514
+pico_ioc/event_bus.py,sha256=E8Qb8KZ6K1CuXSbMlG0MNPHkGoWlssLLPzHq1QYdADQ,8346
+pico_ioc/exceptions.py,sha256=GT8flzyXeUWetguc8RRkB4p56waTXMdeNhSKQQ8rh4w,2468
+pico_ioc/factory.py,sha256=Q3aLwZ-MWbXKjm8unr871vlWSeVUDmzFQZ1mXzPkY5I,1557
+pico_ioc/locator.py,sha256=PBxZYO_xCOxG7aJZ0adDtINrJass_ZDNYmPD2O_oNqM,2401
+pico_ioc/scope.py,sha256=GDsDJWw7e5Vpiys-M4vQfKMJWSCiorRsT5cPo6z34Mk,5924
+pico_ioc-2.0.1.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_ioc-2.0.1.dist-info/METADATA,sha256=U6L0obv__5poIDJvadj9z9w56B1-1HWz8Q3yiCStFAI,8741
+pico_ioc-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pico_ioc-2.0.1.dist-info/top_level.txt,sha256=_7_RLu616z_dtRw16impXn4Mw8IXe2J4BeX5912m5dQ,9
+pico_ioc-2.0.1.dist-info/RECORD,,