telegrinder 0.1.dev165__py3-none-any.whl → 0.1.dev166__py3-none-any.whl

telegrinder/bot/cute_types/message.py

@@ -14,6 +14,7 @@ from telegrinder.types import (
     InlineKeyboardMarkup,
     InputFile,
     InputMedia,
+    InputPollOption,
     LabeledPrice,
     LinkPreviewOptions,
     Message,
@@ -80,7 +81,7 @@ async def execute_method_answer(
         params["link_preview_options"] = compose_link_preview_options(
             **link_preview_options
         )
-        
+
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
         lambda x: (
@@ -1213,10 +1214,12 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def answer_poll(
         self,
         question: str,
-        options: list[str],
+        options: list[InputPollOption],
         chat_id: int | str | None = None,
         business_connection_id: str | None = None,
         message_thread_id: int | None = None,
+        question_parse_mode: str | None = None,
+        question_entities: list[MessageEntity] | None = None,
         is_anonymous: bool | None = None,
         type: typing.Literal["quiz", "regular"] | None = None,
         allows_multiple_answers: bool | None = None,
@@ -1246,10 +1249,15 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
         forum supergroups only.
 
+        :param question_parse_mode: Mode for parsing entities in the question. See formatting options for more \
+        details. Currently, only custom emoji entities are allowed.
+
+        :param question_entities: A JSON-serialized list of special entities that appear in the poll question. \
+        It can be specified instead of question_parse_mode.
+
         :param question: Poll question, 1-300 characters.
 
-        :param options: A JSON-serialized list of answer options, 2-10 strings 1-100 characters \
-        each.
+        :param options: A JSON-serialized list of 2-10 answer options.
 
         :param is_anonymous: True, if the poll needs to be anonymous, defaults to True.
 
@@ -2365,10 +2373,12 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def reply_poll(
         self,
         question: str,
-        options: list[str],
+        options: list[InputPollOption],
         chat_id: int | str | None = None,
         business_connection_id: str | None = None,
         message_thread_id: int | None = None,
+        question_parse_mode: str | None = None,
+        question_entities: list[MessageEntity] | None = None,
         is_anonymous: bool | None = None,
         type: typing.Literal["quiz", "regular"] | None = None,
         allows_multiple_answers: bool | None = None,
@@ -2398,10 +2408,15 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
         forum supergroups only.
 
+        :param question_parse_mode: Mode for parsing entities in the question. See formatting options for more \
+        details. Currently, only custom emoji entities are allowed.
+
+        :param question_entities: A JSON-serialized list of special entities that appear in the poll question. \
+        It can be specified instead of question_parse_mode.
+
         :param question: Poll question, 1-300 characters.
 
-        :param options: A JSON-serialized list of answer options, 2-10 strings 1-100 characters \
-        each.
+        :param options: A JSON-serialized list of 2-10 answer options.
 
         :param is_anonymous: True, if the poll needs to be anonymous, defaults to True.
 
@@ -2910,6 +2925,8 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         chat_id: int | str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
+        inline_message_id: str | None = None,
+        live_period: int | None = None,
         horizontal_accuracy: float | None = None,
         heading: int | None = None,
         proximity_alert_radius: int | None = None,
@@ -2932,6 +2949,16 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
         forum supergroups only.
 
+        :param live_period: New period in seconds during which the location can be updated, starting \
+        from the message send date. If 0x7FFFFFFF is specified, then the location \
+        can be updated forever. Otherwise, the new value must not exceed the current \
+        live_period by more than a day, and the live location expiration date must \
+        remain within the next 90 days. If not specified, then live_period remains \
+        unchanged.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
         :param latitude: Latitude of new location.
 
         :param longitude: Longitude of new location.

telegrinder/bot/cute_types/update.py

@@ -15,15 +15,16 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     api: ABCAPI
 
     @property
-    def incoming_update(self) -> Model:
+    def incoming_update(self) -> Option[Model]:
         return getattr(
             self,
             self.update_type.expect("Update object has no incoming update.").value,
         )
-    
+
     def get_event(self, event_model: type[ModelT]) -> Option[ModelT]:
-        if isinstance(self.incoming_update, event_model):
-            return Some(self.incoming_update)
+        match self.incoming_update:
+            case Some(event) if isinstance(event, event_model):
+                return Some(event)
         return Nothing()
 
 

telegrinder/bot/cute_types/utils.py

@@ -2,6 +2,7 @@ import typing
 
 from telegrinder.model import get_params
 from telegrinder.types import (
+    ChatPermissions,
     InlineKeyboardMarkup,
     InlineQueryResultArticle,
     InlineQueryResultAudio,
@@ -115,6 +116,26 @@ def compose_link_preview_options(
     return LinkPreviewOptions(**get_params(locals()))
 
 
+def compose_chat_permissions(
+    *,
+    can_send_messages: bool | None = None,
+    can_send_audios: bool | None = None,
+    can_send_documents: bool | None = None,
+    can_send_photos: bool | None = None,
+    can_send_videos: bool | None = None,
+    can_send_video_notes: bool | None = None,
+    can_send_voice_notes: bool | None = None,
+    can_send_polls: bool | None = None,
+    can_send_other_messages: bool | None = None,
+    can_add_web_page_previews: bool | None = None,
+    can_change_info: bool | None = None,
+    can_invite_users: bool | None = None,
+    can_pin_messages: bool | None = None,
+    can_manage_topics: bool | None = None,
+) -> ChatPermissions:
+    return ChatPermissions(**get_params(locals()))
+
+
 def input_media(
     type: typing.Literal["animation", "audio", "document", "photo", "video"],
     media: str | InputFile,
@@ -510,33 +531,34 @@ def inline_query_cached_photo(
 
 
 __all__ = (
+    "compose_chat_permissions",
     "compose_link_preview_options",
     "compose_reactions",
     "compose_reply_params",
     "inline_query_article",
-    "inline_query_photo",
-    "inline_query_mpeg4_gif",
-    "inline_query_gif",
-    "inline_query_video",
     "inline_query_audio",
-    "inline_query_voice",
-    "inline_query_document",
-    "inline_query_location",
-    "inline_query_venue",
-    "inline_query_contact",
-    "inline_query_game",
-    "inline_query_cached_sticker",
-    "inline_query_cached_document",
     "inline_query_cached_audio",
-    "inline_query_cached_video",
+    "inline_query_cached_document",
     "inline_query_cached_gif",
     "inline_query_cached_mpeg4_gif",
-    "inline_query_cached_voice",
     "inline_query_cached_photo",
+    "inline_query_cached_sticker",
+    "inline_query_cached_video",
+    "inline_query_cached_voice",
+    "inline_query_contact",
+    "inline_query_document",
+    "inline_query_game",
+    "inline_query_gif",
+    "inline_query_location",
+    "inline_query_mpeg4_gif",
+    "inline_query_photo",
+    "inline_query_venue",
+    "inline_query_video",
+    "inline_query_voice",
+    "input_contact_message_content",
+    "input_invoice_message_content",
+    "input_location_message_content",
     "input_media",
     "input_text_message_content",
-    "input_location_message_content",
     "input_venue_message_content",
-    "input_contact_message_content",
-    "input_invoice_message_content",
 )

telegrinder/bot/dispatch/__init__.py

@@ -20,11 +20,14 @@ from .view import (
     BaseStateView,
     BaseView,
     CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
     InlineQueryView,
     MessageView,
+    RawEventView,
     ViewBox,
 )
-from .waiter_machine import WaiterMachine
+from .waiter_machine import ShortState, ShortStateStorage, WaiterMachine
 
 __all__ = (
     "ABCDispatch",
@@ -39,6 +42,8 @@ __all__ = (
     "BaseView",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
+    "ChatJoinRequestView",
+    "ChatMemberView",
     "CompositionDispatch",
     "Context",
     "Dispatch",
@@ -49,6 +54,9 @@ __all__ = (
     "MessageReplyHandler",
     "MessageReturnManager",
     "MessageView",
+    "RawEventView",
+    "ShortState",
+    "ShortStateStorage",
     "TelegrinderCtx",
     "ViewBox",
     "WaiterMachine",

telegrinder/bot/dispatch/composition.py

@@ -26,15 +26,14 @@ class Composition:
             for name, parameter in inspect.signature(func).parameters.items()
         }
         self.is_blocking = is_blocking
-    
+
     def __repr__(self) -> str:
         return "<{}: for function={!r} with nodes={}>".format(
-            ("blocking " if self.is_blocking else "")
-            + self.__class__.__name__,
+            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
             self.func.__name__,
             self.nodes,
         )
-    
+
     async def compose_nodes(self, update: UpdateCute) -> NodeCollection | None:
         nodes: dict[str, NodeSession] = {}
         for name, node_t in self.nodes.items():
@@ -44,7 +43,7 @@ class Composition:
                 await NodeCollection(nodes).close_all()
                 return None
         return NodeCollection(nodes)
-    
+
     async def __call__(self, **kwargs: typing.Any) -> typing.Any:
         return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
 
@@ -52,7 +51,7 @@ class Composition:
 class CompositionDispatch(ABCDispatch):
     def __init__(self) -> None:
         self.compositions: list[Composition] = []
-    
+
     def __repr__(self) -> str:
         return "<{}: with compositions={!r}>".format(
             self.__class__.__name__,
@@ -71,7 +70,7 @@ class CompositionDispatch(ABCDispatch):
                     return True
                 is_found = True
         return is_found
-    
+
     def load(self, external: typing.Self):
         self.compositions.extend(external.compositions)
 
@@ -79,9 +78,12 @@ class CompositionDispatch(ABCDispatch):
         def wrapper(func: typing.Callable):
             composition = Composition(func, is_blocking)
             if container_nodes:
-                composition.nodes["container"] = ContainerNode.link_nodes(list(container_nodes))
+                composition.nodes["container"] = ContainerNode.link_nodes(
+                    list(container_nodes)
+                )
             self.compositions.append(composition)
             return func
+
         return wrapper
 
 

telegrinder/bot/dispatch/context.py

@@ -33,45 +33,44 @@ class Context(dict[str, AnyValue]):
                 defaults[k] = cls_vars[k]
                 delattr(self.__class__, k)
         dict.__init__(self, **defaults | kwargs)
-    
+
     @recursive_repr()
     def __repr__(self) -> str:
         return "{}({})".format(
-            self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.items())
+            self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items())
         )
 
     def __setitem__(self, __key: Key, __value: AnyValue) -> None:
         dict.__setitem__(self, self.key_to_str(__key), __value)
-    
+
     def __getitem__(self, __key: Key) -> AnyValue:
         return dict.__getitem__(self, self.key_to_str(__key))
-    
+
     def __delitem__(self, __key: Key) -> None:
         dict.__delitem__(self, self.key_to_str(__key))
 
     def __setattr__(self, __name: str, __value: AnyValue) -> None:
         self.__setitem__(__name, __value)
-    
+
     def __getattr__(self, __name: str) -> AnyValue:
         return self.__getitem__(__name)
-    
+
     def __delattr__(self, __name: str) -> None:
         self.__delitem__(__name)
 
     @staticmethod
     def key_to_str(key: Key) -> str:
         return key if isinstance(key, str) else str(key.value)
-    
+
     def copy(self) -> typing.Self:
         return self.__class__(**self)
 
     def set(self, key: Key, value: AnyValue) -> None:
         self[key] = value
-    
+
     def get(self, key: Key, default: T | None = None) -> T | AnyValue:
         return dict.get(self, key, default)
-    
+
     def delete(self, key: Key) -> None:
         del self[key]
 

telegrinder/bot/dispatch/dispatch.py

@@ -16,12 +16,22 @@ from telegrinder.types import Update
 from .abc import ABCDispatch
 from .handler import ABCHandler, FuncHandler
 from .handler.func import ErrorHandlerT
-from .view.box import CallbackQueryViewT, InlineQueryViewT, MessageViewT, ViewBox
+from .view.box import (
+    CallbackQueryViewT,
+    ChatJoinRequestViewT,
+    ChatMemberViewT,
+    InlineQueryViewT,
+    MessageViewT,
+    RawEventViewT,
+    ViewBox,
+)
 
 T = typing.TypeVar("T")
 R = typing.TypeVar("R")
 P = typing.ParamSpec("P")
-Handler = typing.Callable[typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]]
+Handler = typing.Callable[
+    typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]
+]
 Event = typing.TypeVar("Event", bound=BaseCute)
 
 DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
@@ -30,7 +40,14 @@ DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
 @dataclasses.dataclass(repr=False, kw_only=True)
 class Dispatch(
     ABCDispatch,
-    ViewBox[CallbackQueryViewT, InlineQueryViewT, MessageViewT],
+    ViewBox[
+        CallbackQueryViewT,
+        ChatJoinRequestViewT,
+        ChatMemberViewT,
+        InlineQueryViewT,
+        MessageViewT,
+        RawEventViewT,
+    ],
 ):
     global_context: TelegrinderCtx = dataclasses.field(
         init=False,
@@ -42,29 +59,25 @@ class Dispatch(
     )
 
     def __repr__(self) -> str:
-        return "Dispatch(%s)" % ", ".join(
-            f"{k}={v!r}" for k, v in self.__dict__.items()
-        )
+        return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
 
     @property
     def patcher(self) -> Patcher:
         """Alias `patcher` to get `vbml.Patcher` from the global context"""
         return self.global_context.vbml_patcher
-    
+
     @typing.overload
     def handle(
         self,
         *rules: ABCRule[Event],
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: ABCRule[Event],
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
@@ -72,8 +85,7 @@ class Dispatch(
         *rules: ABCRule[Event],
         dataclass: type[T],
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(  # type: ignore
@@ -81,8 +93,7 @@ class Dispatch(
         *rules: ABCRule[Event],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
@@ -91,8 +102,7 @@ class Dispatch(
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
@@ -101,8 +111,7 @@ class Dispatch(
         dataclass: type[T] = DEFAULT_DATACLASS,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
-    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
-        ...
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]: ...
 
     def handle(  # type: ignore
         self,
@@ -126,6 +135,7 @@ class Dispatch(
 
     async def feed(self, event: Update, api: ABCAPI) -> bool:
         logger.debug("Processing update (update_id={})", event.update_id)
+        await self.raw_event.process(event, api)
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(

telegrinder/bot/dispatch/handler/abc.py

@@ -20,4 +20,5 @@ class ABCHandler(ABC, typing.Generic[T]):
     async def run(self, event: T, ctx: Context) -> typing.Any:
         pass
 
+
 __all__ = ("ABCHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -9,15 +9,23 @@ from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.modules import logger
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types import Update
+from telegrinder.types.enums import UpdateType
 
 from .abc import ABCHandler
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules import ABCRule
 
-F = typing.TypeVar("F", bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]])
+F = typing.TypeVar(
+    "F",
+    bound=typing.Callable[
+        typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]
+    ],
+)
 EventT = typing.TypeVar("EventT", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
+ErrorHandlerT = typing.TypeVar(
+    "ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler
+)
 
 
 @dataclasses.dataclass(repr=False)
@@ -31,6 +39,7 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
         default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
     )
     preset_context: Context = dataclasses.field(default_factory=lambda: Context())
+    update_type: UpdateType | None = dataclasses.field(default=None)
 
     def __repr__(self) -> str:
         return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
@@ -41,8 +50,13 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
             self.dataclass,
             self.error_handler,
         )
-    
+
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
+        if (
+            self.update_type is not None
+            and self.update_type != event.update_type.unwrap_or_none()
+        ):
+            return False
         ctx = ctx or Context()
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
@@ -51,14 +65,23 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
             if not await check_rule(api, rule, event, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
                 return False
-        
+
         ctx |= temp_ctx
         return True
 
     async def run(self, event: EventT, ctx: Context) -> typing.Any:
+        api = event.api
         if self.dataclass is not None:
-            event = self.dataclass(**event.to_dict())
-        return (await self.error_handler.run(self.func, event, event.api, ctx)).unwrap()
+            if self.update_type is not None:
+                update = event.to_dict()[self.update_type.value].unwrap()
+                event = (
+                    self.dataclass.from_update(update, bound_api=api)  # type: ignore
+                    if issubclass(self.dataclass, BaseCute)
+                    else self.dataclass(**update.to_dict())
+                )
+            else:
+                event = self.dataclass(**event.to_dict())
+        return (await self.error_handler.run(self.func, event, api, ctx)).unwrap()
 
 
 __all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -25,11 +25,10 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         self.as_reply = as_reply
         self.is_blocking = is_blocking
         self.preset_context = Context()
-    
+
     def __repr__(self) -> str:
         return "<{}: with rules={!r}, {}: {!r}>".format(
-            ("blocking " if self.is_blocking else "")
-            + self.__class__.__name__,
+            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
             self.rules,
             "answer text as reply" if self.as_reply else "answer text",
             self.text,

telegrinder/bot/dispatch/middleware/abc.py

@@ -8,11 +8,9 @@ T = typing.TypeVar("T", bound=BaseCute)
 
 
 class ABCMiddleware(ABC, typing.Generic[T]):
-    async def pre(self, event: T, ctx: Context) -> bool:
-        ...
+    async def pre(self, event: T, ctx: Context) -> bool: ...
 
-    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None:
-        ...
+    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None: ...
 
 
 __all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -25,7 +25,7 @@ async def process_inner(
     raw_event: Update,
     middlewares: list[ABCMiddleware[T]],
     handlers: list["ABCHandler[T]"],
-    return_manager: ABCReturnManager[T],
+    return_manager: ABCReturnManager[T] | None = None,
 ) -> bool:
     logger.debug("Processing {!r}...", event.__class__.__name__)
     ctx = Context(raw_update=raw_event)
@@ -43,7 +43,8 @@ async def process_inner(
             found = True
             response = await handler.run(event, ctx)
             responses.append(response)
-            await return_manager.run(response, event, ctx)
+            if return_manager is not None:
+                await return_manager.run(response, event, ctx)
             if handler.is_blocking:
                 break
             ctx = ctx_copy
@@ -56,7 +57,7 @@ async def process_inner(
 
 async def check_rule(
     api: ABCAPI,
-    rule: "ABCRule",
+    rule: "ABCRule[T]",
     update: Update,
     ctx: Context,
 ) -> bool:

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -16,4 +16,4 @@ __all__ = (
     "Manager",
     "MessageReturnManager",
     "register_manager",
-) 
+)