Update version.

Fixing and upgrading next step and reply handlers. + minor fixes

.travis.yml

@@ -5,6 +5,7 @@ python:
     - "3.3"
     - "3.4"
     - "3.5"
+    - "3.6"
     - "pypy"
     - "pypy3"
 install: "pip install -r requirements.txt"

README.md

@@ -500,16 +500,13 @@ You can use proxy for request. `apihelper.proxy` object will use by call `reques
 ```python
 from telebot import apihelper
 
-apihelper.proxy = {'http', 'http://10.10.1.10:3128'}
+apihelper.proxy = {'http':'http://10.10.1.10:3128'}
 ```
 
-If you want to use socket5 proxy you need install dependency `pip install requests[socks]`.
+If you want to use socket5 proxy you need install dependency `pip install requests[socks]` and make sure, that you have the latest version of `gunicorn`, `PySocks`, `pyTelegramBotAPI`, `requests` and `urllib3`.
 
 ```python
-proxies = {
-    'http': 'socks5://user:pass@host:port',
-    'https': 'socks5://user:pass@host:port'
-}
+apihelper.proxy = {'https':'socks5://userproxy:password@proxy_address:port'}
 ```
 
 
@@ -585,4 +582,7 @@ Get help. Discuss. Chat.
 * [filex_bot](http://t.me/filex_bot)([link](https://github.com/victor141516/FileXbot-telegram))
 * [Spbu4UBot](http://t.me/Spbu4UBot)([link](https://github.com/EeOneDown/spbu4u)) by *EeOneDown* - Bot with timetables for SPbU students.
 * [SmartySBot](http://t.me/ZDU_bot)([link](https://github.com/0xVK/SmartySBot)) by *0xVK* - Telegram timetable bot, for Zhytomyr Ivan Franko State University students. 
+* [yandex_music_bot](http://t.me/yandex_music_bot)- Downloads tracks/albums/public playlists from Yandex.Music streaming service for free.
+* [LearnIt](https://t.me/LearnItbot)([link](https://github.com/tiagonapoli/LearnIt)) - A Telegram Bot created to help people to memorize other languages’ vocabulary.
+
 Want to have your bot listed here? Send a Telegram message to @eternnoir or @pevdh.

examples/webhook_examples/webhook_flask_echo_bot.py

@@ -7,6 +7,7 @@
 import flask
 import telebot
 import logging
+import time
 
 
 API_TOKEN = '<api_token>'
@@ -73,6 +74,8 @@ def echo_message(message):
 # Remove webhook, it fails sometimes the set if there is a previous webhook
 bot.remove_webhook()
 
+time.sleep(0.1)
+
 # Set webhook
 bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
                 certificate=open(WEBHOOK_SSL_CERT, 'r'))

examples/webhook_examples/webhook_flask_heroku_echo.py

@@ -1,29 +1,35 @@
-import telebot
 import os
+
+import telebot
 from flask import Flask, request
 
-bot = telebot.TeleBot('<api_token>')
-
+TOKEN = '<api_token>'
+bot = telebot.TeleBot(TOKEN)
 server = Flask(__name__)
 
+
 @bot.message_handler(commands=['start'])
 def start(message):
     bot.reply_to(message, 'Hello, ' + message.from_user.first_name)
 
+
 @bot.message_handler(func=lambda message: True, content_types=['text'])
 def echo_message(message):
     bot.reply_to(message, message.text)
 
-@server.route("/bot", methods=['POST'])
+
+@server.route('/' + TOKEN, methods=['POST'])
 def getMessage():
     bot.process_new_updates([telebot.types.Update.de_json(request.stream.read().decode("utf-8"))])
     return "!", 200
 
+
 @server.route("/")
 def webhook():
     bot.remove_webhook()
-    bot.set_webhook(url="https://herokuProject_url/bot")
+    bot.set_webhook(url='https://your_heroku_project.com/' + TOKEN)
     return "!", 200
 
-server.run(host="0.0.0.0", port=os.environ.get('PORT', 5000))
-server = Flask(__name__)
+
+if __name__ == "__main__":
+    server.run(host="0.0.0.0", port=int(os.environ.get('PORT', 5000)))

setup.py

@@ -7,7 +7,7 @@ def readme():
         return f.read()
 
 setup(name='pyTelegramBotAPI',
-      version='3.5.2',
+      version='3.6.3',
       description='Python Telegram bot api. ',
       long_description=readme(),
       author='eternnoir',

telebot/__init__.py

@@ -70,6 +70,7 @@ class TeleBot:
         :param token: bot API token
         :return: Telebot object.
         """
+
         self.token = token
         self.update_listener = []
         self.skip_pending = skip_pending
@@ -78,13 +79,11 @@ class TeleBot:
         self.last_update_id = 0
         self.exc_info = None
 
-        self.message_subscribers_messages = []
-        self.message_subscribers_callbacks = []
-        self.message_subscribers_lock = threading.Lock()
+        # key: message_id, value: handler list
+        self.reply_handlers = {}
 
         # key: chat_id, value: handler list
-        self.message_subscribers_next_step = {}
-        self.pre_message_subscribers_next_step = {}
+        self.next_step_handlers = {}
 
         self.message_handlers = []
         self.edited_message_handlers = []
@@ -213,11 +212,10 @@ class TeleBot:
             self.process_new_shipping_query(new_shipping_querys)
 
     def process_new_messages(self, new_messages):
-        self._append_pre_next_step_handler()
+        self._notify_next_handlers(new_messages)
+        self._notify_reply_handlers(new_messages)
         self.__notify_update(new_messages)
         self._notify_command_handlers(self.message_handlers, new_messages)
-        self._notify_message_subscribers(new_messages)
-        self._notify_message_next_handler(new_messages)
 
     def process_new_edited_messages(self, edited_message):
         self._notify_command_handlers(self.edited_message_handlers, edited_message)
@@ -247,6 +245,15 @@ class TeleBot:
         for listener in self.update_listener:
             self._exec_task(listener, new_messages)
 
+    def infinity_polling(self, *args, **kwargs):
+        while not self.__stop_polling.is_set():
+            try:
+                self.polling(*args, **kwargs)
+            except Exception as e:
+                time.sleep(5)
+                pass
+        logger.info("Break infinity polling")
+
     def polling(self, none_stop=False, interval=0, timeout=20):
         """
         This function creates a new Thread that calls an internal __retrieve_updates function.
@@ -302,9 +309,9 @@ class TeleBot:
             except KeyboardInterrupt:
                 logger.info("KeyboardInterrupt received.")
                 self.__stop_polling.set()
-                polling_thread.stop()
                 break
 
+        polling_thread.stop()
         logger.info('Stopped polling.')
 
     def __non_threaded_polling(self, none_stop=False, interval=0, timeout=3):
@@ -341,6 +348,11 @@ class TeleBot:
     def stop_polling(self):
         self.__stop_polling.set()
 
+    def stop_bot(self):
+        self.stop_polling()
+        if self.worker_pool:
+            self.worker_pool.close()
+
     def set_update_listener(self, listener):
         self.update_listener.append(listener)
 
@@ -351,6 +363,9 @@ class TeleBot:
     def get_file(self, file_id):
         return types.File.de_json(apihelper.get_file(self.token, file_id))
 
+    def get_file_url(self, file_id):
+        return apihelper.get_file_url(self.token, file_id)
+
     def download_file(self, file_path):
         return apihelper.download_file(self.token, file_path)
 
@@ -478,7 +493,7 @@ class TeleBot:
 
     def delete_message(self, chat_id, message_id):
         """
-        Use this method to delete message. Returns True on success. 
+        Use this method to delete message. Returns True on success.
         :param chat_id: in which chat to delete
         :param message_id: which message to delete
         :return: API reply.
@@ -486,24 +501,25 @@ class TeleBot:
         return apihelper.delete_message(self.token, chat_id, message_id)
 
     def send_photo(self, chat_id, photo, caption=None, reply_to_message_id=None, reply_markup=None,
-                   disable_notification=None):
+                   parse_mode=None, disable_notification=None):
         """
         Use this method to send photos.
         :param disable_notification:
         :param chat_id:
         :param photo:
         :param caption:
+        :param parse_mode
         :param reply_to_message_id:
         :param reply_markup:
         :return: API reply.
         """
         return types.Message.de_json(
             apihelper.send_photo(self.token, chat_id, photo, caption, reply_to_message_id, reply_markup,
-                                 disable_notification))
+                                 parse_mode, disable_notification))
 
     def send_audio(self, chat_id, audio, caption=None, duration=None, performer=None, title=None,
-                   reply_to_message_id=None,
-                   reply_markup=None, disable_notification=None, timeout=None):
+                   reply_to_message_id=None, reply_markup=None, parse_mode=None, disable_notification=None,
+                   timeout=None):
         """
         Use this method to send audio files, if you want Telegram clients to display them in the music player. Your audio must be in the .mp3 format.
         :param chat_id:Unique identifier for the message recipient
@@ -511,16 +527,17 @@ class TeleBot:
         :param duration:Duration of the audio in seconds
         :param performer:Performer
         :param title:Track name
+        :param parse_mode
         :param reply_to_message_id:If the message is a reply, ID of the original message
         :param reply_markup:
         :return: Message
         """
         return types.Message.de_json(
             apihelper.send_audio(self.token, chat_id, audio, caption, duration, performer, title, reply_to_message_id,
-                                 reply_markup, disable_notification, timeout))
+                                 reply_markup, parse_mode, disable_notification, timeout))
 
     def send_voice(self, chat_id, voice, caption=None, duration=None, reply_to_message_id=None, reply_markup=None,
-                   disable_notification=None, timeout=None):
+                   parse_mode=None, disable_notification=None, timeout=None):
         """
         Use this method to send audio files, if you want Telegram clients to display the file as a playable voice message.
         :param chat_id:Unique identifier for the message recipient.
@@ -528,25 +545,28 @@ class TeleBot:
         :param duration:Duration of sent audio in seconds
         :param reply_to_message_id:
         :param reply_markup:
+        :param parse_mode
         :return: Message
         """
         return types.Message.de_json(
             apihelper.send_voice(self.token, chat_id, voice, caption, duration, reply_to_message_id, reply_markup,
-                                 disable_notification, timeout))
+                                 parse_mode, disable_notification, timeout))
 
     def send_document(self, chat_id, data, reply_to_message_id=None, caption=None, reply_markup=None,
-                      disable_notification=None, timeout=None):
+                      parse_mode=None, disable_notification=None, timeout=None):
         """
         Use this method to send general files.
         :param chat_id:
         :param data:
         :param reply_to_message_id:
         :param reply_markup:
+        :param parse_mode:
+        :param disable_notification:
         :return: API reply.
         """
         return types.Message.de_json(
             apihelper.send_data(self.token, chat_id, data, 'document', reply_to_message_id, reply_markup,
-                                disable_notification, timeout, caption=caption))
+                                parse_mode, disable_notification, timeout, caption=caption))
 
     def send_sticker(self, chat_id, data, reply_to_message_id=None, reply_markup=None, disable_notification=None,
                      timeout=None):
@@ -563,20 +583,22 @@ class TeleBot:
                                 disable_notification, timeout))
 
     def send_video(self, chat_id, data, duration=None, caption=None, reply_to_message_id=None, reply_markup=None,
-                   disable_notification=None, timeout=None):
+                   parse_mode=None, supports_streaming=None, disable_notification=None, timeout=None):
         """
         Use this method to send video files, Telegram clients support mp4 videos.
         :param chat_id: Integer : Unique identifier for the message recipient — User or GroupChat id
         :param data: InputFile or String : Video to send. You can either pass a file_id as String to resend a video that is already on the Telegram server
         :param duration: Integer : Duration of sent video in seconds
         :param caption: String : Video caption (may also be used when resending videos by file_id).
+        :param parse_mode:
+        :param supports_streaming:
         :param reply_to_message_id:
         :param reply_markup:
         :return:
         """
         return types.Message.de_json(
             apihelper.send_video(self.token, chat_id, data, duration, caption, reply_to_message_id, reply_markup,
-                                 disable_notification, timeout))
+                                 parse_mode, supports_streaming, disable_notification, timeout))
 
     def send_video_note(self, chat_id, data, duration=None, length=None, reply_to_message_id=None, reply_markup=None,
                         disable_notification=None, timeout=None):
@@ -888,8 +910,8 @@ class TeleBot:
     def send_invoice(self, chat_id, title, description, invoice_payload, provider_token, currency, prices,
                      start_parameter, photo_url=None, photo_size=None, photo_width=None, photo_height=None,
                      need_name=None, need_phone_number=None, need_email=None, need_shipping_address=None,
-                     is_flexible=None,
-                     disable_notification=None, reply_to_message_id=None, reply_markup=None, provider_data=None):
+                     is_flexible=None, disable_notification=None, reply_to_message_id=None, reply_markup=None,
+                     provider_data=None):
         result = apihelper.send_invoice(self.token, chat_id, title, description, invoice_payload, provider_token,
                                         currency, prices, start_parameter, photo_url, photo_size, photo_width,
                                         photo_height,
@@ -903,9 +925,10 @@ class TeleBot:
     def answer_pre_checkout_query(self, pre_checkout_query_id, ok, error_message=None):
         return apihelper.answer_pre_checkout_query(self.token, pre_checkout_query_id, ok, error_message)
 
-    def edit_message_caption(self, caption, chat_id=None, message_id=None, inline_message_id=None, reply_markup=None):
+    def edit_message_caption(self, caption, chat_id=None, message_id=None, inline_message_id=None,
+                             parse_mode=None, reply_markup=None):
         result = apihelper.edit_message_caption(self.token, caption, chat_id, message_id, inline_message_id,
-                                                reply_markup)
+                                                parse_mode, reply_markup)
         if type(result) == bool:
             return result
         return types.Message.de_json(result)
@@ -1025,7 +1048,7 @@ class TeleBot:
         """
         return apihelper.delete_sticker_from_set(self.token, sticker)
 
-    def register_for_reply(self, message, callback):
+    def register_for_reply(self, message, callback, *args, **kwargs):
         """
         Registers a callback function to be notified when a reply to `message` arrives.
 
@@ -1036,40 +1059,60 @@ class TeleBot:
         :param callback:    The callback function to be called when a reply arrives. Must accept one `message`
                             parameter, which will contain the replied message.
         """
-        with self.message_subscribers_lock:
-            self.message_subscribers_messages.insert(0, message.message_id)
-            self.message_subscribers_callbacks.insert(0, callback)
-            if len(self.message_subscribers_messages) > 10000:
-                self.message_subscribers_messages.pop()
-                self.message_subscribers_callbacks.pop()
+        message_id = message.message_id
+        self.register_for_reply_by_message_id(message_id, callback, *args, **kwargs)
 
-    def _notify_message_subscribers(self, new_messages):
+    def register_for_reply_by_message_id(self, message_id, callback, *args, **kwargs):
+        """
+        Registers a callback function to be notified when a reply to `message` arrives.
+
+        Warning: `message` must be sent with reply_markup=types.ForceReply(), otherwise TeleBot will not be able to see
+        the difference between a reply to `message` and an ordinary message.
+
+        :param message:     The message for which we are awaiting a reply.
+        :param callback:    The callback function to be called when a reply arrives. Must accept one `message`
+                            parameter, which will contain the replied message.
+        """
+        if message_id in self.reply_handlers.keys():
+            self.reply_handlers[message_id].append({"callback": callback, "args": args, "kwargs": kwargs})
+        else:
+            self.reply_handlers[message_id] = [{"callback": callback, "args": args, "kwargs": kwargs}]
+
+    def _notify_reply_handlers(self, new_messages):
         for message in new_messages:
-            if not message.reply_to_message:
-                continue
+            if hasattr(message, "reply_to_message") and message.reply_to_message is not None:
+                reply_msg_id = message.reply_to_message.message_id
+                if reply_msg_id in self.reply_handlers.keys():
+                    handlers = self.reply_handlers[reply_msg_id]
+                    for handler in handlers:
+                        self._exec_task(handler["callback"], message, *handler["args"], **handler["kwargs"])
+                    self.reply_handlers.pop(reply_msg_id)
 
-            reply_msg_id = message.reply_to_message.message_id
-            if reply_msg_id in self.message_subscribers_messages:
-                index = self.message_subscribers_messages.index(reply_msg_id)
-                self.message_subscribers_callbacks[index](message)
-
-                with self.message_subscribers_lock:
-                    index = self.message_subscribers_messages.index(reply_msg_id)
-                    del self.message_subscribers_messages[index]
-                    del self.message_subscribers_callbacks[index]
-
-    def register_next_step_handler(self, message, callback):
+    def register_next_step_handler(self, message, callback, *args, **kwargs):
         """
         Registers a callback function to be notified when new message arrives after `message`.
 
-        :param message:     The message for which we want to handle new message after that in same chat.
+        :param message:     The message for which we want to handle new message in the same chat.
         :param callback:    The callback function which next new message arrives.
+        :param args:        Args to pass in callback func
+        :param kwargs:      Args to pass in callback func
         """
         chat_id = message.chat.id
-        if chat_id in self.pre_message_subscribers_next_step:
-            self.pre_message_subscribers_next_step[chat_id].append(callback)
+        self.register_next_step_handler_by_chat_id(chat_id, callback, *args, **kwargs)
+
+    def register_next_step_handler_by_chat_id(self, chat_id, callback, *args, **kwargs):
+        """
+        Registers a callback function to be notified when new message arrives after `message`.
+
+        :param chat_id:     The chat for which we want to handle new message.
+        :param callback:    The callback function which next new message arrives.
+        :param args:        Args to pass in callback func
+        :param kwargs:      Args to pass in callback func
+        """
+        if chat_id in self.next_step_handlers.keys():
+            self.next_step_handlers[chat_id].append({"callback": callback, "args": args, "kwargs": kwargs})
         else:
-            self.pre_message_subscribers_next_step[chat_id] = [callback]
+            self.next_step_handlers[chat_id] = [{"callback": callback, "args": args, "kwargs": kwargs}]
 
     def clear_step_handler(self, message):
         """
@@ -1078,26 +1121,48 @@ class TeleBot:
         :param message:     The message for which we want to handle new message after that in same chat.
         """
         chat_id = message.chat.id
-        self.pre_message_subscribers_next_step[chat_id] = []
+        self.clear_step_handler_by_chat_id(chat_id)
 
-    def _notify_message_next_handler(self, new_messages):
-        for message in new_messages:
+    def clear_step_handler_by_chat_id(self, chat_id):
+        """
+        Clears all callback functions registered by register_next_step_handler().
+
+        :param chat_id: The chat for which we want to clear next step handlers
+        """
+        self.next_step_handlers[chat_id] = []
+
+    def clear_reply_handlers(self, message):
+        """
+        Clears all callback functions registered by register_for_reply() and register_for_reply_by_message_id().
+
+        :param message_id: The message for which we want to clear reply handlers
+        """
+        message_id = message.message_id
+        self.clear_reply_handlers_by_message_id(message_id)
+
+    def clear_reply_handlers_by_message_id(self, message_id):
+        """
+        Clears all callback functions registered by register_for_reply() and register_for_reply_by_message_id().
+
+        :param message_id: The message id for which we want to clear reply handlers
+        """
+        self.reply_handlers[message_id] = []
+
+    def _notify_next_handlers(self, new_messages):
+        i = 0
+        while i < len(new_messages):
+            message = new_messages[i]
             chat_id = message.chat.id
-            if chat_id in self.message_subscribers_next_step:
-                handlers = self.message_subscribers_next_step[chat_id]
+            if chat_id in self.next_step_handlers.keys():
+                handlers = self.next_step_handlers[chat_id]
                 for handler in handlers:
-                    self._exec_task(handler, message)
-                self.message_subscribers_next_step.pop(chat_id, None)
+                    self._exec_task(handler["callback"], message, *handler["args"], **handler["kwargs"])
+                self.next_step_handlers.pop(chat_id, None)
+                new_messages.pop(i)  # removing message that detects with next_step_handler
+            i += 1
 
-    def _append_pre_next_step_handler(self):
-        for k in self.pre_message_subscribers_next_step.keys():
-            if k in self.message_subscribers_next_step:
-                self.message_subscribers_next_step[k].extend(self.pre_message_subscribers_next_step[k])
-            else:
-                self.message_subscribers_next_step[k] = self.pre_message_subscribers_next_step[k]
-        self.pre_message_subscribers_next_step = {}
-
-    def _build_handler_dict(self, handler, **filters):
+    @staticmethod
+    def _build_handler_dict(handler, **filters):
         return {
             'function': handler,
             'filters': filters
@@ -1275,9 +1340,6 @@ class TeleBot:
 
     def _notify_command_handlers(self, handlers, new_messages):
         for message in new_messages:
-            # if message has next step handler, dont exec command handlers
-            if hasattr(message, 'chat') and message.chat and (message.chat.id in self.message_subscribers_next_step):
-                continue
             for message_handler in handlers:
                 if self._test_message_handler(message_handler, message):
                     self._exec_task(message_handler['function'], message)

telebot/apihelper.py

@@ -98,9 +98,14 @@ def get_file(token, file_id):
     return _make_request(token, method_url, params={'file_id': file_id})
 
 
+def get_file_url(token, file_id):
+    method_url = r'getFile'
+    return FILE_URL.format(token, get_file(token, file_id).file_path)
+
+
 def download_file(token, file_path):
     url = FILE_URL.format(token, file_path)
-    result = _get_req_session().get(url)
+    result = _get_req_session().get(url, proxies=proxy)
     if result.status_code != 200:
         msg = 'The server returned HTTP {0} {1}. Response body:\n[{2}]' \
             .format(result.status_code, result.reason, result.text)
@@ -236,7 +241,7 @@ def forward_message(token, chat_id, from_chat_id, message_id, disable_notificati
 
 
 def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, reply_markup=None,
-               disable_notification=None):
+               parse_mode=None, disable_notification=None):
     method_url = r'sendPhoto'
     payload = {'chat_id': chat_id}
     files = None
@@ -250,6 +255,8 @@ def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, re
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
     if disable_notification:
         payload['disable_notification'] = disable_notification
     return _make_request(token, method_url, params=payload, files=files, method='post')
@@ -257,13 +264,14 @@ def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, re
 
 def send_media_group(token, chat_id, media, disable_notification=None, reply_to_message_id=None):
     method_url = r'sendMediaGroup'
-    media_json = _convert_list_json_serializable(media)
+    media_json, files = _convert_input_media(media)
     payload = {'chat_id': chat_id, 'media': media_json}
     if disable_notification:
         payload['disable_notification'] = disable_notification
     if reply_to_message_id:
         payload['reply_to_message_id'] = reply_to_message_id
-    return _make_request(token, method_url, params=payload)
+    return _make_request(token, method_url, params=payload, method='post' if files else 'get',
+                         files=files if files else None)
 
 
 def send_location(token, chat_id, latitude, longitude, live_period=None, reply_to_message_id=None, reply_markup=None,
@@ -348,7 +356,7 @@ def send_chat_action(token, chat_id, action):
 
 
 def send_video(token, chat_id, data, duration=None, caption=None, reply_to_message_id=None, reply_markup=None,
-               disable_notification=None, timeout=None):
+               parse_mode=None, supports_streaming=None, disable_notification=None, timeout=None):
     method_url = r'sendVideo'
     payload = {'chat_id': chat_id}
     files = None
@@ -364,6 +372,10 @@ def send_video(token, chat_id, data, duration=None, caption=None, reply_to_messa
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
+    if supports_streaming:
+        payload['supports_streaming'] = supports_streaming
     if disable_notification:
         payload['disable_notification'] = disable_notification
     if timeout:
@@ -372,7 +384,7 @@ def send_video(token, chat_id, data, duration=None, caption=None, reply_to_messa
 
 
 def send_voice(token, chat_id, voice, caption=None, duration=None, reply_to_message_id=None, reply_markup=None,
-               disable_notification=None, timeout=None):
+               parse_mode=None, disable_notification=None, timeout=None):
     method_url = r'sendVoice'
     payload = {'chat_id': chat_id}
     files = None
@@ -388,6 +400,8 @@ def send_voice(token, chat_id, voice, caption=None, duration=None, reply_to_mess
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
     if disable_notification:
         payload['disable_notification'] = disable_notification
     if timeout:
@@ -422,7 +436,7 @@ def send_video_note(token, chat_id, data, duration=None, length=None, reply_to_m
 
 
 def send_audio(token, chat_id, audio, caption=None, duration=None, performer=None, title=None, reply_to_message_id=None,
-               reply_markup=None, disable_notification=None, timeout=None):
+               reply_markup=None, parse_mode=None, disable_notification=None, timeout=None):
     method_url = r'sendAudio'
     payload = {'chat_id': chat_id}
     files = None
@@ -442,6 +456,8 @@ def send_audio(token, chat_id, audio, caption=None, duration=None, performer=Non
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
     if disable_notification:
         payload['disable_notification'] = disable_notification
     if timeout:
@@ -449,8 +465,8 @@ def send_audio(token, chat_id, audio, caption=None, duration=None, performer=Non
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
-def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_markup=None, disable_notification=None,
-              timeout=None, caption=None):
+def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_markup=None, parse_mode=None,
+              disable_notification=None, timeout=None, caption=None):
     method_url = get_method_by_type(data_type)
     payload = {'chat_id': chat_id}
     files = None
@@ -462,6 +478,8 @@ def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_m
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if parse_mode and data_type == 'document':
+        payload['parse_mode'] = parse_mode
     if disable_notification:
         payload['disable_notification'] = disable_notification
     if timeout:
@@ -603,7 +621,8 @@ def edit_message_text(token, text, chat_id=None, message_id=None, inline_message
     return _make_request(token, method_url, params=payload)
 
 
-def edit_message_caption(token, caption, chat_id=None, message_id=None, inline_message_id=None, reply_markup=None):
+def edit_message_caption(token, caption, chat_id=None, message_id=None, inline_message_id=None,
+                         parse_mode=None, reply_markup=None):
     method_url = r'editMessageCaption'
     payload = {'caption': caption}
     if chat_id:
@@ -612,6 +631,8 @@ def edit_message_caption(token, caption, chat_id=None, message_id=None, inline_m
         payload['message_id'] = message_id
     if inline_message_id:
         payload['inline_message_id'] = inline_message_id
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
     return _make_request(token, method_url, params=payload)
@@ -826,7 +847,7 @@ def answer_callback_query(token, callback_query_id, text=None, show_alert=None,
         payload['show_alert'] = show_alert
     if url:
         payload['url'] = url
-    if cache_time:
+    if cache_time is not None:
         payload['cache_time'] = cache_time
     return _make_request(token, method_url, params=payload, method='post')
 
@@ -835,7 +856,7 @@ def answer_inline_query(token, inline_query_id, results, cache_time=None, is_per
                         switch_pm_text=None, switch_pm_parameter=None):
     method_url = 'answerInlineQuery'
     payload = {'inline_query_id': inline_query_id, 'results': _convert_list_json_serializable(results)}
-    if cache_time:
+    if cache_time is not None:
         payload['cache_time'] = cache_time
     if is_personal:
         payload['is_personal'] = is_personal
@@ -916,10 +937,23 @@ def _convert_markup(markup):
     return markup
 
 
+def _convert_input_media(array):
+    media = []
+    files = {}
+    for input_media in array:
+        if isinstance(input_media, types.JsonSerializable):
+            media_dict = input_media.to_dic()
+            if media_dict['media'].startswith('attach://'):
+                key = media_dict['media'].replace('attach://', '')
+                files[key] = input_media.media
+            media.append(media_dict)
+    return json.dumps(media), files
+
+
 def _no_encode(func):
     def wrapper(key, val):
         if key == 'filename':
-            return '{0}={1}'.format(key, val)
+            return u'{0}={1}'.format(key, val)
         else:
             return func(key, val)
 

telebot/types.py

@@ -127,7 +127,6 @@ class Update(JsonDeserializable):
     def __init__(self, update_id, message, edited_message, channel_post, edited_channel_post, inline_query,
                  chosen_inline_result, callback_query, shipping_query, pre_checkout_query):
         self.update_id = update_id
-        self.edited_message = edited_message
         self.message = message
         self.edited_message = edited_message
         self.channel_post = channel_post
@@ -366,7 +365,10 @@ class Message(JsonDeserializable):
         if 'successful_payment' in obj:
             opts['successful_payment'] = SuccessfulPayment.de_json(obj['successful_payment'])
             content_type = 'successful_payment'
-        return cls(message_id, from_user, date, chat, content_type, opts)
+        if 'connected_website' in obj:
+            opts['connected_website'] = obj['connected_website']
+            content_type = 'connected_website'
+        return cls(message_id, from_user, date, chat, content_type, opts, json_string)
 
     @classmethod
     def parse_chat(cls, chat):
@@ -389,7 +391,7 @@ class Message(JsonDeserializable):
             ret.append(MessageEntity.de_json(me))
         return ret
 
-    def __init__(self, message_id, from_user, date, chat, content_type, options):
+    def __init__(self, message_id, from_user, date, chat, content_type, options, json_string):
         self.content_type = content_type
         self.message_id = message_id
         self.from_user = from_user
@@ -430,8 +432,66 @@ class Message(JsonDeserializable):
         self.pinned_message = None
         self.invoice = None
         self.successful_payment = None
+        self.connected_website = None
         for key in options:
             setattr(self, key, options[key])
+        self.json = json_string
+
+    @property
+    def html_text(self):
+        """
+        Author: @sviat9440
+        Message: "*Test* parse _formatting_, [url](https://example.com), [text_mention](tg://user?id=123456) and mention @username"
+
+        Example:
+            message.html_text
+            >> "<b>Test</b> parse <i>formatting</i>, <a href=\"https://example.com\">url</a>, <a href=\"tg://user?id=123456\">text_mention</a> and mention @username"
+
+        Cusom subs:
+            You can customize the substitutes. By default, there is no substitute for the entities: hashtag, bot_command, email. You can add or modify substitute an existing entity.
+        Example:
+            message.custom_subs = {"bold": "<strong class=\"example\">{text}</strong>", "italic": "<i class=\"example\">{text}</i>", "mention": "<a href={url}>{text}</a>"}
+            message.html_text
+            >> "<strong class=\"example\">Test</strong> parse <i class=\"example\">formatting</i>, <a href=\"https://example.com\">url</a> and <a href=\"tg://user?id=123456\">text_mention</a> and mention <a href=\"https://t.me/username\">@username</a>"
+        """
+
+        if not self.entities:
+            return self.text
+        _subs = {
+            "bold": "<b>{text}</b>",
+            "italic": "<i>{text}</i>",
+            "pre": "<pre>{text}</pre>",
+            "code": "<code>{text}</code>",
+            "url": "<a href=\"{url}\">{text}</a>"
+        }
+        if hasattr(self, "custom_subs"):
+            for type in self.custom_subs:
+                _subs[type] = self.custom_subs[type]
+        utf16_text = self.text.encode("utf-16-le")
+        html_text = ""
+        def func(text, type=None, url=None, user=None):
+            text = text.decode("utf-16-le")
+            if type == "text_mention":
+                type = "url"
+                url = "tg://user?id={0}".format(user.id)
+            elif type == "mention":
+                url = "https://t.me/{0}".format(text[1:])
+            if not type or not _subs.get(type):
+                return text
+            subs = _subs.get(type)
+            text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            return subs.format(text=text, url=url)
+
+        offset = 0
+        for entity in self.entities:
+            if entity.offset > offset:
+                html_text += func(utf16_text[offset * 2 : entity.offset * 2])
+                offset = entity.offset
+            html_text += func(utf16_text[offset * 2 : (offset + entity.length) * 2], entity.type, entity.url, entity.user)
+            offset += entity.length
+        if offset * 2 < len(utf16_text):
+            html_text += func(utf16_text[offset * 2:])
+        return html_text
 
 
 class MessageEntity(JsonDeserializable):
@@ -1817,7 +1877,7 @@ class ShippingOption(JsonSerializable):
     def add_price(self, *args):
         """
         Add LabeledPrice to ShippingOption
-        :param args: LabeledPrices 
+        :param args: LabeledPrices
         """
         for price in args:
             self.prices.append(price)
@@ -1975,41 +2035,53 @@ class MaskPosition(JsonDeserializable, JsonSerializable):
 # InputMedia
 
 class InputMediaPhoto(JsonSerializable):
-    def __init__(self, media, caption=None):
+    def __init__(self, media, caption=None, parse_mode=None):
         self.type = "photo"
         self.media = media
         self.caption = caption
+        self.parse_mode = parse_mode
 
     def to_json(self):
         return json.dumps(self.to_dic())
 
     def to_dic(self):
-        ret = {'type': self.type, 'media': self.media}
+        ret = {'type': self.type, 'media': 'attach://' + util.generate_random_token()
+               if not util.is_string(self.media) else self.media}
         if self.caption:
             ret['caption'] = self.caption
+        if self.parse_mode:
+            ret['parse_mode'] = self.parse_mode
         return ret
 
 
 class InputMediaVideo(JsonSerializable):
-    def __init__(self, media, caption=None, width=None, height=None, duration=None):
+    def __init__(self, media, caption=None, parse_mode=None, width=None, height=None, duration=None,
+                 supports_streaming=None):
         self.type = "video"
         self.media = media
         self.caption = caption
+        self.parse_mode = parse_mode
         self.width = width
         self.height = height
         self.duration = duration
+        self.supports_streaming = supports_streaming
 
     def to_json(self):
         return json.dumps(self.to_dic())
 
     def to_dic(self):
-        ret = {'type': self.type, 'media': self.media}
+        ret = {'type': self.type, 'media': 'attach://' + util.generate_random_token()
+               if not util.is_string(self.media) else self.media}
         if self.caption:
             ret['caption'] = self.caption
+        if self.parse_mode:
+            ret['parse_mode'] = self.parse_mode
         if self.width:
             ret['width'] = self.width
         if self.height:
             ret['height'] = self.height
         if self.duration:
             ret['duration'] = self.duration
+        if self.supports_streaming:
+            ret['supports_streaming'] = self.supports_streaming
         return ret

telebot/util.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-
+import random
+import string
 import threading
 import traceback
 import re
@@ -13,9 +14,9 @@ try:
     import Queue
 except ImportError:
     import queue as Queue
+import logging
 
-from telebot import logger
-
+logger = logging.getLogger('TeleBot')
 
 thread_local = threading.local()
 
@@ -254,3 +255,7 @@ def per_thread(key, construct_value):
         value = construct_value()
         setattr(thread_local, key, value)
         return value
+
+
+def generate_random_token():
+    return ''.join(random.sample(string.ascii_letters, 16))

tests/test_telebot.py

@@ -391,7 +391,7 @@ class TestTeleBot:
     def create_text_message(self, text):
         params = {'text': text}
         chat = types.User(11, False, 'test')
-        return types.Message(1, None, None, chat, 'text', params)
+        return types.Message(1, None, None, chat, 'text', params, "")
 
     def test_is_string_unicode(self):
         s1 = u'string'
@@ -420,3 +420,57 @@ class TestTeleBot:
         assert len(result) == 2
         assert result[0].media_group_id is not None
         assert result[0].media_group_id == result[1].media_group_id
+
+    def test_send_media_group_local_files(self):
+        photo = open('../examples/detailed_example/kitten.jpg', 'rb')
+        video = open('./test_data/test_video.mp4', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        medias = [types.InputMediaPhoto(photo, "View"),
+                  types.InputMediaVideo(video)]
+        result = tb.send_media_group(CHAT_ID, medias)
+        assert len(result) == 2
+        assert result[0].media_group_id is not None
+        assert result[1].media_group_id is not None
+
+    def test_send_photo_formating_caption(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_photo(CHAT_ID, file_data, caption='_italic_', parse_mode='Markdown')
+        assert ret_msg.caption_entities[0].type == 'italic'
+
+    def test_send_video_formatting_caption(self):
+        file_data = open('./test_data/test_video.mp4', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_video(CHAT_ID, file_data, caption='_italic_', parse_mode='Markdown')
+        assert ret_msg.caption_entities[0].type == 'italic'
+
+    def test_send_audio_formatting_caption(self):
+        file_data = open('./test_data/record.mp3', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_audio(CHAT_ID, file_data, caption='<b>bold</b>', parse_mode='HTML')
+        assert ret_msg.caption_entities[0].type == 'bold'
+
+    def test_send_voice_formatting_caprion(self):
+        file_data = open('./test_data/record.ogg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_voice(CHAT_ID, file_data, caption='<b>bold</b>', parse_mode='HTML')
+        assert ret_msg.caption_entities[0].type == 'bold'
+        assert ret_msg.voice.mime_type == 'audio/ogg'
+
+    def test_send_media_group_formatting_caption(self):
+        tb = telebot.TeleBot(TOKEN)
+        img1 = 'https://i.imgur.com/CjXjcnU.png'
+        img2 = 'https://i.imgur.com/CjXjcnU.png'
+        medias = [types.InputMediaPhoto(img1, "*View*", parse_mode='Markdown'),
+                  types.InputMediaPhoto(img2, "_Dog_", parse_mode='Markdown')]
+        result = tb.send_media_group(CHAT_ID, medias)
+        assert len(result) == 2
+        assert result[0].media_group_id is not None
+        assert result[0].caption_entities[0].type == 'bold'
+        assert result[1].caption_entities[0].type == 'italic'
+
+    def test_send_document_formating_caption(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_document(CHAT_ID, file_data, caption='_italic_', parse_mode='Markdown')
+        assert ret_msg.caption_entities[0].type == 'italic'