fast-clean 1.0.0__tar.gz → 1.1.0__tar.gz

{fast_clean-1.0.0 → fast_clean-1.1.0}/PKG-INFO

@@ -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.1.0/fast_clean/container.py

@@ -0,0 +1,100 @@
+"""
+Модуль, содержащий контейнер зависимостей.
+"""
+
+import importlib
+import os
+import sys
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from dishka import AsyncContainer, Provider, make_async_container
+from dishka.integrations.fastapi import FastapiProvider, setup_dishka
+from fastapi import FastAPI
+
+
+class ContainerManager:
+    """
+    Менеджер для управления контейнером зависимостей.
+    """
+
+    DEPENDS_MODULE = 'depends'
+
+    container: AsyncContainer | None = None
+
+    @classmethod
+    def init(cls, module_names: set[str] | None = None) -> AsyncContainer:
+        """
+        Инициализируем контейнер зависимостей.
+        """
+        if cls.container is None:
+            cls.container = cls.create(module_names)
+        return cls.container
+
+    @classmethod
+    def init_for_fastapi(cls, app: FastAPI, module_names: set[str] | None = None) -> AsyncContainer:
+        """
+        Инициализируем контейнер зависимостей для приложения FastAPI.
+        """
+        container = cls.init(module_names)
+        setup_dishka(container=container, app=app)
+        return container
+
+    @classmethod
+    async def close(cls) -> None:
+        """
+        Закрываем контейнер зависимостей.
+        """
+        if cls.container is None:
+            return
+        await cls.container.close()
+        cls.container = None
+
+    @classmethod
+    def create(cls, module_names: set[str] | None = None) -> AsyncContainer:
+        """
+        Создаем контейнер зависимостей.
+        """
+        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]:
+        """
+        Получаем список модулей с зависимостями по умолчанию.
+        """
+        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_providers(module_names: set[str]) -> list[Provider]:
+        """
+        Получаем провайдеры зависимостей.
+        """
+        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 obj in module.__dict__.values():
+                if isinstance(obj, Provider):
+                    providers.append(obj)
+        return providers
+
+
+@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-1.1.0/fast_clean/depends.py

@@ -0,0 +1,213 @@
+"""
+Модуль, содержащий зависимости.
+"""
+
+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
+from sqlalchemy.ext.asyncio import AsyncSession
+from starlette.datastructures import FormData
+from stringcase import snakecase
+
+from .broker import BrokerFactory
+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,
+    CryptographyServiceFactory,
+    CryptographyServiceProtocol,
+    LockServiceProtocol,
+    RedisLockService,
+    SeedService,
+    TransactionService,
+)
+from .settings import CoreCacheSettingsSchema, CoreKafkaSettingsSchema, CoreSettingsSchema, CoreStorageSettingsSchema
+
+
+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(',')]
+
+
+NestedFormData = Annotated[FormData, Depends(get_nested_form_data)]
+Pagination = Annotated[PaginationRequestSchema, Depends(get_pagination)]
+Sorting = Annotated[Sequence[str], Depends(get_sorting)]
+
+
+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)
+        assert RedisManager.redis is not None
+        return RedisLockService(RedisManager.redis)
+
+
+provider = CoreProvider()

{fast_clean-1.0.0 → fast_clean-1.1.0}/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-1.1.0/fast_clean/services/__init__.py

@@ -0,0 +1,12 @@
+"""
+Пакет, содержащий сервисы.
+"""
+
+from .cryptography import AesGcmCryptographyService as AesGcmCryptographyService
+from .cryptography import CryptographicAlgorithmEnum as CryptographicAlgorithmEnum
+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 SeedService as SeedService
+from .transaction import TransactionService as TransactionService

{fast_clean-1.0.0 → fast_clean-1.1.0}/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-1.0.0 → fast_clean-1.1.0}/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-1.0.0 → fast_clean-1.1.0}/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-1.0.0 → fast_clean-1.1.0}/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-1.0.0 → fast_clean-1.1.0}/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-1.0.0 → fast_clean-1.1.0}/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 → fast_clean-1.1.0}/fast_clean.egg-info/PKG-INFO

@@ -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 → fast_clean-1.1.0}/fast_clean.egg-info/SOURCES.txt

@@ -67,6 +67,5 @@ fast_clean/utils/time.py
 fast_clean/utils/type_converters.py
 fast_clean/utils/typer.py
 tests/test_broker.py
-tests/test_container.py
 tests/test_db.py
 tests/test_exceptions.py

{fast_clean-1.0.0 → fast_clean-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-clean"
-version = "1.0.0"
+version = "1.1.0"
 description = "FastAPI Clean Architecture implementation"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -44,6 +44,8 @@ dev = [
     "ruff>=0.9.7",
 ]
 
+[tool.ruff.format]
+quote-style = "single"
 
 [tool.black]
 skip-string-normalization = true
@@ -103,4 +105,4 @@ version_toml = [
 commit_message = "chore(release): {version} [skip ci]"
 branch = "main"
 upload_to_pypi = false
-upload_to_release = true
+upload_to_release = true