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

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,34 +2,42 @@ import asyncio
 import datetime
 import typing
 
-from telegrinder.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.view.abc import ABCStateView, 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:
@@ -45,144 +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():
+        """Drops all waiters in storage."""
+
+        for hasher in self.storage:
+            for ident, short_state in self.storage[hasher].items():
                 if short_state.context:
                     await self.drop(
-                        view_name,
+                        hasher,
                         ident,
-                        short_state.context.event,
-                        short_state.context.context.raw_update
                     )
                 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)
 
 

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -5,8 +5,11 @@ from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-from telegrinder.bot.dispatch.view.abc import ABCStateView
+from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.dispatch.waiter_machine.short_state import ShortStateContext
+from telegrinder.modules import logger
+
+from .hasher import Hasher
 
 if typing.TYPE_CHECKING:
     from .machine import WaiterMachine
@@ -19,27 +22,21 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
     def __init__(
         self,
         machine: "WaiterMachine",
-        view: ABCStateView[EventType],
+        hasher: Hasher,
     ) -> None:
         self.machine = machine
-        self.view = view
+        self.hasher = hasher
 
     async def pre(self, event: EventType, ctx: Context) -> bool:
-        if not self.view or not hasattr(self.view, "get_state_key"):
-            raise RuntimeError(
-                "WaiterMiddleware cannot be used inside a view which doesn't "
-                "provide get_state_key (ABCStateView interface)."
-            )
-
-        view_name = self.view.__class__.__name__
-        if view_name not in self.machine.storage:
+        if self.hasher not in self.machine.storage:
             return True
 
-        key = self.view.get_state_key(event)
+        key = self.hasher.get_hash_from_data_from_event(event)
         if key is None:
-            raise RuntimeError("Unable to get state key.")
+            logger.info(f"Unable to get hash from event with hasher {self.hasher}")
+            return True
 
-        short_state: "ShortState[EventType] | None" = self.machine.storage[view_name].get(key)
+        short_state: "ShortState[EventType] | None" = self.machine.storage[self.hasher].get(key.unwrap())
         if not short_state:
             return True
 
@@ -47,35 +44,24 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if short_state.context is not None:
             preset_context.update(short_state.context.context)
 
-        if short_state.expiration_date is not None and datetime.datetime.now() >= short_state.expiration_date:
-            await self.machine.drop(
-                self.view,
-                short_state.key,
-                event,
-                ctx.raw_update,
-                **preset_context.copy(),
-            )
+        # Run filter rule
+        if short_state.filter and not await check_rule(
+            event.ctx_api, short_state.filter, ctx.raw_update, preset_context
+        ):
+            logger.debug("Filter rule {!r} failed", short_state.filter)
             return True
 
-        # before running the handler we check if the user wants to exit waiting
-        if short_state.exit_behaviour is not None and await self.machine.call_behaviour(
-            event,
-            ctx.raw_update,
-            behaviour=short_state.exit_behaviour,
-            **preset_context,
-        ):
+        if short_state.expiration_date is not None and datetime.datetime.now() >= short_state.expiration_date:
             await self.machine.drop(
-                self.view,
-                short_state.key,
-                event,
-                ctx.raw_update,
+                self.hasher,
+                self.hasher.get_data_from_event(event).unwrap(),
                 **preset_context.copy(),
             )
             return True
 
         handler = FuncHandler(
             self.pass_runtime,
-            list(short_state.rules),
+            [short_state.release] if short_state.release else [],
             dataclass=None,
             preset_context=preset_context,
         )
@@ -84,13 +70,9 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if result is True:
             await handler.run(event.api, event, ctx)
 
-        elif short_state.default_behaviour is not None:
-            await self.machine.call_behaviour(
-                event,
-                ctx.raw_update,
-                behaviour=short_state.default_behaviour,
-                **handler.preset_context,
-            )
+        elif on_miss := short_state.actions.get("on_miss"):  # noqa: SIM102
+            if await on_miss.check(event.ctx_api, ctx.raw_update, ctx):
+                await on_miss.run(event.ctx_api, event, ctx)
 
         return False
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -3,7 +3,6 @@ import dataclasses
 import datetime
 import typing
 
-from telegrinder.api import API
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
@@ -11,7 +10,8 @@ from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.model import Model
 
 if typing.TYPE_CHECKING:
