telegrinder 0.1.dev19__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/bot/dispatch/return_manager/message.py

@@ -0,0 +1,25 @@
+from telegrinder.bot.cute_types import MessageCute
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import BaseReturnManager, register_manager
+
+
+class MessageReturnManager(BaseReturnManager[MessageCute]):  
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
+        await event.answer(value)
+    
+    @register_manager(list | tuple)
+    @staticmethod
+    async def seq_manager(value: list[str] | tuple[str, ...], event: MessageCute, ctx: Context) -> None:
+        for message in value:
+            await event.answer(message)
+    
+    @register_manager(dict)
+    @staticmethod
+    async def dict_manager(value: dict, event: MessageCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("MessageReturnManager",)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,4 +1,16 @@
-from .abc import ABCView
-from .message import MessageView
+from .abc import ABCStateView, ABCView, BaseStateView, BaseView
+from .box import ViewBox
 from .callback_query import CallbackQueryView
 from .inline_query import InlineQueryView
+from .message import MessageView
+
+__all__ = (
+    "ABCView",
+    "ABCStateView",
+    "BaseView",
+    "BaseStateView",
+    "CallbackQueryView",
+    "InlineQueryView",
+    "MessageView",
+    "ViewBox",
+)

telegrinder/bot/dispatch/view/abc.py

@@ -1,6 +1,21 @@
+import typing
 from abc import ABC, abstractmethod
+
+from fntypes.co import Nothing, Some
+
 from telegrinder.api.abc import ABCAPI
-from telegrinder.types import Update
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import Update
+
+EventType = typing.TypeVar("EventType", bound=BaseCute)
 
 
 class ABCView(ABC):
@@ -13,5 +28,109 @@ class ABCView(ABC):
         pass
 
     @abstractmethod
-    async def load(self, external: "ABCView"):
+    def load(self, external: typing.Self) -> None:
         pass
+
+
+class ABCStateView(ABCView, typing.Generic[EventType]):
+    @abstractmethod
+    def get_state_key(self, event: EventType) -> int | None:
+        pass
+
+    def __repr__(self) -> str:
+        return "<{!r}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
+        )
+
+
+class BaseView(ABCView, typing.Generic[EventType]):
+    auto_rules: list[ABCRule[EventType]]
+    handlers: list[ABCHandler[EventType]]
+    middlewares: list[ABCMiddleware[EventType]]
+    return_manager: ABCReturnManager[EventType]
+
+    @classmethod
+    def get_event_type(cls) -> Option[type[EventType]]:
+        for base in cls.__dict__.get("__orig_bases__", ()):
+            if issubclass(typing.get_origin(base) or base, ABCView):
+                for generic_type in typing.get_args(base):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
+                        return Some(generic_type)
+        return Nothing()
+    
+    @classmethod
+    def get_event_raw(cls, update: Update) -> Option[Model]:
+        match cls.get_event_type():
+            case Some(event_type):
+                for field in update.__struct_fields__:
+                    event_raw = getattr(update, field)
+                    if isinstance(event_raw, Some | Nothing):
+                        event_raw = event_raw.unwrap_or_none()
+                    if event_raw is not None and issubclass(event_type, event_raw.__class__):
+                        return Some(event_raw)
+        return Nothing()
+
+    def __call__(
+        self,
+        *rules: ABCRule[EventType],
+        is_blocking: bool = True,
+        error_handler: ErrorHandlerT | None = None,
+    ):
+        def wrapper(
+            func: typing.Callable[
+                typing.Concatenate[EventType, ...],
+                typing.Coroutine,
+            ]
+        ):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking,
+                dataclass=None,
+                error_handler=error_handler,
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+    
+    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
+        def wrapper(cls: type[ABCMiddleware[EventType]]):
+            self.middlewares.append(cls(*args, **kwargs))
+            return cls
+        
+        return wrapper
+    
+    async def check(self, event: Update) -> bool:
+        return bool(self.get_event_raw(event))
+        
+    async def process(self, event: Update, api: ABCAPI) -> bool:
+        event_raw = self.get_event_raw(event).unwrap()
+        event_type = self.get_event_type().unwrap()
+        return await process_inner(
+            event_type(**event_raw.to_dict(), api=api),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+    def load(self, external: typing.Self) -> None:
+        self.auto_rules.extend(external.auto_rules)
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+
+class BaseStateView(ABCStateView[EventType], BaseView[EventType], ABC, typing.Generic[EventType]):
+    @abstractmethod
+    def get_state_key(self, event: EventType) -> int | None:
+        pass
+
+
+__all__ = (
+    "ABCView",
+    "ABCStateView",
+    "BaseView",
+    "BaseStateView",
+)

telegrinder/bot/dispatch/view/box.py

@@ -0,0 +1,38 @@
+import dataclasses
+
+import typing_extensions as typing
+
+from .abc import ABCView
+from .callback_query import CallbackQueryView
+from .inline_query import InlineQueryView
+from .message import MessageView
+
+CallbackQueryViewT = typing.TypeVar(
+    "CallbackQueryViewT", bound=ABCView, default=CallbackQueryView
+)
+InlineQueryViewT = typing.TypeVar(
+    "InlineQueryViewT", bound=ABCView, default=InlineQueryView
+)
+MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
+
+
+@dataclasses.dataclass(kw_only=True)
+class ViewBox(typing.Generic[CallbackQueryViewT, InlineQueryViewT, MessageViewT]):
+    callback_query: CallbackQueryViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: CallbackQueryView(),
+    )
+    inline_query: InlineQueryViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: InlineQueryView(),
+    )
+    message: MessageViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: MessageView(),
+    )
+
+    def get_views(self) -> dict[str, ABCView]:
+        return {
+            name: view for name, view in self.__dict__.items()
+            if isinstance(view, ABCView)
+        }
+
+
+__all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,45 +1,20 @@
-from .abc import ABCView
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler
-from telegrinder.bot.dispatch.waiter import Waiter
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.rules import ABCRule
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.dispatch.waiter import WithWaiter
-from telegrinder.bot.dispatch.process import process_waiters, process_inner
-from telegrinder.types import Update
-import typing
-
+from fntypes.option import Some
 
