pico-ioc 2.0.5__py3-none-any.whl → 2.1.1__py3-none-any.whl

pico_ioc/__init__.py

@@ -3,7 +3,6 @@ from .constants import LOGGER_NAME, LOGGER, PICO_INFRA, PICO_NAME, PICO_KEY, PIC
 from .exceptions import (
     PicoError,
     ProviderNotFoundError,
-    CircularDependencyError,
     ComponentCreationError,
     ScopeError,
     ConfigurationError,
@@ -18,23 +17,20 @@ from .api import (
     factory,
     provides,
     Qualifier,
-    configuration,
     configure,
     cleanup,
-    ConfigSource,
-    EnvSource,
-    FileSource,
-    FlatDictSource,
     init,
     configured,
 )
+from .config_builder import configuration, ContextConfig, EnvSource, FileSource, FlatDictSource, Value
 from .scope import ScopeManager, ContextVarScope, ScopeProtocol, ScopedCaches
 from .locator import ComponentLocator
 from .factory import ComponentFactory, ProviderMetadata, DeferredProvider
 from .aop import MethodCtx, MethodInterceptor, intercepted_by, UnifiedComponentProxy, health, ContainerObserver
 from .container import PicoContainer
 from .event_bus import EventBus, ExecPolicy, ErrorPolicy, Event, subscribe, AutoSubscriberMixin
-from .config_runtime import JsonTreeSource, YamlTreeSource, DictSource, Discriminator
+from .config_runtime import JsonTreeSource, YamlTreeSource, DictSource, Discriminator, Value
+from .analysis import DependencyRequest, analyze_callable_dependencies
 
 __all__ = [
     "LOGGER_NAME",
@@ -45,7 +41,6 @@ __all__ = [
     "PICO_META",
     "PicoError",
     "ProviderNotFoundError",
-    "CircularDependencyError",
     "ComponentCreationError",
     "ScopeError",
     "ConfigurationError",
@@ -58,7 +53,6 @@ __all__ = [
     "factory",
     "provides",
     "Qualifier",
-    "configuration",
     "configure",
     "cleanup",
     "ScopeProtocol",
@@ -78,10 +72,12 @@ __all__ = [
     "PicoContainer",
     "EnvSource",
     "FileSource",
-    "ConfigSource",
     "FlatDictSource",
     "init",
     "configured",
+    "configuration",
+    "ContextConfig",
+    "Value",
     "EventBus",
     "ExecPolicy",
     "ErrorPolicy",
@@ -92,6 +88,7 @@ __all__ = [
     "YamlTreeSource",
     "DictSource",
     "Discriminator",
+    "Value",
+    "DependencyRequest",
+    "analyze_callable_dependencies",
 ]
-
-

pico_ioc/_version.py

@@ -1 +1 @@
-__version__ = '2.0.5'
+__version__ = '2.1.1'

pico_ioc/analysis.py

@@ -0,0 +1,92 @@
+import inspect
+from dataclasses import dataclass
+from typing import Any, Callable, List, Optional, Tuple, Union, get_args, get_origin, Annotated
+from .decorators import Qualifier
+
+KeyT = Union[str, type]
+
+@dataclass(frozen=True)
+class DependencyRequest:
+    parameter_name: str
+    key: KeyT
+    is_list: bool = False
+    qualifier: Optional[str] = None
+    is_optional: bool = False
+
+def _extract_annotated(ann: Any) -> Tuple[Any, Optional[str]]:
+    qualifier = None
+    base = ann
+    origin = get_origin(ann)
+
+    if origin is Annotated:
+        args = get_args(ann)
+        base = args[0] if args else Any
+        metas = args[1:] if len(args) > 1 else ()
+        for m in metas:
+            if isinstance(m, Qualifier):
+                qualifier = str(m)
+                break
+    return base, qualifier
+
+def _check_optional(ann: Any) -> Tuple[Any, bool]:
+    origin = get_origin(ann)
+    if origin is Union:
+        args = [a for a in get_args(ann) if a is not type(None)]
+        if len(args) == 1:
+            return args[0], True
+    return ann, False
+
+def analyze_callable_dependencies(callable_obj: Callable[..., Any]) -> Tuple[DependencyRequest, ...]:
+    try:
+        sig = inspect.signature(callable_obj)
+    except (ValueError, TypeError):
+        return ()
+
+    plan: List[DependencyRequest] = []
+    
+    for name, param in sig.parameters.items():
+        if name in ("self", "cls"):
+            continue
+        if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            continue
+
+        ann = param.annotation
+        
+        base_type, is_optional = _check_optional(ann)
+        base_type, qualifier = _extract_annotated(base_type)
+
+        is_list = False
+        elem_t = None
+        
+        origin = get_origin(base_type)
+        if origin in (list, List):
+            is_list = True
+            elem_t = get_args(base_type)[0] if get_args(base_type) else Any
+            elem_t, list_qualifier = _extract_annotated(elem_t)
+            if qualifier is None:
+                qualifier = list_qualifier
+        
+        final_key: KeyT
+        if is_list:
+            final_key = elem_t if isinstance(elem_t, type) else Any
+        elif isinstance(base_type, type):
+            final_key = base_type
+        elif isinstance(base_type, str):
+            final_key = base_type
+        elif ann is inspect._empty:
+            final_key = name
+        else:
+            final_key = base_type
+
+        plan.append(
+            DependencyRequest(
+                parameter_name=name,
+                key=final_key,
+                is_list=is_list,
+                qualifier=qualifier,
+                is_optional=is_optional or (param.default is not inspect._empty)
+            )
+        )
+    
+    return tuple(plan)
+    

pico_ioc/aop.py

@@ -1,9 +1,10 @@
 # src/pico_ioc/aop.py
+
 import inspect
 import pickle
 import threading
 from typing import Any, Callable, Dict, List, Tuple, Protocol, Union
-from .exceptions import SerializationError
+from .exceptions import SerializationError, AsyncResolutionError
 
 KeyT = Union[str, type]
 
@@ -120,9 +121,19 @@ class UnifiedComponentProxy:
             tgt = creator()
             if tgt is None:
                 raise RuntimeError("UnifiedComponentProxy object_creator returned None")
+
+            container = object.__getattribute__(self, "_container")
+            if container and hasattr(container, "_run_configure_methods"):
+                res = container._run_configure_methods(tgt)
+                if inspect.isawaitable(res):
+                    raise AsyncResolutionError(
+                        f"Lazy component {type(tgt).__name__} requires async "
+                        "@configure but was resolved via sync get()"
+                    )
+
             object.__setattr__(self, "_target", tgt)
             return tgt
-    
+        
     def _scope_signature(self) -> Tuple[Any, ...]:
         container = object.__getattribute__(self, "_container")
         target = object.__getattribute__(self, "_target")
@@ -139,7 +150,7 @@ class UnifiedComponentProxy:
                         return ()
                     return (container.scopes.get_id(sc),)
         return ()
-    
+        
     def _build_wrapped(self, name: str, bound: Callable[..., Any], interceptors_cls: Tuple[type, ...]):
         container = object.__getattribute__(self, "_container")
         interceptors = [container.get(cls) for cls in interceptors_cls]
@@ -148,6 +159,7 @@ class UnifiedComponentProxy:
         original_func = bound
         if hasattr(bound, '__func__'):
             original_func = bound.__func__
+        
         if inspect.iscoroutinefunction(original_func):
             async def aw(*args, **kwargs):
                 ctx = MethodCtx(
@@ -182,16 +194,17 @@ class UnifiedComponentProxy:
                     raise RuntimeError(f"Async interceptor returned awaitable on sync method: {name}")
                 return res
             return sig, sw, interceptors_cls
-    
+        
     @property
     def __class__(self):
         return self._get_real_object().__class__
-    
+        
     def __getattr__(self, name: str) -> Any:
         target = self._get_real_object()
         attr = getattr(target, name)
         if not callable(attr):
             return attr
+        
         interceptors_cls = _gather_interceptors_for_method(type(target), name)
         if not interceptors_cls:
             return attr
@@ -201,20 +214,16 @@ class UnifiedComponentProxy:
             cache: Dict[str, Tuple[Tuple[Any, ...], Callable[..., Any], Tuple[type, ...]]] = object.__getattribute__(self, "_cache")
             cur_sig = self._scope_signature()
             cached = cache.get(name)
+            
             if cached is not None:
                 sig, wrapped, cls_tuple = cached
                 if sig == cur_sig and cls_tuple == interceptors_cls:
                     return wrapped
                     
-            cached = cache.get(name)
-            if cached is not None:
-                sig, wrapped, cls_tuple = cached
-                if sig == cur_sig and cls_tuple == interceptors_cls:
-                    return wrapped
             sig, wrapped, cls_tuple = self._build_wrapped(name, attr, interceptors_cls)
             cache[name] = (sig, wrapped, cls_tuple)
             return wrapped
-    
+        
     def __setattr__(self, name, value): setattr(self._get_real_object(), name, value)
     def __delattr__(self, name): delattr(self._get_real_object(), name)
     def __str__(self): return str(self._get_real_object())
@@ -278,4 +287,3 @@ class UnifiedComponentProxy:
             return (pickle.loads, (data,))
         except Exception as e:
             raise SerializationError(f"Proxy target is not serializable: {e}")
-