-    from .machine import Identificator
+    from .actions import WaiterActions
+
 
 T = typing.TypeVar("T", bound=Model)
 EventModel = typing.TypeVar("EventModel", bound=BaseCute)
@@ -26,19 +26,19 @@ class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
 
 @dataclasses.dataclass(slots=True)
 class ShortState(typing.Generic[EventModel]):
-    key: "Identificator"
-    ctx_api: API
     event: asyncio.Event
-    rules: tuple[ABCRule, ...]
-    expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
+    actions: "WaiterActions"
+
+    release: ABCRule | None = None
+    filter: ABCRule | None = None
+    lifetime: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
         default=None,
         kw_only=True,
     )
-    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
-    on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
-    exit_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
+
     expiration_date: datetime.datetime | None = dataclasses.field(init=False, kw_only=True)
     creation_date: datetime.datetime = dataclasses.field(init=False)
+
     context: ShortStateContext[EventModel] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:

telegrinder/bot/polling/polling.py

@@ -5,7 +5,7 @@ import aiohttp
 import msgspec
 from fntypes.result import Error, Ok
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.api.error import InvalidTokenError
 from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
@@ -72,7 +72,10 @@ class Polling(ABCPolling):
     async def get_updates(self) -> msgspec.Raw | None:
         raw_updates = await self.api.request_raw(
             "getUpdates",
-            {"offset": self.offset, "allowed_updates": self.allowed_updates},
+            {
+                "offset": self.offset,
+                "allowed_updates": self.allowed_updates,
+            },
         )
         match raw_updates:
             case Ok(value):

telegrinder/bot/rules/__init__.py

@@ -83,7 +83,6 @@ __all__ = (
     "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "IsInteger",
     "IntegerInRange",
     "InviteLinkByCreator",
     "InviteLinkName",
@@ -96,6 +95,7 @@ __all__ = (
     "IsForward",
     "IsForwardType",
     "IsGroup",
+    "IsInteger",
     "IsLanguageCode",
     "IsPremium",
     "IsPrivate",
@@ -107,13 +107,13 @@ __all__ = (
     "Markup",
     "MessageEntities",
     "MessageRule",
+    "NodeRule",
     "NotRule",
     "OrRule",
     "Regex",
     "RuleEnum",
     "StartCommand",
-    "Text",
-    "NodeRule",
     "State",
     "StateMeta",
+    "Text",
 )

telegrinder/bot/rules/abc.py

@@ -118,12 +118,13 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         ctx: Context,
         node_col: "NodeCollection | None" = None,
     ) -> bool:
+        bound_check_rule = self.check
         kw = {}
         node_col_values = node_col.values if node_col is not None else {}
-        temp_ctx = get_default_args(self.check) | ctx
+        temp_ctx = get_default_args(bound_check_rule) | ctx
 
-        for i, (k, v) in enumerate(get_annotations(self.check).items()):
-            if (isinstance(adapted_value, Event) and not i) or (
+        for i, (k, v) in enumerate(get_annotations(bound_check_rule).items()):
+            if (isinstance(adapted_value, Event) and i == 0) or (  # First arg is Event
                 isinstance(v, type) and isinstance(adapted_value, v)
             ):
                 kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
@@ -140,14 +141,14 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
                     "because it cannot be resolved."
                 )
 
-        return await self.check(**kw)
+        return await bound_check_rule(**kw)
 
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self
 
 
 class AndRule(ABCRule):
-    def __init__(self, *rules: ABCRule[AdaptTo]) -> None:
+    def __init__(self, *rules: ABCRule) -> None:
         self.rules = rules
 
     async def check(self, event: Update, ctx: Context) -> bool:

telegrinder/bot/rules/adapter/__init__.py

@@ -7,8 +7,8 @@ from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 __all__ = (
     "ABCAdapter",
     "AdapterError",
+    "Event",
     "EventAdapter",
     "NodeAdapter",
     "RawUpdateAdapter",
-    "Event",
 )

telegrinder/bot/rules/integer.py

@@ -17,4 +17,4 @@ class IntegerInRange(ABCRule):
         return integer in self.rng
 
 
-__all__ = ("IsInteger", "IntegerInRange")
+__all__ = ("IntegerInRange", "IsInteger")