telegrinder 0.1.dev168__py3-none-any.whl → 0.1.dev170__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -6,6 +6,7 @@ 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
+from telegrinder.bot.dispatch.waiter_machine.short_state import ShortStateContext
 
 if typing.TYPE_CHECKING:
     from .machine import WaiterMachine
@@ -27,7 +28,7 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         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)."
+                "provide get_state_key (ABCStateView interface)."
             )
 
         view_name = self.view.__class__.__name__
@@ -41,13 +42,36 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         short_state: "ShortState[EventType] | None" = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
-        
+
         preset_context = Context(short_state=short_state)
-        if (
-            short_state.expiration_date is not None
-            and datetime.datetime.now() >= short_state.expiration_date
+        if short_state.context is not None:
+            preset_context.update(short_state.context.context)
+
+        if short_state.expiration_date is not None and datetime.datetime.now() >= short_state.expiration_date:
+            await self.machine.drop(
+                self.view,
+                short_state.key,
+                event,
+                ctx.raw_update,
+                **preset_context.copy(),
+            )
+            return True
+
+        # before running the handler we check if the user wants to exit waiting
+        if short_state.exit_behaviour is not None and await self.machine.call_behaviour(
+            self.view,
+            event,
+            ctx.raw_update,
+            behaviour=short_state.exit_behaviour,
+            **preset_context,
         ):
-            await self.machine.drop(self.view, short_state.key, ctx.raw_update, **preset_context.copy())
+            await self.machine.drop(
+                self.view,
+                short_state.key,
+                event,
+                ctx.raw_update,
+                **preset_context.copy(),
+            )
             return True
 
         handler = FuncHandler(
@@ -78,7 +102,7 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         short_state: "ShortState[EventType]",
         ctx: Context,
     ) -> None:
-        setattr(short_state.event, "context", (event, ctx))
+        short_state.context = ShortStateContext(event, ctx)
         short_state.event.set()
 
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -5,6 +5,7 @@ import typing
 
 from telegrinder.api import ABCAPI
 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
@@ -18,23 +19,31 @@ 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
 class ShortState(typing.Generic[EventModel]):
     key: "Identificator"
     ctx_api: ABCAPI
     event: asyncio.Event
-    rules: tuple[ABCRule[EventModel], ...]
-    _: dataclasses.KW_ONLY
+    rules: tuple[ABCRule, ...]
     expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
         default=None,
+        kw_only=True,
     )
-    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
-    on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
-    expiration_date: datetime.datetime | None = dataclasses.field(init=False)
+    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
+    on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
+    exit_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
+    expiration_date: datetime.datetime | None = dataclasses.field(init=False, kw_only=True)
+    context: ShortStateContext[EventModel] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
-        self.expiration_date = (datetime.datetime.now() - expiration) if expiration is not None else None
-    
+        self.creation_date = datetime.datetime.now()
+        self.expiration_date = (self.creation_date + expiration) if expiration is not None else None
+
     def cancel(self) -> None:
         """Cancel schedule waiters."""
 
@@ -46,4 +55,4 @@ class ShortState(typing.Generic[EventModel]):
             future.cancel()
 
 
-__all__ = ("ShortState",)
+__all__ = ("ShortState", "ShortStateContext")

telegrinder/bot/polling/polling.py

@@ -97,7 +97,7 @@ class Polling(ABCPolling):
             except InvalidTokenError as e:
                 logger.error(e)
                 self.stop()
-                exit(6)
+                exit(3)
             except asyncio.CancelledError:
                 logger.info("Caught cancel, polling stopping...")
                 self.stop()
@@ -108,14 +108,14 @@ class Polling(ABCPolling):
                         self.max_reconnetions,
                     )
                     self.stop()
-                    exit(9)
+                    exit(6)
                 else:
                     logger.warning(
-                        "Server disconnected, waiting 5 seconds to reconnetion...",
+                        "Server disconnected, waiting 5 seconds to reconnet...",
                     )
                     reconn_counter += 1
                     await asyncio.sleep(self.reconnection_timeout)
-            except aiohttp.ClientConnectorError:
+            except (aiohttp.ClientConnectorError, aiohttp.ClientOSError):
                 logger.error("Client connection failed, attempted to reconnect...")
                 await asyncio.sleep(self.reconnection_timeout)
             except BaseException as e:

telegrinder/bot/rules/__init__.py

@@ -26,11 +26,12 @@ from .inline import (
     InlineQueryRule,
     InlineQueryText,
 )
-from .integer import Integer, IntegerInRange
+from .integer import IntegerInRange, IsInteger
 from .is_from import (
     IsBot,
     IsChat,
     IsChatId,
+    IsDice,
     IsDiceEmoji,
     IsForum,
     IsForward,
@@ -48,11 +49,12 @@ from .markup import Markup
 from .mention import HasMention
 from .message import MessageRule
 from .message_entities import HasEntities, MessageEntities
+from .node import NodeRule
 from .regex import Regex
 from .rule_enum import RuleEnum
 from .start import StartCommand
-from .text import HasText, Text, TextMessageRule
-from .update import IsUpdate
+from .text import HasText, Text
+from .update import IsUpdateType
 
 __all__ = (
     "ABCRule",
@@ -80,13 +82,14 @@ __all__ = (
     "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "Integer",
+    "IsInteger",
     "IntegerInRange",
     "InviteLinkByCreator",
     "InviteLinkName",
     "IsBot",
     "IsChat",
     "IsChatId",
+    "IsDice",
     "IsDiceEmoji",
     "IsForum",
     "IsForward",
@@ -97,7 +100,7 @@ __all__ = (
     "IsPrivate",
     "IsReply",
     "IsSuperGroup",
-    "IsUpdate",
+    "IsUpdateType",
     "IsUser",
     "IsUserId",
     "Markup",
@@ -109,5 +112,5 @@ __all__ = (
     "RuleEnum",
     "StartCommand",
     "Text",
-    "TextMessageRule",
+    "NodeRule",
 )

telegrinder/bot/rules/abc.py

@@ -1,25 +1,29 @@
 import inspect
-import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.bot.cute_types import BaseCute, MessageCute, UpdateCute
+import typing_extensions as typing
+
+from telegrinder.bot.cute_types import 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.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
+from telegrinder.bot.rules.adapter.node import Event
+from telegrinder.node.base import Node, is_node
+from telegrinder.node.composer import NodeCollection
 from telegrinder.tools.i18n.base import ABCTranslator
-from telegrinder.tools.magic import cache_translation, get_cached_translation
+from telegrinder.tools.magic import cache_translation, get_annotations, get_cached_translation
 from telegrinder.types.objects import Update as UpdateObject
 
-T = typing.TypeVar("T", bound=BaseCute)
+AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any)
 
 Message: typing.TypeAlias = MessageCute
 Update: typing.TypeAlias = UpdateCute
 
 
-def with_caching_translations(func):
+def with_caching_translations(func: typing.Callable[..., typing.Any]):
     """Should be used as decorator for .translate method. Caches rule translations."""
 
-    async def wrapper(self: "ABCRule[typing.Any]", translator: ABCTranslator):
+    async def wrapper(self: "ABCRule", translator: ABCTranslator):
         if translation := get_cached_translation(self, translator.locale):
             return translation
         translation = await func(self, translator)
@@ -29,15 +33,52 @@ def with_caching_translations(func):
     return wrapper
 
 
-class ABCRule(ABC, typing.Generic[T]):
-    adapter: ABCAdapter[UpdateObject, T] = RawUpdateAdapter()  # type: ignore
-    requires: list["ABCRule[T]"] = []
+class ABCRule(ABC, typing.Generic[AdaptTo]):
+    adapter: ABCAdapter[UpdateObject, AdaptTo] = RawUpdateAdapter()  # type: ignore
+    requires: list["ABCRule"] = []
 
     @abstractmethod
-    async def check(self, event: T, ctx: Context) -> bool:
+    async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
         pass
 
-    def __init_subclass__(cls, requires: list["ABCRule[T]"] | None = None):
+    def get_required_nodes(self) -> dict[str, type[Node]]:
+        return {k: v for k, v in get_annotations(self.check).items() if is_node(v)}
+
+    async def bounding_check(
+        self,
+        adapted_value: AdaptTo,
+        ctx: Context,
+        node_col: NodeCollection | None = None,
+    ) -> bool:
+        kw = {}
+        node_col_values = node_col.values() if node_col is not None else {}
+
+        for i, (k, v) in enumerate(get_annotations(self.check).items()):
+            if (isinstance(adapted_value, Event) and not i) or (
+                isinstance(v, type) and isinstance(adapted_value, v)
+            ):
+                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
+            elif is_node(v):
+                assert k in node_col_values, "Node is undefined, error while bounding."
+                kw[k] = node_col_values[k]
+            elif k in ctx:
+                kw[k] = ctx[k]
+            elif v is Context:
+                kw[k] = ctx
+            else:
+                raise LookupError(
+                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__name__}.check()', because it cannot be resolved."
+                )
+
+        return await self.check(**kw)
+
+    def optional(self) -> "ABCRule":
+        return self | Always()
+
+    def should_fail(self) -> "ABCRule":
+        return self & Never()
+
+    def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
 
         requirements = []
@@ -48,17 +89,41 @@ class ABCRule(ABC, typing.Generic[T]):
         requirements.extend(requires or ())
         cls.requires = list(dict.fromkeys(requirements))
 
-    def __and__(self, other: "ABCRule[T]"):
+    def __and__(self, other: "ABCRule") -> "AndRule":
+        """And Rule.
+
+        ```python
+        rule = HasText() & HasCaption()
+        rule #> AndRule(HasText(), HasCaption()) -> True if all rules in an AndRule are True, otherwise False.
+        ```
+        """
+
         return AndRule(self, other)
 
-    def __or__(self, other: "ABCRule[T]"):
+    def __or__(self, other: "ABCRule") -> "OrRule":
+        """Or Rule.
+
+        ```python
+        rule = HasText() | HasCaption()
+        rule #> OrRule(HasText(), HasCaption()) -> True if any rule in an OrRule are True, otherwise False.
+        ```
+        """
+
         return OrRule(self, other)
 
-    def __neg__(self) -> "ABCRule[T]":
+    def __invert__(self) -> "NotRule":
+        """Not Rule.
+
+        ```python
+        rule = ~HasText()
+        rule # NotRule(HasText()) -> True if rule returned False, otherwise False.
+        ```
+        """
+
         return NotRule(self)
 
     def __repr__(self) -> str:
-        return "<rule: {!r}, adapter: {!r}>".format(
+        return "<{}: adapter={!r}>".format(
             self.__class__.__name__,
             self.adapter,
         )
@@ -67,8 +132,8 @@ class ABCRule(ABC, typing.Generic[T]):
         return self
 
 
-class AndRule(ABCRule[T]):
-    def __init__(self, *rules: ABCRule[T]):
+class AndRule(ABCRule):
+    def __init__(self, *rules: ABCRule[AdaptTo]) -> None:
         self.rules = rules
 
     async def check(self, event: Update, ctx: Context) -> bool:
@@ -80,8 +145,8 @@ class AndRule(ABCRule[T]):
         return True
 
 
-class OrRule(ABCRule[T]):
-    def __init__(self, *rules: ABCRule[T]):
+class OrRule(ABCRule):
+    def __init__(self, *rules: ABCRule) -> None:
         self.rules = rules
 
     async def check(self, event: Update, ctx: Context) -> bool:
@@ -93,8 +158,8 @@ class OrRule(ABCRule[T]):
         return False
 
 
-class NotRule(ABCRule[T]):
-    def __init__(self, rule: ABCRule[T]):
+class NotRule(ABCRule):
+    def __init__(self, rule: ABCRule) -> None:
         self.rule = rule
 
     async def check(self, event: Update, ctx: Context) -> bool:
@@ -102,10 +167,22 @@ class NotRule(ABCRule[T]):
         return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
 
 
+class Never(ABCRule):
+    async def check(self) -> typing.Literal[False]:
+        return False
+
+
+class Always(ABCRule):
+    async def check(self) -> typing.Literal[True]:
+        return True
+
+
 __all__ = (
     "ABCRule",
     "AndRule",
     "NotRule",
     "OrRule",
     "with_caching_translations",
+    "Never",
+    "Always",
 )

telegrinder/bot/rules/adapter/__init__.py

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

telegrinder/bot/rules/adapter/abc.py

@@ -1,21 +1,26 @@
 import abc
+import dataclasses
 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)
+From = typing.TypeVar("From", bound=Model)
+To = typing.TypeVar("To")
 
 
-class ABCAdapter(abc.ABC, typing.Generic[UpdateT, CuteT]):
+class ABCAdapter(abc.ABC, typing.Generic[From, To]):
     @abc.abstractmethod
-    async def adapt(self, api: ABCAPI, update: UpdateT) -> Result[CuteT, AdapterError]:
+    async def adapt(self, api: ABCAPI, update: From) -> Result[To, AdapterError]:
         pass
 
 
-__all__ = ("ABCAdapter",)
+@dataclasses.dataclass
+class Event(typing.Generic[To]):
+    obj: To
+
+
+__all__ = ("ABCAdapter", "Event")

telegrinder/bot/rules/adapter/errors.py

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

telegrinder/bot/rules/adapter/event.py

@@ -7,13 +7,14 @@ 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.enums import UpdateType
 from telegrinder.types.objects import Model, Update
 
-CuteT = typing.TypeVar("CuteT", bound=BaseCute)
+ToCute = typing.TypeVar("ToCute", bound=BaseCute)
 
 
-class EventAdapter(ABCAdapter[Update, CuteT]):
-    def __init__(self, event: str | type[Model], cute_model: type[CuteT]) -> None:
+class EventAdapter(ABCAdapter[Update, ToCute]):
+    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
         self.event = event
         self.cute_model = cute_model
 
@@ -27,27 +28,31 @@ class EventAdapter(ABCAdapter[Update, CuteT]):
             )
         else:
             raw_update_type = self.event.__name__
+
         return "<{}: adapt {} -> {}>".format(
             self.__class__.__name__,
             raw_update_type,
             self.cute_model.__name__,
         )
 
-    async def adapt(self, api: ABCAPI, update: Update) -> Result[CuteT, AdapterError]:
+    async def adapt(self, api: ABCAPI, update: Update) -> Result[ToCute, AdapterError]:
         update_dct = update.to_dict()
-        if isinstance(self.event, str):
-            if self.event not in update_dct:
+        if isinstance(self.event, UpdateType):
+            if update.update_type != self.event:
                 return Error(
                     AdapterError(f"Update is not of event type {self.event!r}."),
                 )
-            if update_dct[self.event] is Nothing:
+
+            if update_dct[self.event.value] is Nothing:
                 return Error(
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
+
             return Ok(
-                self.cute_model.from_update(update_dct[self.event].unwrap(), bound_api=api),
+                self.cute_model.from_update(update_dct[self.event.value].unwrap(), bound_api=api),
             )
-        event = update_dct[update.update_type.unwrap()].unwrap()
+
+        event = update_dct[update.update_type.value].unwrap()
         if not update.update_type or not issubclass(event.__class__, self.event):
             return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
         return Ok(self.cute_model.from_update(event, bound_api=api))

telegrinder/bot/rules/adapter/node.py

@@ -0,0 +1,42 @@
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.node.base import ComposeError
+from telegrinder.node.composer import NodeSession, compose_node
+from telegrinder.types.objects import Update
+
+Ts = typing.TypeVarTuple("Ts")
+
+
+class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
+    def __init__(self, *nodes: *Ts) -> None:
+        self.nodes = nodes
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> {}>".format(
+            self.__class__.__name__,
+            Update.__name__,
+            ", ".join(node.__name__ for node in self.nodes),  # type: ignore
+        )
+
+    async def adapt(self, api: ABCAPI, update: Update) -> Result[Event[tuple[*Ts]], AdapterError]:
+        update_cute = UpdateCute.from_update(update, api)
+        node_sessions: list[NodeSession] = []
+        for node_t in self.nodes:
+            try:
+                # FIXME: adapters should have context
+                node_sessions.append(await compose_node(node_t, update_cute, Context()))  # type: ignore
+            except ComposeError:
+                for session in node_sessions:
+                    await session.close(with_value=None)
+                return Error(AdapterError(f"Couldn't compose nodes, error on {node_t}"))
+        return Ok(Event(tuple(node_sessions)))  # type: ignore
+
+
+__all__ = ("NodeAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -10,6 +10,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter import EventAdapter
 from telegrinder.model import decoder
 from telegrinder.tools.buttons import DataclassInstance
+from telegrinder.types.enums import UpdateType
 
 from .abc import ABCRule
 from .markup import Markup, PatternLike, check_string
@@ -22,7 +23,7 @@ CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapSt
 
 
 class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
-    adapter = EventAdapter("callback_query", CallbackQuery)
+    adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
 
     @abc.abstractmethod
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -31,7 +32,7 @@ class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
 
 class HasData(CallbackQueryRule):
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        return bool(event.data or event.data.unwrap())
+        return bool(event.data.unwrap_or_none())
 
 
 class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
@@ -98,8 +99,7 @@ class CallbackDataMap(CallbackQueryDataRule):
 
             if isinstance(validator, list):
                 if not (
-                    isinstance(callback_data[key], dict)
-                    and await cls.match(callback_data[key], validator)
+                    isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)
                 ):
                     return False
 

telegrinder/bot/rules/chat_join.py

@@ -4,14 +4,15 @@ import typing
 from telegrinder.bot.cute_types import ChatJoinRequestCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.types.enums import UpdateType
 
 from .abc import ABCRule
 
 ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
 
 
-class ChatJoinRequestRule(ABCRule[ChatJoinRequestCute], requires=[]):
-    adapter = EventAdapter("chat_join_request", ChatJoinRequest)
+class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
+    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
 
     @abc.abstractmethod
     async def check(self, event: ChatJoinRequest, ctx: Context) -> bool: