mvcx 0.1.0__py3-none-any.whl

mvcx/application.py

@@ -0,0 +1,337 @@
+import pathlib
+from asyncio import AbstractEventLoop
+from typing import Literal, Self, cast
+
+from granian import Granian
+from granian.constants import Interfaces
+from granian.log import LogLevels
+
+from mvcx.asgi import (
+    AsgiBodyFactory,
+    AsgiHttpReceive,
+    AsgiHttpSend,
+    AsgiLifespanReceive,
+    AsgiLifespanSend,
+    AsgiReceive,
+    AsgiScope,
+    AsgiSend,
+    AsgiWsAdapter,
+    AsgiWsReceive,
+    AsgiWsSend,
+    close_ws_asgi,
+    create_http_context_asgi,
+    send_http_exc_asgi,
+    send_response_asgi,
+)
+from mvcx.controller import ControllerFactory
+from mvcx.di import Container, DefaultContainer, Invokable, Lifetime, Resolvable
+from mvcx.http import (
+    HttpContext,
+    HttpHandler,
+    HttpHandlerFactory,
+    HttpResult,
+    Request,
+)
+from mvcx.middleware import (
+    HttpMiddlewareFactory,
+    MiddlewareFactory,
+    WsMiddlewareFactory,
+)
+from mvcx.routing import DefaultRouter, RouteMethod, Router
+from mvcx.rsgi import (
+    RsgiHttpProto,
+    RsgiProto,
+    RsgiScope,
+    RsgiWsAdapter,
+    RsgiWsProto,
+    close_ws_rsgi,
+    send_http_exc_rsgi,
+    send_response_rsgi,
+)
+from mvcx.url import Path
+from mvcx.view import View
+from mvcx.websocket import WebSocket, WsHandler, WsHandlerFactory, WsResult
+
+
+async def _default_http_handler(request: Request) -> HttpResult:
+    return await request.handler(request)
+
+
+async def _default_ws_handler(ws: WebSocket) -> WsResult:
+    return await ws.handler(ws)
+
+
+class Application:
+    def __init__(
+        self,
+        *,
+        container: Container | None = None,
+        router: Router | None = None,
+    ) -> None:
+        self._container: Container = container or DefaultContainer()
+        self._router: Router = router or DefaultRouter()
+
+        self._http_handler: HttpHandler = _default_http_handler
+        self._ws_handler: WsHandler = _default_ws_handler
+
+        if pathlib.Path("./views").is_dir():
+            self.add_dependency(View)
+
+    def add_route(
+        self, path: str, method: RouteMethod, handler: HttpHandlerFactory
+    ) -> Self:
+        self._router.add_route(Path(path), method, handler)
+        return self
+
+    def add_controller(self, path: str, controller: ControllerFactory) -> Self:
+        async def http_handler(request: Request) -> HttpResult:
+            return await self._container.invoke(
+                controller, request.scoped_cache
+            ).handle_http(request)
+
+        async def ws_handler(ws: WebSocket) -> WsResult:
+            return await self._container.invoke(controller, ws.scoped_cache).handle_ws(
+                ws
+            )
+
+        self._router.add_route(Path(path), "*", lambda: http_handler)
+        self._router.add_ws_route(Path(path), lambda: ws_handler)
+        return self
+
+    def add_fallback_route(self, status: int, handler: HttpHandlerFactory) -> Self:
+        self._router.add_fallback_route(status, handler)
+        return self
+
+    def add_ws_route(self, path: str, handler: WsHandlerFactory) -> Self:
+        self._router.add_ws_route(Path(path), handler)
+        return self
+
+    def add_dependency[T](
+        self,
+        resolvable: Resolvable[T],
+        invokable: Invokable[T] | None = None,
+        lifetime: Lifetime | None = None,
+    ) -> Self:
+        self._container.register(
+            resolvable, invokable or resolvable, lifetime or "singleton"
+        )
+        return self
+
+    def overwrite_dependency[T](
+        self, resolvable: Resolvable[T], invokable: Invokable[T]
+    ) -> Self:
+        self._container.overwrite(resolvable, invokable)
+        return self
+
+    def add_middleware(self, middleware_factory: MiddlewareFactory) -> Self:
+        async def http_handler(
+            request: Request, call_next: HttpHandler = self._http_handler
+        ) -> HttpResult:
+            return await self._container.invoke(
+                middleware_factory, request.scoped_cache
+            ).handle_http(request, call_next)
+
+        async def ws_handler(
+            ws: WebSocket, call_next: WsHandler = self._ws_handler
+        ) -> WsResult:
+            return await self._container.invoke(
+                middleware_factory, ws.scoped_cache
+            ).handle_ws(ws, call_next)
+
+        self._http_handler = http_handler
+        self._ws_handler = ws_handler
+        return self
+
+    def add_http_middleware(self, middleware_factory: HttpMiddlewareFactory) -> Self:
+        async def handler(
+            request: Request, call_next: HttpHandler = self._http_handler
+        ) -> HttpResult:
+            return await self._container.invoke(
+                middleware_factory, request.scoped_cache
+            )(request, call_next)
+
+        self._http_handler = handler
+        return self
+
+    def add_ws_middleware(self, middleware_factory: WsMiddlewareFactory) -> Self:
+        async def handler(
+            ws: WebSocket, call_next: WsHandler = self._ws_handler
+        ) -> WsResult:
+            return await self._container.invoke(middleware_factory, ws.scoped_cache)(
+                ws, call_next
+            )
+
+        self._ws_handler = handler
+        return self
+
+    def run(
+        self,
+        app: str,
+        port: int,
+        *,
+        host: str = "0.0.0.0",
+        reload: bool = False,
+        static_url: str = "/static",
+        static_root: str = "static",
+        access_log: bool = True,
+        interface: Literal["asgi", "rsgi"] = "rsgi",
+    ) -> None:
+        static_root_path = pathlib.Path(static_root)
+
+        Granian(
+            app,
+            port=port,
+            address=host,
+            reload=reload,
+            static_path_route=[static_url] if static_root_path.is_dir() else None,
+            static_path_mount=[static_root_path] if static_root_path.is_dir() else None,
+            log_access=access_log,
+            interface=Interfaces.ASGI if interface == "asgi" else Interfaces.RSGI,
+            log_level=LogLevels.info if reload else LogLevels.warning,
+        ).serve()
+
+    async def __call__(
+        self, scope: AsgiScope, receive: AsgiReceive, send: AsgiSend
+    ) -> None:
+        if scope["type"] == "lifespan":
+            receive = cast(AsgiLifespanReceive, receive)
+            send = cast(AsgiLifespanSend, send)
+            event = await receive()
+            match event["type"]:
+                case "lifespan.startup":
+                    return await send({"type": "lifespan.startup.complete"})
+                case "lifespan.shutdown":
+                    try:
+                        await self._container.clear()
+                        await send({"type": "lifespan.shutdown.complete"})
+                    except Exception as e:
+                        await send(
+                            {"type": "lifespan.shutdown.failed", "message": str(e)}
+                        )
+                        raise e
+            return
+
+        context = create_http_context_asgi(scope, self._container)
+        try:
+            match scope["type"]:
+                case "http":
+                    receive = cast(AsgiHttpReceive, receive)
+                    send = cast(AsgiHttpSend, send)
+                    body_factory = AsgiBodyFactory(receive)
+                    request = Request(context, body_factory)
+                    route = self._router.get_route(request.path, request.method)
+                    if route.error is not None:
+                        fallback = self._router.get_fallback_route(route.error)
+                        if fallback.error is not None:
+                            return await send_http_exc_asgi(send, fallback.error)
+                        response = await self._container.invoke(
+                            fallback.value, request.scoped_cache
+                        )(request)
+                        if response.error is not None:
+                            return await send_http_exc_asgi(send, response.error)
+                        return await send_response_asgi(send, response.value)
+                    request.params = route.value.params
+                    request.handler = self._container.invoke(
+                        route.value.handler, request.scoped_cache
+                    )
+                    response = await self._http_handler(request)
+                    if response.error is not None:
+                        fallback = self._router.get_fallback_route(response.error)
+                        if fallback.error is not None:
+                            return await send_http_exc_asgi(send, fallback.error)
+                        handler = self._container.invoke(
+                            fallback.value, request.scoped_cache
+                        )
+                        response = await handler(request)
+                        if response.error is not None:
+                            return await send_http_exc_asgi(send, response.error)
+                        return await send_response_asgi(send, response.value)
+                    await send_response_asgi(send, response.value)
+
+                case "websocket":
+                    receive = cast(AsgiWsReceive, receive)
+                    send = cast(AsgiWsSend, send)
+                    adapter = AsgiWsAdapter(receive, send)
+                    ws = WebSocket(context, adapter)
+                    route = self._router.get_ws_route(ws.path)
+                    if route.error is not None:
+                        return await close_ws_asgi(send, route.error)
+                    handler = self._container.invoke(
+                        route.value.handler, ws.scoped_cache
+                    )
+                    ws.handler = handler
+                    ws.params = route.value.params
+                    response = await self._ws_handler(ws)
+                    if response.error is not None:
+                        await close_ws_asgi(send, response.error)
+
+        finally:
+            await context.scoped_cache.clear()
+
+    def __rsgi_del__(self, loop: AbstractEventLoop) -> None:
+        loop.run_until_complete(self._container.clear())
+
+    async def __rsgi__(self, scope: RsgiScope, proto: RsgiProto) -> None:
+        context = HttpContext(
+            Path(scope.path),
+            scope.method,
+            lambda: scope.headers,
+            scope.query_string,
+            {},
+            self._container,
+        )
+
+        try:
+            match scope.proto:
+                case "http":
+                    proto = cast(RsgiHttpProto, proto)
+                    request = Request(context, proto)
+                    route = self._router.get_route(request.path, request.method)
+                    if route.error is not None:
+                        fallback = self._router.get_fallback_route(route.error)
+                        if fallback.error is not None:
+                            return send_http_exc_rsgi(proto, fallback.error)
+                        handler = self._container.invoke(
+                            fallback.value, request.scoped_cache
+                        )
+                        response = await handler(request)
+                        if response.error is not None:
+                            return send_http_exc_rsgi(proto, response.error)
+                        return await send_response_rsgi(proto, response.value)
+                    handler = self._container.invoke(
+                        route.value.handler, request.scoped_cache
+                    )
+                    request.handler = handler
+                    request.params = route.value.params
+                    response = await self._http_handler(request)
+                    if response.error is not None:
+                        fallback = self._router.get_fallback_route(response.error)
+                        if fallback.error is not None:
+                            return send_http_exc_rsgi(proto, fallback.error)
+                        handler = self._container.invoke(
+                            fallback.value, request.scoped_cache
+                        )
+                        response = await handler(request)
+                        if response.error is not None:
+                            return send_http_exc_rsgi(proto, response.error)
+                        return await send_response_rsgi(proto, response.value)
+                    return await send_response_rsgi(proto, response.value)
+
+                case "ws":
+                    proto = cast(RsgiWsProto, proto)
+                    adapter = RsgiWsAdapter(proto)
+                    ws = WebSocket(context, adapter)
+                    route = self._router.get_ws_route(ws.path)
+                    if route.error is not None:
+                        return close_ws_rsgi(proto, route.error)
+                    handler = self._container.invoke(
+                        route.value.handler, ws.scoped_cache
+                    )
+                    ws.handler = handler
+                    ws.params = route.value.params
+                    response = await self._ws_handler(ws)
+                    if response.error is not None:
+                        close_ws_rsgi(proto, response.error)
+
+        finally:
+            await context.scoped_cache.clear()