wireup 2.2.2__tar.gz → 2.3.0__tar.gz

{wireup-2.2.2 → wireup-2.3.0}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: wireup
-Version: 2.2.2
+Version: 2.3.0
 Summary: Python Dependency Injection Library
+Home-page: https://github.com/maldoinc/wireup
 License: MIT
 Keywords: flask,django,injector,dependency injection,dependency injection container,dependency injector
 Author: Aldo Mateli
@@ -25,8 +26,8 @@ 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: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: eval-type
@@ -34,7 +35,6 @@ Requires-Dist: eval-type-backport (>=0.2.0,<0.3.0) ; (python_version < "3.11") a
 Requires-Dist: typing_extensions (>=4.7,<5.0)
 Project-URL: Changelog, https://github.com/maldoinc/wireup/releases
 Project-URL: Documentation, https://maldoinc.github.io/wireup/
-Project-URL: Homepage, https://github.com/maldoinc/wireup
 Project-URL: Repository, https://github.com/maldoinc/wireup
 Description-Content-Type: text/markdown
 

{wireup-2.2.2 → wireup-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wireup"
-version = "2.2.2"
+version = "2.3.0"
 description = "Python Dependency Injection Library"
 authors = ["Aldo Mateli <aldo.mateli@gmail.com>"]
 license = "MIT"

{wireup-2.2.2 → wireup-2.3.0}/wireup/__init__.py

@@ -1,4 +1,4 @@
-from wireup._annotations import Inject, Injected, abstract, injectable, service
+from wireup._annotations import Inject, Injected, abstract, service
 from wireup._decorators import inject_from_container
 from wireup.ioc.container import (
     create_async_container,
@@ -21,6 +21,5 @@ __all__ = [
     "create_async_container",
     "create_sync_container",
     "inject_from_container",
-    "injectable",
     "service",
 ]

{wireup-2.2.2 → wireup-2.3.0}/wireup/_annotations.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
 
 def Inject(  # noqa: N802
     *,
-    config: str | None = None,
     param: str | None = None,
     expr: str | None = None,
     qualifier: Qualifier | None = None,
@@ -42,8 +41,6 @@ def Inject(  # noqa: N802
     """
     res: InjectableType
 
-    if config:
-        res = ParameterWrapper(config)
     if param:
         res = ParameterWrapper(param)
     elif expr:
@@ -92,7 +89,7 @@ class AbstractDeclaration:
 
 
 @overload
-def injectable(
+def service(
     obj: None = None,
     *,
     qualifier: Qualifier | None = None,
@@ -102,7 +99,7 @@ def injectable(
 
 
 @overload
-def injectable(
+def service(
     obj: T,
     *,
     qualifier: Qualifier | None = None,
@@ -111,7 +108,7 @@ def injectable(
     pass
 
 
-def injectable(
+def service(
     obj: T | None = None,
     *,
     qualifier: Qualifier | None = None,
@@ -129,9 +126,6 @@ def injectable(
     return _service_decorator if obj is None else _service_decorator(obj)
 
 
-service = injectable
-
-
 def abstract(cls: type[T]) -> type[T]:
     """Mark the decorated class as an abstract service."""
     cls.__wireup_registration__ = AbstractDeclaration(cls)  # type: ignore[attr-defined]

{wireup-2.2.2 → wireup-2.3.0}/wireup/errors.py

@@ -71,7 +71,7 @@ class UnknownQualifiedServiceRequestedError(WireupError):
 class UnknownServiceRequestedError(WireupError):
     """Raised when requesting an unknown type."""
 
-    def __init__(self, klass: type[Any], qualifier: Qualifier | None = None) -> None:
+    def __init__(self, klass: type[Any] | None, qualifier: Qualifier | None = None) -> None:
         qualifier_str = f" with qualifier '{qualifier}'" if qualifier else ""
         msg = f"Cannot create unknown service {klass}{qualifier_str}. Make sure it is registered with the container."
         super().__init__(msg)

{wireup-2.2.2 → wireup-2.3.0}/wireup/integration/django/__init__.py

@@ -1,3 +1,4 @@
 from wireup.integration.django.apps import WireupSettings, get_app_container, get_request_container, wireup_middleware
+from wireup.integration.django.decorators import inject
 
-__all__ = ["WireupSettings", "get_app_container", "get_request_container", "wireup_middleware"]
+__all__ = ["WireupSettings", "get_app_container", "get_request_container", "inject", "wireup_middleware"]

{wireup-2.2.2 → wireup-2.3.0}/wireup/integration/django/apps.py

@@ -114,7 +114,8 @@ class WireupConfig(AppConfig):
         )
         self.inject_scoped = inject_from_container(self.container, get_request_container)
 
-        self._inject(django.urls.get_resolver())
+        if integration_settings.auto_inject_views:
+            self._inject(django.urls.get_resolver())
 
     def _inject(self, resolver: URLResolver) -> None:
         for p in resolver.url_patterns:
@@ -123,6 +124,10 @@ class WireupConfig(AppConfig):
                 continue
 
             if isinstance(p, URLPattern) and p.callback:  # type: ignore[reportUnnecessaryComparison]
+                # Skip auto-injection if the view is already marked by @inject decorator
+                if getattr(p.callback, "__wireup_marked__", False):
+                    continue
+
                 if hasattr(p.callback, "view_class") and hasattr(p.callback, "view_initkwargs"):
                     p.callback = self._inject_class_based_view(p.callback)
                 else:
@@ -160,3 +165,13 @@ class WireupSettings:
 
     service_modules: List[Union[str, ModuleType]]
     """List of modules containing wireup service registrations."""
+
+    auto_inject_views: bool = True
+    """Whether to automatically inject dependencies into Django views.
+
+    When True (default), Wireup will automatically inject dependencies into all Django views.
+    When False, you must use the @inject decorator explicitly on views that need injection.
+
+    Set this to False if you want to use @inject explicitly across all views (useful when mixing
+    core Django views with third-party views like Django REST framework).
+    """

wireup-2.3.0/wireup/integration/django/decorators.py

@@ -0,0 +1,19 @@
+from typing import Any, Callable
+
+from wireup._decorators import inject_from_container_unchecked
+from wireup.errors import WireupError
+from wireup.integration.django.apps import get_request_container
+from wireup.ioc.util import hide_annotated_names
+
+
+def inject(func: Callable[..., Any]) -> Callable[..., Any]:
+    if getattr(func, "__wireup_marked__", False):
+        msg = f"@inject decorator applied multiple times to {func.__module__}.{func.__name__}. Apply it only once."
+        raise WireupError(msg)
+
+    # Modify __signature__ and __annotations__ to hide injectable params (useful for packages like django-ninja)
+    # This also stores the original injectable params in __wireup_names__ for later use.
+    hide_annotated_names(func)
+
+    func.__wireup_marked__ = True  # type: ignore[attr-defined]
+    return inject_from_container_unchecked(get_request_container)(func)

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/container/__init__.py

@@ -92,9 +92,7 @@ def _merge_definitions(
 def create_sync_container(
     service_modules: list[ModuleType] | None = None,
     services: list[Any] | None = None,
-    injectables: list[Any] | None = None,
     parameters: dict[str, Any] | None = None,
-    config: dict[str, Any] | None = None,
 ) -> SyncContainer:
     """Create a Wireup container.
 
@@ -106,12 +104,7 @@ def create_sync_container(
     request parameters via the `Inject(param="name")` syntax.
     :raises WireupError: Raised if the dependencies cannot be fully resolved.
     """
-    return _create_container(
-        SyncContainer,
-        service_modules=service_modules,
-        services=[*(services or []), *(injectables or [])],
-        parameters=parameters,
-    )
+    return _create_container(SyncContainer, service_modules=service_modules, services=services, parameters=parameters)
 
 
 def create_async_container(

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/container/async_container.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, TypeVar, overload
 
 from typing_extensions import Self
 
@@ -18,7 +18,16 @@ T = TypeVar("T")
 
 
 class BareAsyncContainer(BaseContainer):
-    async def get(self, klass: type[T], qualifier: Qualifier | None = None) -> T:
+    @overload
+    async def get(self, klass: type[T], qualifier: Qualifier | None = None) -> T: ...
+    @overload
+    async def get(self, klass: type[T] | None, qualifier: Qualifier | None = None) -> T | None: ...
+
+    async def get(
+        self,
+        klass: type[T] | None,
+        qualifier: Qualifier | None = None,
+    ) -> T | None:
         """Get an instance of the requested type.
 
         :param qualifier: Qualifier for the class if it was registered with one.

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/container/base_container.py

@@ -1,27 +1,30 @@
+from __future__ import annotations
+
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
-    Dict,
     Generator,
     List,
-    Optional,
-    Type,
     TypeVar,
     Union,
+    overload,
 )
 
 from wireup.errors import (
     UnknownServiceRequestedError,
     WireupError,
 )
-from wireup.ioc.factory_compiler import FactoryCompiler
-from wireup.ioc.override_manager import OverrideManager
-from wireup.ioc.parameter import ParameterBag
-from wireup.ioc.service_registry import ServiceRegistry
-from wireup.ioc.types import (
-    ContainerObjectIdentifier,
-    Qualifier,
-)
+
+if TYPE_CHECKING:
+    from wireup.ioc.factory_compiler import FactoryCompiler
+    from wireup.ioc.override_manager import OverrideManager
+    from wireup.ioc.parameter import ParameterBag
+    from wireup.ioc.service_registry import ServiceRegistry
+    from wireup.ioc.types import (
+        ContainerObjectIdentifier,
+        Qualifier,
+    )
 
 T = TypeVar("T")
 ContainerExitStack = List[Union[Generator[Any, Any, Any], AsyncGenerator[Any, Any]]]
@@ -46,10 +49,10 @@ class BaseContainer:
         override_manager: OverrideManager,
         factory_compiler: FactoryCompiler,
         scoped_compiler: FactoryCompiler,
-        global_scope_objects: Dict[ContainerObjectIdentifier, Any],
-        global_scope_exit_stack: List[Union[Generator[Any, Any, Any], AsyncGenerator[Any, Any]]],
-        current_scope_objects: Optional[Dict[ContainerObjectIdentifier, Any]] = None,
-        current_scope_exit_stack: Optional[List[Union[Generator[Any, Any, Any], AsyncGenerator[Any, Any]]]] = None,
+        global_scope_objects: dict[ContainerObjectIdentifier, Any],
+        global_scope_exit_stack: list[Generator[Any, Any, Any] | AsyncGenerator[Any, Any]],
+        current_scope_objects: dict[ContainerObjectIdentifier, Any] | None = None,
+        current_scope_exit_stack: list[Generator[Any, Any, Any] | AsyncGenerator[Any, Any]] | None = None,
     ) -> None:
         self._registry = registry
         self._override_mgr = override_manager
@@ -71,7 +74,16 @@ class BaseContainer:
         """Override registered container services with new values."""
         return self._override_mgr
 
-    def _synchronous_get(self, klass: Type[T], qualifier: Optional[Qualifier] = None) -> T:
+    @overload
+    def _synchronous_get(self, klass: type[T], qualifier: Qualifier | None = None) -> T: ...
+    @overload
+    def _synchronous_get(self, klass: type[T] | None, qualifier: Qualifier | None = None) -> T | None: ...
+
+    def _synchronous_get(
+        self,
+        klass: type[T] | None,
+        qualifier: Qualifier | None = None,
+    ) -> T | None:
         """Get an instance of the requested type.
 
         :param qualifier: Qualifier for the class if it was registered with one.

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/factory_compiler.py

@@ -24,6 +24,7 @@ _CONTAINER_SCOPE_ERROR_MSG = (
     "If you are within a scope, use the scoped container instance to create dependencies."
 )
 _WIREUP_GENERATED_FACTORY_NAME = "_wireup_factory"
+_SENTINEL = object()
 
 
 class FactoryCompiler:
@@ -82,7 +83,7 @@ class FactoryCompiler:
             else:
                 code += "    storage = container._current_scope_objects\n"
 
-            code += "    if res := storage.get(OBJ_ID):\n"
+            code += "    if (res := storage.get(OBJ_ID, _SENTINEL)) is not _SENTINEL:\n"
             code += "        return res\n"
 
         kwargs = ""
@@ -148,6 +149,7 @@ class FactoryCompiler:
                 "TemplatedString": TemplatedString,
                 "WireupError": WireupError,
                 "_CONTAINER_SCOPE_ERROR_MSG": _CONTAINER_SCOPE_ERROR_MSG,
+                "_SENTINEL": _SENTINEL,
                 "parameters": self._registry.parameters,
             }
 

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/service_registry.py

@@ -18,6 +18,7 @@ from wireup.errors import (
     WireupError,
 )
 from wireup.ioc.parameter import ParameterBag
+from wireup.ioc.type_analysis import analyze_type
 from wireup.ioc.types import (
     AnnotatedParameter,
     AnyCallable,
@@ -26,7 +27,7 @@ from wireup.ioc.types import (
     ParameterWrapper,
     ServiceLifetime,
 )
-from wireup.ioc.util import ensure_is_type, get_globals, param_get_annotation, stringify_type, unwrap_optional_type
+from wireup.ioc.util import ensure_is_type, get_globals, param_get_annotation, stringify_type
 
 if TYPE_CHECKING:
     from wireup._annotations import AbstractDeclaration, ServiceDeclaration
@@ -56,6 +57,8 @@ class ServiceFactory:
     factory: Callable[..., Any]
     factory_type: FactoryType
     is_async: bool
+    is_optional_type: bool
+    raw_type: type
 
 
 ServiceCreationDetails = Tuple[Callable[..., Any], ContainerObjectIdentifier, FactoryType, ServiceLifetime]
@@ -90,7 +93,7 @@ def _function_get_unwrapped_return_type(fn: Callable[..., T]) -> type[T] | None:
                 return None
             ret = args[0]  # Extract the yield type from the generator
 
-        return unwrap_optional_type(ret)  # type: ignore[no-any-return]
+        return ret  # type: ignore[no-any-return]
 
     return None
 
@@ -125,7 +128,16 @@ class ServiceRegistry:
             self._register_abstract(abstract.obj)
 
         for impl in impls or []:
-            self._register(obj=impl.obj, lifetime=impl.lifetime, qualifier=impl.qualifier)
+            obj = impl.obj
+            if not callable(obj):
+                raise InvalidRegistrationTypeError(obj)
+
+            klass = _function_get_unwrapped_return_type(obj)
+
+            if klass is None:
+                raise FactoryReturnTypeIsEmptyError(obj)
+
+            self._register(klass=klass, factory_fn=obj, lifetime=impl.lifetime, qualifier=impl.qualifier)
 
         self.assert_dependencies_valid()
         self._precompute_ctors()
@@ -181,17 +193,13 @@ class ServiceRegistry:
 
     def _register(
         self,
-        obj: Callable[..., Any],
+        klass: type[Any],
+        factory_fn: Callable[..., Any],
         lifetime: ServiceLifetime = "singleton",
         qualifier: Qualifier | None = None,
     ) -> None:
-        if not callable(obj):
-            raise InvalidRegistrationTypeError(obj)
-
-        klass = _function_get_unwrapped_return_type(obj)
-
-        if klass is None:
-            raise FactoryReturnTypeIsEmptyError(obj)
+        type_analysis = analyze_type(klass)
+        klass = type_analysis.normalized_type
 
         if self.is_type_with_qualifier_known(klass, qualifier):
             raise DuplicateServiceRegistrationError(klass, qualifier=qualifier)
@@ -208,14 +216,47 @@ class ServiceRegistry:
         if hasattr(klass, "__bases__"):
             discover_interfaces(klass.__bases__)
 
-        self._target_init_context(obj)
+        self._target_init_context(factory_fn)
         self.lifetime[klass, qualifier] = lifetime
-        factory_type = _get_factory_type(obj)
+        factory_type = _get_factory_type(factory_fn)
         self.factories[klass, qualifier] = ServiceFactory(
-            factory=obj, factory_type=factory_type, is_async=factory_type in ASYNC_FACTORY_TYPES
+            factory=factory_fn,
+            factory_type=factory_type,
+            is_async=factory_type in ASYNC_FACTORY_TYPES,
+            is_optional_type=type_analysis.is_optional,
+            raw_type=type_analysis.raw_type,
         )
         self.impls[klass].add(qualifier)
 
+        if type_analysis.is_optional:
+            # Backwards compatibility: In earlier versions when a factory returned T | None
+            # you could do container.get(T). Alias that type to the normalized T | None factory.
+            # Create a fake factory that warns and returns the original instance.
+            # https://github.com/maldoinc/wireup/commit/00590dc741035a4c7042c5b6fc434ed08e27f5c0
+            def compat_fn(raw_type_instance: Any) -> Any:
+                type_name = type_analysis.raw_type.__name__
+                deprecated_msg = (
+                    f"Deprecated: {stringify_type(type_analysis.raw_type)} was registered as optional "
+                    f"and retrieving it via container.get({type_name}) is deprecated. "
+                    f"Please use container.get({type_name} | None) or container.get(Optional[{type_name}]) instead."
+                )
+
+                warnings.warn(deprecated_msg, DeprecationWarning, stacklevel=4)
+
+                return raw_type_instance
+
+            compat_fn.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+                parameters=[
+                    inspect.Parameter(
+                        "raw_type_instance",
+                        kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        annotation=klass,
+                    )
+                ],
+            )
+
+            self._register(type_analysis.raw_type, factory_fn=compat_fn, lifetime=lifetime, qualifier=qualifier)
+
     def _register_abstract(self, klass: type) -> None:
         self.interfaces[klass] = {}
 

wireup-2.3.0/wireup/ioc/type_analysis.py

@@ -0,0 +1,57 @@
+import sys
+from dataclasses import dataclass
+from typing import Any, List, Optional, Tuple, Union
+
+from typing_extensions import Annotated, get_args, get_origin
+
+if sys.version_info >= (3, 10):
+    from types import UnionType
+else:
+    UnionType = object()
+
+
+@dataclass(eq=True)
+class TypeAnalysis:
+    normalized_type: type
+    """The type normalized to Optional[T] (if optional) or T."""
+
+    raw_type: type
+    """The core inner type T, stripped of all Optional/Annotated wrappers."""
+
+    is_optional: bool
+    """True if None was found anywhere in the wrapping layers."""
+
+    annotations: Tuple[Any, ...]
+    """All metadata collected from every Annotated layer found."""
+
+
+def analyze_type(type_hint: Any) -> TypeAnalysis:
+    current_type = type_hint
+    annotations: List[Any] = []
+    is_optional = False
+
+    while True:
+        origin = get_origin(current_type)
+        args = get_args(current_type)
+
+        if origin is Annotated:
+            current_type = args[0]
+            annotations.extend(args[1:])
+            continue
+
+        # Handle Union[T, None] / Optional[T] / T | None (if on 3.10+)
+        if (origin is Union or origin is UnionType) and type(None) in args:
+            is_optional = True
+            union_without_none = tuple(arg for arg in args if arg is not type(None))
+
+            current_type = union_without_none[0] if len(union_without_none) == 1 else Union[union_without_none]  # type:ignore[reportUnknownVariableType, unused-ignore]
+            continue
+
+        break
+
+    return TypeAnalysis(
+        normalized_type=Optional[current_type] if is_optional else current_type,  # type:ignore[arg-type]
+        raw_type=current_type,  # type:ignore[arg-type, unused-ignore]
+        is_optional=is_optional,
+        annotations=tuple(annotations),
+    )

{wireup-2.2.2 → wireup-2.3.0}/wireup/ioc/util.py

@@ -4,16 +4,15 @@ import functools
 import importlib
 import inspect
 import sys
-import types
 import typing
 from inspect import Parameter
 from typing import Any, Sequence, TypeVar, cast
 
 from wireup.errors import WireupError
+from wireup.ioc.type_analysis import analyze_type
 from wireup.ioc.types import AnnotatedParameter, AnyCallable, InjectableType
 
 T = TypeVar("T")
-_OPTIONAL_UNION_ARG_COUNT = 2
 _eval_type = cast("Callable[..., Any]", typing._eval_type)  # type: ignore[attr-defined]
 
 if typing.TYPE_CHECKING:
@@ -65,24 +64,12 @@ def param_get_annotation(
     if not resolved_type:
         return None
 
-    annotation = None
-    inner_type = resolved_type
+    type_analysis = analyze_type(resolved_type)
 
-    # Handle Annotated[Optional[T], ...] pattern
-    if hasattr(resolved_type, "__metadata__") and hasattr(resolved_type, "__args__"):
-        annotation = _get_wireup_annotation(resolved_type.__metadata__)
-        inner_type = resolved_type.__args__[0]
-        unwrapped_type = unwrap_optional_type(inner_type)
-        inner_type = unwrapped_type
-    else:
-        # Handle Optional[T] or Optional[Annotated[T, ...]] pattern
-        unwrapped_type = unwrap_optional_type(resolved_type)
-        inner_type = unwrapped_type
-        if hasattr(inner_type, "__metadata__") and hasattr(inner_type, "__args__"):
-            annotation = _get_wireup_annotation(inner_type.__metadata__)
-            inner_type = inner_type.__args__[0]
-
-    return AnnotatedParameter(klass=inner_type, annotation=annotation)
+    return AnnotatedParameter(
+        klass=type_analysis.normalized_type,
+        annotation=_get_wireup_annotation(type_analysis.annotations),
+    )
 
 
 def _type_get_globals(typ: type) -> dict[str, Any]:
@@ -169,23 +156,6 @@ def ensure_is_type(value: type[T] | str, globalns_supplier: Callable[[], dict[st
         raise WireupError(msg) from e
 
 
-def unwrap_optional_type(type_: Any) -> Any:
-    """If the given type is Optional[T], returns T. Otherwise returns type_."""
-    valid_origins = [typing.Union]
-
-    # types.UnionType requires py310+
-    if union_type := getattr(types, "UnionType", None):
-        valid_origins.append(union_type)
-
-    origin = typing.get_origin(type_) or type_
-    if origin in valid_origins:
-        args = typing.get_args(type_)
-        if len(args) == _OPTIONAL_UNION_ARG_COUNT and type(None) in args:
-            return next(arg for arg in args if arg is not type(None))
-
-    return type_
-
-
 def stringify_type(target: type | AnyCallable) -> str:
     return f"{type(target).__name__.capitalize()} {target.__module__}.{target.__name__}"