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

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -1,68 +1,57 @@
-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
-
-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
-    context: Context
-
-
-@dataclasses.dataclass(slots=True)
-class ShortState(typing.Generic[EventModel]):
-    event: asyncio.Event
-    actions: "WaiterActions[EventModel]"
-
-    release: ABCRule | None = dataclasses.field(
-        default=None,
-        kw_only=True,
-    )
-    filter: ABCRule | None = dataclasses.field(
-        default=None,
-        kw_only=True,
-    )
-
-    lifetime: dataclasses.InitVar[datetime.timedelta | 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:
-        self.creation_date = datetime.datetime.now()
-        self.expiration_date = (self.creation_date + expiration) if expiration is not None else None
-
-    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
-
-
-__all__ = ("ShortState", "ShortStateContext")
+import asyncio
+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
+
+if typing.TYPE_CHECKING:
+    from .actions import WaiterActions
+
+
+class ShortStateContext[Event: BaseCute](typing.NamedTuple):
+    event: Event
+    context: Context
+
+
+@dataclasses.dataclass(slots=True)
+class ShortState[Event: BaseCute]:
+    event: asyncio.Event
+    actions: "WaiterActions[Event]"
+
+    release: ABCRule | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    filter: ABCRule | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+
+    lifetime: dataclasses.InitVar[datetime.timedelta | 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[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()
+        self.expiration_date = (self.creation_date + expiration) if expiration is not None else None
+
+    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:
+            await cancel_future(future)
+
+
+__all__ = ("ShortState", "ShortStateContext")

telegrinder/bot/polling/__init__.py

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

telegrinder/bot/polling/abc.py

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

telegrinder/bot/polling/polling.py

@@ -1,131 +1,139 @@
-import asyncio
-import typing
-
-import aiohttp
-import msgspec
-from fntypes.result import Error, Ok
-
-from telegrinder.api.api import API
-from telegrinder.api.error import InvalidTokenError
-from telegrinder.bot.polling.abc import ABCPolling
-from telegrinder.modules import logger
-from telegrinder.msgspec_utils import decoder
-from telegrinder.types.objects import Update, UpdateType
-
-
-class Polling(ABCPolling):
-    def __init__(
-        self,
-        api: API,
-        *,
-        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,
-    ) -> None:
-        self.api = api
-        self.allowed_updates = self.get_allowed_updates(
-            include_updates=include_updates,
-            exclude_updates=exclude_updates,
-        )
-        self.reconnection_timeout = 5.0 if reconnection_timeout < 0 else reconnection_timeout
-        self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
-        self.offset = offset
-        self._stop = False
-
-    def __repr__(self) -> str:
-        return (
-            "<{}: with api={!r}, stopped={}, offset={}, allowed_updates={!r}, "
-            "max_reconnetions={}, reconnection_timeout={}>"
-        ).format(
-            self.__class__.__name__,
-            self.api,
-            self._stop,
-            self.offset,
-            self.allowed_updates,
-            self.max_reconnetions,
-            self.reconnection_timeout,
-        )
-
-    @staticmethod
-    def get_allowed_updates(
-        *,
-        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,
-            },
-        )
-        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.AsyncGenerator[list[Update], None]:
-        logger.debug("Listening polling")
-        reconn_counter = 0
-
-        while not self._stop:
-            try:
-                updates = await self.get_updates()
-                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(3)
-            except asyncio.CancelledError:
-                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(6)
-                else:
-                    logger.warning(
-                        "Server disconnected, waiting 5 seconds to reconnect...",
-                    )
-                    reconn_counter += 1
-                    await asyncio.sleep(self.reconnection_timeout)
-            except (aiohttp.ClientConnectorError, aiohttp.ClientOSError):
-                logger.error("Client connection failed, attempted to reconnect...")
-                await asyncio.sleep(self.reconnection_timeout)
-            except BaseException as e:
-                logger.exception(e)
-
-    def stop(self) -> None:
-        self._stop = True
-
-
-__all__ = ("Polling",)
+import asyncio
+import sys
+import typing
+from http import HTTPStatus
+
+import msgspec
+from fntypes.result import Error, Ok
+
+from telegrinder.api.api import API, HTTPClient
+from telegrinder.api.error import APIServerError, InvalidTokenError
+from telegrinder.bot.polling.abc import ABCPolling
+from telegrinder.modules import logger
+from telegrinder.msgspec_utils import decoder
+from telegrinder.types.objects import Update, UpdateType
+
+
+class Polling(ABCPolling, typing.Generic[HTTPClient]):
+    def __init__(
+        self,
+        api: API[HTTPClient],
+        *,
+        offset: int = 0,
+        reconnection_timeout: float = 5.0,
+        max_reconnetions: int = 15,
+        include_updates: set[str | UpdateType] | None = None,
+        exclude_updates: set[str | UpdateType] | None = None,
+    ) -> None:
+        self.api = api
+        self.allowed_updates = self.get_allowed_updates(
+            include_updates=include_updates,
+            exclude_updates=exclude_updates,
+        )
+        self.reconnection_timeout = 5.0 if reconnection_timeout < 0 else reconnection_timeout
+        self.max_reconnetions = 15 if max_reconnetions < 0 else max_reconnetions
+        self.offset = offset
+        self._stop = True
+
+    def __repr__(self) -> str:
+        return (
+            "<{}: with api={!r}, stopped={}, offset={}, allowed_updates={!r}, "
+            "max_reconnetions={}, reconnection_timeout={}>"
+        ).format(
+            self.__class__.__name__,
+            self.api,
+            self._stop,
+            self.offset,
+            self.allowed_updates,
+            self.max_reconnetions,
+            self.reconnection_timeout,
+        )
+
+    @staticmethod
+    def get_allowed_updates(
+        *,
+        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:
+        raw_updates = await self.api.request_raw(
+            method="getUpdates",
+            data=dict(
+                offset=self.offset,
+                allowed_updates=self.allowed_updates,
+            ),
+        )
+
+        match raw_updates:
+            case Ok(value):
+                return value
+            case Error(err):
+                if err.code in (HTTPStatus.UNAUTHORIZED, HTTPStatus.NOT_FOUND):
+                    raise InvalidTokenError("Token seems to be invalid")
+                if err.code in (HTTPStatus.BAD_GATEWAY, HTTPStatus.GATEWAY_TIMEOUT):
+                    raise APIServerError("Unavilability of the API Telegram server")
+                raise err from None
+
+    async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
+        logger.debug("Listening polling")
+        reconn_counter = 0
+        self._stop = False
+
+        with decoder(list[Update]) as dec:  # For improve performance
+            while not self._stop:
+                try:
+                    updates = await self.get_updates()
+                    reconn_counter = 0
+                    updates_list = dec.decode(updates)
+                    if updates_list:
+                        yield updates_list
+                        self.offset = updates_list[-1].update_id + 1
+                except InvalidTokenError as e:
+                    logger.error(e)
+                    self.stop()
+                    sys.exit(3)
+                except APIServerError as e:
+                    logger.error(f"{e}, waiting {self.reconnection_timeout} seconds to the next request...")
+                    await asyncio.sleep(self.reconnection_timeout)
+                except asyncio.CancelledError:
+                    logger.info("Caught cancel, polling stopping...")
+                    self.stop()
+                except self.api.http.CONNECTION_TIMEOUT_ERRORS:
+                    if reconn_counter > self.max_reconnetions:
+                        logger.error(
+                            "Failed to reconnect to the server after {} attempts, polling stopping.",
+                            self.max_reconnetions,
+                        )
+                        self.stop()
+                        sys.exit(6)
+                    else:
+                        logger.warning(
+                            "Server disconnected, waiting {} seconds to reconnect...",
+                            self.reconnection_timeout,
+                        )
+                        reconn_counter += 1
+                        await asyncio.sleep(self.reconnection_timeout)
+                except self.api.http.CLIENT_CONNECTION_ERRORS:
+                    logger.error("Client connection failed, attempted to reconnect...")
+                    await asyncio.sleep(self.reconnection_timeout)
+                except BaseException as e:
+                    logger.exception("Traceback message below:")
+
+    def stop(self) -> None:
+        self._stop = True
+
+
+__all__ = ("Polling",)

telegrinder/bot/rules/__init__.py

@@ -1,63 +1,76 @@
-from telegrinder.bot.rules.abc import ABCRule, AndRule, NotRule, OrRule
-from telegrinder.bot.rules.callback_data import (
-    CallbackDataEq,
-    CallbackDataJsonEq,
-    CallbackDataJsonModel,
-    CallbackDataMap,
-    CallbackDataMarkup,
-    CallbackQueryDataRule,
-    CallbackQueryRule,
-    HasData,
-)
-from telegrinder.bot.rules.chat_join import (
-    ChatJoinRequestRule,
-    HasInviteLink,
-    InviteLinkByCreator,
-    InviteLinkName,
-)
-from telegrinder.bot.rules.command import Argument, Command
-from telegrinder.bot.rules.enum_text import EnumTextRule
-from telegrinder.bot.rules.func import FuncRule
-from telegrinder.bot.rules.fuzzy import FuzzyText
-from telegrinder.bot.rules.inline import (
-    HasLocation,
-    InlineQueryChatType,
-    InlineQueryMarkup,
-    InlineQueryRule,
-    InlineQueryText,
-)
-from telegrinder.bot.rules.integer import IntegerInRange, IsInteger
-from telegrinder.bot.rules.is_from import (
-    IsBot,
-    IsChat,
-    IsChatId,
-    IsDice,
-    IsDiceEmoji,
-    IsForum,
-    IsForward,
-    IsForwardType,
-    IsGroup,
-    IsLanguageCode,
-    IsPremium,
-    IsPrivate,
-    IsReply,
-    IsSuperGroup,
-    IsUser,
-    IsUserId,
-)
-from telegrinder.bot.rules.markup import Markup
-from telegrinder.bot.rules.mention import HasMention
-from telegrinder.bot.rules.message import MessageRule
-from telegrinder.bot.rules.message_entities import HasEntities, MessageEntities
-from telegrinder.bot.rules.node import NodeRule
-from telegrinder.bot.rules.regex import Regex
-from telegrinder.bot.rules.rule_enum import RuleEnum
-from telegrinder.bot.rules.start import StartCommand
-from telegrinder.bot.rules.state import State, StateMeta
-from telegrinder.bot.rules.text import HasText, Text
-from telegrinder.bot.rules.update import IsUpdateType
-
-__all__ = (
+from telegrinder.bot.rules.abc import ABCRule, AndRule, NotRule, OrRule
+from telegrinder.bot.rules.callback_data import (
+    CallbackDataEq,
+    CallbackDataJsonEq,
+    CallbackDataJsonModel,
+    CallbackDataMap,
+    CallbackDataMarkup,
+    CallbackQueryDataRule,
+    CallbackQueryRule,
+    HasData,
+)
+from telegrinder.bot.rules.chat_join import (
+    ChatJoinRequestRule,
+    HasInviteLink,
+    InviteLinkByCreator,
+    InviteLinkName,
+)
+from telegrinder.bot.rules.command import Argument, Command
+from telegrinder.bot.rules.enum_text import EnumTextRule
+from telegrinder.bot.rules.func import FuncRule
+from telegrinder.bot.rules.fuzzy import FuzzyText
+from telegrinder.bot.rules.id import IdRule
+from telegrinder.bot.rules.inline import (
+    HasLocation,
+    InlineQueryChatType,
+    InlineQueryMarkup,
+    InlineQueryRule,
+    InlineQueryText,
+)
+from telegrinder.bot.rules.integer import IntegerInRange, IsInteger
+from telegrinder.bot.rules.is_from import (
+    IsBot,
+    IsChat,
+    IsChatId,
+    IsDice,
+    IsDiceEmoji,
+    IsForum,
+    IsForward,
+    IsForwardType,
+    IsGroup,
+    IsLanguageCode,
+    IsPremium,
+    IsPrivate,
+    IsReply,
+    IsSuperGroup,
+    IsUser,
+    IsUserId,
+)
+from telegrinder.bot.rules.logic import If
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.bot.rules.mention import HasMention
+from telegrinder.bot.rules.message import MessageRule
+from telegrinder.bot.rules.message_entities import HasEntities, MessageEntities
+from telegrinder.bot.rules.node import NodeRule
+from telegrinder.bot.rules.payload import (
+    PayloadEqRule,
+    PayloadJsonEqRule,
+    PayloadMarkupRule,
+    PayloadModelRule,
+    PayloadRule,
+)
+from telegrinder.bot.rules.payment_invoice import (
+    PaymentInvoiceCurrency,
+    PaymentInvoiceRule,
+)
+from telegrinder.bot.rules.regex import Regex
+from telegrinder.bot.rules.rule_enum import RuleEnum
+from telegrinder.bot.rules.start import StartCommand
+from telegrinder.bot.rules.state import State, StateMeta
+from telegrinder.bot.rules.text import HasCaption, HasText, Text
+from telegrinder.bot.rules.update import IsUpdateType
+
+__all__ = (
     "ABCRule",
     "AndRule",
     "Argument",
@@ -73,12 +86,15 @@ __all__ = (
     "EnumTextRule",
     "FuncRule",
     "FuzzyText",
+    "HasCaption",
     "HasData",
     "HasEntities",
     "HasInviteLink",
     "HasLocation",
     "HasMention",
     "HasText",
+    "IdRule",
+    "If",
     "InlineQueryChatType",
     "InlineQueryMarkup",
     "InlineQueryRule",
@@ -110,10 +126,17 @@ __all__ = (
     "NodeRule",
     "NotRule",
     "OrRule",
+    "PayloadEqRule",
+    "PayloadJsonEqRule",
+    "PayloadMarkupRule",
+    "PayloadModelRule",
+    "PayloadRule",
+    "PaymentInvoiceCurrency",
+    "PaymentInvoiceRule",
     "Regex",
     "RuleEnum",
     "StartCommand",
     "State",
     "StateMeta",
-    "Text",
-)
+    "Text",
+)