fast-clean 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fast_clean/container.py

@@ -2,196 +2,63 @@
 Модуль, содержащий контейнер зависимостей.
 """
 
-from __future__ import annotations
-
 import importlib
-import inspect
 import os
 import sys
-from collections.abc import Callable
-from contextlib import AsyncExitStack
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 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:
-        """
-        Закрываем асинхронный контекстный менеджер для управления стеком контекстных менеджеров.
-        """
-        ...
+from dishka import AsyncContainer, Provider, make_async_container
+from dishka.integrations.fastapi import FastapiProvider, setup_dishka
+from fastapi import FastAPI
 
-    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:
+class ContainerManager:
     """
-    Реализация контейнера зависимостей.
+    Менеджер для управления контейнером зависимостей.
     """
 
     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
+    container: AsyncContainer | 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:
+    @classmethod
+    def init(cls, module_names: set[str] | None = None) -> AsyncContainer:
         """
-        Получаем зависимость по имени.
+        Инициализируем контейнер зависимостей.
         """
-        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)
+        if cls.container is None:
+            cls.container = cls.create(module_names)
+        return cls.container
 
-    async def resolve_dependency(self: Self, annotated_type: type, extra: dict[tuple[str, Any], Any]) -> Any:
+    @classmethod
+    def init_for_fastapi(cls, app: FastAPI, module_names: set[str] | None = None) -> AsyncContainer:
         """
-        Разрешаем зависимость.
+        Инициализируем контейнер зависимостей для приложения FastAPI.
         """
-        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
+        container = cls.init(module_names)
+        setup_dishka(container=container, app=app)
+        return container
 
-    async def resolve_params(self: Self, call: Callable[..., Any], extra: dict[tuple[str, Any], Any]) -> dict[str, Any]:
+    @classmethod
+    async def close(cls) -> None:
         """
-        Разрешаем параметры зависимости.
+        Закрываем контейнер зависимостей.
         """
-        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
+        if cls.container is None:
+            return
+        await cls.container.close()
+        cls.container = None
 
     @classmethod
-    def init(cls, module_names: set[str] | None = None) -> None:
+    def create(cls, module_names: set[str] | None = None) -> AsyncContainer:
         """
-        Инициализируем контейнер.
+        Создаем контейнер зависимостей.
         """
-        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()
+        module_names = module_names or set()
+        module_names.update(cls.get_default_module_names())
+        return make_async_container(FastapiProvider(), *cls.get_providers(module_names))
 
     @classmethod
     def get_default_module_names(cls) -> set[str]:
@@ -208,28 +75,26 @@ class ContainerImpl:
         return module_names
 
     @staticmethod
-    def get_dependencies_name_mapping(
-        module_names: set[str],
-    ) -> dict[str, Annotated[Any, Depends]]:
+    def get_providers(module_names: set[str]) -> list[Provider]:
         """
-        Получаем маппинг имен на зависимости.
+        Получаем провайдеры зависимостей.
         """
-        name_mapping: dict[str, Annotated[Any, Depends]] = {}
+        providers: list[Provider] = []
         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
+            for obj in module.__dict__.values():
+                if isinstance(obj, Provider):
+                    providers.append(obj)
+        return providers
 
-    @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
+
+@asynccontextmanager
+async def get_container() -> AsyncIterator[AsyncContainer]:
+    """
+    Получаем контейнер зависимостей.
+    """
+    container = ContainerManager.container
+    if container is None:
+        container = ContainerManager.init()
+    async with container() as nested_container:
+        yield nested_container

fast_clean/depends.py

@@ -6,6 +6,7 @@ import json
 from collections.abc import AsyncIterator, Sequence
 from typing import Annotated
 
+from dishka import Provider, Scope, provide
 from fastapi import Depends, Request
 from faststream.kafka import KafkaBroker
 from flatten_dict import unflatten
@@ -14,7 +15,6 @@ 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 (
@@ -34,28 +34,15 @@ from .repositories import (
 from .schemas import PaginationRequestSchema
 from .services import (
     CryptographicAlgorithmEnum,
-    CryptographyServiceFactoryImpl,
-    CryptographyServiceFactoryProtocol,
+    CryptographyServiceFactory,
     CryptographyServiceProtocol,
     LockServiceProtocol,
     RedisLockService,
-    SeedServiceImpl,
-    SeedServiceProtocol,
-    TransactionServiceImpl,
-    TransactionServiceProtocol,
+    SeedService,
+    TransactionService,
 )
 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:
     """
@@ -85,171 +72,142 @@ def get_sorting(sorting: str | None = None) -> Sequence[str]:
     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:
+class CoreProvider(Provider):
+    """
+    Провайдер зависимостей.
+    """
+
+    scope = Scope.REQUEST
+
+    # --- repositories ---
+
+    settings_repository_factory = provide(
+        SettingsRepositoryFactoryImpl, provides=SettingsRepositoryFactoryProtocol, scope=Scope.APP
+    )
+    storage_repository_factory = provide(
+        StorageRepositoryFactoryImpl, provides=StorageRepositoryFactoryProtocol, scope=Scope.APP
+    )
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    async def get_settings_repository(
+        settings_repository_factory: SettingsRepositoryFactoryProtocol,
+    ) -> SettingsRepositoryProtocol:
+        """
+        Получаем репозиторий настроек.
+        """
+        return await settings_repository_factory.make(SettingsSourceEnum.ENV)
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    async def get_settings(settings_repository: SettingsRepositoryProtocol) -> CoreSettingsSchema:
+        """
+        Получаем настройки.
+        """
+        return await settings_repository.get(CoreSettingsSchema)
+
+    @staticmethod
+    async def get_broker_repository(settings_repository: SettingsRepositoryProtocol) -> AsyncIterator[KafkaBroker]:
+        """
+        Получаем репозиторий брокера сообщений.
+        """
+        kafka_settings = await settings_repository.get(CoreKafkaSettingsSchema)
+        yield BrokerFactory.make_static(kafka_settings)
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    async def get_cache_repository(settings_repository: SettingsRepositoryProtocol) -> 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_repository is None:
+            CacheManager.init(cache_settings, RedisManager.redis)
+        if CacheManager.cache_repository is not None:
+            return CacheManager.cache_repository
+        raise ValueError('Cache is not initialized')
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    async def get_storage_repository(
+        settings_repository: SettingsRepositoryProtocol,
+        storage_repository_factory: StorageRepositoryFactoryProtocol,
+    ) -> 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' and storage_settings.dir is not None:
+            return await storage_repository_factory.make(
+                StorageTypeEnum.LOCAL, LocalStorageParamsSchema(path=storage_settings.dir)
+            )
+        raise NotImplementedError(f'Storage {storage_settings.provider} not allowed')
+
+    # --- db ---
+
+    @provide
+    @staticmethod
+    async def get_async_session(settings_repository: SettingsRepositoryProtocol) -> AsyncIterator[AsyncSession]:
+        """
+        Получаем асинхронную сессию.
+        """
+        async with SessionFactory.make_async_session_static(settings_repository) as session:
+            yield session
+
+    @provide
+    @staticmethod
+    def get_session_manager(session: AsyncSession) -> SessionManagerProtocol:
+        """
+        Получаем менеджер сессий.
+        """
+        return SessionManagerImpl(session)
+
+    # --- services ---
+
+    seed_service = provide(SeedService)
+    transaction_service = provide(TransactionService)
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    def get_cryptography_service_factory(settings: CoreSettingsSchema) -> CryptographyServiceFactory:
+        """
+        Получаем фабрику сервисов криптографии.
+        """
+        return CryptographyServiceFactory(settings.secret_key)
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    async def get_cryptography_service(
+        cryptography_service_factory: CryptographyServiceFactory,
+    ) -> CryptographyServiceProtocol:
+        """
+        Получаем сервис криптографии.
+        """
+        return await cryptography_service_factory.make(CryptographicAlgorithmEnum.AES_GCM)
+
+    @provide(scope=Scope.APP)
+    @staticmethod
+    def get_lock_service(settings: CoreSettingsSchema) -> LockServiceProtocol:
+        """
+        Получаем сервис распределенной блокировки.
+        """
+        assert 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)
+        assert RedisManager.redis is not None
+        return RedisLockService(RedisManager.redis)
 
 
-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)]
+provider = CoreProvider()

