telegrinder 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

telegrinder/bot/dispatch/__init__.py

@@ -36,7 +36,19 @@ from telegrinder.bot.dispatch.view import (
     RawEventView,
     ViewBox,
 )
-from telegrinder.bot.dispatch.waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    ShortState,
+    StateViewHasher,
+    WaiterMachine,
+    clear_wm_storage_worker,
+)
 
 __all__ = (
     "ABCDispatch",
@@ -49,6 +61,9 @@ __all__ = (
     "BaseReturnManager",
     "BaseStateView",
     "BaseView",
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
     "ChatJoinRequestView",
@@ -57,8 +72,12 @@ __all__ = (
     "Dispatch",
     "DocumentReplyHandler",
     "FuncHandler",
+    "Hasher",
     "InlineQueryReturnManager",
     "InlineQueryView",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
     "Manager",
     "MediaGroupReplyHandler",
     "MessageReplyHandler",
@@ -67,6 +86,7 @@ __all__ = (
     "PhotoReplyHandler",
     "RawEventView",
     "ShortState",
+    "StateViewHasher",
     "StickerReplyHandler",
     "TelegrinderContext",
     "VideoReplyHandler",
@@ -74,6 +94,7 @@ __all__ = (
     "WaiterMachine",
     "check_rule",
     "clear_wm_storage_worker",
+    "clear_wm_storage_worker",
     "process_inner",
     "register_manager",
 )

telegrinder/bot/dispatch/abc.py

@@ -1,10 +1,14 @@
 import typing
 from abc import ABC, abstractmethod
 
+from fntypes import Option
+
 from telegrinder.api.api import API
 from telegrinder.tools.global_context.abc import ABCGlobalContext
 from telegrinder.types.objects import Update
 
+T = typing.TypeVar("T")
+
 
 class ABCDispatch(ABC):
     @property
@@ -24,5 +28,8 @@ class ABCDispatch(ABC):
         for external in externals:
             self.load(external)
 
+    @abstractmethod
+    def get_view(self, of_type: type[T]) -> Option[T]: ...
+
 
 __all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/dispatch.py

@@ -1,6 +1,7 @@
 import dataclasses
 import typing
 
+from fntypes import Nothing, Option, Some
 from vbml.patcher import Patcher
 
 from telegrinder.api.api import API
@@ -188,6 +189,12 @@ class Dispatch(
             view.load(view_external[name])
             setattr(external, name, view)
 
+    def get_view(self, of_type: type[T]) -> Option[T]:
+        for view in self.get_views().values():
+            if isinstance(view, of_type):
+                return Some(view)
+        return Nothing()
+
     __call__ = handle
 
 

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,9 +1,27 @@
+from telegrinder.bot.dispatch.waiter_machine.hasher import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    StateViewHasher,
+)
 from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine, clear_wm_storage_worker
 from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import ShortState
 
 __all__ = (
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
+    "Hasher",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
     "ShortState",
+    "StateViewHasher",
     "WaiterMachine",
     "WaiterMiddleware",
     "clear_wm_storage_worker",

telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -0,0 +1,10 @@
+import typing
+
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+
+from .short_state import EventModel, ShortState
+
+
+class WaiterActions(typing.TypedDict, typing.Generic[EventModel]):
+    on_miss: typing.NotRequired[ABCHandler[EventModel]]
+    on_drop: typing.NotRequired[typing.Callable[[ShortState[EventModel]], None]]

telegrinder/bot/dispatch/waiter_machine/hasher/__init__.py

@@ -0,0 +1,15 @@
+from .callback import CALLBACK_QUERY_FOR_MESSAGE, CALLBACK_QUERY_FROM_CHAT, CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE
+from .hasher import Hasher
+from .message import MESSAGE_FROM_USER, MESSAGE_FROM_USER_IN_CHAT, MESSAGE_IN_CHAT
+from .state import StateViewHasher
+
+__all__ = (
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
+    "Hasher",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
+    "StateViewHasher",
+)

telegrinder/bot/dispatch/waiter_machine/hasher/callback.py

@@ -0,0 +1,60 @@
+from fntypes import Some
+
+from telegrinder.bot.cute_types import CallbackQueryCute as CallbackQuery
+from telegrinder.bot.dispatch.view import CallbackQueryView
+
+from .hasher import Hasher
+
+
+def from_chat_hash(chat_id: int) -> int:
+    return chat_id
+
+
+def get_chat_from_event(event: CallbackQuery) -> int | None:
+    return event.chat.and_then(lambda chat: Some(chat.id)).unwrap_or_none()
+
+
+CALLBACK_QUERY_FROM_CHAT = Hasher(
+    view=CallbackQueryView,
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
+
+def for_message_hash(message_id: int) -> int:
+    return message_id
+
+
+def get_message_for_event(event: CallbackQuery) -> int | None:
+    return event.message_id.unwrap_or_none()
+
+
+CALLBACK_QUERY_FOR_MESSAGE = Hasher(
+    view=CallbackQueryView,
+    get_hash_from_data=for_message_hash,
+    get_data_from_event=get_message_for_event,
+)
+
+
+def for_message_in_chat(chat_and_message: tuple[int, int]) -> str:
+    return f"{chat_and_message[0]}_{chat_and_message[1]}"
+
+
+def get_chat_and_message_for_event(event: CallbackQuery) -> tuple[int, int] | None:
+    if not event.message_id or not event.chat:
+        return None
+    return event.chat.unwrap().id, event.message_id.unwrap()
+
+
+CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE = Hasher(
+    view=CallbackQueryView,
+    get_hash_from_data=for_message_in_chat,
+    get_data_from_event=get_chat_and_message_for_event,
+)
+
+
+__all__ = (
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
+)

telegrinder/bot/dispatch/waiter_machine/hasher/hasher.py

@@ -0,0 +1,49 @@
+import typing
+
+from fntypes import Option
+
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.tools.functional import from_optional
+
+Event = typing.TypeVar("Event", bound=BaseCute)
+Data = typing.TypeVar("Data")
+
+ECHO = lambda x: x
+
+
+class Hasher(typing.Generic[Event, Data]):
+    def __init__(
+        self,
+        view: type[BaseView[Event]],
+        get_hash_from_data: typing.Callable[[Data], typing.Hashable | None] | None = None,
+        get_data_from_event: typing.Callable[[Event], Data | None] | None = None,
+    ):
+        self.view = view
+        self._get_hash_from_data = get_hash_from_data
+        self._get_data_from_event = get_data_from_event
+
+    def get_name(self) -> str:
+        return f"{self.view.__class__.__name__}_{id(self)}"
+
+    def get_hash_from_data(self, data: Data) -> Option[typing.Hashable]:
+        if self._get_hash_from_data is None:
+            raise NotImplementedError
+        return from_optional(self._get_hash_from_data(data))
+
+    def get_data_from_event(self, event: Event) -> Option[Data]:
+        if not self._get_data_from_event:
+            raise NotImplementedError
+        return from_optional(self._get_data_from_event(event))
+
+    def get_hash_from_data_from_event(self, event: Event) -> Option[typing.Hashable]:
+        return self.get_data_from_event(event).and_then(self.get_hash_from_data)  # type: ignore
+
+    def __hash__(self) -> int:
+        return hash(self.get_name())
+
+    def __repr__(self) -> str:
+        return f"<Hasher {self.get_name()}>"
+
+
+__all__ = ("Hasher",)

telegrinder/bot/dispatch/waiter_machine/hasher/message.py

@@ -0,0 +1,54 @@
+from telegrinder.bot.cute_types import MessageCute as Message
+from telegrinder.bot.dispatch.view import MessageView
+
+from .hasher import Hasher
+
+
+def from_chat_hash(chat_id: int) -> int:
+    return chat_id
+
+
+def get_chat_from_event(event: Message) -> int:
+    return event.chat.id
+
+
+MESSAGE_IN_CHAT = Hasher(
+    view=MessageView, get_hash_from_data=from_chat_hash, get_data_from_event=get_chat_from_event
+)
+
+
+def from_user_hash(from_id: int) -> int:
+    return from_id
+
+
+def get_user_from_event(event: Message) -> int:
+    return event.from_user.id
+
+
+MESSAGE_FROM_USER = Hasher(
+    view=MessageView,
+    get_hash_from_data=from_user_hash,
+    get_data_from_event=get_user_from_event,
+)
+
+
+def from_user_in_chat_hash(chat_and_user: tuple[int, int]) -> str:
+    return f"{chat_and_user[0]}_{chat_and_user[1]}"
+
+
+def get_user_in_chat_from_event(event: Message) -> tuple[int, int]:
+    return event.chat.id, event.from_user.id
+
+
+MESSAGE_FROM_USER_IN_CHAT = Hasher(
+    view=MessageView,
+    get_hash_from_data=from_user_in_chat_hash,
+    get_data_from_event=get_user_in_chat_from_event,
+)
+
+
+__all__ = (
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
+)

telegrinder/bot/dispatch/waiter_machine/hasher/state.py

@@ -0,0 +1,19 @@
+from fntypes import Option
+
+from telegrinder.bot.dispatch.view import BaseStateView
+from telegrinder.tools.functional import from_optional
+
+from .hasher import ECHO, Event, Hasher
+
+
+class StateViewHasher(Hasher[Event, int]):
+    view: BaseStateView
+
+    def __init__(self, view: type[BaseStateView[Event]]):
+        super().__init__(view, get_hash_from_data=ECHO)
+
+    def get_data_from_event(self, event: Event) -> Option[int]:
+        return from_optional(self.view.get_state_key(event))
+
+
+__all__ = ("StateViewHasher",)

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -2,35 +2,42 @@ import asyncio
 import datetime
 import typing
 
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.view.abc import ABCStateView
-from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.view.base import BaseStateView, BaseView
 from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import (
-    Behaviour,
     EventModel,
     ShortState,
     ShortStateContext,
 )
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.limited_dict import LimitedDict
-from telegrinder.types import Update
 
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch import Dispatch
+from .actions import WaiterActions
+from .hasher import Hasher, StateViewHasher
 
 T = typing.TypeVar("T")
+HasherData = typing.TypeVar("HasherData")
 
-Identificator: typing.TypeAlias = str | int
-Storage: typing.TypeAlias = dict[str, LimitedDict[Identificator, ShortState[EventModel]]]
+
+Storage: typing.TypeAlias = dict[
+    Hasher[EventModel, HasherData], LimitedDict[typing.Hashable, ShortState[EventModel]]
+]
 
 WEEK: typing.Final[datetime.timedelta] = datetime.timedelta(days=7)
 
 
 class WaiterMachine:
-    def __init__(self, *, max_storage_size: int = 1000) -> None:
+    def __init__(
+        self,
+        dispatch: ABCDispatch | None = None,
+        *,
+        max_storage_size: int = 1000,
+        base_state_lifetime: datetime.timedelta = WEEK,
+    ) -> None:
+        self.dispatch = dispatch
         self.max_storage_size = max_storage_size
+        self.base_state_lifetime = base_state_lifetime
         self.storage: Storage = {}
 
     def __repr__(self) -> str:
@@ -46,142 +53,123 @@ class WaiterMachine:
 
     async def drop(
         self,
-        state_view: "ABCStateView[EventModel] | str",
-        id: Identificator,
-        event: EventModel,
-        update: Update,
+        hasher: Hasher[EventModel, HasherData],
+        id: HasherData,
         **context: typing.Any,
     ) -> None:
-        view_name = state_view if isinstance(state_view, str) else state_view.__class__.__name__
-        if view_name not in self.storage:
-            raise LookupError("No record of view {!r} found.".format(view_name))
+        if hasher not in self.storage:
+            raise LookupError("No record of hasher {!r} found.".format(hasher))
 
-        short_state = self.storage[view_name].pop(id, None)
+        waiter_id: typing.Hashable = hasher.get_hash_from_data(id).expect(
+            RuntimeError("Couldn't create hash from data")
+        )
+        short_state = self.storage[hasher].pop(waiter_id, None)
         if short_state is None:
-            raise LookupError("Waiter with identificator {} is not found for view {!r}".format(id, view_name))
+            raise LookupError(
+                "Waiter with identificator {} is not found for hasher {!r}".format(waiter_id, hasher)
+            )
+
+        if on_drop := short_state.actions.get("on_drop"):
+            on_drop(short_state, **context)
 
         short_state.cancel()
-        await self.call_behaviour(
-            event,
-            update,
-            behaviour=short_state.on_drop_behaviour,
-            **context,
-        )
 
     async def drop_all(self) -> None:
         """Drops all waiters in storage."""
 
-        for view_name in self.storage:
-            for ident, short_state in self.storage[view_name].items():
+        for hasher in self.storage:
+            for ident, short_state in self.storage[hasher].items():
                 if short_state.context:
                     await self.drop(
-                        view_name, ident, short_state.context.event, short_state.context.context.raw_update
+                        hasher,
+                        ident,
                     )
                 else:
                     short_state.cancel()
 
-    async def wait(
+    async def wait_from_event(
         self,
-        state_view: "BaseStateView[EventModel]",
-        linked: EventModel | tuple[API, Identificator],
-        *rules: ABCRule,
-        default: Behaviour[EventModel] | None = None,
-        on_drop: Behaviour[EventModel] | None = None,
-        exit: Behaviour[EventModel] | None = None,
-        expiration: datetime.timedelta | float | None = None,
+        view: BaseStateView[EventModel],
+        event: EventModel,
+        *,
+        filter: ABCRule | None = None,
+        release: ABCRule | None = None,
+        lifetime: datetime.timedelta | float | None = None,
+        **actions: typing.Unpack[WaiterActions],
     ) -> ShortStateContext[EventModel]:
-        if isinstance(expiration, int | float):
-            expiration = datetime.timedelta(seconds=expiration)
+        hasher = StateViewHasher(view.__class__)
+        return await self.wait(
+            hasher=hasher,
+            data=hasher.get_data_from_event(event).expect(
+                RuntimeError("Hasher couldn't create data from event.")
+            ),
+            filter=filter,
+            release=release,
+            lifetime=lifetime,
+            **actions,
+        )
 
-        api: API
-        key: Identificator
-        api, key = linked if isinstance(linked, tuple) else (linked.ctx_api, state_view.get_state_key(linked))  # type: ignore
-        if not key:
-            raise RuntimeError("Unable to get state key.")
+    async def wait(
+        self,
+        hasher: Hasher[EventModel, HasherData],
+        data: HasherData,
+        *,
+        filter: ABCRule | None = None,
+        release: ABCRule | None = None,
+        lifetime: datetime.timedelta | float | None = None,
+        **actions: typing.Unpack[WaiterActions],
+    ) -> ShortStateContext[EventModel]:
+        if isinstance(lifetime, int | float):
+            lifetime = datetime.timedelta(seconds=lifetime)
 
-        view_name = state_view.__class__.__name__
         event = asyncio.Event()
         short_state = ShortState[EventModel](
-            key,
-            api,
-            event,
-            rules,
-            expiration=expiration,
-            default_behaviour=default,
-            on_drop_behaviour=on_drop,
-            exit_behaviour=exit,
+            filter=filter,
+            release=release,
+            event=event,
+            lifetime=lifetime or self.base_state_lifetime,
+            actions=actions,
         )
+        waiter_hash = hasher.get_hash_from_data(data).expect(RuntimeError("Hasher couldn't create hash."))
 
-        if view_name not in self.storage:
-            state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
-            self.storage[view_name] = LimitedDict(maxlimit=self.max_storage_size)
+        if hasher not in self.storage:
+            if self.dispatch:
+                view: BaseView[EventModel] = self.dispatch.get_view(hasher.view).expect(
+                    RuntimeError(f"View {hasher.view.__name__} is not defined in dispatch")
+                )
+                view.middlewares.insert(0, WaiterMiddleware(self, hasher))
+            self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
 
-        if (deleted_short_state := self.storage[view_name].set(key, short_state)) is not None:
+        if (deleted_short_state := self.storage[hasher].set(waiter_hash, short_state)) is not None:
             deleted_short_state.cancel()
 
         await event.wait()
-        self.storage[view_name].pop(key, None)
+        self.storage[hasher].pop(waiter_hash, None)
         assert short_state.context is not None
         return short_state.context
 
-    async def call_behaviour(
-        self,
-        event: EventModel,
-        update: Update,
-        behaviour: Behaviour[EventModel] | None = None,
-        **context: typing.Any,
-    ) -> bool:
-        # TODO: support view as a behaviour
-
-        if behaviour is None:
-            return False
-
-        ctx = Context(**context)
-        if await behaviour.check(event.api, update, ctx):
-            await behaviour.run(event.api, event, ctx)
-            return True
-
-        return False
-
     async def clear_storage(
         self,
-        views: typing.Iterable[ABCStateView[EventModel]],
-        absolutely_dead_time: datetime.timedelta = WEEK,
     ) -> None:
-        """Clears storage.
+        """Clears storage."""
 
-        :param absolutely_dead_time: timedelta when state can be forgotten.
-        """
-
-        for view in views:
-            view_name = view.__class__.__name__
+        for hasher in self.storage:
             now = datetime.datetime.now()
-            for ident, short_state in self.storage.get(view_name, {}).copy().items():
+            for ident, short_state in self.storage.get(hasher, {}).copy().items():
                 if short_state.expiration_date is not None and now > short_state.expiration_date:
-                    assert short_state.context  # FIXME: why???
                     await self.drop(
-                        view,
+                        hasher,
                         ident,
-                        event=short_state.context.event,
-                        update=short_state.context.context.raw_update,
                         force=True,
                     )
-                elif short_state.creation_date + absolutely_dead_time < now:
-                    short_state.cancel()
-                    del self.storage[view_name][short_state.key]
 
 
 async def clear_wm_storage_worker(
     wm: WaiterMachine,
-    dp: "Dispatch",
     interval_seconds: int = 60,
-    absolutely_dead_time: datetime.timedelta = WEEK,
 ) -> typing.NoReturn:
     while True:
-        await wm.clear_storage(
-            views=[view for view in dp.get_views().values() if isinstance(view, ABCStateView)],
-            absolutely_dead_time=absolutely_dead_time,
-        )
+        await wm.clear_storage()
         await asyncio.sleep(interval_seconds)