fast-clean 1.3.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

fast_clean/cli/__init__.py

@@ -0,0 +1,6 @@
+"""
+Пакет, содержащий команды Typer.
+"""
+
+from .cryptography import use_cryptography as use_cryptography
+from .load_seed import use_load_seed as use_load_seed

fast_clean/cli/cryptography.py

@@ -0,0 +1,53 @@
+"""
+Модуль, содержащий команды криптографии для шифрования секретных параметров.
+"""
+
+from typing import Annotated
+
+import typer
+from rich import print
+
+from fast_clean.container import get_container
+from fast_clean.services import CryptographicAlgorithmEnum, CryptographyServiceFactory
+from fast_clean.utils import typer_async
+
+
+@typer_async
+async def encrypt(
+    data: Annotated[str, typer.Argument(help='Данные для шифровки.')],
+    algorithm: Annotated[
+        CryptographicAlgorithmEnum, typer.Option(help='Криптографический алгоритм')
+    ] = CryptographicAlgorithmEnum.AES_GCM,
+) -> None:
+    """
+    Зашифровываем данные.
+    """
+    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
+async def decrypt(
+    data: Annotated[str, typer.Argument(help='Данные для расшифровки.')],
+    algorithm: Annotated[
+        CryptographicAlgorithmEnum, typer.Option(help='Криптографический алгоритм')
+    ] = CryptographicAlgorithmEnum.AES_GCM,
+) -> None:
+    """
+    Расшифровываем данные.
+    """
+    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:
+    """
+    Регистрируем команды криптографии для шифрования секретных параметров.
+    """
+
+    app.command()(encrypt)
+    app.command()(decrypt)

fast_clean/cli/load_seed.py

@@ -0,0 +1,31 @@
+"""
+Модуль, содержащий команды загрузки данных из файлов.
+"""
+
+from typing import Annotated
+
+import typer
+
+from fast_clean.container import get_container
+from fast_clean.services import SeedService
+from fast_clean.utils import typer_async
+
+
+@typer_async
+async def load_seed(
+    path: Annotated[str | None, typer.Argument(help='Путь к директории для загрузки данных.')] = None,
+) -> None:
+    """
+    Загружаем данные из файлов.
+    """
+    async with get_container() as container:
+        seed_service = await container.get(SeedService)
+        await seed_service.load_data(path)
+
+
+def use_load_seed(app: typer.Typer) -> None:
+    """
+    Регистрируем команды загрузки данных из файлов.
+    """
+
+    app.command()(load_seed)

fast_clean/contrib/healthcheck/schemas.py

@@ -1,4 +1,3 @@
-
 from fast_clean.schemas.request_response import ResponseSchema
 
 

fast_clean/contrib/monitoring/middleware.py

@@ -3,4 +3,4 @@ from fastapi import FastAPI
 
 
 def use_middleware(app: FastAPI) -> None:
-    app.add_middleware(MetricsMiddleware)   # type: ignore
+    app.add_middleware(MetricsMiddleware)  # type: ignore

fast_clean/db.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import uuid
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, AsyncContextManager, Protocol, Self
+from typing import TYPE_CHECKING, Any, AsyncContextManager, Protocol, Self
 
 import sqlalchemy as sa
 from sqlalchemy import MetaData
@@ -18,11 +18,9 @@ from sqlalchemy.ext.asyncio import (
     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.types.uuid import UUIDType
-from stringcase import snakecase
+from sqlalchemy_utils.types import UUIDType
 
 from .settings import CoreDbSettingsSchema, CoreSettingsSchema
 
@@ -40,24 +38,46 @@ POSTGRES_INDEXES_NAMING_CONVENTION = {
 metadata = MetaData(naming_convention=POSTGRES_INDEXES_NAMING_CONVENTION)
 
 
-def make_async_engine(db_dsn: str, *, scheme: str = 'public', echo: bool = False) -> AsyncEngine:
+def make_async_engine(
+    db_dsn: str,
+    *,
+    scheme: str = 'public',
+    echo: bool = False,
+    pool_pre_ping: bool = True,
+    disable_prepared_statements: bool = True,
+) -> AsyncEngine:
     """
     Создаем асинхронный движок.
     """
+    connect_args: dict[str, Any] = {}
+    if disable_prepared_statements:
+        connect_args['prepare_threshold'] = None
     return create_async_engine(
         db_dsn,
-        connect_args={'options': f'-csearch_path={scheme}'},
         echo=echo,
+        pool_pre_ping=pool_pre_ping,
+        connect_args=connect_args,
     )
 
 
 def make_async_session_factory(
-    db_dsn: str, *, scheme: str = 'public', echo: bool = False
+    db_dsn: str,
+    *,
+    scheme: str = 'public',
+    echo: bool = False,
+    pool_pre_ping: bool = True,
+    disable_prepared_statements: bool = True,
 ) -> async_sessionmaker[AsyncSession]:
     """
     Создаем фабрику асинхронных сессий.
     """
-    asyncio_engine = make_async_engine(db_dsn, scheme=scheme, echo=echo)
+    asyncio_engine = make_async_engine(
+        db_dsn,
+        scheme=scheme,
+        echo=echo,
+        pool_pre_ping=pool_pre_ping,
+        disable_prepared_statements=disable_prepared_statements,
+    )
     return async_sessionmaker(asyncio_engine, expire_on_commit=False, autoflush=False)
 
 
@@ -85,10 +105,6 @@ class BaseUUID(Base):
         server_default=func.gen_random_uuid(),
     )
 
-    @declared_attr.directive
-    def __tablename__(cls) -> str:
-        return snakecase(cls.__name__)
-
 
 class BaseInt(Base):
     """
@@ -100,10 +116,6 @@ class BaseInt(Base):
     id: Mapped[int] = mapped_column(primary_key=True)
 
 
-    @declared_attr.directive
-    def __tablename__(cls) -> str:
-        return snakecase(cls.__name__)
-
 class SessionFactory:
     """
     Фабрика сессий.
@@ -125,16 +137,13 @@ class SessionFactory:
             yield session
 
     @classmethod
-    @asynccontextmanager
     async def make_async_session_dynamic(
         cls, settings_repository: SettingsRepositoryProtocol
-    ) -> AsyncIterator[AsyncSession]:
+    ) -> async_sessionmaker[AsyncSession]:
         """
         Создаем асинхронную сессию с помощью динамической фабрики.
         """
-        async_session_factory = await cls.make_async_session_factory(settings_repository)
-        async with async_session_factory() as session:
-            yield session
+        return await cls.make_async_session_factory(settings_repository)
 
     @staticmethod
     async def make_async_session_factory(
@@ -145,7 +154,13 @@ class SessionFactory:
         """
         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)
+        return make_async_session_factory(
+            db_settings.dsn,
+            scheme=db_settings.scheme,
+            echo=settings.debug,
+            pool_pre_ping=db_settings.pool_pre_ping,
+            disable_prepared_statements=db_settings.disable_prepared_statements,
+        )
 
 
 class SessionManagerProtocol(Protocol):

fast_clean/depends.py

@@ -16,7 +16,6 @@ from stringcase import snakecase
 
 from .broker import BrokerFactory
 from .db import SessionFactory, SessionManagerImpl, SessionManagerProtocol
-from .redis import RedisManager
 from .repositories import (
     CacheManager,
     CacheRepositoryProtocol,
@@ -82,18 +81,14 @@ class CoreProvider(Provider):
     Провайдер зависимостей.
     """
 
-    scope = Scope.REQUEST
+    scope = Scope.APP
 
     # --- repositories ---
 
-    settings_repository_factory = provide(
-        SettingsRepositoryFactoryImpl, provides=SettingsRepositoryFactoryProtocol, scope=Scope.APP
-    )
-    storage_repository_factory = provide(
-        StorageRepositoryFactoryImpl, provides=StorageRepositoryFactoryProtocol, scope=Scope.APP
-    )
+    settings_repository_factory = provide(SettingsRepositoryFactoryImpl, provides=SettingsRepositoryFactoryProtocol)
+    storage_repository_factory = provide(StorageRepositoryFactoryImpl, provides=StorageRepositoryFactoryProtocol)
 
-    @provide(scope=Scope.APP)
+    @provide
     @staticmethod
     async def get_settings_repository(
         settings_repository_factory: SettingsRepositoryFactoryProtocol,
@@ -103,7 +98,7 @@ class CoreProvider(Provider):
         """
         return await settings_repository_factory.make(SettingsSourceEnum.ENV)
 
-    @provide(scope=Scope.APP)
+    @provide
     @staticmethod
     async def get_settings(settings_repository: SettingsRepositoryProtocol) -> CoreSettingsSchema:
         """
@@ -119,41 +114,38 @@ class CoreProvider(Provider):
         kafka_settings = await settings_repository.get(CoreKafkaSettingsSchema)
         yield BrokerFactory.make_static(kafka_settings)
 
-    @provide(scope=Scope.APP)
+    @provide
     @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')
+        return CacheManager.init(cache_settings)
 
-    @provide(scope=Scope.APP)
+    @provide(scope=Scope.REQUEST)
     @staticmethod
     async def get_storage_repository(
         settings_repository: SettingsRepositoryProtocol,
         storage_repository_factory: StorageRepositoryFactoryProtocol,
-    ) -> StorageRepositoryProtocol:
+    ) -> AsyncIterator[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(
+            storage_repository = 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(
+            async with storage_repository:
+                yield storage_repository
+        elif storage_settings.provider == 'local':
+            storage_repository = await storage_repository_factory.make(
                 StorageTypeEnum.LOCAL, LocalStorageParamsSchema(path=storage_settings.dir)
             )
+            async with storage_repository:
+                yield storage_repository
         raise NotImplementedError(f'Storage {storage_settings.provider} not allowed')
 
     # --- db ---
@@ -164,7 +156,8 @@ class CoreProvider(Provider):
         """
         Получаем асинхронную сессию.
         """
-        async with SessionFactory.make_async_session_static(settings_repository) as session:
+        session_maker = await SessionFactory.make_async_session_dynamic(settings_repository)
+        async with session_maker() as session:
             yield session
 
     @provide
@@ -180,7 +173,7 @@ class CoreProvider(Provider):
     seed_service = provide(SeedService)
     transaction_service = provide(TransactionService)
 
-    @provide(scope=Scope.APP)
+    @provide
     @staticmethod
     def get_cryptography_service_factory(settings: CoreSettingsSchema) -> CryptographyServiceFactory:
         """
@@ -188,7 +181,7 @@ class CoreProvider(Provider):
         """
         return CryptographyServiceFactory(settings.secret_key)
 
-    @provide(scope=Scope.APP)
+    @provide
     @staticmethod
     async def get_cryptography_service(
         cryptography_service_factory: CryptographyServiceFactory,
@@ -198,16 +191,14 @@ class CoreProvider(Provider):
         """
         return await cryptography_service_factory.make(CryptographicAlgorithmEnum.AES_GCM)
 
-    @provide(scope=Scope.APP)
+    @provide
     @staticmethod
-    def get_lock_service(settings: CoreSettingsSchema) -> LockServiceProtocol:
+    def get_lock_service(cache_settings: CoreCacheSettingsSchema) -> LockServiceProtocol:
         """
         Получаем сервис распределенной блокировки.
         """
-        assert settings.redis_dsn is not None
-        RedisManager.init(settings.redis_dsn)
-        assert RedisManager.redis is not None
-        return RedisLockService(RedisManager.redis)
+        redis_client = CacheManager.init(cache_settings)
+        return RedisLockService(redis_client)  # type: ignore
 
 
 provider = CoreProvider()

fast_clean/middleware.py

@@ -2,22 +2,39 @@
 Модуль, содержащий middleware.
 """
 
-from fastapi import FastAPI
+import time
+from typing import Awaitable, Callable
+
+from fastapi import FastAPI, Request, Response
 from starlette.middleware.cors import CORSMiddleware
 
-from .contrib.monitoring.middleware import use_middleware as use_monitoring_middleware
+
+async def add_process_time_header(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+    start_time = time.perf_counter()
+    response = await call_next(request)
+    response.headers['x-process-time'] = f'{time.perf_counter() - start_time}'
+    return response
 
 
-def use_middleware(app: FastAPI, cors_origins: list[str]) -> FastAPI:
+def use_middleware(
+    app: FastAPI,
+    name: str,
+    cors_origins: list[str],
+    *,
+    allow_methods: list[str] | None = None,
+    allow_headers: list[str] | None = None,
+) -> FastAPI:
     """
     Регистрируем middleware.
     """
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=cors_origins,
         allow_credentials=True,
-        allow_methods=['*'],
-        allow_headers=['*'],
+        allow_methods=allow_methods or ['*'],
+        allow_headers=allow_headers or ['*'],
     )
-    use_monitoring_middleware(app)
+
+    app.middleware('http')(add_process_time_header)
     return app

fast_clean/models.py

@@ -9,9 +9,9 @@ from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy.sql import func
 
 
-class TimestampMixin:
+class CreatedAtMixin:
     """
-    Миксин, содержащий дату и время создания и обновления модели.
+    Миксин, содержащий дату и время создания записи.
     """
 
     created_at: Mapped[dt.datetime] = mapped_column(
@@ -19,15 +19,22 @@ class TimestampMixin:
         default=lambda: dt.datetime.now(dt.UTC),
         server_default=func.now(),
     )
+
+
+class UpdatedAtMixin:
     """
-    Дата и время создания.
+    Миксин, содержащий дату и время обновления записи.
     """
+
     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),
     )
+
+
+class TimestampMixin(CreatedAtMixin, UpdatedAtMixin):
     """
-    Дата и время обновления.
+    Миксин, содержащий дату и время создания и обновления записи.
     """

fast_clean/repositories/cache/__init__.py

@@ -9,9 +9,9 @@
 from typing import ClassVar, Protocol, Self, cast
 
 from fastapi_cache import FastAPICache
+from redis import asyncio as aioredis
 
 from fast_clean.settings import CoreCacheSettingsSchema
-from redis import asyncio as aioredis
 
 from .in_memory import InMemoryCacheRepository as InMemoryCacheRepository
 from .redis import RedisCacheRepository as RedisCacheRepository
@@ -67,7 +67,7 @@ class CacheManager:
     cache_repository: ClassVar[CacheRepositoryProtocol | None] = None
 
     @classmethod
-    def init(cls, cache_settings: CoreCacheSettingsSchema, redis: aioredis.Redis | None) -> None:
+    def init(cls, cache_settings: CoreCacheSettingsSchema):
         """
         Инициализируем кеш.
         """
@@ -77,7 +77,13 @@ class CacheManager:
                 case 'in_memory':
                     cache_backend = InMemoryCacheRepository()
                 case 'redis':
-                    assert redis is not None
-                    cache_backend = RedisCacheRepository(redis)
+                    if not cache_settings.redis:
+                        raise ValueError('Redis not configured in settings')
+                    cache_backend = RedisCacheRepository(
+                        aioredis.from_url(url=str(cache_settings.redis.dsn), decode_responses=True)  # type: ignore
+                    )
+                case _:
+                    raise ValueError('Cache is not initialized')
             FastAPICache.init(cache_backend, prefix=cache_settings.prefix)
             cls.cache_repository = cast(CacheRepositoryProtocol, cache_backend)
+        return cls.cache_repository

fast_clean/repositories/cache/redis.py

@@ -6,7 +6,6 @@ from typing import Self
 
 from fastapi_cache.backends.redis import RedisBackend
 from overrides import override
-
 from redis.asyncio.client import Redis
 
 

fast_clean/repositories/crud/db.py

@@ -502,11 +502,11 @@ class DbCrudRepositoryBase(
             count = (await s.execute(count_statement)).scalar_one()
             return PaginationResultSchema(count=count, objects=objects)
 
-    def get_order_by_expr(self: Self, sorting: Iterable[str]) -> list[sa.UnaryExpression]:
+    def get_order_by_expr(self: Self, sorting: Iterable[str]) -> list[sa.UnaryExpression[Any]]:
         """
         Получаем выражение сортировки.
         """
-        order_by_expr: list[sa.UnaryExpression] = []
+        order_by_expr: list[sa.UnaryExpression[Any]] = []
         for st in sorting:
             try:
                 if st[0] == '-':

fast_clean/repositories/storage/__init__.py

@@ -6,11 +6,13 @@
 - S3
 """
 
+from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import AsyncContextManager, Protocol, Self
 
 from .enums import StorageTypeEnum
 from .local import LocalStorageRepository
+from .reader import AsyncStreamReaderProtocol as AsyncStreamReaderProtocol
 from .reader import StreamReaderProtocol, StreamReadProtocol
 from .s3 import S3StorageRepository
 from .schemas import (
@@ -25,6 +27,18 @@ class StorageRepositoryProtocol(Protocol):
     Протокол репозитория файлового хранилища.
     """
 
+    async def __aenter__(self: Self) -> Self:
+        """
+        Вход в контекст менеджера.
+        """
+        ...
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Выход из контекст менеджера.
+        """
+        ...
+
     async def exists(self: Self, path: str | Path) -> bool:
         """
         Проверяем существует ли файл.
@@ -71,14 +85,18 @@ class StorageRepositoryProtocol(Protocol):
         self: Self,
         path: str | Path,
         stream: StreamReadProtocol,
-        length: int = -1,
-        part_size: int = 0,
     ) -> None:
         """
         Создаем файл или переписываем существующий в потоковом режиме.
         """
         ...
 
+    def straming_read(self: Self, path: str | Path) -> AsyncIterator[bytes]:
+        """
+        Возвращаем асинхронные итератор потока байт.
+        """
+        ...
+
     async def delete(self: Self, path: str | Path) -> None:
         """
         Удаляем файл.

fast_clean/repositories/storage/local.py

@@ -4,7 +4,7 @@
 
 import asyncio
 import os
-from collections.abc import AsyncGenerator, Awaitable, Callable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 from logging import getLogger
 from pathlib import Path
@@ -28,6 +28,14 @@ class LocalStorageRepository:
             os.makedirs(self.work_dir)
         self.logger = getLogger(__name__)
 
+    async def __aenter__(self: Self) -> Self:
+        """
+        Вход в контекст менеджера.
+        """
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb): ...
+
     async def exists(self: Self, path: str | Path) -> bool:
         """
         Проверяем существует ли файл.
@@ -78,6 +86,12 @@ class LocalStorageRepository:
         async with open(path, 'rb') as f:
             yield AiofilesStreamReader(f)
 
+    async def straming_read(self: Self, path: str | Path) -> AsyncIterator[bytes]:
+        path = self.work_dir / path
+        async with open(path, 'rb') as f:
+            async for chunk in f:
+                yield chunk
+
     async def write(self: Self, path: str | Path, content: str | bytes) -> None:
         """
         Создаем файл или переписываем существующий.
@@ -91,15 +105,11 @@ class LocalStorageRepository:
         self: Self,
         path: str | Path,
         stream: StreamReadProtocol,
-        length: int = -1,
-        part_size: int = 0,
     ) -> None:
         """
         Создаем файл или переписываем существующий в потоковом режиме.
         """
-        if length != -1:
-            self.logger.warning('Параметр length не используется для LocalStorage.')
-        part_size = part_size or 1024
+        part_size = 1024 * 1024
         path = self.work_dir / path
         is_co_function = asyncio.iscoroutinefunction(stream.read)
         async with open(path, 'wb') as f:

fast_clean/repositories/storage/reader.py

@@ -35,6 +35,14 @@ class StreamReadAsyncProtocol(Protocol):
         ...
 
 
+class AsyncStreamReaderProtocol(Protocol):
+    async def read(self: Self, size: int = -1) -> bytes:
+        """
+        Потоковое чтение файлов.
+        """
+        ...
+
+
 StreamReadProtocol = StreamReadAsyncProtocol | StreamReadSyncProtocol
 
 

fast_clean/repositories/storage/s3.py

@@ -1,112 +1,163 @@
 """
-Модуль, содержащий репозиторий хранилища S3.
+Модуль содержит имплементация работы с репозиторием по средствам протокола S3.
 """
 
-import io
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Self
+from typing import TYPE_CHECKING, Self, cast
 
-import aiohttp
-import miniopy_async
-from miniopy_async.error import S3Error
+import aiobotocore
+import aiobotocore.session
+from aiobotocore.response import StreamingBody
+from aiobotocore.session import AioSession
+from botocore.exceptions import ClientError
 
-from .reader import AiohttpStreamReader, StreamReaderProtocol, StreamReadProtocol
-from .schemas import S3StorageParamsSchema
+from fast_clean.repositories.storage.schemas import S3StorageParamsSchema
+
+from .reader import AiofilesStreamReader, StreamReaderProtocol, StreamReadProtocol
+
+if TYPE_CHECKING:
+    from types_aiobotocore_s3.client import S3Client as AioBaseClient
+else:
+    from aiobotocore.client import AioBaseClient
 
 
 class S3StorageRepository:
     """
-    Репозиторий хранилища S3.
+    Репозиторий хранилища S3 с использованием aiobotocore.
     """
 
-    def __init__(self: Self, params: S3StorageParamsSchema):
+    def __init__(self, params: S3StorageParamsSchema) -> None:
         self.params = params
         self.bucket = self.params.bucket
-        self.client = miniopy_async.Minio(  # type: ignore
-            f'{self.params.endpoint}:{self.params.port}',
-            access_key=self.params.access_key,
-            secret_key=self.params.secret_key,
-            secure=self.params.secure,
-        )
 
-    async def exists(self: Self, path: str | Path) -> bool:
+        self.session: AioSession | None = None
+        self.client: AioBaseClient | None = None
+
+        protocol = 'https' if self.params.secure else 'http'
+        self.endpoint_url = f'{protocol}://{self.params.endpoint}:{self.params.port}'
+
+    async def __aenter__(self: Self) -> Self:
+        self.session = aiobotocore.session.get_session()
+        self.client = await self.session.create_client(
+            's3',
+            endpoint_url=self.endpoint_url,
+            aws_access_key_id=self.params.aws_access_key_id,
+            aws_secret_access_key=self.params.aws_secret_access_key,
+            region_name=self.params.region_name,
+        ).__aenter__()
+        return self
+
+    async def __aexit__(self: Self, exc_type, exc_val, exc_tb) -> None:
         """
-        Проверяем существует ли файл.
+        Выход из контектсного менеджера сессии.
         """
+        if self.client:
+            await self.client.__aexit__(exc_type, exc_val, exc_tb)
+            self.client = None
+            self.session = None
+
+    async def exists(self: Self, path: str | Path) -> bool:
+        assert self.client
+        key = self.get_str_path(path)
+        if key == '':
+            key = '/'
         try:
-            await self.client.stat_object(self.bucket, self.get_str_path(path))
+            await self.client.head_object(Bucket=self.bucket, Key=key)
             return True
-        except S3Error:
+        except ClientError:
             return False
 
     async def listdir(self: Self, path: str | Path) -> list[str]:
         """
-        Получаем список файлов и директорий в заданной директории.
-        """
-        str_path = self.get_str_path(path)
-        if not str_path or str_path[-1] != '/':
-            str_path += '/'
-        objects = await self.client.list_objects(self.bucket, prefix=str_path if str_path != '/' else None)
-        return [str(obj.object_name) for obj in objects] if objects else []
+        Получаем список файлов и директорий в указанной лиректории.
+        """
+        assert self.client
+        prefix = self.get_str_path(path)
+        if prefix and not prefix.endswith('/'):
+            prefix += '/'
+        objects = []
+        paginator = self.client.get_paginator('list_objects_v2')
+        async for page in paginator.paginate(Bucket=self.bucket, Prefix=prefix, Delimiter='/'):
+            if 'Contents' in page:
+                objects.extend([obj.get('Key') for obj in page['Contents'] if obj.get('Key') != prefix])
+            if 'CommonPrefixes' in page:
+                objects.extend([folder.get('Prefix') for folder in page['CommonPrefixes']])
+        return objects
 
     async def is_file(self: Self, path: str | Path) -> bool:
         """
-        Проверяем находится ли файл по пути.
+        Проверяем, является ли путь файлом.
         """
-        return not await self.is_dir(path)
+        return await self.exists(path)
 
     async def is_dir(self: Self, path: str | Path) -> bool:
         """
-        Проверяем находится ли директория по пути.
-        """
-        return len(await self.listdir(path)) > 0
+        Проверяем, является ли путь дирректорией.
+        """
+        assert self.client
+        prefix = self.get_str_path(path)
+        if prefix != '' and not prefix.endswith('/'):
+            prefix += '/'
+        response = await self.client.list_objects_v2(
+            Bucket=self.bucket,
+            Prefix=prefix,
+            MaxKeys=1,
+            Delimiter='/',
+        )
+        return 'Contents' in response or 'CommonPrefixes' in response
 
     async def read(self: Self, path: str | Path) -> bytes:
         """
         Читаем содержимое файла.
         """
-        async with aiohttp.ClientSession() as session:
-            response: aiohttp.ClientResponse = await self.client.get_object(
-                self.bucket, self.get_str_path(path), session
-            )
-            return await response.read()
+        assert self.client
+        key = self.get_str_path(path)
+        response = await self.client.get_object(Bucket=self.bucket, Key=key)
+        async with response['Body'] as stream:
+            return await stream.read()
 
-    @asynccontextmanager
-    async def stream_read(self: Self, path: str | Path) -> AsyncGenerator[StreamReaderProtocol, None]:
+    async def write(self: Self, path: str | Path, content: str | bytes) -> None:
         """
-        Читаем содержимое файла в потоковом режиме.
+        Создаем файл или перезаписываем существующий.
         """
-        async with aiohttp.ClientSession() as session:
-            reader = await self.client.get_object(self.bucket, self.get_str_path(path), session)
-            yield AiohttpStreamReader(reader)
+        assert self.client
+        key = self.get_str_path(path)
+        content = content.encode('utf-8') if isinstance(content, str) else content
+        await self.client.put_object(Bucket=self.bucket, Key=key, Body=content)
 
-    async def write(self: Self, path: str | Path, content: str | bytes) -> None:
+    @asynccontextmanager
+    async def stream_read(self: Self, path: str | Path) -> AsyncIterator[StreamReaderProtocol]:
         """
-        Создаем файл или переписываем существующий.
+        Читаем содержимое в потоковом режиме.
         """
-        content = content.encode('utf-8') if isinstance(content, str) else content
-        data = io.BytesIO(content)
-        await self.client.put_object(self.bucket, self.get_str_path(path), data, len(content))
+        assert self.client
+        key = self.get_str_path(path)
+        response = await self.client.get_object(Bucket=self.bucket, Key=key)
+        yield AiofilesStreamReader(response['Body'])
+
+    async def straming_read(self: Self, path: str | Path) -> AsyncIterator[bytes]:
+        assert self.client
+        key = self.get_str_path(path)
+        response = await self.client.get_object(Bucket=self.bucket, Key=key)
+        async for chunk in response['Body']:
+            yield chunk
 
-    async def stream_write(
-        self: Self,
-        path: str | Path,
-        stream: StreamReadProtocol,
-        length: int = -1,
-        part_size: int = 0,
-    ) -> None:
+    async def stream_write(self: Self, path: str | Path, stream: StreamReadProtocol) -> None:
         """
-        Создаем файл или переписываем существующий в потоковом режиме.
+        Создаем поток на запись файла и перезаписываем существующий, если он есть.
         """
-        await self.client.put_object(self.bucket, self.get_str_path(path), stream, length=length, part_size=part_size)
+        assert self.client
+        await self.client.put_object(Bucket=self.bucket, Key=self.get_str_path(path), Body=cast(StreamingBody, stream))
 
     async def delete(self: Self, path: str | Path) -> None:
         """
-        Удаляем файл.
+        Удаление файла.
         """
-        await self.client.remove_object(self.bucket, self.get_str_path(path))
+        assert self.client
+        key = self.get_str_path(path)
+        await self.client.delete_object(Bucket=self.bucket, Key=key)
 
     @staticmethod
     def get_str_path(path: str | Path) -> str:
@@ -114,5 +165,5 @@ class S3StorageRepository:
         Получаем путь в виде строки.
         """
         if isinstance(path, Path):
-            return '/' if path == Path('') else str(path)
+            return '' if path == Path('') else str(path)
         return path

fast_clean/repositories/storage/schemas.py

@@ -12,12 +12,17 @@ class S3StorageParamsSchema(BaseModel):
     Параметры настроек для S3Storage.
     """
 
+    """
+    Параметры настроек для S3Storage.
+    """
+
     endpoint: str
-    access_key: str
-    secret_key: str
+    aws_secret_access_key: str
+    aws_access_key_id: str
     port: int
     bucket: str
-    secure: bool = False
+    secure: bool = True
+    region_name: str = 'us-east-1'
 
 
 class LocalStorageParamsSchema(BaseModel):

fast_clean/services/cryptography/__init__.py

@@ -43,4 +43,4 @@ class CryptographyServiceFactory:
             case CryptographicAlgorithmEnum.AES_GCM:
                 return AesGcmCryptographyService(self.secret_key)
             case _:
-                 raise NotImplementedError(algorithm)
+                raise NotImplementedError(algorithm)

fast_clean/services/lock.py

@@ -6,10 +6,11 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from typing import AsyncContextManager, Protocol
 
-from fast_clean.exceptions import LockError
 from redis import asyncio as aioredis
 from redis.exceptions import LockError as AIORedisLockError
 
+from fast_clean.exceptions import LockError
+
 
 class LockServiceProtocol(Protocol):
     """

fast_clean/settings.py

@@ -27,6 +27,8 @@ class CoreDbSettingsSchema(BaseModel):
     password: str
     name: str
 
+    pool_pre_ping: bool = True
+    disable_prepared_statements: bool = True
     scheme: str = 'public'
 
     @property
@@ -37,6 +39,10 @@ class CoreDbSettingsSchema(BaseModel):
         return f'{self.provider}://{self.user}:{self.password}@{self.host}:{self.port}/{self.name}'
 
 
+class CoreRedisSettingsSchema(BaseModel):
+    dsn: RedisDsn
+
+
 class CoreCacheSettingsSchema(BaseModel):
     """
     Схема настроек кеша.
@@ -46,6 +52,8 @@ class CoreCacheSettingsSchema(BaseModel):
 
     prefix: str
 
+    redis: CoreRedisSettingsSchema | None = None
+
 
 class CoreS3SettingsSchema(BaseModel):
     """
@@ -53,9 +61,8 @@ class CoreS3SettingsSchema(BaseModel):
     """
 
     endpoint: str
-    endpoint_url: str
-    access_key: str
-    secret_key: str
+    aws_access_key_id: str
+    aws_secret_access_key: str
     port: int
     bucket: str
     secure: bool = False
@@ -177,7 +184,6 @@ class CoreSettingsSchema(BaseSettingsSchema):
     base_dir: Path = Path(os.getcwd())
     secret_key: str
     cors_origins: Annotated[list[str], Field(default_factory=list)]
-    redis_dsn: RedisDsn | None = None
     sentry_dsn: str | None = None
 
     model_config = SettingsConfigDict(

fast_clean/utils/toml.py

@@ -0,0 +1,34 @@
+import tomllib
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+__all__ = (
+    'use_toml_info',
+    'ProjectInfo',
+)
+
+
+class ProjectInfo(BaseModel):
+    """
+    Схема для получения информации о проекте.
+    """
+
+    name: str
+    version: str
+    description: str | None = None
+
+
+def use_toml(dir: Path) -> dict[str, Any]:
+    with open(Path(dir) / 'pyproject.toml', 'rb') as f:
+        return tomllib.load(f)
+
+
+@lru_cache(maxsize=1)
+def use_toml_info(dir: Path) -> ProjectInfo:
+    """
+    Получение версии приложения из pyproject.toml.
+    """
+    return ProjectInfo.model_validate(use_toml(dir)['project'])

{fast_clean-1.3.0.dist-info → fast_clean-1.4.1.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: fast-clean
-Version: 1.3.0
+Version: 1.4.1
 Summary: FastAPI Clean Architecture implementation
 Author-email: Luferov Victor <luferovvs@yandex.ru>, Orlov Artem <squakrazv@yandex.ru>, Kashapov Rustam <hardtechnik91@gmail.com>
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
+Requires-Dist: aiobotocore>=2.23.2
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: aiokafka>=0.12.0
 Requires-Dist: aioprometheus>=23.12.0
@@ -15,14 +16,12 @@ Requires-Dist: fastapi>=0.115.8
 Requires-Dist: fastapi-cache2[redis]>=0.2.2
 Requires-Dist: faststream>=0.5.34
 Requires-Dist: flatten-dict>=0.4.2
-Requires-Dist: miniopy-async>=1.21.1
 Requires-Dist: overrides>=7.7.0
 Requires-Dist: psycopg[binary]>=3.2.4
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pydantic-settings>=2.8.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: sentry-sdk[fastapi]>=2.32.0
-Requires-Dist: snakecase>=1.0.1
 Requires-Dist: sqlalchemy-utils>=0.41.2
 Requires-Dist: sqlalchemy[asyncio]>=2.0.38
 Requires-Dist: stringcase>=1.2.0

{fast_clean-1.3.0.dist-info → fast_clean-1.4.1.dist-info}/RECORD

@@ -1,34 +1,36 @@
 fast_clean/__init__.py,sha256=sT4tb75t5PXws8W_7wpA0jNtNxkWPFLAMrPlDGS7RHw,51
 fast_clean/broker.py,sha256=CHnL4Jd6jF5gKgtUXi33j9QFG2EUM4uqhVqdLuxIrZs,4474
 fast_clean/container.py,sha256=E1e0H1JqGOacH4uBNwkjTDXYhzN56yZi0AmWXQ3DkEQ,3535
-fast_clean/db.py,sha256=8lfs9SS41naPkvyKcsStdBAXo07p_6Kwr_6zx7--oGU,5552
-fast_clean/depends.py,sha256=nSsn1-c7A0VmtudCI70z5wi0b7TmSUqvHjyZpTE3_wk,7750
+fast_clean/db.py,sha256=uZHXXHdLstqhyzGtBL5Z7VvXwIe6mxuPOUheJEzSMyM,5776
+fast_clean/depends.py,sha256=InU6x629CyRGskMbA4LzX5btzw_a1YeVwUckBH5tJNg,7330
 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
-fast_clean/middleware.py,sha256=G75qKJ7WxSySTIFUFa7ZwlvnZ16lm4giS0Hx4Ogu1SM,584
-fast_clean/models.py,sha256=qnNUSwLf0gOW8C98PMIs6vTw7UP3-Nk-k6YoFvHstVM,880
+fast_clean/middleware.py,sha256=p0Tv_qu89ZQtzKZ10tNepArJyHlFX2II9UmivGWnycw,1037
+fast_clean/models.py,sha256=H7-Hk3gZP9i2TiJHu0u2Nex76c8ZbDhMR4lF41_PMyI,1057
 fast_clean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fast_clean/redis.py,sha256=H_SLnDhY_ute8pYHdhIypUGlCwMcVfFA4S2j8vLUph0,578
-fast_clean/settings.py,sha256=NPWBmCB8eL6EiHPtlryW5rQyrE1EqeytnBLrcz5pQLI,4792
+fast_clean/settings.py,sha256=Ox2aDEOxw4LgrszCNpUMNlxCqozc6kcv7406786ADAw,4938
+fast_clean/cli/__init__.py,sha256=m8n09uN47JGtAfgWVbXCJOxpzlrUazogqtLo6xPWe3s,181
+fast_clean/cli/cryptography.py,sha256=ACaYAOn4KEKIdsTuCYkX1m6g2YpMczNCjJcVfLE2Rzo,1936
+fast_clean/cli/load_seed.py,sha256=Tm5_r_myrC5dl_WyC6Bx2WKFAkfLf-Pch4ZK6zWN2Qg,867
 fast_clean/contrib/__init__.py,sha256=AcFNyhc0QGsOnYvzQGanDN3QIAsKpn4d8RIj73F-sGc,63
 fast_clean/contrib/healthcheck/__init__.py,sha256=p8hUCLdv2qGngTwAeTGIV4h_ZGDm9ZNWMrA5_k3Yi0E,106
 fast_clean/contrib/healthcheck/router.py,sha256=7uq0D6ldhxB3Jsa9Ia1zpiRAyC3hQgUv8jF4W8SPi88,398
-fast_clean/contrib/healthcheck/schemas.py,sha256=nMdUezXvwyJdlHiJbPiLUIa6bJ_JeF1Tr3S-TllMENU,200
+fast_clean/contrib/healthcheck/schemas.py,sha256=s9HcXDWYUsFXHownoem5qOEL741IZWp5yOLu2LKtkkU,199
 fast_clean/contrib/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fast_clean/contrib/logging/enums.py,sha256=a-Tz3k4j0aAbUXDvTV6sl2pKKEGuKG94qc3plXixezU,154
 fast_clean/contrib/logging/sentry.py,sha256=gey6ynlkZtrU2qzwdKvpkYy0JO0AEyHDpiiRcIzfiDg,593
 fast_clean/contrib/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fast_clean/contrib/monitoring/middleware.py,sha256=F6EDY_hNBmFlji-cCJwzsm5Wl1S0CsO373rjxfqjlGA,191
+fast_clean/contrib/monitoring/middleware.py,sha256=nRhiARjpHm21qwBgkdh2Sdkuc8maDQcb6ofCRthv_O0,190
 fast_clean/contrib/monitoring/router.py,sha256=94gffX34VE_Yb6TLaQOP4YyXDQsClzOn4APb45V_HyA,153
 fast_clean/contrib/sqlalchemy_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fast_clean/contrib/sqlalchemy_utils/utils.py,sha256=5xktmJlQifGpIXMruhe7qofEEu_ExncBTUmlrtFK1YQ,1061
 fast_clean/repositories/__init__.py,sha256=mHJ6CW1fYkkiSnnYiO3GRAa5YVCPN1otOOKkjbutuhs,1753
-fast_clean/repositories/cache/__init__.py,sha256=pD7qIS6H8DrnhOptJiXrlGcWYUCIU3VmVQCLccyxx4Q,2511
+fast_clean/repositories/cache/__init__.py,sha256=aVl1ReoU0doH1i78-Ef8rS-LaVQacF0SS9xLFWzmcgQ,2811
 fast_clean/repositories/cache/in_memory.py,sha256=Hb68UrTmQozALcyLrmYPBIfJfi67NvsCTDe1RfqwBHQ,2259
-fast_clean/repositories/cache/redis.py,sha256=UjrA2CXQtMfHTpowz6Ot952y73YjTEr6zJlBbWblaws,1908
+fast_clean/repositories/cache/redis.py,sha256=-iX6x-sfXj-pDYfcRIyKjq9nCjnlRQKeJtfeMmDpT-4,1907
 fast_clean/repositories/crud/__init__.py,sha256=z_-zY3esEbUEHSGb9WInU-vvRuTpTu4M-Qe5UhCN0Pc,4359
-fast_clean/repositories/crud/db.py,sha256=KzqQXt0srcBFt2ftlkDcGPEKC_dvwAybFi5UvRTyIq0,23202
+fast_clean/repositories/crud/db.py,sha256=wyvDvEjvncfSVHlaguhrgCP7wIsiKRoGZEesxHzDVHI,23212
 fast_clean/repositories/crud/in_memory.py,sha256=37VBQJTIV4z1_Om9DhYqpa1t98hGGhY8gumoyV-fhDg,13172
 fast_clean/repositories/crud/type_vars.py,sha256=Gb4ew1T1NkitL87hJ75KtpTjOi6PuML5fU_zFAsVUqA,1318
 fast_clean/repositories/settings/__init__.py,sha256=ZxrncvTDs8pNkhWSy2cxV3a8uElTnrM-b1-vq4ouJok,1485
@@ -36,22 +38,22 @@ fast_clean/repositories/settings/enums.py,sha256=coqZg6xe_mRFWeihBfnSkCByLuD0pT8
 fast_clean/repositories/settings/env.py,sha256=maQttYENMJyTf4vnSXa4L3R6tKiLmb-d0Q5VS-r9ZuE,2153
 fast_clean/repositories/settings/exceptions.py,sha256=SKU45z-ahPzI_G6k4A9twupx1v3GaXDj2pbFkg3YgFE,348
 fast_clean/repositories/settings/type_vars.py,sha256=_Oe8x4JwwrN9WOVjLA05BN6gv7cBcBmq2YR2ZI4Hz5w,197
-fast_clean/repositories/storage/__init__.py,sha256=mP_2NTx_Ec19WCmxecJsbjvNjhy8Oj8001lJC-BTGB8,3582
+fast_clean/repositories/storage/__init__.py,sha256=HoSOCWbntw74W0OlXM0Nn4QN29AXftKbo5ZtVcfycQU,4155
 fast_clean/repositories/storage/enums.py,sha256=bS4L63aEXNaGnJql8A1jmsK4KY916cWnzTW5p_PyLmg,375
-fast_clean/repositories/storage/local.py,sha256=s5REPU7xczvzin13sKyZtFdiocrgAMk8bnDIbJ90KT4,4270
-fast_clean/repositories/storage/reader.py,sha256=yAxj51ITWJf0u-KGC3DJ0iTB3pDI1p9ixi_h0ZcWoZ4,3299
-fast_clean/repositories/storage/s3.py,sha256=z3YHGk89Ac87qAy3FApCXDpEx_CRdLfLzXBIng-BfUQ,4318
-fast_clean/repositories/storage/schemas.py,sha256=etlogfK_1uUZPQjHWQN6LWy6-8YY2Sago3Zbf6p0KcQ,623
+fast_clean/repositories/storage/local.py,sha256=W7aV-vRbN1E2Sn-V-n7ztDZiZe1xFmFa9AJucDM1XJc,4525
+fast_clean/repositories/storage/reader.py,sha256=T-5BLkiUSg-3fo3ACrHO0qqE-OKi40L6Wu2fXJJO9L4,3491
+fast_clean/repositories/storage/s3.py,sha256=70bkMd48YNYyZxLKIOD8vwoaePfD9mUNkHJtMo93JwU,6445
+fast_clean/repositories/storage/schemas.py,sha256=zJcjl3jrxcO0A6d7ohD5GRLsgRL5f2mcGZQ95pJimc8,755
 fast_clean/schemas/__init__.py,sha256=VgJKIY20qoZZOV55zLGnH2FYWoHpPfJS31HJAj_nGIo,1283
 fast_clean/schemas/exceptions.py,sha256=E7G9jv4G82Ede7OQ3619vPGwEywc7tKmXW6EolOGRFQ,723
 fast_clean/schemas/pagination.py,sha256=GEQ-Tbhx6xkMMXhDNWrTEhPv8IdnAOJxH2P1tscmn60,1384
 fast_clean/schemas/repository.py,sha256=ASxMJb23H3zwavr7P0_ZpCWZX7FjqAuC75qAIYqejvQ,889
 fast_clean/schemas/request_response.py,sha256=i4HTpjelWl4DxJ1sQaeanTWB_PThlhVJRhtMMGqRAiQ,693
 fast_clean/services/__init__.py,sha256=Lvdb5ZibRGwoMn_WENrk9wERUViTsPrU8E_71XtPFJc,617
-fast_clean/services/lock.py,sha256=SLF9_wRx3rgHMw829XwflJgAlGJyXj57o4iVPvGwe78,1653
+fast_clean/services/lock.py,sha256=SlO-wkULBtm9X7jvtUTiEpmDWuiNTscMD-73PPlmI0o,1654
 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=4bey1z11YvSv1V6PgBNYI6brgE1zMvDYh-1ZYhqDFYU,1560
+fast_clean/services/cryptography/__init__.py,sha256=XK9-z6HT1Jgfc4-IpNY6fZihjW2dqeO83cz5ZvjJIbo,1559
 fast_clean/services/cryptography/aes.py,sha256=_k0WtnKDaEKdUBegfwmqerE75ER44307CEQ-I2W0abo,4616
 fast_clean/services/cryptography/enums.py,sha256=cLibSGv6LNVTUI2rm3_DtDwU68GYIAf4kY3GGbtnw1A,494
 fast_clean/utils/__init__.py,sha256=Q3OiJNdWl51Vd_wSP7iuZQIq4_SjM1mYkqIWPaw94WU,709
@@ -61,9 +63,10 @@ fast_clean/utils/ssl_context.py,sha256=I3tM9bDB6LVMaKCDcrpREzBE4AoTWr3NQDU3_A0Kt
 fast_clean/utils/string.py,sha256=8Dy3MeDHn-V9SUknuYZp8M6iakuU_UAmkMC9UreoN8k,630
 fast_clean/utils/thread.py,sha256=ChEWBLupnSEMq4Wro_aiW0QvCLUKedKc0TQFMu7Zg4g,565
 fast_clean/utils/time.py,sha256=nvavbtG4zR_gkrGSbsqKAsBdePxO3LuTeoISbFZIgn0,307
+fast_clean/utils/toml.py,sha256=NbP7EfgKNYQ18LH8Hc-DmY1gks92bUSBW3D3-tMrY4E,737
 fast_clean/utils/type_converters.py,sha256=bMEJeoQB9Q6Qok1-ppn4Ii8ZpIkZwJbD2IzCydSStHw,523
 fast_clean/utils/typer.py,sha256=1O7BsNGn68bBzNbj0-Ycfhv35WpLzwvYTKn510YNXQQ,663
-fast_clean-1.3.0.dist-info/METADATA,sha256=RIsstyzjbBZFKcJmzekGf1Hb_d8ZQfjhG5I3P_DtPIU,1234
-fast_clean-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fast_clean-1.3.0.dist-info/top_level.txt,sha256=QfsGs-QLmPCZWWPFOukD0zhMnokH68FoO2KeObl6ZIA,11
-fast_clean-1.3.0.dist-info/RECORD,,
+fast_clean-1.4.1.dist-info/METADATA,sha256=mXmRInGHMorgthwk9OC2GgE0O3zeelJbj5j9_JvG8pA,1200
+fast_clean-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fast_clean-1.4.1.dist-info/top_level.txt,sha256=QfsGs-QLmPCZWWPFOukD0zhMnokH68FoO2KeObl6ZIA,11
+fast_clean-1.4.1.dist-info/RECORD,,

fast_clean/redis.py

@@ -1,23 +0,0 @@
-"""
-Модуль, содержащий функционал, связанный с 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)