fix: make distributabe

Author: emptybutton

deploy/dev/backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim AS app
+FROM ghcr.io/astral-sh/uv:0.7.13-python3.13-bookworm-slim AS app
 
 WORKDIR /app
 

src/app_name_snake_case/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+
+
+__version__ = version("app_name_kebab_case")

src/app_name_snake_case/main/fastapi/di.py

@@ -1,23 +1,27 @@
 from dishka import Provider, Scope, make_async_container, provide
 
+from app_name_snake_case import __version__
 from app_name_snake_case.main.common.di import CommonProvider
 from app_name_snake_case.presentation.fastapi.app import (
     FastAPIAppCoroutines,
     FastAPIAppRouters,
+    FastAPIAppVersion,
 )
 from app_name_snake_case.presentation.fastapi.routers import all_routers
 
 
 class FastAPIProvider(Provider):
-    scope = Scope.APP
-
-    @provide
+    @provide(scope=Scope.APP)
     def provide_routers(self) -> FastAPIAppRouters:
-        return all_routers
+        return FastAPIAppRouters(all_routers)
 
-    @provide
+    @provide(scope=Scope.APP)
     def provide_coroutines(self) -> FastAPIAppCoroutines:
-        return []
+        return FastAPIAppCoroutines(tuple())
+
+    @provide(scope=Scope.APP)
+    def provide_version(self) -> FastAPIAppVersion:
+        return FastAPIAppVersion(__version__)
 
 
 container = make_async_container(FastAPIProvider(), CommonProvider())

src/app_name_snake_case/presentation/fastapi/app.py

@@ -1,7 +1,9 @@
 import asyncio
-from collections.abc import AsyncIterator, Coroutine, Iterable
-from contextlib import asynccontextmanager, suppress
-from typing import Any, cast
+from collections.abc import AsyncIterator, Callable, Coroutine
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Any, NewType, Self, cast
 
 from dishka import AsyncContainer
 from dishka.integrations.fastapi import setup_dishka
@@ -12,21 +14,70 @@
 from app_name_snake_case.presentation.fastapi.tags import tags_metadata
 
 
-type FastAPIAppCoroutines = Iterable[Coroutine[Any, Any, Any]]
-type FastAPIAppRouters = Iterable[APIRouter]
+FastAPIAppCoroutines = NewType(
+    "FastAPIAppCoroutines",
+    tuple[Callable[[], Coroutine[Any, Any, Any]], ...],
+)
+FastAPIAppRouters = NewType("FastAPIAppRouters", tuple[APIRouter, ...])
+FastAPIAppVersion = NewType("FastAPIAppVersion", str)
+
+
+@dataclass(frozen=True, unsafe_hash=False)
+class AppBackgroundTasks:
+    _loop: asyncio.AbstractEventLoop = field(
+        default_factory=asyncio.get_running_loop,
+    )
+    _tasks: set[asyncio.Task[Any]] = field(init=False, default_factory=set)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        error_type: type[BaseException] | None,
+        error: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        for task in self._tasks:
+            task.cancel()
+
+        await asyncio.gather(*self._tasks, return_exceptions=True)
+
+    def create_task(
+        self,
+        func: Callable[[], Coroutine[Any, Any, Any]],
+    ) -> None:
+        decorated_func = self._decorator(func)
+        self._create_task(decorated_func())
+
+    def _decorator(
+        self,
+        func: Callable[[], Coroutine[Any, Any, Any]],
+    ) -> Callable[[], Coroutine[Any, Any, Any]]:
+        async def decorated_func() -> None:
+            try:
+                await func()
+            except Exception as error:
+                self._create_task(decorated_func())
+                raise error from error
+
+        return decorated_func
+
+    def _create_task(self, coro: Coroutine[Any, Any, Any]) -> None:
+        task = self._loop.create_task(coro)
+
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-    with suppress(asyncio.CancelledError):
-        async with asyncio.TaskGroup() as tasks:
-            for coroutine in cast("FastAPIAppCoroutines", app.state.coroutines):
-                tasks.create_task(coroutine)
-
-            yield
+    async with AppBackgroundTasks() as tasks:
+        for coroutine in cast("FastAPIAppCoroutines", app.state.coroutines):
+            tasks.create_task(coroutine)
 
-            await app.state.dishka_container.close()
-            raise asyncio.CancelledError
+        yield
+        await app.state.dishka_container.close()
 
 
 class _FastAPIWithAdditionalModels(FastAPI):
@@ -48,8 +99,8 @@ def openapi(self) -> dict[str, Any]:
 
 async def app_from(container: AsyncContainer) -> FastAPI:
     author_url = "https://github.com/emptybutton"
-    repo_url = f"{author_url}/app_name_snake_case"
-    version = "0.1.0"
+    repo_url = f"{author_url}/app_name_kebab_case"
+    version: FastAPIAppVersion = await container.get(FastAPIAppVersion)
 
     app = _FastAPIWithAdditionalModels(
         title="app-name-kebab-case",
@@ -65,12 +116,9 @@ async def app_from(container: AsyncContainer) -> FastAPI:
         root_path=f"/api/{version}",
     )
 
-    coroutines = await container.get(FastAPIAppCoroutines)
-    routers = await container.get(FastAPIAppRouters)
-
-    app.state.coroutines = coroutines
+    app.state.coroutines = await container.get(FastAPIAppCoroutines)
 
-    for router in routers:
+    for router in await container.get(FastAPIAppRouters):
         app.include_router(router)
 
     setup_dishka(container=container, app=app)

src/app_name_snake_case/py.typed

@@ -9,6 +9,7 @@
 from app_name_snake_case.presentation.fastapi.app import (
     FastAPIAppCoroutines,
     FastAPIAppRouters,
+    FastAPIAppVersion,
     app_from,
 )
 
@@ -30,8 +31,15 @@ async def endpoint(x: FromDishka[X]) -> Response:
 async def test_app_from() -> None:
     provider = Provider(scope=Scope.APP)
     provider.provide(lambda: X(x=4), provides=X)
-    provider.provide(lambda: [router], provides=FastAPIAppRouters)
-    provider.provide(list, provides=FastAPIAppCoroutines)
+    provider.provide(
+        lambda: FastAPIAppRouters((router, )), provides=FastAPIAppRouters,
+    )
+    provider.provide(
+        lambda: FastAPIAppCoroutines(tuple()), provides=FastAPIAppCoroutines,
+    )
+    provider.provide(
+        lambda: FastAPIAppVersion("0.0.0"), provides=FastAPIAppVersion,
+    )
     container = make_async_container(provider)
 
     app = await app_from(container)