wireup 2.0.1__tar.gz → 2.2.0__tar.gz

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

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: wireup
-Version: 2.0.1
+Version: 2.2.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
@@ -26,12 +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: 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
 
@@ -43,8 +46,7 @@ Description-Content-Type: text/markdown
 [![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/maldoinc/wireup/run_all.yml)](https://github.com/maldoinc/wireup)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/wireup)](https://pypi.org/project/wireup/)
 [![PyPI - Version](https://img.shields.io/pypi/v/wireup)](https://pypi.org/project/wireup/)
-
-<p><a target="_blank" href="https://maldoinc.github.io/wireup">📚 Documentation</a> | <a target="_blank" href="https://github.com/maldoinc/wireup-demo">🎮 Demo Application</a></p>
+[![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
 Dependency Injection (DI) is a design pattern where dependencies are provided externally rather than created within objects. Wireup automates dependency management using Python's type system, with support for async, generators, modern Python features and integrations for FastAPI, Django, Flask and AIOHTTP out of the box.
@@ -74,19 +76,32 @@ user_service = container.get(UserService) # ✅ Dependencies resolved.
 ```
 
 <details>
-<summary>Example With Configuration</summary>
+<summary>No annotations</summary>
+
+Keep domain objects clean of framework annotations by using factories.
 
 ```python
-@service
+# Clean domain objects: No annotations
 class Database:
-    def __init__(self, db_url: Annotated[str, Inject(param="db_url")]) -> None:
-        self.db_url = db_url
+    pass
+
+class UserService:
+    def __init__(self, db: Database) -> None:
+        self.db = db
+
+# Register services via factories
+@service
+def database_factory() -> Database:
+    return Database()
+
+@service
+def user_service_factory(db: Database) -> UserService:
+    return UserService(db)
 
 container = wireup.create_sync_container(
-    services=[Database], 
-    parameters={"db_url": os.environ["APP_DB_URL"]}
+    services=[database_factory, user_service_factory]
 )
-database = container.get(Database) # ✅ Dependencies resolved.
+user_service = container.get(UserService) # ✅ Dependencies resolved.
 ```
 
 </details>
@@ -228,7 +243,7 @@ Wireup provides its own Dependency Injection mechanism and is not tied to specif
 
 Share the service layer between your web application and its accompanying CLI using Wireup.
 
-### 🔌 Native Integration with Django, FastAPI, Flask and AIOHTTP
+### 🔌 Native Integration with Django, FastAPI, Flask, AIOHTTP, Click and Starlette
 
 Integrate with popular frameworks for a smoother developer experience.
 Integrations manage request scopes, injection in endpoints, and lifecycle of services.
@@ -244,6 +259,10 @@ def users_list(user_service: Injected[UserService]):
 wireup.integration.fastapi.setup(container, app)
 ```
 
+**Supported Frameworks:** FastAPI (with zero-overhead class-based handlers), Django, Flask, AIOHTTP, Starlette, and Click.
+
+[View all integrations →](https://maldoinc.github.io/wireup/latest/integrations/)
+
 ### 🧪 Simplified Testing
 
 Wireup does not patch your services and lets you test them in isolation.
@@ -263,7 +282,3 @@ with container.override.service(target=Database, new=in_memory_database):
 
 For more information [check out the documentation](https://maldoinc.github.io/wireup)
 
-## 🎮 Demo application
-
-A demo flask application is available at [maldoinc/wireup-demo](https://github.com/maldoinc/wireup-demo)
-

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wireup"
-version = "2.0.1"
+version = "2.2.0"
 description = "Python Dependency Injection Library"
 authors = ["Aldo Mateli <aldo.mateli@gmail.com>"]
 license = "MIT"
@@ -46,6 +46,10 @@ 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 }
+
+[tool.poetry.extras]
+eval-type = ["eval-type-backport"]
 
 [tool.poetry.group.dev.dependencies]
 ruff = "0.11.0"
@@ -131,3 +135,4 @@ exclude = "wireup.integration"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

{wireup-2.0.1 → wireup-2.2.0}/readme.md

@@ -6,8 +6,7 @@
 [![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/maldoinc/wireup/run_all.yml)](https://github.com/maldoinc/wireup)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/wireup)](https://pypi.org/project/wireup/)
 [![PyPI - Version](https://img.shields.io/pypi/v/wireup)](https://pypi.org/project/wireup/)
-
-<p><a target="_blank" href="https://maldoinc.github.io/wireup">📚 Documentation</a> | <a target="_blank" href="https://github.com/maldoinc/wireup-demo">🎮 Demo Application</a></p>
+[![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20Documentation-3D9970)](https://maldoinc.github.io/wireup)
 </div>
 
 Dependency Injection (DI) is a design pattern where dependencies are provided externally rather than created within objects. Wireup automates dependency management using Python's type system, with support for async, generators, modern Python features and integrations for FastAPI, Django, Flask and AIOHTTP out of the box.
@@ -37,19 +36,32 @@ user_service = container.get(UserService) # ✅ Dependencies resolved.
 ```
 
 <details>
-<summary>Example With Configuration</summary>
+<summary>No annotations</summary>
+
+Keep domain objects clean of framework annotations by using factories.
 
 ```python
-@service
+# Clean domain objects: No annotations
 class Database:
-    def __init__(self, db_url: Annotated[str, Inject(param="db_url")]) -> None:
-        self.db_url = db_url
+    pass
+
+class UserService:
+    def __init__(self, db: Database) -> None:
+        self.db = db
+
+# Register services via factories
+@service
+def database_factory() -> Database:
+    return Database()
+
+@service
+def user_service_factory(db: Database) -> UserService:
+    return UserService(db)
 
 container = wireup.create_sync_container(
-    services=[Database], 
-    parameters={"db_url": os.environ["APP_DB_URL"]}
+    services=[database_factory, user_service_factory]
 )
-database = container.get(Database) # ✅ Dependencies resolved.
+user_service = container.get(UserService) # ✅ Dependencies resolved.
 ```
 
 </details>
@@ -191,7 +203,7 @@ Wireup provides its own Dependency Injection mechanism and is not tied to specif
 
 Share the service layer between your web application and its accompanying CLI using Wireup.
 
-### 🔌 Native Integration with Django, FastAPI, Flask and AIOHTTP
+### 🔌 Native Integration with Django, FastAPI, Flask, AIOHTTP, Click and Starlette
 
 Integrate with popular frameworks for a smoother developer experience.
 Integrations manage request scopes, injection in endpoints, and lifecycle of services.
@@ -207,6 +219,10 @@ def users_list(user_service: Injected[UserService]):
 wireup.integration.fastapi.setup(container, app)
 ```
 
+**Supported Frameworks:** FastAPI (with zero-overhead class-based handlers), Django, Flask, AIOHTTP, Starlette, and Click.
+
+[View all integrations →](https://maldoinc.github.io/wireup/latest/integrations/)
+
 ### 🧪 Simplified Testing
 
 Wireup does not patch your services and lets you test them in isolation.
@@ -225,7 +241,3 @@ with container.override.service(target=Database, new=in_memory_database):
 ## 📚 Documentation
 
 For more information [check out the documentation](https://maldoinc.github.io/wireup)
-
-## 🎮 Demo application
-
-A demo flask application is available at [maldoinc/wireup-demo](https://github.com/maldoinc/wireup-demo)

wireup-2.2.0/wireup/_decorators.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import contextlib
+import functools
+import inspect
+from contextlib import AsyncExitStack, ExitStack
+from typing import TYPE_CHECKING, Any, Callable
+
+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.util import (
+    get_inject_annotated_parameters,
+    get_valid_injection_annotated_parameters,
+)
+
+if TYPE_CHECKING:
+    from wireup.ioc.container.sync_container import ScopedSyncContainer
+
+
+def inject_from_container_unchecked(
+    scoped_container_supplier: Callable[[], ScopedSyncContainer | ScopedAsyncContainer],
+) -> Callable[..., Any]:
+    """Inject dependencies into the decorated function. The "unchecked" part of the name refers to the fact that
+    this cannot perform validation on the parameters to inject on module import time due to the absence of a container
+    instance."""
+
+    def _decorator(target: Callable[..., Any]) -> Callable[..., Any]:
+        return inject_from_container_util(
+            target=target,
+            names_to_inject=get_inject_annotated_parameters(target),
+            container=None,
+            scoped_container_supplier=scoped_container_supplier,
+            middleware=None,
+        )
+
+    return _decorator
+
+
+def inject_from_container(
+    container: SyncContainer | AsyncContainer,
+    scoped_container_supplier: Callable[[], ScopedSyncContainer | ScopedAsyncContainer] | None = None,
+    middleware: Callable[
+        [ScopedSyncContainer | ScopedAsyncContainer, tuple[Any, ...], dict[str, Any]],
+        contextlib.AbstractContextManager[None],
+    ]
+    | None = None,
+) -> Callable[..., Any]:
+    """Inject dependencies into the decorated function based on annotations.
+
+    :param container: The main container instance created via `wireup.create_sync_container` or
+    `wireup.create_async_container`.
+    :param scoped_container_supplier: An optional callable that returns the current scoped container instance.
+    If provided, it will be used to create scoped dependencies. If not provided, the container will automatically
+    enter a scope. Provide a scoped_container_supplier if you need to manage the container's scope manually. For
+    example, in web frameworks, you might enter the scope at the start of a request in middleware so that other
+    middlewares can access the scoped container if needed.
+    :param middleware: A context manager that wraps the execution of the target function.
+    """
+
+    def _decorator(target: Callable[..., Any]) -> Callable[..., Any]:
+        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."
+            )
+            raise WireupError(msg)
+
+        return inject_from_container_util(
+            target=target,
+            names_to_inject=get_valid_injection_annotated_parameters(container, target),
+            container=container,
+            scoped_container_supplier=scoped_container_supplier,
+            middleware=middleware,
+        )
+
+    return _decorator
+
+
+def inject_from_container_util(  # noqa: C901
+    target: Callable[..., Any],
+    names_to_inject: dict[str, AnnotatedParameter],
+    container: SyncContainer | AsyncContainer | None,
+    scoped_container_supplier: Callable[[], ScopedSyncContainer | ScopedAsyncContainer] | None = None,
+    middleware: Callable[
+        [ScopedSyncContainer | ScopedAsyncContainer, tuple[Any, ...], dict[str, Any]],
+        contextlib.AbstractContextManager[None],
+    ]
+    | None = None,
+) -> Callable[..., Any]:
+    if not (container or scoped_container_supplier):
+        msg = "Container or scoped_container_supplier must be provided for injection."
+        raise WireupError(msg)
+
+    if not names_to_inject:
+        return target
+
+    if inspect.iscoroutinefunction(target):
+
+        @functools.wraps(target)
+        async def _inject_async_target(*args: Any, **kwargs: Any) -> Any:
+            async with AsyncExitStack() as cm:
+                if scoped_container_supplier:
+                    scoped_container = scoped_container_supplier()
+                elif container:
+                    scoped_container = await cm.enter_async_context(container.enter_scope())  # type: ignore[reportArgumentType, arg-type, unused-ignore]
+                else:
+                    msg = "scoped_container_supplier or container must be provided for injection."
+                    raise ValueError(msg)
+
+                if middleware:
+                    cm.enter_context(middleware(scoped_container, args, kwargs))
+
+                injected_names = {
+                    name: scoped_container.params.get(param.annotation.param)
+                    if isinstance(param.annotation, ParameterWrapper)
+                    else await scoped_container.get(param.klass, qualifier=param.qualifier_value)
+                    for name, param in names_to_inject.items()
+                    if param.annotation
+                }
+
+                return await target(*args, **{**kwargs, **injected_names})
+
+        return _inject_async_target
+
+    @functools.wraps(target)
+    def _inject_target(*args: Any, **kwargs: Any) -> Any:
+        with ExitStack() as cm:
+            if scoped_container_supplier:
+                scoped_container = scoped_container_supplier()
+            elif container:
+                scoped_container = cm.enter_context(
+                    container.enter_scope()
+                    if isinstance(container, SyncContainer)
+                    else async_container_force_sync_scope(container)
+                )
+            else:
+                msg = "scoped_container_supplier or container must be provided for injection."
+                raise ValueError(msg)
+
+            if middleware:
+                cm.enter_context(middleware(scoped_container, args, kwargs))
+
+            get = scoped_container._synchronous_get
+
+            injected_names = {
+                name: scoped_container.params.get(param.annotation.param)
+                if isinstance(param.annotation, ParameterWrapper)
+                else get(param.klass, qualifier=param.qualifier_value)
+                for name, param in names_to_inject.items()
+                if param.annotation
+            }
+            return target(*args, **{**kwargs, **injected_names})
+
+    return _inject_target

{wireup-2.0.1 → wireup-2.2.0}/wireup/errors.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -90,9 +91,20 @@ class UnknownOverrideRequestedError(WireupError):
         super().__init__(f"Cannot override unknown {klass} with qualifier '{qualifier}'.")
 
 
-class ContainerCloseError(WireupError):
-    """Contains a list of exceptions raised while closing the container."""
+if sys.version_info >= (3, 11):
 
-    def __init__(self, errors: list[Exception]) -> None:
-        self.errors = errors
-        super().__init__(f"The following exceptions were raised while closing the container: {errors}")
+    class ContainerCloseError(ExceptionGroup, WireupError):  # noqa: F821
+        """Contains a list of exceptions raised while closing the container."""
+
+        def __init__(self, message: str, errors: list[Exception]) -> None:
+            self.errors = errors
+            super().__init__(message, errors)
+
+else:
+
+    class ContainerCloseError(WireupError):
+        """Contains a list of exceptions raised while closing the container."""
+
+        def __init__(self, message: str, errors: list[Exception]) -> None:
+            self.errors = errors
+            super().__init__(f"{message}: {errors}")

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

@@ -73,10 +73,13 @@ async def _instantiate_class_based_handlers(
 
 
 def _get_startup_event(
-    container: wireup.AsyncContainer, handlers: Optional[Iterable[Type[_WireupHandler]]]
+    container: wireup.AsyncContainer,
+    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:
@@ -88,7 +91,9 @@ def _get_startup_event(
 
 
 def setup(
-    container: wireup.AsyncContainer, app: web.Application, handlers: Optional[Iterable[Type[_WireupHandler]]] = None
+    container: wireup.AsyncContainer,
+    app: web.Application,
+    handlers: Optional[Iterable[Type[_WireupHandler]]] = None,
 ) -> None:
     """Integrate Wireup with AIOHTTP.
 

wireup-2.2.0/wireup/integration/click.py

@@ -0,0 +1,26 @@
+from click import Group
+
+from wireup import SyncContainer, inject_from_container
+
+
+def _inject_commands(container: SyncContainer, group: Group) -> None:
+    for command in group.commands.values():
+        if fn := command.callback:
+            command.callback = inject_from_container(container)(fn)
+
+        if isinstance(command, Group):
+            _inject_commands(container, command)
+
+
+def setup(container: SyncContainer, command: Group) -> None:
+    """Integrate Wireup with Click by injecting dependencies into Click commands.
+
+    :command: The Click command group to inject dependencies into
+    """
+    _inject_commands(container, command)
+    command.wireup_container = container  # type: ignore[reportAttributeAccessIssue]
+
+
+def get_app_container(app: Group) -> SyncContainer:
+    """Retrieve the Wireup container associated with a Click command group."""
+    return app.wireup_container  # type: ignore[reportAttributeAccessIssue]

{wireup-2.0.1 → 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:
@@ -65,7 +65,7 @@ def wireup_middleware(
     return sync_inner
 
 
-@service
+@service(lifetime="scoped")
 def _django_request_factory() -> HttpRequest:
     try:
         return current_request.get()

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

@@ -1,9 +1,7 @@
 import contextlib
-from contextvars import ContextVar
 from typing import (
     Any,
     AsyncIterator,
-    Awaitable,
     Callable,
     Dict,
     Iterable,
@@ -16,26 +14,38 @@ from typing import (
 )
 
 import fastapi
-from fastapi import FastAPI, Request, Response, WebSocket
-from fastapi.requests import HTTPConnection
+from fastapi import FastAPI
 from fastapi.routing import APIRoute, APIWebSocketRoute
-from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.routing import BaseRoute
 from typing_extensions import Protocol
 
-from wireup import inject_from_container, service
+from wireup import inject_from_container
 from wireup._annotations import ServiceDeclaration
 from wireup.errors import WireupError
+from wireup.integration.starlette import (
+    WireupAsgiMiddleware,
+    current_request,
+    get_app_container,
+    get_request_container,
+    request_factory,
+    websocket_factory,
+)
 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,
 )
 
-current_request: ContextVar[HTTPConnection] = ContextVar("wireup_fastapi_request")
+__all__ = [
+    "WireupRoute",
+    "get_app_container",
+    "get_request_container",
+    "request_factory",
+    "setup",
+    "websocket_factory",
+]
 
 
 class _ClassBasedHandlersProtocol(Protocol):
@@ -48,50 +58,6 @@ class WireupRoute(APIRoute):
         super().__init__(path=path, endpoint=endpoint, **kwargs)
 
 
-@service(lifetime="scoped")
-def fastapi_request_factory() -> Request:
-    """Provide the current FastAPI request as a dependency.
-
-    Note that this requires the Wireup-FastAPI integration to be set up.
-    """
-    msg = "fastapi.Request in Wireup is only available during a request."
-    try:
-        res = current_request.get()
-        if not isinstance(res, Request):
-            raise WireupError(msg)
-
-        return res
-    except LookupError as e:
-        raise WireupError(msg) from e
-
-
-@service(lifetime="scoped")
-def fastapi_websocket_factory() -> WebSocket:
-    """Provide the current FastAPI WebSocket as a dependency.
-
-    Note that this requires the Wireup-FastAPI integration to be set up.
-    """
-    msg = "fastapi.WebSocket in Wireup is only available in a websocket connection."
-    try:
-        res = current_request.get()
-        if not isinstance(res, WebSocket):
-            raise WireupError(msg)
-
-        return res
-    except LookupError as e:
-        raise WireupError(msg) from e
-
-
-async def _wireup_request_middleware(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
-    token = current_request.set(request)
-    try:
-        async with request.app.state.wireup_container.enter_scope() as scoped_container:
-            request.state.wireup_container = scoped_container
-            return await call_next(request)
-    finally:
-        current_request.reset(token)
-
-
 def _inject_fastapi_route(
     *,
     container: AsyncContainer,
@@ -100,14 +66,13 @@ def _inject_fastapi_route(
     remove_http_connection_from_arguments: bool,
     add_custom_middleware: bool,
 ) -> AnyCallable:
-    # Warn: Make sure the logic evolves with the _wireup_request_middleware function.
     @contextlib.contextmanager
     def _request_middleware(
         scoped_container: Union[ScopedAsyncContainer, ScopedSyncContainer],
         _args: Tuple[Any, ...],
         kwargs: Dict[str, Any],
     ) -> Iterator[None]:
-        request: HTTPConnection = kwargs[http_connection_param_name]
+        request = kwargs[http_connection_param_name]
         request.state.wireup_container = scoped_container
         token = current_request.set(request)
         try:
@@ -135,8 +100,7 @@ def _inject_routes(container: AsyncContainer, routes: List[BaseRoute], *, is_usi
             route.dependant.call = inject_from_container(container, get_request_container)(route.dependant.call)
             continue
 
-        # This is now either a websocket route
-        # or an APIRoute but the asgi middleware is not used.
+        # This is now either a websocket route or an APIRoute but the asgi middleware is not used.
         # In this case we need to use the custom route middleware to extract the current request/websocket.
         add_custom_middleware = isinstance(route, APIWebSocketRoute) or not is_using_asgi_middleware
         is_http_connection_in_signature = route.dependant.http_connection_param_name is not None
@@ -201,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)
@@ -242,7 +207,7 @@ def setup(
     """
     app.state.wireup_container = container
     if middleware_mode:
-        app.add_middleware(BaseHTTPMiddleware, dispatch=_wireup_request_middleware)
+        app.add_middleware(WireupAsgiMiddleware)
     _update_lifespan(
         app,
         class_based_routes=class_based_handlers,
@@ -253,13 +218,3 @@ def setup(
     # If no class-based handlers are used, we inject them immediately.
     if not class_based_handlers:
         _inject_routes(container, app.routes, is_using_asgi_middleware=middleware_mode)
-
-
-def get_app_container(app: FastAPI) -> AsyncContainer:
-    """Return the container associated with the given FastAPI application."""
-    return app.state.wireup_container
-
-
-def get_request_container() -> ScopedAsyncContainer:
-    """When inside a request, returns the scoped container instance handling the current request."""
-    return current_request.get().state.wireup_container