Bump version.

Update version.

.github/ISSUE_TEMPLATE

@@ -0,0 +1,7 @@
+Please answer these questions before submitting your issue. Thanks!
+
+1. What version of pyTelegramBotAPI are you using?
+
+2. What OS are you using?
+
+3. What version of python are you using?

.travis.yml

@@ -2,7 +2,9 @@ language: python
 python:
     - "2.6"
     - "2.7"
+    - "3.3"
     - "3.4"
+    - "3.5"
     - "pypy"
     - "pypy3"
 install: "pip install -r requirements.txt"

README.md

@@ -1,9 +1,9 @@
 # <p align="center">pyTelegramBotAPI
 
-<p align="center">A simple, but extensible Python implementation for the [Telegram Bot API](https://core.telegram.org/bots/api).
+<p align="center">A simple, but extensible Python implementation for the <a href="https://core.telegram.org/bots/api">Telegram Bot API</a>.
 
-
-<p align="center">[![Build Status](https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master)](https://travis-ci.org/eternnoir/pyTelegramBotAPI)
+[![Download Month](https://img.shields.io/pypi/v/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)
   * [Writing your first bot](#writing-your-first-bot)
@@ -14,8 +14,10 @@
     * [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)
@@ -23,10 +25,13 @@
     * [The listener mechanism](#the-listener-mechanism)
     * [Using web hooks](#using-web-hooks)
     * [Logging](#logging)
+    * [Proxy](#proxy)
   * [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.
 
@@ -118,8 +123,12 @@ 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', 'location', 'contact', 'new_chat_participant', 'left_chat_participant', 'new_chat_title', 'new_chat_photo', 'delete_chat_photo', 'group_chat_created'.
+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_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:
+
+```content_types=["text", "sticker", "pinned_message", "photo", "audio"]```
 
 ### Methods
 
@@ -150,6 +159,7 @@ TeleBot supports the following filters:
 |func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`
 
 Here are some examples of using the filters and message handlers:
+
 ```python
 import telebot
 bot = telebot.TeleBot("TOKEN")
@@ -176,13 +186,43 @@ def handle_text_doc(message):
 
 #Which could also be defined as:
 def test_message(message):
-	return message.document.mime_type == 'text/plan'
+	return message.document.mime_type == 'text/plain'
 
 @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**
+
+#### Edited Message handlers
+
+Same as Message handlers
+
+#### channel_post_handler
+
+Same as Message handlers
+
+#### edited_channel_post_handler
+
+Same as Message handlers
+
+#### 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.
+
+```python
+@bot.callback_query_handler(func=lambda call: True)
+def  test_callback(call):
+    logger.info(call)
+```
+
 #### TeleBot
 ```python
 import telebot
@@ -194,12 +234,17 @@ tb = telebot.TeleBot(TOKEN)	#create a new Telegram Bot object
 # - 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
-# - block: True/False (default True) - Blocks upon calling this function
-tb.polling(none_stop=False, interval=0, block=True)
+# - 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):
@@ -244,6 +289,11 @@ video = open('/tmp/video.mp4', 'rb')
 tb.send_video(chat_id, video)
 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")
+
 # sendLocation
 tb.send_location(chat_id, lat, lon)
 
@@ -251,9 +301,19 @@ tb.send_location(chat_id, lat, lon)
 # 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`, `ReplyKeyboardHide` or `ForceReply`, which are defined in types.py.
+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.
 
 ```python
 from telebot import types
@@ -267,23 +327,31 @@ from telebot import types
 # 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)
-markup.add('a', 'v', 'd')
+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:
+# or add KeyboardButton one row at a time:
 markup = types.ReplyKeyboardMarkup()
-markup.row('a', 'v')
-markup.row('c', 'd', 'e')
+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:
 
-![ReplyKeyboardMarkup](https://pp.vk.me/c624430/v624430512/473e5/_mxxW7FPe4U.jpg "ReplyKeyboardMarkup")
+![ReplyKeyboardMarkup](https://farm3.staticflickr.com/2933/32418726704_9ef76093cf_o_d.jpg "ReplyKeyboardMarkup")
 
 ```python
-# ReplyKeyboardHide: hides a previously sent ReplyKeyboardMarkup
+# ReplyKeyboardRemove: hides a previously sent ReplyKeyboardMarkup
 # Takes an optional selective argument (True/False, default False)
-markup = types.ReplyKeyboardHide(selective=False)
+markup = types.ReplyKeyboardRemove(selective=False)
 tb.send_message(chat_id, message, reply_markup=markup)
 ```
 
@@ -295,7 +363,65 @@ tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
 ```
 ForceReply:
 
-![ForceReply](https://pp.vk.me/c624430/v624430512/473ec/602byyWUHcs.jpg "ForceReply")
+![ForceReply](https://farm4.staticflickr.com/3809/32418726814_d1baec0fc2_o_d.jpg "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.
+
+```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)
+
+```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
+
+```python
+@bot.inline_handler(lambda query: query.query == 'text')
+def query_text(inline_query):
+    try:
+        r = types.InlineQueryResultArticle('1', 'Result', types.InputTextMessageContent('Result message.'))
+        r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('Result message2.'))
+        bot.answer_inline_query(inline_query.id, [r, r2])
+    except Exception as e:
+        print(e)
+
+```
+### Working with entities:
+This object represents one special entity in a text message. For example, hashtags, usernames, URLs, etc.
+Attributes:
+* `type`
+* `url`
+* `offset`
+* `length`
+* `user`
+
+
+**Here's an Example:**`message.entities[num].<attribute>`<br>
+Here `num` is the entity number or order of entity in a reply, for if incase there are multiple entities in the reply/message.<br>
+`message.entities` returns a list of entities object. <br>
+`message.entities[0].type` would give the type of the first entity<br>
+Refer [Bot Api](https://core.telegram.org/bots/api#messageentity) for extra details
 
 ## Advanced use of the API
 
@@ -335,15 +461,14 @@ for text in splitted_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
+ - threaded: 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:
 ```python
 def handle_messages(messages):
-	for message in messsages:
+	for message in messages:
 		# Do something with the message
 		bot.reply_to(message, 'Hi')
 
@@ -352,7 +477,9 @@ bot.polling()
 ```
 
 ### Using web hooks
-If you prefer using web hooks to the getUpdates method, you can use the `process_new_messages(messages)` function in TeleBot to make it process the messages that you supply. It takes a list of Message objects. This function is still incubating.
+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
 
@@ -366,34 +493,96 @@ logger = telebot.logger
 telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
 ```
 
+### Proxy
+
+You can use proxy for request. `apihelper.proxy` object will use by call `requests` proxies argument.
+
+```python
+from telebot import apihelper
+
+apihelper.proxy = {'http', 'http://10.10.1.10:3128'}
+```
+
+If you want to use socket5 proxy you need install dependency `pip install requests[socks]`.
+
+```python
+proxies = {
+    'http': 'socks5://user:pass@host:port',
+    'https': 'socks5://user:pass@host:port'
+}
+```
+
+
 ## 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?
-There are two ways to do this:
+Telegram Bot API support new type Chat for message.chat.
 
- - Checking the instance of message.chat with `isinstance`:
+- Check the ```type``` attribute in ```Chat``` object:
+-
 ```python
-def is_user(chat):
-	return isinstance(chat, types.User)
+if message.chat.type == “private”:
+	# private chat message
 
-print is_user(message.chat) # True or False
-```
- - Checking whether the chat id is negative or positive. If the chat id is negative, the chat is a GroupChat, if it is positive, it is a User. Example:
-```python
-def is_user(chat):
-	return chat.id > 0
+if message.chat.type == “group”:
+	# group chat message
+
+if message.chat.type == “supergroup”:
+	# supergroup chat message
+
+if message.chat.type == “channel”:
+	# channel message
 
-print is_user(message.chat) # True or False
 ```
 
 ## The Telegram Chat Group
 
 Get help. Discuss. Chat.
 
-Join the [pyTelegramBotAPI Telegram Chat Group](https://telegram.me/joinchat/067e22c60035523fda8f6025ee87e30b).
+* Join the [pyTelegramBotAPI Telegram Chat Group](https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A)
+* 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*
+* [Send to Kindle Bot](https://telegram.me/Send2KindleBot) by *GabrielRF* - Send to Kindle files or links to files.
+* [Telegram LMGTFY_bot](https://github.com/GabrielRF/telegram-lmgtfy_bot) ([source](https://github.com/GabrielRF/telegram-lmgtfy_bot)) by *GabrielRF* - Let me Google that for you.
+* [Telegram UrlProBot](https://github.com/GabrielRF/telegram-urlprobot) ([source](https://github.com/GabrielRF/telegram-urlprobot)) by *GabrielRF* - URL shortener and URL expander.
+* [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*
+* [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.
+* [TheZigZagProject](https://github.com/WebShark025/TheZigZagProject) - The 'All In One' bot for Telegram! by WebShark025
+* [proxybot](https://github.com/p-hash/proxybot) - Simple Proxy Bot for Telegram. by p-hash
+* [DonantesMalagaBot](https://github.com/vfranch/DonantesMalagaBot)- DonantesMalagaBot facilitates information to Malaga blood donors about the places where they can donate today or in the incoming days. It also records the date of the last donation so that it helps the donors to know when they can donate again. - by vfranch
+* [DuttyBot](https://github.com/DmytryiStriletskyi/DuttyBot) by *Dmytryi Striletskyi* - Timetable for one university in Kiev.
+* [dailypepebot](https://telegram.me/dailypepebot) by [*Jaime*](https://github.com/jiwidi/Dailypepe) - Get's you random pepe images and gives you their id, then you can call this image with the number.
+* [DailyQwertee](https://t.me/DailyQwertee) by [*Jaime*](https://github.com/jiwidi/DailyQwertee) - Bot that manages a channel that sends qwertee daily tshirts every day at 00:00
+* [wat-bridge](https://github.com/rmed/wat-bridge) by [*rmed*](https://github.com/rmed) - Send and receive messages to/from WhatsApp through Telegram
+* [flibusta_bot](https://github.com/Kurbezz/flibusta_bot) by [*Kurbezz*](https://github.com/Kurbezz)
+* [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.
+
+Want to have your bot listed here? Send a Telegram message to @eternnoir or @pevdh.

README.rst

@@ -13,11 +13,7 @@ pyTelegramBotAPI
 A simple, but extensible Python implementation for the `Telegram Bot
 API <https://core.telegram.org/bots/api>`__.
 
-.. raw:: html
-
-   <p align="center">
-
-|Build Status|
+|Download Month| |Build Status| |Download Month|
 
 -  `Getting started. <#getting-started>`__
 -  `Writing your first bot <#writing-your-first-bot>`__
@@ -31,8 +27,10 @@ API <https://core.telegram.org/bots/api>`__.
    -  `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>`__
 
@@ -47,14 +45,16 @@ API <https://core.telegram.org/bots/api>`__.
 
 -  `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:
@@ -80,10 +80,10 @@ 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
@@ -92,7 +92,7 @@ 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``
@@ -174,10 +174,10 @@ To start the bot, simply open up a terminal and enter
 ('/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
@@ -189,15 +189,15 @@ 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',
-'location', 'contact', 'new\_chat\_participant',
+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
@@ -206,16 +206,151 @@ 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 which is decorated with the
-``message_handler`` decorator of a TeleBot instance. The following
-examples illustrate the possibilities of 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
 
@@ -250,8 +385,30 @@ examples illustrate the possibilities of message handlers:
     def handle_text_doc(message)
         pass
 
-*Note: all handlers are tested in the order in which they were declared*
-#### TeleBot
+    # 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
 
@@ -264,12 +421,17 @@ examples illustrate the possibilities of message handlers:
     # - 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
-    # - block: True/False (default True) - Blocks upon calling this function
-    tb.polling(none_stop=False, interval=0, block=True)
+    # - 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):
@@ -322,12 +484,20 @@ examples illustrate the possibilities of message handlers:
     # '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``,
-``ReplyKeyboardHide`` or ``ForceReply``, which are defined in types.py.
+``ReplyKeyboardRemove`` or ``ForceReply``, which are defined in types.py.
 
 .. code:: python
 
@@ -342,13 +512,21 @@ argument. This argument must be an instance of ``ReplyKeyboardMarkup``,
     # 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)
-    markup.add('a', 'v', 'd')
+    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()
-    markup.row('a', 'v')
-    markup.row('c', 'd', 'e')
+    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:
@@ -360,9 +538,9 @@ The last example yields this result:
 
 .. code:: python
 
-    # ReplyKeyboardHide: hides a previously sent ReplyKeyboardMarkup
+    # ReplyKeyboardRemove: hides a previously sent ReplyKeyboardMarkup
     # Takes an optional selective argument (True/False, default False)
-    markup = types.ReplyKeyboardHide(selective=False)
+    markup = types.ReplyKeyboardRemove(selective=False)
     tb.send_message(chat_id, message, reply_markup=markup)
 
 .. code:: python
@@ -379,11 +557,58 @@ 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
@@ -418,7 +643,7 @@ 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
@@ -437,7 +662,7 @@ API:
         tb.send_message(chat_id, text)
 
 Controlling the amount of Threads used by TeleBot
--------------------------------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The TeleBot constructor takes the following optional arguments:
 
@@ -450,7 +675,7 @@ The TeleBot constructor takes the following optional arguments:
    False.
 
 The listener mechanism
-----------------------
+~~~~~~~~~~~~~~~~~~~~~~
 
 As an alternative to the message handlers, one can also register a
 function as a listener to TeleBot. Example:
@@ -465,57 +690,75 @@ function as a listener to TeleBot. Example:
     bot.set_update_listener(handle_messages)
     bot.polling()
 
-Using web hooks
----------------
+Using webhooks
+~~~~~~~~~~~~~~
 
-If you prefer using web hooks to the getUpdates method, you can use the
-``process_new_messages(messages)`` function in TeleBot to make it
-process the messages that you supply. It takes a list of Message
-objects. This function is still incubating.
+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.
+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
-    formatter = logging.Formatter('[%(asctime)s] %(thread)d {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
-                                      '%m-%d %H:%M:%S')
-    ch = logging.StreamHandler(sys.stdout)
-    logger.addHandler(ch)
-    logger.setLevel(logging.DEBUG)  # or use logging.INFO
-    ch.setFormatter(formatter)
+    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?
--------------------------------------------------------------
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-There are two ways to do this:
+Telegram Bot API support new type Chat for message.chat.
 
--  Checking the instance of message.chat with ``isinstance``:
-   \`\`\`python def is\_user(chat): return isinstance(chat, types.User)
+-  Check the ``type`` attribute in ``Chat`` object:
+-  \`\`\`python if message.chat.type == “private”: # private chat
+   message
 
-print is\_user(message.chat) # True or False
-``- Checking whether the chat id is negative or positive. If the chat id is negative, the chat is a GroupChat, if it is positive, it is a User. Example:``\ python
-def is\_user(chat): return chat.id > 0
+if message.chat.type == “group”: # group chat message
 
-print is\_user(message.chat) # True or False \`\`\`
+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 <https://telegram.me/joinchat/067e22c60035523fda8f6025ee87e30b>`__.
+-  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>`__
@@ -524,5 +767,41 @@ More examples
 -  `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

examples/detailed_example/detailed_example.py

@@ -21,7 +21,7 @@ commands = {  # command description used in the "help" command
 imageSelect = types.ReplyKeyboardMarkup(one_time_keyboard=True)  # create the image selection keyboard
 imageSelect.add('cock', 'pussy')
 
-hideBoard = types.ReplyKeyboardHide()  # if sent as reply_markup, will hide the keyboard
+hideBoard = types.ReplyKeyboardRemove()  # if sent as reply_markup, will hide the keyboard
 
 
 # error handling if user isn't known yet

examples/download_file_example.py

@@ -0,0 +1,15 @@
+import telebot
+
+TOKEN = 'YOUR BOT TOKEN'
+CHAT_ID = 'YOUR CHAT ID'
+
+bot = telebot.TeleBot(TOKEN)
+
+ret_msg = bot.send_voice(CHAT_ID, open('tests/test_data/record.ogg', 'rb'))
+
+file_info = bot.get_file(ret_msg.voice.file_id)
+
+downloaded_file = bot.download_file(file_info.file_path)
+
+with open('new_file.ogg', 'wb') as new_file:
+    new_file.write(downloaded_file)

examples/inline_example.py

@@ -0,0 +1,73 @@
+# This example show how to write an inline mode telegramt bot use pyTelegramBotAPI.
+import telebot
+import time
+import sys
+import logging
+from telebot import types
+
+API_TOKEN = '<TOKEN>'
+
+bot = telebot.TeleBot(API_TOKEN)
+telebot.logger.setLevel(logging.DEBUG)
+
+
+@bot.inline_handler(lambda query: query.query == 'text')
+def query_text(inline_query):
+    try:
+        r = types.InlineQueryResultArticle('1', 'Result1', types.InputTextMessageContent('hi'))
+        r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('hi'))
+        bot.answer_inline_query(inline_query.id, [r, r2])
+    except Exception as e:
+        print(e)
+
+
+@bot.inline_handler(lambda query: query.query == 'photo1')
+def query_photo(inline_query):
+    try:
+        r = types.InlineQueryResultPhoto('1',
+                                         'https://raw.githubusercontent.com/eternnoir/pyTelegramBotAPI/master/examples/detailed_example/kitten.jpg',
+                                         'https://raw.githubusercontent.com/eternnoir/pyTelegramBotAPI/master/examples/detailed_example/kitten.jpg',
+                                         input_message_content=types.InputTextMessageContent('hi'))
+        r2 = types.InlineQueryResultPhoto('2',
+                                          'https://raw.githubusercontent.com/eternnoir/pyTelegramBotAPI/master/examples/detailed_example/rooster.jpg',
+                                          'https://raw.githubusercontent.com/eternnoir/pyTelegramBotAPI/master/examples/detailed_example/rooster.jpg')
+        bot.answer_inline_query(inline_query.id, [r, r2], cache_time=1)
+    except Exception as e:
+        print(e)
+
+
+@bot.inline_handler(lambda query: query.query == 'video')
+def query_video(inline_query):
+    try:
+        r = types.InlineQueryResultVideo('1',
+                                         'https://github.com/eternnoir/pyTelegramBotAPI/blob/master/tests/test_data/test_video.mp4?raw=true',
+                                         'video/mp4', 'Video',
+                                         'https://raw.githubusercontent.com/eternnoir/pyTelegramBotAPI/master/examples/detailed_example/rooster.jpg',
+                                         'Title'
+                                         )
+        bot.answer_inline_query(inline_query.id, [r])
+    except Exception as e:
+        print(e)
+
+
+@bot.inline_handler(lambda query: len(query.query) is 0)
+def default_query(inline_query):
+    try:
+        r = types.InlineQueryResultArticle('1', 'default', types.InputTextMessageContent('default'))
+        bot.answer_inline_query(inline_query.id, [r])
+    except Exception as e:
+        print(e)
+
+
+def main_loop():
+    bot.polling(True)
+    while 1:
+        time.sleep(3)
+
+
+if __name__ == '__main__':
+    try:
+        main_loop()
+    except KeyboardInterrupt:
+        print >> sys.stderr, '\nExiting by user request.\n'
+        sys.exit(0)

examples/payments_example.py

@@ -0,0 +1,83 @@
+import telebot
+from telebot.types import LabeledPrice
+from telebot.types import ShippingOption
+
+token = '1234567890:AAAABBBBCCCCDDDDeeeeFFFFgggGHHHH'
+provider_token = '1234567890:TEST:AAAABBBBCCCCDDDD'  # @BotFather -> Bot Settings -> Payments
+bot = telebot.TeleBot(token)
+
+# More about Payments: https://core.telegram.org/bots/payments
+
+prices = [LabeledPrice(label='Working Time Machine', amount=5750), LabeledPrice('Gift wrapping', 500)]
+
+shipping_options = [
+    ShippingOption(id='instant', title='WorldWide Teleporter').add_price(LabeledPrice('Teleporter', 1000)),
+    ShippingOption(id='pickup', title='Local pickup').add_price(LabeledPrice('Pickup', 300))]
+
+
+@bot.message_handler(commands=['start'])
+def command_start(message):
+    bot.send_message(message.chat.id,
+                     "Hello, I'm the demo merchant bot."
+                     " I can sell you a Time Machine."
+                     " Use /buy to order one, /terms for Terms and Conditions")
+
+
+@bot.message_handler(commands=['terms'])
+def command_terms(message):
+    bot.send_message(message.chat.id,
+                     'Thank you for shopping with our demo bot. We hope you like your new time machine!\n'
+                     '1. If your time machine was not delivered on time, please rethink your concept of time and try again.\n'
+                     '2. If you find that your time machine is not working, kindly contact our future service workshops on Trappist-1e.'
+                     ' They will be accessible anywhere between May 2075 and November 4000 C.E.\n'
+                     '3. If you would like a refund, kindly apply for one yesterday and we will have sent it to you immediately.')
+
+
+@bot.message_handler(commands=['buy'])
+def command_pay(message):
+    bot.send_message(message.chat.id,
+                     "Real cards won't work with me, no money will be debited from your account."
+                     " Use this test card number to pay for your Time Machine: `4242 4242 4242 4242`"
+                     "\n\nThis is your demo invoice:", parse_mode='Markdown')
+    bot.send_invoice(message.chat.id, title='Working Time Machine',
+                     description='Want to visit your great-great-great-grandparents?'
+                                 ' Make a fortune at the races?'
+                                 ' Shake hands with Hammurabi and take a stroll in the Hanging Gardens?'
+                                 ' Order our Working Time Machine today!',
+                     provider_token=provider_token,
+                     currency='usd',
+                     photo_url='http://erkelzaar.tsudao.com/models/perrotta/TIME_MACHINE.jpg',
+                     photo_height=512,  # !=0/None or picture won't be shown
+                     photo_width=512,
+                     photo_size=512,
+                     is_flexible=False,  # True If you need to set up Shipping Fee
+                     prices=prices,
+                     start_parameter='time-machine-example',
+                     invoice_payload='HAPPY FRIDAYS COUPON')
+
+
+@bot.shipping_query_handler(func=lambda query: True)
+def shipping(shipping_query):
+    print(shipping_query)
+    bot.answer_shipping_query(shipping_query.id, ok=True, shipping_options=shipping_options,
+                              error_message='Oh, seems like our Dog couriers are having a lunch right now. Try again later!')
+
+
+@bot.pre_checkout_query_handler(func=lambda query: True)
+def checkout(pre_checkout_query):
+    bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True,
+                                  error_message="Aliens tried to steal your card's CVV, but we successfully protected your credentials,"
+                                                " try to pay again in a few minutes, we need a small rest.")
+
+
+@bot.message_handler(content_types=['successful_payment'])
+def got_payment(message):
+    bot.send_message(message.chat.id,
+                     'Hoooooray! Thanks for payment! We will proceed your order for `{} {}` as fast as possible! '
+                     'Stay in touch.\n\nUse /buy again to get a Time Machine for your friend!'.format(
+                         message.successful_payment.total_amount / 100, message.successful_payment.currency),
+                     parse_mode='Markdown')
+
+
+bot.skip_pending = True
+bot.polling(none_stop=True, interval=0)

examples/webhook_examples/README.md

@@ -0,0 +1,45 @@
+# Webhook examples using pyTelegramBotAPI
+
+There are 4 examples in this directory using different libraries:
+
+* **Python (CPython):** *webhook_cpython_echo_bot.py*
+  * **Pros:**
+    * Official python libraries, it works out of the box (doesn't require to
+      install anything).
+    * Works with Python 2 and Python 3 (need to be converted with 2to3).
+  * **Cons:**
+    * Ugly code.
+    * Many things to handle yourself, this can lead to errors.
+    * Not powerful, do the trick but the performance is low.
+
+* **CherryPy (3.8.0):** *webhook_cherrypy_echo_bot.py*
+  * **Pros:**
+    * It's a web application framework, cleaner code, uses objects for defining
+      the web application.
+    * Very good performance.
+    * The project seems to be active, latest version is recent.
+    * Works with Python 2 and Python 3.
+  * **Cons:**
+    * Some things are not very intuitive, reading the doc is a must.
+
+* **Flask (0.10.1):** *webhook_flask_echo_bot.py*
+  * **Pros:**
+    * It's a web application framework, cleaner code, uses decorator which can
+      be nice.
+    * Good performance.
+    * It's intuitive if you know how web application works.
+  * **Cons:**
+    * The project seems not to be very active, latest version dates 2013.
+    * They don't recommend to use it with Python 3, but may work.
+    * May be a oversized for just handling webhook petitions.
+    
+* **aiohttp (1.2.0):** *webhook_aiohttp_echo_bot.py*
+  * **Pros:**
+    * It's a web application framework
+    * Python 3 compatible
+    * Asynchronous, excellent perfomance
+    * Utilizes new async/await syntax
+  * **Cons:**
+    * Requires Python 3.4.2+, don't work with Python 2
+
+*Latest update of this document: 2017-01-30*

examples/webhook_examples/webhook_aiohttp_echo_bot.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# This is a simple echo bot using decorators and webhook with aiohttp
+# It echoes any incoming text messages and does not use the polling method.
+
+import logging
+import ssl
+
+from aiohttp import web
+
+import telebot
+
+
+API_TOKEN = '<api_token>'
+
+WEBHOOK_HOST = '<ip/host where the bot is running>'
+WEBHOOK_PORT = 8443  # 443, 80, 88 or 8443 (port need to be 'open')
+WEBHOOK_LISTEN = '0.0.0.0'  # In some VPS you may need to put here the IP addr
+
+WEBHOOK_SSL_CERT = './webhook_cert.pem'  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out webhook_pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+WEBHOOK_URL_BASE = "https://{}:{}".format(WEBHOOK_HOST, WEBHOOK_PORT)
+WEBHOOK_URL_PATH = "/{}/".format(API_TOKEN)
+
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.INFO)
+
+bot = telebot.TeleBot(API_TOKEN)
+
+app = web.Application()
+
+
+# Process webhook calls
+async def handle(request):
+    if request.match_info.get('token') == bot.token:
+        request_body_dict = await request.json()
+        update = telebot.types.Update.de_json(request_body_dict)
+        bot.process_new_updates([update])
+        return web.Response()
+    else:
+        return web.Response(status=403)
+
+app.router.add_post('/{token}/', handle)
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+def send_welcome(message):
+    bot.reply_to(message,
+                 ("Hi there, I am EchoBot.\n"
+                  "I am here to echo your kind words back to you."))
+
+
+# Handle all other messages
+@bot.message_handler(func=lambda message: True, content_types=['text'])
+def echo_message(message):
+    bot.reply_to(message, message.text)
+
+
+# Remove webhook, it fails sometimes the set if there is a previous webhook
+bot.remove_webhook()
+
+# Set webhook
+bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
+                certificate=open(WEBHOOK_SSL_CERT, 'r'))
+
+# Build ssl context
+context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
+context.load_cert_chain(WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV)
+
+# Start aiohttp server
+web.run_app(
+    app,
+    host=WEBHOOK_LISTEN,
+    port=WEBHOOK_PORT,
+    ssl_context=context,
+)

examples/webhook_examples/webhook_cherrypy_echo_bot.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 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
+
+
+API_TOKEN = '<api_token>'
+
+WEBHOOK_HOST = '<ip/host where the bot is running>'
+WEBHOOK_PORT = 8443  # 443, 80, 88 or 8443 (port need to be 'open')
+WEBHOOK_LISTEN = '0.0.0.0'  # In some VPS you may need to put here the IP addr
+
+WEBHOOK_SSL_CERT = './webhook_cert.pem'  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out webhook_pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
+WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)
+
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.INFO)
+
+bot = telebot.TeleBot(API_TOKEN)
+
+
+# WebhookServer, process webhook calls
+class WebhookServer(object):
+    @cherrypy.expose
+    def index(self):
+        if 'content-length' in cherrypy.request.headers and \
+           'content-type' in cherrypy.request.headers and \
+           cherrypy.request.headers['content-type'] == 'application/json':
+            length = int(cherrypy.request.headers['content-length'])
+            json_string = cherrypy.request.body.read(length).decode("utf-8")
+            update = telebot.types.Update.de_json(json_string)
+            bot.process_new_updates([update])
+            return ''
+        else:
+            raise cherrypy.HTTPError(403)
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+def send_welcome(message):
+    bot.reply_to(message,
+                 ("Hi there, I am EchoBot.\n"
+                  "I am here to echo your kind words back to you."))
+
+
+# Handle all other messages
+@bot.message_handler(func=lambda message: True, content_types=['text'])
+def echo_message(message):
+    bot.reply_to(message, message.text)
+
+
+# Remove webhook, it fails sometimes the set if there is a previous webhook
+bot.remove_webhook()
+
+# Set webhook
+bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
+                certificate=open(WEBHOOK_SSL_CERT, 'r'))
+
+# Disable CherryPy requests log
+access_log = cherrypy.log.access_log
+for handler in tuple(access_log.handlers):
+    access_log.removeHandler(handler)
+
+# Start cherrypy server
+cherrypy.config.update({
+    '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
+})
+
+cherrypy.quickstart(WebhookServer(), WEBHOOK_URL_PATH, {'/': {}})

examples/webhook_examples/webhook_cpython_echo_bot.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 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
+
+
+API_TOKEN = '<api_token>'
+
+WEBHOOK_HOST = '<ip/host where the bot is running>'
+WEBHOOK_PORT = 8443  # 443, 80, 88 or 8443 (port need to be 'open')
+WEBHOOK_LISTEN = '0.0.0.0'  # In some VPS you may need to put here the IP addr
+
+WEBHOOK_SSL_CERT = './webhook_cert.pem'  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out webhook_pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
+WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)
+
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.INFO)
+
+bot = telebot.TeleBot(API_TOKEN)
+
+
+# WebhookHandler, process webhook calls
+class WebhookHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+    server_version = "WebhookHandler/1.0"
+
+    def do_HEAD(self):
+        self.send_response(200)
+        self.end_headers()
+
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+
+    def do_POST(self):
+        if self.path == WEBHOOK_URL_PATH and \
+           'content-type' in self.headers and \
+           'content-length' in self.headers and \
+           self.headers['content-type'] == 'application/json':
+            json_string = self.rfile.read(int(self.headers['content-length']))
+
+            self.send_response(200)
+            self.end_headers()
+
+            update = telebot.types.Update.de_json(json_string)
+            bot.process_new_messages([update.message])
+        else:
+            self.send_error(403)
+            self.end_headers()
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+def send_welcome(message):
+    bot.reply_to(message,
+                 ("Hi there, I am EchoBot.\n"
+                  "I am here to echo your kind words back to you."))
+
+
+# Handle all other messages
+@bot.message_handler(func=lambda message: True, content_types=['text'])
+def echo_message(message):
+    bot.reply_to(message, message.text)
+
+
+# Remove webhook, it fails sometimes the set if there is a previous webhook
+bot.remove_webhook()
+
+# Set webhook
+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.socket = ssl.wrap_socket(httpd.socket,
+                               certfile=WEBHOOK_SSL_CERT,
+                               keyfile=WEBHOOK_SSL_PRIV,
+                               server_side=True)
+
+httpd.serve_forever()

examples/webhook_examples/webhook_flask_echo_bot.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 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
+
+
+API_TOKEN = '<api_token>'
+
+WEBHOOK_HOST = '<ip/host where the bot is running>'
+WEBHOOK_PORT = 8443  # 443, 80, 88 or 8443 (port need to be 'open')
+WEBHOOK_LISTEN = '0.0.0.0'  # In some VPS you may need to put here the IP addr
+
+WEBHOOK_SSL_CERT = './webhook_cert.pem'  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out webhook_pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+WEBHOOK_URL_BASE = "https://%s:%s" % (WEBHOOK_HOST, WEBHOOK_PORT)
+WEBHOOK_URL_PATH = "/%s/" % (API_TOKEN)
+
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.INFO)
+
+bot = telebot.TeleBot(API_TOKEN)
+
+app = flask.Flask(__name__)
+
+
+# Empty webserver index, return nothing, just http 200
+@app.route('/', methods=['GET', 'HEAD'])
+def index():
+    return ''
+
+
+# Process webhook calls
+@app.route(WEBHOOK_URL_PATH, methods=['POST'])
+def webhook():
+    if flask.request.headers.get('content-type') == 'application/json':
+        json_string = flask.request.get_data().decode('utf-8')
+        update = telebot.types.Update.de_json(json_string)
+        bot.process_new_updates([update])
+        return ''
+    else:
+        flask.abort(403)
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+def send_welcome(message):
+    bot.reply_to(message,
+                 ("Hi there, I am EchoBot.\n"
+                  "I am here to echo your kind words back to you."))
+
+
+# Handle all other messages
+@bot.message_handler(func=lambda message: True, content_types=['text'])
+def echo_message(message):
+    bot.reply_to(message, message.text)
+
+
+# Remove webhook, it fails sometimes the set if there is a previous webhook
+bot.remove_webhook()
+
+# Set webhook
+bot.set_webhook(url=WEBHOOK_URL_BASE+WEBHOOK_URL_PATH,
+                certificate=open(WEBHOOK_SSL_CERT, 'r'))
+
+# Start flask server
+app.run(host=WEBHOOK_LISTEN,
+        port=WEBHOOK_PORT,
+        ssl_context=(WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV),
+        debug=True)

examples/webhook_examples/webhook_flask_heroku_echo.py

@@ -0,0 +1,29 @@
+import telebot
+import os
+from flask import Flask, request
+
+bot = telebot.TeleBot('<api_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'])
+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")
+    return "!", 200
+
+server.run(host="0.0.0.0", port=os.environ.get('PORT', 5000))
+server = Flask(__name__)

examples/webhook_examples/webhook_tornado_echo_bot.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 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
+
+API_TOKEN = '<api_token>'
+WEBHOOK_CERT = "./cert.pem"
+WEBHOOK_PKEY = "./pkey.pem"
+WEBHOOK_HOST = "<domain_or_ip>"
+WEBHOOK_SECRET = "<secret_uri_for_updates"
+WEBHOOK_PORT = 88
+WEBHOOK_URL_BASE = "https://{0}:{1}/{2}".format(WEBHOOK_HOST, str(WEBHOOK_PORT), WEBHOOK_SECRET)
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key pkey.pem -out cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+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 \
+            self.request.headers['Content-Type'] == "application/json":
+
+            # length = int(self.request.headers['Content-Length'])
+            json_data = self.request.body.decode("utf-8")
+            update = telebot.types.Update.de_json(json_data)
+            bot.process_new_updates([update])
+            self.write("")
+            self.finish()
+        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):
+    bot.reply_to(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'))
+tornado.options.options.logging = None
+tornado.options.parse_command_line()
+signal.signal(signal.SIGINT, signal_handler)
+application = tornado.web.Application([
+    (r"/", Root),
+    (r"/" + WEBHOOK_SECRET, webhook_serv)
+])
+
+http_server = tornado.httpserver.HTTPServer(application, ssl_options={
+        "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()

requirements.txt

@@ -1,5 +1,5 @@
 py==1.4.29
-pytest==2.7.2
+pytest==3.0.2
 requests==2.7.0
 six==1.9.0
 wheel==0.24.0

setup.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python
 from setuptools import setup
+from io import open
 
 def readme():
-    with open('README.rst') as f:
+    with open('README.rst', encoding='utf-8') as f:
         return f.read()
 
 setup(name='pyTelegramBotAPI',
-      version='0.3.4',
+      version='3.5.0',
       description='Python Telegram bot api. ',
       long_description=readme(),
       author='eternnoir',
@@ -15,7 +16,10 @@ setup(name='pyTelegramBotAPI',
       packages=['telebot'],
       license='GPL2',
       keywords='telegram bot api tools',
-      install_requires=['pytest', 'requests', 'six'],
+      install_requires=['requests', 'six'],
+      extras_require={
+          'json': 'ujson',
+      },
       classifiers=[
           'Development Status :: 5 - Production/Stable',
           'Programming Language :: Python :: 2',

telebot/apihelper.py

@@ -1,14 +1,37 @@
 # -*- coding: utf-8 -*-
 
+try:
+    import ujson as json
+except ImportError:
+    import json
+
 import requests
+
+try:
+    from requests.packages.urllib3 import fields
+
+    format_header_param = fields.format_header_param
+except ImportError:
+    format_header_param = None
 import telebot
 from telebot import types
 from telebot import util
 
 logger = telebot.logger
+proxy = None
+
+API_URL = "https://api.telegram.org/bot{0}/{1}"
+FILE_URL = "https://api.telegram.org/file/bot{0}/{1}"
+
+CONNECT_TIMEOUT = 3.5
+READ_TIMEOUT = 9999
 
 
-def _make_request(token, method_name, method='get', params=None, files=None):
+def _get_req_session():
+    return util.per_thread('req_session', lambda: requests.session())
+
+
+def _make_request(token, method_name, method='get', params=None, files=None, base_url=API_URL):
     """
     Makes a request to the Telegram API.
     :param token: The bot's API token. (Created with @BotFather)
@@ -18,10 +41,18 @@ def _make_request(token, method_name, method='get', params=None, files=None):
     :param files: Optional files.
     :return: The result parsed to a JSON dictionary.
     """
-    request_url = telebot.API_URL + 'bot' + token + '/' + method_name
+    request_url = base_url.format(token, method_name)
     logger.debug("Request: method={0} url={1} params={2} files={3}".format(method, request_url, params, files))
-    result = requests.request(method, request_url, params=params, files=files)
-    logger.debug("The server returned: '{0}'".format(result.text))
+    read_timeout = READ_TIMEOUT
+    connect_timeout = CONNECT_TIMEOUT
+    if files and format_header_param:
+        fields.format_header_param = _no_encode(format_header_param)
+    if params:
+        if 'timeout' in params: read_timeout = params['timeout'] + 10
+        if 'connect-timeout' in params: connect_timeout = params['connect-timeout'] + 10
+    result = _get_req_session().request(method, request_url, params=params, files=files,
+                                        timeout=(connect_timeout, read_timeout), proxies=proxy)
+    logger.debug("The server returned: '{0}'".format(result.text.encode('utf8')))
     return _check_result(method_name, result)['result']
 
 
@@ -39,31 +70,46 @@ def _check_result(method_name, result):
     :return: The result parsed to a JSON dictionary.
     """
     if result.status_code != 200:
-        msg = 'The server returned HTTP {0} {1}. Response body:\n[{2}]'\
-            .format(result.status_code, result.reason, result.text)
+        msg = 'The server returned HTTP {0} {1}. Response body:\n[{2}]' \
+            .format(result.status_code, result.reason, result.text.encode('utf8'))
         raise ApiException(msg, method_name, result)
 
     try:
         result_json = result.json()
     except:
-        msg = 'The server returned an invalid JSON response. Response body:\n[{0}]'\
-            .format(result.text)
+        msg = 'The server returned an invalid JSON response. Response body:\n[{0}]' \
+            .format(result.text.encode('utf8'))
         raise ApiException(msg, method_name, result)
 
     if not result_json['ok']:
-        msg = 'Error code: {0} Description: {1}'\
+        msg = 'Error code: {0} Description: {1}' \
             .format(result_json['error_code'], result_json['description'])
         raise ApiException(msg, method_name, result)
     return result_json
 
 
 def get_me(token):
-    method_url = 'getMe'
+    method_url = r'getMe'
     return _make_request(token, method_url)
 
 
+def get_file(token, file_id):
+    method_url = r'getFile'
+    return _make_request(token, method_url, params={'file_id': file_id})
+
+
+def download_file(token, file_path):
+    url = FILE_URL.format(token, file_path)
+    result = _get_req_session().get(url)
+    if result.status_code != 200:
+        msg = 'The server returned HTTP {0} {1}. Response body:\n[{2}]' \
+            .format(result.status_code, result.reason, result.text)
+        raise ApiException(msg, 'Download file', result)
+    return result.content
+
+
 def send_message(token, chat_id, text, disable_web_page_preview=None, reply_to_message_id=None, reply_markup=None,
-                 parse_mode=None):
+                 parse_mode=None, disable_notification=None):
     """
     Use this method to send text messages. On success, the sent Message is returned.
     :param token:
@@ -84,10 +130,38 @@ def send_message(token, chat_id, text, disable_web_page_preview=None, reply_to_m
         payload['reply_markup'] = _convert_markup(reply_markup)
     if parse_mode:
         payload['parse_mode'] = parse_mode
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
     return _make_request(token, method_url, params=payload, method='post')
 
 
-def get_updates(token, offset=None, limit=None, timeout=None):
+def set_webhook(token, url=None, certificate=None, max_connections=None, allowed_updates=None):
+    method_url = r'setWebhook'
+    payload = {
+        'url': url if url else "",
+    }
+    files = None
+    if certificate:
+        files = {'certificate': certificate}
+    if max_connections:
+        payload['max_connections'] = max_connections
+    if allowed_updates:
+        payload['allowed_updates'] = json.dumps(allowed_updates)
+    return _make_request(token, method_url, params=payload, files=files)
+
+
+def delete_webhook(token):
+    method_url = r'deleteWebhook'
+    return _make_request(token, method_url)
+
+
+def get_webhook_info(token):
+    method_url = r'getWebhookInfo'
+    payload = {}
+    return _make_request(token, method_url, params=payload)
+
+
+def get_updates(token, offset=None, limit=None, timeout=None, allowed_updates=None):
     method_url = r'getUpdates'
     payload = {}
     if offset:
@@ -96,6 +170,8 @@ def get_updates(token, offset=None, limit=None, timeout=None):
         payload['limit'] = limit
     if timeout:
         payload['timeout'] = timeout
+    if allowed_updates:
+        payload['allowed_updates'] = json.dumps(allowed_updates)
     return _make_request(token, method_url, params=payload)
 
 
@@ -109,13 +185,58 @@ def get_user_profile_photos(token, user_id, offset=None, limit=None):
     return _make_request(token, method_url, params=payload)
 
 
-def forward_message(token, chat_id, from_chat_id, message_id):
-    method_url = r'forwardMessage'
-    payload = {'chat_id': chat_id, 'from_chat_id': from_chat_id, 'message_id': message_id}
+def get_chat(token, chat_id):
+    method_url = r'getChat'
+    payload = {'chat_id': chat_id}
     return _make_request(token, method_url, params=payload)
 
 
-def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, reply_markup=None):
+def leave_chat(token, chat_id):
+    method_url = r'leaveChat'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload)
+
+
+def get_chat_administrators(token, chat_id):
+    method_url = r'getChatAdministrators'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload)
+
+
+def get_chat_members_count(token, chat_id):
+    method_url = r'getChatMembersCount'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload)
+
+
+def set_chat_sticker_set(token, chat_id, sticker_set_name):
+    method_url = r'setChatStickerSet'
+    payload = {'chat_id': chat_id, 'sticker_set_name': sticker_set_name}
+    return _make_request(token, method_url, params=payload)
+
+
+def delete_chat_sticker_set(token, chat_id):
+    method_url = r'deleteChatStickerSet'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload)
+
+
+def get_chat_member(token, chat_id, user_id):
+    method_url = r'getChatMember'
+    payload = {'chat_id': chat_id, 'user_id': user_id}
+    return _make_request(token, method_url, params=payload)
+
+
+def forward_message(token, chat_id, from_chat_id, message_id, disable_notification=None):
+    method_url = r'forwardMessage'
+    payload = {'chat_id': chat_id, 'from_chat_id': from_chat_id, 'message_id': message_id}
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    return _make_request(token, method_url, params=payload)
+
+
+def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, reply_markup=None,
+               disable_notification=None):
     method_url = r'sendPhoto'
     payload = {'chat_id': chat_id}
     files = None
@@ -129,12 +250,91 @@ def send_photo(token, chat_id, photo, caption=None, reply_to_message_id=None, re
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
-def send_location(token, chat_id, latitude, longitude, reply_to_message_id=None, reply_markup=None):
+def send_media_group(token, chat_id, media, disable_notification=None, reply_to_message_id=None):
+    method_url = r'sendMediaGroup'
+    media_json = _convert_list_json_serializable(media)
+    print(media_json)
+    payload = {'chat_id': chat_id, 'media': media_json}
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    return _make_request(token, method_url, params=payload)
+
+
+def send_location(token, chat_id, latitude, longitude, live_period=None, reply_to_message_id=None, reply_markup=None,
+                  disable_notification=None):
     method_url = r'sendLocation'
     payload = {'chat_id': chat_id, 'latitude': latitude, 'longitude': longitude}
+    if live_period:
+        payload['live_perion'] = live_period
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    return _make_request(token, method_url, params=payload)
+
+
+def edit_message_live_location(token, latitude, longitude, chat_id=None, message_id=None,
+                               inline_message_id=None, reply_markup=None):
+    method_url = r'editMessageLiveLocation'
+    payload = {'latitude': latitude, 'longitude': longitude}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def stop_message_live_location(token, chat_id=None, message_id=None,
+                               inline_message_id=None, reply_markup=None):
+    method_url = r'stopMessageLiveLocation'
+    payload = {}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def send_venue(token, chat_id, latitude, longitude, title, address, foursquare_id=None, disable_notification=None,
+               reply_to_message_id=None, reply_markup=None):
+    method_url = r'sendVenue'
+    payload = {'chat_id': chat_id, 'latitude': latitude, 'longitude': longitude, 'title': title, 'address': address}
+    if foursquare_id:
+        payload['foursquare_id'] = foursquare_id
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def send_contact(token, chat_id, phone_number, first_name, last_name=None, disable_notification=None,
+                 reply_to_message_id=None, reply_markup=None):
+    method_url = r'sendContact'
+    payload = {'chat_id': chat_id, 'phone_number': phone_number, 'first_name': first_name}
+    if last_name:
+        payload['last_name'] = last_name
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
     if reply_to_message_id:
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
@@ -148,7 +348,8 @@ def send_chat_action(token, chat_id, action):
     return _make_request(token, method_url, params=payload)
 
 
-def send_video(token, chat_id, data, duration=None, caption=None, reply_to_message_id=None, reply_markup=None):
+def send_video(token, chat_id, data, duration=None, caption=None, reply_to_message_id=None, reply_markup=None,
+               disable_notification=None, timeout=None):
     method_url = r'sendVideo'
     payload = {'chat_id': chat_id}
     files = None
@@ -164,10 +365,15 @@ def send_video(token, chat_id, data, duration=None, caption=None, reply_to_messa
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if timeout:
+        payload['connect-timeout'] = timeout
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
-def send_voice(token, chat_id, voice, duration=None, reply_to_message_id=None, reply_markup=None):
+def send_voice(token, chat_id, voice, caption=None, duration=None, reply_to_message_id=None, reply_markup=None,
+               disable_notification=None, timeout=None):
     method_url = r'sendVoice'
     payload = {'chat_id': chat_id}
     files = None
@@ -175,17 +381,49 @@ def send_voice(token, chat_id, voice, duration=None, reply_to_message_id=None, r
         files = {'voice': voice}
     else:
         payload['voice'] = voice
+    if caption:
+        payload['caption'] = caption
     if duration:
         payload['duration'] = duration
     if reply_to_message_id:
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if timeout:
+        payload['connect-timeout'] = timeout
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
-def send_audio(token, chat_id, audio, duration=None, performer=None, title=None, reply_to_message_id=None,
-               reply_markup=None):
+def send_video_note(token, chat_id, data, duration=None, length=None, reply_to_message_id=None, reply_markup=None,
+                    disable_notification=None, timeout=None):
+    method_url = r'sendVideoNote'
+    payload = {'chat_id': chat_id}
+    files = None
+    if not util.is_string(data):
+        files = {'video_note': data}
+    else:
+        payload['video_note'] = data
+    if duration:
+        payload['duration'] = duration
+    if length:
+        payload['length'] = length
+    else:
+        payload['length'] = 639  # seems like it is MAX length size
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if timeout:
+        payload['connect-timeout'] = timeout
+    return _make_request(token, method_url, params=payload, files=files, method='post')
+
+
+def send_audio(token, chat_id, audio, caption=None, duration=None, performer=None, title=None, reply_to_message_id=None,
+               reply_markup=None, disable_notification=None, timeout=None):
     method_url = r'sendAudio'
     payload = {'chat_id': chat_id}
     files = None
@@ -193,6 +431,8 @@ def send_audio(token, chat_id, audio, duration=None, performer=None, title=None,
         files = {'audio': audio}
     else:
         payload['audio'] = audio
+    if caption:
+        payload['caption'] = caption
     if duration:
         payload['duration'] = duration
     if performer:
@@ -203,10 +443,15 @@ def send_audio(token, chat_id, audio, duration=None, performer=None, title=None,
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if timeout:
+        payload['connect-timeout'] = timeout
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
-def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_markup=None):
+def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_markup=None, disable_notification=None,
+              timeout=None, caption=None):
     method_url = get_method_by_type(data_type)
     payload = {'chat_id': chat_id}
     files = None
@@ -218,14 +463,452 @@ def send_data(token, chat_id, data, data_type, reply_to_message_id=None, reply_m
         payload['reply_to_message_id'] = reply_to_message_id
     if reply_markup:
         payload['reply_markup'] = _convert_markup(reply_markup)
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if timeout:
+        payload['connect-timeout'] = timeout
+    if caption:
+        payload['caption'] = caption
     return _make_request(token, method_url, params=payload, files=files, method='post')
 
 
 def get_method_by_type(data_type):
     if data_type == 'document':
-        return 'sendDocument'
+        return r'sendDocument'
     if data_type == 'sticker':
-        return 'sendSticker'
+        return r'sendSticker'
+
+
+def kick_chat_member(token, chat_id, user_id, until_date=None):
+    method_url = 'kickChatMember'
+    payload = {'chat_id': chat_id, 'user_id': user_id}
+    if until_date:
+        payload['until_date'] = until_date
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def unban_chat_member(token, chat_id, user_id):
+    method_url = 'unbanChatMember'
+    payload = {'chat_id': chat_id, 'user_id': user_id}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def restrict_chat_member(token, chat_id, user_id, until_date=None, can_send_messages=None,
+                         can_send_media_messages=None, can_send_other_messages=None,
+                         can_add_web_page_previews=None):
+    method_url = 'restrictChatMember'
+    payload = {'chat_id': chat_id, 'user_id': user_id}
+    if until_date:
+        payload['until_date'] = until_date
+    if can_send_messages:
+        payload['can_send_messages'] = can_send_messages
+    if can_send_media_messages:
+        payload['can_send_media_messages'] = can_send_media_messages
+    if can_send_other_messages:
+        payload['can_send_other_messages'] = can_send_other_messages
+    if can_add_web_page_previews:
+        payload['can_add_web_page_previews'] = can_add_web_page_previews
+
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def promote_chat_member(token, chat_id, user_id, can_change_info=None, can_post_messages=None,
+                        can_edit_messages=None, can_delete_messages=None, can_invite_users=None,
+                        can_restrict_members=None, can_pin_messages=None, can_promote_members=None):
+    method_url = 'promoteChatMember'
+    payload = {'chat_id': chat_id, 'user_id': user_id}
+    if can_change_info:
+        payload['can_change_info'] = can_change_info
+    if can_post_messages:
+        payload['can_post_messages'] = can_post_messages
+    if can_edit_messages:
+        payload['can_edit_messages'] = can_edit_messages
+    if can_delete_messages:
+        payload['can_delete_messages'] = can_delete_messages
+    if can_invite_users:
+        payload['can_invite_users'] = can_invite_users
+    if can_restrict_members:
+        payload['can_restrict_members'] = can_restrict_members
+    if can_pin_messages:
+        payload['can_pin_messages'] = can_pin_messages
+    if can_promote_members:
+        payload['can_promote_members'] = can_promote_members
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def export_chat_invite_link(token, chat_id):
+    method_url = 'exportChatInviteLink'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def set_chat_photo(token, chat_id, photo):
+    method_url = 'setChatPhoto'
+    payload = {'chat_id': chat_id}
+    files = None
+    if not util.is_string(photo):
+        files = {'photo': photo}
+    else:
+        payload['photo'] = photo
+    return _make_request(token, method_url, params=payload, files=files, method='post')
+
+
+def delete_chat_photo(token, chat_id):
+    method_url = 'deleteChatPhoto'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def set_chat_title(token, chat_id, title):
+    method_url = 'setChatTitle'
+    payload = {'chat_id': chat_id, 'title': title}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def set_chat_description(token, chat_id, description):
+    method_url = 'setChatDescription'
+    payload = {'chat_id': chat_id, 'description': description}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def pin_chat_message(token, chat_id, message_id, disable_notification=False):
+    method_url = 'pinChatMessage'
+    payload = {'chat_id': chat_id, 'message_id': message_id, 'disable_notification': disable_notification}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def unpin_chat_message(token, chat_id):
+    method_url = 'unpinChatMessage'
+    payload = {'chat_id': chat_id}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+# Updating messages
+
+def edit_message_text(token, text, chat_id=None, message_id=None, inline_message_id=None, parse_mode=None,
+                      disable_web_page_preview=None, reply_markup=None):
+    method_url = r'editMessageText'
+    payload = {'text': text}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if parse_mode:
+        payload['parse_mode'] = parse_mode
+    if disable_web_page_preview:
+        payload['disable_web_page_preview'] = disable_web_page_preview
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def edit_message_caption(token, caption, chat_id=None, message_id=None, inline_message_id=None, reply_markup=None):
+    method_url = r'editMessageCaption'
+    payload = {'caption': caption}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def edit_message_reply_markup(token, chat_id=None, message_id=None, inline_message_id=None, reply_markup=None):
+    method_url = r'editMessageReplyMarkup'
+    payload = {}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+def delete_message(token, chat_id, message_id):
+    method_url = r'deleteMessage'
+    payload = {'chat_id': chat_id, 'message_id': message_id}
+    return _make_request(token, method_url, params=payload)
+
+
+# Game
+
+def send_game(token, chat_id, game_short_name, disable_notification=None, reply_to_message_id=None, reply_markup=None):
+    method_url = r'sendGame'
+    payload = {'chat_id': chat_id, 'game_short_name': game_short_name}
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    return _make_request(token, method_url, params=payload)
+
+
+# https://core.telegram.org/bots/api#setgamescore
+def set_game_score(token, user_id, score, force=None, disable_edit_message=None, chat_id=None, message_id=None,
+                   inline_message_id=None):
+    """
+    Use this method to set the score of the specified user in a game. On success, if the message was sent by the bot, returns the edited Message, otherwise returns True. Returns an error, if the new score is not greater than the user's current score in the chat.
+    :param token: Bot's token (you don't need to fill this)
+    :param user_id: User identifier
+    :param score: New score, must be non-negative
+    :param force: (Optional) Pass True, if the high score is allowed to decrease. This can be useful when fixing mistakes or banning cheaters
+    :param disable_edit_message: (Optional) Pass True, if the game message should not be automatically edited to include the current scoreboard
+    :param chat_id: (Optional, required if inline_message_id is not specified) Unique identifier for the target chat (or username of the target channel in the format @channelusername)
+    :param message_id: (Optional, required if inline_message_id is not specified) Unique identifier of the sent message
+    :param inline_message_id: (Optional, required if chat_id and message_id are not specified) Identifier of the inline message
+    :return:
+    """
+    method_url = r'setGameScore'
+    payload = {'user_id': user_id, 'score': score}
+    if force:
+        payload['force'] = force
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    if disable_edit_message:
+        payload['disable_edit_message'] = disable_edit_message
+    return _make_request(token, method_url, params=payload)
+
+
+# https://core.telegram.org/bots/api#getgamehighscores
+def get_game_high_scores(token, user_id, chat_id=None, message_id=None, inline_message_id=None):
+    """
+    Use this method to get data for high score tables. Will return the score of the specified user and several of his neighbors in a game. On success, returns an Array of GameHighScore objects.
+    This method will currently return scores for the target user, plus two of his closest neighbors on each side. Will also return the top three users if the user and his neighbors are not among them. Please note that this behavior is subject to change.
+    :param token: Bot's token (you don't need to fill this)
+    :param user_id: Target user id
+    :param chat_id: (Optional, required if inline_message_id is not specified) Unique identifier for the target chat (or username of the target channel in the format @channelusername)
+    :param message_id: (Optional, required if inline_message_id is not specified) Unique identifier of the sent message
+    :param inline_message_id: (Optional, required if chat_id and message_id are not specified) Identifier of the inline message
+    :return:
+    """
+    method_url = r'getGameHighScores'
+    payload = {'user_id': user_id}
+    if chat_id:
+        payload['chat_id'] = chat_id
+    if message_id:
+        payload['message_id'] = message_id
+    if inline_message_id:
+        payload['inline_message_id'] = inline_message_id
+    return _make_request(token, method_url, params=payload)
+
+
+# Payments (https://core.telegram.org/bots/api#payments)
+
+def send_invoice(token, chat_id, title, description, invoice_payload, provider_token, currency, prices,
+                 start_parameter, photo_url=None, photo_size=None, photo_width=None, photo_height=None,
+                 need_name=None, need_phone_number=None, need_email=None, need_shipping_address=None, is_flexible=None,
+                 disable_notification=None, reply_to_message_id=None, reply_markup=None, provider_data=None):
+    """
+    Use this method to send invoices. On success, the sent Message is returned.
+    :param token: Bot's token (you don't need to fill this)
+    :param chat_id: Unique identifier for the target private chat
+    :param title: Product name
+    :param description: Product description
+    :param invoice_payload: Bot-defined invoice payload, 1-128 bytes. This will not be displayed to the user, use for your internal processes.
+    :param provider_token: Payments provider token, obtained via @Botfather
+    :param currency: Three-letter ISO 4217 currency code, see https://core.telegram.org/bots/payments#supported-currencies
+    :param prices: Price breakdown, a list of components (e.g. product price, tax, discount, delivery cost, delivery tax, bonus, etc.)
+    :param start_parameter: Unique deep-linking parameter that can be used to generate this invoice when used as a start parameter
+    :param photo_url: URL of the product photo for the invoice. Can be a photo of the goods or a marketing image for a service. People like it better when they see what they are paying for.
+    :param photo_size: Photo size
+    :param photo_width: Photo width
+    :param photo_height: Photo height
+    :param need_name: Pass True, if you require the user's full name to complete the order
+    :param need_phone_number: Pass True, if you require the user's phone number to complete the order
+    :param need_email: Pass True, if you require the user's email to complete the order
+    :param need_shipping_address: Pass True, if you require the user's shipping address to complete the order
+    :param is_flexible: Pass True, if the final price depends on the shipping method
+    :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
+    :param reply_to_message_id: If the message is a reply, ID of the original message
+    :param reply_markup: A JSON-serialized object for an inline keyboard. If empty, one 'Pay total price' button will be shown. If not empty, the first button must be a Pay button
+    :return: 
+    """
+    method_url = r'sendInvoice'
+    payload = {'chat_id': chat_id, 'title': title, 'description': description, 'payload': invoice_payload,
+               'provider_token': provider_token, 'start_parameter': start_parameter, 'currency': currency,
+               'prices': _convert_list_json_serializable(prices)}
+    if photo_url:
+        payload['photo_url'] = photo_url
+    if photo_size:
+        payload['photo_size'] = photo_size
+    if photo_width:
+        payload['photo_width'] = photo_width
+    if photo_height:
+        payload['photo_height'] = photo_height
+    if need_name:
+        payload['need_name'] = need_name
+    if need_phone_number:
+        payload['need_phone_number'] = need_phone_number
+    if need_email:
+        payload['need_email'] = need_email
+    if need_shipping_address:
+        payload['need_shipping_address'] = need_shipping_address
+    if is_flexible:
+        payload['is_flexible'] = is_flexible
+    if disable_notification:
+        payload['disable_notification'] = disable_notification
+    if reply_to_message_id:
+        payload['reply_to_message_id'] = reply_to_message_id
+    if reply_markup:
+        payload['reply_markup'] = _convert_markup(reply_markup)
+    if provider_data:
+        payload['provider_data'] = provider_data
+    return _make_request(token, method_url, params=payload)
+
+
+def answer_shipping_query(token, shipping_query_id, ok, shipping_options=None, error_message=None):
+    """
+    If you sent an invoice requesting a shipping address and the parameter is_flexible was specified, the Bot API will send an Update with a shipping_query field to the bot. Use this method to reply to shipping queries. On success, True is returned.
+    :param token: Bot's token (you don't need to fill this)
+    :param shipping_query_id: Unique identifier for the query to be answered
+    :param ok: Specify True if delivery to the specified address is possible and False if there are any problems (for example, if delivery to the specified address is not possible)
+    :param shipping_options: Required if ok is True. A JSON-serialized array of available shipping options.
+    :param error_message: Required if ok is False. Error message in human readable form that explains why it is impossible to complete the order (e.g. "Sorry, delivery to your desired address is unavailable'). Telegram will display this message to the user.
+    :return: 
+    """
+    method_url = 'answerShippingQuery'
+    payload = {'shipping_query_id': shipping_query_id, 'ok': ok}
+    if shipping_options:
+        payload['shipping_options'] = _convert_list_json_serializable(shipping_options)
+    if error_message:
+        payload['error_message'] = error_message
+    return _make_request(token, method_url, params=payload)
+
+
+def answer_pre_checkout_query(token, pre_checkout_query_id, ok, error_message=None):
+    """
+    Once the user has confirmed their payment and shipping details, the Bot API sends the final confirmation in the form of an Update with the field pre_checkout_query. Use this method to respond to such pre-checkout queries. On success, True is returned. Note: The Bot API must receive an answer within 10 seconds after the pre-checkout query was sent.
+    :param token: Bot's token (you don't need to fill this)
+    :param pre_checkout_query_id: Unique identifier for the query to be answered
+    :param ok: Specify True if everything is alright (goods are available, etc.) and the bot is ready to proceed with the order. Use False if there are any problems.
+    :param error_message: Required if ok is False. Error message in human readable form that explains the reason for failure to proceed with the checkout (e.g. "Sorry, somebody just bought the last of our amazing black T-shirts while you were busy filling out your payment details. Please choose a different color or garment!"). Telegram will display this message to the user.
+    :return: 
+    """
+    method_url = 'answerPreCheckoutQuery'
+    payload = {'pre_checkout_query_id': pre_checkout_query_id, 'ok': ok}
+    if error_message:
+        payload['error_message'] = error_message
+    return _make_request(token, method_url, params=payload)
+
+
+# InlineQuery
+
+def answer_callback_query(token, callback_query_id, text=None, show_alert=None, url=None, cache_time=None):
+    """
+    Use this method to send answers to callback queries sent from inline keyboards. The answer will be displayed to the user as a notification at the top of the chat screen or as an alert. On success, True is returned.
+    Alternatively, the user can be redirected to the specified Game URL. For this option to work, you must first create a game for your bot via BotFather and accept the terms. Otherwise, you may use links like telegram.me/your_bot?start=XXXX that open your bot with a parameter.
+    :param token: Bot's token (you don't need to fill this)
+    :param callback_query_id: Unique identifier for the query to be answered
+    :param text: (Optional) Text of the notification. If not specified, nothing will be shown to the user, 0-200 characters
+    :param show_alert: (Optional) If true, an alert will be shown by the client instead of a notification at the top of the chat screen. Defaults to false.
+    :param url: (Optional) URL that will be opened by the user's client. If you have created a Game and accepted the conditions via @Botfather, specify the URL that opens your game – note that this will only work if the query comes from a callback_game button.
+    Otherwise, you may use links like telegram.me/your_bot?start=XXXX that open your bot with a parameter.
+    :param cache_time: (Optional) The maximum amount of time in seconds that the result of the callback query may be cached client-side. Telegram apps will support caching starting in version 3.14. Defaults to 0.
+    :return:
+    """
+    method_url = 'answerCallbackQuery'
+    payload = {'callback_query_id': callback_query_id}
+    if text:
+        payload['text'] = text
+    if show_alert:
+        payload['show_alert'] = show_alert
+    if url:
+        payload['url'] = url
+    if cache_time:
+        payload['cache_time'] = cache_time
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def answer_inline_query(token, inline_query_id, results, cache_time=None, is_personal=None, next_offset=None,
+                        switch_pm_text=None, switch_pm_parameter=None):
+    method_url = 'answerInlineQuery'
+    payload = {'inline_query_id': inline_query_id, 'results': _convert_list_json_serializable(results)}
+    if cache_time:
+        payload['cache_time'] = cache_time
+    if is_personal:
+        payload['is_personal'] = is_personal
+    if next_offset is not None:
+        payload['next_offset'] = next_offset
+    if switch_pm_text:
+        payload['switch_pm_text'] = switch_pm_text
+    if switch_pm_parameter:
+        payload['switch_pm_parameter'] = switch_pm_parameter
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def get_sticker_set(token, name):
+    method_url = 'getStickerSet'
+    return _make_request(token, method_url, params={'name': name})
+
+
+def upload_sticker_file(token, user_id, png_sticker):
+    method_url = 'uploadStickerFile'
+    payload = {'user_id': user_id}
+    files = {'png_sticker': png_sticker}
+    return _make_request(token, method_url, params=payload, files=files, method='post')
+
+
+def create_new_sticker_set(token, user_id, name, title, png_sticker, emojis, contains_masks=None, mask_position=None):
+    method_url = 'createNewStickerSet'
+    payload = {'user_id': user_id, 'name': name, 'title': title, 'emojis': emojis}
+    files = None
+    if not util.is_string(png_sticker):
+        files = {'png_sticker': png_sticker}
+    else:
+        payload['png_sticker'] = png_sticker
+    if contains_masks:
+        payload['contains_masks'] = contains_masks
+    if mask_position:
+        payload['mask_position'] = mask_position.to_json()
+    return _make_request(token, method_url, params=payload, files=files, method='post')
+
+
+def add_sticker_to_set(token, user_id, name, png_sticker, emojis, mask_position):
+    method_url = 'addStickerToSet'
+    payload = {'user_id': user_id, 'name': name, 'emojis': emojis}
+    files = None
+    if not util.is_string(png_sticker):
+        files = {'png_sticker': png_sticker}
+    else:
+        payload['png_sticker'] = png_sticker
+    if mask_position:
+        payload['mask_position'] = mask_position.to_json()
+    return _make_request(token, method_url, params=payload, files=files, method='post')
+
+
+def set_sticker_position_in_set(token, sticker, position):
+    method_url = 'setStickerPositionInSet'
+    payload = {'sticker': sticker, 'position': position}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def delete_sticker_from_set(token, sticker):
+    method_url = 'deleteStickerFromSet'
+    payload = {'sticker': sticker}
+    return _make_request(token, method_url, params=payload, method='post')
+
+
+def _convert_list_json_serializable(results):
+    ret = ''
+    for r in results:
+        if isinstance(r, types.JsonSerializable):
+            ret = ret + r.to_json() + ','
+    if len(ret) > 0:
+        ret = ret[:-1]
+    return '[' + ret + ']'
 
 
 def _convert_markup(markup):
@@ -233,6 +916,17 @@ def _convert_markup(markup):
         return markup.to_json()
     return markup
 
+
+def _no_encode(func):
+    def wrapper(key, val):
+        if key == 'filename':
+            return '{0}={1}'.format(key, val)
+        else:
+            return func(key, val)
+
+    return wrapper
+
+
 class ApiException(Exception):
     """
     This class represents an Exception thrown when a call to the Telegram API fails.

telebot/util.py

@@ -1,54 +1,121 @@
 # -*- coding: utf-8 -*-
 
 import threading
+import traceback
+import re
+import sys
+import six
 from six import string_types
 
 # Python3 queue support.
+
 try:
     import Queue
 except ImportError:
     import queue as Queue
 
+from telebot import logger
 
-class ThreadPool:
-    class WorkerThread(threading.Thread):
+
+thread_local = threading.local()
+
+
+class WorkerThread(threading.Thread):
         count = 0
 
-        def __init__(self, queue):
-            threading.Thread.__init__(self, name="WorkerThread{0}".format(self.__class__.count + 1))
-            self.__class__.count += 1
+        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
 
+            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()
 
         def run(self):
             while self._running:
                 try:
-                    task, args, kwargs = self.queue.get(block=True, timeout=.01)
+                    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()
+
+                    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 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 stop(self):
             self._running = False
 
-    def __init__(self, num_threads=4):
-        self.tasks = Queue.Queue()
-        self.workers = [self.WorkerThread(self.tasks) for _ in range(num_threads)]
 
+class ThreadPool:
+
+    def __init__(self, num_threads=2):
+        self.tasks = Queue.Queue()
+        self.workers = [WorkerThread(self.on_exception, self.tasks) for _ in range(num_threads)]
         self.num_threads = num_threads
 
+        self.exception_event = threading.Event()
+        self.exc_info = None
+
     def put(self, func, *args, **kwargs):
         self.tasks.put((func, args, kwargs))
 
+    def on_exception(self, worker_thread, exc_info):
+        self.exc_info = exc_info
+        self.exception_event.set()
+        worker_thread.continue_event.set()
+
+    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()
+
     def close(self):
         for worker in self.workers:
             worker.stop()
         for worker in self.workers:
             worker.join()
 
+
 class AsyncTask:
     def __init__(self, target, *args, **kwargs):
         self.target = target
@@ -62,15 +129,15 @@ class AsyncTask:
     def _run(self):
         try:
             self.result = self.target(*self.args, **self.kwargs)
-        except Exception as e:
-            self.result = e
+        except:
+            self.result = sys.exc_info()
         self.done = True
 
     def wait(self):
         if not self.done:
             self.thread.join()
-        if isinstance(self.result, Exception):
-            raise self.result
+        if isinstance(self.result, BaseException):
+            six.reraise(self.result[0], self.result[1], self.result[2])
         else:
             return self.result
 
@@ -124,3 +191,66 @@ def split_string(text, chars_per_string):
     :return: The splitted text as a list of strings.
     """
     return [text[i:i + chars_per_string] for i in range(0, len(text), chars_per_string)]
+
+# CREDITS TO http://stackoverflow.com/questions/12317940#answer-12320352
+def or_set(self):
+    self._set()
+    self.changed()
+
+
+def or_clear(self):
+    self._clear()
+    self.changed()
+
+
+def orify(e, changed_callback):
+    e._set = e.set
+    e._clear = e.clear
+    e.changed = changed_callback
+    e.set = lambda: or_set(e)
+    e.clear = lambda: or_clear(e)
+
+def OrEvent(*events):
+    or_event = threading.Event()
+    def changed():
+        bools = [e.is_set() for e in events]
+        if any(bools):
+            or_event.set()
+        else:
+            or_event.clear()
+
+    def busy_wait():
+        while not or_event.is_set():
+            or_event._wait(3)
+
+    for e in events:
+        orify(e, changed)
+    or_event._wait = or_event.wait
+    or_event.wait = busy_wait
+    changed()
+    return or_event
+
+def extract_arguments(text):
+    """
+    Returns the argument after the command.
+    
+    Examples:
+    extract_arguments("/get name"): 'name'
+    extract_arguments("/get"): ''
+    extract_arguments("/get@botName name"): 'name'
+    
+    :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)
+    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:
+        value = construct_value()
+        setattr(thread_local, key, value)
+        return value

tests/test_telebot.py

@@ -9,7 +9,6 @@ import os
 
 import telebot
 from telebot import types
-from telebot import apihelper
 from telebot import util
 
 should_skip = 'TOKEN' and 'CHAT_ID' not in os.environ
@@ -17,6 +16,7 @@ should_skip = 'TOKEN' and 'CHAT_ID' not in os.environ
 if not should_skip:
     TOKEN = os.environ['TOKEN']
     CHAT_ID = os.environ['CHAT_ID']
+    GROUP_ID = os.environ['GROUP_ID']
 
 
 @pytest.mark.skipif(should_skip, reason="No environment variables configured")
@@ -56,6 +56,30 @@ class TestTeleBot:
         time.sleep(1)
         assert msg.text == 'got'
 
+    def test_message_handler_lambda(self):
+        bot = telebot.TeleBot('')
+        msg = self.create_text_message(r'lambda_text')
+
+        @bot.message_handler(func=lambda message: r'lambda' in message.text)
+        def command_url(message):
+            msg.text = 'got'
+
+        bot.process_new_messages([msg])
+        time.sleep(1)
+        assert msg.text == 'got'
+
+    def test_message_handler_lambda_fail(self):
+        bot = telebot.TeleBot('')
+        msg = self.create_text_message(r'text')
+
+        @bot.message_handler(func=lambda message: r'lambda' in message.text)
+        def command_url(message):
+            msg.text = 'got'
+
+        bot.process_new_messages([msg])
+        time.sleep(1)
+        assert not msg.text == 'got'
+
     def test_message_handler_reg_fail(self):
         bot = telebot.TeleBot('')
         msg = self.create_text_message(r'web.telegram.org/')
@@ -78,6 +102,15 @@ class TestTeleBot:
         ret_msg = tb.send_message(CHAT_ID, markdown, parse_mode="Markdown")
         assert ret_msg.message_id
 
+    def test_send_message_with_disable_notification(self):
+        tb = telebot.TeleBot(TOKEN)
+        markdown = """
+        *bold text*
+        _italic text_
+        [text](URL)
+        """
+        ret_msg = tb.send_message(CHAT_ID, markdown, parse_mode="Markdown", disable_notification=True)
+        assert ret_msg.message_id
 
     def test_send_file(self):
         file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
@@ -88,18 +121,48 @@ class TestTeleBot:
         ret_msg = tb.send_document(CHAT_ID, ret_msg.document.file_id)
         assert ret_msg.message_id
 
+    def test_send_file_dis_noti(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_document(CHAT_ID, file_data, disable_notification=True)
+        assert ret_msg.message_id
+
+        ret_msg = tb.send_document(CHAT_ID, ret_msg.document.file_id)
+        assert ret_msg.message_id
+
+    def test_send_file_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="Test")
+        assert ret_msg.message_id
+
+        ret_msg = tb.send_document(CHAT_ID, ret_msg.document.file_id)
+        assert ret_msg.message_id
+
     def test_send_video(self):
         file_data = open('./test_data/test_video.mp4', 'rb')
         tb = telebot.TeleBot(TOKEN)
         ret_msg = tb.send_video(CHAT_ID, file_data)
         assert ret_msg.message_id
 
+    def test_send_video_dis_noti(self):
+        file_data = open('./test_data/test_video.mp4', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_video(CHAT_ID, file_data, disable_notification=True)
+        assert ret_msg.message_id
+
     def test_send_video_more_params(self):
         file_data = open('./test_data/test_video.mp4', 'rb')
         tb = telebot.TeleBot(TOKEN)
         ret_msg = tb.send_video(CHAT_ID, file_data, 1)
         assert ret_msg.message_id
 
+    def test_send_video_more_params_dis_noti(self):
+        file_data = open('./test_data/test_video.mp4', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_video(CHAT_ID, file_data, 1, disable_notification=True)
+        assert ret_msg.message_id
+
     def test_send_file_exception(self):
         tb = telebot.TeleBot(TOKEN)
         try:
@@ -118,10 +181,28 @@ class TestTeleBot:
         ret_msg = tb.send_photo(CHAT_ID, ret_msg.photo[0].file_id)
         assert ret_msg.message_id
 
+    def test_send_photo_dis_noti(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_photo(CHAT_ID, file_data)
+        assert ret_msg.message_id
+
+        ret_msg = tb.send_photo(CHAT_ID, ret_msg.photo[0].file_id, disable_notification=True)
+        assert ret_msg.message_id
+
     def test_send_audio(self):
         file_data = open('./test_data/record.mp3', 'rb')
         tb = telebot.TeleBot(TOKEN)
-        ret_msg = tb.send_audio(CHAT_ID, file_data, 1, 'eternnoir', 'pyTelegram')
+        ret_msg = tb.send_audio(CHAT_ID, file_data, 1, performer='eternnoir', title='pyTelegram')
+        assert ret_msg.content_type == 'audio'
+        assert ret_msg.audio.performer == 'eternnoir'
+        assert ret_msg.audio.title == 'pyTelegram'
+
+    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)
         assert ret_msg.content_type == 'audio'
         assert ret_msg.audio.performer == 'eternnoir'
         assert ret_msg.audio.title == 'pyTelegram'
@@ -132,12 +213,69 @@ class TestTeleBot:
         ret_msg = tb.send_voice(CHAT_ID, file_data)
         assert ret_msg.voice.mime_type == 'audio/ogg'
 
+    def test_send_voice_dis_noti(self):
+        file_data = open('./test_data/record.ogg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_voice(CHAT_ID, file_data, disable_notification=True)
+        assert ret_msg.voice.mime_type == 'audio/ogg'
+
+    def test_get_file(self):
+        file_data = open('./test_data/record.ogg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_voice(CHAT_ID, file_data)
+        file_id = ret_msg.voice.file_id
+        file_info = tb.get_file(file_id)
+        assert file_info.file_id == file_id
+
+    def test_get_file_dis_noti(self):
+        file_data = open('./test_data/record.ogg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_voice(CHAT_ID, file_data, disable_notification=True)
+        file_id = ret_msg.voice.file_id
+        file_info = tb.get_file(file_id)
+        assert file_info.file_id == file_id
+
     def test_send_message(self):
         text = 'CI Test Message'
         tb = telebot.TeleBot(TOKEN)
         ret_msg = tb.send_message(CHAT_ID, text)
         assert ret_msg.message_id
 
+    def test_send_message_dis_noti(self):
+        text = 'CI Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        ret_msg = tb.send_message(CHAT_ID, text, disable_notification=True)
+        assert ret_msg.message_id
+
+    def test_send_message_with_markup(self):
+        text = 'CI Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        markup = types.ReplyKeyboardMarkup()
+        markup.add(types.KeyboardButton("1"))
+        markup.add(types.KeyboardButton("2"))
+        ret_msg = tb.send_message(CHAT_ID, text, disable_notification=True, reply_markup=markup)
+        assert ret_msg.message_id
+
+    def test_send_message_with_markup_use_string(self):
+        text = 'CI Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        markup = types.ReplyKeyboardMarkup()
+        markup.add("1")
+        markup.add("2")
+        markup.add("3")
+        markup.add("4")
+        ret_msg = tb.send_message(CHAT_ID, text, disable_notification=True, reply_markup=markup)
+        assert ret_msg.message_id
+
+    def test_send_message_with_inlinemarkup(self):
+        text = 'CI Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        markup = types.InlineKeyboardMarkup()
+        markup.add(types.InlineKeyboardButton("Google", url="http://www.google.com"))
+        markup.add(types.InlineKeyboardButton("Yahoo", url="http://www.yahoo.com"))
+        ret_msg = tb.send_message(CHAT_ID, text, disable_notification=True, reply_markup=markup)
+        assert ret_msg.message_id
+
     def test_forward_message(self):
         text = 'CI forward_message Test Message'
         tb = telebot.TeleBot(TOKEN)
@@ -145,6 +283,13 @@ class TestTeleBot:
         ret_msg = tb.forward_message(CHAT_ID, CHAT_ID, msg.message_id)
         assert ret_msg.forward_from
 
+    def test_forward_message_dis_noti(self):
+        text = 'CI forward_message Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        msg = tb.send_message(CHAT_ID, text)
+        ret_msg = tb.forward_message(CHAT_ID, CHAT_ID, msg.message_id, disable_notification=True)
+        assert ret_msg.forward_from
+
     def test_reply_to(self):
         text = 'CI reply_to Test Message'
         tb = telebot.TeleBot(TOKEN)
@@ -173,9 +318,79 @@ class TestTeleBot:
         assert int(ret_msg.location.longitude) == int(lon)
         assert int(ret_msg.location.latitude) == int(lat)
 
+    def test_send_location_dis_noti(self):
+        tb = telebot.TeleBot(TOKEN)
+        lat = 26.3875591
+        lon = -161.2901042
+        ret_msg = tb.send_location(CHAT_ID, lat, lon, disable_notification=True)
+        assert int(ret_msg.location.longitude) == int(lon)
+        assert int(ret_msg.location.latitude) == int(lat)
+
+    def test_send_venue(self):
+        tb = telebot.TeleBot(TOKEN)
+        lat = 26.3875591
+        lon = -161.2901042
+        ret_msg = tb.send_venue(CHAT_ID, lat, lon, "Test Venue", "1123 Test Venue address")
+        assert ret_msg.venue.title == "Test Venue"
+        assert int(lat) == int(ret_msg.venue.location.latitude)
+
+    def test_send_venue_dis_noti(self):
+        tb = telebot.TeleBot(TOKEN)
+        lat = 26.3875591
+        lon = -161.2901042
+        ret_msg = tb.send_venue(CHAT_ID, lat, lon, "Test Venue", "1123 Test Venue address", disable_notification=True)
+        assert ret_msg.venue.title == "Test Venue"
+
+    def test_Chat(self):
+        tb = telebot.TeleBot(TOKEN)
+        me = tb.get_me()
+        msg = tb.send_message(CHAT_ID, 'Test')
+        assert me.id == msg.from_user.id
+        assert msg.chat.id == int(CHAT_ID)
+
+    def test_edit_message_text(self):
+        tb = telebot.TeleBot(TOKEN)
+        msg = tb.send_message(CHAT_ID, 'Test')
+        new_msg = tb.edit_message_text('Edit test', chat_id=CHAT_ID, message_id=msg.message_id)
+        assert new_msg.text == 'Edit test'
+
+    def test_edit_message_caption(self):
+        file_data = open('../examples/detailed_example/kitten.jpg', 'rb')
+        tb = telebot.TeleBot(TOKEN)
+        msg = tb.send_document(CHAT_ID, file_data, caption="Test")
+        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_get_chat(self):
+        tb = telebot.TeleBot(TOKEN)
+        ch = tb.get_chat(GROUP_ID)
+        assert str(ch.id) == GROUP_ID
+
+    def test_get_chat_administrators(self):
+        tb = telebot.TeleBot(TOKEN)
+        cas = tb.get_chat_administrators(GROUP_ID)
+        assert len(cas) > 0
+
+    def test_get_chat_members_count(self):
+        tb = telebot.TeleBot(TOKEN)
+        cn = tb.get_chat_members_count(GROUP_ID)
+        assert cn > 1
+
+    def test_edit_markup(self):
+        text = 'CI Test Message'
+        tb = telebot.TeleBot(TOKEN)
+        markup = types.InlineKeyboardMarkup()
+        markup.add(types.InlineKeyboardButton("Google", url="http://www.google.com"))
+        markup.add(types.InlineKeyboardButton("Yahoo", url="http://www.yahoo.com"))
+        ret_msg = tb.send_message(CHAT_ID, text, disable_notification=True, reply_markup=markup)
+        markup.add(types.InlineKeyboardButton("Google2", url="http://www.google.com"))
+        markup.add(types.InlineKeyboardButton("Yahoo2", url="http://www.yahoo.com"))
+        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):
         params = {'text': text}
-        chat = types.User(11, 'test')
+        chat = types.User(11, False, 'test')
         return types.Message(1, None, None, chat, 'text', params)
 
     def test_is_string_unicode(self):
@@ -190,3 +405,16 @@ class TestTeleBot:
         i1 = 10
         assert not util.is_string(i1)
 
+    def test_send_video_note(self):
+        file_data = open('./test_data/test_video.mp4', 'rb')
+        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

tests/test_types.py

@@ -6,19 +6,19 @@ 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":108929734,"first_name":"Frank","last_name":"Wang","username":"eternnoir"},"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_group():
-    json_string = r'{"message_id":10,"from":{"id":12345,"first_name":"g","last_name":"G","username":"GG"},"chat":{"id":-866,"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 +39,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","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 +48,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","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":98,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd","is_bot":true },"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}}'
     msg = types.Message.de_json(json_string)
     assert msg.sticker.height == 368
     assert msg.sticker.thumb.height == 60
@@ -56,7 +56,7 @@ 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","last_name":"Wd","username":"dd"},"date":1435479551,"sticker":{"width":550,"height":368,"file_id":"BQADBQADNAIAAsYifgYdGJOa6bGAsQI","file_size":30320}}'
+    json_string = r'{"message_id":98,"from":{"id":10734,"first_name":"Fd","last_name":"Wd","username":"dd","is_bot":true },"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}}'
     msg = types.Message.de_json(json_string)
     assert msg.sticker.height == 368
     assert msg.sticker.thumb == None
@@ -64,21 +64,21 @@ def test_json_Message_Sticker_without_thumb():
 
 
 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","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","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","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 +87,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","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'
@@ -114,9 +114,44 @@ def test_json_voice():
     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","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)
+    assert chat.id == -111111
+    assert chat.type == 'group'
+    assert chat.title == 'Test Title'
+
+def test_InlineQueryResultCachedPhoto():
+    iq = types.InlineQueryResultCachedPhoto('aaa', 'Fileid')
+    json_str = iq.to_json()
+    assert 'aa' in json_str
+    assert 'Fileid' in json_str
+    assert 'caption' not in json_str
+
+
+def test_InlineQueryResultCachedPhoto_with_title():
+    iq = types.InlineQueryResultCachedPhoto('aaa', 'Fileid', title='Title')
+    json_str = iq.to_json()
+    assert 'aa' in json_str
+    assert 'Fileid' in json_str
+    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"))
+    markup.add(types.InlineKeyboardButton("Yahoo", url="http://www.yahoo.com"))
+    iq = types.InlineQueryResultCachedPhoto('aaa', 'Fileid', title='Title', reply_markup=markup)
+    json_str = iq.to_json()
+    assert 'aa' in json_str
+    assert 'Fileid' in json_str
+    assert 'Title' in json_str
+    assert 'caption' not in json_str
+    assert 'reply_markup' in json_str
+