fast-clean 0.4.0__py3-none-any.whl

fast_clean/services/cryptography/aes.py

@@ -0,0 +1,120 @@
+"""
+Модуль, содержащий реализацию сервиса криптографии с использованием алгоритма AES.
+"""
+
+import base64
+import os
+import warnings
+from typing import Self
+
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+
+class AesGcmCryptographyService:
+    """
+    Сервис криптографии с использованием алгоритма AES в режиме GCM.
+    """
+
+    def __init__(self, secret_key: str) -> None:
+        self.secret_key = secret_key
+        self.backend = default_backend()
+
+    def encrypt(self: Self, data: str) -> str:
+        """
+        Зашифровываем данные.
+        """
+        bytes_data = data.encode('utf-8')
+        iv = os.urandom(12)
+        cipher = Cipher(algorithms.AES(self.key), modes.GCM(iv), backend=self.backend)
+        encryptor = cipher.encryptor()
+        cipher_text = encryptor.update(bytes_data) + encryptor.finalize()
+        assert hasattr(encryptor, 'tag')
+        encrypted_data = iv + cipher_text + encryptor.tag
+        return base64.b64encode(encrypted_data).decode('ascii')
+
+    def decrypt(self: Self, encrypted_data: str) -> str:
+        """
+        Расшифровываем данные.
+        """
+        bytes_encrypted_data = base64.b64decode(encrypted_data)
+        iv = bytes_encrypted_data[:12]
+        tag = bytes_encrypted_data[-16:]
+        cipher_text = bytes_encrypted_data[12:-16]
+        cipher = Cipher(algorithms.AES(self.key), modes.GCM(iv, tag), backend=self.backend)
+        decryptor = cipher.decryptor()
+        decrypted_data = decryptor.update(cipher_text) + decryptor.finalize()
+        return decrypted_data.decode('utf-8')
+
+    @property
+    def key(self: Self) -> bytes:
+        """
+        Ключ длиной в 32 байта.
+        """
+        key_bytes = self.secret_key.encode()
+        if len(key_bytes) > 32:
+            return key_bytes[:32]
+        if len(key_bytes) < 32:
+            diff = 32 - len(key_bytes)
+            return key_bytes + b'0' * diff
+        return key_bytes
+
+
+class AesCbcCryptographyService:
+    """
+    Сервис криптографии с использованием алгоритма AES в режиме CBC.
+
+    Данный класс использует режим CBC без аутентификации и поэтому может быть небезопасным.
+    В будущем данный класс будет удален.
+    https://sonarsource.github.io/rspec/#/rspec/S5542/python
+    """
+
+    def __init__(self, secret_key: str) -> None:
+        warnings.warn(
+            f'{self.__class__.__name__} is deprecated and will be removed in future versions',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self.secret_key = secret_key
+        self.backend = default_backend()
+
+    def encrypt(self: Self, data: str) -> str:
+        """
+        Зашифровываем данные.
+        """
+        bytes_data = data.encode(encoding='utf-8')
+        iv = os.urandom(16)
+        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv), backend=self.backend)
+        encryptor = cipher.encryptor()
+        padder = padding.PKCS7(128).padder()
+        padded_data = padder.update(bytes_data) + padder.finalize()
+        cipher_text = encryptor.update(padded_data) + encryptor.finalize()
+        return base64.b64encode(iv + cipher_text).decode('ascii')
+
+    def decrypt(self: Self, encrypted_data: str) -> str:
+        """
+        Расшифровываем данные.
+        """
+        bytes_encrypted_data = base64.b64decode(encrypted_data)
+        iv = bytes_encrypted_data[:16]
+        cipher_text = bytes_encrypted_data[16:]
+        cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv), backend=self.backend)
+        decryptor = cipher.decryptor()
+        decrypted_data = decryptor.update(cipher_text) + decryptor.finalize()
+        unpadder = padding.PKCS7(128).unpadder()
+        unpadded_data = unpadder.update(decrypted_data) + unpadder.finalize()
+        return unpadded_data.decode(encoding='utf-8')
+
+    @property
+    def key(self: Self) -> bytes:
+        """
+        Ключ длиной в 32 байта.
+        """
+        key_bytes = self.secret_key.encode()
+        if len(key_bytes) > 32:
+            return key_bytes[:32]
+        if len(key_bytes) < 32:
+            diff = 32 - len(key_bytes)
+            return key_bytes + b'0' * diff
+        return key_bytes

fast_clean/services/cryptography/enums.py

@@ -0,0 +1,20 @@
+"""
+Модуль, содержащий перечисления сервиса криптографии для шифрования секретных параметров.
+"""
+
+from enum import StrEnum, auto
+
+
+class CryptographicAlgorithmEnum(StrEnum):
+    """
+    Криптографический алгоритм.
+    """
+
+    AES_GCM = auto()
+    """
+    Алгоритм AES в режиме GCM.
+    """
+    AES_CBC = auto()
+    """
+    Алгоритм AES в режиме CBC.
+    """

fast_clean/services/lock.py

@@ -0,0 +1,57 @@
+"""
+Модуль, содержащий сервис распределенной блокировки.
+"""
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import AsyncContextManager, Protocol, Self
+
+from fast_clean.exceptions import LockError
+from redis import asyncio as aioredis
+from redis.exceptions import LockError as RedisLockError
+
+
+class LockServiceProtocol(Protocol):
+    """
+    Протокол сервиса распределенной блокировки.
+    """
+
+    def lock(
+        self: Self,
+        name: str,
+        *,
+        timeout: float | None = None,
+        sleep: float = 0.1,
+        blocking_timeout: float | None = None,
+    ) -> AsyncContextManager[None]:
+        """
+        Осуществляем распределенную блокировку.
+        """
+        ...
+
+
+class RedisLockService:
+    """
+    Сервис распределенной блокировки с помощью Redis.
+    """
+
+    def __init__(self, redis: aioredis.Redis) -> None:
+        self.redis = redis
+
+    @asynccontextmanager
+    async def lock(
+        self: Self,
+        name: str,
+        *,
+        timeout: float | None = None,
+        sleep: float = 0.1,
+        blocking_timeout: float | None = None,
+    ) -> AsyncIterator[None]:
+        """
+        Осуществляем распределенную блокировку.
+        """
+        try:
+            async with self.redis.lock(name, timeout=timeout, sleep=sleep, blocking_timeout=blocking_timeout):
+                yield
+        except RedisLockError as lock_error:
+            raise LockError() from lock_error

fast_clean/services/seed.py

@@ -0,0 +1,91 @@
+"""
+Модуль, содержащий сервис для загрузки данных из файлов.
+"""
+
+import importlib
+import json
+import os
+from pathlib import Path
+from typing import Any, Protocol, Self, cast
+
+import sqlalchemy as sa
+from sqlalchemy.dialects.postgresql import insert
+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:
+    """
+    Реализация сервиса для загрузки данных из файлов.
+    """
+
+    def __init__(self, session_manager: SessionManagerProtocol) -> None:
+        self.session_manager = session_manager
+
+    async def load_data(self: Self, directory: str | Path | None = None) -> None:
+        """
+        Загружаем данные из файлов по пути.
+        """
+        directory = directory if directory is not None else self.find_directory()
+        directory = Path(directory) if isinstance(directory, str) else directory
+        async with self.session_manager.get_session() as session:
+            for file in sorted(os.listdir(directory)):
+                file_path = directory / file
+                with open(file_path) as f:
+                    items = json.load(f)
+                    for item in items:
+                        await self.upsert_item(item, session)
+
+    @staticmethod
+    def find_directory() -> Path:
+        """
+        Ищем директорию с файлами для загрузки.
+        """
+        cwd = Path(os.getcwd())
+        virtual_env_paths = {path.parent for path in cwd.rglob('pyvenv.cfg')}
+        for path in cwd.rglob('seed'):
+            if not any(path.is_relative_to(venv) for venv in virtual_env_paths):
+                return path
+        raise ValueError('Seed directory not found')
+
+    @classmethod
+    async def upsert_item(cls, item: Any, session: AsyncSession) -> None:
+        """
+        Сохраняем запись в базу данных.
+        """
+        model_type = cls.import_from_string(item['model'])
+        primary_keys = {key.name for key in cast(Any, sa.inspect(model_type)).primary_key}
+        values = {**item['fields']}
+        item_id = item.get('id')
+        if item_id:
+            values['id'] = item_id
+        await session.execute(
+            insert(model_type)
+            .values(values)
+            .on_conflict_do_update(
+                index_elements=primary_keys,
+                set_={k: v for k, v in values.items() if k not in primary_keys},
+            )
+        )
+
+    @staticmethod
+    def import_from_string(import_str: str) -> sa.TableClause:
+        """
+        Импортируем таблицу.
+        """
+        package_name, model_name = import_str.rsplit('.', maxsplit=1)
+        package = importlib.import_module(package_name)
+        return getattr(package, model_name)

fast_clean/services/transaction.py

@@ -0,0 +1,40 @@
+"""
+Модуль, содержащий сервис транзакций.
+"""
+
+from contextlib import asynccontextmanager
+from typing import AsyncContextManager, AsyncIterator, Protocol, Self
+
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+class TransactionServiceProtocol(Protocol):
+    """
+    Протокол сервиса транзакций.
+    """
+
+    def begin(self: Self, immediate: bool = True) -> AsyncContextManager[None]:
+        """
+        Начинаем транзакцию.
+        """
+        ...
+
+
+class TransactionServiceImpl:
+    """
+    Реализация сервиса транзакций.
+    """
+
+    def __init__(self, session: AsyncSession) -> None:
+        self.session = session
+
+    @asynccontextmanager
+    async def begin(self: Self, immediate: bool = True) -> AsyncIterator[None]:
+        """
+        Начинаем транзакцию.
+        """
+        async with self.session.begin():
+            if immediate:
+                await self.session.execute(sa.text('SET CONSTRAINTS ALL IMMEDIATE'))
+            yield

fast_clean/settings.py

@@ -0,0 +1,189 @@
+"""
+Модуль, содержащий настройки.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import ClassVar, Literal, Self
+
+from pydantic import BaseModel, ConfigDict, RedisDsn, model_validator
+from pydantic_settings import BaseSettings as PydanticBaseSettings
+from pydantic_settings import SettingsConfigDict
+from typing_extensions import Unpack
+
+
+class CoreDbSettingsSchema(BaseModel):
+    """
+    Схема настроек базы данных.
+    """
+
+    provider: str = 'postgresql+psycopg_async'
+
+    host: str
+    port: int
+    user: str
+    password: str
+    name: str
+
+    scheme: str = 'public'
+
+    @property
+    def dsn(self: Self) -> str:
+        """
+        DSN подключения к базе данных.
+        """
+        return f'{self.provider}://{self.user}:{self.password}@{self.host}:{self.port}/{self.name}'
+
+
+class CoreCacheSettingsSchema(BaseModel):
+    """
+    Схема настроек кеша.
+    """
+
+    provider: Literal['in_memory', 'redis'] = 'in_memory'
+
+    prefix: str
+
+
+class CoreS3SettingsSchema(BaseModel):
+    """
+    Схема настроек S3.
+    """
+
+    endpoint: str
+    endpoint_url: str
+    access_key: str
+    secret_key: str
+    port: int
+    bucket: str
+    secure: bool = False
+
+
+class CoreStorageSettingsSchema(BaseModel):
+    """
+    Схема настроек хранилища.
+    """
+
+    provider: Literal['local', 's3'] = 'local'
+
+    dir: Path = Path(__file__).resolve().parent.parent / 'storage'
+    s3: CoreS3SettingsSchema | None = None
+
+
+class CoreElasticsearchSettingsSchema(BaseModel):
+    """
+    Схема настроек Elasticsearch.
+    """
+
+    host: str
+    port: int
+    scheme: str
+    username: str
+    password: str
+    cluster_name: str
+
+    cacert: str | None = None
+    security: bool = False
+    ssl: bool = False
+
+
+class CoreSearchSettingsSchema(BaseModel):
+    """
+    Схема настроек движка поиска.
+    """
+
+    provider: Literal['elasticsearch', 'open_search'] = 'elasticsearch'
+    elasticsearch: CoreElasticsearchSettingsSchema | None = None
+
+
+class CoreKafkaSettingsSchema(BaseModel):
+    """
+    Схема настроек Kafka.
+    """
+
+    bootstrap_servers: str
+    group_id: str
+    credentials: Literal['SSL', 'SASL'] | None = None
+    # For SSL
+    cert_file: str | None = None
+    ca_file: str | None = None
+    key_file: str | None = None
+    password: str | None = None
+    # For SASL
+    broker_username: str | None = None
+    broker_password: str | None = None
+
+    @model_validator(mode='after')
+    def validate_credentials(self: Self) -> Self:
+        """
+        Проверяем на правильность заполнение параметров для авторизации.
+        """
+        match self.credentials:
+            case 'SSL':
+                for field in ('ca_file', 'cert_file', 'key_file'):
+                    assert bool(getattr(self, field)), f'{field} must be set when credentials={self.credentials}'
+            case 'SASL':
+                for field in ('broker_username', 'broker_password'):
+                    assert bool(getattr(self, field)), f'{field} must be set when credentials={self.credentials}'
+            case _:
+                ...
+        return self
+
+
+class CoreServiceSettingsSchema(BaseModel):
+    """
+    Схема настроек доступа к сервису.
+    """
+
+    host: str
+    user: str | None = None
+    password: str | None = None
+
+
+class CoreTopicSettingsSchema(BaseModel):
+    """
+    Схема настроек топика.
+    """
+
+    name: str
+    auto_offset_reset: Literal['latest', 'earliest', 'none'] = 'latest'
+
+
+class BaseSettingsSchema(PydanticBaseSettings):
+    """
+    Схема настроек с возможностью поиска через репозиторий.
+    """
+
+    descendant_types: ClassVar[list[type[BaseSettingsSchema]]] = []
+
+    def __init_subclass__(cls, **kwargs: Unpack[ConfigDict]) -> None:
+        """
+        Добавляем настройки в репозиторий.
+        """
+        cls.descendant_types.append(cls)
+
+        return super().__init_subclass__(**kwargs)
+
+
+class CoreSettingsSchema(BaseSettingsSchema):
+    """
+    Схема базовых настроек приложения.
+    """
+
+    debug: bool
+    title: str
+    base_url: str
+    base_dir: Path = Path(os.getcwd())
+    secret_key: str
+    cors_origins: list[str]
+    redis_dsn: RedisDsn | None = None
+
+    model_config = SettingsConfigDict(
+        env_file='.env',
+        env_file_encoding='utf-8',
+        env_nested_delimiter='__',
+        case_sensitive=False,
+        extra='ignore',
+    )

fast_clean/tools/__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/tools/cryptography.py

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

fast_clean/tools/load_seed.py

@@ -0,0 +1,31 @@
+"""
+Модуль, содержащий команды загрузки данных из файлов.
+"""
+
+from typing import Annotated
+
+import typer
+
+from fast_clean.depends import get_container
+from fast_clean.services import SeedServiceProtocol
+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: SeedServiceProtocol = await container.get_by_type(SeedServiceProtocol)
+        await seed_service.load_data(path)
+
+
+def use_load_seed(app: typer.Typer) -> None:
+    """
+    Регистрируем команды загрузки данных из файлов.
+    """
+
+    app.command()(load_seed)

fast_clean/use_cases.py

@@ -0,0 +1,38 @@
+"""
+Модуль, содержащий варианты использования.
+"""
+
+from __future__ import annotations
+
+from types import new_class
+from typing import Any, Protocol, TypeVar, cast
+
+UseCaseResultSchemaType = TypeVar('UseCaseResultSchemaType', covariant=True)
+
+
+class UseCaseProtocol(Protocol[UseCaseResultSchemaType]):
+    """
+    Протокол варианта использования.
+    """
+
+    async def __call__(self) -> UseCaseResultSchemaType:
+        """
+        Вызываем вариант использования.
+        """
+        ...
+
+    def __class_getitem__(cls, params: type | tuple[type, ...]) -> type:
+        """
+        Создаем уникальный класс.
+
+        По умолчанию одинаковые обобщенные классы указывают на один и тот же _GenericAlias.
+        Из-за данного поведения поиск по типу становится невозможным.
+
+            UseCaseA = UseCaseProtocol[None]
+            UseCaseB = UseCaseProtocol[None]
+            assert UseCaseA is UseCaseB
+
+        Поэтому вместо _GenericAlias возвращаем уникального наследника.
+        """
+        generic_alias = cast(Any, super()).__class_getitem__(params)
+        return new_class(cls.__name__, (generic_alias,))

fast_clean/utils/__init__.py

@@ -0,0 +1,15 @@
+"""
+Пакет, содержащий вспомогательные функции и классы.
+"""
+
+from .process import run_in_processpool as run_in_processpool
+from .pydantic import rebuild_schemas as rebuild_schemas
+from .ssl_context import CertificateSchema as CertificateSchema
+from .ssl_context import make_ssl_context as make_ssl_context
+from .string import decode_base64 as decode_base64
+from .string import encode_base64 as encode_base64
+from .string import make_random_string as make_random_string
+from .thread import run_in_threadpool as run_in_threadpool
+from .time import ts_now as ts_now
+from .type_converters import str_to_bool as str_to_bool
+from .typer import typer_async as typer_async