pico-ioc 0.6.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

pico_ioc/resolver.py

@@ -1,58 +1,110 @@
-# pico_ioc/resolver.py
+# pico_ioc/resolver.py (Python 3.10+)
 
+from __future__ import annotations
 import inspect
-from typing import Any, Dict, Optional
-from .container import PicoContainer
-from .typing_utils import evaluated_hints, resolve_annotation_to_type
-from ._state import _resolving
+from typing import Any, Annotated, get_args, get_origin, get_type_hints
+
+
+def _get_hints(obj, owner_cls=None) -> dict:
+    """type hints with include_extras=True and correct globals/locals."""
+    mod = inspect.getmodule(obj)
+    g = getattr(mod, "__dict__", {})
+    l = vars(owner_cls) if owner_cls is not None else None
+    return get_type_hints(obj, globalns=g, localns=l, include_extras=True)
+
+
+def _is_collection_hint(tp) -> bool:
+    """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", ...].
+    """
+    origin = get_origin(tp) or tp
+    args = get_args(tp) or ()
+    container_kind = list if origin is list else tuple
+
+    if not args:
+        return (object, (), container_kind)
+
+    inner = args[0]
+    if get_origin(inner) is Annotated:
+        base, *extras = get_args(inner)
+        quals = tuple(a for a in extras if isinstance(a, str))
+        return (base, quals, container_kind)
+
+    return (inner, (), container_kind)
+
 
 class Resolver:
-    def __init__(self, container: PicoContainer):
+    def __init__(self, container, *, prefer_name_first: bool = True):
         self.c = container
+        self._prefer_name_first = bool(prefer_name_first)
 
-    def _resolve_by_mro(self, ann) -> Optional[Any]:
-        try:
-            for base in getattr(ann, "__mro__", ())[1:]:
-                if base is object: break
-                if self.c.has(base): return self.c.get(base)
-        except Exception:
-            pass
-        return None
-
-    def _resolve_param(self, name: str, ann) -> Any:
-        if self.c.has(name): return self.c.get(name)
-        if ann is not inspect._empty and self.c.has(ann): return self.c.get(ann)
-        if ann is not inspect._empty:
-            mro_hit = self._resolve_by_mro(ann)
-            if mro_hit is not None: return mro_hit
-        if self.c.has(str(name)): return self.c.get(str(name))
-        key = name if ann is inspect._empty else ann
-        return self.c.get(key)
-
-    def kwargs_for_callable(self, fn, owner_cls=None) -> Dict[str, Any]:
-        sig = inspect.signature(fn)
-        hints = evaluated_hints(fn, owner_cls=owner_cls)
-        deps: Dict[str, Any] = {}
+    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":
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            ann = hints.get(name, param.annotation)
+            try:
+                value = self._resolve_param(name, ann)
+            except NameError:
+                if param.default is not inspect._empty:
+                    continue
+                raise
+            kwargs[name] = value
+        return cls(**kwargs)
 
-        tok = _resolving.set(True)
-        try:
-            for p in sig.parameters.values():
-                if p.name == "self" or p.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+    def kwargs_for_callable(self, fn, *, owner_cls=None):
+        sig = inspect.signature(fn)
+        hints = _get_hints(fn, owner_cls=owner_cls)
+        kwargs = {}
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            ann = hints.get(name, param.annotation)
+            try:
+                value = self._resolve_param(name, ann)
+            except NameError:
+                if param.default is not inspect._empty:
                     continue
-                raw_ann = hints.get(p.name, p.annotation)
-                ann = resolve_annotation_to_type(raw_ann, fn, owner_cls)
-                try:
-                    deps[p.name] = self._resolve_param(p.name, ann)
-                except NameError:
-                    if p.default is not inspect._empty:
-                        continue
-                    missing = ann if ann is not inspect._empty else p.name
-                    raise NameError(f"No provider found for key: {missing}")
-            return deps
-        finally:
-            _resolving.reset(tok)
-
-    def create_instance(self, cls: type) -> Any:
-        kw = self.kwargs_for_callable(cls.__init__, owner_cls=cls)
-        return cls(**kw)
+                raise
+            kwargs[name] = value
+        return kwargs
+
+    def _resolve_param(self, name: str, ann: Any):
+        # collections (list/tuple) with optional qualifiers via Annotated
+        if _is_collection_hint(ann):
+            base, quals, container_kind = _base_and_qualifiers_from_hint(ann)
+            items = self.c._resolve_all_for_base(base, qualifiers=quals)
+            return list(items) if container_kind is list else tuple(items)
+
+        # precedence: by name > by exact annotation > by MRO > by name again
+        if self._prefer_name_first and self.c.has(name):
+            return self.c.get(name)
+
+        if ann is not inspect._empty and self.c.has(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):
+                    return self.c.get(base)
+
+        if self.c.has(name):
+            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,8 +1,10 @@
+# pico_ioc/scanner.py
 import importlib
 import inspect
 import logging
 import pkgutil
