wireup 2.4.0__tar.gz → 2.5.0__tar.gz

{wireup-2.4.0 → wireup-2.5.0}/.vscode/settings.json

@@ -12,6 +12,7 @@
     "cursorpyright.analysis.autoImportCompletions": true,
     "cSpell.words": [
         "asyncio",
+        "Codegen",
         "pyrefly"
     ],
 }

{wireup-2.4.0 → wireup-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wireup
-Version: 2.4.0
+Version: 2.5.0
 Summary: Python Dependency Injection Library
 Project-URL: Homepage, https://github.com/maldoinc/wireup
 Project-URL: Repository, https://github.com/maldoinc/wireup
@@ -47,7 +47,9 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
-Automate dependency management using Python's type system. Build complex applications with native support for async and generators, plus integrations for popular frameworks out of the box.
+Automate dependency management using Python's type system. Build complex applications with native support for async and
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL
+Python (PEP 703).
 
 > [!TIP]
 > **New**: Inject Dependencies in FastAPI with zero runtime overhead using [Class-Based Handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
@@ -339,26 +341,6 @@ def command(service: Injected[UserService]): ...
 def task(service: Injected[UserService]): ...
 ```
 
-```mermaid
-graph LR
-    subgraph "Core Business Logic"
-        Services[Injectables & Services]
-        Domain[Domain Models]
-    end
-
-    subgraph "Entry Points"
-        API[FastAPI / Web]
-        CLI[Click / CLI]
-        Worker[Celery / Worker]
-    end
-
-    API -->|Uses| Services
-    CLI -->|Uses| Services
-    Worker -->|Uses| Services
-
-    Services --> Domain
-```
-
 ### 🔌 Native Integration with popular frameworks
 
 Integrate with popular frameworks for a smoother developer experience.

{wireup-2.4.0 → wireup-2.5.0}/docs/pages/index.md

@@ -5,7 +5,8 @@ Performant, concise and type-safe Dependency Injection for Python.
 [![PyPI - Version](https://img.shields.io/pypi/v/wireup)](https://pypi.org/project/wireup/)
 
 Automate dependency management using Python's type system. Build complex applications with native support for async and
-generators, plus integrations for popular frameworks out of the box.
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL Python
+(PEP 703).
 
 !!! tip "Zero Runtime Overhead"
 

{wireup-2.4.0 → wireup-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wireup"
-version = "2.4.0"
+version = "2.5.0"
 description = "Python Dependency Injection Library"
 authors = [{ name = "Aldo Mateli", email = "aldo.mateli@gmail.com" }]
 license = { text = "MIT" }

{wireup-2.4.0 → wireup-2.5.0}/readme.md

@@ -9,7 +9,9 @@
 [![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
-Automate dependency management using Python's type system. Build complex applications with native support for async and generators, plus integrations for popular frameworks out of the box.
+Automate dependency management using Python's type system. Build complex applications with native support for async and
+generators, plus integrations for popular frameworks out of the box. Wireup is thread-safe and ready for no-GIL
+Python (PEP 703).
 
 > [!TIP]
 > **New**: Inject Dependencies in FastAPI with zero runtime overhead using [Class-Based Handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
@@ -301,26 +303,6 @@ def command(service: Injected[UserService]): ...
 def task(service: Injected[UserService]): ...
 ```
 
-```mermaid
-graph LR
-    subgraph "Core Business Logic"
-        Services[Injectables & Services]
-        Domain[Domain Models]
-    end
-
-    subgraph "Entry Points"
-        API[FastAPI / Web]
-        CLI[Click / CLI]
-        Worker[Celery / Worker]
-    end
-
-    API -->|Uses| Services
-    CLI -->|Uses| Services
-    Worker -->|Uses| Services
-
-    Services --> Domain
-```
-
 ### 🔌 Native Integration with popular frameworks
 
 Integrate with popular frameworks for a smoother developer experience.

{wireup-2.4.0 → wireup-2.5.0}/test/unit/test_as_type.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import sys
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from typing import Optional, Protocol
 
 import pytest
@@ -171,3 +173,78 @@ def test_as_type_on_optional_factory_new_union_optional():
     instance = container.get(OptionalProto | None)
     assert isinstance(instance, OptionalImpl)
     assert instance.opt() == "opt"
+
+
+class AbstractFoo(ABC):
+    @abstractmethod
+    def bar(self) -> str: ...
+
+
+@injectable(as_type=AbstractFoo)
+class AbstractFooImpl(AbstractFoo):
+    def bar(self) -> str:
+        return "bar"
+
+
+def test_register_with_as_type_abc():
+    container = create_sync_container(injectables=[AbstractFooImpl])
+
+    # Should be resolvable via the abstraction
+    instance = container.get(AbstractFoo)
+    assert isinstance(instance, AbstractFooImpl)
+    assert instance.bar() == "bar"
+
+    # Should NOT be resolvable via the implementation class directly
+    with pytest.raises(UnknownServiceRequestedError):
+        container.get(AbstractFooImpl)
+
+
+class FunctionProto(Protocol):
+    def call(self) -> int: ...
+
+
+class RealService:
+    def call(self) -> int:
+        return 42
+
+
+def test_as_type_on_simple_function():
+    @injectable(as_type=FunctionProto)
+    def factory() -> RealService:
+        return RealService()
+
+    container = create_sync_container(injectables=[factory])
+
+    svc = container.get(FunctionProto)
+    assert svc.call() == 42
+    assert isinstance(svc, RealService)
+
+
+class DependencyProto(Protocol):
+    def do_something(self) -> str: ...
+
+
+class DependencyImpl:
+    def do_something(self) -> str:
+        return "dependency_impl"
+
+
+@injectable
+@dataclass
+class ServiceWithDependency:
+    dependency: DependencyProto
+
+
+def test_as_type_factory_dependency_injection():
+    # Test that a dependency produced by a factory with as_type
+    # is correctly injected into another service.
+
+    @injectable(as_type=DependencyProto)
+    def make_dependency() -> DependencyImpl:
+        return DependencyImpl()
+
+    container = create_sync_container(injectables=[make_dependency, ServiceWithDependency])
+
+    service = container.get(ServiceWithDependency)
+    assert isinstance(service.dependency, DependencyImpl)
+    assert service.dependency.do_something() == "dependency_impl"

wireup-2.5.0/test/unit/test_concurrency.py

@@ -0,0 +1,85 @@
+import asyncio
+
+import pytest
+from wireup import create_async_container, injectable
+
+
+class Counter:
+    pass
+
+
+class ScopedCounter:
+    pass
+
+
+@injectable
+async def counter_factory() -> Counter:
+    await asyncio.sleep(0.01)
+    return Counter()
+
+
+@injectable(lifetime="scoped")
+async def scoped_counter_factory() -> ScopedCounter:
+    await asyncio.sleep(0.01)
+    return ScopedCounter()
+
+
+async def test_singleton_concurrency() -> None:
+    container = create_async_container(services=[counter_factory])
+
+    results = await asyncio.gather(
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+        container.get(Counter),
+    )
+
+    unique_instances = set(results)
+    assert len(unique_instances) == 1, f"Expected 1 singleton instance, got {len(unique_instances)}"
+
+
+async def test_scoped_concurrency_same_scope() -> None:
+    container = create_async_container(services=[scoped_counter_factory])
+
+    async with container.enter_scope() as scope:
+        results = await asyncio.gather(
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+            scope.get(ScopedCounter),
+        )
+
+        unique_instances = set(results)
+        assert len(unique_instances) == 1, f"Expected 1 scoped instance within same scope, got {len(unique_instances)}"
+
+
+async def test_scoped_concurrency_different_scopes() -> None:
+    container = create_async_container(services=[scoped_counter_factory])
+
+    async with container.enter_scope() as scope1:
+        async with container.enter_scope() as scope2:
+            res1, res2 = await asyncio.gather(scope1.get(ScopedCounter), scope2.get(ScopedCounter))
+
+            assert res1 is not res2, "Different scopes should produce different instances"
+
+
+async def test_singleton_concurrency_cross_scope() -> None:
+    container = create_async_container(services=[counter_factory])
+
+    async with container.enter_scope() as scope1, container.enter_scope() as scope2:
+        # Concurrently request the SINGLETON from two different scopes
+        results = await asyncio.gather(
+            scope1.get(Counter),
+            scope1.get(Counter),
+            scope1.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            scope2.get(Counter),
+            container.get(Counter),
+        )
+
+        unique_instances = set(results)
+        assert len(unique_instances) == 1, f"Expected 1 singleton instance, got {len(unique_instances)}"

wireup-2.4.0/z_test_codegen.py → wireup-2.5.0/wireup/codegen.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import contextlib
 from typing import Iterator
 

{wireup-2.4.0 → wireup-2.5.0}/wireup/integration/aiohttp.py

@@ -76,10 +76,10 @@ def _get_startup_event(
     container: wireup.AsyncContainer,
     handlers: Optional[Iterable[Type[_WireupHandler]]],
 ) -> Callable[[web.Application], Awaitable[None]]:
-    for handler_type in handlers or []:
-        container._registry.extend(impls=[InjectableDeclaration(handler_type)])
-        container._compiler.compile()
-        container._scoped_compiler.compile()
+    if handlers:
+        for handler_type in handlers:
+            container._registry.extend(impls=[InjectableDeclaration(handler_type)])
+        container._recompile()
 
     async def _inner(app: web.Application) -> None:
         if handlers:

{wireup-2.4.0 → wireup-2.5.0}/wireup/integration/fastapi.py

@@ -166,8 +166,7 @@ def _update_lifespan(
         if class_based_routes:
             for cbr in class_based_routes:
                 container._registry.extend(impls=[InjectableDeclaration(cbr)])
-            container._compiler.compile()
-            container._scoped_compiler.compile()
+            container._recompile()
 
             for cbr in class_based_routes:
                 await _instantiate_class_based_route(app, container, cbr)

{wireup-2.4.0 → wireup-2.5.0}/wireup/ioc/container/__init__.py

@@ -93,7 +93,7 @@ def _create_container(  # noqa: PLR0913
     singleton_compiler = FactoryCompiler(registry, is_scoped_container=False)
     scoped_compiler = FactoryCompiler(registry, is_scoped_container=True)
     singleton_compiler.compile()
-    scoped_compiler.compile()
+    scoped_compiler.compile(copy_singletons_from=singleton_compiler)
 
     override_manager = OverrideManager(registry.is_type_with_qualifier_known, singleton_compiler, scoped_compiler)
     return klass(

{wireup-2.4.0 → wireup-2.5.0}/wireup/ioc/container/base_container.py

@@ -17,6 +17,7 @@ from wireup.errors import (
     UnknownServiceRequestedError,
     WireupError,
 )
+from wireup.ioc.container.lock_registry import LockRegistry
 
 if TYPE_CHECKING:
     from wireup.ioc.configuration import ConfigStore
@@ -40,6 +41,7 @@ class BaseContainer:
         "_factories",
         "_global_scope_exit_stack",
         "_global_scope_objects",
+        "_locks",
         "_override_mgr",
         "_registry",
         "_scoped_compiler",
@@ -65,6 +67,7 @@ class BaseContainer:
         self._compiler = factory_compiler
         self._scoped_compiler = scoped_compiler
         self._factories = self._compiler.factories
+        self._locks = LockRegistry({obj_id for obj_id, f in self._factories.items() if f.is_async})
 
     @property
     def params(self) -> ConfigStore:
@@ -111,3 +114,9 @@ class BaseContainer:
             return compiled_factory.factory(self)  # type:ignore[no-any-return]
 
         raise UnknownServiceRequestedError(klass, qualifier)
+
+    def _recompile(self) -> None:
+        """Update internal container state after registry changes"""
+        self._compiler.compile()
+        self._scoped_compiler.compile(copy_singletons_from=self._compiler)
+        self._locks._async_hashes.update({obj_id for obj_id, f in self._factories.items() if f.is_async})

wireup-2.5.0/wireup/ioc/container/lock_registry.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Dict
+
+
+class LockRegistry(Dict[int, "asyncio.Lock | threading.Lock"]):
+    __slots__ = ("_async_hashes", "_lock")
+
+    def __init__(self, async_hashes: set[int]) -> None:
+        super().__init__()
+        self._async_hashes = async_hashes
+        self._lock = threading.Lock()
+
+    def __missing__(self, key: int) -> asyncio.Lock | threading.Lock:
+        with self._lock:
+            if key not in self:
+                self[key] = asyncio.Lock() if key in self._async_hashes else threading.Lock()
+            return self[key]

wireup-2.5.0/wireup/ioc/factory_compiler.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+import threading
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Hashable
+
+from wireup.codegen import Codegen
+from wireup.errors import WireupError
+from wireup.ioc.registry import GENERATOR_FACTORY_TYPES, ContainerRegistry, FactoryType
+from wireup.ioc.types import ConfigInjectionRequest, TemplatedString
+from wireup.util import format_name
+
+if TYPE_CHECKING:
+    from wireup.ioc.container.base_container import BaseContainer
+    from wireup.ioc.registry import InjectableFactory
+
+
+@dataclass(**({"slots": True} if sys.version_info >= (3, 10) else {}))
+class CompiledFactory:
+    factory: Callable[[BaseContainer], Any]
+    is_async: bool
+
+
+_CONTAINER_SCOPE_ERROR_MSG = (
+    "Scope mismatch: Cannot resolve {lifetime} injectable {fmt_klass} "
+    "from the root container. "
+    "Only Singleton injectables can be resolved without a scope. "
+    "To resolve {lifetime} injectables, you must create a scope.\n"
+    "See: https://maldoinc.github.io/wireup/latest/lifetimes_and_scopes/"
+)
+
+_WIREUP_GENERATED_FACTORY_NAME = "_wireup_factory"
+_SENTINEL = object()
+
+
+class FactoryCompiler:
+    def __init__(self, registry: ContainerRegistry, *, is_scoped_container: bool) -> None:
+        self._registry = registry
+        self._is_scoped_container = is_scoped_container
+        self.factories: dict[int, CompiledFactory] = {}
+
+    @classmethod
+    def get_object_id(cls, impl: type, qualifier: Hashable) -> int:
+        return hash(impl if qualifier is None else (impl, qualifier))
+
+    def compile(self, copy_singletons_from: FactoryCompiler | None = None) -> None:
+        for impl, qualifiers in self._registry.impls.items():
+            for qualifier in qualifiers:
+                obj_id = FactoryCompiler.get_object_id(impl, qualifier)
+
+                if obj_id in self.factories:
+                    continue
+
+                if (
+                    copy_singletons_from
+                    and (compiled := copy_singletons_from.factories.get(obj_id))
+                    and self._registry.lifetime[impl, qualifier] == "singleton"
+                ):
+                    self.factories[obj_id] = compiled
+                    continue
+
+                self.factories[obj_id] = self._compile_and_create_function(
+                    self._registry.factories[impl, qualifier],
+                    impl,
+                    qualifier,
+                )
+
+        for interface, impls in self._registry.interfaces.items():
+            for qualifier, impl in impls.items():
+                obj_id = FactoryCompiler.get_object_id(interface, qualifier)
+
+                if obj_id in self.factories:
+                    continue
+
+                if (
+                    copy_singletons_from
+                    and (compiled := copy_singletons_from.factories.get(obj_id))
+                    and self._registry.lifetime[impl, qualifier] == "singleton"
+                ):
+                    self.factories[obj_id] = compiled
+                    continue
+
+                self.factories[obj_id] = self._compile_and_create_function(
+                    self._registry.factories[impl, qualifier],
+                    interface,
+                    qualifier,
+                )
+
+    def _get_factory_code(  # noqa: C901, PLR0915
+        self,
+        factory: InjectableFactory,
+        lifetime: str,
+        *,
+        is_interface: bool,
+    ) -> tuple[str, bool, bool]:
+        cg = Codegen()
+
+        maybe_async = "async " if factory.is_async else ""
+        cg += f"{maybe_async}def {_WIREUP_GENERATED_FACTORY_NAME}(container):"
+        cache_created_instance = lifetime != "transient"
+
+        def _generate_factory_body(cg: Codegen) -> None:
+            kwargs = ""
+            for name, dep in self._registry.dependencies[factory.factory].items():
+                if isinstance(dep.annotation, ConfigInjectionRequest):
+                    param_value = (
+                        str(dep.annotation.config_key)
+                        if isinstance(dep.annotation.config_key, TemplatedString)
+                        else f'"{dep.annotation.config_key}"'
+                    )
+                    cg += f"_obj_dep_{name} = parameters.get({param_value})"
+                else:
+                    if self._registry.is_interface_known(dep.klass):
+                        dep_class = self._registry.interface_resolve_impl(dep.klass, dep.qualifier_value)
+                    else:
+                        dep_class = dep.klass
+
+                    maybe_await = "await " if self._registry.factories[dep_class, dep.qualifier_value].is_async else ""
+                    dep_hash = FactoryCompiler.get_object_id(dep_class, dep.qualifier_value)
+                    cg += f"_obj_dep_{name} = {maybe_await}factories[{dep_hash}].factory(container)"
+                kwargs += f"{name}=_obj_dep_{name}, "
+
+            maybe_await = "await " if factory.factory_type == FactoryType.COROUTINE_FN else ""
+
+            cg += f"instance = {maybe_await}ORIGINAL_FACTORY({kwargs.strip()})"
+
+            if factory.factory_type in GENERATOR_FACTORY_TYPES:
+                if lifetime == "singleton":
+                    cg += "container._global_scope_exit_stack.append(instance)"
+                else:
+                    cg += "container._current_scope_exit_stack.append(instance)"
+
+                if factory.factory_type == FactoryType.GENERATOR:
+                    cg += "instance = next(instance)"
+                else:
+                    cg += "instance = await instance.__anext__()"
+
+            if cache_created_instance:
+                cg += "storage[OBJ_ID] = instance"
+                if is_interface:
+                    cg += "storage[ORIGINAL_OBJ_ID] = instance"
+
+            cg += "return instance"
+
+        with cg.indent():
+            if cache_created_instance:
+                if lifetime == "singleton":
+                    cg += "storage = container._global_scope_objects"
+                else:
+                    cg += "storage = container._current_scope_objects"
+
+                cg += "if (res := storage.get(OBJ_ID, _SENTINEL)) is not _SENTINEL:"
+                with cg.indent():
+                    cg += "return res"
+
+                lock = "_singleton_lock" if lifetime == "singleton" else "container._locks[OBJ_HASH]"
+
+                if factory.is_async:
+                    cg += f"async with {lock}:"
+                else:
+                    cg += f"with {lock}:"
+
+                with cg.indent():
+                    # Use Double-Checked locking for factories
+                    # See: https://en.wikipedia.org/wiki/Double-checked_locking
+                    cg += "if (res := storage.get(OBJ_ID, _SENTINEL)) is not _SENTINEL:"
+                    with cg.indent():
+                        cg += "return res"
+
+                    _generate_factory_body(cg)
+            else:
+                _generate_factory_body(cg)
+
+        return cg.get_source(), factory.is_async, lifetime == "singleton"
+
+    def _compile_and_create_function(
+        self, factory: InjectableFactory, impl: type, qualifier: Hashable
+    ) -> CompiledFactory:
+        obj_id = impl, qualifier
+        resolved_obj_id = (
+            (self._registry.interface_resolve_impl(impl, qualifier), qualifier)
+            if self._registry.is_interface_known(impl)
+            else obj_id
+        )
+
+        is_interface = self._registry.is_interface_known(impl)
+
+        if is_interface:
+            lifetime = self._registry.lifetime[self._registry.interface_resolve_impl(impl, qualifier), qualifier]
+        else:
+            lifetime = self._registry.lifetime[impl, qualifier]
+
+        # Non-singleton types cannot be resolved from the root container. Return a factory that will simply error.
+        if lifetime != "singleton" and not self._is_scoped_container:
+            return CompiledFactory(
+                factory=FactoryCompiler._create_scope_mismatch_error_factory(impl, qualifier, lifetime),
+                is_async=False,
+            )
+
+        obj_hash = FactoryCompiler.get_object_id(impl, qualifier)
+        source, is_async, needs_global_lock = self._get_factory_code(
+            factory,
+            lifetime,
+            is_interface=is_interface,
+        )
+
+        try:
+            namespace: dict[str, Any] = {
+                "factories": self.factories,
+                "ORIGINAL_OBJ_ID": obj_id,
+                "OBJ_ID": resolved_obj_id,
+                "OBJ_HASH": obj_hash,
+                "ORIGINAL_FACTORY": self._registry.factories[resolved_obj_id].factory,
+                "TemplatedString": TemplatedString,
+                "WireupError": WireupError,
+                "_CONTAINER_SCOPE_ERROR_MSG": _CONTAINER_SCOPE_ERROR_MSG,
+                "_SENTINEL": _SENTINEL,
+                "parameters": self._registry.parameters,
+            }
+
+            if needs_global_lock:
+                namespace["_singleton_lock"] = asyncio.Lock() if is_async else threading.Lock()
+
+            compiled_code = compile(source, f"<{_WIREUP_GENERATED_FACTORY_NAME}_{obj_id}>", "exec")
+            exec(compiled_code, namespace)  # noqa: S102
+
+            return CompiledFactory(factory=namespace[_WIREUP_GENERATED_FACTORY_NAME], is_async=is_async)
+
+        except Exception as e:
+            msg = f"Failed to compile generated factory {obj_id}: {e}"
+            raise WireupError(msg) from e
+
+    @staticmethod
+    def _create_scope_mismatch_error_factory(
+        impl: type,
+        qualifier: Hashable,
+        lifetime: str,
+    ) -> Callable[[BaseContainer], Any]:
+        def _factory(_: BaseContainer) -> Any:
+            msg = _CONTAINER_SCOPE_ERROR_MSG.format(fmt_klass=format_name(impl, qualifier), lifetime=lifetime)
+            raise WireupError(msg)
+
+        return _factory