Update version.X

Merge pull request #955 from fgallaire/master
Fix 'NoneType' object assignment error from #892 and #954
2023-08-10 21:12:57 +03:00 · 2020-08-24 21:36:27 +08:00 · 2020-08-22 18:32:25 +03:00 · 2020-08-22 16:11:52 +02:00 · 2020-08-21 17:33:22 +03:00 · 2020-08-21 14:09:38 +03:00
32 changed files with 3775 additions and 1663 deletions
--- a/.gitignore
+++ b/.gitignore
@ -58,4 +58,7 @@ docs/_build/

 # PyBuilder
 target/
-testMain.py
+testMain.py
+
+#VS Code
+.vscode/
--- a/.travis.yml
+++ b/.travis.yml
@ -1,11 +1,9 @@
 language: python
 python:
-    - "2.6"
-    - "2.7"
-    - "3.3"
-    - "3.4"
    - "3.5"
-    - "pypy"
+    - "3.6"
+    - "3.7"
+    - "3.8"
    - "pypy3"
 install: "pip install -r requirements.txt"
 script:
--- a/README.md
+++ b/README.md
@ -2,7 +2,8 @@

 <p align="center">A simple, but extensible Python implementation for the <a href="https://core.telegram.org/bots/api">Telegram Bot API</a>.

