wireup 2.2.1__tar.gz → 2.2.2__tar.gz

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

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wireup
-Version: 2.2.1
+Version: 2.2.2
 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
@@ -26,14 +25,16 @@ 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: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: eval-type
-Requires-Dist: eval-type-backport (>=0.2.0,<0.3.0) ; extra == "eval-type"
+Requires-Dist: eval-type-backport (>=0.2.0,<0.3.0) ; (python_version < "3.11") and (extra == "eval-type")
 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.1 → wireup-2.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wireup"
-version = "2.2.1"
+version = "2.2.2"
 description = "Python Dependency Injection Library"
 authors = ["Aldo Mateli <aldo.mateli@gmail.com>"]
 license = "MIT"
@@ -33,6 +33,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3 :: Only",
     "Typing :: Typed",
     "Topic :: Software Development :: Libraries :: Python Modules",
@@ -46,7 +47,7 @@ Changelog = "https://github.com/maldoinc/wireup/releases"
 [tool.poetry.dependencies]
 python = "^3.8"
 typing_extensions = "^4.7"
-eval-type-backport = { version = "^0.2.0", optional = true }
+eval-type-backport = { version = "^0.2.0", optional = true, python = "<3.11" }
 
 [tool.poetry.extras]
 eval-type = ["eval-type-backport"]

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

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

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

@@ -23,6 +23,7 @@ if TYPE_CHECKING:
 
 def Inject(  # noqa: N802
     *,
+    config: str | None = None,
     param: str | None = None,
     expr: str | None = None,
     qualifier: Qualifier | None = None,
@@ -41,6 +42,8 @@ def Inject(  # noqa: N802
     """
     res: InjectableType
 
+    if config:
+        res = ParameterWrapper(config)
     if param:
         res = ParameterWrapper(param)
     elif expr:
@@ -89,7 +92,7 @@ class AbstractDeclaration:
 
 
 @overload
-def service(
+def injectable(
     obj: None = None,
     *,
     qualifier: Qualifier | None = None,
@@ -99,7 +102,7 @@ def service(
 
 
 @overload
-def service(
+def injectable(
     obj: T,
     *,
     qualifier: Qualifier | None = None,
@@ -108,7 +111,7 @@ def service(
     pass
 
 
-def service(
+def injectable(
     obj: T | None = None,
     *,
     qualifier: Qualifier | None = None,
@@ -126,6 +129,9 @@ def service(
     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.1 → wireup-2.2.2}/wireup/integration/django/apps.py

@@ -137,7 +137,7 @@ class WireupConfig(AppConfig):
             injected_names = {
                 name: self.container.params.get(param.annotation.param)
                 if isinstance(param.annotation, ParameterWrapper)
-                else get_request_container().get(param.klass, qualifier=param.qualifier_value)
+                else get_request_container()._synchronous_get(param.klass, qualifier=param.qualifier_value)
                 for name, param in names_to_inject.items()
                 if param.annotation
             }

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

@@ -92,7 +92,9 @@ 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.
 
@@ -104,7 +106,12 @@ 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, parameters=parameters)
+    return _create_container(
+        SyncContainer,
+        service_modules=service_modules,
+        services=[*(services or []), *(injectables or [])],
+        parameters=parameters,
+    )
 
 
 def create_async_container(

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

@@ -80,7 +80,7 @@ def _function_get_unwrapped_return_type(fn: Callable[..., T]) -> type[T] | None:
         return fn
 
     if ret := fn.__annotations__.get("return"):
-        ret = ensure_is_type(ret, globalns=get_globals(fn))
+        ret = ensure_is_type(ret, globalns_supplier=lambda: get_globals(fn))
         if not ret:
             return None
 
@@ -225,7 +225,7 @@ class ServiceRegistry:
     ) -> None:
         """Init and collect all the necessary dependencies to initialize the specified target."""
         for name, parameter in inspect.signature(target).parameters.items():
-            annotated_param = param_get_annotation(parameter, globalns=get_globals(target))
+            annotated_param = param_get_annotation(parameter, globalns_supplier=lambda: get_globals(target))
 
             if not annotated_param:
                 msg = f"Wireup dependencies must have types. Please add a type to the '{name}' parameter in {target}."

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

@@ -3,15 +3,18 @@ from __future__ import annotations
 import functools
 import importlib
 import inspect
+import sys
 import types
 import typing
 from inspect import Parameter
-from typing import Any, Sequence, TypeVar
+from typing import Any, Sequence, TypeVar, cast
 
 from wireup.errors import WireupError
 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:
     from collections.abc import Callable
@@ -43,14 +46,18 @@ def _get_wireup_annotation(metadata: Sequence[Any]) -> InjectableType | None:
     return annotations[0]
 
 
-def param_get_annotation(parameter: Parameter, *, globalns: dict[str, Any]) -> AnnotatedParameter | None:
+def param_get_annotation(
+    parameter: Parameter,
+    *,
+    globalns_supplier: Callable[[], dict[str, Any]],
+) -> AnnotatedParameter | None:
     """Get the annotation injection type from a signature's Parameter.
 
     Returns the first injectable annotation for an Annotated type or the default value.
     Also handles Optional types by marking them as optional in the AnnotatedParameter.
     Supports both Annotated[Optional[T], ...] and Optional[Annotated[T, ...]] patterns.
     """
-    resolved_type: type[Any] | None = ensure_is_type(parameter.annotation, globalns=globalns)
+    resolved_type: type[Any] | None = ensure_is_type(parameter.annotation, globalns_supplier=globalns_supplier)
 
     if resolved_type is Parameter.empty:
         resolved_type = None
@@ -78,10 +85,24 @@ def param_get_annotation(parameter: Parameter, *, globalns: dict[str, Any]) -> A
     return AnnotatedParameter(klass=inner_type, annotation=annotation)
 
 
+def _type_get_globals(typ: type) -> dict[str, Any]:
+    """
+    Merge globals from parent classes with the child class's module globals,
+    with child class globals taking precedence.
+    """
+    merged_globals: dict[str, Any] = {}
+
+    for base_class in reversed(typ.__mro__[:-1]):
+        base_globals = importlib.import_module(base_class.__module__).__dict__
+        merged_globals.update(base_globals)
+
+    return merged_globals
+
+
 def get_globals(obj: type[Any] | Callable[..., Any]) -> dict[str, Any]:
     """Return the globals for the given object."""
     if isinstance(obj, type):
-        return importlib.import_module(obj.__module__).__dict__
+        return _type_get_globals(obj)
 
     # Unwrap nested functools.partial to get the underlying function
     while isinstance(obj, functools.partial):
@@ -90,31 +111,62 @@ def get_globals(obj: type[Any] | Callable[..., Any]) -> dict[str, Any]:
     return obj.__globals__
 
 
-T = TypeVar("T")
+def _eval_type_native(
+    value: typing.ForwardRef,
+    globalns: dict[str, Any] | None = None,
+) -> Any:
+    """Evaluate a ForwardRef using the native typing._eval_type function.
+
+    This function handles version-specific differences in typing._eval_type.
+    """
+    if sys.version_info >= (3, 14):
+        res = _eval_type(value, globalns, None, type_params=())
+
+        return type(None) if res is None else res
+
+    return _eval_type(value, globalns, None)
 
 
-def ensure_is_type(value: type[T] | str, globalns: dict[str, Any] | None = None) -> type[T] | None:
+def ensure_is_type(value: type[T] | str, globalns_supplier: Callable[[], dict[str, Any]]) -> type[T] | None:
     """Ensure the given value represents a type.
 
-    If it is a string it will be evaluated using eval_type_backport.
+    If it is a string it will be evaluated, first trying the native typing._eval_type,
+    and falling back to eval_type_backport if needed.
+
+    This approach ensures compatibility with Python 3.14+ where eval_type_backport
+    cannot be imported due to ForwardRef subclassing restrictions.
     """
-    if isinstance(value, str):
+    if not isinstance(value, str):
+        return value
+
+    forward_ref = typing.ForwardRef(value)
+
+    try:
+        # First, try using the native typing._eval_type then fall back to eval_type_backport.
+        # For a more complete solution see the pydantic implementation below.
+        # See: https://github.com/pydantic/pydantic/blob/f42171c760d43b9522fde513ae6e209790f7fefb/pydantic/_internal/_typing_extra.py#L485-L512
+        return _eval_type_native(forward_ref, globalns=globalns_supplier())  # type:ignore[no-any-return]
+    except TypeError as eval_type_error:
         try:
             import eval_type_backport
-
-            return eval_type_backport.eval_type_backport(  # type:ignore[no-any-return]
-                eval_type_backport.ForwardRef(value), globalns=globalns, try_default=False
-            )
-        except NameError:
-            return None
-        except ImportError as e:
+        except ImportError as import_error:
             msg = (
-                "Using __future__ annotations in Wireup requires the eval_type_backport package to be installed. "
+                f"Error evaluating type annotation '{value}'. "
+                f"Got: TypeError: {eval_type_error}.\n"
+                "Tip: Try using the eval_type_backport package to resolve stringified types.\n"
                 "See: https://maldoinc.github.io/wireup/latest/future_annotations/"
             )
-            raise WireupError(msg) from e
+            raise WireupError(msg) from import_error
+
+        return eval_type_backport.eval_type_backport(forward_ref, globalns=globalns_supplier(), try_default=False)  # type:ignore[no-any-return]
 
-    return value
+    except NameError as e:
+        msg = (
+            f"Error evaluating type annotation '{value}'. Got NameError: {e!s}. "
+            "Make sure the type is correctly imported and not inside a TYPE_CHECKING block.\n"
+            "See: https://maldoinc.github.io/wireup/latest/future_annotations/"
+        )
+        raise WireupError(msg) from e
 
 
 def unwrap_optional_type(type_: Any) -> Any:
@@ -182,7 +234,7 @@ def get_inject_annotated_parameters(target: AnyCallable) -> dict[str, AnnotatedP
     return {
         name: param
         for name, parameter in inspect.signature(target).parameters.items()
-        if (param := param_get_annotation(parameter, globalns=get_globals(target)))
+        if (param := param_get_annotation(parameter, globalns_supplier=lambda: get_globals(target)))
         and isinstance(param.annotation, InjectableType)
     }