fast-clean 0.4.0__py3-none-any.whl

fast_clean/depends.py

@@ -0,0 +1,255 @@
+"""
+Модуль, содержащий зависимости.
+"""
+
+import json
+from collections.abc import AsyncIterator, Sequence
+from typing import Annotated
+
+from fastapi import Depends, Request
+from faststream.kafka import KafkaBroker
+from flatten_dict import unflatten
+from sqlalchemy.ext.asyncio import AsyncSession
+from starlette.datastructures import FormData
+from stringcase import snakecase
+
+from .broker import BrokerFactory
+from .container import ContainerImpl, ContainerProtocol
+from .db import SessionFactory, SessionManagerImpl, SessionManagerProtocol
+from .redis import RedisManager
+from .repositories import (
+    CacheManager,
+    CacheRepositoryProtocol,
+    LocalStorageParamsSchema,
+    S3StorageParamsSchema,
+    SettingsRepositoryFactoryImpl,
+    SettingsRepositoryFactoryProtocol,
+    SettingsRepositoryProtocol,
+    SettingsSourceEnum,
+    StorageRepositoryFactoryImpl,
+    StorageRepositoryFactoryProtocol,
+    StorageRepositoryProtocol,
+    StorageTypeEnum,
+)
+from .schemas import PaginationRequestSchema
+from .services import (
+    CryptographicAlgorithmEnum,
+    CryptographyServiceFactoryImpl,
+    CryptographyServiceFactoryProtocol,
+    CryptographyServiceProtocol,
+    LockServiceProtocol,
+    RedisLockService,
+    SeedServiceImpl,
+    SeedServiceProtocol,
+    TransactionServiceImpl,
+    TransactionServiceProtocol,
+)
+from .settings import CoreCacheSettingsSchema, CoreKafkaSettingsSchema, CoreSettingsSchema, CoreStorageSettingsSchema
+
+# --- utils ---
+
+
+def get_container() -> ContainerProtocol:
+    """
+    Получаем контейнер зависимостей.
+    """
+    ContainerImpl.init()
+    return ContainerImpl()
+
+
+async def get_nested_form_data(request: Request) -> FormData:
+    """
+    Получаем форму, позволяющую использовать вложенные словари.
+    """
+    dot_data = {k.replace('[', '.').replace(']', ''): v for k, v in (await request.form()).items()}
+    nested_data = unflatten(dot_data, 'dot')
+    for k, v in nested_data.items():
+        if isinstance(v, dict):
+            nested_data[k] = json.dumps(v)
+    return FormData(nested_data)
+
+
+def get_pagination(page: int | None = None, page_size: int | None = None) -> PaginationRequestSchema:
+    """
+    Получаем входные данные пагинации.
+    """
+    return PaginationRequestSchema(page=page or 1, page_size=page_size or 10)
+
+
+def get_sorting(sorting: str | None = None) -> Sequence[str]:
+    """
+    Получаем входные данные сортировки.
+    """
+    if not sorting:
+        return []
+    return [s[0] + snakecase(s[1:]) if s[0] == '-' else snakecase(s) for s in sorting.split(',')]
+
+
+Container = Annotated[ContainerProtocol, Depends(get_container)]
+NestedFormData = Annotated[FormData, Depends(get_nested_form_data)]
+Pagination = Annotated[PaginationRequestSchema, Depends(get_pagination)]
+Sorting = Annotated[Sequence[str], Depends(get_sorting)]
+
+# --- repositories ---
+
+
+def get_settings_repository_factory() -> SettingsRepositoryFactoryProtocol:
+    """
+    Получаем фабрику репозиториев настроек.
+    """
+    return SettingsRepositoryFactoryImpl()
+
+
+SettingsRepositoryFactory = Annotated[SettingsRepositoryFactoryProtocol, Depends(get_settings_repository_factory)]
+
+
+async def get_settings_repository(settings_repository_factory: SettingsRepositoryFactory) -> SettingsRepositoryProtocol:
+    """
+    Получаем репозиторий настроек.
+    """
+    return await settings_repository_factory.make(SettingsSourceEnum.ENV)
+
+
+SettingsRepository = Annotated[SettingsRepositoryProtocol, Depends(get_settings_repository)]
+
+
+async def get_settings(settings_repository: SettingsRepository) -> CoreSettingsSchema:
+    """
+    Получаем настройки.
+    """
+    return await settings_repository.get(CoreSettingsSchema)
+
+
+Settings = Annotated[CoreSettingsSchema, Depends(get_settings)]
+
+
+async def get_broker_repository(settings_repository: SettingsRepository) -> AsyncIterator[KafkaBroker]:
+    """
+    Получаем репозиторий брокера сообщений.
+    """
+    kafka_settings = await settings_repository.get(CoreKafkaSettingsSchema)
+    yield BrokerFactory.make_static(kafka_settings)
+
+
+async def get_cache_repository(settings_repository: SettingsRepository) -> CacheRepositoryProtocol:
+    """
+    Получаем репозиторий кеша.
+    """
+    settings = await settings_repository.get(CoreSettingsSchema)
+    if settings.redis_dsn is not None:
+        RedisManager.init(settings.redis_dsn)
+    cache_settings = await settings_repository.get(CoreCacheSettingsSchema)
+    if CacheManager.cache is None:
+        CacheManager.init(cache_settings, RedisManager.redis)
+    if CacheManager.cache is not None:
+        return CacheManager.cache
+    raise ValueError('Cache is not initialized')
+
+
+def get_storage_repository_factory() -> StorageRepositoryFactoryProtocol:
+    """
+    Получаем фабрику репозиториев файлового хранилища.
+    """
+    return StorageRepositoryFactoryImpl()
+
+
+BrokerRepository = Annotated[KafkaBroker, Depends(get_broker_repository)]
+CacheRepository = Annotated[CacheRepositoryProtocol, Depends(get_cache_repository)]
+StorageRepositoryFactory = Annotated[StorageRepositoryFactoryProtocol, Depends(get_storage_repository_factory)]
+
+
+async def get_storage_repository(
+    settings_repository: SettingsRepository,
+    storage_repository_factory: StorageRepositoryFactory,
+) -> StorageRepositoryProtocol:
+    """
+    Получаем репозиторий файлового хранилища.
+    """
+    storage_settings = await settings_repository.get(CoreStorageSettingsSchema)
+    if storage_settings.provider == 's3' and storage_settings.s3 is not None:
+        return await storage_repository_factory.make(
+            StorageTypeEnum.S3,
+            S3StorageParamsSchema.model_validate(storage_settings.s3.model_dump()),
+        )
+    elif storage_settings.provider == 'local':
+        return await storage_repository_factory.make(
+            StorageTypeEnum.LOCAL, LocalStorageParamsSchema(path=storage_settings.dir)
+        )
+    raise NotImplementedError(f'Storage {storage_settings.provider} not allowed')
+
+
+StorageRepository = Annotated[StorageRepositoryProtocol, Depends(get_storage_repository)]
+
+# --- db ---
+
+
+async def get_async_session(settings_repository: SettingsRepository) -> AsyncIterator[AsyncSession]:
+    """
+    Получаем асинхронную сессию.
+    """
+    async with SessionFactory.make_async_session_static(settings_repository) as session:
+        yield session
+
+
+Session = Annotated[AsyncSession, Depends(get_async_session)]
+
+
+def get_session_manager(session: Session) -> SessionManagerProtocol:
+    """
+    Получаем менеджер сессий.
+    """
+    return SessionManagerImpl(session)
+
+
+SessionManager = Annotated[SessionManagerProtocol, Depends(get_session_manager)]
+
+# --- services ---
+
+
+def get_cryptography_service_factory(settings: Settings) -> CryptographyServiceFactoryProtocol:
+    """
+    Получаем фабрику сервисов криптографии.
+    """
+    return CryptographyServiceFactoryImpl(settings.secret_key)
+
+
+CryptographyServiceFactory = Annotated[CryptographyServiceFactoryProtocol, Depends(get_cryptography_service_factory)]
+
+
+async def get_cryptography_service(
+    cryptography_service_factory: CryptographyServiceFactory,
+) -> CryptographyServiceProtocol:
+    """
+    Получаем сервис криптографии.
+    """
+    return await cryptography_service_factory.make(CryptographicAlgorithmEnum.AES_GCM)
+
+
+def get_lock_service(settings: Settings) -> LockServiceProtocol:
+    """
+    Получаем сервис распределенной блокировки.
+    """
+    assert settings.redis_dsn is not None
+    RedisManager.init(settings.redis_dsn)
+    assert RedisManager.redis is not None
+    return RedisLockService(RedisManager.redis)
+
+
+def get_seed_service(session_manager: SessionManager) -> SeedServiceProtocol:
+    """
+    Получаем сервис для загрузки данных из файлов.
+    """
+    return SeedServiceImpl(session_manager)
+
+
+def get_transaction_service(session: Session) -> TransactionServiceProtocol:
+    """
+    Получаем сервис транзакций.
+    """
+    return TransactionServiceImpl(session)
+
+
+CryptographyService = Annotated[CryptographyServiceProtocol, Depends(get_cryptography_service)]
+LockService = Annotated[LockServiceProtocol, Depends(get_lock_service)]
+SeedService = Annotated[SeedServiceProtocol, Depends(get_seed_service)]
+TransactionService = Annotated[TransactionServiceProtocol, Depends(get_transaction_service)]

