aiogram-tool 1.2.2__py3-none-any.whl

aiogram_tool/storage/__init__.py

@@ -0,0 +1,15 @@
+from .impl.file import FileLockStorage, FileStorage
+from .impl.memory import (
+    MemoryLockStorage,
+    MemoryStorage,
+)
+from .impl.redis import AsyncRedisLockStorage, AsyncRedisStorage
+
+__all__ = [
+    "FileStorage",
+    "MemoryStorage",
+    "AsyncRedisStorage",
+    "MemoryLockStorage",
+    "FileLockStorage",
+    "AsyncRedisLockStorage",
+]

aiogram_tool/storage/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from contextlib import AbstractAsyncContextManager
+
+from aiogram_tool.types import _MISSING
+
+
+class BaseStorage(ABC):
+    @abstractmethod
+    async def set_value(self, key: str, value: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_value(self, key: str) -> str | _MISSING:
+        raise NotImplementedError
+
+
+class BaseLockStorage(BaseStorage):
+    @abstractmethod
+    async def lock(self, key: str) -> AbstractAsyncContextManager[None]:
+        raise NotImplementedError

aiogram_tool/storage/impl/file.py

@@ -0,0 +1,72 @@
+import os
+from asyncio import Lock
+from collections.abc import MutableMapping
+
+import aiofiles
+
+from aiogram_tool.storage.base import BaseLockStorage
+from aiogram_tool.storage.impl.memory import MemoryStorage
+from aiogram_tool.types import _MISSING
+
+
+class FileStorage(MemoryStorage):
+    def __init__(self, file: str, storage: MutableMapping | None = None) -> None:
+        if not os.path.exists(file):
+            raise FileNotFoundError(f"File {file} not found")
+
+        self.file = file
+
+        self._is_memory = False
+        if storage is not None:
+            self._is_memory = True
+            super().__init__(storage=storage)
+
+    async def set_value(self, key: str, value: str) -> None:
+        if "&" in key:
+            raise ValueError(f"Symbol & can't use in key {key}")
+
+        async with aiofiles.open(self.file, "a") as aiofile:
+            await aiofile.write(f"\n{key}&{value}")
+
+        if self._is_memory:
+            await super().set_value(key=key, value=value)
+
+    async def get_value(self, key: str) -> str | _MISSING:
+        if self._is_memory:
+            value = await super().get_value(key=key)
+            if value:
+                return value
+
+        async with aiofiles.open(self.file) as aiofile:
+            data = await aiofile.readlines()
+            data.reverse()
+
+        for line in data:
+            line = line.strip()
+            if not line:
+                continue
+
+            line_key, line_value = line.split(sep="&", maxsplit=1)
+            if line_key == key:
+                if self._is_memory:
+                    await super().set_value(key, line_value)
+                return line_value
+        return _MISSING
+
+
+class FileLockStorage(FileStorage, BaseLockStorage):
+    def __init__(
+        self,
+        file: str,
+        storage: MutableMapping | None = None,
+        locks_storage: MutableMapping | None = None,
+    ) -> None:
+        self.global_lock = Lock()
+        self.locks = locks_storage if locks_storage is not None else {}
+        super().__init__(file=file, storage=storage)
+
+    async def lock(self, key: str) -> Lock:
+        async with self.global_lock:
+            if key not in self.locks.keys():
+                self.locks[key] = Lock()
+            return self.locks[key]

aiogram_tool/storage/impl/memory.py

@@ -0,0 +1,33 @@
+from asyncio import Lock
+from collections.abc import MutableMapping
+
+from aiogram_tool.storage.base import BaseLockStorage, BaseStorage
+from aiogram_tool.types import _MISSING
+
+
+class MemoryStorage(BaseStorage):
+    def __init__(self, storage: MutableMapping | None = None) -> None:
+        self.storage = storage if storage is not None else {}
+
+    async def set_value(self, key: str, value: str) -> None:
+        self.storage[key] = value
+
+    async def get_value(self, key: str) -> str | _MISSING:
+        return self.storage.get(key, _MISSING)
+
+
+class MemoryLockStorage(MemoryStorage, BaseLockStorage):
+    def __init__(
+        self,
+        storage: MutableMapping | None = None,
+        locks_storage: MutableMapping | None = None,
+    ) -> None:
+        self.global_lock = Lock()
+        self.locks = locks_storage if locks_storage is not None else {}
+        super().__init__(storage=storage)
+
+    async def lock(self, key: str) -> Lock:
+        async with self.global_lock:
+            if key not in self.locks.keys():
+                self.locks[key] = Lock()
+            return self.locks[key]

aiogram_tool/storage/impl/redis.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+from redis.asyncio import Redis as AsyncRedis
+from redis.asyncio.lock import Lock as RedisLock
+
+from aiogram_tool.storage.base import BaseLockStorage, BaseStorage
+from aiogram_tool.types import _MISSING
+
+
+class AsyncRedisStorage(BaseStorage):
+    def __init__(self, redis: AsyncRedis, expire: int | None = None) -> None:
+        self.redis = redis
+        self.expire = expire
+
+    async def get_value(self, key: str) -> str | _MISSING:
+        value = await self.redis.get(name=key)
+        if value is not None:
+            return value.decode() if isinstance(value, bytes) else value
+        return _MISSING
+
+    async def set_value(self, key: str, value: Any) -> None:
+        await self.redis.set(name=key, value=value, ex=self.expire)
+
+
+class AsyncRedisLockStorage(AsyncRedisStorage, BaseLockStorage):
+    def __init__(
+        self,
+        redis: AsyncRedis,
+        expire: int | None = None,
+    ) -> None:
+        super().__init__(redis=redis, expire=expire)
+
+    async def lock(self, key: str) -> RedisLock:
+        lock_key = f"aigram_tool_lock:{key}"
+        return self.redis.lock(
+            name=lock_key,
+            timeout=10,
+            blocking_timeout=10,
+        )

aiogram_tool/tools/callback_data/__init__.py

@@ -0,0 +1,4 @@
+from .answer import CallbackDataAnswer
+from .filter import LongCallbackData
+
+__all__ = ["LongCallbackData", "CallbackDataAnswer"]

aiogram_tool/tools/callback_data/answer.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+from aiogram.types import CallbackQuery
+
+
+class CallbackDataAnswer:
+    """Called when callback data for the button is not found."""
+
+    async def __call__(self, query: CallbackQuery) -> Any:
+        await query.answer(text="Button expired", show_alert=True)

aiogram_tool/tools/callback_data/filter.py

@@ -0,0 +1,120 @@
+import secrets
+from typing import Any, ClassVar, Self
+
+from aiogram.filters.callback_data import CallbackData, CallbackQueryFilter
+from aiogram.types import CallbackQuery
+from magic_filter import MagicFilter
+
+from aiogram_tool.storage.base import BaseStorage
+from aiogram_tool.storage.impl.memory import MemoryStorage
+from aiogram_tool.tools.callback_data.answer import CallbackDataAnswer
+from aiogram_tool.types import _MISSING
+
+UNIQUE_PREFIX: str = "UIDPR"
+STORAGE_PREFIX: str = "aiot_callback_data"
+
+
+class _UniqueIDCallbackData(CallbackData, prefix=UNIQUE_PREFIX):
+    unique_id: str
+    callback_data_prefix: str
+
+    @classmethod
+    def build(cls, callback_data: type[CallbackData]) -> Self:
+        separators_len = len(cls.__separator__) * len(cls.model_fields)
+        unique_id_len = (
+            64 - (len(UNIQUE_PREFIX) + len(callback_data.__prefix__) + separators_len)
+        ) // 2
+
+        if unique_id_len < 6:
+            raise ValueError(
+                f"Prefix '{callback_data.__prefix__}' at {callback_data.__name__} is too long. "
+                f"Unique id must be at least 6 bytes (12 chars)."
+            )
+
+        return cls(
+            unique_id=secrets.token_hex(unique_id_len),
+            callback_data_prefix=callback_data.__prefix__,
+        )
+
+    def get_storage_key(self) -> str:
+        return f"{STORAGE_PREFIX}@{self.unique_id}"
+
+
+class LongCallbackQueryFilter(CallbackQueryFilter):
+    async def __call__(self, query: CallbackQuery) -> bool | dict[str, Any]:
+        if not isinstance(query, CallbackQuery) or not query.data:
+            return False
+
+        try:
+            instance = _UniqueIDCallbackData.unpack(query.data)
+        except (TypeError, ValueError):
+            try:
+                instance = self.callback_data.unpack(query.data)
+            except (TypeError, ValueError):
+                return False
+
+        if isinstance(instance, _UniqueIDCallbackData):
+            if instance.callback_data_prefix != self.callback_data.__prefix__:
+                return False
+
+            storage: BaseStorage = self.callback_data._storage
+            answer_callback: CallbackDataAnswer = self.callback_data._answer_callback
+
+            packed_callback_data = await storage.get_value(
+                key=instance.get_storage_key()
+            )
+            if packed_callback_data is _MISSING:
+                await answer_callback(query)
+                return False
+            try:
+                instance = self.callback_data.unpack(packed_callback_data)
+            except (TypeError, ValueError):
+                return False
+
+        if self.rule is None or self.rule.resolve(instance):
+            return {"callback_data": instance}
+        return False
+
+
+class LongCallbackData(CallbackData, prefix="?"):
+    """Class registering long callback data
+
+    _storage - storage for long values\n
+    _answer_callback - A callback that triggers if the callback data for the button is not found in the storage.
+    """
+
+    _storage: ClassVar[BaseStorage] = MemoryStorage()
+    _answer_callback: ClassVar[CallbackDataAnswer] = CallbackDataAnswer()
+
+    def _pack_without_errors(self) -> str:
+        result = [self.__prefix__]
+        for key, value in self.model_dump(mode="python").items():
+            encoded = self._encode_value(key, value)
+            result.append(encoded)
+        return self.__separator__.join(result)
+
+    async def pack_long(self) -> str:
+        """A method that catches the long-data error
+
+        Returns:
+            str: A unique ID generated if a "long data" error was caught
+             or resulting from the call to the parent `pack` method.
+        """
+
+        try:
+            return super().pack()
+        except ValueError as ex:
+            if "data is too long!" in str(ex):
+                callback_data_instance = _UniqueIDCallbackData.build(
+                    callback_data=self.__class__
+                )
+                await self._storage.set_value(
+                    key=callback_data_instance.get_storage_key(),
+                    value=self._pack_without_errors(),
+                )
+                return callback_data_instance.pack()
+            raise ex
+
+    @classmethod
+    def filter(cls, rule: MagicFilter | None = None) -> LongCallbackQueryFilter:
+        return LongCallbackQueryFilter(callback_data=cls, rule=rule)

aiogram_tool/tools/depend/__init__.py

@@ -0,0 +1,16 @@
+from .components.exit import DependExit
+from .components.filter import DependFilter
+from .depend import Depends, From
+from .tool import DependTool
+from .types.enums import Scope
+from .utils.scope_registry import ScopeRegistry
+
+__all__ = [
+    "Depends",
+    "From",
+    "DependExit",
+    "DependFilter",
+    "ScopeRegistry",
+    "Scope",
+    "DependTool",
+]

aiogram_tool/tools/depend/components/exit.py

@@ -0,0 +1,4 @@
+class DependExit(Exception):
+    """If an error occurs in a dependency, the handler will not be called."""
+
+    ...

aiogram_tool/tools/depend/components/filter.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+from aiogram import Dispatcher
+from aiogram.filters import Filter
+
+from aiogram_tool.tools.depend.depend import From
+from aiogram_tool.tools.depend.tool import DependTool
+from aiogram_tool.tools.depend.types.exceptions import (
+    InvalidDependencyError,
+    NotFoundDependTool,
+)
+from aiogram_tool.tools.depend.utils.registry_manager import DependRegistryTransaction
+from aiogram_tool.tools.depend.utils.resolver import DependResolver
+from aiogram_tool.tools.depend.utils.stack_manager import AsyncExitStackTransaction
+
+from .exit import DependExit
+
+
+class DependFilter(Filter):
+    """This class allows invoking a dependency at the filter level."""
+
+    def __init__(self, *dependencies: From) -> None:
+        for dep in dependencies:
+            if not isinstance(dep, From):
+                raise InvalidDependencyError(f"Invalid type in dependency {dep}")
+
+        self._dependencies = dependencies
+
+    def get_depend_tool(self, data: dict[str, Any]) -> DependTool:
+        dispatcher: Dispatcher = data.get("dispatcher")
+        depend_tool = dispatcher.workflow_data.get("depend_tool")
+
+        if not isinstance(depend_tool, DependTool):
+            raise NotFoundDependTool("Not found DependTool. Add it in setup")
+        return depend_tool
+
+    def get_transactions(
+        self, data: dict[str, Any]
+    ) -> tuple[DependRegistryTransaction, AsyncExitStackTransaction]:
+        return data.get("request_registry"), data.get("request_stack")
+
+    async def __call__(self, *args, **kwargs) -> bool:
+        depend_tool = self.get_depend_tool(kwargs)
+        req_registry, req_stack = self.get_transactions(kwargs)
+
+        resolver = DependResolver(
+            handler_callback=lambda: 1,
+            registry=req_registry,
+            stack=req_stack,
+            scope_registry=depend_tool.scope_registry,
+            middleware_data=kwargs.copy(),
+            dependency_override=depend_tool.dependency_override,
+        )
+        for depend in self._dependencies:
+            scope_object = depend_tool.scope_registry.get_scope_object(depend)
+            try:
+                params = await resolver.resolve_depend_params(
+                    scope_object=scope_object, resolved_depends=set()
+                )
+                await resolver.depend_call(scope_object=scope_object, params=params)
+            except DependExit:
+                return False
+        return True

aiogram_tool/tools/depend/components/inner_middleware.py

@@ -0,0 +1,54 @@
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+from aiogram.dispatcher.middlewares.base import BaseMiddleware
+from aiogram.types.base import TelegramObject
+
+from aiogram_tool.tools.depend.utils.registry_manager import DependRegistryTransaction
+from aiogram_tool.tools.depend.utils.resolver import DependResolver
+from aiogram_tool.tools.depend.utils.stack_manager import AsyncExitStackTransaction
+
+from .exit import DependExit
+
+if TYPE_CHECKING:
+    from aiogram_tool.tools.depend.tool import DependTool
+
+
+class DependInnerMiddleware(BaseMiddleware):
+    """Class that injects dependencies into the handler"""
+
+    def __init__(self, depend_tool: "DependTool") -> None:
+        self.depend_tool = depend_tool
+
+    def get_transactions(
+        self, data: dict[str, Any]
+    ) -> tuple[DependRegistryTransaction, AsyncExitStackTransaction]:
+        return data.get("request_registry"), data.get("request_stack")
+
+    def get_handler_callback(self, data: dict[str, Any]) -> Callable:
+        return data["handler"].callback
+
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: dict[str, Any],
+    ) -> Any:
+        handler_callback = self.get_handler_callback(data)
+        req_registry, req_stack = self.get_transactions(data)
+
+        resolver = DependResolver(
+            dependency_override=self.depend_tool.dependency_override,
+            scope_registry=self.depend_tool.scope_registry,
+            handler_callback=handler_callback,
+            registry=req_registry,
+            stack=req_stack,
+            middleware_data=data.copy(),
+        )
+        try:
+            inject_params = await resolver.resolve_callback_depends()
+        except DependExit:
+            return
+
+        data.update(inject_params)
+        return await handler(event, data)

