telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/bot/dispatch/view/message.py

@@ -1,54 +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.auto_rules: list[ABCRule] = []
-        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, [*self.auto_rules, *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, *self.auto_rules, *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",)

telegrinder/bot/polling/polling.py

@@ -1,71 +1,120 @@
-import traceback
 import asyncio
+import typing
 
-import msgspec.json
+import aiohttp
+import msgspec
+from fntypes.result import Error, Ok
 
-from .abc import ABCPolling
 from telegrinder.api.abc import ABCAPI
-import typing
+from telegrinder.api.error import InvalidTokenError
+from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
-from telegrinder.model import Raw
-from telegrinder.types import Update
-
-ALLOWED_UPDATES = [
-    "update_id",
-    "message",
-    "edited_message",
-    "channel_post",
-    "edited_channel_post",
-    "inline_query",
-    "chosen_inline_result",
-    "callback_query",
-    "shipping_query",
-    "pre_checkout_query",
-    "poll",
-    "poll_answer",
-    "my_chat_member",
-    "chat_member",
-]
+from telegrinder.msgspec_utils import decoder
+from telegrinder.types import Update, UpdateType
 
 
 class Polling(ABCPolling):
     def __init__(
         self,
-        api: typing.Optional[ABCAPI] = None,
-        offset: typing.Optional[int] = None,
+        api: ABCAPI,
+        *,
+        offset: int = 0,
+        reconnection_timeout: float = 5,
+        max_reconnetions: int = 10,
+        include_updates: set[str | UpdateType] | None = None,
+        exclude_updates: set[str | UpdateType] | None = None,
     ):
         self.api = api
-        self.offset = offset or 0
+        self.allowed_updates = self.get_allowed_updates(
+            include_updates=include_updates,
+            exclude_updates=exclude_updates,
+        )
+        self.reconnection_timeout = 5 if reconnection_timeout < 0 else reconnection_timeout
+        self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
+        self.offset = offset
         self._stop = False
-        self.allowed_updates = ALLOWED_UPDATES
 
-    async def get_updates(self) -> typing.Optional[Raw]:
+    def get_allowed_updates(
+        self,
+        *,
+        include_updates: set[str | UpdateType] | None = None,
+        exclude_updates: set[str | UpdateType] | None = None,
+    ) -> list[str]:
+        allowed_updates: list[str] = list(x.value for x in UpdateType)
+        if not include_updates and not exclude_updates:
+            return allowed_updates
+
+        if include_updates and exclude_updates:
+            allowed_updates = [
+                x
+                for x in allowed_updates
+                if x in include_updates and x not in exclude_updates
+            ]
+        elif exclude_updates:
+            allowed_updates = [x for x in allowed_updates if x not in exclude_updates]
+        elif include_updates:
+            allowed_updates = [x for x in allowed_updates if x in include_updates]
+
+        return [x.value if isinstance(x, UpdateType) else x for x in allowed_updates]
+
+    async def get_updates(self) -> msgspec.Raw | None:
         raw_updates = await self.api.request_raw(
             "getUpdates",
             {"offset": self.offset, "allowed_updates": self.allowed_updates},
         )
-        if not raw_updates.is_ok and raw_updates.error.code == 404:
-            logger.fatal("Token seems to be invalid")
-            exit(6)
-        return raw_updates.unwrap()
+        match raw_updates:
+            case Ok(value):
+                return value
+            case Error(err) if err.code in (401, 404):
+                raise InvalidTokenError("Token seems to be invalid")
 
-    async def listen(self) -> typing.AsyncIterator[typing.List[Update]]:
-        logger.debug("listening polling")
+    async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
+        logger.debug("Listening polling")
+        reconn_counter = 0
+        
         while not self._stop:
             try:
                 updates = await self.get_updates()
-                updates_list: typing.List[Update] = msgspec.json.decode(
-                    updates, type=typing.List[Update]
+                reconn_counter = 0
+                if not updates:
+                    continue
+                updates_list: list[Update] = decoder.decode(
+                    updates, type=list[Update]
                 )
                 if updates_list:
                     yield updates_list
                     self.offset = updates_list[-1].update_id + 1
+            except InvalidTokenError as e:
+                logger.error(e)
+                self.stop()
+                exit(6)
             except asyncio.CancelledError:
-                logger.info("caught cancel, stopping")
-                self._stop = True
+                logger.info("Caught cancel, polling stopping...")
+                self.stop()
+            except (aiohttp.client.ServerConnectionError, TimeoutError):
+                if reconn_counter > self.max_reconnetions:
+                    logger.error(
+                        "Failed to reconnect to the server after {} attempts, polling stopping.",
+                        self.max_reconnetions,
+                    )
+                    self.stop()
+                    exit(9)
+                else:
+                    logger.warning("Server disconnected, waiting 5 seconds to reconnetion...")
+                    reconn_counter += 1
+                    await asyncio.sleep(self.reconnection_timeout)
+            except aiohttp.ClientConnectorError:
+                logger.error(
+                    "Client connection failed, polling stopping! "
+                    "Please, check your internet connection."
+                )
+                self.stop()
+                exit(3)
             except BaseException as e:
-                traceback.print_exc()
-                logger.error(e)
+                logger.exception(e)
 
     def stop(self) -> None:
         self._stop = True
+
+
+__all__ = ("Polling",)

telegrinder/bot/rules/__init__.py

@@ -1,15 +1,101 @@
-from .abc import ABCRule, ABCMessageRule, AndRule, OrRule
+from .abc import ABCRule, AndRule, MessageRule, OrRule
 from .callback_data import (
     CallbackDataEq,
     CallbackDataJsonEq,
     CallbackDataJsonModel,
+    CallbackDataMap,
     CallbackDataMarkup,
+    CallbackQueryDataRule,
+    CallbackQueryRule,
+    HasData,
 )
+from .command import Argument, Command
+from .enum_text import EnumTextRule
 from .func import FuncRule
-from .is_from import IsPrivate, IsChat
-from .markup import Markup
-from .regex import Regex
-from .text import Text, HasText, ABCTextMessageRule
 from .fuzzy import FuzzyText
+from .inline import (
+    HasLocation,
+    InlineQueryChatType,
+    InlineQueryMarkup,
+    InlineQueryRule,
+    InlineQueryText,
+)
 from .integer import Integer, IntegerInRange
+from .is_from import (
+    IsBasketballDice,
+    IsBot,
+    IsBowlingDice,
+    IsChat,
+    IsChatId,
+    IsDartDice,
+    IsDice,
+    IsForum,
+    IsGroup,
+    IsLanguageCode,
+    IsPremium,
+    IsPrivate,
+    IsReply,
+    IsSuperGroup,
+    IsUser,
+    IsUserId,
+)
+from .markup import Markup
+from .mention import HasMention
+from .message_entities import HasEntities, MessageEntities
+from .regex import Regex
+from .rule_enum import RuleEnum
 from .start import StartCommand
+from .text import HasText, Text, TextMessageRule
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "Argument",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
+    "Command",
+    "EnumTextRule",
+    "FuncRule",
+    "FuzzyText",
+    "HasData",
+    "HasEntities",
+    "HasMention",
+    "HasText",
+    "InlineQueryRule",
+    "InlineQueryText",
+    "Integer",
+    "IntegerInRange",
+    "IsBasketballDice",
+    "IsBot",
+    "IsBowlingDice",
+    "IsChat",
+    "IsChatId",
+    "IsDartDice",
+    "IsDice",
+    "IsForum",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSuperGroup",
+    "IsUser",
+    "IsUserId",
+    "HasLocation",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "Markup",
+    "MessageEntities",
+    "MessageRule",
+    "OrRule",
+    "Regex",
+    "RuleEnum",
+    "StartCommand",
+    "Text",
+    "TextMessageRule",
+)