Lots of improvements

Author: immmdreza

src/telegrambots/custom/contexts/_contexts/callback_query_context.py

@@ -1,4 +1,4 @@
-from typing import Optional, final, TYPE_CHECKING
+from typing import Any, Optional, final, TYPE_CHECKING
 
 from telegrambots.wrapper.types.objects import (
     CallbackQuery,
@@ -15,13 +15,14 @@
 
 class CallbackQueryContext(GenericContext[CallbackQuery]):
     def __init__(
-        self,
-        dp: "Dispatcher",
-        update: Update,
-        handler_tag: str,
+        self, dp: "Dispatcher", update: Update, handler_tag: str, **kwargs: Any
     ) -> None:
         super().__init__(
-            dp, update=update, update_type=CallbackQuery, handler_tag=handler_tag
+            dp,
+            update=update,
+            update_type=CallbackQuery,
+            handler_tag=handler_tag,
+            **kwargs
         )
 
     @final

src/telegrambots/custom/contexts/_contexts/context_template.py

@@ -3,6 +3,7 @@
     Any,
     Callable,
     Generic,
+    Mapping,
     Optional,
     final,
     TYPE_CHECKING,
@@ -21,7 +22,11 @@
 
 class ContextTemplate(metaclass=ABCMeta):
     def __init__(
-        self, dp: "Dispatcher", update: Update, update_type: type[Any], handler_tag: str
+        self,
+        dp: "Dispatcher",
+        update: Update,
+        update_type: type[Any],
+        handler_tag: str,
     ):
         self.__dp = dp
         self.__update = update
@@ -78,11 +83,28 @@ def continue_with(self) -> ContinueWithExtensions:
         return self.__continue_with
 
 
-class GenericContext(Generic[TUpdate], Exctractable[TUpdate], ABC, ContextTemplate):
+class GenericContext(
+    Generic[TUpdate], Exctractable[TUpdate], Mapping[str, Any], ContextTemplate, ABC
+):
     def __init__(
-        self, dp: "Dispatcher", update: Update, update_type: type[Any], handler_tag: str
+        self,
+        dp: "Dispatcher",
+        update: Update,
+        update_type: type[Any],
+        handler_tag: str,
+        **kwargs: Any,
     ) -> None:
         super().__init__(dp, update, update_type, handler_tag)
+        self._metadata: dict[str, Any] = kwargs
+
+    def __getitem__(self, name: str):
+        return self._metadata[name]
+
+    def __iter__(self):
+        return iter(self._metadata)
+
+    def __len__(self) -> int:
+        return len(self._metadata)
 
     @final
     @property
@@ -102,8 +124,9 @@ def __init__(
         update: Update,
         update_type: type[Any],
         handler_tag: str,
+        **kwargs: Any,
     ) -> None:
-        super().__init__(dp, update, update_type, handler_tag)
+        super().__init__(dp, update, update_type, handler_tag, **kwargs)
         self.__extractor = _exctractor
 
     @final

src/telegrambots/custom/contexts/_contexts/message_context.py

@@ -1,4 +1,4 @@
-from typing import Optional, final, TYPE_CHECKING
+from typing import Any, Optional, final, TYPE_CHECKING
 
 from telegrambots.wrapper.types.objects import (
     Message,
@@ -17,9 +17,11 @@
 
 
 class MessageContext(GenericContext[Message]):
-    def __init__(self, dp: "Dispatcher", update: Update, handler_tag: str) -> None:
+    def __init__(
+        self, dp: "Dispatcher", update: Update, handler_tag: str, **kwargs: Any
+    ) -> None:
         super().__init__(
-            dp, update=update, update_type=Message, handler_tag=handler_tag
+            dp, update=update, update_type=Message, handler_tag=handler_tag, **kwargs
         )
 
     @final

src/telegrambots/custom/dispatcher.py

@@ -4,6 +4,7 @@
     Any,
     Callable,
     Coroutine,
+    Mapping,
     Optional,
     cast,
     final,
@@ -158,8 +159,9 @@ def add_continuously_handler(
             self._continuously_handlers.append((continuously_handler,))
 
     async def _unlimited(self, *allowed_updates: str):
-        async for update in self.bot.stream_updates(list(allowed_updates)):
-            await self.feed_update(update)
+        async with self.bot:
+            async for update in self.bot.stream_updates(list(allowed_updates)):
+                await self.feed_update(update)
 
     async def _process_update(self, update: Update):
         update_type = update.update_type
@@ -173,7 +175,8 @@ async def _process_update(self, update: Update):
                     if c.check_keys(update):
                         handler = self._handlers[update_type][c.target_tag]
 
-                        if not handler.should_process(update):
+                        result = handler.should_process(update)
+                        if not result.result:
                             continue
 
                         if handler.continue_after is not None:
@@ -184,7 +187,12 @@ async def _process_update(self, update: Update):
                             f"Processing continuously handler {c.update_type.__name__}:{c.target_tag}"
                         )
                         await self._do_handling(
-                            handler, update, c.target_tag, *c.args, **c.kwargs
+                            handler,
+                            update,
+                            c.target_tag,
+                            result.metadata,
+                            *c.args,
+                            **c.kwargs,
                         )
                         self._continuously_handlers.remove(batch)
                         return  # Don't process the update anymore
@@ -201,8 +209,11 @@ async def _process_update(self, update: Update):
             )
             if not h.continue_after
         ):