aiogram_tool/tools/depend/components/outer_middleware.py

@@ -0,0 +1,27 @@
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+from aiogram.dispatcher.middlewares.base import BaseMiddleware
+from aiogram.types import TelegramObject
+
+if TYPE_CHECKING:
+    from aiogram_tool.tools.depend.tool import DependTool
+
+
+class DependOuterMiddleware(BaseMiddleware):
+    def __init__(self, depend_tool: "DependTool") -> None:
+        self.depend_tool = depend_tool
+
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: dict[str, Any],
+    ) -> Any:
+        data["context"] = event
+        async with self.depend_tool.registry.transaction() as req_registry:
+            async with self.depend_tool.stack_manager.transaction() as req_stack:
+                data.update(
+                    {"request_registry": req_registry, "request_stack": req_stack}
+                )
+                return await handler(event, data)

aiogram_tool/tools/depend/depend.py

@@ -0,0 +1,20 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from aiogram_tool.tools.depend.types.enums import Scope
+from aiogram_tool.tools.depend.types.exceptions import CallableError
+from aiogram_tool.types import _MISSING
+
+
+@dataclass(frozen=True)
+class From:
+    depend: Callable
+    scope: Scope | _MISSING = _MISSING
+
+    def __post_init__(self) -> None:
+        if not callable(self.depend):
+            raise CallableError(f"object {self.depend} is not callable")
+
+
+def Depends(depend: Callable, *, scope: Scope | _MISSING = _MISSING) -> From:
+    return From(depend=depend, scope=scope)

aiogram_tool/tools/depend/storage/memory.py

@@ -0,0 +1,29 @@
+from asyncio import Lock
+from collections.abc import Callable, MutableMapping
+from typing import Any
+
+from aiogram_tool.types import _MISSING
+
+
+class DependencyMemoryStorage:
+    def __init__(self) -> None:
+        self.storage: MutableMapping = {}
+
+    async def get_value(self, key: Callable) -> Any | _MISSING:
+        return self.storage.get(key, _MISSING)
+
+    async def set_value(self, key: Callable, value: Any) -> None:
+        self.storage[key] = value
+
+
+class DependencyMemoryLockStorage(DependencyMemoryStorage):
+    def __init__(self):
+        self.global_lock = Lock()
+        self.locks: MutableMapping = {}
+        super().__init__()
+
+    async def lock(self, key: Callable) -> Lock:
+        async with self.global_lock:
+            if key not in self.locks.keys():
+                self.locks[key] = Lock()
+            return self.locks[key]

aiogram_tool/tools/depend/tool.py

@@ -0,0 +1,72 @@
+from collections.abc import Callable
+
+from aiogram import Dispatcher
+from aiogram.dispatcher.event.telegram import TelegramEventObserver
+
+from aiogram_tool.tools.depend.types.exceptions import (
+    DependencyOverrideError,
+    ObserverError,
+)
+from aiogram_tool.tools.depend.utils.registry_manager import (
+    DependRegistryTransactionManager,
+)
+from aiogram_tool.tools.depend.utils.scope_registry import ScopeRegistry
+from aiogram_tool.tools.depend.utils.stack_manager import (
+    AsyncExitStackTransactionManager,
+)
+from aiogram_tool.tools.setup import BaseTool
+
+from .components.inner_middleware import DependInnerMiddleware
+from .components.outer_middleware import DependOuterMiddleware
+from .depend import From
+
+
+class DependTool(BaseTool):
+    """Class for register dependency middlewares"""
+
+    def __init__(
+        self,
+        dependency_override: dict[Callable, From] | None = None,
+        allowed_updates: list[str] | None = None,
+        scope_registry: ScopeRegistry | None = None,
+    ) -> None:
+        if dependency_override is not None:
+            for key, depend in dependency_override.items():
+                error_msg = None
+                if not callable(key):
+                    error_msg = f"Key {key} in dependency override must be callable"
+
+                if not isinstance(depend, From):
+                    error_msg = f"Invalid type in dependency_override {depend}"
+
+                if error_msg is not None:
+                    raise DependencyOverrideError(error_msg)
+
+        self.dependency_override = dependency_override or {}
+        self.allowed_updates = allowed_updates
+        self.scope_registry = scope_registry or ScopeRegistry()
+        self.registry = DependRegistryTransactionManager()
+        self.stack_manager = AsyncExitStackTransactionManager()
+
+    async def shutdown(self) -> None:
+        await self.stack_manager.stack.aclose()
+
+    def setup(self, dispatcher: Dispatcher) -> None:
+        dispatcher.shutdown.register(self.shutdown)
+        dispatcher.workflow_data["depend_tool"] = self
+
+        updates = (
+            self.allowed_updates
+            if self.allowed_updates is not None
+            else dispatcher.resolve_used_update_types()
+        )
+        inner_middleware = DependInnerMiddleware(depend_tool=self)
+        outer_middleware = DependOuterMiddleware(depend_tool=self)
+
+        for update in updates:
+            observer: TelegramEventObserver = dispatcher.observers.get(update, None)
+            if observer is None:
+                raise ObserverError(f"Invalid observer {update}")
+
+            observer.outer_middleware(outer_middleware)
+            observer.middleware(inner_middleware)

aiogram_tool/tools/depend/types/enums.py

@@ -0,0 +1,15 @@
+from enum import Enum, auto
+
+
+class Scope(Enum):
+    """Scopes for dependecies
+
+    Args:
+        SINGLETON - caching of the dependency result at the full lifecycle level
+        REQUEST - caching of a dependency result at the level of a single user request
+        TRANSIENT - Dependence is triggered every time.
+    """
+
+    SINGLETON = auto()
+    REQUEST = auto()
+    TRANSIENT = auto()

aiogram_tool/tools/depend/types/exceptions.py

@@ -0,0 +1,25 @@
+class DependencyOverrideError(Exception): ...
+
+
+class ObserverError(Exception): ...
+
+
+class CallableError(Exception): ...
+
+
+class DependRecursionError(Exception): ...
+
+
+class UnsupportedParameterKindError(Exception): ...
+
+
+class InvalidMiddlewareDataArgumentError(Exception): ...
+
+
+class ContextManagerError(Exception): ...
+
+
+class InvalidDependencyError(Exception): ...
+
+
+class NotFoundDependTool(Exception): ...