telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/dispatch/view/raw.py

@@ -1,93 +1,94 @@
 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, ErrorHandlerT
+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
 
-T = typing.TypeVar("T", contravariant=True)
-R = typing.TypeVar("R", covariant=True)
-P = typing.ParamSpec("P")
-
 
 class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
-    def __init__(self) -> None:
-        self.auto_rules = []
-        self.handlers = []
-        self.middlewares = []
-        self.return_manager = None
-
     @typing.overload
-    def __call__(
+    def __call__[**P, R](
         self,
-        update_type: UpdateType,
         *rules: ABCRule,
+        update_type: UpdateType,
+        final: bool = True,
     ) -> typing.Callable[
         [Func[P, R]],
-        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandler[BaseCute[typing.Any]]],
     ]: ...
 
     @typing.overload
-    def __call__(
+    def __call__[**P, Dataclass, R](
         self,
-        update_type: UpdateType,
         *rules: ABCRule,
-        dataclass: type[T],
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+        dataclass: type[Dataclass],
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[Dataclass, Func[P, R], ErrorHandler[Dataclass]]]: ...
 
     @typing.overload
-    def __call__(
+    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[UpdateCute, Func[P, R], ErrorHandlerT],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
     ]: ...
 
     @typing.overload
-    def __call__(
+    def __call__[**P, ErrorHandlerT: ABCErrorHandler, R](
         self,
-        update_type: UpdateType,
         *rules: ABCRule,
-        dataclass: type[typing.Any],
         error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def __call__(
-        self,
         update_type: UpdateType,
-        *rules: ABCRule,
-        dataclass: None = None,
-        error_handler: None = None,
-        is_blocking: bool = True,
+        final: bool = True,
     ) -> typing.Callable[
         [Func[P, R]],
-        FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]],
+        FuncHandler[BaseCute[typing.Any], Func[P, R], ErrorHandlerT],
     ]: ...
 
-    def __call__(  # type: ignore
+    @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,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func):
+        final: bool = True,
+    ) -> typing.Callable[..., typing.Any]:
+        def wrapper(func: typing.Callable[..., typing.Any]):
             func_handler = FuncHandler(
                 func,
                 rules=[*self.auto_rules, *rules],
-                is_blocking=is_blocking,
+                final=final,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
                 update_type=update_type,
@@ -100,11 +101,12 @@ class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
     async def check(self, event: Update) -> bool:
         return bool(self.handlers) or bool(self.middlewares)
 
-    async def process(self, event: Update, api: API) -> bool:
+    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,

telegrinder/bot/dispatch/waiter_machine/actions.py

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

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

@@ -7,12 +7,11 @@ from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.view.base import BaseView
 from telegrinder.tools.functional import from_optional
 
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=BaseCute)
-Data = typing.TypeVar("Data")
+Event = typing.TypeVar("Event", bound=BaseCute, covariant=True)
+Data = typing.TypeVar("Data", covariant=True)
 
 
-def _echo(__x: T) -> T:
+def _echo[T](__x: T) -> T:
     return __x
 
 
@@ -40,17 +39,20 @@ class Hasher(typing.Generic[Event, Data]):
     def name(self) -> str:
         return f"{self.view_class.__name__}_{id(self)}"
 