-class CallbackQueryView(ABCView, WithWaiter[int, CallbackQueryCute]):
-    def __init__(self):
-        self.handlers: typing.List[ABCHandler[CallbackQueryCute]] = []
-        self.middlewares: typing.List[ABCMiddleware[CallbackQueryCute]] = []
-        self.short_waiters: typing.Dict[int, Waiter] = {}
-
-    def __call__(self, *rules: ABCRule, is_blocking: bool = True):
-        def wrapper(func: typing.Callable[..., typing.Coroutine]):
-            self.handlers.append(
-                FuncHandler(func, list(rules), is_blocking, dataclass=None)
-            )
-            return func
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
 
-        return wrapper
+from .abc import BaseStateView
 
-    async def check(self, event: Update) -> bool:
-        return bool(event.callback_query)
 
-    async def process(self, event: Update, api: ABCAPI):
-        query = CallbackQueryCute(**event.callback_query.to_dict(), api=api)
+class CallbackQueryView(BaseStateView[CallbackQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = CallbackQueryReturnManager()
 
-        if await process_waiters(
-            self.short_waiters, query.message.message_id, query, event, query.answer
-        ):
-            return
+    def get_state_key(self, event: CallbackQueryCute) -> int | None:
+        return event.message.map(lambda variative: variative.v.message_id).unwrap_or_none()
 
-        return await process_inner(query, event, self.middlewares, self.handlers)
 
-    def load(self, external: "CallbackQueryView"):
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-        external.short_waiters = self.short_waiters
+__all__ = ("CallbackQueryView",)

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,45 +1,18 @@
-from .abc import ABCView
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler
-from telegrinder.bot.dispatch.waiter import Waiter
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.rules import ABCRule
 from telegrinder.bot.cute_types import InlineQueryCute
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.dispatch.waiter import WithWaiter
-from telegrinder.bot.dispatch.process import process_waiters, process_inner
-from telegrinder.types import Update
-import typing
+from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
 
+from .abc import BaseStateView
 
-class InlineQueryView(ABCView, WithWaiter[str, InlineQueryCute]):
-    def __init__(self):
-        self.handlers: typing.List[ABCHandler[InlineQueryCute]] = []
-        self.middlewares: typing.List[ABCMiddleware[InlineQueryCute]] = []
-        self.short_waiters: typing.Dict[str, Waiter] = {}
 
-    def __call__(self, *rules: ABCRule, is_blocking: bool = True):
-        def wrapper(func: typing.Callable[..., typing.Coroutine]):
-            self.handlers.append(
-                FuncHandler(func, list(rules), is_blocking, dataclass=None)
-            )
-            return func
+class InlineQueryView(BaseStateView[InlineQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = InlineQueryReturnManager()
 
-        return wrapper
+    def get_state_key(self, event: InlineQueryCute) -> int | None:
+        return event.from_.id
 
-    def load(self, external: "InlineQueryView"):
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-        external.short_waiters = self.short_waiters
 
-    async def check(self, event: Update) -> bool:
-        return bool(event.inline_query)
-
-    async def process(self, event: Update, api: ABCAPI):
-        query = InlineQueryCute(**event.inline_query.to_dict(), api=api)
-
-        if await process_waiters(
-            self.short_waiters, query.id, query, event, query.answer
-        ):
-            return
-
-        return await process_inner(query, event, self.middlewares, self.handlers)
+__all__ = ("InlineQueryView",)

telegrinder/bot/dispatch/view/message.py

@@ -1,53 +1,18 @@
-from .abc import ABCView
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler
-from telegrinder.bot.dispatch.waiter import Waiter
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.rules import ABCRule
 from telegrinder.bot.cute_types import MessageCute
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.dispatch.waiter import WithWaiter, DefaultWaiterHandler
-from telegrinder.bot.dispatch.process import process_waiters, process_inner
-from telegrinder.types import Update
-import typing
+from telegrinder.bot.dispatch.return_manager import MessageReturnManager
 
+from .abc import BaseStateView
 
-class MessageView(ABCView, WithWaiter[int, MessageCute]):
-    def __init__(self):
-        self.handlers: typing.List[ABCHandler[MessageCute]] = []
-        self.middlewares: typing.List[ABCMiddleware[MessageCute]] = []
-        self.short_waiters: typing.Dict[int, Waiter] = {}
 
-    def __call__(self, *rules: ABCRule, is_blocking: bool = True):
-        def wrapper(func: typing.Callable[..., typing.Coroutine]):
-            self.handlers.append(
-                FuncHandler(func, list(rules), is_blocking, dataclass=None)
-            )
-            return func
+class MessageView(BaseStateView[MessageCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = MessageReturnManager()
 
-        return wrapper
+    def get_state_key(self, event: MessageCute) -> int | None:
+        return event.chat.id
 
-    def load(self, external: "MessageView"):
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-        external.short_waiters = self.short_waiters
 
-    async def check(self, event: Update) -> bool:
-        return bool(event.message)
-
-    async def process(self, event: Update, api: ABCAPI):
-        msg = MessageCute(**event.message.to_dict(), api=api)
-
-        if await process_waiters(
-            self.short_waiters, msg.chat.id, msg, event, msg.answer
-        ):
-            return
-
-        return await process_inner(msg, event, self.middlewares, self.handlers)
-
-    async def wait_for_message(
-        self,
-        chat_id: int,
-        *rules: ABCRule,
-        default: typing.Optional[typing.Union[DefaultWaiterHandler, str]] = None
-    ) -> typing.Tuple["MessageCute", dict]:
-        return await self.wait_for_answer(chat_id, *rules, default=default)
+__all__ = ("MessageView",)

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -0,0 +1,9 @@
+from .machine import WaiterMachine
+from .middleware import WaiterMiddleware
+from .short_state import ShortState
+
+__all__ = (
+    "ShortState",
+    "WaiterMachine",
+    "WaiterMiddleware",
+)

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -0,0 +1,116 @@
+import asyncio
+import datetime
+import typing
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+
+from .middleware import WaiterMiddleware
+from .short_state import Behaviour, EventModel, ShortState
+
+Identificator: typing.TypeAlias = str | int
+Storage: typing.TypeAlias = dict[str, dict[Identificator, "ShortState"]]
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
+
+
+class WaiterMachine:
+    def __init__(self) -> None:
+        self.storage: Storage = {}
+
+    async def drop(
+        self,
+        state_view: "ABCStateView[EventModel]",
+        id: Identificator,
+        **context,
+    ) -> None:
+        view_name = state_view.__class__.__name__
+        if view_name not in self.storage:
+            raise LookupError("No record of view {!r} found".format(view_name))
+
+        short_state = self.storage[view_name].pop(id, None)
+        if not short_state:
+            raise LookupError(
+                "Waiter with identificator {} is not found for view {!r}".format(
+                    id,
+                    view_name,
+                )
+            )
+
+        waiters = typing.cast(
+            typing.Iterable[asyncio.Future[typing.Any]],
+            short_state.event._waiters  # type: ignore
+        )
+        for future in waiters:
+            future.cancel()
+
+        await self.call_behaviour(
+            state_view,
+            short_state.on_drop_behaviour,
+            short_state.event,
+            **context,
+        )
+
+    async def wait(
+        self,
+        state_view: "BaseStateView[EventModel]",
+        linked: EventModel | tuple[ABCAPI, Identificator],
+        *rules: ABCRule[EventModel],
+        default: Behaviour = None,
+        on_drop: Behaviour = None,
+        expiration: datetime.timedelta | int | None = None,
+    ) -> tuple[EventModel, Context]:
+        if isinstance(expiration, int):
+            expiration = datetime.timedelta(seconds=expiration)
+
+        api: ABCAPI
+        key: Identificator
+        event = asyncio.Event()
+        if isinstance(linked, tuple):
+            api, key = linked
+        else:
+            api, key = linked.ctx_api, state_view.get_state_key(linked)  # type: ignore
+            if not key:
+                raise RuntimeError("Unable to get state key.")
+
+        short_state = ShortState(
+            key,
+            ctx_api=api,
+            event=event,
+            rules=rules,
+            expiration=expiration,
+            default_behaviour=default,
+            on_drop_behaviour=on_drop,
+        )
+
+        view_name = state_view.__class__.__name__
+        if view_name not in self.storage:
+            state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
+            self.storage[view_name] = {}
+
+        self.storage[view_name][key] = short_state
+
+        await event.wait()
+
+        e, ctx = getattr(event, "context")
+        self.storage[view_name].pop(key)
+
+        return e, ctx
+
+    async def call_behaviour(
+        self,
+        view: "ABCStateView[EventModel]",
+        behaviour: Behaviour,
+        event: asyncio.Event | EventModel,
+        **context,
+    ) -> None:
+        if behaviour is None:
+            return
+        # TODO: add behaviour check
+        # TODO: support view as a behaviour
+        await behaviour.run(event)
+
+
+__all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -0,0 +1,76 @@
+import datetime
+import typing
+
+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
+
+if typing.TYPE_CHECKING:
+    from .machine import WaiterMachine
+    from .short_state import ShortState
+
+EventType = typing.TypeVar("EventType", bound=BaseCute)
+
+
+class WaiterMiddleware(ABCMiddleware[EventType]):
+    def __init__(
+        self,
+        machine: "WaiterMachine",
+        view: ABCStateView[EventType],
+    ) -> None:
+        self.machine = machine
+        self.view = view
+
+    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 Protocol)."
+            )
+
+        view_name = self.view.__class__.__name__
+        if view_name not in self.machine.storage:
+            return True
+
+        key = self.view.get_state_key(event)
+        if key is None:
+            raise RuntimeError("Unable to get state key.")
+
+        short_state: typing.Optional["ShortState"] = self.machine.storage[view_name].get(key)
+        if not short_state:
+            return True
+
+        if (
+            short_state.expiration is not None
+            and datetime.datetime.now() >= short_state.expiration
+        ):
+            await self.machine.drop(self.view, short_state.key)
+            return True
+        
+        handler = FuncHandler(
+            self.pass_runtime, list(short_state.rules), dataclass=None
+        )
+        handler.ctx.set("short_state", short_state)
+        result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
+
+        if result is True:
+            await handler.run(event)
+
+        elif short_state.default_behaviour is not None:
+            await self.machine.call_behaviour(
+                self.view,
+                short_state.default_behaviour,
+                event,
+                **handler.ctx,
+            )
+
+        return False
+
+    async def pass_runtime(self, event: EventType, short_state: "ShortState[EventType]", ctx: Context) -> None:
+        setattr(short_state.event, "context", (event, ctx))
+        short_state.event.set()
+
+
+__all__ = ("WaiterMiddleware",)

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -0,0 +1,37 @@
+import asyncio
+import datetime
+import typing
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.rules.abc import ABCRule
+
+if typing.TYPE_CHECKING:
+    from .machine import Identificator
+
+EventModel = typing.TypeVar("EventModel", bound=BaseCute)
+Behaviour = ABCHandler | None
+
+
+class ShortState(typing.Generic[EventModel]):
+    def __init__(
+        self,
+        key: "Identificator",
+        ctx_api: ABCAPI,
+        event: asyncio.Event,
+        rules: tuple[ABCRule[EventModel], ...],
+        expiration: datetime.timedelta | None = None,
+        default_behaviour: Behaviour | None = None,
+        on_drop_behaviour: Behaviour | None = None,
+    ) -> None:
+        self.key = key
+        self.ctx_api = ctx_api
+        self.event = event
+        self.rules = rules
+        self.default_behaviour = default_behaviour
+        self.expiration = (datetime.datetime.now() + expiration) if expiration else None
+        self.on_drop_behaviour = on_drop_behaviour
+
+
+__all__ = ("ShortState",)

telegrinder/bot/polling/__init__.py

@@ -1,2 +1,4 @@
 from .abc import ABCPolling
 from .polling import Polling
+
+__all__ = ("ABCPolling", "Polling")

telegrinder/bot/polling/abc.py

@@ -1,18 +1,25 @@
 import typing
 from abc import ABC, abstractmethod
+
+import msgspec
+
 from telegrinder.types import Update
-from telegrinder.model import Raw
 
 
 class ABCPolling(ABC):
+    offset: int
+
     @abstractmethod
-    async def get_updates(self) -> typing.List[Raw]:
+    async def get_updates(self) -> list[msgspec.Raw]:
         pass
 
     @abstractmethod
-    async def listen(self) -> typing.AsyncIterator[typing.List[Update]]:
-        pass
+    async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
+        yield []
 
     @abstractmethod
     def stop(self) -> None:
         pass
+
+
+__all__ = ("ABCPolling",)