Bot API Huge Update - 7.0, introducing reactions, replies and some other changes

README.md

@@ -10,7 +10,7 @@
 <p align="center">A simple, but extensible Python implementation for the <a href="https://core.telegram.org/bots/api">Telegram Bot API</a>.</p>
 <p align="center">Both synchronous and asynchronous.</p>
 
-## <p align="center">Supported Bot API version: <a href="https://core.telegram.org/bots/api-changelog#september-22-2023">6.9</a>!
+## <p align="center">Supported Bot API version: <a href="https://core.telegram.org/bots/api#december-29-2023">7.0</a>!
 
 <h2><a href='https://pytba.readthedocs.io/en/latest/index.html'>Official documentation</a></h2>
 <h2><a href='https://pytba.readthedocs.io/ru/latest/index.html'>Official ru documentation</a></h2>

telebot/__init__.py

@@ -217,6 +217,8 @@ def __init__(
         self.edited_message_handlers = []
         self.channel_post_handlers = []
         self.edited_channel_post_handlers = []
+        self.message_reaction_handlers = []
+        self.message_reaction_count_handlers = []
         self.inline_handlers = []
         self.chosen_inline_handlers = []
         self.callback_query_handlers = []
@@ -670,6 +672,8 @@ def process_new_updates(self, updates: List[types.Update]):
         new_edited_messages = None
         new_channel_posts = None
         new_edited_channel_posts = None
+        new_message_reactions = None
+        message_reaction_counts = None
         new_inline_queries = None
         new_chosen_inline_results = None
         new_callback_queries = None
@@ -737,6 +741,12 @@ def process_new_updates(self, updates: List[types.Update]):
             if update.chat_join_request:
                 if new_chat_join_request is None: new_chat_join_request = []
                 new_chat_join_request.append(update.chat_join_request)
+            if update.message_reaction:
+                if new_message_reactions is None: new_message_reactions = []
+                new_message_reactions.append(update.message_reaction)
+            if update.message_reaction_count:
+                if message_reaction_counts is None: message_reaction_counts = []
+                message_reaction_counts.append(update.message_reaction_count)
 
         if new_messages:
             self.process_new_messages(new_messages)
@@ -766,6 +776,10 @@ def process_new_updates(self, updates: List[types.Update]):
             self.process_new_chat_member(new_chat_members)
         if new_chat_join_request:
             self.process_new_chat_join_request(new_chat_join_request)
+        if new_message_reactions:
+            self.process_new_message_reaction(new_message_reactions)
+        if message_reaction_counts:
+            self.process_new_message_reaction_count(message_reaction_counts)
 
     def process_new_messages(self, new_messages):
         """
@@ -794,6 +808,18 @@ def process_new_edited_channel_posts(self, edited_channel_post):
         """
         self._notify_command_handlers(self.edited_channel_post_handlers, edited_channel_post, 'edited_channel_post')
 
+    def process_new_message_reaction(self, message_reactions):
+        """
+        :meta private:
+        """
+        self._notify_command_handlers(self.message_reaction_handlers, message_reactions, 'message_reaction')
+
+    def process_new_message_reaction_count(self, message_reaction_counts):
+        """
+        :meta private:
+        """
+        self._notify_command_handlers(self.message_reaction_count_handlers, message_reaction_counts, 'message_reaction_count')
+
     def process_new_inline_query(self, new_inline_queries):
         """
         :meta private:
@@ -1303,6 +1329,29 @@ def close(self) -> bool:
         :return: :obj:`bool`
         """
         return apihelper.close(self.token)
+
+    def set_message_reaction(self, chat_id: Union[int, str], message_id: int, reaction: Optional[List[types.ReactionType]]=None, is_big: Optional[bool]=None) -> bool:
+        """
+        Use this method to set a reaction to a message in a chat. The bot must be an administrator in the chat for this to work and must have the appropriate admin rights. Returns True on success.
+
+        Telegram documentation: https://core.telegram.org/bots/api#setmessagereaction
+
+        :param chat_id: Unique identifier for the target chat or username of the target supergroup or channel (in the format @channelusername)
+        :type chat_id: :obj:`int` or :obj:`str`
+
+        :param message_id: Identifier of the message to set reaction to
+        :type message_id: :obj:`int`
+
+        :param reaction: New list of reaction types to set on the message. Currently, as non-premium users, bots can set up to one reaction per message.
+            A custom emoji reaction can be used if it is either already present on the message or explicitly allowed by chat administrators.
+        :type reaction: :obj:`list` of :class:`telebot.types.ReactionType`
+
+        :param is_big: Pass True to set the reaction with a big animation
+        :type is_big: :obj:`bool`
+
+        :return: :obj:`bool`
+        """
+        return apihelper.set_message_reaction(self.token, chat_id, message_id, reaction, is_big)
 
 
     def get_user_profile_photos(self, user_id: int, offset: Optional[int]=None, 
@@ -6174,6 +6223,109 @@ def register_edited_channel_post_handler(self, callback: Callable, content_types
                                                 **kwargs)
         self.add_edited_channel_post_handler(handler_dict)
 
+
+    def message_reaction_handler(self, func, **kwargs):
+        """
+        Handles new incoming message reaction.
+        As a parameter to the decorator function, it passes :class:`telebot.types.Message` object.
+
+        :param func: Function executed as a filter
+        :type func: :obj:`function`
+
+        :param kwargs: Optional keyword arguments(custom filters)
+
+        :return:
+        """
+        def decorator(handler):
+            handler_dict = self._build_handler_dict(handler, func=func, **kwargs)
+            self.add_message_reaction_handler(handler_dict)
+            return handler
+
+        return decorator
+
+    def add_message_reaction_handler(self, handler_dict):
+        """
+        Adds message reaction handler
+        Note that you should use register_message_reaction_handler to add message_reaction_handler to the bot.
+
+        :meta private:
+
+        :param handler_dict:
+        :return:
+        """
+        self.message_reaction_handlers.append(handler_dict)
+
+    def register_message_reaction_handler(self, callback: Callable, func: Callable, pass_bot: Optional[bool]=False, **kwargs):
+        """
+        Registers message reaction handler.
+
+        :param callback: function to be called
+        :type callback: :obj:`function`
+
+        :param func: Function executed as a filter
+        :type func: :obj:`function`
+
+        :param pass_bot: True if you need to pass TeleBot instance to handler(useful for separating handlers into different files)
+        :type pass_bot: :obj:`bool`
+
+        :param kwargs: Optional keyword arguments(custom filters)
+
+        :return: None
+        """
+        handler_dict = self._build_handler_dict(callback, func=func, pass_bot=pass_bot, **kwargs)
+        self.add_message_reaction_handler(handler_dict)
+
+    def message_reaction_count_handler(self, func, **kwargs):
+        """
+        Handles new incoming message reaction count.
+        As a parameter to the decorator function, it passes :class:`telebot.types.Message` object.
+
+        :param func: Function executed as a filter
+        :type func: :obj:`function`
+
+        :param kwargs: Optional keyword arguments(custom filters)
+
+        :return:
+        """
+        def decorator(handler):
+            handler_dict = self._build_handler_dict(handler, func=func, **kwargs)
+            self.add_message_reaction_count_handler(handler_dict)
+            return handler
+
+        return decorator
+
+    def add_message_reaction_count_handler(self, handler_dict):
+        """
+        Adds message reaction count handler
+        Note that you should use register_message_reaction_count_handler to add message_reaction_count_handler to the bot.
+
+        :meta private:
+
+        :param handler_dict:
+        :return:
+        """
+        self.message_reaction_count_handlers.append(handler_dict)
+
+    def register_message_reaction_count_handler(self, callback: Callable, func: Callable, pass_bot: Optional[bool]=False, **kwargs):
+        """
+        Registers message reaction count handler.
+
+        :param callback: function to be called
+        :type callback: :obj:`function`
+
+        :param func: Function executed as a filter
+        :type func: :obj:`function`
+
+        :param pass_bot: True if you need to pass TeleBot instance to handler(useful for separating handlers into different files)
+        :type pass_bot: :obj:`bool`
+
+        :param kwargs: Optional keyword arguments(custom filters)
+
+        :return: None
+        """
+        handler_dict = self._build_handler_dict(callback, func=func, pass_bot=pass_bot, **kwargs)
+        self.add_message_reaction_count_handler(handler_dict)
+
     def inline_handler(self, func, **kwargs):
         """
         Handles new incoming inline query.

telebot/apihelper.py

@@ -332,6 +332,16 @@ def get_user_profile_photos(token, user_id, offset=None, limit=None):
         payload['limit'] = limit
     return _make_request(token, method_url, params=payload)
 
+def set_message_reaction(token, chat_id, message_id, reaction=None, is_big=None):
+    method_url = r'setMessageReaction'
+    payload = {'chat_id': chat_id, 'message_id': message_id}
+    if reaction:
+        payload['reaction'] = reaction
+    if is_big is not None:
+        payload['is_big'] = is_big
+    return _make_request(token, method_url, params=payload)
+
+
 
 def get_chat(token, chat_id):
     method_url = r'getChat'