-from typing import Any, Callable, Optional, Tuple, List
+from types import ModuleType
+from typing import Any, Callable, Optional, Tuple, List, Iterable
 
 from .container import PicoContainer, Binder
 from .decorators import (
@@ -16,6 +18,7 @@ from .decorators import (
 from .proxy import ComponentProxy
 from .resolver import Resolver
 from .plugins import PicoPlugin
+from . import _state
 
 
 def scan_and_configure(
@@ -24,82 +27,212 @@ def scan_and_configure(
     *,
     exclude: Optional[Callable[[str], bool]] = None,
     plugins: Tuple[PicoPlugin, ...] = (),
-):
-    package = importlib.import_module(package_or_name) if isinstance(package_or_name, str) else package_or_name
-    logging.info(f"Scanning in '{package.__name__}'...")
+) -> None:
+    """
+    Scan a package, discover component classes/factories, and bind them into the container.
+
+    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.
+    """
+    package = _as_module(package_or_name)
+    logging.info("Scanning in '%s'...", getattr(package, "__name__", repr(package)))
+
     binder = Binder(container)
     resolver = Resolver(container)
 
+    _run_plugin_hook(plugins, "before_scan", package, binder)
+
+    comp_classes, factory_classes = _collect_decorated_classes(
+        package=package,
+        exclude=exclude,
+        plugins=plugins,
+        binder=binder,
+    )
+
+    _run_plugin_hook(plugins, "after_scan", package, binder)
+
+    _register_component_classes(
+        classes=comp_classes,
+        container=container,
+        resolver=resolver,
+    )
+
+    _register_factory_classes(
+        factory_classes=factory_classes,
+        container=container,
+        resolver=resolver,
+    )
+
+
+# -------------------- Helpers (private) --------------------
+
+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__"):
+        return package_or_name  # type: ignore[return-value]
+    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:
-            getattr(pl, "before_scan", lambda *a, **k: None)(package, binder)
+            fn = getattr(pl, hook_name, None)
+            if fn:
+                fn(*args, **kwargs)
         except Exception:
-            logging.exception("Plugin before_scan failed")
+            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).
+    """
+    try:
+        pkg_path = package.__path__  # type: ignore[attr-defined]
+    except Exception:
+        return  # not a package; nothing to iterate
 
+    prefix = package.__name__ + "."
+    for _finder, name, _is_pkg in pkgutil.walk_packages(pkg_path, prefix):
+        yield name
+
+
+def _collect_decorated_classes(
+    *,
+    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] = []
 
-    for _, name, _ in pkgutil.walk_packages(package.__path__, package.__name__ + "."):
-        if exclude and exclude(name):
-            logging.info(f"Skipping module {name} (excluded)")
+    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)
+
+            # Collect decorated classes
+            if getattr(obj, COMPONENT_FLAG, False):
+                comp_classes.append(obj)
+            elif getattr(obj, FACTORY_FLAG, False):
+                factory_classes.append(obj)
+
+    # 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(name)
-            for _, obj in inspect.getmembers(module, inspect.isclass):
-                for pl in plugins:
-                    try:
-                        getattr(pl, "visit_class", lambda *a, **k: None)(module, obj, binder)
-                    except Exception:
-                        logging.exception("Plugin visit_class failed")
-                if getattr(obj, COMPONENT_FLAG, False):
-                    comp_classes.append(obj)
-                elif getattr(obj, FACTORY_FLAG, False):
-                    factory_classes.append(obj)
+            module = importlib.import_module(mod_name)
         except Exception as e:
-            logging.warning(f"Module {name} not processed: {e}")
+            logging.warning("Module %s not processed: %s", mod_name, e)
+            continue
 
-    for pl in plugins:
-        try:
-            getattr(pl, "after_scan", lambda *a, **k: None)(package, binder)
-        except Exception:
-            logging.exception("Plugin after_scan failed")
+        _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)
 
-    # Register @component classes (bind ONLY by declared key)
-    for cls in comp_classes:
+    return comp_classes, factory_classes
+
+
+def _register_component_classes(
+    *,
+    classes: List[type],
+    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))
 
-        def provider_factory(c=cls, lazy=is_lazy):
+        def _provider_factory(c=cls, lazy=is_lazy):
             def _factory():
                 if lazy:
                     return ComponentProxy(lambda: resolver.create_instance(c))
                 return resolver.create_instance(c)
             return _factory
 
-        container.bind(key, provider_factory(), lazy=is_lazy)
+        container.bind(key, _provider_factory(), lazy=is_lazy)
 
-    # Register @factory_component methods marked with @provides
+
+def _register_factory_classes(
+    *,
+    factory_classes: List[type],
+    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:
-            finst = resolver.create_instance(fcls)
-            for name, func in inspect.getmembers(fcls, predicate=inspect.isfunction):
-                pk = getattr(func, PROVIDES_KEY, None)
-                if pk is None:
-                    continue
-                is_lazy = bool(getattr(func, PROVIDES_LAZY, False))
-                bound = getattr(finst, name, func.__get__(finst, fcls))
+            # 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)
+            finally:
+                _state._resolving.reset(tok_res)
+        except Exception:
+            logging.exception("Error in factory %s", fcls.__name__)
+            continue
 
-                def make_provider(m=bound, lazy=is_lazy):
-                    def _factory():
-                        kwargs = resolver.kwargs_for_callable(m, owner_cls=fcls)
+        for attr_name, func in inspect.getmembers(fcls, predicate=inspect.isfunction):
+            provided_key = getattr(func, PROVIDES_KEY, None)
+            if provided_key is None:
+                continue
 
-                        def _call():
-                            return m(**kwargs)
+            is_lazy = bool(getattr(func, PROVIDES_LAZY, False))
+            # `bound` is the bound method on the instance (so it has `self`)
+            bound = getattr(finst, attr_name, func.__get__(finst, fcls))
 
-                        return ComponentProxy(lambda: _call()) if lazy else _call()
-                    return _factory
+            def _make_provider(m=bound, owner=fcls, lazy=is_lazy):
+                def _factory():
+                    # Compute kwargs at call time to ensure up-to-date dependency resolution
+                    kwargs = resolver.kwargs_for_callable(m, owner_cls=owner)
 
-                container.bind(pk, make_provider(), lazy=is_lazy)
-        except Exception:
-            logging.exception(f"Error in factory {fcls.__name__}")
+                    def _call():
+                        return m(**kwargs)
+
+                    return ComponentProxy(lambda: _call()) if lazy else _call()
+                return _factory
+
+            container.bind(provided_key, _make_provider(), lazy=is_lazy)
 

pico_ioc/typing_utils.py

@@ -1,23 +1,28 @@
 # pico_ioc/typing_utils.py
 
-import sys, typing
+import sys
+import typing
+
 
 def evaluated_hints(func, owner_cls=None) -> dict:
+    """Return type hints; swallow any error and return {}."""
     try:
         module = sys.modules.get(func.__module__)
         globalns = getattr(module, "__dict__", {})
-        localns = vars(owner_cls) if owner_cls is not None else {}
-        return typing.get_type_hints(func, globalns=globalns, localns=localns)
+        localns = vars(owner_cls) if owner_cls is not None else None
+        return typing.get_type_hints(func, globalns=globalns, localns=localns, include_extras=True)
     except Exception:
         return {}
 
+
 def resolve_annotation_to_type(ann, func, owner_cls=None):
+    """Best-effort evaluation of a string annotation; return original on failure."""
     if not isinstance(ann, str):
         return ann
     try:
         module = sys.modules.get(func.__module__)
         globalns = getattr(module, "__dict__", {})
-        localns = vars(owner_cls) if owner_cls is not None else {}
+        localns = vars(owner_cls) if owner_cls is not None else None
         return eval(ann, globalns, localns)
     except Exception:
         return ann

pico_ioc-1.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: pico-ioc
+Version: 1.1.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: 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 Minimalist IoC Container for Python
+
+[![PyPI](https://img.shields.io/pypi/v/pico-ioc.svg)](https://pypi.org/project/pico-ioc/)
+[![DeepWiki](https://img.shields.io/badge/docs-DeepWiki-blue)](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 **tiny, zero-dependency, decorator-based IoC container for Python**.  
+It helps you build loosely-coupled, testable apps without manual wiring. Inspired by the Spring ecosystem, but minimal.
+
+> ⚠️ **Requires Python 3.10+** (uses `typing.Annotated` and `include_extras=True`).
+
+---
+
+## ✨ Features
+
+- **Zero dependencies** — pure Python, framework-agnostic.
+- **Decorator API** — `@component`, `@factory_component`, `@provides`, `@plugin`.
+- **Fail-fast bootstrap** — eager by default; missing deps surface at startup.
+- **Opt-in lazy** — `lazy=True` wraps with `ComponentProxy`.
+- **Smart resolution order** — parameter name → type annotation → MRO → string.
+- **Qualifiers & collections** — `list[Annotated[T, Q]]` filters by qualifier.
+- **Plugins** — lifecycle hooks (`before_scan`, `after_ready`).
+- **Public API helper** — auto-export decorated symbols in `__init__.py`.
+- **Thread/async safe** — isolation via `ContextVar`.
+- **Overrides for testing** — inject mocks/fakes directly via `init(overrides={...})`.
+
+---
+
+## 📦 Installation
+
+```bash
+# Requires Python 3.10+
+pip install pico-ioc
+````
+
+---
+
+## 🚀 Quick start
+
+```python
+from pico_ioc import component, init
+
+@component
+class Config:
+    url = "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
+import myapp
+c = init(myapp)
+svc = c.get(Service)
+print(svc.run())
+```
+
+**Output:**
+
+```
+fetching from sqlite:///demo.db
+```
+---
+
+### Quick overrides for testing
+
+```python
+from pico_ioc import init
+import myapp
+
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,                  # constant instance
+    "user_service": lambda: {"id": 1},   # provider
+})
+assert c.get("fast_model") == {"repo": "fake-data"}
+```
+---
+
+## 📖 Documentation
+
+* [Overview](.llm/OVERVIEW.md) — mission & concepts
+* [Guide](.llm/GUIDE.md) — practical usage & recipes
+* [Architecture](.llm/ARCHITECTURE.md) — internals & design rationale
+
+---
+
+## 🧪 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-1.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pico_ioc/__init__.py,sha256=7EyifZ02LFfhkAR6zzAaQJvByyMI2_-qNrw49gPoJkA,633
+pico_ioc/_state.py,sha256=KHNtdPrv1s-uynfot2IsNkWotBPyORPCcM2xe9qMMPo,286
+pico_ioc/_version.py,sha256=b6-WiVk0Li5MaV2rBnHYl104TsouINojSWKqHDas0js,22
+pico_ioc/api.py,sha256=pInjKJ1oi8bM4N0u4T3XLFa2qmYiHpQ7omcdXFFkGmE,3928
+pico_ioc/container.py,sha256=oyCCeiPFVx7qw51IR9_ReuccInnpYMNuYhKxOKsioYE,5193
+pico_ioc/decorators.py,sha256=gNPxLFNEdFUFYlxILKjU76XyoPohediK0DNiv-RpK3I,1902
+pico_ioc/plugins.py,sha256=JbI-28VLGJaik7ysXi3L-YGTGxhqwJH4W5QYuWSruDE,589
+pico_ioc/proxy.py,sha256=-e3Z9z7Bc_2wxswwUJI_s8AfvCTps8f8RWUJ9RuEp7E,4606
+pico_ioc/public_api.py,sha256=E3sArCoI1xxkIw7xQBvLYAWcIoVJjcq1s0kH-0qIVDE,2383
+pico_ioc/resolver.py,sha256=PN5uq2dFEStAzzTEl0n4AEyC-k7TowqCu7-uwIDDgEk,3897
+pico_ioc/scanner.py,sha256=-iOj_qX15IBFmOAFQlP_1rIkBfamGzdqYdvIPOvq7sY,7709
+pico_ioc/typing_utils.py,sha256=JQ4bkR60pKxFs3f8JlEz41ruKDsWj-SmkKv3DLJriec,950
+pico_ioc-1.1.0.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_ioc-1.1.0.dist-info/METADATA,sha256=9tZ6dAnCgwLxD2GinaNb3U0FsCTPHTmicJxk9YsFY18,5920
+pico_ioc-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pico_ioc-1.1.0.dist-info/top_level.txt,sha256=_7_RLu616z_dtRw16impXn4Mw8IXe2J4BeX5912m5dQ,9
+pico_ioc-1.1.0.dist-info/RECORD,,