fast_clean/enums.py

@@ -0,0 +1,39 @@
+"""
+Модуль, содержащий перечисления.
+"""
+
+from enum import StrEnum, auto
+from typing import Self
+
+
+class CascadeEnum(StrEnum):
+    """
+    Настройки каскадного поведения для SQLAlchemy.
+    """
+
+    SAVE_UPDATE = 'save-update'
+    MERGE = 'merge'
+    REFRESH_EXPIRE = 'refresh-expire'
+    EXPUNGE = 'expunge'
+    DELETE = 'delete'
+    ALL = 'all'
+    DELETE_ORPHAN = 'delete-orphan'
+
+    ALL_DELETE_ORPHAN = 'all, delete-orphan'
+
+    def __add__(self: Self, value: str) -> str:
+        return f'{self}, {value}'
+
+    def __radd__(self: Self, value: str) -> str:
+        return f'{value}, {self}'
+
+
+class ModelActionEnum(StrEnum):
+    """
+    Действие с моделью.
+    """
+
+    INSERT = auto()
+    UPDATE = auto()
+    UPSERT = auto()
+    DELETE = auto()

fast_clean/exceptions.py

@@ -0,0 +1,281 @@
+"""
+Модуль, содержащий исключения.
+"""
+
+import traceback
+import uuid
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Sequence
+from functools import partial
+from typing import Self, TypeVar
+
+from fastapi import FastAPI, HTTPException, Request, Response, status
+from fastapi.exception_handlers import http_exception_handler
+from stringcase import camelcase, snakecase
+
+from .enums import ModelActionEnum
+from .schemas import BusinessLogicExceptionSchema, ModelAlreadyExistsErrorSchema, ValidationErrorSchema
+from .settings import CoreSettingsSchema
+
+ModelType = TypeVar('ModelType')
+
+
+class ContainerError(Exception):
+    """
+    Ошибка контейнера зависимостей.
+    """
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(*args)
+        self.message = message
+
+
+class LockError(Exception):
+    """
+    Ошибка распределенной блокировки.
+    """
+
+    message = 'Errors acquiring or releasing a lock'
+
+
+class BusinessLogicException(Exception, ABC):
+    """
+    Базовое исключение бизнес-логики.
+    """
+
+    @property
+    def type(self: Self) -> str:
+        """
+        Тип ошибки.
+        """
+        return snakecase(type(self).__name__.replace('Error', ''))
+
+    @property
+    @abstractmethod
+    def msg(self: Self) -> str:
+        """
+        Сообщение ошибки.
+        """
+        ...
+
+    def __str__(self: Self) -> str:
+        return self.msg
+
+    def get_schema(self: Self, debug: bool) -> BusinessLogicExceptionSchema:
+        """
+        Получаем схему исключения.
+        """
+        return BusinessLogicExceptionSchema(
+            type=self.type,
+            msg=self.msg,
+            traceback=(''.join(traceback.format_exception(type(self), self, self.__traceback__)) if debug else None),
+        )
+
+
+class PermissionDeniedError(BusinessLogicException):
+    """
+    Ошибка, возникающая при недостатке прав для выполнения действия.
+    """
+
+    @property
+    def msg(self: Self) -> str:
+        return 'Недостаточно прав для выполнения действия'
+
+
+class ModelNotFoundError(BusinessLogicException):
+    """
+    Ошибка, возникающая при невозможности найти модель.
+    """
+
+    def __init__(
+        self,
+        model: type[ModelType] | str,
+        *args: object,
+        model_id: int | uuid.UUID | Iterable[int | uuid.UUID] | None = None,
+        model_name: str | Iterable[str] | None = None,
+        message: str | None = None,
+    ) -> None:
+        super().__init__(*args)
+        self.model = model
+        self.model_id = model_id
+        self.model_name = model_name
+        self.custom_message = message
+
+    @property
+    def msg(self: Self) -> str:
+        if self.custom_message is not None:
+            return self.custom_message
+        msg = f'Не удалось найти модель {self.model if isinstance(self.model, str) else self.model.__name__}'
+        if self.model_id is not None:
+            if isinstance(self.model_id, Iterable):
+                return f'{msg} по идентификаторам: [{", ".join(map(str, self.model_id))}]'
+            return f'{msg} по идентификатору: {self.model_id}'
+        if self.model_name is not None:
+            if isinstance(self.model_name, Iterable):
+                return f'{msg} по именам: [{", ".join(self.model_name)}]'
+            return f'{msg} по имени: {self.model_name}'
+        return msg
+
+
+class ModelAlreadyExistsError(BusinessLogicException):
+    """
+    Ошибка, возникающая при попытке создать модель с существующим уникальным полем.
+    """
+
+    def __init__(self, field: str, message: str, *args: object) -> None:
+        super().__init__(*args)
+        self.field = field
+        self.message = message
+
+    @property
+    def msg(self: Self) -> str:
+        return self.message
+
+    def get_schema(self: Self, debug: bool) -> BusinessLogicExceptionSchema:
+        return ModelAlreadyExistsErrorSchema.model_validate(
+            {**super().get_schema(debug).model_dump(), 'field': self.field}
+        )
+
+
+class ModelIntegrityError(BusinessLogicException):
+    """
+    Ошибка целостности данных при взаимодействии с моделью.
+    """
+
+    def __init__(self, model: type[ModelType] | str, action: ModelActionEnum, *args: object) -> None:
+        super().__init__(*args)
+        self.model = model
+        self.action = action
+
+    @property
+    def msg(self: Self) -> str:
+        """
+        Сообщение ошибки.
+        """
+        msg = 'Ошибка целостности данных'
+        model_name = self.model if isinstance(self.model, str) else self.model.__name__
+        match self.action:
+            case ModelActionEnum.INSERT:
+                msg += f' при создании модели {model_name}'
+            case ModelActionEnum.UPDATE:
+                msg += f' при изменении модели {model_name}'
+            case ModelActionEnum.UPSERT:
+                msg += f' при создании или изменении модели {model_name}'
+            case ModelActionEnum.DELETE:
+                msg += f' при удалении модели {model_name}'
+        return msg
+
+
+class ValidationError(BusinessLogicException):
+    """
+    Ошибка валидации.
+    """
+
+    def __init__(self, field: str | Sequence[str], message: str, *args: object) -> None:
+        super().__init__(*args)
+        self.field = field
+        self.message = message
+
+    @property
+    def fields(self: Self) -> Sequence[str]:
+        """
+        Поля ошибки.
+        """
+        return [self.field] if isinstance(self.field, str) else self.field
+
+    @property
+    def msg(self: Self) -> str:
+        return self.message
+
+    def get_schema(self: Self, debug: bool) -> BusinessLogicExceptionSchema:
+        return ValidationErrorSchema.model_validate(
+            {
+                **super().get_schema(debug).model_dump(),
+                'fields': list(map(camelcase, self.fields)),
+            }
+        )
+
+
+class SortingFieldNotFoundError(BusinessLogicException):
+    """
+    Ошибка, возникающая при невозможности найти поле для сортировки.
+    """
+
+    def __init__(self, field: str, *args: object) -> None:
+        super().__init__(*args)
+        self.field = field
+
+    @property
+    def msg(self: Self) -> str:
+        return f'Не удалось найти поле для сортировки: {self.field}'
+
+
+async def business_logic_exception_handler(
+    settings: CoreSettingsSchema, request: Request, exception: BusinessLogicException
+) -> Response:
+    """
+    Обработчик базового исключения бизнес-логики.
+    """
+    return await http_exception_handler(
+        request,
+        HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=[exception.get_schema(settings.debug).model_dump()],
+        ),
+    )
+
+
+async def permission_denied_error_handler(
+    settings: CoreSettingsSchema, request: Request, error: PermissionDeniedError
+) -> Response:
+    """
+    Обработчик ошибки, возникающей при недостатке прав для выполнения действия.
+    """
+    return await http_exception_handler(
+        request,
+        HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=[error.get_schema(settings.debug).model_dump()],
+        ),
+    )
+
+
+async def model_not_found_error_handler(
+    settings: CoreSettingsSchema, request: Request, error: ModelNotFoundError
+) -> Response:
+    """
+    Обработчик ошибки, возникающей при невозможности найти модель.
+    """
+    return await http_exception_handler(
+        request,
+        HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=[error.get_schema(settings.debug).model_dump()],
+        ),
+    )
+
+
+async def model_already_exists_error_handler(
+    settings: CoreSettingsSchema, request: Request, error: ModelAlreadyExistsError
+) -> Response:
+    """
+    Обработчик ошибки, возникающей при попытке создать модель с существующим уникальным
+    полем.
+    """
+    return await http_exception_handler(
+        request,
+        HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=[error.get_schema(settings.debug).model_dump()],
+        ),
+    )
+
+
+def use_exceptions_handlers(app: FastAPI, settings: CoreSettingsSchema) -> None:
+    """
+    Регистрируем глобальные обработчики исключений.
+    """
+    app.exception_handler(BusinessLogicException)(partial(business_logic_exception_handler, settings))
+    app.exception_handler(PermissionDeniedError)(partial(permission_denied_error_handler, settings))
+    app.exception_handler(ModelNotFoundError)(partial(model_not_found_error_handler, settings))
+    app.exception_handler(ModelAlreadyExistsError)(partial(model_already_exists_error_handler, settings))

