fast-clean 0.4.0__py3-none-any.whl

fast_clean/__init__.py

@@ -0,0 +1,3 @@
+"""
+FastAPI clean architecture implementation.
+"""

fast_clean/broker.py

@@ -0,0 +1,123 @@
+"""
+Модуль, содержащий функционал, связанный с брокером сообщений.
+"""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from functools import partial
+from typing import Callable, Self
+
+from faststream import ExceptionMiddleware
+from faststream.kafka import KafkaBroker
+from faststream.kafka.fastapi import KafkaRouter
+from faststream.security import BaseSecurity, SASLPlaintext
+
+from fast_clean.settings import CoreKafkaSettingsSchema
+from fast_clean.utils import CertificateSchema, make_ssl_context
+
+
+class BrokerFactory:
+    """
+    Фабрика брокеров сообщений.
+    """
+
+    router: KafkaRouter | None = None
+
+    @classmethod
+    def get_router(cls, kafka_settings: CoreKafkaSettingsSchema) -> KafkaRouter:
+        if cls.router is None:
+            cls.router = cls.make_router(kafka_settings)
+        return cls.router
+
+    @classmethod
+    def make_static(cls, kafka_settings: CoreKafkaSettingsSchema) -> KafkaBroker:
+        """
+        Создаем брокер сообщений с помощью статического роутера.
+        """
+        return cls.get_router(kafka_settings).broker
+
+    @classmethod
+    @asynccontextmanager
+    async def make_dynamic(cls, kafka_settings: CoreKafkaSettingsSchema) -> AsyncIterator[KafkaBroker]:
+        """
+        Создаем брокер сообщений с помощью динамического роутера.
+        """
+        async with cls.make_router(kafka_settings).broker as broker:
+            yield broker
+
+    @classmethod
+    def make_router(cls, kafka_settings: CoreKafkaSettingsSchema) -> KafkaRouter:
+        """
+        Создаем роутер.
+        """
+        credentials = BrokerCredentials(kafka_settings)
+        return KafkaRouter(
+            kafka_settings.bootstrap_servers,
+            security=credentials.get(),
+            asyncapi_url='/asyncapi',
+            middlewares=[cls.make_exception_middleware()],
+        )
+
+    @classmethod
+    def make_exception_middleware(cls) -> ExceptionMiddleware:
+        """
+        Создаем middleware для обработки исключений.
+        """
+        exception_middleware = ExceptionMiddleware()
+        exception_middleware.add_handler(Exception)(cls.exception_handler)
+        return exception_middleware
+
+    @staticmethod
+    def exception_handler(exception: Exception) -> None:
+        """
+        Обработчик исключения.
+        """
+        print(repr(exception))
+
+
+class BrokerCredentials:
+    """
+    Класс получения параметров для подключения к Kafka.
+    """
+
+    def __init__(self, kafka_settings: CoreKafkaSettingsSchema) -> None:
+        self.kafka_settings = kafka_settings
+
+    def get(self: Self, use_ssl: bool = True) -> BaseSecurity | SASLPlaintext | None:
+        """
+        Получаем параметры для подключения.
+        """
+        if self.kafka_settings.credentials is None:
+            return self.get_none_credentials()
+
+        credentials_mapping: dict[str, Callable[[], BaseSecurity | SASLPlaintext | None]] = {
+            'SSL': partial(self.get_ssl_credentials, use_ssl),
+            'SASL': partial(self.get_sasl_credentials, use_ssl),
+        }
+        return credentials_mapping.get(self.kafka_settings.credentials, self.get_none_credentials)()
+
+    @staticmethod
+    def get_none_credentials() -> None:
+        """
+        Получаем отсутствующие параметры для подключения.
+        """
+        return None
+
+    def get_ssl_credentials(self: Self, use_ssl: bool = True) -> BaseSecurity:
+        """
+        Получаем SSL параметры для подключения.
+        """
+        ssl_context = make_ssl_context(CertificateSchema.model_validate(self.kafka_settings.model_dump()))
+        return BaseSecurity(ssl_context, use_ssl)
+
+    def get_sasl_credentials(self: Self, use_ssl: bool = True) -> SASLPlaintext:
+        """
+        Получаем SASL параметры для подключения.
+        """
+        assert self.kafka_settings.broker_username
+        assert self.kafka_settings.broker_password
+        return SASLPlaintext(
+            username=self.kafka_settings.broker_username,
+            password=self.kafka_settings.broker_password,
+            use_ssl=use_ssl,
+        )

fast_clean/container.py

@@ -0,0 +1,235 @@
+"""
+Модуль, содержащий контейнер зависимостей.
+"""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+import sys
+from collections.abc import Callable
+from contextlib import AsyncExitStack
+from pathlib import Path
+from types import TracebackType
+from typing import (
+    Annotated,
+    Any,
+    Protocol,
+    Self,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from fastapi.dependencies.utils import (
+    is_async_gen_callable,
+    is_coroutine_callable,
+    is_gen_callable,
+    solve_generator,
+)
+from fastapi.params import Depends
+from starlette.concurrency import run_in_threadpool
+from stringcase import pascalcase
+
+from .exceptions import ContainerError
+
+
+class ContainerProtocol(Protocol):
+    """
+    Протокол контейнера зависимостей.
+    """
+
+    def __call__(self: Self, extra: dict[tuple[str, Any], Any] | None = None) -> ContainerProtocol:
+        """
+        Получаем новый контейнер.
+        """
+        ...
+
+    async def __aenter__(self: Self) -> ContainerProtocol:
+        """
+        Открываем асинхронный контекстный менеджер для управления стеком контекстных менеджеров.
+        """
+        ...
+
+    async def __aexit__(
+        self: Self,
+        exc_type: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> None:
+        """
+        Закрываем асинхронный контекстный менеджер для управления стеком контекстных менеджеров.
+        """
+        ...
+
+    async def get_by_type(self: Self, dependency_type: Any, *, extra: dict[tuple[str, Any], Any] | None = None) -> Any:
+        """
+        Получаем зависимость по типу.
+        """
+        ...
+
+    async def get_by_name(self: Self, name: str, *, extra: dict[tuple[str, Any], Any] | None = None) -> Any:
+        """
+        Получаем зависимость по имени.
+        """
+        ...
+
+
+class ContainerImpl:
+    """
+    Реализация контейнера зависимостей.
+    """
+
+    DEPENDS_MODULE = 'depends'
+
+    dependencies_name_mapping: dict[str, Annotated[Any, Depends]] | None = None
+    dependencies_type_mapping: dict[type, Annotated[Any, Depends]] | None = None
+
+    def __init__(self, extra: dict[tuple[str, Any], Any] | None = None) -> None:
+        self.extra = extra
+        self.instances: dict[type, Any] = {}
+        self.async_exit_stack: AsyncExitStack | None = None
+
+    def __call__(self: Self, extra: dict[tuple[str, Any], Any] | None = None) -> ContainerProtocol:
+        """
+        Получаем новый контейнер.
+        """
+        return ContainerImpl(extra)
+
+    async def __aenter__(self: Self) -> ContainerProtocol:
+        """
+        Открываем асинхронный контекстный менеджер для управления стеком контекстных менеджеров.
+        """
+        self.async_exit_stack = AsyncExitStack()
+        return self
+
+    async def __aexit__(
+        self: Self,
+        exc_type: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> None:
+        """
+        Закрываем асинхронный контекстный менеджер для управления стеком контекстных менеджеров.
+        """
+        assert self.async_exit_stack is not None
+        await self.async_exit_stack.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def get_by_type(self: Self, dependency_type: Any, *, extra: dict[tuple[str, Any], Any] | None = None) -> Any:
+        """
+        Получаем зависимость по типу.
+        """
+        extra = extra or self.extra or {}
+        assert self.dependencies_type_mapping is not None
+        if dependency_type not in self.dependencies_type_mapping:
+            raise ContainerError(f'Dependency {dependency_type} not found')
+        return await self.resolve_dependency(self.dependencies_type_mapping[dependency_type], extra)
+
+    async def get_by_name(self: Self, name: str, *, extra: dict[tuple[str, Any], Any] | None = None) -> Any:
+        """
+        Получаем зависимость по имени.
+        """
+        extra = extra or self.extra or {}
+        assert self.dependencies_name_mapping is not None
+        name = pascalcase(name)
+        if name not in self.dependencies_name_mapping:
+            raise ContainerError(f'Dependency {name} not found')
+        return await self.resolve_dependency(self.dependencies_name_mapping[name], extra)
+
+    async def resolve_dependency(self: Self, annotated_type: type, extra: dict[tuple[str, Any], Any]) -> Any:
+        """
+        Разрешаем зависимость.
+        """
+        dependency_type: type
+        depends: Depends
+        dependency_type, depends = get_args(annotated_type)
+        if dependency_type in self.instances:
+            return self.instances[dependency_type]
+        call = depends.dependency
+        assert call is not None
+        resolved_params = await self.resolve_params(call, extra)
+        if is_gen_callable(call) or is_async_gen_callable(call):
+            if self.async_exit_stack is None:
+                raise ContainerError('Generator requires `async_exit_stack`')
+            resolved = await solve_generator(call=call, stack=self.async_exit_stack, sub_values=resolved_params)
+        elif is_coroutine_callable(call):
+            resolved = await call(**resolved_params)
+        else:
+            resolved = await run_in_threadpool(call, **resolved_params)
+        if depends.use_cache:
+            self.instances[dependency_type] = resolved
+        return resolved
+
+    async def resolve_params(self: Self, call: Callable[..., Any], extra: dict[tuple[str, Any], Any]) -> dict[str, Any]:
+        """
+        Разрешаем параметры зависимости.
+        """
+        signature = inspect.signature(call)
+        resolved_params: dict[str, Any] = {}
+        type_hints = get_type_hints(call, include_extras=True)
+        for param_name, param in signature.parameters.items():
+            annotation = type_hints[param_name]
+            args = get_args(annotation)
+            if (param_name, annotation) in extra:
+                extra_value = extra[param_name, annotation]
+                resolved_params[param_name] = extra_value() if callable(extra_value) else extra_value
+            elif get_origin(annotation) is Annotated and len(args) == 2 and isinstance(args[1], Depends):
+                resolved_params[param_name] = await self.resolve_dependency(annotation, extra)
+            elif param.default is not inspect.Parameter.empty:
+                resolved_params[param_name] = param.default
+            else:
+                raise ContainerError(f'Can not resolve dependency {param_name}: {annotation}')
+        return resolved_params
+
+    @classmethod
+    def init(cls, module_names: set[str] | None = None) -> None:
+        """
+        Инициализируем контейнер.
+        """
+        if cls.dependencies_name_mapping is None:
+            module_names = module_names or cls.get_default_module_names()
+            cls.dependencies_name_mapping = cls.get_dependencies_name_mapping(module_names)
+        if cls.dependencies_type_mapping is None:
+            cls.dependencies_type_mapping = cls.get_dependencies_type_mapping()
+
+    @classmethod
+    def get_default_module_names(cls) -> set[str]:
+        """
+        Получаем список модулей с зависимостями по умолчанию.
+        """
+        cwd = Path(os.getcwd())
+        virtual_env_paths = {path.parent for path in cwd.rglob('pyvenv.cfg')}
+        module_names: set[str] = set()
+        for path in cwd.rglob(f'{cls.DEPENDS_MODULE}.py'):
+            if not any(path.is_relative_to(venv) for venv in virtual_env_paths):
+                module_names.add('.'.join(str(path.relative_to(cwd).with_suffix('')).split('/')))
+        module_names.add(f'fast_clean.{cls.DEPENDS_MODULE}')
+        return module_names
+
+    @staticmethod
+    def get_dependencies_name_mapping(
+        module_names: set[str],
+    ) -> dict[str, Annotated[Any, Depends]]:
+        """
+        Получаем маппинг имен на зависимости.
+        """
+        name_mapping: dict[str, Annotated[Any, Depends]] = {}
+        for module_name in module_names:
+            module = sys.modules[module_name] if module_name in sys.modules else importlib.import_module(module_name)
+            for name, obj in module.__dict__.items():
+                args = get_args(obj)
+                if get_origin(obj) is Annotated and len(args) == 2 and isinstance(args[1], Depends):
+                    name_mapping[name] = obj
+        return name_mapping
+
+    @classmethod
+    def get_dependencies_type_mapping(cls) -> dict[type, Annotated[Any, Depends]]:
+        """
+        Получаем маппинг типов на зависимости.
+        """
+        assert cls.dependencies_name_mapping is not None
+        type_mapping: dict[type, Annotated[Any, Depends]] = {}
+        for dependency in cls.dependencies_name_mapping.values():
+            type_mapping[get_args(dependency)[0]] = dependency
+        return type_mapping

fast_clean/contrib/__init__.py

@@ -0,0 +1,3 @@
+"""
+Пакет, содержащий приложения.
+"""

fast_clean/contrib/healthcheck/__init__.py

@@ -0,0 +1,3 @@
+"""
+Приложение для получения состояния и метрик сервера.
+"""

fast_clean/contrib/healthcheck/router.py

@@ -0,0 +1,17 @@
+"""
+Роутер приложения healthcheck.
+"""
+
+from fastapi import APIRouter
+
+from fast_clean.schemas import StatusOkResponseSchema
+
+router = APIRouter(prefix='/health', tags=['Healthcheck'], include_in_schema=False)
+
+
+@router.get('')
+async def get_healthcheck_status() -> StatusOkResponseSchema:
+    """
+    Получаем статус сервера.
+    """
+    return StatusOkResponseSchema()

fast_clean/db.py

@@ -0,0 +1,179 @@
+"""
+Модуль, содержащий функционал, связанный с базой данных.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, AsyncContextManager, Protocol, Self
+
+import sqlalchemy as sa
+from sqlalchemy import MetaData
+from sqlalchemy.ext.asyncio import (
+    AsyncAttrs,
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.sql import func
+from sqlalchemy_utils import UUIDType
+from stringcase import snakecase
+
+from .settings import CoreDbSettingsSchema, CoreSettingsSchema
+
+if TYPE_CHECKING:
+    from .repositories import SettingsRepositoryProtocol
+
+POSTGRES_INDEXES_NAMING_CONVENTION = {
+    'ix': '%(column_0_label)s_idx',
+    'uq': '%(table_name)s_%(column_0_name)s_key',
+    'ck': '%(table_name)s_%(constraint_name)s_check',
+    'fk': '%(table_name)s_%(column_0_name)s_fkey',
+    'pk': '%(table_name)s_pkey',
+}
+
+metadata = MetaData(naming_convention=POSTGRES_INDEXES_NAMING_CONVENTION)
+
+
+def make_async_engine(db_dsn: str, *, scheme: str = 'public', echo: bool = False) -> AsyncEngine:
+    """
+    Создаем асинхронный движок.
+    """
+    return create_async_engine(
+        db_dsn,
+        connect_args={'options': f'-csearch_path={scheme}'},
+        echo=echo,
+    )
+
+
+def make_async_session_factory(
+    db_dsn: str, *, scheme: str = 'public', echo: bool = False
+) -> async_sessionmaker[AsyncSession]:
+    """
+    Создаем фабрику асинхронных сессий.
+    """
+    asyncio_engine = make_async_engine(db_dsn, scheme=scheme, echo=echo)
+    return async_sessionmaker(asyncio_engine, expire_on_commit=False, autoflush=False)
+
+
+class BaseParent(AsyncAttrs, DeclarativeBase):
+    """
+    Базовая родительская модель.
+    """
+
+    __abstract__ = True
+
+    metadata = metadata
+
+
+class Base(BaseParent):
+    """
+    Базовая родительская модель нового типа.
+    """
+
+    __abstract__ = True
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUIDType(binary=False),
+        primary_key=True,
+        default=uuid.uuid4,
+        server_default=func.gen_random_uuid(),
+    )
+
+    @declared_attr.directive
+    def __tablename__(cls) -> str:
+        return snakecase(cls.__name__)
+
+
+class BaseOld(BaseParent):
+    """
+    Базовая родительская модель старого типа.
+    """
+
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+
+class SessionFactory:
+    """
+    Фабрика сессий.
+    """
+
+    async_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+    @classmethod
+    @asynccontextmanager
+    async def make_async_session_static(
+        cls, settings_repository: SettingsRepositoryProtocol
+    ) -> AsyncIterator[AsyncSession]:
+        """
+        Создаем асинхронную сессию с помощью статической фабрики.
+        """
+        if cls.async_session_factory is None:
+            cls.async_session_factory = await cls.make_async_session_factory(settings_repository)
+        async with cls.async_session_factory() as session:
+            yield session
+
+    @classmethod
+    @asynccontextmanager
+    async def make_async_session_dynamic(
+        cls, settings_repository: SettingsRepositoryProtocol
+    ) -> AsyncIterator[AsyncSession]:
+        """
+        Создаем асинхронную сессию с помощью динамической фабрики.
+        """
+        async_session_factory = await cls.make_async_session_factory(settings_repository)
+        async with async_session_factory() as session:
+            yield session
+
+    @staticmethod
+    async def make_async_session_factory(
+        settings_repository: SettingsRepositoryProtocol,
+    ) -> async_sessionmaker[AsyncSession]:
+        """
+        Создаем фабрику асинхронных сессий.
+        """
+        settings = await settings_repository.get(CoreSettingsSchema)
+        db_settings = await settings_repository.get(CoreDbSettingsSchema)
+        return make_async_session_factory(db_settings.dsn, scheme=db_settings.scheme, echo=settings.debug)
+
+
+class SessionManagerProtocol(Protocol):
+    """
+    Протокол менеджера сессий.
+    """
+
+    def get_session(self: Self, immediate: bool = True) -> AsyncContextManager[AsyncSession]:
+        """
+        Получаем сессию для выполнения запроса.
+        """
+        ...
+
+
+class SessionManagerImpl:
+    """
+    Реализация менеджера сессий.
+    """
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    @asynccontextmanager
+    async def get_session(self: Self, immediate: bool = True) -> AsyncIterator[AsyncSession]:
+        """
+        Получаем сессию для выполнения запроса.
+        """
+        if self.session.in_transaction():
+            async with self.session.begin_nested():
+                yield self.session
+        else:
+            async with self.session.begin():
+                if immediate:
+                    await self.session.execute(sa.text('SET CONSTRAINTS ALL IMMEDIATE'))
+                yield self.session