fast_clean/repositories/cache/__init__.py

@@ -6,7 +6,7 @@
 - Redis
 """
 
-from typing import ClassVar, Protocol, Self, Tuple, cast
+from typing import ClassVar, Protocol, Self, cast
 
 from fastapi_cache import FastAPICache
 
@@ -34,7 +34,7 @@ class CacheRepositoryProtocol(Protocol):
         """
         ...
 
-    async def get_with_ttl(self: Self, key: str) -> Tuple[int, str | None]:
+    async def get_with_ttl(self: Self, key: str) -> tuple[int, str | None]:
         """
         Получаем значение со сроком жизни.
         """
@@ -61,17 +61,17 @@ class CacheRepositoryProtocol(Protocol):
 
 class CacheManager:
     """
-    Менеджер для реализации кеширования.
+    Менеджер для работы с репозиторием кеша.
     """
 
-    cache: ClassVar[CacheRepositoryProtocol | None] = None
+    cache_repository: ClassVar[CacheRepositoryProtocol | None] = None
 
     @classmethod
     def init(cls, cache_settings: CoreCacheSettingsSchema, redis: aioredis.Redis | None) -> None:
         """
         Инициализируем кеш.
         """
-        if cls.cache is None:
+        if cls.cache_repository is None:
             cache_backend: InMemoryCacheRepository | RedisCacheRepository
             match cache_settings.provider:
                 case 'in_memory':
@@ -80,4 +80,4 @@ class CacheManager:
                     assert redis is not None
                     cache_backend = RedisCacheRepository(redis)
             FastAPICache.init(cache_backend, prefix=cache_settings.prefix)
-            cls.cache = cast(CacheRepositoryProtocol, cache_backend)
+            cls.cache_repository = cast(CacheRepositoryProtocol, cache_backend)

fast_clean/services/__init__.py

@@ -2,15 +2,11 @@
 Пакет, содержащий сервисы.
 """
 
-from .cryptography import AesCbcCryptographyService as AesCbcCryptographyService
 from .cryptography import AesGcmCryptographyService as AesGcmCryptographyService
 from .cryptography import CryptographicAlgorithmEnum as CryptographicAlgorithmEnum
-from .cryptography import CryptographyServiceFactoryImpl as CryptographyServiceFactoryImpl
-from .cryptography import CryptographyServiceFactoryProtocol as CryptographyServiceFactoryProtocol
+from .cryptography import CryptographyServiceFactory as CryptographyServiceFactory
 from .cryptography import CryptographyServiceProtocol as CryptographyServiceProtocol
 from .lock import LockServiceProtocol as LockServiceProtocol
 from .lock import RedisLockService as RedisLockService
-from .seed import SeedServiceImpl as SeedServiceImpl
-from .seed import SeedServiceProtocol as SeedServiceProtocol
-from .transaction import TransactionServiceImpl as TransactionServiceImpl
-from .transaction import TransactionServiceProtocol as TransactionServiceProtocol
+from .seed import SeedService as SeedService
+from .transaction import TransactionService as TransactionService

fast_clean/services/cryptography/__init__.py

@@ -4,7 +4,8 @@
 
 from typing import Protocol, Self
 
-from .aes import AesCbcCryptographyService, AesGcmCryptographyService
+from .aes import AesCbcCryptographyService as AesCbcCryptographyService
+from .aes import AesGcmCryptographyService
 from .enums import CryptographicAlgorithmEnum
 
 
@@ -26,21 +27,9 @@ class CryptographyServiceProtocol(Protocol):
         ...
 
 
-class CryptographyServiceFactoryProtocol(Protocol):
+class CryptographyServiceFactory:
     """