fast_clean/loggers.py

@@ -0,0 +1,26 @@
+"""
+Модуль, содержащий функционал, связанный логированием.
+"""
+
+import logging
+import logging.config
+from pathlib import Path
+
+import yaml
+
+
+def use_logging(base_dir: Path) -> None:
+    """
+    Применяем настройки логирования.
+    """
+    files = ['.logging.dev.yaml', '.logging.yaml']
+    for file in files:
+        ls_file = base_dir / file
+        if ls_file.exists():
+            with open(ls_file, 'rt') as f:
+                config = yaml.safe_load(f.read())
+            logging.config.dictConfig(config)
+            break
+    else:
+        print(f'Missing configuration logging files: {", ".join(files)}')
+        exit(0)

fast_clean/middleware.py

@@ -0,0 +1,20 @@
+"""
+Модуль, содержащий middleware.
+"""
+
+from fastapi import FastAPI
+from starlette.middleware.cors import CORSMiddleware
+
+
+def use_middleware(app: FastAPI, cors_origins: list[str]) -> FastAPI:
+    """
+    Регистрируем middleware.
+    """
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=cors_origins,
+        allow_credentials=True,
+        allow_methods=['*'],
+        allow_headers=['*'],
+    )
+    return app

fast_clean/models.py

@@ -0,0 +1,33 @@
+"""
+Модуль, содержащий модели.
+"""
+
+import datetime as dt
+
+from sqlalchemy import DateTime
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.sql import func
+
+
+class TimestampMixin:
+    """
+    Миксин, содержащий дату и время создания и обновления модели.
+    """
+
+    created_at: Mapped[dt.datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: dt.datetime.now(dt.UTC),
+        server_default=func.now(),
+    )
+    """
+    Дата и время создания.
+    """
+    updated_at: Mapped[dt.datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: dt.datetime.now(dt.UTC),
+        server_default=func.now(),
+        onupdate=lambda: dt.datetime.now(dt.UTC),
+    )
+    """
+    Дата и время обновления.
+    """

fast_clean/redis.py

@@ -0,0 +1,23 @@
+"""
+Модуль, содержащий функционал, связанный с Redis.
+"""
+
+from pydantic import RedisDsn
+
+from redis import asyncio as aioredis
+
+
+class RedisManager:
+    """
+    Менеджер для управления клиентом Redis.
+    """
+
+    redis: aioredis.Redis | None = None
+
+    @classmethod
+    def init(cls, redis_dsn: RedisDsn) -> None:
+        """
+        Инициализируем клиент Redis.
+        """
+        if cls.redis is None:
+            cls.redis = aioredis.from_url(url=str(redis_dsn), decode_responses=True)