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

pico_ioc/__init__.py

@@ -11,6 +11,7 @@ from .exceptions import (
     ValidationError,
     InvalidBindingError,
     EventBusClosedError,
+    AsyncResolutionError,
 )
 from .api import (
     component,
@@ -23,6 +24,7 @@ from .api import (
     ConfigSource,
     EnvSource,
     FileSource,
+    FlatDictSource,
     init,
     configured,
 )
@@ -50,6 +52,7 @@ __all__ = [
     "SerializationError",
     "ValidationError",
     "InvalidBindingError",
+    "AsyncResolutionError",
     "EventBusClosedError",
     "component",
     "factory",
@@ -76,6 +79,7 @@ __all__ = [
     "EnvSource",
     "FileSource",
     "ConfigSource",
+    "FlatDictSource",
     "init",
     "configured",
     "EventBus",

pico_ioc/_version.py

@@ -1 +1 @@
-__version__ = '2.0.1'
+__version__ = '2.0.3'

pico_ioc/api.py

@@ -6,10 +6,9 @@ import importlib
 import pkgutil
 import logging
 from dataclasses import is_dataclass, fields, dataclass, MISSING
-from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Union, get_args, get_origin, Annotated, Protocol
+from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Union, get_args, get_origin, Annotated, Protocol, Mapping
 from .constants import LOGGER, PICO_INFRA, PICO_NAME, PICO_KEY, PICO_META
 from .exceptions import (
-    ProviderNotFoundError,
     CircularDependencyError,
     ScopeError,
     ConfigurationError,
@@ -54,6 +53,31 @@ class FileSource:
             return str(v)
         return None
 
+class FlatDictSource(ConfigSource):
+    def __init__(self, data: Mapping[str, Any], prefix: str = "", case_sensitive: bool = True):
+        base = dict(data)
+        if case_sensitive:
+            self._data = {str(k): v for k, v in base.items()}
+            self._prefix = prefix
+        else:
+            self._data = {str(k).upper(): v for k, v in base.items()}
+            self._prefix = prefix.upper()
+        self._case_sensitive = case_sensitive
+
+    def get(self, key: str) -> Optional[str]:
+        if not key:
+            return None
+        k = f"{self._prefix}{key}" if self._prefix else key
+        if not self._case_sensitive:
+            k = k.upper()
+        v = self._data.get(k)
+        if v is None:
+            return None
+        if isinstance(v, (str, int, float, bool)):
+            return str(v)
+        return None
+
+
 def _meta_get(obj: Any) -> Dict[str, Any]:
     m = getattr(obj, PICO_META, None)
     if m is None:
@@ -132,29 +156,21 @@ def factory(
         return c
     return dec(cls) if cls else dec
 
-def provides(
-    key: Any,
-    *,
-    name: Any = None,
-    qualifiers: Iterable[str] = (),
-    scope: str = "singleton",
-    primary: bool = False,
-    lazy: bool = False,
-    conditional_profiles: Iterable[str] = (),
-    conditional_require_env: Iterable[str] = (),
-    conditional_predicate: Optional[Callable[[], bool]] = None,
-    on_missing_selector: Optional[object] = None,
-    on_missing_priority: int = 0,
-):
-    def dec(fn):
+def provides(*dargs, **dkwargs):
+    def _apply(fn, key_hint, *, name=None, qualifiers=(), scope="singleton", primary=False, lazy=False, conditional_profiles=(), conditional_require_env=(), conditional_predicate=None, on_missing_selector=None, on_missing_priority=0):
         target = fn.__func__ if isinstance(fn, (staticmethod, classmethod)) else fn
-        @functools.wraps(target)
-        def w(*a, **k):
-            return target(*a, **k)
-        setattr(w, PICO_INFRA, "provides")
-        setattr(w, PICO_NAME, name if name is not None else key)
-        setattr(w, PICO_KEY, key)
-        m = _meta_get(w)
+        inferred_key = key_hint
+        if inferred_key is MISSING:
+            rt = _get_return_type(target)
+            if isinstance(rt, type):
+                inferred_key = rt
+            else:
+                inferred_key = getattr(target, "__name__", str(target))
+        setattr(target, PICO_INFRA, "provides")
+        pico_name = name if name is not None else (inferred_key if isinstance(inferred_key, str) else getattr(target, "__name__", str(target)))
+        setattr(target, PICO_NAME, pico_name)
+        setattr(target, PICO_KEY, inferred_key)
+        m = _meta_get(target)
         m["qualifier"] = tuple(str(q) for q in qualifiers or ())
         m["scope"] = scope
         if primary:
@@ -169,8 +185,16 @@ def provides(
             }
         if on_missing_selector is not None:
             m["on_missing"] = {"selector": on_missing_selector, "priority": int(on_missing_priority)}
-        return w
-    return dec
+        return fn
+
+    if dargs and len(dargs) == 1 and inspect.isfunction(dargs[0]) and not dkwargs:
+        fn = dargs[0]
+        return _apply(fn, MISSING)
+    else:
+        key = dargs[0] if dargs else MISSING
+        def _decorator(fn):
+            return _apply(fn, key, **dkwargs)
+        return _decorator
 
 class Qualifier(str):
     __slots__ = ()
@@ -384,8 +408,18 @@ def _resolve_args(callable_obj: Callable[..., Any], pico: "PicoContainer") -> Di
     try:
         for kind, name, data in plan:
             if kind == "key":
-                tracer.note_param(data if isinstance(data, (str, type)) else name, name)
-                kwargs[name] = pico.get(data)
+                primary_key = data
+                tracer.note_param(primary_key, name)
+                try:
+                    kwargs[name] = pico.get(primary_key)
+                except ProviderNotFoundError as first_error:
+                    if primary_key != name:
+                        try:
+                            kwargs[name] = pico.get(name)
+                        except ProviderNotFoundError:
+                            raise first_error from None
+                    else:
+                        raise first_error from None
             else:
                 vals = [pico.get(k) for k in data]
                 kwargs[name] = vals
@@ -549,7 +583,7 @@ class Registrar:
             deferred.attach(pico, locator)
         for key, md in list(self._metadata.items()):
             if md.lazy:
-                original = self._factory.get(key)
+                original = self._factory.get(key, origin='lazy')
                 def lazy_proxy_provider(_orig=original, _p=pico):
                     return UnifiedComponentProxy(container=_p, object_creator=_orig)
                 self._factory.bind(key, lazy_proxy_provider)

pico_ioc/container.py

@@ -4,7 +4,7 @@ import contextvars
 from typing import Any, Dict, List, Optional, Tuple, overload, Union
 from contextlib import contextmanager
 from .constants import LOGGER, PICO_META
-from .exceptions import CircularDependencyError, ComponentCreationError, ProviderNotFoundError
+from .exceptions import CircularDependencyError, ComponentCreationError, ProviderNotFoundError, AsyncResolutionError
 from .factory import ComponentFactory
 from .locator import ComponentLocator
 from .scope import ScopedCaches, ScopeManager
@@ -173,85 +173,88 @@ class PicoContainer:
                     return k
         return key
 
-    @overload
-    def get(self, key: type) -> Any: ...
-    @overload
-    def get(self, key: str) -> Any: ...
-    def get(self, key: KeyT) -> Any:
+    def _resolve_or_create_internal(self, key: KeyT) -> Tuple[Any, float, bool]:
         key = self._canonical_key(key)
         cache = self._cache_for(key)
         cached = cache.get(key)
         if cached is not None:
             self.context.cache_hit_count += 1
             for o in self._observers: o.on_cache_hit(key)
-            return cached
+            return cached, 0.0, True
+
         import time as _tm
         t0 = _tm.perf_counter()
         chain = list(_resolve_chain.get())
-        for k in chain:
-            if k == key:
+
+        for k_in_chain in chain:
+            if k_in_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")
+
+        requester = chain[-1] if chain else None
+        instance_or_awaitable = None
+
         try:
-            provider = self._factory.get(key)
+            provider = self._factory.get(key, origin=requester)
             try:
-                instance = provider()
+                instance_or_awaitable = provider()
             except ProviderNotFoundError as e:
                 raise
-            except Exception as e:
-                raise ComponentCreationError(key, e) from e
-            instance = self._maybe_wrap_with_aspects(key, instance)
-            cache.put(key, instance)
-            self.context.resolve_count += 1
+            except Exception as creation_error:
+                raise ComponentCreationError(key, creation_error) from creation_error
+
             took_ms = (_tm.perf_counter() - t0) * 1000
-            for o in self._observers: o.on_resolve(key, took_ms)
-            return instance
+            return instance_or_awaitable, took_ms, False
+
         finally:
             self._tracer.leave(token_tracer)
             _resolve_chain.reset(token_chain)
             self.deactivate(token_container)
+            
+    @overload
+    def get(self, key: type) -> Any: ...
+    @overload
+    def get(self, key: str) -> Any: ...
+    def get(self, key: KeyT) -> Any:
+        instance_or_awaitable, took_ms, was_cached = self._resolve_or_create_internal(key)
+
+        if was_cached:
+            return instance_or_awaitable
+
+        instance = instance_or_awaitable
+        if inspect.isawaitable(instance):
+            key_name = getattr(key, '__name__', str(key))
+            raise AsyncResolutionError(key)
+
+        final_instance = self._maybe_wrap_with_aspects(key, instance)
+        cache = self._cache_for(key)
+        cache.put(key, final_instance)
+        self.context.resolve_count += 1
+        for o in self._observers: o.on_resolve(key, took_ms)
+
+        return final_instance
 
     async def aget(self, key: KeyT) -> Any:
-        key = self._canonical_key(key)
+        instance_or_awaitable, took_ms, was_cached = self._resolve_or_create_internal(key)
+
+        if was_cached:
+            return instance_or_awaitable
+
+        instance = instance_or_awaitable
+        if inspect.isawaitable(instance_or_awaitable):
+            instance = await instance_or_awaitable
+
+        final_instance = self._maybe_wrap_with_aspects(key, instance)
         cache = self._cache_for(key)
-        cached = cache.get(key)
-        if cached is not None:
-            self.context.cache_hit_count += 1
-            for o in self._observers: o.on_cache_hit(key)
-            return cached
-        import time as _tm
-        t0 = _tm.perf_counter()
-        chain = list(_resolve_chain.get())
-        for k in chain:
-            if k == 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:
-            provider = self._factory.get(key)
-            try:
-                instance = provider()
-                if inspect.isawaitable(instance):
-                    instance = await instance
-            except ProviderNotFoundError as e:
-                raise
-            except Exception as e:
-                raise ComponentCreationError(key, e) from e
-            instance = self._maybe_wrap_with_aspects(key, instance)
-            cache.put(key, instance)
-            self.context.resolve_count += 1
-            took_ms = (_tm.perf_counter() - t0) * 1000
-            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)
+        cache.put(key, final_instance)
+        self.context.resolve_count += 1
+        for o in self._observers: o.on_resolve(key, took_ms)
+
+        return final_instance
 
     def _resolve_type_key(self, key: type):
         if not self._locator:

pico_ioc/exceptions.py

@@ -4,9 +4,15 @@ class PicoError(Exception):
     pass
 
 class ProviderNotFoundError(PicoError):
-    def __init__(self, key: Any):
-        super().__init__(f"Provider not found for key: {getattr(key, '__name__', key)}")
+    def __init__(self, key: Any, origin: Any | None = None):
+        key_name = getattr(key, '__name__', str(key))
+        origin_name = getattr(origin, '__name__', str(origin)) if origin else "init"
+        super().__init__(
+            f"Provider for key '{key_name}' not found "
+            f"(required by: '{origin_name}')"
+        )
         self.key = key
+        self.origin = origin
 
 class CircularDependencyError(PicoError):
     def __init__(self, chain: Iterable[Any], current: Any, details: str | None = None, hint: str | None = None):
@@ -51,6 +57,15 @@ class InvalidBindingError(ValidationError):
         super().__init__("Invalid bindings:\n" + "\n".join(f"- {e}" for e in errors))
         self.errors = errors
 
+class AsyncResolutionError(PicoError):
+    def __init__(self, key: Any):
+        key_name = getattr(key, '__name__', str(key))
+        super().__init__(
+            f"Synchronous get() received an awaitable for key '{key_name}'. "
+            "Use aget() instead."
+        )
+        self.key = key
+        
 class EventBusError(PicoError):
     def __init__(self, msg: str):
         super().__init__(msg)

pico_ioc/factory.py

@@ -28,9 +28,9 @@ class ComponentFactory:
         self._providers[key] = provider
     def has(self, key: KeyT) -> bool:
         return key in self._providers
-    def get(self, key: KeyT) -> Provider:
+    def get(self, key: KeyT, origin: KeyT) -> Provider:
         if key not in self._providers:
-            raise ProviderNotFoundError(key)
+            raise ProviderNotFoundError(key, origin)
         return self._providers[key]
 
 class DeferredProvider:

{pico_ioc-2.0.1.dist-info → pico_ioc-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pico-ioc
-Version: 2.0.1
+Version: 2.0.3
 Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
 Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
 License: MIT License

pico_ioc-2.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+pico_ioc/__init__.py,sha256=x7Sg0i4P0aXN3L5WH9IoTkyELPk-NQBdaRq8GuoZqO4,2294
+pico_ioc/_version.py,sha256=fcRMgwI40iVFwre_3iKQA-N6sHUo3pAErXcKJS63DRg,22
+pico_ioc/aop.py,sha256=prFSlZC6vJYUfTbkMvlSc1T9UvvdEHr94Z0HAvjZ1fg,12985
+pico_ioc/api.py,sha256=rV8_xa6rjARHND_G1vGSNPBplzaaTV3qm3CEp9ntH54,47444
+pico_ioc/config_runtime.py,sha256=z1cHDb5PbM8PMLYRFf5c2dmze8V22xwEzpWcBhtmMpA,11950
+pico_ioc/constants.py,sha256=AhIt0ieDZ9Turxb_YbNzj11wUbBbzjKfWh1BDlSx2Nw,183
+pico_ioc/container.py,sha256=-0o3T2uiKCnYVHTXP4MnUnA-atNeITjz0CtvUc_rY_E,17237
+pico_ioc/event_bus.py,sha256=E8Qb8KZ6K1CuXSbMlG0MNPHkGoWlssLLPzHq1QYdADQ,8346
+pico_ioc/exceptions.py,sha256=PnIY60r8O-eYXEVk7XPghz-hHNx_012ZLw9ikDwQhqQ,3019
+pico_ioc/factory.py,sha256=RMJJrD91HJdb7R3C6y48Fnia7YRQnQuMuYTC2cIAm34,1579
+pico_ioc/locator.py,sha256=PBxZYO_xCOxG7aJZ0adDtINrJass_ZDNYmPD2O_oNqM,2401
+pico_ioc/scope.py,sha256=GDsDJWw7e5Vpiys-M4vQfKMJWSCiorRsT5cPo6z34Mk,5924
+pico_ioc-2.0.3.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_ioc-2.0.3.dist-info/METADATA,sha256=h7J1Q3I0qZUUqKPLWGrS59TM-yx74-qXjbYH47rn8t8,8741
+pico_ioc-2.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pico_ioc-2.0.3.dist-info/top_level.txt,sha256=_7_RLu616z_dtRw16impXn4Mw8IXe2J4BeX5912m5dQ,9
+pico_ioc-2.0.3.dist-info/RECORD,,

pico_ioc-2.0.1.dist-info/RECORD

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