-    Протокол фабрики сервисов криптографии для шифрования секретных параметров.
-    """
-
-    async def make(self: Self, algorithm: CryptographicAlgorithmEnum) -> CryptographyServiceProtocol:
-        """
-        Создаем сервис криптографии для шифрования секретных параметров.
-        """
-        ...
-
-
-class CryptographyServiceFactoryImpl:
-    """
-    Реализация фабрики сервисов криптографии для шифрования секретных параметров.
+    Фабрика сервисов криптографии для шифрования секретных параметров.
     """
 
     def __init__(self, secret_key: str) -> None:
@@ -53,5 +42,4 @@ class CryptographyServiceFactoryImpl:
         match algorithm:
             case CryptographicAlgorithmEnum.AES_GCM:
                 return AesGcmCryptographyService(self.secret_key)
-            case CryptographicAlgorithmEnum.AES_CBC:
-                return AesCbcCryptographyService(self.secret_key)
+        raise NotImplementedError(algorithm)

fast_clean/services/lock.py

@@ -4,11 +4,11 @@
 
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import AsyncContextManager, Protocol, Self
+from typing import AsyncContextManager, Protocol
 
+import redis.asyncio.lock as aioredis_lock
 from fast_clean.exceptions import LockError
 from redis import asyncio as aioredis
-from redis.exceptions import LockError as RedisLockError
 
 
 class LockServiceProtocol(Protocol):
@@ -17,7 +17,7 @@ class LockServiceProtocol(Protocol):
     """
 
     def lock(
-        self: Self,
+        self,
         name: str,
         *,
         timeout: float | None = None,
@@ -40,7 +40,7 @@ class RedisLockService:
 
     @asynccontextmanager
     async def lock(
-        self: Self,
+        self,
         name: str,
         *,
         timeout: float | None = None,
@@ -53,5 +53,5 @@ class RedisLockService:
         try:
             async with self.redis.lock(name, timeout=timeout, sleep=sleep, blocking_timeout=blocking_timeout):
                 yield
-        except RedisLockError as lock_error:
+        except aioredis_lock.LockError as lock_error:
             raise LockError() from lock_error

fast_clean/services/seed.py

@@ -6,7 +6,7 @@ import importlib
 import json
 import os
 from pathlib import Path
-from typing import Any, Protocol, Self, cast
+from typing import Any, cast
 
 import sqlalchemy as sa
 from sqlalchemy.dialects.postgresql import insert
@@ -15,19 +15,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from ..db import SessionManagerProtocol
 
 
-class SeedServiceProtocol(Protocol):
-    """
-    Протокол сервиса для загрузки данных из файлов.
-    """
-
-    async def load_data(self: Self, directory: str | Path | None = None) -> None:
-        """
-        Загружаем данные из файлов по пути.
-        """
-        ...
-
-
-class SeedServiceImpl:
+class SeedService:
     """
     Реализация сервиса для загрузки данных из файлов.
     """
@@ -35,7 +23,7 @@ class SeedServiceImpl:
     def __init__(self, session_manager: SessionManagerProtocol) -> None:
         self.session_manager = session_manager
 
-    async def load_data(self: Self, directory: str | Path | None = None) -> None:
+    async def load_data(self, directory: str | Path | None = None) -> None:
         """
         Загружаем данные из файлов по пути.
         """

fast_clean/services/transaction.py

@@ -3,25 +3,13 @@
 """
 
 from contextlib import asynccontextmanager
-from typing import AsyncContextManager, AsyncIterator, Protocol, Self
+from typing import AsyncIterator
 
 import sqlalchemy as sa
 from sqlalchemy.ext.asyncio import AsyncSession
 
 
-class TransactionServiceProtocol(Protocol):
-    """
-    Протокол сервиса транзакций.
-    """
-
-    def begin(self: Self, immediate: bool = True) -> AsyncContextManager[None]:
-        """
-        Начинаем транзакцию.
-        """
-        ...
-
-
-class TransactionServiceImpl:
+class TransactionService:
     """
     Реализация сервиса транзакций.
     """
@@ -30,7 +18,7 @@ class TransactionServiceImpl:
         self.session = session
 
     @asynccontextmanager
-    async def begin(self: Self, immediate: bool = True) -> AsyncIterator[None]:
+    async def begin(self, immediate: bool = True) -> AsyncIterator[None]:
         """
         Начинаем транзакцию.
         """

fast_clean/tools/cryptography.py

@@ -6,8 +6,8 @@ from typing import Annotated
 
 import typer
 
-from fast_clean.depends import get_container
-from fast_clean.services import CryptographicAlgorithmEnum, CryptographyServiceFactoryProtocol
+from fast_clean.container import get_container
+from fast_clean.services import CryptographicAlgorithmEnum, CryptographyServiceFactory
 from fast_clean.utils import typer_async
 
 
@@ -21,12 +21,10 @@ async def encrypt(
     """
     Зашифровываем данные.
     """
-    container = get_container()
-    cryptography_service_factory: CryptographyServiceFactoryProtocol = await container.get_by_type(
-        CryptographyServiceFactoryProtocol
-    )
-    cryptography_service = await cryptography_service_factory.make(algorithm)
-    print(cryptography_service.encrypt(data))
+    async with get_container() as container:
+        cryptography_service_factory = await container.get(CryptographyServiceFactory)
+        cryptography_service = await cryptography_service_factory.make(algorithm)
+        print(cryptography_service.encrypt(data))
 
 
 @typer_async
@@ -39,12 +37,10 @@ async def decrypt(
     """
     Расшифровываем данные.
     """
-    container = get_container()
-    cryptography_service_factory: CryptographyServiceFactoryProtocol = await container.get_by_type(
-        CryptographyServiceFactoryProtocol
-    )
-    cryptography_service = await cryptography_service_factory.make(algorithm)
-    print(cryptography_service.decrypt(data))
+    async with get_container() as container:
+        cryptography_service_factory = await container.get(CryptographyServiceFactory)
+        cryptography_service = await cryptography_service_factory.make(algorithm)
+        print(cryptography_service.decrypt(data))
 
 
 def use_cryptography(app: typer.Typer) -> None:

fast_clean/tools/load_seed.py

@@ -6,8 +6,8 @@ from typing import Annotated
 
 import typer
 
-from fast_clean.depends import get_container
-from fast_clean.services import SeedServiceProtocol
+from fast_clean.container import get_container
+from fast_clean.services import SeedService
 from fast_clean.utils import typer_async
 
 
@@ -19,7 +19,7 @@ async def load_seed(
     Загружаем данные из файлов.
     """
     async with get_container() as container:
-        seed_service: SeedServiceProtocol = await container.get_by_type(SeedServiceProtocol)
+        seed_service = await container.get(SeedService)
         await seed_service.load_data(path)
 
 

{fast_clean-1.0.0.dist-info → fast_clean-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-clean
-Version: 1.0.0
+Version: 1.1.0
 Summary: FastAPI Clean Architecture implementation
 Author-email: Luferov Victor <luferovvs@yandex.ru>, Orlov Artem <squakrazv@yandex.ru>
 Requires-Python: >=3.12

{fast_clean-1.0.0.dist-info → fast_clean-1.1.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 fast_clean/__init__.py,sha256=sT4tb75t5PXws8W_7wpA0jNtNxkWPFLAMrPlDGS7RHw,51
 fast_clean/broker.py,sha256=CHnL4Jd6jF5gKgtUXi33j9QFG2EUM4uqhVqdLuxIrZs,4474
-fast_clean/container.py,sha256=i7ZLZY_UN6ohGn-PT3RgAkzRPza3-DWRfgRdoaeMBWU,9562
+fast_clean/container.py,sha256=E1e0H1JqGOacH4uBNwkjTDXYhzN56yZi0AmWXQ3DkEQ,3535
 fast_clean/db.py,sha256=d03D9cYHpq8iQ7ErAwZYggLhITmxD5feSr071kv0_x0,5507
-fast_clean/depends.py,sha256=94mIIfXoY7X_lm0xrcd15QjrGkyr_QLF0Om5byJNuJ0,8824
+fast_clean/depends.py,sha256=nSsn1-c7A0VmtudCI70z5wi0b7TmSUqvHjyZpTE3_wk,7750
 fast_clean/enums.py,sha256=lPhC_2_r6YFby7Mq-9u_JSiuyZ0e57F2VxBfUwnBZ18,826
 fast_clean/exceptions.py,sha256=Sp-k-a5z1Gedu0slzj1-rORnr4GP1FXDHKCKRaJq-7o,9485
 fast_clean/loggers.py,sha256=hVvZSDMMxYnK-p_yyjd4R7SyHpmxQF3eKQEeMu9Q-jo,705
@@ -16,7 +16,7 @@ fast_clean/contrib/__init__.py,sha256=AcFNyhc0QGsOnYvzQGanDN3QIAsKpn4d8RIj73F-sG
 fast_clean/contrib/healthcheck/__init__.py,sha256=p8hUCLdv2qGngTwAeTGIV4h_ZGDm9ZNWMrA5_k3Yi0E,106
 fast_clean/contrib/healthcheck/router.py,sha256=6kyFuNqR5m3pB_fzerrZ7m7yvoqL_BiwkUMeLrxJVnE,408
 fast_clean/repositories/__init__.py,sha256=IpETRNot2t6rI5qUtsyqinkloS2fhcqSVpB5-s1iUmY,1753
-fast_clean/repositories/cache/__init__.py,sha256=9i3_AbUDt4HbPBRUfvNb2HqYGTDhZ6ZRRqz9jKE5o9c,2479
+fast_clean/repositories/cache/__init__.py,sha256=pD7qIS6H8DrnhOptJiXrlGcWYUCIU3VmVQCLccyxx4Q,2511
 fast_clean/repositories/cache/in_memory.py,sha256=Hb68UrTmQozALcyLrmYPBIfJfi67NvsCTDe1RfqwBHQ,2259
 fast_clean/repositories/cache/redis.py,sha256=UjrA2CXQtMfHTpowz6Ot952y73YjTEr6zJlBbWblaws,1908
 fast_clean/repositories/crud/__init__.py,sha256=CrfjDlf0QLQXzX4GO7VkDf_qaZMPl1Pz9pXv9fCyWSU,4391
@@ -40,16 +40,16 @@ fast_clean/schemas/pagination.py,sha256=GEQ-Tbhx6xkMMXhDNWrTEhPv8IdnAOJxH2P1tscm
 fast_clean/schemas/repository.py,sha256=up4-c7irCRm73Xsq0jMu5pot1xMDOuNRNNopId0-Zn8,889
 fast_clean/schemas/request_response.py,sha256=i4HTpjelWl4DxJ1sQaeanTWB_PThlhVJRhtMMGqRAiQ,693
 fast_clean/schemas/status_response.py,sha256=mASZRCNtKJnDbmhr8_pBytkE_3NguyTIFqO4aw-nNEQ,269
-fast_clean/services/__init__.py,sha256=hhT-tt4pQxD7EanesryzxPa9MqIavaU8bj4lrVGXLi0,964
-fast_clean/services/lock.py,sha256=sWrlEP4rWkKTJgcnR1UrBOnZ8kOvuji4aNWr9VPzjwo,1665
-fast_clean/services/seed.py,sha256=dytqnztOdvAoja3-bs_ldqf6LnoAUcaGEti2TxTTYOU,3201
-fast_clean/services/transaction.py,sha256=9XW084PnBgN-g9hBSSDs5NN6QbrsVArBjOLMuhn-W_8,1093
-fast_clean/services/cryptography/__init__.py,sha256=aXGBi49z9qeaRyTM7ZU9qncN-PfwlSXAJ_WSBuyYMf4,2071
+fast_clean/services/__init__.py,sha256=Lvdb5ZibRGwoMn_WENrk9wERUViTsPrU8E_71XtPFJc,617
+fast_clean/services/lock.py,sha256=Sw8LKAQ6w-EFSOeIOVsbB89lZa3LvF4ROiRpJFF5hzE,1642
+fast_clean/services/seed.py,sha256=M0yA2I5z-jLM2UcW_x7287mwIFW5Vt0fPFaplakGFc0,2836
+fast_clean/services/transaction.py,sha256=djXR6e6ukgpBXDbVmU095MvRJAIqdOPMgAcege52Qxg,762
+fast_clean/services/cryptography/__init__.py,sha256=IDokTE-dJriQxdsov3yoVw1OrsgyxJLeBFJwi_Mb7iE,1531
 fast_clean/services/cryptography/aes.py,sha256=_k0WtnKDaEKdUBegfwmqerE75ER44307CEQ-I2W0abo,4616
 fast_clean/services/cryptography/enums.py,sha256=cLibSGv6LNVTUI2rm3_DtDwU68GYIAf4kY3GGbtnw1A,494
 fast_clean/tools/__init__.py,sha256=m8n09uN47JGtAfgWVbXCJOxpzlrUazogqtLo6xPWe3s,181
-fast_clean/tools/cryptography.py,sha256=NznbY5wtXeX8doyn6Hf76ztakckto5QnsUDK1GK7RWE,2001
-fast_clean/tools/load_seed.py,sha256=Bql-c-hjFdrf-qsGo5V7DSX9sa9_RCk_P9BLF7G5xts,910
+fast_clean/tools/cryptography.py,sha256=Q79-Qb4-nyrid3CNr7uWplT6tghnivFI-bqNUTvqlIQ,1913
+fast_clean/tools/load_seed.py,sha256=Tm5_r_myrC5dl_WyC6Bx2WKFAkfLf-Pch4ZK6zWN2Qg,867
 fast_clean/utils/__init__.py,sha256=Q3OiJNdWl51Vd_wSP7iuZQIq4_SjM1mYkqIWPaw94WU,709
 fast_clean/utils/process.py,sha256=6k2E1q7d31Wq6G5BqJqrX5czimvJExeltk7uO7CxiSg,936
 fast_clean/utils/pydantic.py,sha256=FtBkNsxdlrhrlEiIHu2wZwF-UR4THETV8mw-h_jevYg,871
@@ -59,7 +59,7 @@ fast_clean/utils/thread.py,sha256=ChEWBLupnSEMq4Wro_aiW0QvCLUKedKc0TQFMu7Zg4g,56
 fast_clean/utils/time.py,sha256=nvavbtG4zR_gkrGSbsqKAsBdePxO3LuTeoISbFZIgn0,307
 fast_clean/utils/type_converters.py,sha256=bMEJeoQB9Q6Qok1-ppn4Ii8ZpIkZwJbD2IzCydSStHw,523
 fast_clean/utils/typer.py,sha256=1O7BsNGn68bBzNbj0-Ycfhv35WpLzwvYTKn510YNXQQ,663
-fast_clean-1.0.0.dist-info/METADATA,sha256=jt-CLrTfxZI6T1S020P1uRyhTHD-o_hoT32hXqZx8Ro,1030
-fast_clean-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fast_clean-1.0.0.dist-info/top_level.txt,sha256=QfsGs-QLmPCZWWPFOukD0zhMnokH68FoO2KeObl6ZIA,11
-fast_clean-1.0.0.dist-info/RECORD,,
+fast_clean-1.1.0.dist-info/METADATA,sha256=TwQl3DYFi2AAzEmjriNSSK0MImCSlUEzIRlbBibnlfQ,1030
+fast_clean-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fast_clean-1.1.0.dist-info/top_level.txt,sha256=QfsGs-QLmPCZWWPFOukD0zhMnokH68FoO2KeObl6ZIA,11
+fast_clean-1.1.0.dist-info/RECORD,,