pico-ioc 2.0.4__py3-none-any.whl → 2.1.0__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,16 +17,12 @@ 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
@@ -35,6 +30,7 @@ from .aop import MethodCtx, MethodInterceptor, intercepted_by, UnifiedComponentP
 from .container import PicoContainer
 from .event_bus import EventBus, ExecPolicy, ErrorPolicy, Event, subscribe, AutoSubscriberMixin
 from .config_runtime import JsonTreeSource, YamlTreeSource, DictSource, Discriminator
+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,6 @@ __all__ = [
     "YamlTreeSource",
     "DictSource",
     "Discriminator",
+    "DependencyRequest",
+    "analyze_callable_dependencies",
 ]
-
-

pico_ioc/_version.py

@@ -1 +1 @@
-__version__ = '2.0.4'
+__version__ = '2.1.0'

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,4 +1,3 @@
-# src/pico_ioc/aop.py
 import inspect
 import pickle
 import threading
@@ -148,6 +147,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(
@@ -192,6 +192,7 @@ class UnifiedComponentProxy:
         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,16 +202,12 @@ 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