telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/bot/dispatch/view/raw.py

@@ -1,116 +1,10 @@
-import typing
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.func import Func, FuncHandler
-from telegrinder.bot.dispatch.process import process_inner
 from telegrinder.bot.dispatch.view.abc import ABCEventRawView
 from telegrinder.bot.dispatch.view.base import BaseView
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-
-class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
-    @typing.overload
-    def __call__[**P, R](
-        self,
-        *rules: ABCRule,
-        update_type: UpdateType,
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandler[BaseCute[typing.Any]]],
-    ]: ...
-
-    @typing.overload
-    def __call__[**P, Dataclass, R](
-        self,
-        *rules: ABCRule,
-        dataclass: type[Dataclass],
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]]]: ...
-
-    @typing.overload
-    def __call__[**P, Dataclass, R](
-        self,
-        *rules: ABCRule,
-        update_type: UpdateType,
-        dataclass: type[Dataclass],
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]]]: ...
-
-    @typing.overload
-    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
-    ]: ...
-
-    @typing.overload
-    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        update_type: UpdateType,
-        final: bool = True,
-    ) -> typing.Callable[
-        [Func[P, R]],
-        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
-    ]: ...
-
-    @typing.overload
-    def __call__[**P, Dataclass, ErrorHandlerT: ABCErrorHandler, R](
-        self,
-        *rules: ABCRule,
-        update_type: UpdateType,
-        dataclass: type[Dataclass],
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandlerT]]: ...
-
-    def __call__(
-        self,
-        *rules: ABCRule,
-        update_type: UpdateType | None = None,
-        dataclass: type[typing.Any] | None = None,
-        error_handler: ABCErrorHandler | None = None,
-        final: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func: typing.Callable[..., typing.Any]):
-            func_handler = FuncHandler(
-                func,
-                rules=[*self.auto_rules, *rules],
-                final=final,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
-                update_type=update_type,
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
 
-    async def check(self, event: Update) -> bool:
-        return bool(self.handlers) or bool(self.middlewares)
 
-    async def process(self, event: Update, api: API, context: Context) -> bool:
-        return await process_inner(
-            api,
-            UpdateCute.from_update(event, bound_api=api),
-            event,
-            context,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
-        )
+class RawEventView(ABCEventRawView, BaseView):
+    def __init__(self) -> None:
+        super().__init__()
 
 
 __all__ = ("RawEventView",)

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -6,9 +6,8 @@ from telegrinder.bot.dispatch.waiter_machine.hasher import (
     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.machine import WaiterMachine
 from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import ShortState
 
@@ -16,13 +15,11 @@ __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",
+    "Hasher",
     "ShortState",
-    "StateViewHasher",
     "WaiterMachine",
     "WaiterMiddleware",
-    "clear_wm_storage_worker",
 )

telegrinder/bot/dispatch/waiter_machine/actions.py

@@ -1,14 +1,16 @@
 import typing
 
-from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 
 from .short_state import ShortState
 
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.cute_types.base import BaseCute
 
-class WaiterActions[Event: BaseCute](typing.TypedDict):
-    on_miss: typing.NotRequired[ABCHandler[Event]]
-    on_drop: typing.NotRequired[typing.Callable[[ShortState[Event]], None]]
+
+class WaiterActions[Event: BaseCute[typing.Any]](typing.TypedDict):
+    on_miss: typing.NotRequired[ABCHandler]
+    on_drop: typing.NotRequired[typing.Callable[[ShortState], None]]
 
 
 __all__ = ("WaiterActions",)

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

@@ -1,15 +1,13 @@
 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",
+    "Hasher",
 )

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

@@ -10,7 +10,7 @@ def from_chat_hash(chat_id: int) -> int:
 
 
 def get_chat_from_event(event: CallbackQuery) -> int | None:
-    return event.chat.and_then(lambda chat: Some(chat.id)).unwrap_or_none()
+    return event.chat.then(lambda chat: Some(chat.id)).unwrap_or_none()
 
 
 def for_message_hash(message_id: int) -> int:

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

@@ -1,27 +1,28 @@
+from __future__ import annotations
+
 import typing
 from functools import cached_property
 
+from fntypes.misc import from_optional
 from fntypes.option import Option
 
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.view.base import BaseView
-from telegrinder.tools.functional import from_optional
+
+type HasherWithData[Event: BaseCute, Data] = tuple[Hasher[Event, Data], Data]
 
 Event = typing.TypeVar("Event", bound=BaseCute, covariant=True)
 Data = typing.TypeVar("Data", covariant=True)
 
 
-def _echo[T](__x: T) -> T:
+def ECHO[T](__x: T) -> T:  # noqa
     return __x
 
 
-ECHO = _echo
-
-
 class Hasher(typing.Generic[Event, Data]):
     def __init__(
         self,
-        view_class: type[BaseView[Event]],
+        view_class: type[BaseView],
         get_hash_from_data: typing.Callable[[Data], typing.Hashable | None] | None = None,
         get_data_from_event: typing.Callable[[Event], Data | None] | None = None,
     ) -> None:
@@ -29,6 +30,9 @@ class Hasher(typing.Generic[Event, Data]):
         self._get_hash_from_data = get_hash_from_data
         self._get_data_from_event = get_data_from_event
 
+    def __call__[D](self: "Hasher[Event, D]", data: D, /) -> HasherWithData[Event, D]:
+        return (self, data)
+
     def __hash__(self) -> int:
         return hash(self.name)
 
@@ -53,7 +57,7 @@ class Hasher(typing.Generic[Event, Data]):
         self: "Hasher[E, Data]",
         event: E,
     ) -> Option[typing.Hashable]:
-        return self.get_data_from_event(event).and_then(self.get_hash_from_data)  # type: ignore
+        return self.get_data_from_event(event).then(self.get_hash_from_data)  # type: ignore
 
 
 __all__ = ("Hasher",)

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import datetime
 import typing
@@ -5,18 +7,19 @@ import typing
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.abc import ABCDispatch
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.view.base import BaseStateView, BaseView
-from telegrinder.bot.dispatch.waiter_machine.middleware import INITIATOR_CONTEXT_KEY, WaiterMiddleware
+from telegrinder.bot.dispatch.view.base import BaseView
+from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import (
     ShortState,
     ShortStateContext,
 )
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
 from telegrinder.tools.lifespan import Lifespan
 from telegrinder.tools.limited_dict import LimitedDict
 
 from .actions import WaiterActions