-            if handler.should_process(update):
-                handling_result = await self._do_handling(handler, update, k)
+            result = handler.should_process(update)
+            if result.result:
+                handling_result = await self._do_handling(
+                    handler, update, k, result.metadata
+                )
                 if handling_result is not None:
                     if handling_result:
                         continue
@@ -214,12 +225,18 @@ async def _do_handling(
         handler: HandlerTemplate,
         update: Update,
         handler_tag: str,
+        filter_data: Mapping[str, Any],
         *args: Any,
         **kwargs: Any,
     ):
         try:
             await handler.process(
-                self, update, handler.update_type, handler_tag, *args, **kwargs
+                self,
+                update,
+                handler_tag,
+                filter_data,
+                *args,
+                **kwargs,
             )
         except ContinuePropagation:
             return True  # -> continue to next handler

src/telegrambots/custom/extensions/context.py

@@ -19,6 +19,11 @@
 from ..exceptions.propagations import BreakPropagation, ContinuePropagation
 from ..general import TUpdate
 from ..key_resolvers.key_resolver import AbstractKeyResolver
+from ..key_resolvers import (
+    MessageSenderId,
+    CallbackQueryMessageId,
+    CallbackQuerySenderId,
+)
 from ..filters import Filter
 
 if TYPE_CHECKING:
@@ -67,12 +72,85 @@ def decorator(
             _tag = tag or _function.__name__
             if not self._context.dp.handler_tag_exists(_tag, CallbackQuery):
                 self._context.dp.add.handlers.callback_query(
-                    _tag, _function, filter, [self.handler_tag]  # type: ignore
+                    _tag, _function, filter, [self._context.handler_tag]
                 )
             self._context.continue_with.callback_query(_tag, keys, *args, **kwargs)
 
         return decorator
 
+    def callback_query_form(
+        self,
+        user_id: int,
+        filter: Filter[CallbackQuery],
+        tag: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        def decorator(
+            _function: Callable[["CallbackQueryContext"], Coroutine[Any, Any, None]]
+        ):
+            _tag = tag or _function.__name__
+            if not self._context.dp.handler_tag_exists(_tag, CallbackQuery):
+                self._context.dp.add.handlers.callback_query(
+                    _tag, _function, filter, [self._context.handler_tag]
+                )
+            self._context.continue_with.callback_query(
+                _tag, [CallbackQuerySenderId(user_id)], *args, **kwargs
+            )
+
+        return decorator
+
+    def callback_query_same_message_form(
+        self,
+        message_id: int,
+        user_id: int,
+        filter: Filter[CallbackQuery],
+        tag: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        def decorator(
+            _function: Callable[["CallbackQueryContext"], Coroutine[Any, Any, None]]
+        ):
+            _tag = tag or _function.__name__
+            if not self._context.dp.handler_tag_exists(_tag, CallbackQuery):
+                self._context.dp.add.handlers.callback_query(
+                    _tag, _function, filter, [self._context.handler_tag]
+                )
+            self._context.continue_with.callback_query(
+                _tag,
+                [CallbackQuerySenderId(user_id), CallbackQueryMessageId(message_id)],
+                *args,
+                **kwargs,
+            )
+
+        return decorator
+
+    def callback_query_same_message(
+        self,
+        message_id: int,
+        filter: Filter[CallbackQuery],
+        tag: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        def decorator(
+            _function: Callable[["CallbackQueryContext"], Coroutine[Any, Any, None]]
+        ):
+            _tag = tag or _function.__name__
+            if not self._context.dp.handler_tag_exists(_tag, CallbackQuery):
+                self._context.dp.add.handlers.callback_query(
+                    _tag, _function, filter, [self._context.handler_tag]
+                )
+            self._context.continue_with.callback_query(
+                _tag,
+                [CallbackQueryMessageId(message_id)],
+                *args,
+                **kwargs,
+            )
+
+        return decorator
+
     def message(
         self,
         keys: list[AbstractKeyResolver[Message, Any]],
@@ -86,11 +164,35 @@ def decorator(
         ):
             _tag = tag or _function.__name__
             if not self._context.dp.handler_tag_exists(_tag, Message):
-                self._context.dp.add.handlers.message(_tag, _function, filter, [self.handler_tag])  # type: ignore
+                self._context.dp.add.handlers.message(
+                    _tag, _function, filter, [self._context.handler_tag]
+                )
             self._context.continue_with.message(_tag, keys, *args, **kwargs)
 
         return decorator
 
+    def message_from(
+        self,
+        user_id: int,
+        filter: "Filter[Message]",
+        tag: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        def decorator(
+            _function: Callable[["MessageContext"], Coroutine[Any, Any, None]]
+        ):
+            _tag = tag or _function.__name__
+            if not self._context.dp.handler_tag_exists(_tag, Message):
+                self._context.dp.add.handlers.message(
+                    _tag, _function, filter, [self._context.handler_tag]
+                )
+            self._context.continue_with.message(
+                _tag, [MessageSenderId(user_id)], *args, **kwargs
+            )
+
+        return decorator
+
 
 class ContinueWithExtensions(ContextExtensions):
     def __init__(self, context: "ContextTemplate") -> None: