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

telegrinder/bot/cute_types/pre_checkout_query.py

@@ -0,0 +1,42 @@
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.api.error import APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params
+from telegrinder.model import get_params
+from telegrinder.tools.magic import shortcut
+from telegrinder.types.objects import PreCheckoutQuery, User
+
+
+class PreCheckoutQueryCute(BaseCute[PreCheckoutQuery], PreCheckoutQuery, kw_only=True):
+    api: API
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @shortcut("answer_pre_checkout_query", custom_params={"pre_checkout_query_id"})
+    async def answer(
+        self,
+        ok: bool,
+        *,
+        error_message: str | None = None,
+        pre_checkout_query_id: str | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.answer_pre_checkout_query()`, see the [documentation](https://core.telegram.org/bots/api#answerprecheckoutquery)
+
+        Once the user has confirmed their payment and shipping details, the Bot
+        API sends the final confirmation in the form of an Update with the field pre_checkout_query.
+        Use this method to respond to such pre-checkout queries. On success, True
+        is returned. Note: The Bot API must receive an answer within 10 seconds after
+        the pre-checkout query was sent."""
+        params = compose_method_params(
+            get_params(locals()), self, default_params={("pre_checkout_query_id", "id")}
+        )
+        return await self.ctx_api.answer_pre_checkout_query(**params)
+
+
+__all__ = ("PreCheckoutQueryCute",)

telegrinder/bot/cute_types/update.py

@@ -9,7 +9,8 @@ from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
 from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.model import From, field
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.model import UNSET, From, field
 from telegrinder.msgspec_utils import Option
 from telegrinder.types.objects import *
 
@@ -20,13 +21,13 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     api: API
 
     message: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New incoming message of any kind - text, photo, sticker, etc."""
 
     edited_message: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New version of a message that is known to the bot and was edited.
@@ -34,14 +35,14 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     either unavailable or not actively used by your bot."""
 
     channel_post: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New incoming channel post of any kind - text, photo, sticker,
     etc."""
 
     edited_channel_post: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New version of a channel post that is known to the bot and was edited.
@@ -49,31 +50,31 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     either unavailable or not actively used by your bot."""
 
     business_message: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New message from a connected business account."""
 
     edited_business_message: Option[MessageCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | None],
     )
     """Optional. New version of a message from a connected business account."""
 
     inline_query: Option[InlineQueryCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[InlineQueryCute | None],
     )
     """Optional. New incoming inline query."""
 
     callback_query: Option[CallbackQueryCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[CallbackQueryCute | None],
     )
     """Optional. New incoming callback query."""
 
     my_chat_member: Option[ChatMemberUpdatedCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[ChatMemberUpdatedCute | None],
     )
     """Optional. The bot's chat member status was updated in a chat. For private
@@ -81,7 +82,7 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     by the user."""
 
     chat_member: Option[ChatMemberUpdatedCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[ChatMemberUpdatedCute | None],
     )
     """Optional. A chat member's status was updated in a chat. The bot must be an
@@ -89,12 +90,19 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     the list of allowed_updates to receive these updates."""
 
     chat_join_request: Option[ChatJoinRequestCute] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[ChatJoinRequestCute | None],
     )
     """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
     administrator right in the chat to receive these updates."""
 
+    pre_checkout_query: Option[PreCheckoutQueryCute] = field(
+        default=UNSET,
+        converter=From[PreCheckoutQueryCute | None],
+    )
+    """Optional. New incoming pre-checkout query. Contains full information
+    about checkout."""
+
     def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
         if isinstance(self.incoming_update, event_model):
             return Some(self.incoming_update)

telegrinder/bot/cute_types/utils.py

@@ -8,15 +8,13 @@ from telegrinder.types.objects import (
     InputMediaDocument,
     InputMediaPhoto,
     InputMediaVideo,
-    LinkPreviewOptions,
     MessageEntity,
     ReactionEmoji,
     ReactionType,
     ReactionTypeEmoji,
-    ReplyParameters,
 )
 
-InputMedia: typing.TypeAlias = typing.Union[
+type InputMedia = typing.Union[
     InputMediaAnimation,
     InputMediaAudio,
     InputMediaDocument,
@@ -45,36 +43,10 @@ def compose_reactions(
             if isinstance(emoji, ReactionEmoji)
             else (ReactionTypeEmoji(ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
         )
-        for emoji in ([reactions] if isinstance(reactions, str) else reactions)  # type: ignore
+        for emoji in reactions
     ]
 
 
-def compose_reply_params(
-    message_id: int | None,
-    chat_id: int | str | None,
-    *,
-    allow_sending_without_reply: bool | None = None,
-    quote: str | None = None,
-    quote_parse_mode: str | None = None,
-    quote_entities: list[MessageEntity] | None = None,
-    quote_position: int | None = None,
-    **other: typing.Any,
-) -> ReplyParameters:
-    return ReplyParameters(**get_params(locals()))
-
-
-def compose_link_preview_options(
-    *,
-    is_disabled: bool | None = None,
-    url: str | None = None,
-    prefer_small_media: bool | None = None,
-    prefer_large_media: bool | None = None,
-    show_above_text: bool | None = None,
-    **other: typing.Any,
-) -> LinkPreviewOptions:
-    return LinkPreviewOptions(**get_params(locals()))
-
-
 def input_media(
     type: typing.Literal["animation", "audio", "document", "photo", "video"],
     media: str | InputFile,
@@ -87,9 +59,4 @@ def input_media(
     return INPUT_MEDIA_TYPES[type](**get_params(locals()))
 
 
-__all__ = (
-    "compose_link_preview_options",
-    "compose_reactions",
-    "compose_reply_params",
-    "input_media",
-)
+__all__ = ("compose_reactions", "input_media")

telegrinder/bot/dispatch/__init__.py

@@ -21,6 +21,7 @@ from telegrinder.bot.dispatch.return_manager import (
     InlineQueryReturnManager,
     Manager,
     MessageReturnManager,
+    PreCheckoutQueryManager,
     register_manager,
 )
 from telegrinder.bot.dispatch.view import (
@@ -33,6 +34,7 @@ from telegrinder.bot.dispatch.view import (
     ChatMemberView,
     InlineQueryView,
     MessageView,
+    PreCheckoutQueryView,
     RawEventView,
     ViewBox,
 )
@@ -84,6 +86,8 @@ __all__ = (
     "MessageReturnManager",
     "MessageView",
     "PhotoReplyHandler",
+    "PreCheckoutQueryManager",
+    "PreCheckoutQueryView",
     "RawEventView",
     "ShortState",
     "StateViewHasher",

telegrinder/bot/dispatch/abc.py

@@ -8,10 +8,10 @@ from abc import ABC, abstractmethod
 from fntypes.option import Option
 
 from telegrinder.api.api import API
-from telegrinder.tools.global_context.abc import ABCGlobalContext
 from telegrinder.types.objects import Update
 
-T = typing.TypeVar("T")
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.view.abc import ABCView
 
 
 class PathExistsError(BaseException):
@@ -19,21 +19,20 @@ class PathExistsError(BaseException):
 
 
 class ABCDispatch(ABC):
-    @property
     @abstractmethod
-    def global_context(self) -> ABCGlobalContext:
+    async def feed(self, event: Update, api: API[typing.Any]) -> bool:
         pass
 
     @abstractmethod
-    async def feed(self, event: Update, api: API) -> bool:
+    def load(self, external: typing.Self) -> None:
         pass
 
     @abstractmethod
-    def load(self, external: typing.Self) -> None:
+    def get_view[T](self, of_type: type[T]) -> Option[T]:
         pass
 
     @abstractmethod
-    def get_view(self, of_type: type[T]) -> Option[T]:
+    def get_views(self) -> dict[str, "ABCView"]:
         pass
 
     def load_many(self, *externals: typing.Self) -> None:
@@ -43,8 +42,8 @@ class ABCDispatch(ABC):
     def load_from_dir(self, directory: str | pathlib.Path) -> bool:
         """Loads dispatchers from a directory containing Python modules where global variables
         are declared with instances of dispatch.
-        Returns True if dispatchers were found, otherwise False."""
-
+        Returns True if dispatchers were found, otherwise False.
+        """
         directory = pathlib.Path(directory)
 
         if not directory.exists():

telegrinder/bot/dispatch/context.py

@@ -9,10 +9,8 @@ from telegrinder.types.objects import Update
 if typing.TYPE_CHECKING:
     from telegrinder.node.composer import NodeCollection
 
-T = typing.TypeVar("T")
-
-Key: typing.TypeAlias = str | enum.Enum
-AnyValue: typing.TypeAlias = typing.Any
+type Key = str | enum.Enum
+type AnyValue = typing.Any
 
 
 class Context(dict[str, AnyValue]):
@@ -78,15 +76,15 @@ class Context(dict[str, AnyValue]):
     def get(self, key: Key) -> AnyValue | None: ...
 
     @typing.overload
-    def get(self, key: Key, default: T) -> T | AnyValue: ...
+    def get[T](self, key: Key, default: T) -> T | AnyValue: ...
 
     @typing.overload
     def get(self, key: Key, default: None = None) -> AnyValue | None: ...
 
-    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
+    def get[T](self, key: Key, default: T | None = None) -> T | AnyValue | None:
         return dict.get(self, key, default)
 
-    def get_or_set(self, key: Key, default: T) -> T:
+    def get_or_set[T](self, key: Key, default: T) -> T:
         if key not in self:
             self.set(key, default)
         return self.get(key, default)

telegrinder/bot/dispatch/dispatch.py

@@ -1,20 +1,25 @@
+from __future__ import annotations
+
 import dataclasses
 
 import typing_extensions as typing
 from fntypes import Nothing, Option, Some
 from vbml.patcher import Patcher
 
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.api.api import API, HTTPClient
 from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, Func, FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import run_middleware
+from telegrinder.bot.dispatch.middleware.global_middleware import GlobalMiddleware
+from telegrinder.bot.dispatch.view.abc import ABCView
 from telegrinder.bot.dispatch.view.box import (
     CallbackQueryView,
     ChatJoinRequestView,
     ChatMemberView,
     InlineQueryView,
     MessageView,
+    PreCheckoutQueryView,
     RawEventView,
     ViewBox,
 )
@@ -25,11 +30,13 @@ from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
+    from telegrinder.bot.cute_types.base import BaseCute
+    from telegrinder.bot.cute_types.update import UpdateCute
     from telegrinder.bot.rules.abc import ABCRule
 
 T = typing.TypeVar("T", default=typing.Any)
 R = typing.TypeVar("R", covariant=True, default=typing.Any)
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound="BaseCute")
 P = typing.ParamSpec("P", default=...)
 
 DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
@@ -44,12 +51,26 @@ class Dispatch(
         ChatMemberView,
         InlineQueryView,
         MessageView,
+        PreCheckoutQueryView,
+        RawEventView,
+    ],
+    typing.Generic[
+        HTTPClient,
+        CallbackQueryView,
+        ChatJoinRequestView,
+        ChatMemberView,
+        InlineQueryView,
+        MessageView,
+        PreCheckoutQueryView,
         RawEventView,
     ],
 ):
     _global_context: TelegrinderContext = dataclasses.field(
         init=False,
-        default_factory=lambda: TelegrinderContext(),
+        default_factory=TelegrinderContext,
+    )
+    global_middleware: "GlobalMiddleware" = dataclasses.field(
+        default_factory=lambda: GlobalMiddleware(),
     )
 
     def __repr__(self) -> str:
@@ -62,31 +83,30 @@ class Dispatch(
     @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",
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[UpdateCute]]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: "ABCRule",
         dataclass: type[T],
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[T]]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: "ABCRule",
         update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[UpdateCute]]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[UpdateCute]]]: ...
 
     @typing.overload
     def handle(
@@ -94,16 +114,16 @@ class Dispatch(
         *rules: "ABCRule",
         dataclass: type[T],
         update_type: UpdateType,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[T]]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: "ABCRule",
         error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
@@ -111,27 +131,27 @@ class Dispatch(
         *rules: "ABCRule",
         update_type: UpdateType,
         error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: "ABCRule",
-        dataclass: type[typing.Any],
+        dataclass: type[T],
         error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
         self,
         *rules: "ABCRule",
-        dataclass: type[typing.Any],
+        dataclass: type[T],
         update_type: UpdateType,
         error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandlerT]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandlerT]]: ...
 
     @typing.overload
     def handle(
@@ -140,8 +160,8 @@ class Dispatch(
         update_type: UpdateType | None = None,
         dataclass: type[T] = DEFAULT_DATACLASS,
         error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[UpdateCute, Func[P, R], ErrorHandler[T]]]: ...
+        final: bool = True,
+    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandler[T]]]: ...
 
     def handle(
         self,
@@ -149,13 +169,13 @@ class Dispatch(
         update_type: UpdateType | None = None,
         dataclass: type[typing.Any] = DEFAULT_DATACLASS,
         error_handler: ErrorHandlerT | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
     ) -> typing.Callable[..., typing.Any]:
         def wrapper(func):
             handler = FuncHandler(
                 func,
                 list(rules),
-                is_blocking=is_blocking,
+                final=final,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
                 update_type=update_type,
@@ -165,12 +185,27 @@ class Dispatch(
 
         return wrapper
 
-    async def feed(self, event: Update, api: API) -> bool:
+    async def feed(self, event: Update, api: API[HTTPClient]) -> bool:
         logger.debug(
             "Processing update (update_id={}, update_type={!r})",
             event.update_id,
             event.update_type.name,
         )
+        context = Context(raw_update=event)
+
+        if (
+            await run_middleware(
+                self.global_middleware.pre,
+                api,
+                event,  # type: ignore
+                raw_event=event,
+                ctx=context,
+                adapter=self.global_middleware.adapter,
+            )
+            is False
+        ):
+            return False
+
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
@@ -179,23 +214,40 @@ class Dispatch(
                     event.update_type.name,
                     view,
                 )
-                if await view.process(event, api):
+                if await view.process(event, api, context):
                     return True
+
+        await run_middleware(
+            self.global_middleware.post,
+            api,
+            event,
+            raw_event=event,
+            ctx=context,
+            adapter=self.global_middleware.adapter,
+        )
+
         return False
 
     def load(self, external: typing.Self) -> None:
-        view_external = external.get_views()
+        views_external = external.get_views()
+
         for name, view in self.get_views().items():
-            assert name in view_external, f"View {name!r} is undefined in external dispatch."
-            view.load(view_external[name])
+            assert name in views_external, f"View {name!r} is undefined in external dispatch."
+            view.load(views_external[name])
             setattr(external, name, view)
 
+        self.global_middleware.filters.difference_update(external.global_middleware.filters)
+
     def get_view(self, of_type: type[T]) -> Option[T]:
         for view in self.get_views().values():
             if isinstance(view, of_type):
                 return Some(view)
         return Nothing()
 
+    def get_views(self) -> dict[str, ABCView]:
+        """Get all views."""
+        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
+
     __call__ = handle
 
 

telegrinder/bot/dispatch/handler/abc.py

@@ -3,21 +3,20 @@ from abc import ABC, abstractmethod
 
 from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
+from telegrinder.tools.adapter.abc import ABCAdapter
 from telegrinder.types.objects import Update
 
-T = typing.TypeVar("T", bound=Model)
 
-
-class ABCHandler(ABC, typing.Generic[T]):
-    is_blocking: bool
+class ABCHandler[Event](ABC):
+    final: bool
+    adapter: ABCAdapter[Update, Event] | None = None
 
     @abstractmethod
     async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
         pass
 
     @abstractmethod
-    async def run(self, api: API, event: T, ctx: Context) -> typing.Any:
+    async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
         pass
 
 

telegrinder/bot/dispatch/handler/audio_reply.py

@@ -15,7 +15,7 @@ class AudioReplyHandler(BaseReplyHandler):
         *rules: ABCRule,
         caption: str | None = None,
         parse_mode: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -25,7 +25,7 @@ class AudioReplyHandler(BaseReplyHandler):
         self.caption = caption
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,

telegrinder/bot/dispatch/handler/base.py

@@ -13,7 +13,7 @@ from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.modules import logger
 from telegrinder.types.objects import Update
 
-APIMethod: typing.TypeAlias = typing.Callable[
+type APIMethod = typing.Callable[
     typing.Concatenate[MessageCute, ...], typing.Awaitable[Result[typing.Any, APIError]]
 ]
 
@@ -22,14 +22,14 @@ class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
     def __init__(
         self,
         *rules: ABCRule,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
     ) -> None:
         self.rules = list(rules)
         self.as_reply = as_reply
-        self.is_blocking = is_blocking
+        self.final = final
         self.default_params = default_params
         self.preset_context = preset_context or Context()
 

telegrinder/bot/dispatch/handler/document_reply.py

@@ -15,7 +15,7 @@ class DocumentReplyHandler(BaseReplyHandler):
         *rules: ABCRule,
         caption: str | None = None,
         parse_mode: str | None = None,
-        is_blocking: bool = True,
+        final: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
@@ -25,7 +25,7 @@ class DocumentReplyHandler(BaseReplyHandler):
         self.caption = caption
         super().__init__(
             *rules,
-            is_blocking=is_blocking,
+            final=final,
             as_reply=as_reply,
             preset_context=preset_context,
             **default_params,