-from .hasher import Hasher, StateViewHasher
+from .hasher import Hasher
 
 type Storage[Event: BaseCute, HasherData] = dict[
     Hasher[Event, HasherData],
@@ -24,35 +27,49 @@ type Storage[Event: BaseCute, HasherData] = dict[
 ]
 type HasherWithData[Event: BaseCute, Data] = tuple[Hasher[Event, Data], Data]
 
+_NODEFAULT: typing.Any = object()
+MAX_STORAGE_SIZE: typing.Final[int] = 10000
+ONE_MINUTE: typing.Final[datetime.timedelta] = datetime.timedelta(minutes=1)
 WEEK: typing.Final[datetime.timedelta] = datetime.timedelta(days=7)
+CONTEXT: typing.Final[TelegrinderContext] = TelegrinderContext()
 
 
-class ContextUnpackProto[*Ts](typing.Protocol):
-    __name__: str
-
-    def __call__(self, context: Context, /) -> tuple[*Ts]: ...
+async def clear_wm_storage_worker(wm: WaiterMachine, interval: float) -> None:
+    await wm.clear_storage()
+    await asyncio.sleep(interval)
 
 
-def unpack_to_context(context: Context) -> tuple[Context]:
+def unpack_to_context(context: Context, /) -> tuple[Context]:
     return (context,)
 
 
-def no_unpack(_: Context) -> tuple[()]:
+def no_unpack(_: Context, /) -> tuple[()]:
     return ()
 
 
+class ContextUnpackProto[*Ts](typing.Protocol):
+    __name__: str
+
+    def __call__(self, context: Context, /) -> tuple[*Ts]: ...
+
+
 class WaiterMachine:
     def __init__(
         self,
         dispatch: ABCDispatch | None = None,
         *,
-        max_storage_size: int = 1000,
+        max_storage_size: int = MAX_STORAGE_SIZE,
         base_state_lifetime: datetime.timedelta = WEEK,
+        clear_storage_interval: datetime.timedelta = ONE_MINUTE,
     ) -> None:
         self.dispatch = dispatch
         self.max_storage_size = max_storage_size
         self.base_state_lifetime = base_state_lifetime
-        self.storage: Storage = {}
+        self.storage: Storage[typing.Any, typing.Any] = {}
+
+        CONTEXT.loop_wrapper.add_task(
+            clear_wm_storage_worker(self, clear_storage_interval.total_seconds()),
+        )
 
     def __repr__(self) -> str:
         return "<{}: with {} storage items and max_storage_size={}, base_state_lifetime={!r}>".format(
@@ -62,17 +79,12 @@ class WaiterMachine:
             self.base_state_lifetime,
         )
 
-    def create_middleware[Event: BaseCute](self, view: BaseStateView[Event]) -> WaiterMiddleware[Event]:
-        hasher = StateViewHasher(view)
-        self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
-        return WaiterMiddleware(self, hasher)
-
     async def drop_all(self) -> None:
         """Drops all waiters in storage."""
         for hasher in self.storage.copy():
             for ident, short_state in self.storage[hasher].items():
                 if short_state.context:
-                    await self.drop(hasher, ident)
+                    await self.drop(hasher, data=ident)
                 else:
                     await short_state.cancel()
 
@@ -101,34 +113,10 @@ class WaiterMachine:
 
         await short_state.cancel()
 
-    async def wait_from_event[Event: BaseCute](
-        self,
-        view: BaseStateView[Event],
-        event: Event,
-        *,
-        filter: ABCRule | None = None,
-        release: ABCRule | None = None,
-        lifetime: datetime.timedelta | float | None = None,
-        lifespan: Lifespan | None = None,
-        **actions: typing.Unpack[WaiterActions[Event]],
-    ) -> ShortStateContext[Event]:
-        hasher = StateViewHasher(view)
-        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,
-            lifespan=lifespan or Lifespan(),
-            **actions,
-        )
-
     async def wait[Event: BaseCute, HasherData](
         self,
-        hasher: Hasher[Event, HasherData],
-        data: HasherData,
+        hasher: Hasher[Event, HasherData] | HasherWithData[Event, HasherData],
+        data: HasherData = _NODEFAULT,
         *,
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
@@ -141,21 +129,25 @@ class WaiterMachine:
 
         lifespan = lifespan or Lifespan()
         event = asyncio.Event()
-        short_state = ShortState[Event](
+        short_state = ShortState(
             event,
             actions,
             release=release,
             filter=filter,
             lifetime=lifetime or self.base_state_lifetime,
         )
+
+        hasher, data = hasher if not isinstance(hasher, Hasher) else (hasher, data)
+        assert data is not _NODEFAULT, "Hasher requires data."
         waiter_hash = hasher.get_hash_from_data(data).expect(RuntimeError("Hasher couldn't create hash."))
 
         if hasher not in self.storage:
             if self.dispatch:
-                view: BaseView[Event] = self.dispatch.get_view(hasher.view_class).expect(
+                view: BaseView = self.dispatch.get_view(hasher.view_class).expect(
                     RuntimeError(f"View {hasher.view_class.__name__!r} 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[hasher].set(waiter_hash, short_state)) is not None:
@@ -170,16 +162,16 @@ class WaiterMachine:
             raise LookupError("No context in short_state.")
         return short_state.context
 
-    async def wait_many[RestEvent: BaseCute[typing.Any], Data, *Ts](
+    async def wait_many[Event: BaseCute[typing.Any], Data, *Ts](
         self,
-        *hashers: HasherWithData[RestEvent, Data],
+        *hashers: HasherWithData[Event, Data],
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
         lifetime: datetime.timedelta | float | None = None,
         lifespan: Lifespan | None = None,
         unpack: ContextUnpackProto[*Ts] = unpack_to_context,
-        **actions: typing.Unpack[WaiterActions[BaseCute[typing.Any]]],
-    ) -> tuple[HasherWithData[RestEvent, Data], RestEvent, *Ts]:
+        **actions: typing.Unpack[WaiterActions[Event]],
+    ) -> tuple[HasherWithData[Event, Data], Event, *Ts]:
         if isinstance(lifetime, int | float):
             lifetime = datetime.timedelta(seconds=lifetime)
 
@@ -192,7 +184,7 @@ class WaiterMachine:
             filter=filter,
             lifetime=lifetime or self.base_state_lifetime,
         )
-        waiter_hashes: dict[Hasher[RestEvent, Data], typing.Hashable] = {}
+        waiter_hashes: dict[Hasher[Event, Data], typing.Hashable] = {}
 
         for hasher, data in hashers:
             waiter_hash = hasher.get_hash_from_data(data).expect(RuntimeError("Hasher couldn't create hash."))
@@ -216,7 +208,7 @@ class WaiterMachine:
         if short_state.context is None:
             raise LookupError("No context in short_state.")
 
-        initiator = short_state.context.context.get(INITIATOR_CONTEXT_KEY)
+        initiator = short_state.context.context.get("initiator")
         if initiator is None:
             raise LookupError("Initiator not found in short_state context.")
 
@@ -239,13 +231,4 @@ class WaiterMachine:
                     await self.drop(hasher, data=ident, force=True)
 
 
-async def clear_wm_storage_worker(
-    wm: WaiterMachine,
-    interval_seconds: int = 60,
-) -> typing.NoReturn:
-    while True:
-        await wm.clear_storage()
-        await asyncio.sleep(interval_seconds)
-
-
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -1,13 +1,15 @@
 import datetime
 import typing
 
-from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
 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.process import check_rule
 from telegrinder.bot.dispatch.waiter_machine.short_state import ShortStateContext
 from telegrinder.modules import logger
+from telegrinder.types.objects import Update
 
 from .hasher import Hasher
 
@@ -15,29 +17,29 @@ if typing.TYPE_CHECKING:
     from .machine import WaiterMachine
     from .short_state import ShortState
 
+type State = ShortState[typing.Any]
 
-INITIATOR_CONTEXT_KEY = "initiator"
 
-
-class WaiterMiddleware[Event: BaseCute](ABCMiddleware[Event]):
+class WaiterMiddleware(ABCMiddleware):
     def __init__(
         self,
         machine: "WaiterMachine",
-        hasher: Hasher,
+        hasher: Hasher[typing.Any, typing.Any],
     ) -> None:
         self.machine = machine
         self.hasher = hasher
 
-    async def pre(self, event: Event, ctx: Context) -> bool:
+    async def pre(self, update: UpdateCute, raw_update: Update, api: API, ctx: Context) -> bool:
         if self.hasher not in self.machine.storage:
             return True
 
+        event = update.incoming_update
         key = self.hasher.get_hash_from_data_from_event(event)
         if not key:
             logger.info(f"Unable to get hash from event with hasher {self.hasher!r}")
             return True
 
-        short_state: "ShortState[Event] | None" = self.machine.storage[self.hasher].get(key.unwrap())
+        short_state: "ShortState | None" = self.machine.storage[self.hasher].get(key.unwrap())
         if not short_state:
             return True
 
@@ -47,12 +49,12 @@ class WaiterMiddleware[Event: BaseCute](ABCMiddleware[Event]):
 
         # Run filter rule
         if short_state.filter and not await check_rule(
-            event.ctx_api,
+            api,
             short_state.filter,
-            ctx.raw_update,
+            raw_update,
             preset_context,
         ):
-            logger.debug("Filter rule {!r} failed", short_state.filter)
+            logger.debug("Filter rule {!r} failed!", short_state.filter)
             return True
 
         if short_state.expiration_date is not None and datetime.datetime.now() >= short_state.expiration_date:
@@ -63,31 +65,25 @@ class WaiterMiddleware[Event: BaseCute](ABCMiddleware[Event]):
             )
             return True
 
-        handler = FuncHandler(
+        result = await FuncHandler(
             self.pass_runtime,
             [short_state.release] if short_state.release else [],
             preset_context=preset_context,
-        )
-        handler.get_name_event_param = lambda event: "event"  # FIXME: HOTFIX
-        result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
-
-        if result is True:
-            await handler.run(event.api, event, ctx)
+        ).run(api, raw_update, ctx)
 
-        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)
+        if not result and (on_miss := short_state.actions.get("on_miss")):
+            await on_miss.run(api, raw_update, ctx)
 
         return False
 
     async def pass_runtime(
         self,
-        event: Event,
-        short_state: "ShortState[Event]",
+        event: UpdateCute,
         ctx: Context,
+        short_state: State,
     ) -> None:
         ctx.initiator = self.hasher
-        short_state.context = ShortStateContext(event, ctx)
+        short_state.context = ShortStateContext(event.incoming_update, ctx)  # type: ignore
         short_state.event.set()
 
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -3,22 +3,23 @@ import dataclasses
 import datetime
 import typing
 
-from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.tools.magic import cancel_future
+from telegrinder.tools.aio import cancel_future
 
 if typing.TYPE_CHECKING:
+    from telegrinder.bot.cute_types.base import BaseCute
+
     from .actions import WaiterActions
 
 
-class ShortStateContext[Event: BaseCute](typing.NamedTuple):
+class ShortStateContext[Event: BaseCute[typing.Any]](typing.NamedTuple):
     event: Event
     context: Context
 
 
 @dataclasses.dataclass(slots=True)
-class ShortState[Event: BaseCute]:
+class ShortState[Event: BaseCute[typing.Any]]:
     event: asyncio.Event
     actions: "WaiterActions[Event]"
 
@@ -47,7 +48,7 @@ class ShortState[Event: BaseCute]:
     async def cancel(self) -> None:
         """Cancel schedule waiters."""
         waiters = typing.cast(
-            typing.Iterable[asyncio.Future[typing.Any]],
+            "typing.Iterable[asyncio.Future[typing.Any]]",
             self.event._waiters,  # type: ignore
         )
         for future in waiters: