fast-clean 1.3.0__tar.gz → 1.4.1__tar.gz

{fast_clean-1.3.0 → fast_clean-1.4.1}/PKG-INFO

@@ -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.4.1/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-1.4.1/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-1.4.1/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-1.3.0 → fast_clean-1.4.1}/fast_clean/contrib/healthcheck/schemas.py

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

{fast_clean-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.4.1/fast_clean/middleware.py

@@ -0,0 +1,40 @@
+"""
+Модуль, содержащий middleware.
+"""
+
+import time
+from typing import Awaitable, Callable
+
+from fastapi import FastAPI, Request, Response
+from starlette.middleware.cors import CORSMiddleware
+
+
+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,
+    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_methods or ['*'],
+        allow_headers=allow_headers or ['*'],
+    )
+
+    app.middleware('http')(add_process_time_header)
+    return app

{fast_clean-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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-1.3.0 → fast_clean-1.4.1}/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