-    def get_hash_from_data(self, data: Data) -> Option[typing.Hashable]:
+    def get_hash_from_data[D](self: "Hasher[Event, D]", data: D) -> 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]:
+    def get_data_from_event[E: BaseCute](self: "Hasher[E, Data]", event: E) -> 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]:
+    def get_hash_from_data_from_event[E: BaseCute](
+        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
 
 

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

@@ -1,11 +1,12 @@
 from fntypes.option import Option
 
+from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.view import BaseStateView
-from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import ECHO, Event, Hasher
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import ECHO, Hasher
 from telegrinder.tools.functional import from_optional
 
 
-class StateViewHasher(Hasher[Event, int]):
+class StateViewHasher[Event: BaseCute](Hasher[Event, int]):
     view: BaseStateView[Event]
 
     def __init__(self, view: BaseStateView[Event]) -> None:

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -2,29 +2,45 @@ import asyncio
 import datetime
 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 WaiterMiddleware
+from telegrinder.bot.dispatch.waiter_machine.middleware import INITIATOR_CONTEXT_KEY, WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import (
-    EventModel,
     ShortState,
     ShortStateContext,
 )
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.lifespan import Lifespan
 from telegrinder.tools.limited_dict import LimitedDict
 
 from .actions import WaiterActions
 from .hasher import Hasher, StateViewHasher
 
-HasherData = typing.TypeVar("HasherData")
-
-Storage: typing.TypeAlias = dict[
-    Hasher[EventModel, HasherData], LimitedDict[typing.Hashable, ShortState[EventModel]]
+type Storage[Event: BaseCute, HasherData] = dict[
+    Hasher[Event, HasherData],
+    LimitedDict[typing.Hashable, ShortState[Event]],
 ]
+type HasherWithData[Event: BaseCute, Data] = tuple[Hasher[Event, Data], Data]
 
 WEEK: typing.Final[datetime.timedelta] = datetime.timedelta(days=7)
 
 
+class ContextUnpackProto[*Ts](typing.Protocol):
+    __name__: str
+
+    def __call__(self, context: Context, /) -> tuple[*Ts]: ...
+
+
+def unpack_to_context(context: Context) -> tuple[Context]:
+    return (context,)
+
+
+def no_unpack(_: Context) -> tuple[()]:
+    return ()
+
+
 class WaiterMachine:
     def __init__(
         self,
@@ -39,20 +55,20 @@ class WaiterMachine:
         self.storage: Storage = {}
 
     def __repr__(self) -> str:
-        return "<{}: max_storage_size={}, base_state_lifetime={!r}>".format(
+        return "<{}: with {} storage items and max_storage_size={}, base_state_lifetime={!r}>".format(
             self.__class__.__name__,
+            len(self.storage),
             self.max_storage_size,
             self.base_state_lifetime,
         )
 
-    def create_middleware(self, view: BaseStateView[EventModel]) -> WaiterMiddleware[EventModel]:
+    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:
@@ -62,17 +78,17 @@ class WaiterMachine:
 
             del self.storage[hasher]
 
-    async def drop(
+    async def drop[Event: BaseCute, HasherData](
         self,
-        hasher: Hasher[EventModel, HasherData],
-        id: HasherData,
+        hasher: Hasher[Event, HasherData],
+        data: HasherData,
         **context: typing.Any,
     ) -> None:
         if hasher not in self.storage:
             raise LookupError("No record of hasher {!r} found.".format(hasher))
 
-        waiter_id: typing.Hashable = hasher.get_hash_from_data(id).expect(
-            RuntimeError("Couldn't create hash from data")
+        waiter_id: typing.Hashable = hasher.get_hash_from_data(data).expect(
+            RuntimeError("Couldn't create hash from data"),
         )
         short_state = self.storage[hasher].pop(waiter_id, None)
         if short_state is None:
@@ -85,16 +101,17 @@ class WaiterMachine:
 
         await short_state.cancel()
 
-    async def wait_from_event(
+    async def wait_from_event[Event: BaseCute](
         self,
-        view: BaseStateView[EventModel],
-        event: EventModel,
+        view: BaseStateView[Event],
+        event: Event,
         *,
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
         lifetime: datetime.timedelta | float | None = None,
-        **actions: typing.Unpack[WaiterActions[EventModel]],
-    ) -> ShortStateContext[EventModel]:
+        lifespan: Lifespan | None = None,
+        **actions: typing.Unpack[WaiterActions[Event]],
+    ) -> ShortStateContext[Event]:
         hasher = StateViewHasher(view)
         return await self.wait(
             hasher=hasher,
@@ -104,24 +121,27 @@ class WaiterMachine:
             filter=filter,
             release=release,
             lifetime=lifetime,
+            lifespan=lifespan or Lifespan(),
             **actions,
         )
 
-    async def wait(
+    async def wait[Event: BaseCute, HasherData](
         self,
-        hasher: Hasher[EventModel, HasherData],
+        hasher: Hasher[Event, HasherData],
         data: HasherData,
         *,
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
         lifetime: datetime.timedelta | float | None = None,
-        **actions: typing.Unpack[WaiterActions[EventModel]],
-    ) -> ShortStateContext[EventModel]:
+        lifespan: Lifespan | None = None,
+        **actions: typing.Unpack[WaiterActions[Event]],
+    ) -> ShortStateContext[Event]:
         if isinstance(lifetime, int | float):
             lifetime = datetime.timedelta(seconds=lifetime)
 
+        lifespan = lifespan or Lifespan()
         event = asyncio.Event()
-        short_state = ShortState[EventModel](
+        short_state = ShortState[Event](
             event,
             actions,
             release=release,
@@ -132,8 +152,8 @@ class WaiterMachine:
 
         if hasher not in self.storage:
             if self.dispatch:
-                view: BaseView[EventModel] = self.dispatch.get_view(hasher.view_class).expect(
-                    RuntimeError(f"View {hasher.view_class.__name__!r} is not defined in dispatch.")
+                view: BaseView[Event] = 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)
@@ -141,23 +161,82 @@ class WaiterMachine:
         if (deleted_short_state := self.storage[hasher].set(waiter_hash, short_state)) is not None:
             await deleted_short_state.cancel()
 
-        await event.wait()
+        async with lifespan:
+            await event.wait()
+
         self.storage[hasher].pop(waiter_hash, None)
-        assert short_state.context is not None
+
+        if short_state.context is None:
+            raise LookupError("No context in short_state.")
         return short_state.context
 
+    async def wait_many[RestEvent: BaseCute[typing.Any], Data, *Ts](
+        self,
+        *hashers: HasherWithData[RestEvent, 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]:
+        if isinstance(lifetime, int | float):
+            lifetime = datetime.timedelta(seconds=lifetime)
+
+        lifespan = lifespan or Lifespan()
+        event = asyncio.Event()
+        short_state = ShortState(
+            event,
+            actions,
+            release=release,
+            filter=filter,
+            lifetime=lifetime or self.base_state_lifetime,
+        )
+        waiter_hashes: dict[Hasher[RestEvent, Data], typing.Hashable] = {}
+
+        for hasher, data in hashers:
+            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 = 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:
+                await deleted_short_state.cancel()
+
+            waiter_hashes[hasher] = waiter_hash
+
+        async with lifespan:
+            await event.wait()
+
+        if short_state.context is None:
+            raise LookupError("No context in short_state.")
+
+        initiator = short_state.context.context.get(INITIATOR_CONTEXT_KEY)
+        if initiator is None:
+            raise LookupError("Initiator not found in short_state context.")
+
+        for hasher, waiter_hash in waiter_hashes.items():
+            self.storage[hasher].pop(waiter_hash, None)
+
+        return (
+            initiator,
+            short_state.context.event,  # type: ignore
+            *unpack(short_state.context.context),
+        )
+
     async def clear_storage(self) -> None:
         """Clears storage."""
+        now = datetime.datetime.now()
 
         for hasher in self.storage:
-            now = datetime.datetime.now()
             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:
-                    await self.drop(
-                        hasher,
-                        ident,
-                        force=True,
-                    )
+                    await self.drop(hasher, data=ident, force=True)
 
 
 async def clear_wm_storage_worker(

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -15,10 +15,11 @@ if typing.TYPE_CHECKING:
     from .machine import WaiterMachine
     from .short_state import ShortState
 
-EventType = typing.TypeVar("EventType", bound=BaseCute)
 
+INITIATOR_CONTEXT_KEY = "initiator"
 
-class WaiterMiddleware(ABCMiddleware[EventType]):
+
+class WaiterMiddleware[Event: BaseCute](ABCMiddleware[Event]):
     def __init__(
         self,
         machine: "WaiterMachine",
@@ -27,16 +28,16 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         self.machine = machine
         self.hasher = hasher
 
-    async def pre(self, event: EventType, ctx: Context) -> bool:
+    async def pre(self, event: Event, ctx: Context) -> bool:
         if self.hasher not in self.machine.storage:
             return True
 
         key = self.hasher.get_hash_from_data_from_event(event)
-        if key is None:
-            logger.info(f"Unable to get hash from event with hasher {self.hasher}")
+        if not key:
+            logger.info(f"Unable to get hash from event with hasher {self.hasher!r}")
             return True
 
-        short_state: "ShortState[EventType] | None" = self.machine.storage[self.hasher].get(key.unwrap())
+        short_state: "ShortState[Event] | None" = self.machine.storage[self.hasher].get(key.unwrap())
         if not short_state:
             return True
 
@@ -46,7 +47,10 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
 
         # Run filter rule
         if short_state.filter and not await check_rule(
-            event.ctx_api, short_state.filter, ctx.raw_update, preset_context
+            event.ctx_api,
+            short_state.filter,
+            ctx.raw_update,
+            preset_context,
         ):
             logger.debug("Filter rule {!r} failed", short_state.filter)
             return True
@@ -62,9 +66,9 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         handler = FuncHandler(
             self.pass_runtime,
             [short_state.release] if short_state.release else [],
-            dataclass=None,
             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:
@@ -78,10 +82,11 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
 
     async def pass_runtime(
         self,
-        event: EventType,
-        short_state: "ShortState[EventType]",
+        event: Event,
+        short_state: "ShortState[Event]",
         ctx: Context,
     ) -> None:
+        ctx.initiator = self.hasher
         short_state.context = ShortStateContext(event, ctx)
         short_state.event.set()
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -2,33 +2,25 @@ import asyncio
 import dataclasses
 import datetime
 import typing
-from contextlib import suppress
 
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.model import Model
+from telegrinder.tools.magic import cancel_future
 
 if typing.TYPE_CHECKING:
     from .actions import WaiterActions
 
 
-T = typing.TypeVar("T", bound=Model)
-EventModel = typing.TypeVar("EventModel", bound=BaseCute)
-
-Behaviour: typing.TypeAlias = ABCHandler[T] | None
-
-
-class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
-    event: EventModel
+class ShortStateContext[Event: BaseCute](typing.NamedTuple):
+    event: Event
     context: Context
 
 
 @dataclasses.dataclass(slots=True)
-class ShortState(typing.Generic[EventModel]):
+class ShortState[Event: BaseCute]:
     event: asyncio.Event
-    actions: "WaiterActions[EventModel]"
+    actions: "WaiterActions[Event]"
 
     release: ABCRule | None = dataclasses.field(
         default=None,
@@ -46,7 +38,7 @@ class ShortState(typing.Generic[EventModel]):
 
     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)
+    context: ShortStateContext[Event] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
         self.creation_date = datetime.datetime.now()
@@ -54,15 +46,12 @@ class ShortState(typing.Generic[EventModel]):
 
     async def cancel(self) -> None:
         """Cancel schedule waiters."""
-
         waiters = typing.cast(
             typing.Iterable[asyncio.Future[typing.Any]],
             self.event._waiters,  # type: ignore
         )
         for future in waiters:
-            future.cancel()
-            with suppress(asyncio.CancelledError):
-                await future
+            await cancel_future(future)
 
 
 __all__ = ("ShortState", "ShortStateContext")