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

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",
+)

telegrinder/bot/rules/abc.py

@@ -1,102 +1,120 @@
-from abc import ABC, abstractmethod
-from telegrinder.bot.cute_types import MessageCute
-from telegrinder.types import Update
-import typing
-import collections
 import inspect
-import vbml
+import typing
+from abc import ABC, abstractmethod
 
-T = typing.TypeVar("T")
-patcher = vbml.Patcher()
+from telegrinder.bot.cute_types import BaseCute, MessageCute, UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.adapter import ABCAdapter, EventAdapter, RawUpdateAdapter
+from telegrinder.tools.i18n.base import ABCTranslator
+from telegrinder.tools.magic import cache_translation, get_cached_translation
+from telegrinder.types.objects import Update as UpdateObject
 
-Message = MessageCute
-EventScheme = collections.namedtuple("EventScheme", ["name", "dataclass"])
+T = typing.TypeVar("T", bound=BaseCute)
 
+Message: typing.TypeAlias = MessageCute
+Update: typing.TypeAlias = UpdateCute
 
-class ABCRule(ABC, typing.Generic[T]):
-    __event__: typing.Optional[EventScheme] = None
-    require: typing.List["ABCRule[T]"] = []
 
-    async def run_check(self, event: T, ctx: dict) -> bool:
-        ctx_copy = ctx.copy()
-        for required in self.require:
-            if not await required.run_check(event, ctx_copy):
-                return False
-        ctx.update(ctx_copy)
-        return await self.check(event, ctx)
+def with_caching_translations(func):
+    """Should be used as decorator for .translate method. Caches rule translations."""
+
+    async def wrapper(self: "ABCRule", translator: ABCTranslator):
+        if translation := get_cached_translation(self, translator.locale):
+            return translation
+        translation = await func(self, translator)
+        cache_translation(self, translator.locale, translation)
+        return translation
+
+    return wrapper
+
+
+class ABCRule(ABC, typing.Generic[T]):
+    adapter: ABCAdapter[UpdateObject, T] = RawUpdateAdapter()  # type: ignore
+    requires: list["ABCRule[T]"] = []
 
     @abstractmethod
-    async def check(self, event: T, ctx: dict) -> bool:
+    async def check(self, event: T, ctx: Context) -> bool:
         pass
 
-    def __init_subclass__(cls, require: typing.Optional[typing.List["ABCRule[T]"]] = None):
-        """Merges requirements from inherited classes and rule-specific requirements"""
+    def __init_subclass__(cls, requires: list["ABCRule[T]"] | None = None):
+        """Merges requirements from inherited classes and rule-specific requirements."""
+
         requirements = []
         for base in inspect.getmro(cls):
             if issubclass(base, ABCRule) and base != cls:
-                requirements.extend(base.require or ())
+                requirements.extend(base.requires or ())  # type: ignore
 
-        requirements.extend(require or ())
-        cls.require = list(dict.fromkeys(requirements))
+        requirements.extend(requires or ())
+        cls.requires = list(dict.fromkeys(requirements))
 
-    def __and__(self, other: "ABCRule"):
+    def __and__(self, other: "ABCRule[T]"):
         return AndRule(self, other)
 
-    def __or__(self, other: "ABCRule"):
+    def __or__(self, other: "ABCRule[T]"):
         return OrRule(self, other)
 
+    def __neg__(self) -> "ABCRule[T]":
+        return NotRule(self)
+
     def __repr__(self) -> str:
-        return f"(rule {self.__class__.__name__})"
+        return "<rule: {!r}, adapter: {!r}>".format(
+            self.__class__.__name__,
+            self.adapter,
+        )
 
+    async def translate(self, translator: ABCTranslator) -> typing.Self:
+        return self
 
-class AndRule(ABCRule):
-    def __init__(self, *rules: ABCRule):
+
+class AndRule(ABCRule[T]):
+    def __init__(self, *rules: ABCRule[T]):
         self.rules = rules
 
-    async def check(self, event: Update, ctx: dict) -> bool:
+    async def check(self, event: Update, ctx: Context) -> bool:
         ctx_copy = ctx.copy()
         for rule in self.rules:
-            e = event
-            if rule.__event__:
-                event_dict = event.to_dict()
-                if rule.__event__.name not in event:
-                    return False
-                e = rule.__event__.dataclass(
-                    **event_dict[rule.__event__.name].to_dict()
-                )
-            if not await rule.run_check(e, ctx_copy):
+            if not await check_rule(event.ctx_api, rule, event, ctx_copy):
                 return False
-        ctx.clear()
-        ctx.update(ctx_copy)
+        ctx |= ctx_copy
         return True
 
 
-class OrRule(ABCRule):
-    def __init__(self, *rules: ABCRule):
+class OrRule(ABCRule[T]):
+    def __init__(self, *rules: ABCRule[T]):
         self.rules = rules
 
-    async def check(self, event: T, ctx: dict) -> bool:
-        ctx_copy = ctx.copy()
-        found = False
-
+    async def check(self, event: Update, ctx: Context) -> bool:
         for rule in self.rules:
-            e = event
-            if rule.__event__:
-                if rule.__event__.name not in event:
-                    continue
-                e = rule.__event__.dataclass(**event[rule.__event__.name])
-            if await rule.run_check(e, ctx_copy):
-                found = True
-                break
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, rule, event, ctx_copy):
+                ctx |= ctx_copy
+                return True
+        return False
 
-        ctx.clear()
-        ctx.update(ctx_copy)
-        return found
 
+class NotRule(ABCRule[T]):
+    def __init__(self, rule: ABCRule[T]):
+        self.rule = rule
 
-class ABCMessageRule(ABCRule, ABC, require=[]):
-    __event__ = EventScheme("message", Message)
+    async def check(self, event: Update, ctx: Context) -> bool:
+        ctx_copy = ctx.copy()
+        return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
+
+
+class MessageRule(ABCRule[Message], ABC, requires=[]):
+    adapter = EventAdapter("message", Message)
 
     @abstractmethod
-    async def check(self, message: Message, ctx: dict) -> bool:
+    async def check(self, message: Message, ctx: Context) -> bool:
         ...
+
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "MessageRule",
+    "NotRule",
+    "OrRule",
+    "with_caching_translations",
+)

telegrinder/bot/rules/adapter/__init__.py

@@ -0,0 +1,11 @@
+from .abc import ABCAdapter
+from .errors import AdapterError
+from .event import EventAdapter
+from .raw_update import RawUpdateAdapter
+
+__all__ = (
+    "ABCAdapter",
+    "AdapterError",
+    "EventAdapter",
+    "RawUpdateAdapter",
+)

telegrinder/bot/rules/adapter/abc.py

@@ -0,0 +1,21 @@
+import abc
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.model import Model
+
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+CuteT = typing.TypeVar("CuteT", bound=BaseCute)
+
+
+class ABCAdapter(abc.ABC, typing.Generic[UpdateT, CuteT]):
+    @abc.abstractmethod
+    async def adapt(self, api: ABCAPI, update: UpdateT) -> Result[CuteT, AdapterError]:
+        pass
+
+
+__all__ = ("ABCAdapter",)

telegrinder/bot/rules/adapter/errors.py

@@ -0,0 +1,5 @@
+class AdapterError(RuntimeError):
+    pass
+
+
+__all__ = ("AdapterError",)

telegrinder/bot/rules/adapter/event.py

@@ -0,0 +1,43 @@
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.rules.adapter.abc import ABCAdapter
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.msgspec_utils import Nothing
+from telegrinder.types.objects import Model, Update
+
+EventT = typing.TypeVar("EventT", bound=Model)
+CuteT = typing.TypeVar("CuteT", bound=BaseCute)
+
+
+class EventAdapter(ABCAdapter[Update, CuteT]):
+    def __init__(self, event_name: str, model: type[CuteT]):
+        self.event_name = event_name
+        self.model = model
+    
+    def __repr__(self) -> str:
+        return "<{}: adapt Update.{} -> {}>".format(
+            self.__class__.__name__,
+            self.event_name,
+            self.model.__name__,
+        )
+
+    async def adapt(self, api: ABCAPI, update: Update) -> Result[CuteT, AdapterError]:
+        update_dct = update.to_dict()
+        if self.event_name not in update_dct:
+            return Error(
+                AdapterError(f"Update is not of event type {self.event_name!r}.")
+            )
+        if update_dct[self.event_name] is Nothing:
+            return Error(
+                AdapterError(f"Update is not an {self.event_name!r}.")
+            )
+        return Ok(
+            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api)
+        )
+
+
+__all__ = ("EventAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -0,0 +1,24 @@
+from fntypes.result import Ok, Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.rules.adapter.abc import ABCAdapter
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.types.objects import Update
+
+
+class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
+
+    async def adapt(
+        self,
+        api: ABCAPI,
+        update: Update,
+    ) -> Result[UpdateCute, AdapterError]:
+        if not isinstance(update, UpdateCute):
+            return Ok(UpdateCute.from_update(update, api))
+        return Ok(update)
+
+
+__all__ = ("RawUpdateAdapter",)