-[![Download Month](https://img.shields.io/pypi/v/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
+[![PyPi Package Version](https://img.shields.io/pypi/v/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
 [![Build Status](https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master)](https://travis-ci.org/eternnoir/pyTelegramBotAPI)

  * [Getting started.](#getting-started)
@ -15,6 +16,7 @@
    * [General use of the API](#general-use-of-the-api)
      * [Message handlers](#message-handlers)
      * [Callback Query handlers](#callback-query-handler)
+      * [Middleware handlers](#middleware-handler)
      * [TeleBot](#telebot)
      * [Reply markup](#reply-markup)
      * [Inline Mode](#inline-mode)
@ -26,6 +28,8 @@
    * [Using web hooks](#using-web-hooks)
    * [Logging](#logging)
    * [Proxy](#proxy)
+  * [API conformance](#api-conformance)
+  * [Change log](#change-log)
  * [F.A.Q.](#faq)
    * [Bot 2.0](#bot-20)
    * [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)
@ -71,7 +75,7 @@ Then, open the file and create an instance of the TeleBot class.
 ```python
 import telebot

-bot = telebot.TeleBot("TOKEN")
+bot = telebot.TeleBot("TOKEN", parse_mode=None) # You can set parse_mode by default. HTML or MARKDOWN
 ```
 *Note: Make sure to actually replace TOKEN with your own API token.*

@ -124,7 +128,7 @@ To start the bot, simply open up a terminal and enter `python echo_bot.py` to ru
 All types are defined in types.py. They are all completely in line with the [Telegram API's definition of the types](https://core.telegram.org/bots/api#available-types), except for the Message's `from` field, which is renamed to `from_user` (because `from` is a Python reserved token). Thus, attributes such as `message_id` can be accessed directly with `message.message_id`. Note that `message.chat` can be either an instance of `User` or `GroupChat` (see [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)).

 The Message object also has a `content_type`attribute, which defines the type of the Message. `content_type` can be one of the following strings:
-`text`, `audio`, `document`, `photo`, `sticker`, `video`, `video_note`, `voice`, `location`, `contact`, `new_chat_member`, `left_chat_member`, `new_chat_title`, `new_chat_photo`, `delete_chat_photo`, `group_chat_created`, `supergroup_chat_created`, `channel_chat_created`, `migrate_to_chat_id`, `migrate_from_chat_id`, `pinned_message`.
+`text`, `audio`, `document`, `photo`, `sticker`, `video`, `video_note`, `voice`, `location`, `contact`, `new_chat_members`, `left_chat_member`, `new_chat_title`, `new_chat_photo`, `delete_chat_photo`, `group_chat_created`, `supergroup_chat_created`, `channel_chat_created`, `migrate_to_chat_id`, `migrate_from_chat_id`, `pinned_message`.

 You can use some types in one function. Example:

@ -154,7 +158,7 @@ TeleBot supports the following filters:
 |name|argument(s)|Condition|
 |:---:|---| ---|
 |content_types|list of strings (default `['text']`)|`True` if message.content_type is in the list of strings.|
-|regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html)|
+|regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html))|
 |commands|list of strings|`True` if `message.content_type == 'text'` and `message.text` starts with a command that is in the list of strings.|
 |func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`

@ -179,17 +183,17 @@ def handle_docs_audio(message):
 def handle_message(message):
 	pass

-#Handles all messages for which the lambda returns True
+# Handles all messages for which the lambda returns True
@bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
 def handle_text_doc(message):
 	pass

-#Which could also be defined as:
+# Which could also be defined as:
 def test_message(message):
 	return message.document.mime_type == 'text/plain'

@bot.message_handler(func=test_message, content_types=['document'])
-def handle_text_doc(message)
+def handle_text_doc(message):
 	pass

 # Handlers can be stacked to create a function which will be called if either message_handler is eligible
@ -203,25 +207,43 @@ def send_something(message):

 #### Edited Message handlers

-Same as Message handlers
+@bot.edited_message_handler(filters)

 #### channel_post_handler

-Same as Message handlers
+@bot.channel_post_handler(filters)

 #### edited_channel_post_handler

-Same as Message handlers
+@bot.edited_channel_post_handler(filters)

 #### Callback Query Handler

-In bot2.0 update. You can get `callback_query` in update object. In telebot use `callback_query_handler` to process callback_querys.
+In bot2.0 update. You can get `callback_query` in update object. In telebot use `callback_query_handler` to process callback queries.

 ```python
@bot.callback_query_handler(func=lambda call: True)
 def  test_callback(call):
    logger.info(call)
 ```
+#### Middleware Handler
+
+A middleware handler is a function that allows you to modify requests or the bot context as they pass through the 
+Telegram to the bot. You can imagine middleware as a chain of logic connection handled before any other handlers are
+executed.
+
+```python
+@bot.middleware_handler(update_types=['message'])
+def modify_message(bot_instance, message):
+    # modifying the message before it reaches any other handler 
+    message.another_text = message.text + ':changed'
+
+@bot.message_handler(commands=['start'])
+def start(message):
+    # the message is already modified when it reaches message handler
+    assert message.another_text == message.text + ':changed'
+```
+There are other examples using middleware handler in the [examples/middleware](examples/middleware) directory.

 #### TeleBot
 ```python
@ -250,7 +272,7 @@ updates = tb.get_updates()
 updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):

 # sendMessage
-tb.send_message(chatid, text)
+tb.send_message(chat_id, text)

 # forwardMessage
 tb.forward_message(to_chat_id, from_chat_id, message_id)
@ -291,8 +313,8 @@ tb.send_video(chat_id, "FILEID")

 # sendVideoNote
 videonote = open('/tmp/videonote.mp4', 'rb')
-tb.send_video(chat_id, videonote)
-tb.send_video(chat_id, "FILEID")
+tb.send_video_note(chat_id, videonote)
+tb.send_video_note(chat_id, "FILEID")

 # sendLocation
 tb.send_location(chat_id, lat, lon)
@ -371,7 +393,7 @@ More information about [Inline mode](https://core.telegram.org/bots/inline).

 #### inline_handler

-Now, you can use inline_handler to get inline_query in telebot.
+Now, you can use inline_handler to get inline queries in telebot.

 ```python

@ -465,7 +487,10 @@ The TeleBot constructor takes the following optional arguments:
   TeleBot should execute message handlers on it's polling Thread.

 ### The listener mechanism
-As an alternative to the message handlers, one can also register a function as a listener to TeleBot. Example:
+As an alternative to the message handlers, one can also register a function as a listener to TeleBot.
+
+NOTICE: handlers won't disappear! Your message will be processed both by handlers and listeners. Also, it's impossible to predict which will work at first because of threading. If you use threaded=False, custom listeners will work earlier, after them handlers will be called. 
+Example:
 ```python
 def handle_messages(messages):
 	for message in messages:
@ -500,19 +525,43 @@ 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'}
 ```


+## API conformance
+
+_Checking is in progress..._
+
+✅ [Bot API 3.5](https://core.telegram.org/bots/api-changelog#november-17-2017) _- To be checked..._
+
+* ✔ [Bot API 3.4](https://core.telegram.org/bots/api-changelog#october-11-2017)
+* ✔ [Bot API 3.3](https://core.telegram.org/bots/api-changelog#august-23-2017)
+* ✔ [Bot API 3.2](https://core.telegram.org/bots/api-changelog#july-21-2017)
+* ✔ [Bot API 3.1](https://core.telegram.org/bots/api-changelog#june-30-2017)
+* ✔ [Bot API 3.0](https://core.telegram.org/bots/api-changelog#may-18-2017)
+* ✔ [Bot API 2.3.1](https://core.telegram.org/bots/api-changelog#december-4-2016)
+* ✔ [Bot API 2.3](https://core.telegram.org/bots/api-changelog#november-21-2016)
+* ✔ [Bot API 2.2](https://core.telegram.org/bots/api-changelog#october-3-2016)
+* ✔ [Bot API 2.1](https://core.telegram.org/bots/api-changelog#may-22-2016)
+* ✔ [Bot API 2.0](https://core.telegram.org/bots/api-changelog#april-9-2016) 
+
+
+## Change log
+
+27.04.2020 - Poll and Dice are up to date.
+Python2 conformance is not checked any more due to EOL. 
+
+11.04.2020 - Refactoring. new_chat_member is out of support. Bugfix in html_text. Started Bot API conformance checking.
+
+06.06.2019 - Added polls support (Poll). Added functions send_poll, stop_poll
+
 ## F.A.Q.

 ### Bot 2.0
@ -527,16 +576,16 @@ Telegram Bot API support new type Chat for message.chat.
 - Check the ```type``` attribute in ```Chat``` object:
 -
 ```python
-if message.chat.type == “private”:
+if message.chat.type == "private":
 	# private chat message

-if message.chat.type == “group”:
+if message.chat.type == "group":
 	# group chat message

-if message.chat.type == “supergroup”:
+if message.chat.type == "supergroup":
 	# supergroup chat message

-if message.chat.type == “channel”:
+if message.chat.type == "channel":
 	# channel message

 ```
@ -564,7 +613,7 @@ Get help. Discuss. Chat.
 * [Telegram Proxy Bot](https://github.com/mrgigabyte/proxybot) by *mrgigabyte* - `Credits for the original version of this bot goes to` **Groosha** `, simply added certain features which I thought were needed`.
 * [RadRetroRobot](https://github.com/Tronikart/RadRetroRobot) by *Tronikart* - Multifunctional Telegram Bot RadRetroRobot.
 * [League of Legends bot](https://telegram.me/League_of_Legends_bot) ([source](https://github.com/i32ropie/lol)) by *i32ropie*
-* [NeoBot](https://github.com/neoranger/NeoBot) by *neoranger*
+* [NeoBot](https://github.com/neoranger/NeoBot) by [@NeoRanger](https://github.com/neoranger)
 * [TagAlertBot](https://github.com/pitasi/TagAlertBot) by *pitasi*
 * [ComedoresUGRbot](http://telegram.me/ComedoresUGRbot) ([source](https://github.com/alejandrocq/ComedoresUGRbot)) by [*alejandrocq*](https://github.com/alejandrocq) - Telegram bot to check the menu of Universidad de Granada dining hall.
 * [picpingbot](https://web.telegram.org/#/im?p=%40picpingbot) - Fun anonymous photo exchange by Boogie Muffin.
@ -579,6 +628,32 @@ Get help. Discuss. Chat.
 * [EmaProject](https://github.com/halkliff/emaproject) by [*halkliff*](https://github.com/halkliff) - Ema - Eastern Media Assistant was made thinking on the ease-to-use feature. Coding here is simple, as much as is fast and powerful.
 * [filmratingbot](http://t.me/filmratingbot)([source](https://github.com/jcolladosp/film-rating-bot)) by [*jcolladosp*](https://github.com/jcolladosp) - Telegram bot using the Python API that gets films rating from IMDb and metacritic
 * [you2mp3bot](http://t.me/you2mp3bot)([link](https://storebot.me/bot/you2mp3bot)) - This bot can convert a Youtube video to Mp3. All you need is send the URL video.
-* [areajugonesbot](http://t.me/areajugonesbot)([link](http://t.me/areajugonesbot)) - The areajugonesbot sends news published on the videogames blog Areajugones to Telegram.
+* [Send2Kindlebot](http://t.me/Send2KindleBot) ([source](https://github.com/GabrielRF/Send2KindleBot)) by *GabrielRF* - Send to Kindle service.
+* [RastreioBot](http://t.me/RastreioBot) ([source](https://github.com/GabrielRF/RastreioBot)) by *GabrielRF* - Bot used to track packages on the Brazilian Mail Service.
+* [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.
+* [MusicQuiz_bot](https://t.me/MusicQuiz_bot) by [Etoneja](https://github.com/Etoneja) - Listen to audio samples and try to name the performer of the song.
+* [Bot-Telegram-Shodan ](https://github.com/rubenleon/Bot-Telegram-Shodan) by [rubenleon](https://github.com/rubenleon)
+* [MandangoBot](https://t.me/MandangoBot) by @Alvaricias - Bot for managing Marvel Strike Force alliances (only in spanish, atm).
+* [ManjaroBot](https://t.me/ManjaroBot) by [@NeoRanger](https://github.com/neoranger) - Bot for Manjaro Linux Spanish group with a lot of info for Manjaro Newbies.
+* [VigoBusTelegramBot](https://t.me/vigobusbot) ([GitHub](https://github.com/Pythoneiro/VigoBus-TelegramBot)) - Bot that provides buses coming to a certain stop and their remaining time for the city of Vigo (Galicia - Spain)
+* [kaishnik-bot](https://t.me/kaishnik_bot) ([source](https://github.com/airatk/kaishnik-bot)) by *airatk* - bot which shows all the necessary information to KNTRU-KAI students.
+* [Creation Date](https://t.me/creationdatebot) by @karipov - interpolates account creation dates based on telegram given ID’s
+* [m0xbot](https://t.me/m0xbot) by [kor0p](https://github.com/kor0p) - tic-tac-toe.  
+* [kboardbot](https://t.me/kboardbot) by [kor0p](https://github.com/kor0p) - inline switches keyboard layout (English, Hebrew, Ukrainian, Russian).  
+* [Robbie](https://t.me/romdeliverybot) ([source](https://github.com/FacuM/romdeliverybot_support)) by @FacuM - Support Telegram bot for developers and maintainers.
+* [AsadovBot](https://t.me/asadov_bot) ([source](https://github.com/desexcile/BotApi)) by @DesExcile - Сatalog of poems by Eduard Asadov.
+* [thesaurus_com_bot](https://t.me/thesaurus_com_bot) ([source](https://github.com/LeoSvalov/words-i-learn-bot)) by @LeoSvalov - words and synonyms from [dictionary.com](https://www.dictionary.com) and [thesaurus.com](https://www.thesaurus.com) in the telegram.
+* [InfoBot](https://t.me/info2019_bot) ([source](https://github.com/irevenko/info-bot)) by @irevenko - An all-round bot that displays some statistics (weather, time, crypto etc...)
+* [FoodBot](https://t.me/ChensonUz_bot) ([source](https://github.com/Fliego/old_restaurant_telegram_chatbot)) by @Fliego - a simple bot for food ordering
+* [Sporty](https://t.me/SportydBot) ([source](https://github.com/0xnu/sporty)) by @0xnu - Telegram bot for displaying the latest news, sports schedules and injury updates.
+* [Neural style transfer](https://t.me/ebanyivolshebnikBot) ([source](https://github.com/timbyxty/StyleTransfer-tgbot)) by @timbyxty - bot for transferring style from one picture to another based on neural network.
+* [JoinGroup Silencer Bot](https://t.me/joingroup_silencer_bot) ([source](https://github.com/zeph1997/Telegram-Group-Silencer-Bot)) by [@zeph1997](https://github.com/zeph1997) - A Telegram Bot to remove "join group" and "removed from group" notifications.
+* [AdviceBook](https://t.me/adviceokbot) by [@barbax7](https://github.com/barbax7) - A Telegram Bot that allows you to receive random reading tips when you don't know which book to read.
+* [Blue_CC_Bot](https://t.me/Blue_CC_Bot) by [@Akash](https://github.com/BLUE-DEVIL1134) - A Telegram Bot Which Checks Your Given Credit Cards And Says Which Is A Real,Card And Which Is Fake.
+* [RandomInfoBot](https://t.me/RandomInfoBot) by [@Akash](https://github.com/BLUE-DEVIL1134) - A Telegram Bot Which Generates Random Information Of Humans Scraped From Over 13 Websites.

 Want to have your bot listed here? Send a Telegram message to @eternnoir or @pevdh.
--- a/README.rst
+++ b/README.rst
@ -1,807 +0,0 @@
-#
-
-.. raw:: html
-
-   <p align="center">
-
-pyTelegramBotAPI
-
-.. raw:: html
-
-   <p align="center">
-
-A simple, but extensible Python implementation for the `Telegram Bot
-API <https://core.telegram.org/bots/api>`__.
-
-|Download Month| |Build Status| |Download Month|
-
-  `Getting started. <#getting-started>`__
-  `Writing your first bot <#writing-your-first-bot>`__
-
-   -  `Prerequisites <#prerequisites>`__
-   -  `A simple echo bot <#a-simple-echo-bot>`__
-
-  `General API Documentation <#general-api-documentation>`__
-
-   -  `Types <#types>`__
-   -  `Methods <#methods>`__
-   -  `General use of the API <#general-use-of-the-api>`__
-   -  `Message handlers <#message-handlers>`__
-   -  `Callback Query handlers <#callback-query-handler>`__
-   -  `TeleBot <#telebot>`__
-   -  `Reply markup <#reply-markup>`__
-   -  `Inline Mode <#inline-mode>`__
-
-  `Advanced use of the API <#advanced-use-of-the-api>`__
-
-   -  `Asynchronous delivery of
-      messages <#asynchronous-delivery-of-messages>`__
-   -  `Sending large text messages <#sending-large-text-messages>`__
-   -  `Controlling the amount of Threads used by
-      TeleBot <#controlling-the-amount-of-threads-used-by-telebot>`__
-   -  `The listener mechanism <#the-listener-mechanism>`__
-   -  `Using web hooks <#using-web-hooks>`__
-   -  `Logging <#logging>`__
-
-  `F.A.Q. <#faq>`__
-
-   -  `Bot 2.0 <#bot-20>`__
-   -  `How can I distinguish a User and a GroupChat in
-      message.chat? <#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat>`__
-
-  `The Telegram Chat Group <#the-telegram-chat-group>`__
-  `More examples <#more-examples>`__
-  `Bots using this API <#bots-using-this-api>`__
-
-Getting started.
----------------
-
-This API is tested with Python 2.6, Python 2.7, Python 3.4, Pypy and
-Pypy 3. There are two ways to install the library:
-
-  Installation using pip (a Python package manager)\*:
-
-::
-
-    $ pip install pyTelegramBotAPI
-
-  Installation from source (requires git):
-
-::
-
-    $ git clone https://github.com/eternnoir/pyTelegramBotAPI.git
-    $ cd pyTelegramBotAPI
-    $ python setup.py install
-
-It is generally recommended to use the first option.
-
-\*\*While the API is production-ready, it is still under development and
-it has regular updates, do not forget to update it regularly by calling
-``pip install pytelegrambotapi --upgrade``\ \*
-
-Writing your first bot
----------------------
-
-Prerequisites
-~~~~~~~~~~~~~
-
-It is presumed that you [have obtained an API token with
-@BotFather](https://core.telegram.org/bots#botfather). We will call this
-token ``TOKEN``. Furthermore, you have basic knowledge of the Python
-programming language and more importantly `the Telegram Bot
-API <https://core.telegram.org/bots/api>`__.
-
-A simple echo bot
-~~~~~~~~~~~~~~~~~
-
-The TeleBot class (defined in \_\_init\_\_.py) encapsulates all API
-calls in a single class. It provides functions such as ``send_xyz``
-(``send_message``, ``send_document`` etc.) and several ways to listen
-for incoming messages.
-
-Create a file called ``echo_bot.py``. Then, open the file and create an
-instance of the TeleBot class.
-
-.. code:: python
-
-    import telebot
-
-    bot = telebot.TeleBot("TOKEN")
-
-*Note: Make sure to actually replace TOKEN with your own API token.*
-
-After that declaration, we need to register some so-called message
-handlers. Message handlers define filters which a message must pass. If
-a message passes the filter, the decorated function is called and the
-incoming message is passed as an argument.
-
-Let's define a message handler which handles incoming ``/start`` and
-``/help`` commands.
-
-.. code:: python
-
-    @bot.message_handler(commands=['start', 'help'])
-    def send_welcome(message):
-        bot.reply_to(message, "Howdy, how are you doing?")
-
-A function which is decorated by a message handler **can have an
-arbitrary name, however, it must have only one parameter (the
-message)**.
-
-Let's add another handler:
-
-.. code:: python
-
-    @bot.message_handler(func=lambda m: True)
-    def echo_all(message):
-        bot.reply_to(message, message.text)
-
-This one echoes all incoming text messages back to the sender. It uses a
-lambda function to test a message. If the lambda returns True, the
-message is handled by the decorated function. Since we want all messages
-to be handled by this function, we simply always return True.
-
-*Note: all handlers are tested in the order in which they were declared*
-
-We now have a basic bot which replies a static message to "/start" and
-"/help" commands and which echoes the rest of the sent messages. To
-start the bot, add the following to our source file:
-
-.. code:: python
-
-    bot.polling()
-
-Alright, that's it! Our source file now looks like this:
-
-.. code:: python
-
-    import telebot
-
-    bot = telebot.TeleBot("TOKEN")
-
-    @bot.message_handler(commands=['start', 'help'])
-    def send_welcome(message):
-        bot.reply_to(message, "Howdy, how are you doing?")
-
-    @bot.message_handler(func=lambda message: True)
-    def echo_all(message):
-        bot.reply_to(message, message.text)
-
-    bot.polling()
-
-To start the bot, simply open up a terminal and enter
-``python echo_bot.py`` to run the bot! Test it by sending commands
-('/start' and '/help') and arbitrary text messages.
-
-General API Documentation
-------------------------
-
-Types
-~~~~~
-
-All types are defined in types.py. They are all completely in line with
-the `Telegram API's definition of the
-types <https://core.telegram.org/bots/api#available-types>`__, except
-for the Message's ``from`` field, which is renamed to ``from_user``
-(because ``from`` is a Python reserved token). Thus, attributes such as
-``message_id`` can be accessed directly with ``message.message_id``.
-Note that ``message.chat`` can be either an instance of ``User`` or
-``GroupChat`` (see `How can I distinguish a User and a GroupChat in
-message.chat? <#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat>`__).
-
-The Message object also has a ``content_types``\ attribute, which
-defines the type of the Message. ``content_types`` can be one of the
-following strings: 'text', 'audio', 'document', 'photo', 'sticker',
-'video', 'voice', 'location', 'contact', 'new\_chat\_participant',
-'left\_chat\_participant', 'new\_chat\_title', 'new\_chat\_photo',
-'delete\_chat\_photo', 'group\_chat\_created'.
-
-Methods
-~~~~~~~
-
-All `API
-methods <https://core.telegram.org/bots/api#available-methods>`__ are
-located in the TeleBot class. They are renamed to follow common Python
-naming conventions. E.g. ``getMe`` is renamed to ``get_me`` and
-``sendMessage`` to ``send_message``.
-
-General use of the API
-~~~~~~~~~~~~~~~~~~~~~~
-
-Outlined below are some general use cases of the API.
-
-Message handlers
-^^^^^^^^^^^^^^^^
-
-A message handler is a function that is decorated with the
-``message_handler`` decorator of a TeleBot instance. Message handlers
-consist of one or multiple filters. Each filter much return True for a
-certain message in order for a message handler to become eligible to
-handle that message. A message handler is declared in the following way
-(provided ``bot`` is an instance of TeleBot):
-
-.. code:: python
-
-    @bot.message_handler(filters)
-    def function_name(message):
-        bot.reply_to(message, "This is a message handler")
-
-``function_name`` is not bound to any restrictions. Any function name is
-permitted with message handlers. The function must accept at most one
-argument, which will be the message that the function must handle.
-``filters`` is a list of keyword arguments. A filter is declared in the
-following manner: ``name=argument``. One handler may have multiple
-filters. TeleBot supports the following filters:
-
-+--------+------+------+
-| name   | argu | Cond |
-|        | ment | itio |
-|        | (s)  | n    |
-+========+======+======+
-| conten | list | ``Tr |
-| t\_typ | of   | ue`` |
-| es     | stri | if   |
-|        | ngs  | mess |
-|        | (def | age. |
-|        | ault | cont |
-|        | ``[' | ent\ |
-|        | text | _typ |
-|        | ']`` | e    |
-|        | )    | is   |
-|        |      | in   |
-|        |      | the  |
-|        |      | list |
-|        |      | of   |
-|        |      | stri |
-|        |      | ngs. |
-+--------+------+------+
-| regexp | a    | ``Tr |
-|        | regu | ue`` |
-|        | lar  | if   |
-|        | expr | ``re |
-|        | essi | .sea |
-|        | on   | rch( |
-|        | as a | rege |
-|        | stri | xp_a |
-|        | ng   | rg)` |
-|        |      | `    |
-|        |      | retu |
-|        |      | rns  |
-|        |      | ``Tr |
-|        |      | ue`` |
-|        |      | and  |
-|        |      | ``me |
-|        |      | ssag |
-|        |      | e.co |
-|        |      | nten |
-|        |      | t_ty |
-|        |      | pe = |
-|        |      | = 't |
-|        |      | ext' |
-|        |      | ``   |
-|        |      | (See |
-|        |      | `Pyt |
-|        |      | hon  |
-|        |      | Regu |
-|        |      | lar  |
-|        |      | Expr |
-|        |      | essi |
-|        |      | ons  |
-|        |      | <htt |
-|        |      | ps:/ |
-|        |      | /doc |
-|        |      | s.py |
-|        |      | thon |
-|        |      | .org |
-|        |      | /2/l |
-|        |      | ibra |
-|        |      | ry/r |
-|        |      | e.ht |
-|        |      | ml>` |
-|        |      | __   |
-+--------+------+------+
-| comman | list | ``Tr |
-| ds     | of   | ue`` |
-|        | stri | if   |
-|        | ngs  | ``me |
-|        |      | ssag |
-|        |      | e.co |
-|        |      | nten |
-|        |      | t_ty |
-|        |      | pe = |
-|        |      | = 't |
-|        |      | ext' |
-|        |      | ``   |
-|        |      | and  |
-|        |      | ``me |
-|        |      | ssag |
-|        |      | e.te |
-|        |      | xt`` |
-|        |      | star |
-|        |      | ts   |
-|        |      | with |
-|        |      | a    |
-|        |      | comm |
-|        |      | and  |
-|        |      | that |
-|        |      | is   |
-|        |      | in   |
-|        |      | the  |
-|        |      | list |
-|        |      | of   |
-|        |      | stri |
-|        |      | ngs. |
-+--------+------+------+
-| func   | a    | ``Tr |
-|        | func | ue`` |
-|        | tion | if   |
-|        | (lam | the  |
-|        | bda  | lamb |
-|        | or   | da   |
-|        | func | or   |
-|        | tion | func |
-|        | refe | tion |
-|        | renc | refe |
-|        | e)   | renc |
-|        |      | e    |
-|        |      | retu |
-|        |      | rns  |
-|        |      | ``Tr |
-|        |      | ue`` |
-+--------+------+------+
-
-Here are some examples of using the filters and message handlers:
-
-.. code:: python
-
-    import telebot
-    bot = telebot.TeleBot("TOKEN")
-
-    # Handles all text messages that contains the commands '/start' or '/help'.
-    @bot.message_handler(commands=['start', 'help'])
-    def handle_start_help(message):
-        pass
-
-    # Handles all sent documents and audio files
-    @bot.message_handler(content_types=['document', 'audio'])
-    def handle_docs_audio(message):
-        pass
-
-    # Handles all text messages that match the regular expression
-    @bot.message_handler(regexp="SOME_REGEXP")
-    def handle_message(message):
-        pass
-
-    #Handles all messages for which the lambda returns True
-    @bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
-    def handle_text_doc(message):
-        pass
-
-    #Which could also be defined as:
-    def test_message(message):
-        return message.document.mime_type == 'text/plan'
-
-    @bot.message_handler(func=test_message, content_types=['document'])
-    def handle_text_doc(message)
-        pass
-
-    # Handlers can be stacked to create a function which will be called if either message_handler is eligible
-    # This handler will be called if the message starts with '/hello' OR is some emoji
-    @bot.message_handler(commands=['hello'])
-    @bot.message_handler(func=lambda msg: msg.text.encode("utf-8") == SOME_FANCY_EMOJI)
-    def send_something(message):
-        pass
-
-**Important: all handlers are tested in the order in which they were
-declared**
-
-Callback Query Handler
-^^^^^^^^^^^^^^^^^^^^^^
-
-In bot2.0 update. You can get ``callback_query`` in update object. In
-telebot use ``callback_query_handler`` to process callback\_querys.
-
-.. code:: python
-
-    @bot.callback_query_handler(func=lambda call: True)
-    def  test_callback(call):
-        logger.info(call)
-
-TeleBot
-^^^^^^^
-
-.. code:: python
-
-    import telebot
-
-    TOKEN = '<token_string>'
-    tb = telebot.TeleBot(TOKEN) #create a new Telegram Bot object
-
-    # Upon calling this function, TeleBot starts polling the Telegram servers for new messages.
-    # - none_stop: True/False (default False) - Don't stop polling when receiving an error from the Telegram servers
-    # - interval: True/False (default False) - The interval between polling requests
-    #           Note: Editing this parameter harms the bot's response time
-    # - timeout: integer (default 20) - Timeout in seconds for long polling.
-    tb.polling(none_stop=False, interval=0, timeout=20)
-
-    # getMe
-    user = tb.get_me()
-
-    # setWebhook
-    tb.set_webhook(url="http://example.com", certificate=open('mycert.pem'))
-    # unset webhook
-    tb.remove_webhook()
-
-    # getUpdates
-    updates = tb.get_updates()
-    updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):
-
-    # sendMessage
-    tb.send_message(chatid, text)
-
-    # forwardMessage
-    tb.forward_message(to_chat_id, from_chat_id, message_id)
-
-    # All send_xyz functions which can take a file as an argument, can also take a file_id instead of a file.
-    # sendPhoto
-    photo = open('/tmp/photo.png', 'rb')
-    tb.send_photo(chat_id, photo)
-    tb.send_photo(chat_id, "FILEID")
-
-    # sendAudio
-    audio = open('/tmp/audio.mp3', 'rb')
-    tb.send_audio(chat_id, audio)
-    tb.send_audio(chat_id, "FILEID")
-
-    ## sendAudio with duration, performer and title.
-    tb.send_audio(CHAT_ID, file_data, 1, 'eternnoir', 'pyTelegram')
-
-    # sendVoice
-    voice = open('/tmp/voice.ogg', 'rb')
-    tb.send_voice(chat_id, voice)
-    tb.send_voice(chat_id, "FILEID")
-
-    # sendDocument
-    doc = open('/tmp/file.txt', 'rb')
-    tb.send_document(chat_id, doc)
-    tb.send_document(chat_id, "FILEID")
-
-    # sendSticker
-    sti = open('/tmp/sti.webp', 'rb')
-    tb.send_sticker(chat_id, sti)
-    tb.send_sticker(chat_id, "FILEID")
-
-    # sendVideo
-    video = open('/tmp/video.mp4', 'rb')
-    tb.send_video(chat_id, video)
-    tb.send_video(chat_id, "FILEID")
-
-    # sendLocation
-    tb.send_location(chat_id, lat, lon)
-
-    # sendChatAction
-    # action_string can be one of the following strings: 'typing', 'upload_photo', 'record_video', 'upload_video',
-    # 'record_audio', 'upload_audio', 'upload_document' or 'find_location'.
-    tb.send_chat_action(chat_id, action_string)
-
-    # getFile
-    # Downloading a file is straightforward
-    # Returns a File object
-    import requests
-    file_info = tb.get_file(file_id)
-
-    file = requests.get('https://api.telegram.org/file/bot{0}/{1}'.format(API_TOKEN, file_info.file_path))
-
-Reply markup
-^^^^^^^^^^^^
-
-All ``send_xyz`` functions of TeleBot take an optional ``reply_markup``
-argument. This argument must be an instance of ``ReplyKeyboardMarkup``,
-``ReplyKeyboardRemove`` or ``ForceReply``, which are defined in types.py.
-
-.. code:: python
-
-    from telebot import types
-
-    # Using the ReplyKeyboardMarkup class
-    # It's constructor can take the following optional arguments:
-    # - resize_keyboard: True/False (default False)
-    # - one_time_keyboard: True/False (default False)
-    # - selective: True/False (default False)
-    # - row_width: integer (default 3)
-    # row_width is used in combination with the add() function.
-    # It defines how many buttons are fit on each row before continuing on the next row.
-    markup = types.ReplyKeyboardMarkup(row_width=2)
-    itembtn1 = types.KeyboardButton('a')
-    itembtn2 = types.KeyboardButton('v')
-    itembtn3 = types.KeyboardButton('d')
-    markup.add(itembtn1, itembtn2, itembtn3)
-    tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
-
-    # or add strings one row at a time:
-    markup = types.ReplyKeyboardMarkup()
-    itembtna = types.KeyboardButton('a')
-    itembtnv = types.KeyboardButton('v')
-    itembtnc = types.KeyboardButton('c')
-    itembtnd = types.KeyboardButton('d')
-    itembtne = types.KeyboardButton('e')
-    markup.row(itembtna, itembtnv)
-    markup.row(itembtnc, itembtnd, itembtne)
-    tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
-
-The last example yields this result:
-
-.. figure:: https://pp.vk.me/c624430/v624430512/473e5/_mxxW7FPe4U.jpg
-   :alt: ReplyKeyboardMarkup
-
-   ReplyKeyboardMarkup
-
-.. code:: python
-
-    # ReplyKeyboardRemove: hides a previously sent ReplyKeyboardMarkup
-    # Takes an optional selective argument (True/False, default False)
-    markup = types.ReplyKeyboardRemove(selective=False)
-    tb.send_message(chat_id, message, reply_markup=markup)
-
-.. code:: python
-
-    # ForceReply: forces a user to reply to a message
-    # Takes an optional selective argument (True/False, default False)
-    markup = types.ForceReply(selective=False)
-    tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
-
-ForceReply:
-
-.. figure:: https://pp.vk.me/c624430/v624430512/473ec/602byyWUHcs.jpg
-   :alt: ForceReply
-
-   ForceReply
-
-Inline Mode
-~~~~~~~~~~~
-
-More information about `Inline
-mode <https://core.telegram.org/bots/inline>`__.
-
-inline\_handler
-^^^^^^^^^^^^^^^
-
-Now, you can use inline\_handler to get inline\_query in telebot.
-
-.. code:: python
-
-
-    @bot.inline_handler(lambda query: query.query == 'text')
-    def query_text(inline_query):
-        # Query message is text
-
-chosen\_inline\_handler
-^^^^^^^^^^^^^^^^^^^^^^^
-
-Use chosen\_inline\_handler to get chosen\_inline\_result in telebot.
-Don't forgot add the /setinlinefeedback command for @Botfather.
-
-More information :
-`collecting-feedback <https://core.telegram.org/bots/inline#collecting-feedback>`__
-
-.. code:: python
-
-    @bot.chosen_inline_handler(func=lambda chosen_inline_result: True)
-    def test_chosen(chosen_inline_result):
-        # Process all chosen_inline_result.
-
-answer\_inline\_query
-^^^^^^^^^^^^^^^^^^^^^
-
-.. code:: python
-
-    @bot.inline_handler(lambda query: query.query == 'text')
-    def query_text(inline_query):
-        try:
-            r = types.InlineQueryResultArticle('1', 'Result', 'Result message.')
-            r2 = types.InlineQueryResultArticle('2', 'Result2', 'Result message2.')
-            bot.answer_inline_query(inline_query.id, [r, r2])
-        except Exception as e:
-            print(e)
-
-Advanced use of the API
-----------------------
-
-Asynchronous delivery of messages
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There exists an implementation of TeleBot which executes all
-``send_xyz`` and the ``get_me`` functions asynchronously. This can speed
-up you bot **significantly**, but it has unwanted side effects if used
-without caution. To enable this behaviour, create an instance of
-AsyncTeleBot instead of TeleBot.
-
-.. code:: python
-
-    tb = telebot.AsyncTeleBot("TOKEN")
-
-Now, every function that calls the Telegram API is executed in a
-separate Thread. The functions are modified to return an AsyncTask
-instance (defined in util.py). Using AsyncTeleBot allows you to do the
-following:
-
-.. code:: python
-
-    import telebot
-
-    tb = telebot.AsyncTeleBot("TOKEN")
-    task = tb.get_me() # Execute an API call
-    # Do some other operations...
-    a = 0
-    for a in range(100):
-        a += 10
-
-    result = task.wait() # Get the result of the execution
-
-*Note: if you execute send\_xyz functions after eachother without
-calling wait(), the order in which messages are delivered might be
-wrong.*
-
-Sending large text messages
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Sometimes you must send messages that exceed 5000 characters. The
-Telegram API can not handle that many characters in one request, so we
-need to split the message in multiples. Here is how to do that using the
-API:
-
-.. code:: python
-
-    from telebot import util
-    large_text = open("large_text.txt", "rb").read()
-
-    # Split the text each 3000 characters.
-    # split_string returns a list with the splitted text.
-    splitted_text = util.split_string(large_text, 3000)
-    for text in splitted_text:
-        tb.send_message(chat_id, text)
-
-Controlling the amount of Threads used by TeleBot
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The TeleBot constructor takes the following optional arguments:
-
-  create\_threads: True/False (default True). A flag to indicate
-   whether TeleBot should execute message handlers on it's polling
-   Thread.
-  num\_threads: integer (default 4). Controls the amount of
-   WorkerThreads created for the internal thread pool that TeleBot uses
-   to execute message handlers. Is not used when create\_threads is
-   False.
-
-The listener mechanism
-~~~~~~~~~~~~~~~~~~~~~~
-
-As an alternative to the message handlers, one can also register a
-function as a listener to TeleBot. Example:
-
-.. code:: python
-
-    def handle_messages(messages):
-        for message in messsages:
-            # Do something with the message
-            bot.reply_to(message, 'Hi')
-
-    bot.set_update_listener(handle_messages)
-    bot.polling()
-
-Using webhooks
-~~~~~~~~~~~~~~
-
-When using webhooks telegram sends one Update per call, for processing
-it you should call process\_new\_messages([update.message]) when you
-recieve it.
-
-There are some examples using webhooks in the
-*examples/webhook\_examples* directory.
-
-Logging
-~~~~~~~
-
-You can use the Telebot module logger to log debug info about Telebot.
-Use ``telebot.logger`` to get the logger of the TeleBot module. It is
-possible to add custom logging Handlers to the logger. Refer to the
-`Python logging module
-page <https://docs.python.org/2/library/logging.html>`__ for more info.
-
-.. code:: python
-
-    import logging
-
-    logger = telebot.logger
-    telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
-
-F.A.Q.
------
-
-Bot 2.0
-~~~~~~~
-
-April 9,2016 Telegram release new bot 2.0 API, which has a drastic
-revision especially for the change of method's interface.If you want to
-update to the latest version, please make sure you've switched bot's
-code to bot 2.0 method interface.
-
-`More information about pyTelegramBotAPI support
-bot2.0 <https://github.com/eternnoir/pyTelegramBotAPI/issues/130>`__
-
-How can I distinguish a User and a GroupChat in message.chat?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Telegram Bot API support new type Chat for message.chat.
-
-  Check the ``type`` attribute in ``Chat`` object:
-  \`\`\`python if message.chat.type == “private”: # private chat
-   message
-
-if message.chat.type == “group”: # group chat message
-
-if message.chat.type == “supergroup”: # supergroup chat message
-
-if message.chat.type == “channel”: # channel message
-
-\`\`\`
-
-The Telegram Chat Group
-----------------------
-
-Get help. Discuss. Chat.
-
-  Join the pyTelegramBotAPI Telegram Chat Group
-  Messge to @eternnoir by telegram for Invitation.
-  We now have a Telegram Channel as well! Keep yourself up to date with
-   API changes, and `join it <https://telegram.me/pytelegrambotapi>`__.
-
-More examples
-------------
-
-  `Echo
-   Bot <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py>`__
-  `Deep
-   Linking <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/deep_linking.py>`__
-  `next\_step\_handler
-   Example <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/step_example.py>`__
-
-Bots using this API
-------------------
-
-  `SiteAlert bot <https://telegram.me/SiteAlert_bot>`__
-   (`source <https://github.com/ilteoood/SiteAlert-Python>`__) by
-   *ilteoood* - Monitors websites and sends a notification on changes
-  `TelegramLoggingBot <https://github.com/aRandomStranger/TelegramLoggingBot>`__
-   by *aRandomStranger*
-  `Telegram
-   LMGTFY\_bot <https://github.com/GabrielRF/telegram-lmgtfy_bot>`__ by
-   *GabrielRF*
-  `Telegram
-   UrlProBot <https://github.com/GabrielRF/telegram-urlprobot>`__ by
-   *GabrielRF*
-  `Telegram Proxy
-   Bot <https://bitbucket.org/master_groosha/telegram-proxy-bot>`__ by
-   *Groosha* - A simple BITM (bot-in-the-middle) for Telegram acting as
-   some kind of "proxy".
-  `Telegram Proxy Bot <https://github.com/mrgigabyte/proxybot>`__ by
-   *mrgigabyte* -
-   ``Credits for the original version of this bot goes to`` **Groosha**
-   ``, simply added certain features which I thought were needed``.
-  `RadRetroRobot <https://github.com/Tronikart/RadRetroRobot>`__ by
-   *Tronikart* - Multifunctional Telegram Bot RadRetroRobot.
-  `League of Legends bot <https://telegram.me/League_of_Legends_bot>`__
-   (`source <https://github.com/i32ropie/lol>`__) by *i32ropie*
-  `NeoBot <https://github.com/neoranger/NeoBot>`__ by *neoranger*
-  `TagAlertBot <https://github.com/pitasi/TagAlertBot>`__ by *pitasi*
-
-Want to have your bot listed here? Send a Telegram message to @eternnoir
-or @pevdh.
-
-.. |Download Month| image:: https://img.shields.io/pypi/v/pyTelegramBotAPI.svg
-   :target: https://pypi.python.org/pypi/pyTelegramBotAPI
-.. |Build Status| image:: https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master
-   :target: https://travis-ci.org/eternnoir/pyTelegramBotAPI
-.. |Download Month| image:: https://img.shields.io/pypi/dm/pyTelegramBotAPI.svg
-   :target: https://pypi.python.org/pypi/pyTelegramBotAPI
--- a/examples/deep_linking.py
+++ b/examples/deep_linking.py
@ -1,3 +1,5 @@
+#!/usr/bin/python
+
 # This example shows how to implement deep linking (https://core.telegram.org/bots#deep-linking)
 # with the pyTelegramBotAPI.
 # Note: This is not a working, production-ready sample.
@ -31,34 +33,38 @@
 # steps are not shown here. Only steps 5 to 7 are illustrated, some in pseudo-code, with this example.

 import telebot
-import time

 bot = telebot.TeleBot('TOKEN')

+
 def extract_unique_code(text):
    # Extracts the unique_code from the sent /start command.
    return text.split()[1] if len(text.split()) > 1 else None

+
 def in_storage(unique_code):
    # (pseudo-code) Should check if a unique code exists in storage
    return True

+
 def get_username_from_storage(unique_code):
    # (pseudo-code) Does a query to the storage, retrieving the associated username
    # Should be replaced by a real database-lookup.
    return "ABC" if in_storage(unique_code) else None

+
 def save_chat_id(chat_id, username):
    # (pseudo-code) Save the chat_id->username to storage
    # Should be replaced by a real database query.
    pass

+
@bot.message_handler(commands=['start'])
 def send_welcome(message):
    unique_code = extract_unique_code(message.text)
-    if unique_code: # if the '/start' command contains a unique_code
+    if unique_code:  # if the '/start' command contains a unique_code
        username = get_username_from_storage(unique_code)
-        if username: # if the username exists in our database
+        if username:  # if the username exists in our database
            save_chat_id(message.chat.id, username)
            reply = "Hello {0}, how are you?".format(username)
        else:
@ -67,4 +73,5 @@ def send_welcome(message):
        reply = "Please visit me via a provided URL from the website."
    bot.reply_to(message, reply)

+
 bot.polling()
--- a/examples/detailed_example/detailed_example.py
+++ b/examples/detailed_example/detailed_example.py
@ -2,9 +2,10 @@
 This is a detailed example using almost every command of the API
 """

+import time
+
 import telebot
 from telebot import types
-import time

 TOKEN = '<token_string>'

@ -12,14 +13,14 @@ knownUsers = []  # todo: save these in a file,
 userStep = {}  # so they won't reset every time the bot restarts

 commands = {  # command description used in the "help" command
-              'start': 'Get used to the bot',
-              'help': 'Gives you information about the available commands',
-              'sendLongText': 'A test using the \'send_chat_action\' command',
-              'getImage': 'A test using multi-stage messages, custom keyboard, and media sending'
+    'start'       : 'Get used to the bot',
+    'help'        : 'Gives you information about the available commands',
+    'sendLongText': 'A test using the \'send_chat_action\' command',
+    'getImage'    : 'A test using multi-stage messages, custom keyboard, and media sending'
 }

 imageSelect = types.ReplyKeyboardMarkup(one_time_keyboard=True)  # create the image selection keyboard
-imageSelect.add('cock', 'pussy')
+imageSelect.add('Mickey', 'Minnie')

 hideBoard = types.ReplyKeyboardRemove()  # if sent as reply_markup, will hide the keyboard

@ -33,7 +34,7 @@ def get_user_step(uid):
    else:
        knownUsers.append(uid)
        userStep[uid] = 0
-        print "New user detected, who hasn't used \"/start\" yet"
+        print("New user detected, who hasn't used \"/start\" yet")
        return 0


@ -45,7 +46,7 @@ def listener(messages):
    for m in messages:
        if m.content_type == 'text':
            # print the sent message to the console
-            print str(m.chat.first_name) + " [" + str(m.chat.id) + "]: " + m.text
+            print(str(m.chat.first_name) + " [" + str(m.chat.id) + "]: " + m.text)


 bot = telebot.TeleBot(TOKEN)
@ -104,15 +105,15 @@ def msg_image_select(m):
    # for some reason the 'upload_photo' status isn't quite working (doesn't show at all)
    bot.send_chat_action(cid, 'typing')

-    if text == "cock":  # send the appropriate image based on the reply to the "/getImage" command
+    if text == 'Mickey':  # send the appropriate image based on the reply to the "/getImage" command
        bot.send_photo(cid, open('rooster.jpg', 'rb'),
                       reply_markup=hideBoard)  # send file and hide keyboard, after image is sent
        userStep[cid] = 0  # reset the users step back to 0
-    elif text == "pussy":
+    elif text == 'Minnie':
        bot.send_photo(cid, open('kitten.jpg', 'rb'), reply_markup=hideBoard)
        userStep[cid] = 0
    else:
-        bot.send_message(cid, "Don't type bullsh*t, if I give you a predefined keyboard!")
+        bot.send_message(cid, "Please, use the predefined keyboard!")
        bot.send_message(cid, "Please try again")


@ -128,4 +129,5 @@ def command_default(m):
    # this is the standard reply to a normal message
    bot.send_message(m.chat.id, "I don't understand \"" + m.text + "\"\nMaybe try the help page at /help")

+
 bot.polling()
--- a/examples/echo_bot.py
+++ b/examples/echo_bot.py
@ -1,3 +1,5 @@
+#!/usr/bin/python
+
 # This is a simple echo bot using the decorator mechanism.
 # It echoes any incoming text messages.

@ -7,6 +9,7 @@ API_TOKEN = '<api_token>'

 bot = telebot.TeleBot(API_TOKEN)

+
 # Handle '/start' and '/help'
@bot.message_handler(commands=['help', 'start'])
 def send_welcome(message):
@ -21,4 +24,5 @@ I am here to echo your kind words back to you. Just say anything nice and I'll s
 def echo_message(message):
    bot.reply_to(message, message.text)

+
 bot.polling()
--- a/examples/inline_example.py
+++ b/examples/inline_example.py
@ -1,8 +1,9 @@
-# This example show how to write an inline mode telegramt bot use pyTelegramBotAPI.
-import telebot
-import time
-import sys
+# This example show how to write an inline mode telegram bot use pyTelegramBotAPI.
 import logging
+import sys
+import time
+
+import telebot
 from telebot import types

 API_TOKEN = '<TOKEN>'
@ -50,7 +51,7 @@ def query_video(inline_query):
        print(e)


-@bot.inline_handler(lambda query: len(query.query) is 0)
+@bot.inline_handler(lambda query: len(query.query) == 0)
 def default_query(inline_query):
    try:
        r = types.InlineQueryResultArticle('1', 'default', types.InputTextMessageContent('default'))
@ -69,5 +70,5 @@ if __name__ == '__main__':
    try:
        main_loop()
    except KeyboardInterrupt:
-        print >> sys.stderr, '\nExiting by user request.\n'
+        print('\nExiting by user request.\n')
        sys.exit(0)
--- a/examples/inline_keyboard_example.py
+++ b/examples/inline_keyboard_example.py
@ -0,0 +1,27 @@
+# This example show how to use inline keyboards and process button presses
+import telebot
+from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+TELEGRAM_TOKEN = '<TOKEN>'
+
+bot = telebot.TeleBot(TELEGRAM_TOKEN)
+
+def gen_markup():
+    markup = InlineKeyboardMarkup()
+    markup.row_width = 2
+    markup.add(InlineKeyboardButton("Yes", callback_data="cb_yes"),
+                               InlineKeyboardButton("No", callback_data="cb_no"))
+    return markup
+
+@bot.callback_query_handler(func=lambda call: True)
+def callback_query(call):
+    if call.data == "cb_yes":
+        bot.answer_callback_query(call.id, "Answer is Yes")
+    elif call.data == "cb_no":
+        bot.answer_callback_query(call.id, "Answer is No")
+
+@bot.message_handler(func=lambda message: True)
+def message_handler(message):
+    bot.send_message(message.chat.id, "Yes/no?", reply_markup=gen_markup())
+
+bot.polling(none_stop=True)
--- a/examples/middleware/i18n.py
+++ b/examples/middleware/i18n.py
@ -0,0 +1,53 @@
+#!/usr/bin/python
+
+# This example shows how to implement i18n (internationalization) l10n (localization) to create
+# multi-language bots with middleware handler.
+#
+# Note: For the sake of simplicity of this example no extra library is used. However, it is recommended to use
+# better i18n systems (gettext and etc) for handling multilingual translations.
+# This is not a working, production-ready sample and it is highly recommended not to use it in production.
+#
+# In this example let's imagine we want to introduce localization or internationalization into our project and
+# we need some global function to activate the language once and to use that language in all other message
+# handler functions for not repeatedly activating it.
+# The middleware (i18n and l10n) is explained:
+
+import telebot
+from telebot import apihelper
+
+apihelper.ENABLE_MIDDLEWARE = True
+
+TRANSLATIONS = {
+    'hello': {
+        'en': 'hello',
+        'ru': 'привет',
+        'uz': 'salom'
+    }
+}
+
+_lang = 'en'
+
+
+def activate(lang):
+    global _lang
+    _lang = lang
+
+
+def _(string):
+    return TRANSLATIONS[string][_lang]
+
+
+bot = telebot.TeleBot('TOKEN')
+
+
+@bot.middleware_handler(update_types=['message'])
+def activate_language(bot_instance, message):
+    activate(message.from_user.language_code)
+
+
+@bot.message_handler(commands=['start'])
+def start(message):
+    bot.send_message(message.chat.id, _('hello'))
+
+
+bot.polling()
--- a/examples/middleware/session.py
+++ b/examples/middleware/session.py
@ -0,0 +1,61 @@
+#!/usr/bin/python
+
+# This example shows how to implement session creation and retrieval based on user id with middleware handler.
+#
+# Note: For the sake of simplicity of this example no extra library is used. However, it is recommended to use
+# in-memory or on-disk storage implementations (redis, mysql, postgres and etc) for storing and retrieving structures.
+# This is not a working, production-ready sample and it is highly recommended not to use it in production.
+#
+# In this example let's imagine we want to create a session for each user who communicates with the bot to store
+# different kind of temporary data while session is active. As an example we want to track the state of the user
+# with the help of this session. So, we need a way to store this session data somewhere globally to enable other
+# message handler functions to be able to use it.
+# The middleware session is explained:
+
+import telebot
+from telebot import apihelper
+
+apihelper.ENABLE_MIDDLEWARE = True
+
+INFO_STATE = 'ON_INFO_MENU'
+MAIN_STATE = 'ON_MAIN_MENU'
+
+SESSIONS = {
+    -10000: {
+        'state': INFO_STATE
+    },
+    -11111: {
+        'state': MAIN_STATE
+    }
+}
+
+
+def get_or_create_session(user_id):
+    try:
+        return SESSIONS[user_id]
+    except KeyError:
+        SESSIONS[user_id] = {'state': MAIN_STATE}
+        return SESSIONS[user_id]
+
+
+bot = telebot.TeleBot('TOKEN')
+
+
+@bot.middleware_handler(update_types=['message'])
+def set_session(bot_instance, message):
+    bot_instance.session = get_or_create_session(message.from_user.id)
+
+
+@bot.message_handler(commands=['start'])
+def start(message):
+    bot.session['state'] = MAIN_STATE
+    bot.send_message(message.chat.id, bot.session['state'])
+
+
+@bot.message_handler(commands=['info'])
+def start(message):
+    bot.session['state'] = INFO_STATE
+    bot.send_message(message.chat.id, bot.session['state'])
+
+
+bot.polling()
--- a/examples/payments_example.py
+++ b/examples/payments_example.py
@ -1,6 +1,5 @@
 import telebot
-from telebot.types import LabeledPrice
-from telebot.types import ShippingOption
+from telebot.types import LabeledPrice, ShippingOption

 token = '1234567890:AAAABBBBCCCCDDDDeeeeFFFFgggGHHHH'
 provider_token = '1234567890:TEST:AAAABBBBCCCCDDDD'  # @BotFather -> Bot Settings -> Payments
--- a/examples/serverless/azure_functions
+++ b/examples/serverless/azure_functions
@ -0,0 +1,69 @@
+# Using Azure Functions for serverless bots.
+# (Thanks to twitter.com/masyan for the idea)
+
+# By default the Azure Functions url is https://.../api/HttpTrigger for HttpTrigger type.
+# In this example we will use clear webhook url without /api/ -> https://.../HttpTrigger.
+# Also we set "authLevel": "anonymous".
+
+# For HttpTrigger type set "route" and "authLevel" in functions.json
+# {
+#   "bindings": [
+#   ...
+#   "authLevel": "anonymous"
+#   "route": "HttpTrigger"
+#   ]
+# }
+
+# To avoid using /api/ in url set "routePrefix":"" in host.json
+# {
+#   ...
+#   "extensions": {
+#     "http": {
+#       "routePrefix": ""
+#     }
+#   }
+# }
+
+import logging
+
+import azure.functions as func
+import telebot
+from telebot import apihelper, types
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.DEBUG)
+
+# Set bot token
+TOKEN = ''
+
+# Uncomment this for using proxy for request
+# PROXY = ''
+# apihelper.proxy = {'https': PROXY}
+
+# Set WEBHOOK as your Azure Functions url (https://...azurewebsites.net/HttpTrigger)
+WEBHOOK = ''
+
+bot = telebot.TeleBot(TOKEN)
+
+@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)
+
+# To avoid "error 429 too many request" set webhook only once. Or use time.sleep(1).
+def main(req: func.HttpRequest) -> func.HttpResponse:
+    bot.set_webhook(url=WEBHOOK)
+    request_body_dict = req.get_json()
+    update = telebot.types.Update.de_json(request_body_dict)
+    bot.process_new_messages([update.message])
+    return func.HttpResponse(body='', status_code=200)
+    
+# Sometimes "requests" version is important. 
+# azure-functions==1.0.4
+# PySocks==1.7.1
+# pyTelegramBotAPI==3.6.6
+# requests==2.10.0
+
--- a/examples/step_example.py
+++ b/examples/step_example.py
@ -2,7 +2,6 @@
 """
 This Example will show you how to use register_next_step handler.
 """
-import time

 import telebot
 from telebot import types
@ -75,4 +74,13 @@ def process_sex_step(message):
        bot.reply_to(message, 'oooops')


+# Enable saving next step handlers to file "./.handlers-saves/step.save".
+# Delay=2 means that after any change in next step handlers (e.g. calling register_next_step_handler())
+# saving will hapen after delay 2 seconds.
+bot.enable_save_next_step_handlers(delay=2)
+
+# Load next_step_handlers from save file (default "./.handlers-saves/step.save")
+# WARNING It will work only if enable_save_next_step_handlers was called!
+bot.load_next_step_handlers()
+
 bot.polling()
--- a/examples/telebot_bot/telebot_bot.py
+++ b/examples/telebot_bot/telebot_bot.py
@ -3,9 +3,10 @@
 # and goes by the name 'TeleBot (@pyTeleBot)'. Join our group to talk to him!
 # WARNING: Tested with Python 2.7

-import telebot
 import os

+import telebot
+
 text_messages = {
    'welcome':
        u'Please welcome {name}!\n\n'
@ -33,8 +34,10 @@ if "TELEBOT_BOT_TOKEN" not in os.environ or "GROUP_CHAT_ID" not in os.environ:
 bot = telebot.AsyncTeleBot(os.environ["TELEBOT_BOT_TOKEN"])
 GROUP_CHAT_ID = int(os.environ["GROUP_CHAT_ID"])

+
 def is_api_group(chat_id):
-    return chat_id== GROUP_CHAT_ID
+    return chat_id == GROUP_CHAT_ID
+

@bot.message_handler(func=lambda m: True, content_types=['new_chat_participant'])
 def on_user_joins(message):
@ -50,6 +53,7 @@ def on_user_joins(message):

    bot.reply_to(message, text_messages['welcome'].format(name=name))

+
@bot.message_handler(commands=['info', 'help'])
 def on_info(message):
    if not is_api_group(message.chat.id):
@ -58,21 +62,23 @@ def on_info(message):

    bot.reply_to(message, text_messages['info'])

+
@bot.message_handler(commands=["ping"])
 def on_ping(message):
    bot.reply_to(message, "Still alive and kicking!")

+
@bot.message_handler(commands=['start'])
 def on_start(message):
    if not is_api_group(message.chat.id):
        bot.reply_to(message, text_messages['wrong_chat'])
        return

+
 def listener(messages):
    for m in messages:
-        print str(m)
+        print(str(m))
+

 bot.set_update_listener(listener)
 bot.polling()
-
-
--- a/examples/webhook_examples/webhook_aiohttp_echo_bot.py
+++ b/examples/webhook_examples/webhook_aiohttp_echo_bot.py
@ -11,7 +11,6 @@ from aiohttp import web

 import telebot

-
 API_TOKEN = '<api_token>'

 WEBHOOK_HOST = '<ip/host where the bot is running>'
@ -32,7 +31,6 @@ WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
 WEBHOOK_URL_BASE = "https://{}:{}".format(WEBHOOK_HOST, WEBHOOK_PORT)
 WEBHOOK_URL_PATH = "/{}/".format(API_TOKEN)

-
 logger = telebot.logger
 telebot.logger.setLevel(logging.INFO)

@ -51,6 +49,7 @@ async def handle(request):
    else:
        return web.Response(status=403)

+
 app.router.add_post('/{token}/', handle)


@ -72,7 +71,7 @@ def echo_message(message):
 bot.remove_webhook()

 # Set webhook
-bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
+bot.set_webhook(url=WEBHOOK_URL_BASE + WEBHOOK_URL_PATH,
                certificate=open(WEBHOOK_SSL_CERT, 'r'))

 # Build ssl context
--- a/examples/webhook_examples/webhook_cherrypy_echo_bot.py
+++ b/examples/webhook_examples/webhook_cherrypy_echo_bot.py
@ -4,10 +4,11 @@
 # This is a simple echo bot using decorators and webhook with CherryPy
 # It echoes any incoming text messages and does not use the polling method.

-import cherrypy
-import telebot
 import logging

+import cherrypy
+
+import telebot

 API_TOKEN = '<api_token>'

@ -29,7 +30,6 @@ WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
 WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
 WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)

-
 logger = telebot.logger
 telebot.logger.setLevel(logging.INFO)

@ -70,7 +70,7 @@ def echo_message(message):
 bot.remove_webhook()

 # Set webhook
-bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
+bot.set_webhook(url=WEBHOOK_URL_BASE + WEBHOOK_URL_PATH,
                certificate=open(WEBHOOK_SSL_CERT, 'r'))

 # Disable CherryPy requests log
@ -80,9 +80,9 @@ for handler in tuple(access_log.handlers):

 # Start cherrypy server
 cherrypy.config.update({
-    'server.socket_host': WEBHOOK_LISTEN,
-    'server.socket_port': WEBHOOK_PORT,
-    'server.ssl_module': 'builtin',
+    'server.socket_host'    : WEBHOOK_LISTEN,
+    'server.socket_port'    : WEBHOOK_PORT,
+    'server.ssl_module'     : 'builtin',
    'server.ssl_certificate': WEBHOOK_SSL_CERT,
    'server.ssl_private_key': WEBHOOK_SSL_PRIV
 })
--- a/examples/webhook_examples/webhook_cpython_echo_bot.py
+++ b/examples/webhook_examples/webhook_cpython_echo_bot.py
@ -4,11 +4,17 @@
 # This is a simple echo bot using decorators and webhook with BaseHTTPServer
 # It echoes any incoming text messages and does not use the polling method.

-import BaseHTTPServer
-import ssl
-import telebot
-import logging
+try:
+    # Python 2
+    from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+except ImportError:
+    # Python 3
+    from http.server import BaseHTTPRequestHandler, HTTPServer

+import logging
+import ssl
+
+import telebot

 API_TOKEN = '<api_token>'

@ -30,7 +36,6 @@ WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
 WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
 WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)

-
 logger = telebot.logger
 telebot.logger.setLevel(logging.INFO)

@ -38,7 +43,7 @@ bot = telebot.TeleBot(API_TOKEN)


 # WebhookHandler, process webhook calls
-class WebhookHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+class WebhookHandler(BaseHTTPRequestHandler):
    server_version = "WebhookHandler/1.0"

    def do_HEAD(self):
@ -81,15 +86,17 @@ def echo_message(message):


 # Remove webhook, it fails sometimes the set if there is a previous webhook
-bot.remove_webhook()
+#bot.remove_webhook()

 # Set webhook
-bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
-                certificate=open(WEBHOOK_SSL_CERT, 'r'))
+# Beacuse telegram bot api server will check webhook server is alive.
+# Here we need set webhook after server started manually.
+#bot.set_webhook(url=WEBHOOK_URL_BASE + WEBHOOK_URL_PATH,
+#                certificate=open(WEBHOOK_SSL_CERT, 'r'))

 # Start server
-httpd = BaseHTTPServer.HTTPServer((WEBHOOK_LISTEN, WEBHOOK_PORT),
-                                  WebhookHandler)
+httpd = HTTPServer((WEBHOOK_LISTEN, WEBHOOK_PORT),
+                   WebhookHandler)

 httpd.socket = ssl.wrap_socket(httpd.socket,
                               certfile=WEBHOOK_SSL_CERT,
--- a/examples/webhook_examples/webhook_flask_echo_bot.py
+++ b/examples/webhook_examples/webhook_flask_echo_bot.py
@ -4,10 +4,12 @@
 # This is a simple echo bot using decorators and webhook with flask
 # It echoes any incoming text messages and does not use the polling method.

-import flask
-import telebot
 import logging
+import time

+import flask
+
+import telebot

 API_TOKEN = '<api_token>'

@ -29,7 +31,6 @@ WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
 WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
 WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)

-
 logger = telebot.logger
 telebot.logger.setLevel(logging.INFO)

@ -73,8 +74,10 @@ 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,
+bot.set_webhook(url=WEBHOOK_URL_BASE + WEBHOOK_URL_PATH,
                certificate=open(WEBHOOK_SSL_CERT, 'r'))

 # Start flask server
--- a/examples/webhook_examples/webhook_flask_heroku_echo.py
+++ b/examples/webhook_examples/webhook_flask_heroku_echo.py
@ -1,29 +1,36 @@
-import telebot
 import os
+
 from flask import Flask, request

-bot = telebot.TeleBot('<api_token>')
+import telebot

+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)))
--- a/examples/webhook_examples/webhook_tornado_echo_bot.py
+++ b/examples/webhook_examples/webhook_tornado_echo_bot.py
@ -4,13 +4,15 @@
 # This example shows webhook echo bot with Tornado web framework
 # Documenation to Tornado: http://tornadoweb.org

-import telebot
-import tornado.web
-import tornado.ioloop
-import tornado.httpserver
-import tornado.options
 import signal

+import tornado.httpserver
+import tornado.ioloop
+import tornado.options
+import tornado.web
+
+import telebot
+
 API_TOKEN = '<api_token>'
 WEBHOOK_CERT = "./cert.pem"
 WEBHOOK_PKEY = "./pkey.pem"
@ -29,15 +31,18 @@ WEBHOOK_URL_BASE = "https://{0}:{1}/{2}".format(WEBHOOK_HOST, str(WEBHOOK_PORT),

 bot = telebot.TeleBot(API_TOKEN)

+
 class Root(tornado.web.RequestHandler):
    def get(self):
        self.write("Hi! This is webhook example!")
        self.finish()

+
 class webhook_serv(tornado.web.RequestHandler):
    def get(self):
        self.write("What are you doing here?")
        self.finish()
+
    def post(self):
        if "Content-Length" in self.request.headers and \
            "Content-Type" in self.request.headers and \
@ -52,21 +57,26 @@ class webhook_serv(tornado.web.RequestHandler):
        else:
            self.write("What are you doing here?")
            self.finish()
- 
+
+
 tornado.options.define("port", default=WEBHOOK_PORT, help="run on the given port", type=int)
 is_closing = False
+
+
 def signal_handler(signum, frame):
    global is_closing
    print("Exiting...")
    is_closing = True

+
 def try_exit():
    global is_closing
    if is_closing:
        # clean up here
        tornado.ioloop.IOLoop.instance().stop()
        print("Exit success!")
-        
+
+
 # Handle '/start' and '/help'
@bot.message_handler(commands=['help', 'start'])
 def send_welcome(message):
@ -74,6 +84,7 @@ def send_welcome(message):
                 ("Hi there, I am EchoBot.\n"
                  "I am here to echo your kind words back to you."))

+
 bot.remove_webhook()
 bot.set_webhook(url=WEBHOOK_URL_BASE,
                certificate=open(WEBHOOK_CERT, 'r'))
@ -86,9 +97,9 @@ application = tornado.web.Application([
 ])

 http_server = tornado.httpserver.HTTPServer(application, ssl_options={
-        "certfile": WEBHOOK_CERT,
-        "keyfile": WEBHOOK_PKEY,
-    })
+    "certfile": WEBHOOK_CERT,
+    "keyfile" : WEBHOOK_PKEY,
+})
 http_server.listen(tornado.options.options.port)
 tornado.ioloop.PeriodicCallback(try_exit, 100).start()
 tornado.ioloop.IOLoop.instance().start()
--- a/requirements.txt
+++ b/requirements.txt
@ -1,5 +1,5 @@
 py==1.4.29
 pytest==3.0.2
-requests==2.7.0
+requests==2.20.0
 six==1.9.0
 wheel==0.24.0
--- a/setup.py
+++ b/setup.py
@ -1,15 +1,21 @@
 #!/usr/bin/env python
 from setuptools import setup
 from io import open
+import re

-def readme():
-    with open('README.rst', encoding='utf-8') as f:
-        return f.read()
+def read(filename):
+    with open(filename, encoding='utf-8') as file:
+        return file.read()
+
+with open('telebot/version.py', 'r', encoding='utf-8') as f:  # Credits: LonamiWebs
+    version = re.search(r"^__version__\s*=\s*'(.*)'.*$",
+                        f.read(), flags=re.MULTILINE).group(1)

 setup(name='pyTelegramBotAPI',
-      version='3.1.1',
+      version=version,
      description='Python Telegram bot api. ',
-      long_description=readme(),
+      long_description=read('README.md'),
+      long_description_content_type="text/markdown",
      author='eternnoir',
      author_email='eternnoir@gmail.com',
      url='https://github.com/eternnoir/pyTelegramBotAPI',
@ -19,12 +25,10 @@ setup(name='pyTelegramBotAPI',
      install_requires=['requests', 'six'],
      extras_require={
          'json': 'ujson',
+          'redis': 'redis>=3.4.1'
      },
      classifiers=[
          'Development Status :: 5 - Production/Stable',
-          'Programming Language :: Python :: 2',
-          'Programming Language :: Python :: 2.6',
-          'Programming Language :: Python :: 2.7',
          'Programming Language :: Python :: 3',
          'Environment :: Console',
          'License :: OSI Approved :: GNU General Public License v2 (GPLv2)',
--- a/telebot/init.py
+++ b/telebot/init.py
--- a/telebot/apihelper.py
+++ b/telebot/apihelper.py
--- a/telebot/handler_backends.py
+++ b/telebot/handler_backends.py
@ -0,0 +1,145 @@
+import os
+import pickle
+import threading
+
+from telebot import apihelper
+
+
+class HandlerBackend(object):
+    """
+    Class for saving (next step|reply) handlers
+    """
+    def __init__(self, handlers=None):
+        if handlers is None:
+            handlers = {}
+        self.handlers = handlers
+
+    def register_handler(self, handler_group_id, handler):
+        raise NotImplementedError()
+
+    def clear_handlers(self, handler_group_id):
+        raise NotImplementedError()
+
+    def get_handlers(self, handler_group_id):
+        raise NotImplementedError()
+
+
+class MemoryHandlerBackend(HandlerBackend):
+    def register_handler(self, handler_group_id, handler):
+        if handler_group_id in self.handlers:
+            self.handlers[handler_group_id].append(handler)
+        else:
+            self.handlers[handler_group_id] = [handler]
+
+    def clear_handlers(self, handler_group_id):
+        self.handlers.pop(handler_group_id, [])
+
+    def get_handlers(self, handler_group_id):
+        return self.handlers.pop(handler_group_id, [])
+
+
+class FileHandlerBackend(HandlerBackend):
+    def __init__(self, handlers=None, filename='./.handler-saves/handlers.save', delay=120):
+        super(FileHandlerBackend, self).__init__(handlers)
+        self.filename = filename
+        self.delay = delay
+        self.timer = threading.Timer(delay, self.save_handlers)
+
+    def register_handler(self, handler_group_id, handler):
+        if handler_group_id in self.handlers:
+            self.handlers[handler_group_id].append(handler)
+        else:
+            self.handlers[handler_group_id] = [handler]
+
+        self.start_save_timer()
+
+    def clear_handlers(self, handler_group_id):
+        self.handlers.pop(handler_group_id, [])
+
+        self.start_save_timer()
+
+    def get_handlers(self, handler_group_id):
+        handlers = self.handlers.pop(handler_group_id, [])
+
+        self.start_save_timer()
+
+        return handlers
+
+    def start_save_timer(self):
+        if not self.timer.is_alive():
+            if self.delay <= 0:
+                self.save_handlers()
+            else:
+                self.timer = threading.Timer(self.delay, self.save_handlers)
+                self.timer.start()
+
+    def save_handlers(self):
+        self.dump_handlers(self.handlers, self.filename)
+
+    def load_handlers(self, filename=None, del_file_after_loading=True):
+        if not filename:
+            filename = self.filename
+        tmp = self.return_load_handlers(filename, del_file_after_loading=del_file_after_loading)
+        if tmp is not None:
+            self.handlers.update(tmp)
+
+    @staticmethod
+    def dump_handlers(handlers, filename, file_mode="wb"):
+        dirs = filename.rsplit('/', maxsplit=1)[0]
+        os.makedirs(dirs, exist_ok=True)
+
+        with open(filename + ".tmp", file_mode) as file:
+            if (apihelper.CUSTOM_SERIALIZER is None):
+                pickle.dump(handlers, file)
+            else:
+                apihelper.CUSTOM_SERIALIZER.dump(handlers, file)
+
+        if os.path.isfile(filename):
+            os.remove(filename)
+
+        os.rename(filename + ".tmp", filename)
+
+    @staticmethod
+    def return_load_handlers(filename, del_file_after_loading=True):
+        if os.path.isfile(filename) and os.path.getsize(filename) > 0:
+            with open(filename, "rb") as file:
+                if (apihelper.CUSTOM_SERIALIZER is None):
+                    handlers = pickle.load(file)
+                else:
+                    handlers = apihelper.CUSTOM_SERIALIZER.load(file)
+
+            if del_file_after_loading:
+                os.remove(filename)
+
+            return handlers
+
+
+class RedisHandlerBackend(HandlerBackend):
+    def __init__(self, handlers=None, host='localhost', port=6379, db=0, prefix='telebot'):
+        super(RedisHandlerBackend, self).__init__(handlers)
+        from redis import Redis
+        self.prefix = prefix
+        self.redis = Redis(host, port, db)
+
+    def _key(self, handle_group_id):
+        return ':'.join((self.prefix, str(handle_group_id)))
+
+    def register_handler(self, handler_group_id, handler):
+        handlers = []
+        value = self.redis.get(self._key(handler_group_id))
+        if value:
+            handlers = pickle.loads(value)
+        handlers.append(handler)
+        self.redis.set(self._key(handler_group_id), pickle.dumps(handlers))
+
+    def clear_handlers(self, handler_group_id):
+        self.redis.delete(self._key(handler_group_id))
+
+    def get_handlers(self, handler_group_id):
+        handlers = []
+        value = self.redis.get(self._key(handler_group_id))
+        if value:
+            handlers = pickle.loads(value)
+            self.clear_handlers(handler_group_id)
+
+        return handlers
--- a/telebot/types.py
+++ b/telebot/types.py
--- a/telebot/util.py
+++ b/telebot/util.py
@ -1,9 +1,13 @@
 # -*- coding: utf-8 -*-
-
+import random
+import re
+import string
+import sys
 import threading
 import traceback
-import re
-import sys
+import warnings
+import functools
+
 import six
 from six import string_types

@ -13,75 +17,82 @@ try:
    import Queue
 except ImportError:
    import queue as Queue
+import logging

-from telebot import logger
+try:
+    import PIL
+    from io import BytesIO
+    pil_imported = True
+except:
+    pil_imported = False

+logger = logging.getLogger('TeleBot')

 thread_local = threading.local()


 class WorkerThread(threading.Thread):
-        count = 0
+    count = 0

-        def __init__(self, exception_callback=None, queue=None, name=None):
-            if not name:
-                name = "WorkerThread{0}".format(self.__class__.count + 1)
-                self.__class__.count += 1
-            if not queue:
-                queue = Queue.Queue()
+    def __init__(self, exception_callback=None, queue=None, name=None):
+        if not name:
+            name = "WorkerThread{0}".format(self.__class__.count + 1)
+            self.__class__.count += 1
+        if not queue:
+            queue = Queue.Queue()

-            threading.Thread.__init__(self, name=name)
-            self.queue = queue
-            self.daemon = True
+        threading.Thread.__init__(self, name=name)
+        self.queue = queue
+        self.daemon = True

-            self.received_task_event = threading.Event()
-            self.done_event = threading.Event()
-            self.exception_event = threading.Event()
-            self.continue_event = threading.Event()
+        self.received_task_event = threading.Event()
+        self.done_event = threading.Event()
+        self.exception_event = threading.Event()
+        self.continue_event = threading.Event()

-            self.exception_callback = exception_callback
-            self.exc_info = None
-            self._running = True
-            self.start()
+        self.exception_callback = exception_callback
+        self.exc_info = None
+        self._running = True
+        self.start()

-        def run(self):
-            while self._running:
-                try:
-                    task, args, kwargs = self.queue.get(block=True, timeout=.5)
-                    self.continue_event.clear()
-                    self.received_task_event.clear()
-                    self.done_event.clear()
-                    self.exception_event.clear()
-                    logger.debug("Received task")
-                    self.received_task_event.set()
+    def run(self):
+        while self._running:
+            try:
+                task, args, kwargs = self.queue.get(block=True, timeout=.5)
+                self.continue_event.clear()
+                self.received_task_event.clear()
+                self.done_event.clear()
+                self.exception_event.clear()
+                logger.debug("Received task")
+                self.received_task_event.set()

-                    task(*args, **kwargs)
-                    logger.debug("Task complete")
-                    self.done_event.set()
-                except Queue.Empty:
-                    pass
-                except Exception as e:
-                    logger.error(type(e).__name__ + " occurred, args=" + str(e.args) + "\n" + traceback.format_exc())
-                    self.exc_info = sys.exc_info()
-                    self.exception_event.set()
+                task(*args, **kwargs)
+                logger.debug("Task complete")
+                self.done_event.set()
+            except Queue.Empty:
+                pass
+            except Exception as e:
+                logger.error(type(e).__name__ + " occurred, args=" + str(e.args) + "\n" + traceback.format_exc())
+                self.exc_info = sys.exc_info()
+                self.exception_event.set()

-                    if self.exception_callback:
-                        self.exception_callback(self, self.exc_info)
-                    self.continue_event.wait()
+                if self.exception_callback:
+                    self.exception_callback(self, self.exc_info)
+                self.continue_event.wait()

-        def put(self, task, *args, **kwargs):
-            self.queue.put((task, args, kwargs))
+    def put(self, task, *args, **kwargs):
+        self.queue.put((task, args, kwargs))

-        def raise_exceptions(self):
-            if self.exception_event.is_set():
-                six.reraise(self.exc_info[0], self.exc_info[1], self.exc_info[2])
+    def raise_exceptions(self):
+        if self.exception_event.is_set():
+            six.reraise(self.exc_info[0], self.exc_info[1], self.exc_info[2])

-        def clear_exceptions(self):
-            self.exception_event.clear()
-            self.continue_event.set()
+    def clear_exceptions(self):
+        self.exception_event.clear()
+        self.continue_event.set()

-        def stop(self):
-            self._running = False
+    def stop(self):
+        self._running = False


 class ThreadPool:
@ -142,7 +153,7 @@ class AsyncTask:
            return self.result


-def async():
+def async_dec():
    def decorator(fn):
        def wrapper(*args, **kwargs):
            return AsyncTask(fn, *args, **kwargs)
@ -155,12 +166,32 @@ def async():
 def is_string(var):
    return isinstance(var, string_types)

+def is_dict(var):
+    return isinstance(var, dict)
+
+def is_bytes(var):
+    return isinstance(var, bytes)
+
+def is_pil_image(var):
+    return pil_imported and isinstance(var, PIL.Image.Image)
+
+def pil_image_to_file(image, extension='JPEG', quality='web_low'):
+    if pil_imported:
+        photoBuffer = BytesIO()
+        image.convert('RGB').save(photoBuffer, extension, quality=quality)
+        photoBuffer.seek(0)
+        
+        return photoBuffer
+    else:
+        raise RuntimeError('PIL module is not imported')
+
 def is_command(text):
    """
    Checks if `text` is a command. Telegram chat commands start with the '/' character.
    :param text: Text to check.
    :return: True if `text` is a command, else False.
    """
+    if (text is None): return None
    return text.startswith('/')


@ -178,6 +209,7 @@ def extract_command(text):
    :param text: String to extract the command from
    :return: the command if `text` is a command (according to is_command), else None.
    """
+    if (text is None): return None
    return text.split()[0].split('@')[0][1:] if is_command(text) else None


@ -242,15 +274,39 @@ def extract_arguments(text):
    :param text: String to extract the arguments from a command
    :return: the arguments if `text` is a command (according to is_command), else None.
    """
-    regexp = re.compile("\/\w*(@\w*)*\s*([\s\S]*)",re.IGNORECASE)
+    regexp = re.compile(r"/\w*(@\w*)*\s*([\s\S]*)",re.IGNORECASE)
    result = regexp.match(text)
    return result.group(2) if is_command(text) else None


-def per_thread(key, construct_value):
-    try:
-        return getattr(thread_local, key)
-    except AttributeError:
+def per_thread(key, construct_value, reset=False):
+    if reset or not hasattr(thread_local, key):
        value = construct_value()
        setattr(thread_local, key, value)
-        return value
+
+    return getattr(thread_local, key)
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    # https://stackoverflow.com/a/312464/9935473
+    for i in range(0, len(lst), n):
+        yield lst[i:i + n]
+
+def generate_random_token():
+    return ''.join(random.sample(string.ascii_letters, 16))
+
+
+def deprecated(func):
+    """This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used."""
+    # https://stackoverflow.com/a/30253848/441814
+    @functools.wraps(func)
+    def new_func(*args, **kwargs):
+        warnings.simplefilter('always', DeprecationWarning)  # turn off filter
+        warnings.warn("Call to deprecated function {}.".format(func.__name__),
+                      category=DeprecationWarning,
+                      stacklevel=2)
+        warnings.simplefilter('default', DeprecationWarning)  # reset filter
+        return func(*args, **kwargs)
+    return new_func
--- a/telebot/version.py
+++ b/telebot/version.py
@ -0,0 +1,3 @@
+# Versions should comply with PEP440.
+# This line is parsed in setup.py:
+__version__ = '3.7.3'
--- a/tests/test_handler_backends.py
+++ b/tests/test_handler_backends.py
@ -0,0 +1,270 @@
+import sys
+
+sys.path.append('../')
+
+REDIS_TESTS = False
+
+import os
+import time
+
+import pytest
+
+import telebot
+from telebot import types
+from telebot.handler_backends import MemoryHandlerBackend, FileHandlerBackend
+
+if REDIS_TESTS:
+    from telebot.handler_backends import RedisHandlerBackend
+
+
+@pytest.fixture()
+def telegram_bot():
+    return telebot.TeleBot('', threaded=False)
+
+
+@pytest.fixture
+def private_chat():
+    return types.Chat(id=11, type='private')
+
+
+@pytest.fixture
+def user():
+    return types.User(id=10, is_bot=False, first_name='Some User')
+
+
+@pytest.fixture()
+def message(user, private_chat):
+    params = {'text': '/start'}
+    return types.Message(
+        message_id=1, from_user=user, date=None, chat=private_chat, content_type='text', options=params, json_string=""
+    )
+
+
+@pytest.fixture()
+def reply_to_message(user, private_chat, message):
+    params = {'text': '/start'}
+    reply_message = types.Message(
+        message_id=2, from_user=user, date=None, chat=private_chat, content_type='text', options=params, json_string=""
+    )
+    reply_message.reply_to_message = message
+    return reply_message
+
+
+@pytest.fixture()
+def update_type(message):
+    edited_message = None
+    channel_post = None
+    edited_channel_post = None
+    inline_query = None
+    chosen_inline_result = None
+    callback_query = None
+    shipping_query = None
+    pre_checkout_query = None
+    poll = None
+    poll_answer = None
+    return types.Update(1001234038283, message, edited_message, channel_post, edited_channel_post, inline_query,
+                        chosen_inline_result, callback_query, shipping_query, pre_checkout_query, poll, poll_answer)
+
+
+@pytest.fixture()
+def reply_to_message_update_type(reply_to_message):
+    edited_message = None
+    channel_post = None
+    edited_channel_post = None
+    inline_query = None
+    chosen_inline_result = None
+    callback_query = None
+    shipping_query = None
+    pre_checkout_query = None
+    poll = None
+    poll_answer = None
+    return types.Update(1001234038284, reply_to_message, edited_message, channel_post, edited_channel_post,
+                        inline_query,
+                        chosen_inline_result, callback_query, shipping_query, pre_checkout_query, poll, poll_answer)
+
+
+def next_handler(message):
+    message.text = 'entered next_handler'
+
+
+def test_memory_handler_backend_default_backend(telegram_bot):
+    assert telegram_bot.reply_backend.__class__ == MemoryHandlerBackend
+    assert telegram_bot.next_step_backend.__class__ == MemoryHandlerBackend
+
+
+def test_memory_handler_backend_register_next_step_handler(telegram_bot, private_chat, update_type):
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    assert len(telegram_bot.next_step_backend.handlers[private_chat.id]) == 1
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered next_handler'
+
+    assert private_chat.id not in telegram_bot.next_step_backend.handlers
+
+
+def test_memory_handler_backend_clear_next_step_handler(telegram_bot, private_chat, update_type):
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    assert len(telegram_bot.next_step_backend.handlers[private_chat.id]) == 1
+
+    telegram_bot.clear_step_handler_by_chat_id(private_chat.id)
+
+    assert private_chat.id not in telegram_bot.next_step_backend.handlers
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+
+def test_memory_handler_backend_register_reply_handler(telegram_bot, private_chat, update_type,
+                                                       reply_to_message_update_type):
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_for_reply_by_message_id(message.message_id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    assert len(telegram_bot.reply_backend.handlers[update_type.message.message_id]) == 1
+
+    telegram_bot.process_new_updates([reply_to_message_update_type])
+    assert reply_to_message_update_type.message.text == 'entered next_handler'
+
+    assert private_chat.id not in telegram_bot.reply_backend.handlers
+
+
+def test_memory_handler_backend_clear_reply_handler(telegram_bot, private_chat, update_type,
+                                                    reply_to_message_update_type):
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_for_reply_by_message_id(message.message_id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    assert len(telegram_bot.reply_backend.handlers[update_type.message.message_id]) == 1
+
+    telegram_bot.clear_reply_handlers_by_message_id(update_type.message.message_id)
+
+    assert update_type.message.message_id not in telegram_bot.reply_backend.handlers
+
+    telegram_bot.process_new_updates([reply_to_message_update_type])
+    assert reply_to_message_update_type.message.text == 'entered start'
+
+
+def test_file_handler_backend_register_next_step_handler(telegram_bot, private_chat, update_type):
+    telegram_bot.next_step_backend=FileHandlerBackend(filename='./.handler-saves/step1.save', delay=0.1)
+
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    time.sleep(0.2)
+
+    assert os.path.exists(telegram_bot.next_step_backend.filename)
+
+    assert len(telegram_bot.next_step_backend.handlers[private_chat.id]) == 1
+
+    telegram_bot.next_step_backend.handlers = {}
+
+    telegram_bot.next_step_backend.load_handlers()
+
+    assert len(telegram_bot.next_step_backend.handlers[private_chat.id]) == 1
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered next_handler'
+
+    assert private_chat.id not in telegram_bot.next_step_backend.handlers
+
+    time.sleep(0.2)
+    if os.path.exists(telegram_bot.next_step_backend.filename):
+        os.remove(telegram_bot.next_step_backend.filename)
+
+
+def test_file_handler_backend_clear_next_step_handler(telegram_bot, private_chat, update_type):
+    telegram_bot.next_step_backend=FileHandlerBackend(filename='./.handler-saves/step2.save', delay=0.1)
+
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    assert len(telegram_bot.next_step_backend.handlers[private_chat.id]) == 1
+
+    time.sleep(0.2)
+
+    assert os.path.exists(telegram_bot.next_step_backend.filename)
+
+    telegram_bot.clear_step_handler_by_chat_id(private_chat.id)
+
+    time.sleep(0.2)
+
+    telegram_bot.next_step_backend.load_handlers()
+
+    assert private_chat.id not in telegram_bot.next_step_backend.handlers
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    time.sleep(0.2)
+    if os.path.exists(telegram_bot.next_step_backend.filename):
+        os.remove(telegram_bot.next_step_backend.filename)
+
+
+def test_redis_handler_backend_register_next_step_handler(telegram_bot, private_chat, update_type):
+    if not REDIS_TESTS:
+        pytest.skip('please install redis and configure redis server, then enable REDIS_TESTS')
+
+    telegram_bot.next_step_backend = RedisHandlerBackend(prefix='pyTelegramBotApi:step_backend1')
+
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered next_handler'
+
+
+def test_redis_handler_backend_clear_next_step_handler(telegram_bot, private_chat, update_type):
+    if not REDIS_TESTS:
+        pytest.skip('please install redis and configure redis server, then enable REDIS_TESTS')
+
+    telegram_bot.next_step_backend = RedisHandlerBackend(prefix='pyTelegramBotApi:step_backend2')
+
+    @telegram_bot.message_handler(commands=['start'])
+    def start(message):
+        message.text = 'entered start'
+        telegram_bot.register_next_step_handler_by_chat_id(message.chat.id, next_handler)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
+
+    telegram_bot.clear_step_handler_by_chat_id(private_chat.id)
+
+    telegram_bot.process_new_updates([update_type])
+    assert update_type.message.text == 'entered start'
--- a/tests/test_telebot.py
+++ b/tests/test_telebot.py
@ -48,7 +48,7 @@ class TestTeleBot:
        bot = telebot.TeleBot('')
        msg = self.create_text_message(r'https://web.telegram.org/')

-        @bot.message_handler(regexp='((https?):((//)|(\\\\))+([\w\d:#@%/;$()~_?\+-=\\\.&](#!)?)*)')
+        @bot.message_handler(regexp=r'((https?):((//)|(\\\\))+([\w\d:#@%/;$()~_?\+-=\\\.&](#!)?)*)')
        def command_url(message):
            msg.text = 'got'

@ -84,7 +84,7 @@ class TestTeleBot:
        bot = telebot.TeleBot('')
        msg = self.create_text_message(r'web.telegram.org/')

-        @bot.message_handler(regexp='((https?):((//)|(\\\\))+([\w\d:#@%/;$()~_?\+-=\\\.&](#!)?)*)')
+        @bot.message_handler(regexp=r'((https?):((//)|(\\\\))+([\w\d:#@%/;$()~_?\+-=\\\.&](#!)?)*)')
        def command_url(message):
            msg.text = 'got'

@ -201,7 +201,8 @@ class TestTeleBot:
    def test_send_audio_dis_noti(self):
        file_data = open('./test_data/record.mp3', 'rb')
        tb = telebot.TeleBot(TOKEN)
-        ret_msg = tb.send_audio(CHAT_ID, file_data, 1, performer='eternnoir', title='pyTelegram', disable_notification=True)
+        ret_msg = tb.send_audio(CHAT_ID, file_data, 1, performer='eternnoir', title='pyTelegram',
+                                disable_notification=True)
        assert ret_msg.content_type == 'audio'
        assert ret_msg.audio.performer == 'eternnoir'
        assert ret_msg.audio.title == 'pyTelegram'
@ -240,6 +241,12 @@ class TestTeleBot:
        ret_msg = tb.send_message(CHAT_ID, text)
        assert ret_msg.message_id

+    def test_send_dice(self):
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_dice(CHAT_ID, emoji='🎯')
+        assert ret_msg.message_id
+        assert ret_msg.content_type == 'dice'
+
    def test_send_message_dis_noti(self):
        text = 'CI Test Message'
        tb = telebot.TeleBot(TOKEN)
@ -360,6 +367,20 @@ class TestTeleBot:
        new_msg = tb.edit_message_caption(caption='Edit test', chat_id=CHAT_ID, message_id=msg.message_id)
        assert new_msg.caption == 'Edit test'

+    def test_edit_message_media(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        file_data_2 = open('../examples/detailed_example/rooster.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        msg = tb.send_photo(CHAT_ID, file_data)
+        new_msg = tb.edit_message_media(chat_id=CHAT_ID, message_id=msg.message_id,
+                                        media=types.InputMediaPhoto(file_data_2, caption='Test editMessageMedia 0'))
+        assert type(new_msg) != bool
+
+        new_msg = tb.edit_message_media(chat_id=CHAT_ID, message_id=msg.message_id,
+                                        media=types.InputMediaPhoto(msg.photo[0].file_id, caption='Test editMessageMedia'))
+        assert type(new_msg) != bool
+        assert new_msg.caption == 'Test editMessageMedia'
+
    def test_get_chat(self):
        tb = telebot.TeleBot(TOKEN)
        ch = tb.get_chat(GROUP_ID)
@ -387,10 +408,29 @@ class TestTeleBot:
        new_msg = tb.edit_message_reply_markup(chat_id=CHAT_ID, message_id=ret_msg.message_id, reply_markup=markup)
        assert new_msg.message_id

-    def create_text_message(self, text):
+    @staticmethod
+    def create_text_message(text):
        params = {'text': text}
-        chat = types.User(11, 'test')
-        return types.Message(1, None, None, chat, 'text', params)
+        chat = types.User(11, False, 'test')
+        return types.Message(1, None, None, chat, 'text', params, "")
+
+    @staticmethod
+    def create_message_update(text):
+        params = {'text': text}
+        chat = types.User(11, False, 'test')
+        message = types.Message(1, None, None, chat, 'text', params, "")
+        edited_message = None
+        channel_post = None
+        edited_channel_post = None
+        inline_query = None
+        chosen_inline_result = None
+        callback_query = None
+        shipping_query = None
+        pre_checkout_query = None
+        poll = None
+        poll_answer = None
+        return types.Update(-1001234038283, message, edited_message, channel_post, edited_channel_post, inline_query,
+                            chosen_inline_result, callback_query, shipping_query, pre_checkout_query, poll, poll_answer)

    def test_is_string_unicode(self):
        s1 = u'string'
@ -409,3 +449,113 @@ class TestTeleBot:
        tb = telebot.TeleBot(TOKEN)
        ret_msg = tb.send_video_note(CHAT_ID, file_data)
        assert ret_msg.message_id
+
+    def test_send_media_group(self):
+        tb = telebot.TeleBot(TOKEN)
+        img1 = 'https://i.imgur.com/CjXjcnU.png'
+        img2 = 'https://i.imgur.com/CjXjcnU.png'
+        medias = [types.InputMediaPhoto(img1, "View"), types.InputMediaPhoto(img2, "Dog")]
+        result = tb.send_media_group(CHAT_ID, medias)
+        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'
+
+    def test_typed_middleware_handler(self):
+        from telebot import apihelper
+
+        apihelper.ENABLE_MIDDLEWARE = True
+
+        tb = telebot.TeleBot('')
+        update = self.create_message_update('/help')
+
+        @tb.middleware_handler(update_types=['message'])
+        def middleware(tb_instance, message):
+            message.text = 'got'
+
+        @tb.message_handler(func=lambda m: m.text == 'got')
+        def command_handler(message):
+            message.text = message.text + message.text
+
+        tb.process_new_updates([update])
+        time.sleep(1)
+        assert update.message.text == 'got' * 2
+
+    def test_default_middleware_handler(self):
+        from telebot import apihelper
+
+        apihelper.ENABLE_MIDDLEWARE = True
+
+        tb = telebot.TeleBot('')
+        update = self.create_message_update('/help')
+
+        @tb.middleware_handler()
+        def middleware(tb_instance, update):
+            update.message.text = 'got'
+
+        @tb.message_handler(func=lambda m: m.text == 'got')
+        def command_handler(message):
+            message.text = message.text + message.text
+
+        tb.process_new_updates([update])
+        time.sleep(1)
+        assert update.message.text == 'got' * 2
+
+    def test_chat_permissions(self):
+        return # CHAT_ID is private chat, no permissions can be set
+        tb = telebot.TeleBot(TOKEN)
+        permissions = types.ChatPermissions(can_send_messages=True, can_send_polls=False)
+        msg = tb.set_chat_permissions(CHAT_ID, permissions)
--- a/tests/test_types.py
+++ b/tests/test_types.py
@ -6,19 +6,28 @@ from telebot import types


 def test_json_user():
-    jsonstring = r'{"id":101176298,"first_name":"RDSSBOT","username":"rdss_bot"}'
+    jsonstring = r'{"id":101176298,"first_name":"RDSSBOT","username":"rdss_bot","is_bot":true}'
    u = types.User.de_json(jsonstring)
    assert u.id == 101176298


 def test_json_message():
-    jsonstring = r'{"message_id":1,"from":{"id":108929734,"first_name":"Frank","last_name":"Wang","username":"eternnoir"},"chat":{"id":1734,"first_name":"F","type":"private","last_name":"Wa","username":"oir"},"date":1435296025,"text":"HIHI"}'
+    jsonstring = r'{"message_id":1,"from":{"id":108929734,"first_name":"Frank","last_name":"Wang","username":"eternnoir","is_bot":true},"chat":{"id":1734,"first_name":"F","type":"private","last_name":"Wa","username":"oir"},"date":1435296025,"text":"HIHI"}'
    msg = types.Message.de_json(jsonstring)
    assert msg.text == 'HIHI'


+def test_json_message_with_dice():
+    jsonstring = r'{"message_id":5560,"from":{"id":879343317,"is_bot":false,"first_name":"George","last_name":"Forse","username":"dr_fxrse","language_code":"ru"},"chat":{"id":879343317,"first_name":"George","last_name":"Forse","username":"dr_fxrse","type":"private"},"date":1586926330,"dice":{"value": 4, "emoji": "\ud83c\udfaf"}}'
+    msg = types.Message.de_json(jsonstring)
+    assert msg.content_type == 'dice'
+    assert isinstance(msg.dice, types.Dice)
+    assert msg.dice.value == 4
+    assert msg.dice.emoji == '🎯'
+
+
 def test_json_message_group():
-    json_string = r'{"message_id":10,"from":{"id":12345,"first_name":"g","last_name":"G","username":"GG"},"chat":{"id":-866,"type":"private","title":"\u4ea4"},"date":1435303157,"text":"HIHI"}'
+    json_string = r'{"message_id":10,"from":{"id":12345,"first_name":"g","last_name":"G","username":"GG","is_bot":true},"chat":{"id":-866,"type":"private","title":"\u4ea4"},"date":1435303157,"text":"HIHI"}'
    msg = types.Message.de_json(json_string)
    assert msg.text == 'HIHI'
    assert len(msg.chat.title) != 0
@ -39,7 +48,7 @@ def test_json_Document():


 def test_json_Message_Audio():
-    json_string = r'{"message_id":131,"from":{"id":12775,"first_name":"dd","username":"dd"},"chat":{"id":10834,"first_name":"dd","type":"private","type":"private","last_name":"dd","username":"dd"},"date":1439978364,"audio":{"duration":1,"mime_type":"audio\/mpeg","title":"pyTelegram","performer":"eternnoir","file_id":"BQADBQADDH1JaB8-1KyWUss2-Ag","file_size":20096}}'
+    json_string = r'{"message_id":131,"from":{"id":12775,"first_name":"dd","username":"dd","is_bot":true },"chat":{"id":10834,"first_name":"dd","type":"private","type":"private","last_name":"dd","username":"dd"},"date":1439978364,"audio":{"duration":1,"mime_type":"audio\/mpeg","title":"pyTelegram","performer":"eternnoir","file_id":"BQADBQADDH1JaB8-1KyWUss2-Ag","file_size":20096}}'
    msg = types.Message.de_json(json_string)
    assert msg.audio.duration == 1
    assert msg.content_type == 'audio'
@ -48,7 +57,7 @@ def test_json_Message_Audio():


 def test_json_Message_Sticker():
-    json_string = r'{"message_id":98,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd"},"chat":{"id":10734,"first_name":"Fd","type":"private","last_name":"Wd","username":"dd"},"date":1435479551,"sticker":{"width":550,"height":368,"thumb":{"file_id":"AAQFABPJLB0sAAQq17w-li3bzoIfAAIC","file_size":1822,"width":90,"height":60},"file_id":"BQADBQADNAIAAsYifgYdGJOa6bGAsQI","file_size":30320}}'
+    json_string = r'{"message_id": 21552, "from": {"id": 590740002, "is_bot": false, "first_name": "⚜️ Ƥυrуα ⚜️", "username": "Purya", "language_code": "en"}, "chat": {"id": -1001309982000, "title": "123", "type": "supergroup"}, "date": 1594068909, "sticker": {"width": 368, "height": 368, "emoji": "🤖", "set_name": "ipuryapack", "is_animated": false, "thumb": {"file_id": "AAMCBAADHQJOFL7mAAJUMF8Dj62hpmDhpRAYvkc8CtIqipolAAJ8AAPA-8cF9yxjgjkLS97A0D4iXQARtQAHbQADHy4AAhoE", "file_unique_id": "AQADwNA-Il0AAx8uAAI", "file_size": 7776, "width": 60, "height": 60}, "file_id": "CAACAgQAAx0CThS-5gACVDBfA4-toaZg4aUQGL5HWerSKoqaJQACArADwPvHBfcsY4I5C3feGgQ", "file_unique_id": "AgADfAADsPvHWQ", "file_size": 14602}}'
    msg = types.Message.de_json(json_string)
    assert msg.sticker.height == 368
    assert msg.sticker.thumb.height == 60
@ -56,29 +65,29 @@ def test_json_Message_Sticker():


 def test_json_Message_Sticker_without_thumb():
-    json_string = r'{"message_id":98,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd"},"chat":{"id":10734,"first_name":"Fd","type":"private","last_name":"Wd","username":"dd"},"date":1435479551,"sticker":{"width":550,"height":368,"file_id":"BQADBQADNAIAAsYifgYdGJOa6bGAsQI","file_size":30320}}'
+    json_string = r'{"message_id": 21552, "from": {"id": 590740002, "is_bot": false, "first_name": "⚜️ Ƥυrуα ⚜️", "username": "Purya", "language_code": "en"}, "chat": {"id": -1001309982000, "title": "123", "type": "supergroup"}, "date": 1594068909, "sticker": {"width": 368, "height": 368, "emoji": "🤖", "set_name": "ipuryapack", "is_animated": false, "file_id": "CAACAgQAAx0CThS-5gACVDBfA4-toaZg4aUQGL5HWerSKoqaJQACArADwPvHBfcsY4I5C3feGgQ", "file_unique_id": "AgADfAADsPvHWQ", "file_size": 14602}}'
    msg = types.Message.de_json(json_string)
    assert msg.sticker.height == 368
-    assert msg.sticker.thumb == None
+    assert msg.sticker.thumb is None
    assert msg.content_type == 'sticker'


 def test_json_Message_Document():
-    json_string = r'{"message_id":97,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd"},"chat":{"id":10,"first_name":"Fd","type":"private","last_name":"Wd","username":"dd"},"date":1435478744,"document":{"file_name":"Text File","thumb":{},"file_id":"BQADBQADMwIAAsYifgZ_CEh0u682xwI","file_size":446}}'
+    json_string = r'{"message_id":97,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd","is_bot":true },"chat":{"id":10,"first_name":"Fd","type":"private","last_name":"Wd","username":"dd"},"date":1435478744,"document":{"file_name":"Text File","thumb":{},"file_id":"BQADBQADMwIAAsYifgZ_CEh0u682xwI","file_size":446}}'
    msg = types.Message.de_json(json_string)
    assert msg.document.file_name == 'Text File'
    assert msg.content_type == 'document'


 def test_json_Message_Photo():
-    json_string = r'{"message_id":96,"from":{"id":109734,"first_name":"Fd","last_name":"Wd","username":"dd"},"chat":{"id":10734,"first_name":"Fd","type":"private","last_name":"dd","username":"dd"},"date":1435478191,"photo":[{"file_id":"AgADBQADIagxG8YifgYv8yLSj76i-dd","file_size":615,"width":90,"height":67},{"file_id":"AgADBQADIagxG8YifgYv8yLSj76i-dd","file_size":10174,"width":320,"height":240},{"file_id":"dd-A_LsTIABFNx-FUOaEa_3AABAQABAg","file_size":53013,"width":759,"height":570}]}'
+    json_string = r'{"message_id":96,"from":{"id":109734,"first_name":"Fd","last_name":"Wd","username":"dd","is_bot":true },"chat":{"id":10734,"first_name":"Fd","type":"private","last_name":"dd","username":"dd"},"date":1435478191,"photo":[{"file_id":"AgADBQADIagxG8YifgYv8yLSj76i-dd","file_size":615,"width":90,"height":67},{"file_id":"AgADBQADIagxG8YifgYv8yLSj76i-dd","file_size":10174,"width":320,"height":240},{"file_id":"dd-A_LsTIABFNx-FUOaEa_3AABAQABAg","file_size":53013,"width":759,"height":570}]}'
    msg = types.Message.de_json(json_string)
    assert len(msg.photo) == 3
    assert msg.content_type == 'photo'


 def test_json_Message_Video():
-    json_string = r'{"message_id":101,"from":{"id":109734,"first_name":"dd","last_name":"dd","username":"dd"},"chat":{"id":109734,"first_name":"dd","type":"private","last_name":"dd","username":"dd"},"date":1435481960,"video":{"duration":3,"caption":"","width":360,"height":640,"thumb":{"file_id":"AAQFABPiYnBjkDwMAAIC","file_size":1597,"width":50,"height":90},"file_id":"BAADBQADNifgb_TOPEKErGoQI","file_size":260699}}'
+    json_string = r'{"message_id":101,"from":{"id":109734,"first_name":"dd","last_name":"dd","username":"dd","is_bot":true },"chat":{"id":109734,"first_name":"dd","type":"private","last_name":"dd","username":"dd"},"date":1435481960,"video":{"duration":3,"caption":"","width":360,"height":640,"thumb":{"file_id":"AAQFABPiYnBjkDwMAAIC","file_size":1597,"width":50,"height":90},"file_id":"BAADBQADNifgb_TOPEKErGoQI","file_size":260699}}'
    msg = types.Message.de_json(json_string)
    assert msg.video
    assert msg.video.duration == 3
@ -87,7 +96,7 @@ def test_json_Message_Video():


 def test_json_Message_Location():
-    json_string = r'{"message_id":102,"from":{"id":108734,"first_name":"dd","last_name":"dd","username":"dd"},"chat":{"id":1089734,"first_name":"dd","type":"private","last_name":"dd","username":"dd"},"date":1535482469,"location":{"longitude":127.479471,"latitude":26.090577}}'
+    json_string = r'{"message_id":102,"from":{"id":108734,"first_name":"dd","last_name":"dd","username":"dd","is_bot":true },"chat":{"id":1089734,"first_name":"dd","type":"private","last_name":"dd","username":"dd"},"date":1535482469,"location":{"longitude":127.479471,"latitude":26.090577}}'
    msg = types.Message.de_json(json_string)
    assert msg.location.latitude == 26.090577
    assert msg.content_type == 'location'
@ -113,13 +122,15 @@ def test_json_voice():
    assert voice.duration == 0
    assert voice.file_size == 10481

+
 def test_json_update():
-    json_string = r'{"update_id":938203,"message":{"message_id":241,"from":{"id":9734,"first_name":"Fk","last_name":"Wg","username":"nir"},"chat":{"id":1111,"first_name":"Fk","type":"private","last_name":"Wg","username":"oir"},"date":1441447009,"text":"HIHI"}}'
+    json_string = r'{"update_id":938203,"message":{"message_id":241,"from":{"is_bot":true,"id":9734,"first_name":"Fk","last_name":"Wg","username":"nir"},"chat":{"id":1111,"first_name":"Fk","type":"private","last_name":"Wg","username":"oir"},"date":1441447009,"text":"HIHI"}}'
    update = types.Update.de_json(json_string)
    assert update.update_id == 938203
    assert update.message.message_id == 241
    assert update.message.from_user.id == 9734

+
 def test_json_chat():
    json_string = r'{"id": -111111,"title": "Test Title","type": "group"}'
    chat = types.Chat.de_json(json_string)
@ -127,6 +138,7 @@ def test_json_chat():
    assert chat.type == 'group'
    assert chat.title == 'Test Title'

+
 def test_InlineQueryResultCachedPhoto():
    iq = types.InlineQueryResultCachedPhoto('aaa', 'Fileid')
    json_str = iq.to_json()
@ -143,6 +155,7 @@ def test_InlineQueryResultCachedPhoto_with_title():
    assert 'Title' in json_str
    assert 'caption' not in json_str

+
 def test_InlineQueryResultCachedPhoto_with_markup():
    markup = types.InlineKeyboardMarkup()
    markup.add(types.InlineKeyboardButton("Google", url="http://www.google.com"))
@ -155,3 +168,31 @@ def test_InlineQueryResultCachedPhoto_with_markup():
    assert 'caption' not in json_str
    assert 'reply_markup' in json_str

+
+def test_json_poll_1():
+    jsonstring = r'{"message_id": 395020,"from": {"id": 111,"is_bot": false,"first_name": "FN","last_name": "LN","username": "Badiboy","language_code": "ru"},"chat": {"id": 111,"first_name": "FN","last_name": "LN","username": "Badiboy","type": "private"},"date": 1587841239,"poll": {"id": "5272018969396510722","question": "Test poll 1","options": [{"text": "Answer 1","voter_count": 0},{"text": "Answer 2","voter_count": 0}],"total_voter_count": 0,"is_closed": false,"is_anonymous": true,"type": "regular","allows_multiple_answers": true}}'
+    msg = types.Message.de_json(jsonstring)
+    assert msg.poll is not None
+    assert isinstance(msg.poll, types.Poll)
+    assert msg.poll.id == '5272018969396510722'
+    assert msg.poll.question is not None
+    assert msg.poll.options is not None
+    assert len(msg.poll.options) == 2
+    assert msg.poll.allows_multiple_answers is True
+
+
+def test_json_poll_answer():
+    jsonstring = r'{"poll_id": "5895675970559410186", "user": {"id": 329343347, "is_bot": false, "first_name": "Test", "username": "test_user", "last_name": "User", "language_code": "en"}, "option_ids": [1]}'
+    __import__('pprint').pprint(__import__('json').loads(jsonstring))
+    poll_answer = types.PollAnswer.de_json(jsonstring)
+    assert poll_answer.poll_id == '5895675970559410186'
+    assert isinstance(poll_answer.user, types.User)
+    assert poll_answer.options_ids == [1]
+
+
+def test_KeyboardButtonPollType():
+    markup = types.ReplyKeyboardMarkup()
+    markup.add(types.KeyboardButton('send me a poll', request_poll=types.KeyboardButtonPollType(type='quiz')))
+    json_str = markup.to_json()
+    assert 'request_poll' in json_str
+    assert 'quiz' in json_str