wireup 2.1.0__tar.gz → 2.2.0__tar.gz

{wireup-2.1.0 → wireup-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wireup
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python Dependency Injection Library
 License: MIT
 Keywords: flask,django,injector,dependency injection,dependency injection container,dependency injector

{wireup-2.1.0 → wireup-2.2.0}/pyproject.toml

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

{wireup-2.1.0 → wireup-2.2.0}/wireup/_decorators.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import asyncio
 import contextlib
 import functools
+import inspect
 from contextlib import AsyncExitStack, ExitStack
 from typing import TYPE_CHECKING, Any, Callable
 
@@ -10,7 +10,7 @@ from wireup.errors import WireupError
 from wireup.ioc.container.async_container import AsyncContainer, ScopedAsyncContainer, async_container_force_sync_scope
 from wireup.ioc.container.sync_container import SyncContainer
 from wireup.ioc.types import AnnotatedParameter, ParameterWrapper
-from wireup.ioc.validation import (
+from wireup.ioc.util import (
     get_inject_annotated_parameters,
     get_valid_injection_annotated_parameters,
 )
@@ -60,7 +60,7 @@ def inject_from_container(
     """
 
     def _decorator(target: Callable[..., Any]) -> Callable[..., Any]:
-        if asyncio.iscoroutinefunction(target) and isinstance(container, SyncContainer):
+        if inspect.iscoroutinefunction(target) and isinstance(container, SyncContainer):
             msg = (
                 "Sync container cannot perform injection on async targets. "
                 "Create an async container via wireup.create_async_container."
@@ -96,7 +96,7 @@ def inject_from_container_util(  # noqa: C901
     if not names_to_inject:
         return target
 
-    if asyncio.iscoroutinefunction(target):
+    if inspect.iscoroutinefunction(target):
 
         @functools.wraps(target)
         async def _inject_async_target(*args: Any, **kwargs: Any) -> Any:

{wireup-2.1.0 → wireup-2.2.0}/wireup/integration/aiohttp.py

@@ -77,7 +77,9 @@ def _get_startup_event(
     handlers: Optional[Iterable[Type[_WireupHandler]]],
 ) -> Callable[[web.Application], Awaitable[None]]:
     for handler_type in handlers or []:
-        container._registry._extend_with_services(abstracts=[], impls=[ServiceDeclaration(handler_type)])
+        container._registry.extend(impls=[ServiceDeclaration(handler_type)])
+        container._compiler.compile()
+        container._scoped_compiler.compile()
 
     async def _inner(app: web.Application) -> None:
         if handlers:

{wireup-2.1.0 → wireup-2.2.0}/wireup/integration/django/apps.py

@@ -1,6 +1,6 @@
-import asyncio
 import functools
 import importlib
+import inspect
 from contextvars import ContextVar
 from dataclasses import dataclass
 from types import ModuleType
@@ -21,7 +21,7 @@ from wireup.errors import WireupError
 from wireup.ioc.container.async_container import AsyncContainer, ScopedAsyncContainer, async_container_force_sync_scope
 from wireup.ioc.container.sync_container import ScopedSyncContainer
 from wireup.ioc.types import ParameterWrapper
-from wireup.ioc.validation import get_valid_injection_annotated_parameters
+from wireup.ioc.util import get_valid_injection_annotated_parameters
 
 if TYPE_CHECKING:
     from wireup.integration.django import WireupSettings
@@ -38,7 +38,7 @@ def wireup_middleware(
 ) -> Callable[[HttpRequest], Union[HttpResponse, Awaitable[HttpResponse]]]:
     container = get_app_container()
 
-    if asyncio.iscoroutinefunction(get_response):
+    if inspect.iscoroutinefunction(get_response):
 
         async def async_inner(request: HttpRequest) -> HttpResponse:
             async with container.enter_scope() as scoped:

{wireup-2.1.0 → wireup-2.2.0}/wireup/integration/fastapi.py

@@ -33,8 +33,7 @@ from wireup.integration.starlette import (
 from wireup.ioc.container.async_container import AsyncContainer, ScopedAsyncContainer
 from wireup.ioc.container.sync_container import ScopedSyncContainer
 from wireup.ioc.types import AnyCallable
-from wireup.ioc.validation import (
-    assert_dependencies_valid,
+from wireup.ioc.util import (
     get_inject_annotated_parameters,
     hide_annotated_names,
 )
@@ -166,8 +165,9 @@ def _update_lifespan(
     async def lifespan(app: FastAPI) -> AsyncIterator[Any]:
         if class_based_routes:
             for cbr in class_based_routes:
-                container._registry._extend_with_services(abstracts=[], impls=[ServiceDeclaration(cbr)])
-            assert_dependencies_valid(container)
+                container._registry.extend(impls=[ServiceDeclaration(cbr)])
+            container._compiler.compile()
+            container._scoped_compiler.compile()
 
             for cbr in class_based_routes:
                 await _instantiate_class_based_route(app, container, cbr)

{wireup-2.1.0 → wireup-2.2.0}/wireup/ioc/container/__init__.py

@@ -8,11 +8,10 @@ from wireup.errors import WireupError
 from wireup.ioc.container.async_container import AsyncContainer
 from wireup.ioc.container.base_container import BaseContainer
 from wireup.ioc.container.sync_container import SyncContainer
+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 ContainerScope
-from wireup.ioc.validation import assert_dependencies_valid
 
 if TYPE_CHECKING:
     from types import ModuleType
@@ -36,6 +35,36 @@ def _create_container(
     :param parameters: Dict containing parameters you want to expose to the container. Services or factories can
     request parameters via the `Inject(param="name")` syntax.
     """
+    abstracts, impls = _merge_definitions(service_modules, services)
+    registry = ServiceRegistry(parameters=ParameterBag(parameters), abstracts=abstracts, impls=impls)
+
+    # The container uses a dual-compiler optimization strategy:
+    # 1. The singleton compiler generates optimized factories for singleton dependencies
+    #    and throws errors if scoped dependencies are accessed outside a scope.
+    # 2. The scoped compiler handles dependencies that require request/scope isolation.
+    #
+    # When entering/exiting scopes, the container switches between these compilers.
+    # This eliminates the need to check lifetime rules at runtime.
+    singleton_compiler = FactoryCompiler(registry, is_scoped_container=False)
+    scoped_compiler = FactoryCompiler(registry, is_scoped_container=True)
+    singleton_compiler.compile()
+    scoped_compiler.compile()
+
+    override_manager = OverrideManager(registry.is_type_with_qualifier_known, singleton_compiler, scoped_compiler)
+    return klass(
+        registry=registry,
+        factory_compiler=singleton_compiler,
+        scoped_compiler=scoped_compiler,
+        global_scope_objects={},
+        global_scope_exit_stack=[],
+        override_manager=override_manager,
+    )
+
+
+def _merge_definitions(
+    service_modules: Iterable[ModuleType] | None = None,
+    services: Iterable[Any] | None = None,
+) -> tuple[list[AbstractDeclaration], list[ServiceDeclaration]]:
     abstracts: list[AbstractDeclaration] = []
     impls: list[ServiceDeclaration] = []
 
@@ -57,17 +86,7 @@ def _create_container(
         abstracts.extend(discovered_abstracts)
         impls.extend(discovered_services)
 
-    registry = ServiceRegistry(abstracts=abstracts, impls=impls)
-    container = klass(
-        registry=registry,
-        parameters=ParameterBag(parameters),
-        global_scope=ContainerScope(objects={}, exit_stack=[]),
-        override_manager=OverrideManager({}, registry.is_type_with_qualifier_known),
-    )
-
-    assert_dependencies_valid(container)
-
-    return container
+    return abstracts, impls
 
 
 def create_sync_container(

{wireup-2.1.0 → wireup-2.2.0}/wireup/ioc/container/async_container.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeVar
 
 from typing_extensions import Self
 
+from wireup.errors import UnknownServiceRequestedError
 from wireup.ioc._exit_stack import async_clean_exit_stack
 from wireup.ioc.container.base_container import BaseContainer
 from wireup.ioc.container.sync_container import ScopedSyncContainer
@@ -11,12 +12,30 @@ from wireup.ioc.container.sync_container import ScopedSyncContainer
 if TYPE_CHECKING:
     from types import TracebackType
 
+    from wireup.ioc.types import Qualifier
+
+T = TypeVar("T")
+
 
 class BareAsyncContainer(BaseContainer):
-    get = BaseContainer._async_get
+    async def get(self, klass: type[T], qualifier: Qualifier | None = None) -> T:
+        """Get an instance of the requested type.
+
+        :param qualifier: Qualifier for the class if it was registered with one.
+        :param klass: Class of the dependency already registered in the container.
+        :return: An instance of the requested object. Always returns an existing instance when one is available.
+        """
+        obj_id = hash(klass if qualifier is None else (klass, qualifier))
+
+        if compiled_factory := self._factories.get(obj_id):
+            res = compiled_factory.factory(self)
+
+            return await res if compiled_factory.is_async else res  # type:ignore[no-any-return]
+
+        raise UnknownServiceRequestedError(klass, qualifier)
 
     async def close(self) -> None:
-        await async_clean_exit_stack(self._global_scope.exit_stack)
+        await async_clean_exit_stack(self._global_scope_exit_stack)
 
 
 class ScopedAsyncContainer(BareAsyncContainer):
@@ -37,11 +56,13 @@ class AsyncContainer(BareAsyncContainer):
     def enter_scope(self) -> ScopedAsyncContainer:
         return ScopedAsyncContainer(
             registry=self._registry,
-            parameters=self._params,
             override_manager=self._override_mgr,
-            global_scope=self._global_scope,
+            global_scope_objects=self._global_scope_objects,
+            global_scope_exit_stack=self._global_scope_exit_stack,
             current_scope_objects={},
             current_scope_exit_stack=[],
+            factory_compiler=self._scoped_compiler,
+            scoped_compiler=self._scoped_compiler,
         )
 
 
@@ -53,9 +74,11 @@ def async_container_force_sync_scope(container: AsyncContainer) -> ScopedSyncCon
     """
     return ScopedSyncContainer(
         registry=container._registry,
-        parameters=container._params,
         override_manager=container._override_mgr,
-        global_scope=container._global_scope,
+        global_scope_objects=container._global_scope_objects,
+        global_scope_exit_stack=container._global_scope_exit_stack,
         current_scope_objects={},
         current_scope_exit_stack=[],
+        factory_compiler=container._scoped_compiler,
+        scoped_compiler=container._scoped_compiler,
     )

wireup-2.2.0/wireup/ioc/container/base_container.py

@@ -0,0 +1,93 @@
+from typing import (
+    Any,
+    AsyncGenerator,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
+
+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,
+)
+
+T = TypeVar("T")
+ContainerExitStack = List[Union[Generator[Any, Any, Any], AsyncGenerator[Any, Any]]]
+
+
+class BaseContainer:
+    __slots__ = (
+        "_compiler",
+        "_current_scope_exit_stack",
+        "_current_scope_objects",
+        "_factories",
+        "_global_scope_exit_stack",
+        "_global_scope_objects",
+        "_override_mgr",
+        "_registry",
+        "_scoped_compiler",
+    )
+
+    def __init__(  # noqa: PLR0913
+        self,
+        registry: ServiceRegistry,
+        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,
+    ) -> None:
+        self._registry = registry
+        self._override_mgr = override_manager
+        self._global_scope_objects = global_scope_objects
+        self._global_scope_exit_stack = global_scope_exit_stack
+        self._current_scope_objects = current_scope_objects
+        self._current_scope_exit_stack = current_scope_exit_stack
+        self._compiler = factory_compiler
+        self._scoped_compiler = scoped_compiler
+        self._factories = self._compiler.factories
+
+    @property
+    def params(self) -> ParameterBag:
+        """Parameter bag associated with this container."""
+        return self._registry.parameters
+
+    @property
+    def override(self) -> OverrideManager:
+        """Override registered container services with new values."""
+        return self._override_mgr
+
+    def _synchronous_get(self, klass: Type[T], qualifier: Optional[Qualifier] = None) -> T:
+        """Get an instance of the requested type.
+
+        :param qualifier: Qualifier for the class if it was registered with one.
+        :param klass: Class of the dependency already registered in the container.
+        :return: An instance of the requested object. Always returns an existing instance when one is available.
+        """
+        obj_id = hash(klass if qualifier is None else (klass, qualifier))
+
+        if compiled_factory := self._factories.get(obj_id):
+            if compiled_factory.is_async:
+                msg = (
+                    f"{klass} is an async dependency and it cannot be created in a synchronous context. "
+                    "Create and use an async container via wireup.create_async_container."
+                )
+                raise WireupError(msg)
+
+            return compiled_factory.factory(self)  # type:ignore[no-any-return]
+
+        raise UnknownServiceRequestedError(klass, qualifier)

{wireup-2.1.0 → wireup-2.2.0}/wireup/ioc/container/sync_container.py

@@ -15,7 +15,7 @@ class BareSyncContainer(BaseContainer):
     get = BaseContainer._synchronous_get
 
     def close(self) -> None:
-        clean_exit_stack(self._global_scope.exit_stack)
+        clean_exit_stack(self._global_scope_exit_stack)
 
 
 class ScopedSyncContainer(BareSyncContainer):
@@ -36,9 +36,11 @@ class SyncContainer(BareSyncContainer):
     def enter_scope(self) -> ScopedSyncContainer:
         return ScopedSyncContainer(
             registry=self._registry,
-            parameters=self._params,
             override_manager=self._override_mgr,
-            global_scope=self._global_scope,
+            global_scope_objects=self._global_scope_objects,
+            global_scope_exit_stack=self._global_scope_exit_stack,
             current_scope_objects={},
             current_scope_exit_stack=[],
+            factory_compiler=self._scoped_compiler,
+            scoped_compiler=self._scoped_compiler,
         )

wireup-2.2.0/wireup/ioc/factory_compiler.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Hashable
+
+from wireup.errors import WireupError
+from wireup.ioc.service_registry import GENERATOR_FACTORY_TYPES, FactoryType, ServiceRegistry
+from wireup.ioc.types import ParameterWrapper, TemplatedString
+
+if TYPE_CHECKING:
+    from wireup.ioc.container.base_container import BaseContainer
+    from wireup.ioc.service_registry import ServiceFactory
+
+
+@dataclass
+class CompiledFactory:
+    factory: Callable[[BaseContainer], Any]
+    is_async: bool
+
+
+_CONTAINER_SCOPE_ERROR_MSG = (
+    "Cannot create 'transient' or 'scoped' lifetime objects from the base container. "
+    "Please enter a scope using container.enter_scope. "
+    "If you are within a scope, use the scoped container instance to create dependencies."
+)
+_WIREUP_GENERATED_FACTORY_NAME = "_wireup_factory"
+
+
+class FactoryCompiler:
+    def __init__(self, registry: ServiceRegistry, *, 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) -> None:
+        for impl, qualifiers in self._registry.impls.items():
+            for qualifier in qualifiers:
+                obj_id = FactoryCompiler.get_object_id(impl, qualifier)
+
+                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)
+
+                self.factories[obj_id] = self._compile_and_create_function(
+                    self._registry.factories[impl, qualifier],
+                    interface,
+                    qualifier,
+                )
+
+    def _get_factory_code(self, factory: ServiceFactory, impl: type, qualifier: Hashable) -> tuple[str, bool]:  # noqa: C901, PLR0912
+        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]
+
+        if lifetime != "singleton" and not self._is_scoped_container:
+            code = f"def {_WIREUP_GENERATED_FACTORY_NAME}(container):\n"
+            code += "    raise WireupError(_CONTAINER_SCOPE_ERROR_MSG)\n"
+
+            return code, False
+
+        maybe_async = "async " if factory.is_async else ""
+        code = f"{maybe_async}def {_WIREUP_GENERATED_FACTORY_NAME}(container):\n"
+        cache_created_instance = lifetime != "transient"
+
+        if cache_created_instance:
+            if lifetime == "singleton":
+                code += "    storage = container._global_scope_objects\n"
+            else:
+                code += "    storage = container._current_scope_objects\n"
+
+            code += "    if res := storage.get(OBJ_ID):\n"
+            code += "        return res\n"
+
+        kwargs = ""
+        for name, dep in self._registry.dependencies[factory.factory].items():
+            if isinstance(dep.annotation, ParameterWrapper):
+                param_value = (
+                    str(dep.annotation.param)
+                    if isinstance(dep.annotation.param, TemplatedString)
+                    else f'"{dep.annotation.param}"'
+                )
+                code += f"    _obj_dep_{name} = parameters.get({param_value})\n"
+            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)
+                code += f"    _obj_dep_{name} = {maybe_await}factories[{dep_hash}].factory(container)\n"
+            kwargs += f"{name}=_obj_dep_{name}, "
+
+        maybe_await = "await " if factory.factory_type == FactoryType.COROUTINE_FN else ""
+
+        code += f"    instance = {maybe_await}ORIGINAL_FACTORY({kwargs.strip()})\n"
+
+        if factory.factory_type in GENERATOR_FACTORY_TYPES:
+            if lifetime == "singleton":
+                code += "    container._global_scope_exit_stack.append(instance)\n"
+            else:
+                code += "    container._current_scope_exit_stack.append(instance)\n"
+
+            if factory.factory_type == FactoryType.GENERATOR:
+                code += "    instance = next(instance)\n"
+            else:
+                code += "    instance = await instance.__anext__()\n"
+
+        if cache_created_instance:
+            code += "    storage[OBJ_ID] = instance\n"
+            if is_interface:
+                code += "    storage[ORIGINAL_OBJ_ID] = instance\n"
+
+        code += "    return instance\n"
+
+        return code, factory.is_async
+
+    def _compile_and_create_function(self, factory: ServiceFactory, 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
+        )
+
+        source, is_async = self._get_factory_code(factory, impl, qualifier)
+
+        try:
+            namespace: dict[str, Any] = {
+                "factories": self.factories,
+                "ORIGINAL_OBJ_ID": obj_id,
+                "OBJ_ID": resolved_obj_id,
+                "ORIGINAL_FACTORY": self._registry.ctors[obj_id][0],
+                "TemplatedString": TemplatedString,
+                "WireupError": WireupError,
+                "_CONTAINER_SCOPE_ERROR_MSG": _CONTAINER_SCOPE_ERROR_MSG,
+                "parameters": self._registry.parameters,
+            }
+
+            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

wireup-2.2.0/wireup/ioc/override_manager.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Any, Iterator
+
+from wireup.errors import UnknownOverrideRequestedError
+from wireup.ioc.factory_compiler import FactoryCompiler
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from wireup.ioc.types import AnyCallable, Qualifier, ServiceOverride
+
+
+class OverrideManager:
+    """Enables overriding of services registered with the container."""
+
+    def __init__(
+        self,
+        is_valid_override: Callable[[type, Qualifier], bool],
+        factory_compiler: FactoryCompiler,
+        scoped_factory_compiler: FactoryCompiler,
+    ) -> None:
+        self.__is_valid_override = is_valid_override
+        self._factory_compiler = factory_compiler
+        self._scoped_factory_compiler = scoped_factory_compiler
+        self._original_factory_functions: dict[tuple[type, Qualifier], tuple[Any, Any]] = {}
+
+    def _compiler_override_obj_id(
+        self,
+        compiler: FactoryCompiler,
+        target: type,
+        qualifier: Qualifier,
+        new: Callable[[Any], Any],
+    ) -> None:
+        compiler.factories[compiler.get_object_id(target, qualifier)].factory = new
+
+    def _compiler_restore_obj_id(
+        self,
+        compiler: FactoryCompiler,
+        target: type,
+        qualifier: Qualifier,
+        original: AnyCallable,
+    ) -> None:
+        compiler.factories[compiler.get_object_id(target, qualifier)].factory = original
+
+    def set(self, target: type, new: Any, qualifier: Qualifier | None = None) -> None:
+        """Override the `target` service with `new`.
+
+        Future requests to inject `target` will result in `new` being injected.
+
+        :param target: The target service to override.
+        :param qualifier: The qualifier of the service to override. Set this if service is registered
+        with the qualifier parameter set to a value.
+        :param new: The new object to be injected instead of `target`.
+        """
+        if not self.__is_valid_override(target, qualifier):
+            raise UnknownOverrideRequestedError(klass=target, qualifier=qualifier)
+
+        obj_id = FactoryCompiler.get_object_id(target, qualifier)
+
+        self._original_factory_functions[target, qualifier] = (
+            self._factory_compiler.factories[obj_id].factory,
+            self._scoped_factory_compiler.factories[obj_id].factory,
+        )
+
+        def override_factory(_container: Any) -> Any:
+            return new
+
+        self._compiler_override_obj_id(
+            target=target,
+            qualifier=qualifier,
+            compiler=self._factory_compiler,
+            new=override_factory,
+        )
+        self._compiler_override_obj_id(
+            target=target,
+            qualifier=qualifier,
+            compiler=self._scoped_factory_compiler,
+            new=override_factory,
+        )
+
+    def _restore_factory_methods(self, target: type, qualifier: Qualifier | None) -> None:
+        """Restore original factory methods after override is removed."""
+        if (target, qualifier) not in self._original_factory_functions:
+            return
+
+        factory_func, scoped_factory_func = self._original_factory_functions[target, qualifier]
+        self._compiler_restore_obj_id(
+            compiler=self._factory_compiler,
+            target=target,
+            qualifier=qualifier,
+            original=factory_func,
+        )
+        self._compiler_restore_obj_id(
+            compiler=self._scoped_factory_compiler,
+            target=target,
+            qualifier=qualifier,
+            original=scoped_factory_func,
+        )
+
+        del self._original_factory_functions[target, qualifier]
+
+    def delete(self, target: type, qualifier: Qualifier | None = None) -> None:
+        """Clear active override for the `target` service."""
+        self._restore_factory_methods(target, qualifier)
+
+    def clear(self) -> None:
+        """Clear active service overrides."""
+        for key in self._original_factory_functions:
+            self._restore_factory_methods(key[0], key[1])
+
+    @contextmanager
+    def service(self, target: type, new: Any, qualifier: Qualifier | None = None) -> Iterator[None]:
+        """Override the `target` service with `new` for the duration of the context manager.
+
+        Future requests to inject `target` will result in `new` being injected.
+
+        :param target: The target service to override.
+        :param qualifier: The qualifier of the service to override. Set this if service is registered
+        with the qualifier parameter set to a value.
+        :param new: The new object to be injected instead of `target`.
+        """
+        try:
+            self.set(target, new, qualifier)
+            yield
+        finally:
+            self.delete(target, qualifier)
+
+    @contextmanager
+    def services(self, overrides: list[ServiceOverride]) -> Iterator[None]:
+        """Override a number of services with new for the duration of the context manager."""
+        try:
+            for override in overrides:
+                self.set(override.target, override.new, override.qualifier)
+            yield
+        finally:
+            for override in overrides:
+                self.delete(override.target, override.qualifier)