Bump version to v4.3.1

Urllib3

.github/CONTRIBUTING.rst

@@ -0,0 +1,186 @@
+How To Contribute
+=================
+
+Every open source project lives from the generous help by contributors that sacrifice their time and ``python-telegram-bot`` is no different. To make participation as pleasant as possible, this project adheres to the `Code of Conduct`_ by the Python Software Foundation.
+
+Setting things up
+-----------------
+
+1. Fork the ``python-telegram-bot`` repository to your GitHub account.
+
+2. Clone your forked repository of ``python-telegram-bot`` to your computer:
+
+   ``$ git clone https://github.com/<your username>/python-telegram-bot``
+
+   ``$ cd python-telegram-bot``
+
+3. Add a track to the original repository:
+
+   ``$ git remote add upstream https://github.com/python-telegram-bot/python-telegram-bot``
+
+4. Install dependencies:
+
+   ``$ pip install -r requirements.txt -r requirements-dev.txt``
+
+
+5. Install pre-commit hooks:
+
+   ``$ pre-commit install``
+
+Finding something to do
+-----------------------
+
+If you already know what you'd like to work on, you can skip this section.
+
+If you have an idea for something to do, first check if it's already been filed on the `issue tracker`_. If so, add a comment to the issue saying you'd like to work on it, and we'll help you get started! Otherwise, please file a new issue and assign yourself to it.
+
+Another great way to start contributing is by writing tests. Tests are really important because they help prevent developers from accidentally breaking existing code, allowing them to build cool things faster. If you're interested in helping out, let the development team know by posting to the `developers' mailing list`_, and we'll help you get started.
+
+Instructions for making a code change
+-------------------------------------
+
+The central development branch is ``master``, which should be clean and ready for release at any time. In general, all changes should be done as feature branches based off of ``master``.
+
+Here's how to make a one-off code change.
+
+1. **Choose a descriptive branch name.** It should be lowercase, hyphen-separated, and a noun describing the change (so, ``fuzzy-rules``, but not ``implement-fuzzy-rules``). Also, it shouldn't start with ``hotfix`` or ``release``.
+
+2. **Create a new branch with this name, starting from** ``master``. In other words, run:
+
+   ``$ git fetch upstream``
+
+   ``$ git checkout master``
+
+   ``$ git merge upstream/master``
+
+   ``$ git checkout -b your-branch-name``
+
+3. **Make a commit to your feature branch**. Each commit should be self-contained and have a descriptive commit message that helps other developers understand why the changes were made.
+
+   - You can refer to relevant issues in the commit message by writing, e.g., "#105".
+
+   - Your code should adhere to the `PEP 8 Style Guide`_, with the exception that we have a maximum line length of 99.
+
+   - For consistency, please conform to `Google Python Style Guide`_ and `Google Python Style Docstrings`_. In addition, code should be formatted consistently with other code around it.
+
+   - The following exceptions to the above (Google's) style guides applies:
+
+        - Documenting types of global variables and complex types of class members can be done using the Sphinx docstring convention.
+
+   - Please ensure that the code you write is well-tested.
+
+   - Don’t break backward compatibility.
+
+   - Add yourself to the AUTHORS.rst_ file in an alphabetical fashion.
+
+   - Before making a commit ensure that all automated tests still pass:
+
+      ``$ make test``
+
+   - To actually make the commit (this will trigger tests for yapf, lint and pep8 automatically):
+
+      ``$ git add your-file-changed.py``
+
+        - yapf may change code formatting, make sure to re-add them to your commit.
+
+      ``$ git commit -a -m "your-commit-message-here"``
+
+   - Finally, push it to your GitHub fork, run:
+
+      ``$ git push origin your-branch-name``
+
+4. **When your feature is ready to merge, create a pull request.**
+
+   - Go to your fork on GitHub, select your branch from the dropdown menu, and click "New pull request".
+
+   - Add a descriptive comment explaining the purpose of the branch (e.g. "Add the new API feature to create inline bot queries."). This will tell the reviewer what the purpose of the branch is.
+
+   - Click "Create pull request". An admin will assign a reviewer to your commit.
+
+5. **Address review comments until all reviewers give LGTM ('looks good to me').**
+
+   - When your reviewer has reviewed the code, you'll get an email. You'll need to respond in two ways:
+
+       - Make a new commit addressing the comments you agree with, and push it to the same branch. Ideally, the commit message would explain what the commit does (e.g. "Fix lint error"), but if there are lots of disparate review comments, it's fine to refer to the original commit message and add something like "(address review comments)".
+
+       - In addition, please reply to each comment. Each reply should be either "Done" or a response explaining why the corresponding suggestion wasn't implemented. All comments must be resolved before LGTM can be given.
+
+   - Resolve any merge conflicts that arise. To resolve conflicts between 'your-branch-name' (in your fork) and 'master' (in the ``python-telegram-bot`` repository), run:
+
+      ``$ git checkout your-branch-name``
+
+      ``$ git fetch upstream``
+
+      ``$ git merge upstream/master``
+
+      ``$ ...[fix the conflicts]...``
+
+      ``$ ...[make sure the tests pass before committing]...``
+
+      ``$ git commit -a``
+
+      ``$ git push origin your-branch-name``
+
+   - At the end, the reviewer will merge the pull request.
+
+6. **Tidy up!** Delete the feature branch from both your local clone and the GitHub repository:
+
+   ``$ git branch -D your-branch-name``
+
+   ``$ git push origin --delete your-branch-name``
+
+7. **Celebrate.** Congratulations, you have contributed to ``python-telegram-bot``!
+
+Style commandments
+==================
+
+Specific commandments
+---------------------
+
+- Avoid using "double quotes" where you can reasonably use 'single quotes'.
+
+AssertEqual argument order
+--------------------------
+
+assertEqual method's arguments should be in ('actual', 'expected') order.
+
+Properly calling callables
+--------------------------
+
+Methods, functions and classes can specify optional parameters (with default
+values) using Python's keyword arg syntax. When providing a value to such a
+callable we prefer that the call also uses keyword arg syntax. For example::
+
+    # GOOD
+    f(0, optional=True)
+
+    # BAD
+    f(0, True)
+
+This gives us the flexibility to re-order arguments and more importantly
+to add new required arguments. It's also more explicit and easier to read.
+
+Properly defining optional arguments
+------------------------------------
+
+It's always good to not initialize optional arguments at class creation, 
+instead use ``**kwargs`` to get them. It's well known Telegram API can 
+change without notice, in that case if a new argument is added it won't 
+break the API classes. For example::
+
+    # GOOD
+    def __init__(self, id, name, **kwargs):
+       self.last_name = kwargs.get('last_name', '')
+
+    # BAD
+    def __init__(self, id, name, last_name=''):
+       self.last_name = last_name
+
+
+.. _`Code of Conduct`: https://www.python.org/psf/codeofconduct/
+.. _`issue tracker`: https://github.com/python-telegram-bot/python-telegram-bot/issues
+.. _`developers' mailing list`: mailto:devs@python-telegram-bot.org
+.. _`PEP 8 Style Guide`: https://www.python.org/dev/peps/pep-0008/
+.. _`Google Python Style Guide`: https://google-styleguide.googlecode.com/svn/trunk/pyguide.html
+.. _`Google Python Style Docstrings`: http://sphinx-doc.org/latest/ext/example_google.html
+.. _AUTHORS.rst: https://github.com/python-telegram-bot/python-telegram-bot/blob/master/AUTHORS.rst

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,31 @@
+<!--
+Thanks for reporting issues of python-telegram-bot!
+To make it easier for us to help you please enter detailed information below.
+-->
+### Steps to reproduce
+1.
+
+2.
+
+3.
+
+### Expected behaviour
+Tell us what should happen
+
+### Actual behaviour
+Tell us what happens instead
+
+### Configuration
+**Operating System:**
+
+
+**Version of Python:**
+
+``$ python -V``
+
+**Version of python-telegram-bot:**
+
+``$ python -c 'import telegram; print(telegram.__version__)'``
+
+### Logs
+Insert logs here (if necessary)

.gitignore

@@ -61,3 +61,10 @@ target/
 
 # Sublime Text 2
 *.sublime*
+
+# unitests files
+telegram.mp3
+telegram.mp4
+telegram.ogg
+telegram.png
+telegram.webp

.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+-   repo: git://github.com/pre-commit/mirrors-yapf
+    sha: 316b795b2f32cbe80047aff7e842b72368d5a2c1
+    hooks:
+    -   id: yapf
+        files: ^(telegram|tests)/.*\.py$
+-   repo: git://github.com/pre-commit/pre-commit-hooks
+    sha: 6dfcb89af3c9b4d172cc2e5a8a2fa0f54615a338
+    hooks:
+    -   id: flake8
+        files: ^telegram/.*\.py$
+-   repo: git://github.com/pre-commit/mirrors-pylint
+    sha: 4de6c8dfadef1a271a814561ce05b8bc1c446d22
+    hooks:
+    -   id: pylint
+        files: ^telegram/.*\.py$
+        args:
+        - --errors-only
+        - --disable=no-name-in-module,import-error

.travis.yml

@@ -4,12 +4,15 @@ python:
   - "2.7"
   - "3.3"
   - "3.4"
+  - "3.5"
   - "pypy"
   - "pypy3"
 install:
   - pip install coveralls
   - pip install -r requirements.txt
+  - pip install -r requirements-dev.txt
 script:
-  nosetests --with-coverage --cover-package telegram/
+  - nosetests -v --with-flaky --no-flaky-report --with-coverage --cover-package=telegram/
+  - 'if [ $TRAVIS_PYTHON_VERSION != 2.6 ] && [ $TRAVIS_PYTHON_VERSION != 3.3 ] && [ $TRAVIS_PYTHON_VERSION != pypy3 ]; then pre-commit run --all-files; fi'
 after_success:
   coveralls

AUTHORS.rst

@@ -9,15 +9,21 @@ Contributors
 The following wonderful people contributed directly or indirectly to this project:
 
 - `Avanatiker <https://github.com/Avanatiker>`_
+- `Balduro <https://github.com/Balduro>`_
 - `bimmlerd <https://github.com/bimmlerd>`_
 - `ErgoZ Riftbit Vaper <https://github.com/ergoz>`_
 - `franciscod <https://github.com/franciscod>`_
 - `JASON0916 <https://github.com/JASON0916>`_
 - `jh0ker <https://github.com/jh0ker>`_
 - `JRoot3D <https://github.com/JRoot3D>`_
+- `jlmadurga <https://github.com/jlmadurga>`_
 - `macrojames <https://github.com/macrojames>`_
+- `naveenvhegde <https://github.com/naveenvhegde>`_
 - `njittam <https://github.com/njittam>`_
+- `Noam Meltzer <https://github.com/tsnoam>`_
+- `Oleg Shlyazhko <https://github.com/ollmer>`_
 - `Rahiel Kasim <https://github.com/rahiel>`_
+- `Shelomentsev D <https://github.com/shelomentsevd>`_
 - `sooyhwang <https://github.com/sooyhwang>`_
 - `wjt <https://github.com/wjt>`_
 

CHANGES.rst

@@ -1,189 +1,413 @@
-2015-11-10
-  Released 2.9
-  Emoji class now uses bytes_to_native_str from future 3rd party lib
-  Make user_from optional to work with channels channels
-  Raise exception if Telegram times out on long-polling
-  *Special thanks to @jh0ker for all hard work*
+**2016-06-29**
+
+*Released 4.3.1*
+
+- Update wrong requirement: ``urllib3>=1.10``
+
+**2016-06-28**
+
+*Released 4.3*
+
+- Use ``urllib3.PoolManager`` for connection re-use
+- Rewrite ``run_async`` decorator to re-use threads
+- New requirements: ``urllib3`` and ``certifi``
+
+**2016-06-10**
+
+*Released 4.2.1*
+
+- Fix ``CallbackQuery.to_dict()`` bug (thanks to @jlmadurga)
+- Fix ``editMessageText`` exception when receiving a ``CallbackQuery``
+
+**2016-05-28**
+
+*Released 4.2*
+
+- Implement Bot API 2.1
+- Move ``botan`` module to ``telegram.contrib``
+- New exception type: ``BadRequest``
+
+**2016-05-22**
+
+*Released 4.1.2*
+
+- Fix ``MessageEntity`` decoding with Bot API 2.1 changes
+
+**2016-05-16**
+
+*Released 4.1.1*
+
+- Fix deprecation warning in ``Dispatcher``
+
+**2016-05-15**
+
+*Released 4.1*
+
+- Implement API changes from May 6, 2016
+- Fix bug when ``start_polling`` with ``clean=True``
+- Methods now have snake_case equivalent, for example ``telegram.Bot.send_message`` is the same as ``telegram.Bot.sendMessage``
+
+**2016-05-01**
+
+*Released 4.0.3*
+
+- Add missing attribute ``location`` to ``InlineQuery``
+
+**2016-04-29**
+
+*Released 4.0.2*
+
+- Bugfixes
+- ``KeyboardReplyMarkup`` now accepts ``str`` again
+
+**2016-04-27**
+
+*Released 4.0.1*
+
+- Implement Bot API 2.0
+- Almost complete recode of ``Dispatcher``
+- Please read the `Transition Guide to 4.0 <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Transition-guide-to-Version-4.0>`_
+- **Changes from 4.0rc1**
+    - The syntax of filters for ``MessageHandler`` (upper/lower cases)
+    - Handler groups are now identified by ``int`` only, and ordered
+- **Note:** v4.0 has been skipped due to a PyPI accident
+
+**2016-04-22**
+
+*Released 4.0rc1*
+
+- Implement Bot API 2.0
+- Almost complete recode of ``Dispatcher``
+- Please read the `Transistion Guide to 4.0 <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Transistion-guide-to-Version-4.0>`_
+
+**2016-03-22**
+
+*Released 3.4*
+
+- Move ``Updater``, ``Dispatcher`` and ``JobQueue`` to new ``telegram.ext`` submodule (thanks to @rahiel)
+- Add ``disable_notification`` parameter (thanks to @aidarbiktimirov)
+- Fix bug where commands sent by Telegram Web would not be recognized (thanks to @shelomentsevd)
+- Add option to skip old updates on bot startup
+- Send files from ``BufferedReader``
+
+**2016-02-28**
+
+*Released 3.3*
+
+- Inline bots
+- Send any file by URL
+- Specialized exceptions: ``Unauthorized``, ``InvalidToken``, ``NetworkError`` and ``TimedOut``
+- Integration for botan.io (thanks to @ollmer)
+- HTML Parsemode (thanks to @jlmadurga)
+- Bugfixes and under-the-hood improvements
+
+**Very special thanks to Noam Meltzer (@tsnoam) for all of his work!**
+
+**2016-01-09**
+
+*Released 3.3b1*
+
+- Implement inline bots (beta)
+
+**2016-01-05**
+
+*Released 3.2.0*
+
+- Introducing ``JobQueue`` (original author: @franciscod)
+- Streamlining all exceptions to ``TelegramError`` (Special thanks to @tsnoam)
+- Proper locking of ``Updater`` and ``Dispatcher`` ``start`` and ``stop`` methods
+- Small bugfixes
+
+**2015-12-29**
+
+*Released 3.1.2*
+
+- Fix custom path for file downloads
+- Don't stop the dispatcher thread on uncaught errors in handlers
+
+**2015-12-21**
+
+*Released 3.1.1*
+
+- Fix a bug where asynchronous handlers could not have additional arguments
+- Add ``groups`` and ``groupdict`` as additional arguments for regex-based handlers
+
+**2015-12-16**
+
+*Released 3.1.0*
+
+- The ``chat``-field in ``Message`` is now of type ``Chat``. (API update Oct 8 2015)
+- ``Message`` now contains the optional fields ``supergroup_chat_created``, ``migrate_to_chat_id``, ``migrate_from_chat_id`` and ``channel_chat_created``. (API update Nov 2015)
+
+**2015-12-08**
+
+*Released 3.0.0*
+
+- Introducing the ``Updater`` and ``Dispatcher`` classes
+
+**2015-11-11**
+
+*Released 2.9.2*
+
+- Error handling on request timeouts has been improved
+
+**2015-11-10**
+
+*Released 2.9.1*
+
+- Add parameter ``network_delay`` to Bot.getUpdates for slow connections
+
+**2015-11-10**
+
+*Released 2.9*
+
+- Emoji class now uses ``bytes_to_native_str`` from ``future`` 3rd party lib
+- Make ``user_from`` optional to work with channels
+- Raise exception if Telegram times out on long-polling
+
+*Special thanks to @jh0ker for all hard work*
 
 
-2015-10-08
-  Released 2.8.7
-  Type as optional for GroupChat class
+**2015-10-08**
+
+*Released 2.8.7*
+
+- Type as optional for ``GroupChat`` class
 
 
-2015-10-08
-  Released 2.8.6
-  Adds type to User and GroupChat classes (pre-release Telegram feature)
+**2015-10-08**
+
+*Released 2.8.6*
+
+- Adds type to ``User`` and ``GroupChat`` classes (pre-release Telegram feature)
 
 
-2015-09-24
-  Released 2.8.5
-  Handles HTTP Bad Gateway (503) errors on request
-  Fixes regression on Audio and Document for unicode fields
+**2015-09-24**
+
+*Released 2.8.5*
+
+- Handles HTTP Bad Gateway (503) errors on request
+- Fixes regression on ``Audio`` and ``Document`` for unicode fields
 
 
-2015-09-20
-  Released 2.8.4
-  getFile and File.download is now fully supported
+**2015-09-20**
+
+*Released 2.8.4*
+
+- ``getFile`` and ``File.download`` is now fully supported
 
 
-2015-09-10
-  Released 2.8.3
-  Moved Bot._requestURL to its own class (telegram.utils.request)
-  Much better, such wow, Telegram Objects tests
-  Add consistency for str properties on Telegram Objects
-  Better design to test if chat_id is invalid
-  Add ability to set custom filename on Bot.sendDocument(..,filename='')
-  Fix Sticker as InputFile
-  Send JSON requests over urlencoded post data
-  Markdown support for Bot.sendMessage(..., parse_mode=ParseMode.MARKDOWN)
-  Refactor of TelegramError class (no more handling IOError or URLError)
+**2015-09-10**
+
+*Released 2.8.3*
+
+- Moved ``Bot._requestURL`` to its own class (``telegram.utils.request``)
+- Much better, such wow, Telegram Objects tests
+- Add consistency for ``str`` properties on Telegram Objects
+- Better design to test if ``chat_id`` is invalid
+- Add ability to set custom filename on ``Bot.sendDocument(..,filename='')``
+- Fix Sticker as ``InputFile``
+- Send JSON requests over urlencoded post data
+- Markdown support for ``Bot.sendMessage(..., parse_mode=ParseMode.MARKDOWN)``
+- Refactor of ``TelegramError`` class (no more handling ``IOError`` or ``URLError``)
 
 
-2015-09-05
-  Released 2.8.2
-  Fix regression on Telegram ReplyMarkup
-  Add certificate to is_inputfile method
+**2015-09-05**
+
+*Released 2.8.2*
+
+- Fix regression on Telegram ReplyMarkup
+- Add certificate to ``is_inputfile`` method
 
 
-2015-09-05
-  Released 2.8.1
-  Fix regression on Telegram objects with thumb properties
+**2015-09-05**
+
+*Released 2.8.1*
+
+- Fix regression on Telegram objects with thumb properties
 
 
-2015-09-04
-  Released 2.8
-  TelegramError when chat_id is empty for send* methods
-  setWebhook now supports sending self-signed certificate
-  Huge redesign of existing Telegram classes
-  Added support for PyPy
-  Added docstring for existing classes
+**2015-09-04**
+
+*Released 2.8*
+
+- TelegramError when ``chat_id`` is empty for send* methods
+- ``setWebhook`` now supports sending self-signed certificate
+- Huge redesign of existing Telegram classes
+- Added support for PyPy
+- Added docstring for existing classes
 
 
-2015-08-19
-  Released 2.7.1
-  Fixed JSON serialization for message
+**2015-08-19**
+
+*Released 2.7.1*
+
+- Fixed JSON serialization for ``message``
 
 
-2015-08-17
-  Released 2.7
-  Added support for Voice object and sendVoice method
-  Due backward compatibility performer or/and title will be required for sendAudio
-  Fixed JSON serialization when forwarded message
+**2015-08-17**
+
+*Released 2.7*
+
+- Added support for ``Voice`` object and ``sendVoice`` method
+- Due backward compatibility performer or/and title will be required for ``sendAudio``
+- Fixed JSON serialization when forwarded message
 
 
-2015-08-15
-  Released 2.6.1
-  Fixed parsing image header issue on < Python 2.7.3
+**2015-08-15**
+
+*Released 2.6.1*
+
+- Fixed parsing image header issue on < Python 2.7.3
 
 
-2015-08-14
-  Released 2.6.0
-  Depreciation of require_authentication and clearCredentials methods
-  Giving AUTHORS the proper credits for their contribution for this project
-  Message.date and Message.forward_date are now datetime objects
+**2015-08-14**
+
+*Released 2.6.0*
+
+- Depreciation of ``require_authentication`` and ``clearCredentials`` methods
+- Giving ``AUTHORS`` the proper credits for their contribution for this project
+- ``Message.date`` and ``Message.forward_date`` are now ``datetime`` objects
 
 
-2015-08-12
-  Released 2.5.3
-  telegram.Bot now supports to be unpickled
+**2015-08-12**
+
+*Released 2.5.3*
+
+- ``telegram.Bot`` now supports to be unpickled
 
 
-2015-08-11
-  Released 2.5.2
-  New changes from Telegram Bot API have been applied
-  telegram.Bot now supports to be pickled
-  Return empty str instead None when message.text is empty
+**2015-08-11**
+
+*Released 2.5.2*
+
+- New changes from Telegram Bot API have been applied
+- ``telegram.Bot`` now supports to be pickled
+- Return empty ``str`` instead ``None`` when ``message.text`` is empty
 
 
-2015-08-10
-  Released 2.5.1
-  Moved from GPLv2 to LGPLv3
+**2015-08-10**
+
+*Released 2.5.1*
+
+- Moved from GPLv2 to LGPLv3
 
 
-2015-08-09
-  Released 2.5
-  Fixes logging calls in API
+**2015-08-09**
+
+*Released 2.5*
+
+- Fixes logging calls in API
 
 
-2015-08-08
-  Released 2.4
-  Fixes Emoji class for Python 3
-  PEP8 improvements
+**2015-08-08**
+
+*Released 2.4*
+
+- Fixes ``Emoji`` class for Python 3
+- ``PEP8`` improvements
 
 
-2015-08-08
-  Released 2.3
-  Fixes ForceReply class
-  Remove logging.basicConfig from library
+**2015-08-08**
+
+*Released 2.3*
+
+- Fixes ``ForceReply`` class
+- Remove ``logging.basicConfig`` from library
 
 
-2015-07-25
-  Released 2.2
-  Allows debug=True when initializing telegram.Bot
+**2015-07-25**
+
+*Released 2.2*
+
+- Allows ``debug=True`` when initializing ``telegram.Bot``
 
 
-2015-07-20
-  Released 2.1
-  Fix to_dict for Document and Video
+**2015-07-20**
+
+*Released 2.1*
+
+- Fix ``to_dict`` for ``Document`` and ``Video``
 
 
-2015-07-19
-  Released 2.0
-  Fixes bugs
-  Improves __str__ over to_json()
-  Creates abstractclass TelegramObject
+**2015-07-19**
+
+*Released 2.0*
+
+- Fixes bugs
+- Improves ``__str__`` over ``to_json()``
+- Creates abstract class ``TelegramObject``
 
 
-2015-07-15
-  Released 1.9
-  Python 3 officially supported
-  PEP8 improvements
+**2015-07-15**
+
+*Released 1.9*
+
+- Python 3 officially supported
+- ``PEP8`` improvements
 
 
-2015-07-12
-  Released 1.8
-  Fixes crash when replying an unicode text message (special thanks to JRoot3D)
+**2015-07-12**
+
+*Released 1.8*
+
+- Fixes crash when replying an unicode text message (special thanks to JRoot3D)
 
 
-2015-07-11
-  Released 1.7
-  Fixes crash when username is not defined on chat (special thanks to JRoot3D)
+**2015-07-11**
+
+*Released 1.7*
+
+- Fixes crash when ``username`` is not defined on ``chat`` (special thanks to JRoot3D)
 
 
-2015-07-10
-  Released 1.6
-  Improvements for GAE support
+**2015-07-10**
+
+*Released 1.6*
+
+- Improvements for GAE support
 
 
-2015-07-10
-  Released 1.5
-  Fixes randomly unicode issues when using InputFile
+**2015-07-10**
+
+*Released 1.5*
+
+- Fixes randomly unicode issues when using ``InputFile``
 
 
-2015-07-10
-  Released 1.4
-  requests lib is no longer required
-  Google App Engine (GAE) is supported
+**2015-07-10**
+
+*Released 1.4*
+
+- ``requests`` lib is no longer required
+- Google App Engine (GAE) is supported
 
 
-2015-07-10
-  Released 1.3
-  Added support to setWebhook (special thanks to macrojames)
+**2015-07-10**
+
+*Released 1.3*
+
+- Added support to ``setWebhook`` (special thanks to macrojames)
 
 
-2015-07-09
-  Released 1.2
-  CustomKeyboard classes now available
-  Emojis available
-  PEP8 improvements
+**2015-07-09**
+
+*Released 1.2*
+
+- ``CustomKeyboard`` classes now available
+- Emojis available
+- ``PEP8`` improvements
 
 
-2015-07-08
-  Released 1.1
-  PyPi package now available
+**2015-07-08**
+
+*Released 1.1*
+
+- PyPi package now available
 
 
-2015-07-08
-  Released 1.0
-  Initial checkin of python-telegram-bot
+**2015-07-08**
+
+*Released 1.0*
+
+- Initial checkin of python-telegram-bot

CONTRIBUTING.rst

@@ -1,39 +0,0 @@
-How To Contribute
-=================
-
-Every open source project lives from the generous help by contributors that sacrifice their time and ``python-telegram-bot`` is no different.
-
-To make participation as pleasant as possible, this project adheres to the `Code of Conduct`_ by the Python Software Foundation.
-
-Here are a few guidelines to get you started:
-
-- Add yourself to the AUTHORS.rst_ file in an alphabetical fashion.
-  Every contribution is valuable and shall be credited.
-- If your change is noteworthy, add an entry to the CHANGES_.
-- No contribution is too small; please submit as many fixes for typos and grammar bloopers as you can!
-- Don’t break backward compatibility.
-- *Always* add tests and docs for your code.
-  This is a hard rule; patches with missing tests or documentation won’t be merged.
-  If a feature is not tested or documented, it doesn’t exist.
-- Obey `PEP 8`_ and `PEP 257`_.
-- Follow `Google Python Style Guide`_ and `Google Python Style Docstrings`_.
-- Write `good commit messages`_.
-
-.. note::
-   If you have something great but aren’t sure whether it adheres -- or even can adhere -- to the rules above: **please submit a pull request anyway**!
-
-   In the best case, we can mold it into something, in the worst case the pull request gets politely closed.
-   There’s absolutely nothing to fear.
-
-Thank you for considering to contribute to ``python-telegram-bot``!
-If you have any question or concerns, feel free to reach out to me.
-
-
-.. _`PEP 8`: https://www.python.org/dev/peps/pep-0008/
-.. _`PEP 257`: https://www.python.org/dev/peps/pep-0257/
-.. _`good commit messages`: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
-.. _`Code of Conduct`: https://www.python.org/psf/codeofconduct/
-.. _`Google Python Style Guide`: https://google-styleguide.googlecode.com/svn/trunk/pyguide.html
-.. _`Google Python Style Docstrings`: http://sphinx-doc.org/latest/ext/example_google.html
-.. _CHANGES: https://github.com/leandrotoledo/python-telegram-bot/blob/master/CHANGES
-.. _AUTHORS.rst: https://github.com/leandrotoledo/python-telegram-bot/blob/master/AUTHORS.rst

MANIFEST.in

@@ -1 +1 @@
-include LICENSE LICENSE.lesser Makefile
+include LICENSE LICENSE.lesser Makefile requirements.txt

Makefile

@@ -1,4 +1,12 @@
-.PHONY: clean pep8 lint test install
+.DEFAULT_GOAL := help
+.PHONY: clean pep257 pep8 yapf lint test install
+
+PYLINT          := pylint
+NOSETESTS       := nosetests
+PEP257          := pep257
+PEP8            := flake8
+YAPF            := yapf
+PIP             := pip
 
 clean:
 	rm -fr build
@@ -6,22 +14,39 @@ clean:
 	find . -name '*.pyc' -exec rm -f {} \;
 	find . -name '*.pyo' -exec rm -f {} \;
 	find . -name '*~' -exec rm -f {} \;
+	find . -regex "./telegram.\(mp3\|mp4\|ogg\|png\|webp\)" -exec rm {} \;
+
+pep257:
+	$(PEP257) telegram
 
 pep8:
-	flake8 telegram
+	$(PEP8) telegram
+
+yapf:
+	$(YAPF) -r telegram
 
 lint:
-	pylint -E telegram
+	$(PYLINT) -E telegram --disable=no-name-in-module,import-error
 
 test:
-	nosetests
+	$(NOSETESTS) -v
 
 install:
-	pip install -r requirements.txt
+	$(PIP)  install -r requirements.txt -r requirements-dev.txt
 
 help:
 	@echo "Available targets:"
 	@echo "- clean       Clean up the source directory"
+	@echo "- pep257      Check docstring style with pep257"
 	@echo "- pep8        Check style with flake8"
 	@echo "- lint        Check style with pylint"
+	@echo "- yapf        Check style with yapf"
 	@echo "- test        Run tests"
+	@echo
+	@echo "Available variables:"
+	@echo "- PYLINT      default: $(PYLINT)"
+	@echo "- NOSETESTS   default: $(NOSETESTS)"
+	@echo "- PEP257      default: $(PEP257)"
+	@echo "- PEP8        default: $(PEP8)"
+	@echo "- YAPF        default: $(YAPF)"
+	@echo "- PIP         default: $(PIP)"

README.rst

@@ -1,38 +1,47 @@
-Python Telegram Bot
+.. image:: https://github.com/python-telegram-bot/logos/blob/master/logo-text/png/ptb-logo-text_768.png?raw=true
+   :align: center
+   :target: https://github.com/python-telegram-bot/logos
+   :alt: python-telegram-bot Logo
 
-A Python wrapper around the Telegram Bot API.
+Not **just** a Python wrapper around the Telegram Bot API
 
-*Stay tuned for library updates and new releases on our* `Telegram Channel <http://telegram.me/pythontelegrambotchannel>`_.
-
-By `Leandro Toledo <leandrotoledodesouza@gmail.com>`_
+*Stay tuned for library updates and new releases on our* `Telegram Channel <https://telegram.me/pythontelegrambotchannel>`_.
 
 .. image:: https://img.shields.io/pypi/v/python-telegram-bot.svg
    :target: https://pypi.python.org/pypi/python-telegram-bot
    :alt: PyPi Package Version
 
-.. image:: https://img.shields.io/pypi/dm/python-telegram-bot.svg
+.. image:: https://img.shields.io/pypi/pyversions/python-telegram-bot.svg
    :target: https://pypi.python.org/pypi/python-telegram-bot
-   :alt: PyPi Package Monthly Download
+   :alt: Supported python versions
 
-.. image:: https://readthedocs.org/projects/python-telegram-bot/badge/?version=latest
-   :target: https://readthedocs.org/projects/python-telegram-bot/?badge=latest
+.. image:: https://img.shields.io/badge/docs-latest-af1a97.svg
+   :target: https://pythonhosted.org/python-telegram-bot/
    :alt: Documentation Status
 
 .. image:: https://img.shields.io/pypi/l/python-telegram-bot.svg
-   :target: http://www.gnu.org/licenses/lgpl-3.0.html
+   :target: https://www.gnu.org/licenses/lgpl-3.0.html
    :alt: LGPLv3 License
 
-.. image:: https://travis-ci.org/leandrotoledo/python-telegram-bot.svg?branch=master
-   :target: https://travis-ci.org/leandrotoledo/python-telegram-bot
+.. image:: https://travis-ci.org/python-telegram-bot/python-telegram-bot.svg?branch=master
+   :target: https://travis-ci.org/python-telegram-bot/python-telegram-bot
    :alt: Travis CI Status
 
-.. image:: https://codeclimate.com/github/leandrotoledo/python-telegram-bot/badges/gpa.svg
-   :target: https://codeclimate.com/github/leandrotoledo/python-telegram-bot
+.. image:: https://codeclimate.com/github/python-telegram-bot/python-telegram-bot/badges/gpa.svg
+   :target: https://codeclimate.com/github/python-telegram-bot/python-telegram-bot
    :alt: Code Climate
 
-.. image:: https://coveralls.io/repos/leandrotoledo/python-telegram-bot/badge.svg?branch=master&service=github
-   :target: https://coveralls.io/github/leandrotoledo/python-telegram-bot?branch=master
+.. image:: https://coveralls.io/repos/python-telegram-bot/python-telegram-bot/badge.svg?branch=master&service=github
+   :target: https://coveralls.io/github/python-telegram-bot/python-telegram-bot?branch=master
    :alt: Coveralls
+   
+.. image:: http://isitmaintained.com/badge/resolution/python-telegram-bot/python-telegram-bot.svg
+   :target: http://isitmaintained.com/project/python-telegram-bot/python-telegram-bot
+   :alt: Average time to resolve an issue
+
+.. image:: https://img.shields.io/badge/Telegram-Group-blue.svg
+   :target: https://telegram.me/pythontelegrambotgroup
+   :alt: Telegram Group
 
 =================
 Table of contents
@@ -40,251 +49,147 @@ Table of contents
 
 - `Introduction`_
 
-- `Status`_
-
-  1. `Telegram API support`_
-
-  2. `Python Version support`_
+- `Telegram API support`_
 
 - `Installing`_
 
-- `Getting the code`_
-
 - `Getting started`_
 
-  1. `API`_
+  #. `Learning by example`_
 
-  2. `Logging`_
+  #. `Logging`_
 
-  3. `Examples`_
+  #. `Documentation`_
 
-  4. `Documentation`_
+- `Getting help`_
+
+- `Contributing`_
 
 - `License`_
 
-- `Contact`_
+============
+Introduction
+============
 
-- `TODO`_
+This library provides a pure Python interface for the
+`Telegram Bot API <https://core.telegram.org/bots/api>`_.
+It works with Python versions from 2.6+ (**Note:** Support for 2.6 will be dropped at some point
+this year. 2.7 will still be supported).
+It also works with `Google App Engine <https://cloud.google.com/appengine>`_.
 
-===============
-_`Introduction`
-===============
+In addition to the pure API implementation, this library features a number of high-level classes to
+make the development of bots easy and straightforward. These classes are contained in the
+``telegram.ext`` submodule.
 
-This library provides a pure Python interface for the `Telegram Bot API <https://core.telegram.org/bots/api>`_. It works with Python versions from 2.6+. It also works with `Google App Engine <https://cloud.google.com/appengine>`_.
+====================
+Telegram API support
+====================
 
-=========
-_`Status`
-=========
+As of **28. May 2016**, all types and methods of the Telegram Bot API are supported.
 
------------------------
-_`Telegram API support`
------------------------
+==========
+Installing
+==========
 
-========================= ============
-Telegram Bot API Method   *Supported?*
-========================= ============
-getMe                     Yes
-sendMessage               Yes
-forwardMessage            Yes
-sendPhoto                 Yes
-sendAudio                 Yes
-sendDocument              Yes
-sendSticker               Yes
-sendVideo                 Yes
-sendVoice                 Yes
-sendLocation              Yes
-sendChatAction            Yes
-getUpdates                Yes
-getUserProfilePhotos      Yes
-getFile                   Yes
-setWebhook                Yes
-========================= ============
+You can install or upgrade python-telegram-bot with:
 
--------------------------
-_`Python Version support`
--------------------------
-
-============== ============
-Python Version *Supported?*
-============== ============
-2.6            Yes
-2.7            Yes
-3.3            Yes
-3.4            Yes
-PyPy           Yes
-PyPy3          Yes
-============== ============
-
-=============
-_`Installing`
-=============
-
-You can install python-telegram-bot using::
-
-    $ pip install python-telegram-bot
-
-Or upgrade to the latest version::
+.. code:: shell
 
     $ pip install python-telegram-bot --upgrade
 
-===================
-_`Getting the code`
-===================
+===============
+Getting started
+===============
 
-The code is hosted at https://github.com/leandrotoledo/python-telegram-bot
+Our Wiki contains a lot of resources to get you started with ``python-telegram-bot``:
 
-Check out the latest development version anonymously with::
+- `Introduction to the API <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Introduction-to-the-API>`_
+- Tutorial: `Your first Bot <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Extensions-%E2%80%93-Your-first-Bot>`_
 
-    $ git clone https://github.com/leandrotoledo/python-telegram-bot
-    $ cd python-telegram-bot
+Other references:
 
-Run tests:
+- `Telegram API documentation <https://core.telegram.org/bots/api>`_
+- `python-telegram-bot documentation <https://pythonhosted.org/python-telegram-bot/>`_
 
-    $ make test
+-------------------
+Learning by example
+-------------------
 
-To see other options available, run:
+We believe that the best way to learn and understand this simple package is by example. So here
+are some examples for you to review. Even if it's not your approach for learning, please take a
+look at ``echobot2`` (below), it is de facto the base for most of the bots out there. Best of all,
+the code for these examples are released to the public domain, so you can start by grabbing the
+code and building on top of it.
 
-    $ make help
+- `echobot2 <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/echobot2.py>`_ replies back messages.
 
-==================
-_`Getting started`
-==================
+- `inlinebot <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/inlinebot.py>`_ basic example of an `inline bot <https://core.telegram.org/bots/inline>`_.
 
-View the last release API documentation at: https://core.telegram.org/bots/api
+- `state machine bot <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/state_machine_bot.py>`_ keeps the state for individual users, useful for multipart conversations.
 
-------
-_`API`
-------
+- `timerbot <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/timerbot.py>`_ uses the ``JobQueue`` to send timed messages.
 
-The API is exposed via the ``telegram.Bot`` class.
+- `echobot <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/examples/legacy/echobot.py>`_ uses only the pure API to echo messages.
 
-To generate an Access Token you have to talk to `BotFather <https://telegram.me/botfather>`_ and follow a few simple steps (described `here <https://core.telegram.org/bots#botfather>`_).
+Look at the examples on the `wiki <https://github.com/python-telegram-bot/python-telegram-bot/wiki/Examples>`_ to see other bots the community has built.
 
-For full details see the `Bots: An introduction for developers <https://core.telegram.org/bots>`_.
+-------
+Logging
+-------
 
-To create an instance of the ``telegram.Bot``::
+This library uses the ``logging`` module. To set up logging to standard output, put:
 
-    >>> import telegram
-    >>> bot = telegram.Bot(token='token')
+.. code:: python
 
-To see if your credentials are successful::
+    import logging
+    logging.basicConfig(level=logging.DEBUG,
+                        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
-    >>> print bot.getMe()
-    {"first_name": "Toledo's Palace Bot", "username": "ToledosPalaceBot"}
+at the beginning of your script.
 
-Bots can't initiate conversations with users. A user must either add them to a group or send them a message first. People can use ``telegram.me/<bot_username>`` links or username search to find your bot.
+You can also use logs in your application by calling ``logging.getLogger()`` and setting the log level you want:
 
-To fetch text messages sent to your Bot::
+.. code:: python
 
-    >>> updates = bot.getUpdates()
-    >>> print [u.message.text for u in updates]
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
 
-To fetch images sent to your Bot::
+If you want DEBUG logs instead:
 
-    >>> updates = bot.getUpdates()
-    >>> print [u.message.photo for u in updates if u.message.photo]
+.. code:: python
 
-To reply messages you'll always need the chat_id::
+    logger.setLevel(logging.DEBUG)
 
-    >>> chat_id = bot.getUpdates()[-1].message.chat_id
 
-To post a text message::
+=============
+Documentation
+=============
 
-    >>> bot.sendMessage(chat_id=chat_id, text="I'm sorry Dave I'm afraid I can't do that.")
+``python-telegram-bot``'s documentation lives at `pythonhosted.org <https://pythonhosted.org/python-telegram-bot/>`_.
 
-To post a text message with markdown::
+============
+Getting help
+============
 
-    >>> bot.sendMessage(chat_id=chat_id, text="*bold* _italic_ [link](http://google.com).", parse_mode=telegram.ParseMode.MARKDOWN)
+You can get help in several ways:
 
-To post an Emoji (special thanks to `Tim Whitlock <http://apps.timwhitlock.info/emoji/tables/unicode>`_)::
+1. We have a vibrant community of developers helping each other in our `Telegram group <https://telegram.me/pythontelegrambotgroup>`_. Join us!
 
-    >>> bot.sendMessage(chat_id=chat_id, text=telegram.Emoji.PILE_OF_POO)
+2. Our `Wiki pages <https://github.com/python-telegram-bot/python-telegram-bot/wiki/>`_ offer a growing amount of resources.
 
-To post an image file via URL (right now only sendPhoto supports this)::
+3. You can ask for help on Stack Overflow using the `python-telegram-bot tag <https://stackoverflow.com/questions/tagged/python-telegram-bot>`_.
 
-    >>> bot.sendPhoto(chat_id=chat_id, photo='https://telegram.org/img/t_logo.png')
+4. As last resort, the developers are ready to help you with `serious issues <https://github.com/python-telegram-bot/python-telegram-bot/issues/new>`_.
 
-To post a voice file::
 
-    >>> bot.sendVoice(chat_id=chat_id, voice=open('tests/telegram.ogg', 'rb'))
+============
+Contributing
+============
 
-To tell the user that something is happening on bot's side::
-
-    >>> bot.sendChatAction(chat_id=chat_id, action=telegram.ChatAction.TYPING)
-
-To create `Custom Keyboards <https://core.telegram.org/bots#keyboards>`_::
-
-    >>> custom_keyboard = [[ telegram.Emoji.THUMBS_UP_SIGN, telegram.Emoji.THUMBS_DOWN_SIGN ]]
-    >>> reply_markup = telegram.ReplyKeyboardMarkup(custom_keyboard)
-    >>> bot.sendMessage(chat_id=chat_id, text="Stay here, I'll be back.", reply_markup=reply_markup)
-
-To hide `Custom Keyboards <https://core.telegram.org/bots#keyboards>`_::
-
-    >>> reply_markup = telegram.ReplyKeyboardHide()
-    >>> bot.sendMessage(chat_id=chat_id, text="I'm back.", reply_markup=reply_markup)
-
-To download a file (you will need its file_id)::
-
-    >>> file_id = message.voice.file_id
-    >>> newFile = bot.getFile(file_id)
-    >>> newFile.download('voice.ogg')
-
-There are many more API methods, to read the full API documentation::
-
-    $ pydoc telegram.Bot
-
------------
-_`Logging`
------------
-
-You can get logs in your main application by calling `logging` and setting the log level you want::
-
-    >>> import logging
-    >>> logger = logging.getLogger()
-    >>> logger.setLevel(logging.INFO)
-
-If you want DEBUG logs instead::
-
-    >>> logger.setLevel(logging.DEBUG)
-
------------
-_`Examples`
------------
-
-Here follows some examples to help you to get your own Bot up to speed:
-
-- `echobot <https://github.com/leandrotoledo/python-telegram-bot/blob/master/examples/echobot.py>`_ replies back messages.
-
-- `roboed <https://github.com/leandrotoledo/python-telegram-bot/blob/master/examples/roboed.py>`_ talks to `Robô Ed <http://www.ed.conpet.gov.br/br/converse.php>`_.
-
-- `Simple-Echo-Telegram-Bot <https://github.com/sooyhwang/Simple-Echo-Telegram-Bot>`_ simple Python Telegram bot that echoes your input with Flask microframework, setWebhook method, and Google App Engine (optional) - by @sooyhwang.
-
-- `DevOps Reaction Bot <https://github.com/leandrotoledo/gae-devops-reaction-telegram-bot>`_ sends latest or random posts from `DevOps Reaction <http://devopsreactions.tumblr.com/>`_. Running on `Google App Engine <https://cloud.google.com/appengine>`_ (billing has to be enabled for fully Socket API support).
-
-================
-_`Documentation`
-================
-
-``python-telegram-bot``'s documentation lives at `Read the Docs <http://python-telegram-bot.readthedocs.org/en/latest/>`_.
-
-==========
-_`License`
-==========
-
-You may copy, distribute and modify the software provided that modifications are described and licensed for free under `LGPL-3 <http://www.gnu.org/licenses/lgpl-3.0.html>`_. Derivatives works (including modifications or anything statically linked to the library) can only be redistributed under `LGPL-3 <http://www.gnu.org/licenses/lgpl-3.0.html>`_, but applications that use the library don't have to be.
-
-==========
-_`Contact`
-==========
-
-Feel free to join to our `Telegram group <https://telegram.me/joinchat/ALnA-AJQm5SEwuAzar3nvw>`_.
-
-If you face trouble joining in the group please ping me `via Telegram <https://telegram.me/leandrotoledo>`_, I'll be glad to add you.
+Contributions of all sizes are welcome. Please review our `contribution guidelines <https://github.com/python-telegram-bot/python-telegram-bot/blob/master/.github/CONTRIBUTING.rst>`_ to get started. You can also help by `reporting bugs <https://github.com/python-telegram-bot/python-telegram-bot/issues/new>`_.
 
 =======
-_`TODO`
+License
 =======
 
-Patches and bug reports are `welcome <https://github.com/leandrotoledo/python-telegram-bot/issues/new>`_, just please keep the style consistent with the original source.
-
-- Add commands handler.
+You may copy, distribute and modify the software provided that modifications are described and licensed for free under `LGPL-3 <https://www.gnu.org/licenses/lgpl-3.0.html>`_. Derivatives works (including modifications or anything statically linked to the library) can only be redistributed under LGPL-3, but applications that use the library don't have to be.

docs/source/conf.py

@@ -15,6 +15,7 @@
 import sys
 import os
 import shlex
+import telegram
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -50,7 +51,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Python Telegram Bot'
-copyright = u'2015, Leandro Toledo'
+copyright = u'2015-2016, Leandro Toledo'
 author = u'Leandro Toledo'
 
 # The version info for the project you're documenting, acts as replacement for
@@ -58,9 +59,9 @@ author = u'Leandro Toledo'
 # built documents.
 #
 # The short X.Y version.
-version = '2.9'
+version = telegram.__version__[:3]
 # The full version, including alpha/beta/rc tags.
-release = '2.9'
+release = telegram.__version__
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -270,7 +271,7 @@ man_pages = [
 #  dir menu entry, description, category)
 texinfo_documents = [
   (master_doc, 'PythonTelegramBot', u'Python Telegram Bot Documentation',
-   author, 'PythonTelegramBot', 'One line description of project.',
+   author, 'PythonTelegramBot', 'Not just a Python wrapper around the Telegram Bot API',
    'Miscellaneous'),
 ]
 

docs/source/telegram.bot.rst

@@ -3,5 +3,4 @@ telegram.bot module
 
 .. automodule:: telegram.bot
     :members:
-    :undoc-members:
     :show-inheritance:

docs/source/telegram.chat.rst

@@ -1,7 +1,7 @@
-telegram.groupchat module
+telegram.chat module
 =========================
 
-.. automodule:: telegram.groupchat
+.. automodule:: telegram.chat
     :members:
     :undoc-members:
     :show-inheritance:

docs/source/telegram.choseninlineresult.rst

@@ -0,0 +1,7 @@
+telegram.choseninlineresult module
+==================================
+
+.. automodule:: telegram.choseninlineresult
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.contrib.botan.rst

@@ -0,0 +1,7 @@
+telegram.contrib.botan module
+=============================
+
+.. automodule:: telegram.contrib.botan
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.callbackqueryhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.handler module
+===========================
+
+.. automodule:: telegram.ext.handler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.choseninlineresulthandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.choseninlineresulthandler module
+=============================================
+
+.. automodule:: telegram.ext.choseninlineresulthandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.commandhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.commandhandler module
+==================================
+
+.. automodule:: telegram.ext.commandhandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.dispatcher.rst

@@ -0,0 +1,7 @@
+telegram.ext.dispatcher module
+==============================
+
+.. automodule:: telegram.ext.dispatcher
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.handler.rst

@@ -0,0 +1,7 @@
+telegram.ext.handler module
+===========================
+
+.. automodule:: telegram.ext.handler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.inlinequeryhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.inlinequeryhandler module
+======================================
+
+.. automodule:: telegram.ext.inlinequeryhandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.jobqueue.rst

@@ -0,0 +1,7 @@
+telegram.ext.jobqueue module
+============================
+
+.. automodule:: telegram.ext.jobqueue
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.messagehandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.messagehandler module
+==================================
+
+.. automodule:: telegram.ext.messagehandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.regexhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.regexhandler module
+================================
+
+.. automodule:: telegram.ext.regexhandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.rst

@@ -0,0 +1,28 @@
+telegram.ext package
+====================
+
+Submodules
+----------
+
+.. toctree::
+
+    telegram.ext.updater
+    telegram.ext.dispatcher
+    telegram.ext.jobqueue
+    telegram.ext.handler
+    telegram.ext.choseninlineresulthandler
+    telegram.ext.commandhandler
+    telegram.ext.inlinequeryhandler
+    telegram.ext.messagehandler
+    telegram.ext.regexhandler
+    telegram.ext.stringcommandhandler
+    telegram.ext.stringregexhandler
+    telegram.ext.typehandler
+
+Module contents
+---------------
+
+.. automodule:: telegram.ext
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.stringcommandhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.stringcommandhandler module
+========================================
+
+.. automodule:: telegram.ext.stringcommandhandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.stringregexhandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.stringregexhandler module
+======================================
+
+.. automodule:: telegram.ext.stringregexhandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.typehandler.rst

@@ -0,0 +1,7 @@
+telegram.ext.typehandler module
+===============================
+
+.. automodule:: telegram.ext.typehandler
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.ext.updater.rst

@@ -0,0 +1,7 @@
+telegram.ext.updater module
+===========================
+
+.. automodule:: telegram.ext.updater
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinekeyboardbutton.rst

@@ -0,0 +1,7 @@
+telegram.inlinekeyboardbutton module
+===========================
+
+.. automodule:: telegram.inlinekeyboardbutton
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinekeyboardmarkup.rst

@@ -0,0 +1,7 @@
+telegram.inlinekeyboardmarkup module
+==========================
+
+.. automodule:: telegram.inlinekeyboardmarkup
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequery.rst

@@ -0,0 +1,7 @@
+telegram.inlinequery module
+===========================
+
+.. automodule:: telegram.inlinequery
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresult.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresult module
+=================================
+
+.. automodule:: telegram.inlinequeryresult
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultarticle.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultarticle module
+=================================
+
+.. automodule:: telegram.inlinequeryresultarticle
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultaudio.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultaudio module
+=================================
+
+.. automodule:: telegram.inlinequeryresultaudio
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedaudio.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedaudio module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedaudio
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcacheddocument.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcacheddocument module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcacheddocument
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedgif.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedgif module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedgif
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedmpeg4gif.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedmpeg4gif module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedmpeg4gif
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedphoto.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedphoto module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedphoto
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedsticker.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedsticker module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedsticker
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedvideo.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedvideo module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedvideo
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcachedvoice.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcachedvoice module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcachedvoice
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultcontact.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultcontact module
+=================================
+
+.. automodule:: telegram.inlinequeryresultcontact
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultdocument.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultdocument module
+=================================
+
+.. automodule:: telegram.inlinequeryresultdocument
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultgif.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultgif module
+=================================
+
+.. automodule:: telegram.inlinequeryresultgif
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultlocation.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultlocation module
+=================================
+
+.. automodule:: telegram.inlinequeryresultlocation
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultmpeg4gif.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultmpeg4gif module
+=================================
+
+.. automodule:: telegram.inlinequeryresultmpeg4gif
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultphoto.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultphoto module
+=================================
+
+.. automodule:: telegram.inlinequeryresultphoto
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultvenue.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultvenue module
+=================================
+
+.. automodule:: telegram.inlinequeryresultvenue
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultvideo.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultvideo module
+=================================
+
+.. automodule:: telegram.inlinequeryresultvideo
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.inlinequeryresultvoice.rst

@@ -0,0 +1,7 @@
+telegram.inlinequeryresultvoice module
+=================================
+
+.. automodule:: telegram.inlinequeryresultvoice
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/telegram.rst

@@ -9,13 +9,38 @@ Submodules
    telegram.audio
    telegram.base
    telegram.bot
+   telegram.ext
+   telegram.inlinequery
+   telegram.inlinequeryresult
+   telegram.inlinekeyboardbutton
+   telegram.inlinekeyboardmarkup
+   telegram.inlinequeryresultarticle
+   telegram.inlinequeryresultaudio
+   telegram.inlinequeryresultcachedaudio
+   telegram.inlinequeryresultcacheddocument
+   telegram.inlinequeryresultcachedgif
+   telegram.inlinequeryresultcachedmpeg4gif
+   telegram.inlinequeryresultcachedphoto
+   telegram.inlinequeryresultcachedsticker
+   telegram.inlinequeryresultcachedvideo
+   telegram.inlinequeryresultcachedvoice
+   telegram.inlinequeryresultcontact
+   telegram.inlinequeryresultdocument
+   telegram.inlinequeryresultgif
+   telegram.inlinequeryresultlocation
+   telegram.inlinequeryresultmpeg4gif
+   telegram.inlinequeryresultphoto
+   telegram.inlinequeryresultvenue
+   telegram.inlinequeryresultvideo
+   telegram.inlinequeryresultvoice
+   telegram.choseninlineresult
    telegram.chataction
    telegram.contact
    telegram.document
    telegram.emoji
    telegram.error
    telegram.forcereply
-   telegram.groupchat
+   telegram.chat
    telegram.inputfile
    telegram.location
    telegram.message

examples/LICENSE.txt

@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>

examples/echobot.py

@@ -1,65 +1,52 @@
 #!/usr/bin/env python
+# -*- coding: utf-8 -*-
 #
-# Simple Bot to reply Telegram messages
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-
+# Simple Bot to reply to Telegram messages. This is built on the API wrapper, see
+# echobot2.py to see the same example built on the telegram.ext bot framework.
+# This program is dedicated to the public domain under the CC0 license.
 import logging
 import telegram
+from telegram.error import NetworkError, Unauthorized
+from time import sleep
 
 
-LAST_UPDATE_ID = None
-
+update_id = None
 
 def main():
-    global LAST_UPDATE_ID
-
-    logging.basicConfig(
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-
+    global update_id
     # Telegram Bot Authorization Token
     bot = telegram.Bot('TOKEN')
 
-    # This will be our global variable to keep the latest update_id when requesting
-    # for updates. It starts with the latest update_id if available.
+    # get the first pending update_id, this is so we can skip over it in case
+    # we get an "Unauthorized" exception.
     try:
-        LAST_UPDATE_ID = bot.getUpdates()[-1].update_id
+        update_id = bot.getUpdates()[0].update_id
     except IndexError:
-        LAST_UPDATE_ID = None
+        update_id = None
+
+    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 
     while True:
-        echo(bot)
+        try:
+            echo(bot)
+        except NetworkError:
+            sleep(1)
+        except Unauthorized:
+            # The user has removed or blocked the bot.
+            update_id += 1
 
 
 def echo(bot):
-    global LAST_UPDATE_ID
-
-    # Request updates after the last updated_id
-    for update in bot.getUpdates(offset=LAST_UPDATE_ID, timeout=10):
-        # chat_id is required to reply any message
+    global update_id
+    # Request updates after the last update_id
+    for update in bot.getUpdates(offset=update_id, timeout=10):
+        # chat_id is required to reply to any message
         chat_id = update.message.chat_id
-        reply_text = update.message.text
+        update_id = update.update_id + 1
 
-        if (reply_text):
-            # Reply the message
-            bot.sendMessage(chat_id=chat_id,
-                            text=reply_text)
-
-            # Updates global offset to get the new updates
-            LAST_UPDATE_ID = update.update_id + 1
+        if update.message:  # your bot can receive updates without messages
+            # Reply to the message
+            bot.sendMessage(chat_id=chat_id, text=update.message.text)
 
 
 if __name__ == '__main__':

examples/echobot2.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Simple Bot to reply to Telegram messages
+# This program is dedicated to the public domain under the CC0 license.
+"""
+This Bot uses the Updater class to handle the bot.
+
+First, a few handler functions are defined. Then, those functions are passed to
+the Dispatcher and registered at their respective places.
+Then, the bot is started and runs until we press Ctrl-C on the command line.
+
+Usage:
+Basic Echobot example, repeats messages.
+Press Ctrl-C on the command line or send a signal to the process to stop the
+bot.
+"""
+
+from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
+import logging
+
+# Enable logging
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    level=logging.INFO)
+
+logger = logging.getLogger(__name__)
+
+
+# Define a few command handlers. These usually take the two arguments bot and
+# update. Error handlers also receive the raised TelegramError object in error.
+def start(bot, update):
+    bot.sendMessage(update.message.chat_id, text='Hi!')
+
+
+def help(bot, update):
+    bot.sendMessage(update.message.chat_id, text='Help!')
+
+
+def echo(bot, update):
+    bot.sendMessage(update.message.chat_id, text=update.message.text)
+
+
+def error(bot, update, error):
+    logger.warn('Update "%s" caused error "%s"' % (update, error))
+
+
+def main():
+    # Create the EventHandler and pass it your bot's token.
+    updater = Updater("TOKEN")
+
+    # Get the dispatcher to register handlers
+    dp = updater.dispatcher
+
+    # on different commands - answer in Telegram
+    dp.add_handler(CommandHandler("start", start))
+    dp.add_handler(CommandHandler("help", help))
+
+    # on noncommand i.e message - echo the message on Telegram
+    dp.add_handler(MessageHandler([Filters.text], echo))
+
+    # log all errors
+    dp.add_error_handler(error)
+
+    # Start the Bot
+    updater.start_polling()
+
+    # Run the bot until the you presses Ctrl-C or the process receives SIGINT,
+    # SIGTERM or SIGABRT. This should be used most of the time, since
+    # start_polling() is non-blocking and will stop the bot gracefully.
+    updater.idle()
+
+
+if __name__ == '__main__':
+    main()

examples/inlinebot.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Simple Bot to reply to Telegram messages
+# This program is dedicated to the public domain under the CC0 license.
+"""
+This Bot uses the Updater class to handle the bot.
+
+First, a few handler functions are defined. Then, those functions are passed to
+the Dispatcher and registered at their respective places.
+Then, the bot is started and runs until we press Ctrl-C on the command line.
+
+Usage:
+Basic inline bot example. Applies different text transformations.
+Press Ctrl-C on the command line or send a signal to the process to stop the
+bot.
+"""
+from uuid import uuid4
+
+import re
+
+from telegram import InlineQueryResultArticle, ParseMode, \
+    InputTextMessageContent
+from telegram.ext import Updater, InlineQueryHandler, CommandHandler
+import logging
+
+# Enable logging
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    level=logging.INFO)
+
+logger = logging.getLogger(__name__)
+
+
+# Define a few command handlers. These usually take the two arguments bot and
+# update. Error handlers also receive the raised TelegramError object in error.
+def start(bot, update):
+    bot.sendMessage(update.message.chat_id, text='Hi!')
+
+
+def help(bot, update):
+    bot.sendMessage(update.message.chat_id, text='Help!')
+
+
+def escape_markdown(text):
+    """Helper function to escape telegram markup symbols"""
+    escape_chars = '\*_`\['
+    return re.sub(r'([%s])' % escape_chars, r'\\\1', text)
+
+
+def inlinequery(bot, update):
+    query = update.inline_query.query
+    results = list()
+
+    results.append(InlineQueryResultArticle(id=uuid4(),
+                                            title="Caps",
+                                            input_message_content=InputTextMessageContent(
+                                                query.upper())))
+
+    results.append(InlineQueryResultArticle(id=uuid4(),
+                                            title="Bold",
+                                            input_message_content=InputTextMessageContent(
+                                                "*%s*" % escape_markdown(query),
+                                                parse_mode=ParseMode.MARKDOWN)))
+
+    results.append(InlineQueryResultArticle(id=uuid4(),
+                                            title="Italic",
+                                            input_message_content=InputTextMessageContent(
+                                                "_%s_" % escape_markdown(query),
+                                                parse_mode=ParseMode.MARKDOWN)))
+
+    bot.answerInlineQuery(update.inline_query.id, results=results)
+
+
+def error(bot, update, error):
+    logger.warn('Update "%s" caused error "%s"' % (update, error))
+
+
+def main():
+    # Create the Updater and pass it your bot's token.
+    updater = Updater("TOKEN")
+
+    # Get the dispatcher to register handlers
+    dp = updater.dispatcher
+
+    # on different commands - answer in Telegram
+    dp.add_handler(CommandHandler("start", start))
+    dp.add_handler(CommandHandler("help", help))
+
+    # on noncommand i.e message - echo the message on Telegram
+    dp.add_handler(InlineQueryHandler(inlinequery))
+
+    # log all errors
+    dp.add_error_handler(error)
+
+    # Start the Bot
+    updater.start_polling()
+
+    # Block until the user presses Ctrl-C or the process receives SIGINT,
+    # SIGTERM or SIGABRT. This should be used most of the time, since
+    # start_polling() is non-blocking and will stop the bot gracefully.
+    updater.idle()
+
+
+if __name__ == '__main__':
+    main()

examples/inlinekeyboard.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Basic example for a bot that awaits an answer from the user. It's built upon
+# the state_machine_bot.py example
+# This program is dedicated to the public domain under the CC0 license.
+
+import logging
+from telegram import Emoji, ForceReply, InlineKeyboardButton, \
+    InlineKeyboardMarkup
+from telegram.ext import Updater, CommandHandler, MessageHandler, \
+    CallbackQueryHandler, Filters
+
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    level=logging.DEBUG)
+
+# Define the different states a chat can be in
+MENU, AWAIT_CONFIRMATION, AWAIT_INPUT = range(3)
+
+# Python 2 and 3 unicode differences
+try:
+    YES, NO = (Emoji.THUMBS_UP_SIGN.decode('utf-8'), Emoji.THUMBS_DOWN_SIGN.decode('utf-8'))
+except AttributeError:
+    YES, NO = (Emoji.THUMBS_UP_SIGN, Emoji.THUMBS_DOWN_SIGN)
+
+# States are saved in a dict that maps chat_id -> state
+state = dict()
+# Sometimes you need to save data temporarily
+context = dict()
+# This dict is used to store the settings value for the chat.
+# Usually, you'd use persistence for this (e.g. sqlite).
+values = dict()
+
+
+# Example handler. Will be called on the /set command and on regular messages
+def set_value(bot, update):
+    chat_id = update.message.chat_id
+    user_id = update.message.from_user.id
+    user_state = state.get(chat_id, MENU)
+
+    if user_state == MENU:
+        state[user_id] = AWAIT_INPUT  # set the state
+        bot.sendMessage(chat_id,
+                        text="Please enter your settings value",
+                        reply_markup=ForceReply())
+
+
+def entered_value(bot, update):
+    chat_id = update.message.chat_id
+    user_id = update.message.from_user.id
+    chat_state = state.get(user_id, MENU)
+
+    # Check if we are waiting for input
+    if chat_state == AWAIT_INPUT:
+        state[user_id] = AWAIT_CONFIRMATION
+
+        # Save the user id and the answer to context
+        context[user_id] = update.message.text
+        reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton(YES, callback_data=YES),
+                                              InlineKeyboardButton(NO, callback_data=NO)]])
+        bot.sendMessage(chat_id, text="Are you sure?", reply_markup=reply_markup)
+
+
+def confirm_value(bot, update):
+    query = update.callback_query
+    chat_id = query.message.chat_id
+    user_id = query.from_user.id
+    text = query.data
+    user_state = state.get(user_id, MENU)
+    user_context = context.get(user_id, None)
+
+    # Check if we are waiting for confirmation and the right user answered
+    if user_state == AWAIT_CONFIRMATION:
+        del state[user_id]
+        del context[user_id]
+        bot.answerCallbackQuery(query.id, text="Ok!")
+        if text == YES:
+            values[user_id] = user_context
+            bot.editMessageText(text="Changed value to %s." % values[user_id],
+                                chat_id=chat_id,
+                                message_id=query.message.message_id)
+        else:
+            bot.editMessageText(text="Alright, value is still %s." %
+                                values.get(user_id, 'not set'),
+                                chat_id=chat_id,
+                                message_id=query.message.message_id)
+
+
+def help(bot, update):
+    bot.sendMessage(update.message.chat_id, text="Use /set to test this bot.")
+
+
+def error(bot, update, error):
+    logging.warning('Update "%s" caused error "%s"' % (update, error))
+
+# Create the Updater and pass it your bot's token.
+updater = Updater("TOKEN")
+
+# The command
+updater.dispatcher.add_handler(CommandHandler('set', set_value))
+# The answer
+updater.dispatcher.add_handler(MessageHandler([Filters.text], entered_value))
+# The confirmation
+updater.dispatcher.add_handler(CallbackQueryHandler(confirm_value))
+updater.dispatcher.add_handler(CommandHandler('start', help))
+updater.dispatcher.add_handler(CommandHandler('help', help))
+updater.dispatcher.add_error_handler(error)
+
+# Start the Bot
+updater.start_polling()
+
+# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
+# SIGTERM or SIGABRT
+updater.idle()

examples/roboed.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-#
-# Robô Ed Telegram Bot
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-
-__author__ = 'leandrotoledodesouza@gmail.com'
-
-import logging
-import telegram
-import urllib
-
-
-def main():
-    logging.basicConfig(
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    bot = telegram.Bot('TOKEN')  # Telegram Bot Authorization Token
-
-    LAST_UPDATE_ID = bot.getUpdates()[-1].update_id  # Get lastest update
-
-    while True:
-        for update in bot.getUpdates(offset=LAST_UPDATE_ID, timeout=10):
-            text = update.message.text
-            chat_id = update.message.chat.id
-            update_id = update.update_id
-
-            if text:
-                roboed = ed(text)  # Ask something to Robô Ed
-                bot.sendMessage(chat_id=chat_id, text=roboed)
-                LAST_UPDATE_ID = update_id + 1
-
-
-def ed(text):
-    url = 'http://www.ed.conpet.gov.br/mod_perl/bot_gateway.cgi?server=0.0.0.0%3A8085&charset_post=utf-8&charset=utf-8&pure=1&js=0&tst=1&msg=' + text
-    data = urllib.urlopen(url).read()
-
-    return data.strip()
-
-if __name__ == '__main__':
-    main()

examples/state_machine_bot.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Basic example for a bot that awaits an answer from the user
+# This program is dedicated to the public domain under the CC0 license.
+
+import logging
+from telegram import Emoji, ForceReply, ReplyKeyboardMarkup, KeyboardButton
+from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
+
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    level=logging.INFO)
+
+# Define the different states a chat can be in
+MENU, AWAIT_CONFIRMATION, AWAIT_INPUT = range(3)
+
+# Python 2 and 3 unicode differences
+try:
+    YES, NO = (Emoji.THUMBS_UP_SIGN.decode('utf-8'), Emoji.THUMBS_DOWN_SIGN.decode('utf-8'))
+except AttributeError:
+    YES, NO = (Emoji.THUMBS_UP_SIGN, Emoji.THUMBS_DOWN_SIGN)
+
+# States are saved in a dict that maps chat_id -> state
+state = dict()
+# Sometimes you need to save data temporarily
+context = dict()
+# This dict is used to store the settings value for the chat.
+# Usually, you'd use persistence for this (e.g. sqlite).
+values = dict()
+
+
+# Example handler. Will be called on the /set command and on regular messages
+def set_value(bot, update):
+    chat_id = update.message.chat_id
+    user_id = update.message.from_user.id
+    text = update.message.text
+    chat_state = state.get(chat_id, MENU)
+    chat_context = context.get(chat_id, None)
+
+    # Since the handler will also be called on messages, we need to check if
+    # the message is actually a command
+    if chat_state == MENU and text[0] == '/':
+        state[chat_id] = AWAIT_INPUT  # set the state
+        context[chat_id] = user_id  # save the user id to context
+        bot.sendMessage(chat_id,
+                        text="Please enter your settings value or send "
+                        "/cancel to abort",
+                        reply_markup=ForceReply())
+
+    # If we are waiting for input and the right user answered
+    elif chat_state == AWAIT_INPUT and chat_context == user_id:
+        state[chat_id] = AWAIT_CONFIRMATION
+
+        # Save the user id and the answer to context
+        context[chat_id] = (user_id, update.message.text)
+        reply_markup = ReplyKeyboardMarkup(
+            [[KeyboardButton(YES), KeyboardButton(NO)]],
+            one_time_keyboard=True)
+        bot.sendMessage(chat_id, text="Are you sure?", reply_markup=reply_markup)
+
+    # If we are waiting for confirmation and the right user answered
+    elif chat_state == AWAIT_CONFIRMATION and chat_context[0] == user_id:
+        del state[chat_id]
+        del context[chat_id]
+        if text == YES:
+            values[chat_id] = chat_context[1]
+            bot.sendMessage(chat_id, text="Changed value to %s." % values[chat_id])
+        else:
+            bot.sendMessage(chat_id,
+                            text="Value not changed: %s." % values.get(chat_id, '<not set>'))
+
+
+# Handler for the /cancel command.
+# Sets the state back to MENU and clears the context
+def cancel(bot, update):
+    chat_id = update.message.chat_id
+    del state[chat_id]
+    del context[chat_id]
+
+
+def help(bot, update):
+    bot.sendMessage(update.message.chat_id, text="Use /set to test this bot.")
+
+# Create the Updater and pass it your bot's token.
+updater = Updater("TOKEN")
+
+# The command
+updater.dispatcher.add_handler(CommandHandler('set', set_value))
+# The answer and confirmation
+updater.dispatcher.add_handler(MessageHandler([Filters.text], set_value))
+updater.dispatcher.add_handler(CommandHandler('cancel', cancel))
+updater.dispatcher.add_handler(CommandHandler('start', help))
+updater.dispatcher.add_handler(CommandHandler('help', help))
+
+# Start the Bot
+updater.start_polling()
+
+# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
+# SIGTERM or SIGABRT
+updater.idle()

examples/timerbot.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Simple Bot to send timed Telegram messages
+# This program is dedicated to the public domain under the CC0 license.
+"""
+This Bot uses the Updater class to handle the bot and the JobQueue to send
+timed messages.
+
+First, a few handler functions are defined. Then, those functions are passed to
+the Dispatcher and registered at their respective places.
+Then, the bot is started and runs until we press Ctrl-C on the command line.
+
+Usage:
+Basic Alarm Bot example, sends a message after a set time.
+Press Ctrl-C on the command line or send a signal to the process to stop the
+bot.
+"""
+
+from telegram.ext import Updater, CommandHandler
+import logging
+
+# Enable logging
+logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                    level=logging.INFO)
+
+logger = logging.getLogger(__name__)
+job_queue = None
+
+
+# Define a few command handlers. These usually take the two arguments bot and
+# update. Error handlers also receive the raised TelegramError object in error.
+def start(bot, update):
+    bot.sendMessage(update.message.chat_id, text='Hi! Use /set <seconds> to ' 'set a timer')
+
+
+def set(bot, update, args):
+    """ Adds a job to the queue """
+    chat_id = update.message.chat_id
+    try:
+        # args[0] should contain the time for the timer in seconds
+        due = int(args[0])
+        if due < 0:
+            bot.sendMessage(chat_id, text='Sorry we can not go back to future!')
+
+        def alarm(bot):
+            """ Inner function to send the alarm message """
+            bot.sendMessage(chat_id, text='Beep!')
+
+        # Add job to queue
+        job_queue.put(alarm, due, repeat=False)
+        bot.sendMessage(chat_id, text='Timer successfully set!')
+
+    except IndexError:
+        bot.sendMessage(chat_id, text='Usage: /set <seconds>')
+    except ValueError:
+        bot.sendMessage(chat_id, text='Usage: /set <seconds>')
+
+
+def error(bot, update, error):
+    logger.warn('Update "%s" caused error "%s"' % (update, error))
+
+
+def main():
+    global job_queue
+
+    updater = Updater("TOKEN")
+    job_queue = updater.job_queue
+
+    # Get the dispatcher to register handlers
+    dp = updater.dispatcher
+
+    # on different commands - answer in Telegram
+    dp.add_handler(CommandHandler("start", start))
+    dp.add_handler(CommandHandler("help", start))
+    dp.add_handler(CommandHandler("set", set, pass_args=True))
+
+    # log all errors
+    dp.add_error_handler(error)
+
+    # Start the Bot
+    updater.start_polling()
+
+    # Block until the you presses Ctrl-C or the process receives SIGINT,
+    # SIGTERM or SIGABRT. This should be used most of the time, since
+    # start_polling() is non-blocking and will stop the bot gracefully.
+    updater.idle()
+
+
+if __name__ == '__main__':
+    main()

requirements-dev.txt

@@ -0,0 +1,9 @@
+flake8
+nose
+pep257
+pylint
+unittest2
+flaky
+yapf
+pre-commit
+pre-commit-hooks

requirements.txt

@@ -1 +1,3 @@
-future
+future>=0.15.2
+urllib3>=1.10
+certifi

setup.cfg

@@ -8,3 +8,12 @@ all_files  = 1
 
 [upload_sphinx]
 upload-dir = docs/build/html
+
+[flake8]
+max-line-length = 99
+ignore = W503
+
+[yapf]
+based_on_style = google
+split_before_logical_operator = True
+column_limit = 99

setup.py

@@ -1,45 +1,48 @@
 #!/usr/bin/env python
+"""The setup and build script for the python-telegram-bot library."""
 
-'''The setup and build script for the python-telegram-bot library.'''
-
-import os
-
+import codecs
+import telegram
 from setuptools import setup, find_packages
 
 
-def read(*paths):
-    """Build a file path from *paths* and return the contents."""
-    with open(os.path.join(*paths), 'r') as f:
-        return f.read()
+def requirements():
+    """Build the requirements list for this project"""
+    requirements_list = []
 
+    with open('requirements.txt') as requirements:
+        for install in requirements:
+            requirements_list.append(install.strip())
 
-setup(
-    name='python-telegram-bot',
-    version='2.9',
-    author='Leandro Toledo',
-    author_email='leandrotoledodesouza@gmail.com',
-    license='LGPLv3',
-    url='https://github.com/leandrotoledo/python-telegram-bot',
-    keywords='python telegram bot api wrapper',
-    description='A Python wrapper around the Telegram Bot API',
-    long_description=(read('README.rst')),
-    packages=find_packages(exclude=['tests*']),
-    include_package_data=True,
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
-        'Operating System :: OS Independent',
-        'Topic :: Software Development :: Libraries :: Python Modules',
-        'Topic :: Communications :: Chat',
-        'Topic :: Internet',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.2',
-        'Programming Language :: Python :: 3.3',
-        'Programming Language :: Python :: 3.4',
-    ],
-)
+    return requirements_list
+
+with codecs.open('README.rst', 'r', 'utf-8') as fd:
+    setup(name='python-telegram-bot',
+          version=telegram.__version__,
+          author='Leandro Toledo',
+          author_email='devs@python-telegram-bot.org',
+          license='LGPLv3',
+          url='https://github.com/python-telegram-bot/python-telegram-bot',
+          keywords='python telegram bot api wrapper',
+          description='Not just a Python wrapper around the Telegram Bot API',
+          long_description=fd.read(),
+          packages=find_packages(exclude=['tests*']),
+          install_requires=requirements(),
+          include_package_data=True,
+          classifiers=[
+              'Development Status :: 5 - Production/Stable',
+              'Intended Audience :: Developers',
+              'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
+              'Operating System :: OS Independent',
+              'Topic :: Software Development :: Libraries :: Python Modules',
+              'Topic :: Communications :: Chat',
+              'Topic :: Internet',
+              'Programming Language :: Python',
+              'Programming Language :: Python :: 2',
+              'Programming Language :: Python :: 2.6',
+              'Programming Language :: Python :: 2.7',
+              'Programming Language :: Python :: 3',
+              'Programming Language :: Python :: 3.3',
+              'Programming Language :: Python :: 3.4',
+              'Programming Language :: Python :: 3.5',
+          ],)

telegram/__init__.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,15 +16,14 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
 """A library that provides a Python interface to the Telegram Bot API"""
 
-__author__ = 'leandrotoledodesouza@gmail.com'
-__version__ = '2.8.7'
+from sys import version_info
 
 from .base import TelegramObject
 from .user import User
-from .groupchat import GroupChat
+from .chat import Chat
+from .chatmember import ChatMember
 from .photosize import PhotoSize
 from .audio import Audio
 from .voice import Voice
@@ -32,8 +32,10 @@ from .sticker import Sticker
 from .video import Video
 from .contact import Contact
 from .location import Location
+from .venue import Venue
 from .chataction import ChatAction
 from .userprofilephotos import UserProfilePhotos
+from .keyboardbutton import KeyboardButton
 from .replymarkup import ReplyMarkup
 from .replykeyboardmarkup import ReplyKeyboardMarkup
 from .replykeyboardhide import ReplyKeyboardHide
@@ -44,13 +46,62 @@ from .file import File
 from .nullhandler import NullHandler
 from .emoji import Emoji
 from .parsemode import ParseMode
+from .messageentity import MessageEntity
 from .message import Message
+from .inputmessagecontent import InputMessageContent
+from .callbackquery import CallbackQuery
+from .choseninlineresult import ChosenInlineResult
+from .inlinekeyboardbutton import InlineKeyboardButton
+from .inlinekeyboardmarkup import InlineKeyboardMarkup
+from .inlinequery import InlineQuery
+from .inlinequeryresult import InlineQueryResult
+from .inlinequeryresultarticle import InlineQueryResultArticle
+from .inlinequeryresultaudio import InlineQueryResultAudio
+from .inlinequeryresultcachedaudio import InlineQueryResultCachedAudio
+from .inlinequeryresultcacheddocument import InlineQueryResultCachedDocument
+from .inlinequeryresultcachedgif import InlineQueryResultCachedGif
+from .inlinequeryresultcachedmpeg4gif import InlineQueryResultCachedMpeg4Gif
+from .inlinequeryresultcachedphoto import InlineQueryResultCachedPhoto
+from .inlinequeryresultcachedsticker import InlineQueryResultCachedSticker
+from .inlinequeryresultcachedvideo import InlineQueryResultCachedVideo
+from .inlinequeryresultcachedvoice import InlineQueryResultCachedVoice
+from .inlinequeryresultcontact import InlineQueryResultContact
+from .inlinequeryresultdocument import InlineQueryResultDocument
+from .inlinequeryresultgif import InlineQueryResultGif
+from .inlinequeryresultlocation import InlineQueryResultLocation
+from .inlinequeryresultmpeg4gif import InlineQueryResultMpeg4Gif
+from .inlinequeryresultphoto import InlineQueryResultPhoto
+from .inlinequeryresultvenue import InlineQueryResultVenue
+from .inlinequeryresultvideo import InlineQueryResultVideo
+from .inlinequeryresultvoice import InlineQueryResultVoice
+from .inputtextmessagecontent import InputTextMessageContent
+from .inputlocationmessagecontent import InputLocationMessageContent
+from .inputvenuemessagecontent import InputVenueMessageContent
+from .inputcontactmessagecontent import InputContactMessageContent
 from .update import Update
 from .bot import Bot
 
-__all__ = ['Bot', 'Emoji', 'TelegramError', 'InputFile', 'ReplyMarkup',
-           'ForceReply', 'ReplyKeyboardHide', 'ReplyKeyboardMarkup',
-           'UserProfilePhotos', 'ChatAction', 'Location', 'Contact',
-           'Video', 'Sticker', 'Document', 'File', 'Audio', 'PhotoSize',
-           'GroupChat', 'Update', 'ParseMode', 'Message', 'User',
-           'TelegramObject', 'NullHandler', 'Voice']
+__author__ = 'devs@python-telegram-bot.org'
+__version__ = '4.3.1'
+__all__ = ['Audio', 'Bot', 'Chat', 'ChatMember', 'ChatAction', 'ChosenInlineResult',
+           'CallbackQuery', 'Contact', 'Document', 'Emoji', 'File', 'ForceReply',
+           'InlineKeyboardButton', 'InlineKeyboardMarkup', 'InlineQuery', 'InlineQueryResult',
+           'InlineQueryResult', 'InlineQueryResultArticle', 'InlineQueryResultAudio',
+           'InlineQueryResultCachedAudio', 'InlineQueryResultCachedDocument',
+           'InlineQueryResultCachedGif', 'InlineQueryResultCachedMpeg4Gif',
+           'InlineQueryResultCachedPhoto', 'InlineQueryResultCachedSticker',
+           'InlineQueryResultCachedVideo', 'InlineQueryResultCachedVoice',
+           'InlineQueryResultContact', 'InlineQueryResultDocument', 'InlineQueryResultGif',
+           'InlineQueryResultLocation', 'InlineQueryResultMpeg4Gif', 'InlineQueryResultPhoto',
+           'InlineQueryResultVenue', 'InlineQueryResultVideo', 'InlineQueryResultVoice',
+           'InputContactMessageContent', 'InputFile', 'InputLocationMessageContent',
+           'InputMessageContent', 'InputTextMessageContent', 'InputVenueMessageContent',
+           'KeyboardButton', 'Location', 'Message', 'MessageEntity', 'NullHandler', 'ParseMode',
+           'PhotoSize', 'ReplyKeyboardHide', 'ReplyKeyboardMarkup', 'ReplyMarkup', 'Sticker',
+           'TelegramError', 'TelegramObject', 'Update', 'User', 'UserProfilePhotos', 'Venue',
+           'Video', 'Voice']
+
+if version_info < (2, 7):
+    from warnings import warn
+    warn("python-telegram-bot will stop supporting Python 2.6 in a future release. "
+         "Please upgrade your Python version to at least Python 2.7!")

telegram/audio.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,8 +16,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram Audio"""
+"""This module contains a object that represents a Telegram Audio."""
 
 from telegram import TelegramObject
 
@@ -44,10 +44,7 @@ class Audio(TelegramObject):
         file_size (Optional[int]):
     """
 
-    def __init__(self,
-                 file_id,
-                 duration,
-                 **kwargs):
+    def __init__(self, file_id, duration, **kwargs):
         # Required
         self.file_id = str(file_id)
         self.duration = int(duration)

telegram/base.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,15 +16,14 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""Base class for Telegram Objects"""
+"""Base class for Telegram Objects."""
 
 import json
 from abc import ABCMeta
 
 
 class TelegramObject(object):
-    """Base class for most telegram objects"""
+    """Base class for most telegram objects."""
 
     __metaclass__ = ABCMeta
 
@@ -42,7 +42,12 @@ class TelegramObject(object):
         Returns:
             telegram.TelegramObject:
         """
-        raise NotImplementedError
+        if not data:
+            return None
+
+        data = data.copy()
+
+        return data
 
     def to_json(self):
         """
@@ -58,8 +63,9 @@ class TelegramObject(object):
         """
         data = dict()
 
-        for key, value in self.__dict__.items():
-            if value:
+        for key in iter(self.__dict__):
+            value = self.__dict__[key]
+            if value is not None:
                 if hasattr(value, 'to_dict'):
                     data[key] = value.to_dict()
                 else:

telegram/callbackquery.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram
+CallbackQuery"""
+
+from telegram import TelegramObject, Message, User
+
+
+class CallbackQuery(TelegramObject):
+    """This object represents a Telegram CallbackQuery."""
+
+    def __init__(self, id, from_user, data, **kwargs):
+        # Required
+        self.id = id
+        self.from_user = from_user
+        self.data = data
+        # Optionals
+        self.message = kwargs.get('message')
+        self.inline_message_id = kwargs.get('inline_message_id', '')
+
+    @staticmethod
+    def de_json(data):
+        if not data:
+            return None
+
+        data['from_user'] = User.de_json(data.get('from'))
+        data['message'] = Message.de_json(data.get('message'))
+
+        return CallbackQuery(**data)
+
+    def to_dict(self):
+        """
+        Returns:
+            dict:
+        """
+        data = super(CallbackQuery, self).to_dict()
+
+        # Required
+        data['from'] = data.pop('from_user', None)
+        return data

telegram/chat.py

@@ -2,7 +2,8 @@
 # pylint: disable=C0103,W0622
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -16,49 +17,56 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram GroupChat"""
+"""This module contains a object that represents a Telegram Chat."""
 
 from telegram import TelegramObject
 
 
-class GroupChat(TelegramObject):
-    """This object represents a Telegram GroupChat.
+class Chat(TelegramObject):
+    """This object represents a Telegram Chat.
 
     Attributes:
         id (int):
-        title (str):
-        type (str):
+        type (str): Can be 'private', 'group', 'supergroup' or 'channel'
+        title (str): Title, for channels and group chats
+        username (str): Username, for private chats and channels if available
+        first_name (str): First name of the other party in a private chat
+        last_name (str): Last name of the other party in a private chat
 
     Args:
         id (int):
-        title (str):
+        type (str):
         **kwargs: Arbitrary keyword arguments.
 
     Keyword Args:
         type (Optional[str]):
     """
 
-    def __init__(self,
-                 id,
-                 title,
-                 **kwargs):
+    PRIVATE = 'private'
+    GROUP = 'group'
+    SUPERGROUP = 'supergroup'
+    CHANNEL = 'channel'
+
+    def __init__(self, id, type, **kwargs):
         # Required
         self.id = int(id)
-        self.title = title
+        self.type = type
         # Optionals
-        self.type = kwargs.get('type', '')
+        self.title = kwargs.get('title', '')
+        self.username = kwargs.get('username', '')
+        self.first_name = kwargs.get('first_name', '')
+        self.last_name = kwargs.get('last_name', '')
 
     @staticmethod
     def de_json(data):
         """
         Args:
-            data (str):
+            data (dict):
 
         Returns:
-            telegram.GroupChat:
+            telegram.Chat:
         """
         if not data:
             return None
 
-        return GroupChat(**data)
+        return Chat(**data)

telegram/chataction.py

@@ -2,7 +2,8 @@
 # pylint: disable=R0903
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -16,8 +17,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram ChatAction"""
+"""This module contains a object that represents a Telegram ChatAction."""
 
 
 class ChatAction(object):

telegram/chatmember.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram ChatMember."""
+
+from telegram import User, TelegramObject
+
+
+class ChatMember(TelegramObject):
+    """This object represents a Telegram ChatMember.
+
+    Attributes:
+        user (:class:`telegram.User`): Information about the user.
+        status (str): The member's status in the chat. Can be 'creator', 'administrator', 'member',
+            'left' or 'kicked'.
+
+    Args:
+        user (:class:`telegram.User`):
+        status (str):
+    """
+
+    CREATOR = 'creator'
+    ADMINISTRATOR = 'administrator'
+    MEMBER = 'member'
+    LEFT = 'left'
+    KICKED = 'kicked'
+
+    def __init__(self, user, status, **kwargs):
+        # Required
+        self.user = user
+        self.status = status
+
+    @staticmethod
+    def de_json(data):
+        """
+        Args:
+            data (dict):
+
+        Returns:
+            telegram.ChatMember:
+        """
+        if not data:
+            return None
+
+        data['user'] = User.de_json(data.get('user'))
+
+        return ChatMember(**data)

telegram/choseninlineresult.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# pylint: disable=R0902,R0912,R0913
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""
+This module contains a object that represents a Telegram ChosenInlineResult
+"""
+
+from telegram import TelegramObject, User, Location
+
+
+class ChosenInlineResult(TelegramObject):
+    """This object represents a Telegram ChosenInlineResult.
+
+    Note:
+        * In Python `from` is a reserved word, use `from_user` instead.
+
+    Attributes:
+        result_id (str):
+        from_user (:class:`telegram.User`):
+        query (str):
+
+    Args:
+        result_id (str):
+        from_user (:class:`telegram.User`):
+        query (str):
+
+    """
+
+    def __init__(self,
+                 result_id,
+                 from_user,
+                 query,
+                 location=None,
+                 inline_message_id=None,
+                 **kwargs):
+        # Required
+        self.result_id = result_id
+        self.from_user = from_user
+        self.query = query
+        # Optionals
+        self.location = location
+        self.inline_message_id = inline_message_id
+
+    @staticmethod
+    def de_json(data):
+        """
+        Args:
+            data (dict):
+
+        Returns:
+            telegram.ChosenInlineResult:
+        """
+        if not data:
+            return None
+
+        # Required
+        data['from_user'] = User.de_json(data.pop('from'))
+        # Optionals
+        data['location'] = Location.de_json(data.get('location'))
+
+        return ChosenInlineResult(**data)
+
+    def to_dict(self):
+        """
+        Returns:
+            dict:
+        """
+        data = super(ChosenInlineResult, self).to_dict()
+
+        # Required
+        data['from'] = data.pop('from_user', None)
+
+        return data

telegram/contact.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,8 +16,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram Contact"""
+"""This module contains a object that represents a Telegram Contact."""
 
 from telegram import TelegramObject
 
@@ -40,10 +40,7 @@ class Contact(TelegramObject):
         user_id (Optional[int]):
     """
 
-    def __init__(self,
-                 phone_number,
-                 first_name,
-                 **kwargs):
+    def __init__(self, phone_number, first_name, **kwargs):
         # Required
         self.phone_number = str(phone_number)
         self.first_name = first_name

telegram/contrib/botan.py

@@ -0,0 +1,46 @@
+import logging
+from telegram import NullHandler
+
+from future.moves.urllib.parse import quote
+from future.moves.urllib.error import HTTPError, URLError
+from future.moves.urllib.request import urlopen, Request
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+class Botan(object):
+    """This class helps to send incoming events to your botan analytics account.
+     See more: https://github.com/botanio/sdk#botan-sdk
+    """
+
+    token = ''
+    url_template = 'https://api.botan.io/track?token={token}' \
+                   '&uid={uid}&name={name}&src=python-telegram-bot'
+
+    def __init__(self, token):
+        self.token = token
+        self.logger = logging.getLogger(__name__)
+
+    def track(self, message, event_name='event'):
+        try:
+            uid = message.chat_id
+        except AttributeError:
+            self.logger.warn('No chat_id in message')
+            return False
+        data = message.to_json()
+        try:
+            url = self.url_template.format(token=str(self.token),
+                                           uid=str(uid),
+                                           name=quote(event_name))
+            request = Request(url,
+                              data=data.encode(),
+                              headers={'Content-Type': 'application/json'})
+            urlopen(request)
+            return True
+        except HTTPError as error:
+            self.logger.warn('Botan track error ' + str(error.code) + ':' + error.read().decode(
+                'utf-8'))
+            return False
+        except URLError as error:
+            self.logger.warn('Botan track error ' + str(error.reason))
+            return False

telegram/document.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,8 +16,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram Document"""
+"""This module contains a object that represents a Telegram Document."""
 
 from telegram import PhotoSize, TelegramObject
 
@@ -42,9 +42,7 @@ class Document(TelegramObject):
         file_size (Optional[int]):
     """
 
-    def __init__(self,
-                 file_id,
-                 **kwargs):
+    def __init__(self, file_id, **kwargs):
         # Required
         self.file_id = str(file_id)
         # Optionals

telegram/emoji.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 # flake8: noqa
-# pylint: disable=C0103,C0301,R0903
+# pylint: disable=C0103,R0903
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -17,8 +18,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents an Emoji"""
+"""This module contains a object that represents an Emoji."""
 
 from future.utils import bytes_to_native_str as n
 
@@ -162,26 +162,26 @@ class Emoji(object):
     SQUARED_SOS = n(b'\xF0\x9F\x86\x98')
     SQUARED_UP_WITH_EXCLAMATION_MARK = n(b'\xF0\x9F\x86\x99')
     SQUARED_VS = n(b'\xF0\x9F\x86\x9A')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_D_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_E\
-        = n(b'\xF0\x9F\x87\xA9\xF0\x9F\x87\xAA')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_G_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_B\
-        = n(b'\xF0\x9F\x87\xAC\xF0\x9F\x87\xA7')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_C_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_N\
-        = n(b'\xF0\x9F\x87\xA8\xF0\x9F\x87\xB3')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_J_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_P\
-        = n(b'\xF0\x9F\x87\xAF\xF0\x9F\x87\xB5')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_K_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_R\
-        = n(b'\xF0\x9F\x87\xB0\xF0\x9F\x87\xB7')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_F_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_R\
-        = n(b'\xF0\x9F\x87\xAB\xF0\x9F\x87\xB7')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_E_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_S\
-        = n(b'\xF0\x9F\x87\xAA\xF0\x9F\x87\xB8')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_I_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_T\
-        = n(b'\xF0\x9F\x87\xAE\xF0\x9F\x87\xB9')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_U_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_S\
-        = n(b'\xF0\x9F\x87\xBA\xF0\x9F\x87\xB8')
-    REGIONAL_INDICATOR_SYMBOL_LETTER_R_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_U\
-        = n(b'\xF0\x9F\x87\xB7\xF0\x9F\x87\xBA')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_D_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_E = n(
+        b'\xF0\x9F\x87\xA9\xF0\x9F\x87\xAA')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_G_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_B = n(
+        b'\xF0\x9F\x87\xAC\xF0\x9F\x87\xA7')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_C_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_N = n(
+        b'\xF0\x9F\x87\xA8\xF0\x9F\x87\xB3')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_J_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_P = n(
+        b'\xF0\x9F\x87\xAF\xF0\x9F\x87\xB5')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_K_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_R = n(
+        b'\xF0\x9F\x87\xB0\xF0\x9F\x87\xB7')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_F_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_R = n(
+        b'\xF0\x9F\x87\xAB\xF0\x9F\x87\xB7')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_E_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_S = n(
+        b'\xF0\x9F\x87\xAA\xF0\x9F\x87\xB8')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_I_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_T = n(
+        b'\xF0\x9F\x87\xAE\xF0\x9F\x87\xB9')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_U_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_S = n(
+        b'\xF0\x9F\x87\xBA\xF0\x9F\x87\xB8')
+    REGIONAL_INDICATOR_SYMBOL_LETTER_R_PLUS_REGIONAL_INDICATOR_SYMBOL_LETTER_U = n(
+        b'\xF0\x9F\x87\xB7\xF0\x9F\x87\xBA')
     SQUARED_KATAKANA_KOKO = n(b'\xF0\x9F\x88\x81')
     SQUARED_KATAKANA_SA = n(b'\xF0\x9F\x88\x82')
     SQUARED_CJK_UNIFIED_IDEOGRAPH_7121 = n(b'\xF0\x9F\x88\x9A')
@@ -857,7 +857,8 @@ class Emoji(object):
     NO_MOBILE_PHONES = n(b'\xF0\x9F\x93\xB5')
     TWISTED_RIGHTWARDS_ARROWS = n(b'\xF0\x9F\x94\x80')
     CLOCKWISE_RIGHTWARDS_AND_LEFTWARDS_OPEN_CIRCLE_ARROWS = n(b'\xF0\x9F\x94\x81')
-    CLOCKWISE_RIGHTWARDS_AND_LEFTWARDS_OPEN_CIRCLE_ARROWS_WITH_CIRCLED_ONE_OVERLAY = n(b'\xF0\x9F\x94\x82')
+    CLOCKWISE_RIGHTWARDS_AND_LEFTWARDS_OPEN_CIRCLE_ARROWS_WITH_CIRCLED_ONE_OVERLAY = n(
+        b'\xF0\x9F\x94\x82')
     ANTICLOCKWISE_DOWNWARDS_AND_UPWARDS_OPEN_CIRCLE_ARROWS = n(b'\xF0\x9F\x94\x84')
     LOW_BRIGHTNESS_SYMBOL = n(b'\xF0\x9F\x94\x85')
     HIGH_BRIGHTNESS_SYMBOL = n(b'\xF0\x9F\x94\x86')

telegram/error.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,10 +16,24 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram Error."""
 
-"""This module contains a object that represents a Telegram Error"""
 
-import re
+def _lstrip_str(in_s, lstr):
+    """
+    Args:
+        in_s (str): in string
+        lstr (str): substr to strip from left side
+
+    Returns:
+        str:
+
+    """
+    if in_s.startswith(lstr):
+        res = in_s[len(lstr):]
+    else:
+        res = in_s
+    return res
 
 
 class TelegramError(Exception):
@@ -26,16 +41,47 @@ class TelegramError(Exception):
 
     def __init__(self, message):
         """
+        Args:
+            message (str):
+
         Returns:
-            str:
+
         """
         super(TelegramError, self).__init__()
 
-        api_error = re.match(r'^Error: (?P<message>.*)', message)
-        if api_error:
-            self.message = api_error.group('message').capitalize()
-        else:
-            self.message = message
+        msg = _lstrip_str(message, 'Error: ')
+        msg = _lstrip_str(msg, '[Error]: ')
+        msg = _lstrip_str(msg, 'Bad Request: ')
+        if msg != message:
+            # api_error - capitalize the msg...
+            msg = msg.capitalize()
+        self.message = msg
 
     def __str__(self):
         return '%s' % (self.message)
+
+
+class Unauthorized(TelegramError):
+
+    def __init__(self):
+        super(Unauthorized, self).__init__('Unauthorized')
+
+
+class InvalidToken(TelegramError):
+
+    def __init__(self):
+        super(InvalidToken, self).__init__('Invalid token')
+
+
+class NetworkError(TelegramError):
+    pass
+
+
+class BadRequest(NetworkError):
+    pass
+
+
+class TimedOut(NetworkError):
+
+    def __init__(self):
+        super(TimedOut, self).__init__('Timed out')

telegram/ext/__init__.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""Extensions over the Telegram Bot API to facilitate bot making"""
+
+from .dispatcher import Dispatcher
+from .jobqueue import JobQueue
+from .updater import Updater
+from .callbackqueryhandler import CallbackQueryHandler
+from .choseninlineresulthandler import ChosenInlineResultHandler
+from .commandhandler import CommandHandler
+from .handler import Handler
+from .inlinequeryhandler import InlineQueryHandler
+from .messagehandler import MessageHandler, Filters
+from .regexhandler import RegexHandler
+from .stringcommandhandler import StringCommandHandler
+from .stringregexhandler import StringRegexHandler
+from .typehandler import TypeHandler
+
+__all__ = ('Dispatcher', 'JobQueue', 'Updater', 'CallbackQueryHandler',
+           'ChosenInlineResultHandler', 'CommandHandler', 'Handler', 'InlineQueryHandler',
+           'MessageHandler', 'Filters', 'RegexHandler', 'StringCommandHandler',
+           'StringRegexHandler', 'TypeHandler')

telegram/ext/callbackqueryhandler.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the CallbackQueryHandler class """
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class CallbackQueryHandler(Handler):
+    """
+    Handler class to handle Telegram callback queries.
+
+    Args:
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, callback, pass_update_queue=False):
+        super(CallbackQueryHandler, self).__init__(callback, pass_update_queue)
+
+    def check_update(self, update):
+        return isinstance(update, Update) and update.callback_query
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.CallbackQueryHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/choseninlineresulthandler.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the ChosenInlineResultHandler class """
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class ChosenInlineResultHandler(Handler):
+    """
+    Handler class to handle Telegram updates that contain a chosen inline
+    result.
+
+    Args:
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, callback, pass_update_queue=False):
+        super(ChosenInlineResultHandler, self).__init__(callback, pass_update_queue)
+
+    def check_update(self, update):
+        return isinstance(update, Update) and update.chosen_inline_result
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.ChosenInlineResultHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/commandhandler.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the CommandHandler class """
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class CommandHandler(Handler):
+    """
+    Handler class to handle Telegram commands. Commands are Telegram messages
+    that start with ``/``, optionally followed by an ``@`` and the bot's
+    name and/or some additional text.
+
+    Args:
+        command (str): The name of the command this handler should listen for.
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        allow_edited (Optional[bool]): If the handler should also accept edited messages.
+            Default is ``False``
+        pass_args (optional[bool]): If the handler should be passed the
+            arguments passed to the command as a keyword argument called `
+            ``args``. It will contain a list of strings, which is the text
+            following the command split on spaces. Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self,
+                 command,
+                 callback,
+                 allow_edited=False,
+                 pass_args=False,
+                 pass_update_queue=False):
+        super(CommandHandler, self).__init__(callback, pass_update_queue)
+        self.command = command
+        self.allow_edited = allow_edited
+        self.pass_args = pass_args
+
+    def check_update(self, update):
+        if (isinstance(update, Update)
+                and (update.message or update.edited_message and self.allow_edited)):
+            message = update.message or update.edited_message
+
+            return (message.text and message.text.startswith('/')
+                    and message.text[1:].split(' ')[0].split('@')[0] == self.command)
+
+        else:
+            return False
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        message = update.message or update.edited_message
+
+        if self.pass_args:
+            optional_args['args'] = message.text.split(' ')[1:]
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.CommandHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/dispatcher.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains the Dispatcher class."""
+
+import logging
+from functools import wraps
+from threading import Thread, Lock, Event, current_thread
+from time import sleep
+from queue import Queue, Empty
+
+from future.builtins import range
+
+from telegram import (TelegramError, NullHandler)
+from telegram.utils import request
+from telegram.ext.handler import Handler
+from telegram.utils.deprecate import deprecate
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+ASYNC_QUEUE = Queue()
+ASYNC_THREADS = set()
+""":type: set[Thread]"""
+ASYNC_LOCK = Lock()  # guards ASYNC_THREADS
+DEFAULT_GROUP = 0
+
+
+def _pooled():
+    """
+    A wrapper to run a thread in a thread pool
+    """
+    while 1:
+        try:
+            func, args, kwargs = ASYNC_QUEUE.get()
+
+        # If unpacking fails, the thread pool is being closed from Updater._join_async_threads
+        except TypeError:
+            logging.getLogger(__name__).debug("Closing run_async thread %s/%d" %
+                                              (current_thread().getName(), len(ASYNC_THREADS)))
+            break
+
+        try:
+            func(*args, **kwargs)
+
+        except:
+            logging.getLogger(__name__).exception("run_async function raised exception")
+
+
+def run_async(func):
+    """
+    Function decorator that will run the function in a new thread.
+
+    Args:
+        func (function): The function to run in the thread.
+
+    Returns:
+        function:
+    """
+
+    # TODO: handle exception in async threads
+    #       set a threading.Event to notify caller thread
+
+    @wraps(func)
+    def async_func(*args, **kwargs):
+        """
+        A wrapper to run a function in a thread
+        """
+        ASYNC_QUEUE.put((func, args, kwargs))
+
+    return async_func
+
+
+class Dispatcher(object):
+    """
+    This class dispatches all kinds of updates to its registered handlers.
+
+    Args:
+        bot (telegram.Bot): The bot object that should be passed to the
+            handlers
+        update_queue (Queue): The synchronized queue that will contain the
+            updates.
+    """
+
+    def __init__(self, bot, update_queue, workers=4, exception_event=None):
+        self.bot = bot
+        self.update_queue = update_queue
+
+        self.handlers = {}
+        """:type: dict[int, list[Handler]"""
+        self.groups = []
+        """:type: list[int]"""
+        self.error_handlers = []
+
+        self.logger = logging.getLogger(__name__)
+        self.running = False
+        self.__stop_event = Event()
+        self.__exception_event = exception_event or Event()
+
+        with ASYNC_LOCK:
+            if not ASYNC_THREADS:
+                if request.is_con_pool_initialized():
+                    raise RuntimeError('Connection Pool already initialized')
+
+                request.CON_POOL_SIZE = workers + 3
+                for i in range(workers):
+                    thread = Thread(target=_pooled, name=str(i))
+                    ASYNC_THREADS.add(thread)
+                    thread.start()
+            else:
+                self.logger.debug('Thread pool already initialized, skipping.')
+
+    def start(self):
+        """
+        Thread target of thread 'dispatcher'. Runs in background and processes
+        the update queue.
+        """
+
+        if self.running:
+            self.logger.warning('already running')
+            return
+
+        if self.__exception_event.is_set():
+            msg = 'reusing dispatcher after exception event is forbidden'
+            self.logger.error(msg)
+            raise TelegramError(msg)
+
+        self.running = True
+        self.logger.debug('Dispatcher started')
+
+        while 1:
+            try:
+                # Pop update from update queue.
+                update = self.update_queue.get(True, 1)
+            except Empty:
+                if self.__stop_event.is_set():
+                    self.logger.debug('orderly stopping')
+                    break
+                elif self.__exception_event.is_set():
+                    self.logger.critical('stopping due to exception in another thread')
+                    break
+                continue
+
+            self.logger.debug('Processing Update: %s' % update)
+            self.process_update(update)
+
+        self.running = False
+        self.logger.debug('Dispatcher thread stopped')
+
+    def stop(self):
+        """
+        Stops the thread
+        """
+        if self.running:
+            self.__stop_event.set()
+            while self.running:
+                sleep(0.1)
+            self.__stop_event.clear()
+
+    def process_update(self, update):
+        """
+        Processes a single update.
+
+        Args:
+            update (object):
+        """
+
+        # An error happened while polling
+        if isinstance(update, TelegramError):
+            self.dispatch_error(None, update)
+
+        else:
+            for group in self.groups:
+                for handler in self.handlers[group]:
+                    try:
+                        if handler.check_update(update):
+                            handler.handle_update(update, self)
+                            break
+                    # Dispatch any errors
+                    except TelegramError as te:
+                        self.logger.warn('A TelegramError was raised while processing the '
+                                         'Update.')
+
+                        try:
+                            self.dispatch_error(update, te)
+                        except Exception:
+                            self.logger.exception('An uncaught error was raised while '
+                                                  'handling the error')
+                        finally:
+                            break
+
+                    # Errors should not stop the thread
+                    except Exception:
+                        self.logger.exception('An uncaught error was raised while '
+                                              'processing the update')
+                        break
+
+    def add_handler(self, handler, group=DEFAULT_GROUP):
+        """
+        Register a handler.
+
+        TL;DR: Order and priority counts. 0 or 1 handlers per group will be
+        used.
+
+        A handler must be an instance of a subclass of
+        telegram.ext.Handler. All handlers are organized in groups with a
+        numeric value. The default group is 0. All groups will be evaluated for
+        handling an update, but only 0 or 1 handler per group will be used.
+
+        The priority/order of handlers is determined as follows:
+
+          * Priority of the group (lower group number == higher priority)
+
+          * The first handler in a group which should handle an update will be
+            used. Other handlers from the group will not be used. The order in
+            which handlers were added to the group defines the priority.
+
+        Args:
+            handler (Handler): A Handler instance
+            group (Optional[int]): The group identifier. Default is 0
+        """
+
+        if not isinstance(handler, Handler):
+            raise TypeError('handler is not an instance of {0}'.format(Handler.__name__))
+        if not isinstance(group, int):
+            raise TypeError('group is not int')
+
+        if group not in self.handlers:
+            self.handlers[group] = list()
+            self.groups.append(group)
+            self.groups = sorted(self.groups)
+
+        self.handlers[group].append(handler)
+
+    def remove_handler(self, handler, group=DEFAULT_GROUP):
+        """
+        Remove a handler from the specified group
+
+        Args:
+            handler (Handler): A Handler instance
+            group (optional[object]): The group identifier. Default is 0
+        """
+        if handler in self.handlers[group]:
+            self.handlers[group].remove(handler)
+            if not self.handlers[group]:
+                del self.handlers[group]
+                self.groups.remove(group)
+
+    def add_error_handler(self, callback):
+        """
+        Registers an error handler in the Dispatcher.
+
+        Args:
+            handler (function): A function that takes ``Bot, Update,
+                TelegramError`` as arguments.
+        """
+
+        self.error_handlers.append(callback)
+
+    def remove_error_handler(self, callback):
+        """
+        De-registers an error handler.
+
+        Args:
+            handler (function):
+        """
+
+        if callback in self.error_handlers:
+            self.error_handlers.remove(callback)
+
+    def dispatch_error(self, update, error):
+        """
+        Dispatches an error.
+
+        Args:
+            update (object): The update that caused the error
+            error (telegram.TelegramError): The Telegram error that was raised.
+        """
+
+        for callback in self.error_handlers:
+            callback(self.bot, update, error)
+
+    # old non-PEP8 Dispatcher methods
+    m = "telegram.dispatcher."
+    addHandler = deprecate(add_handler, m + "AddHandler", m + "add_handler")
+    removeHandler = deprecate(remove_handler, m + "removeHandler", m + "remove_handler")
+    addErrorHandler = deprecate(add_error_handler, m + "addErrorHandler", m + "add_error_handler")
+    removeErrorHandler = deprecate(remove_error_handler, m + "removeErrorHandler",
+                                   m + "remove_error_handler")

telegram/ext/handler.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the base class for handlers as used by the
+Dispatcher """
+
+from telegram.utils.deprecate import deprecate
+
+
+class Handler(object):
+    """
+    The base class for all update handlers. You can create your own handlers
+    by inheriting from this class.
+
+    Args:
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_update_queue (optional[bool]): If the callback should be passed
+            the update queue as a keyword argument called ``update_queue``. It
+            can be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, callback, pass_update_queue=False):
+        self.callback = callback
+        self.pass_update_queue = pass_update_queue
+
+    def check_update(self, update):
+        """
+        This method is called to determine if an update should be handled by
+        this handler instance. It should always be overridden.
+
+        Args:
+            update (object): The update to be tested
+
+        Returns:
+            bool
+        """
+        raise NotImplementedError
+
+    def handle_update(self, update, dispatcher):
+        """
+        This method is called if it was determined that an update should indeed
+        be handled by this instance. It should also be overridden, but in most
+        cases call self.callback(dispatcher.bot, update), possibly along with
+        optional arguments.
+
+        Args:
+            update (object): The update to be handled
+
+        """
+        raise NotImplementedError
+
+    def collect_optional_args(self, dispatcher):
+        """
+        Prepares the optional arguments that are the same for all types of
+        handlers
+
+        Args:
+            dispatcher (Dispatcher):
+        """
+        optional_args = dict()
+        if self.pass_update_queue:
+            optional_args['update_queue'] = dispatcher.update_queue
+
+        return optional_args
+
+    # old non-PEP8 Handler methods
+    m = "telegram.Handler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")
+    collectOptionalArgs = deprecate(collect_optional_args, m + "collectOptionalArgs",
+                                    m + "collect_optional_args")

telegram/ext/inlinequeryhandler.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the InlineQueryHandler class """
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class InlineQueryHandler(Handler):
+    """
+    Handler class to handle Telegram inline queries.
+
+    Args:
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, callback, pass_update_queue=False):
+        super(InlineQueryHandler, self).__init__(callback, pass_update_queue)
+
+    def check_update(self, update):
+        return isinstance(update, Update) and update.inline_query
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.InlineQueryHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/jobqueue.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains the class JobQueue."""
+
+import logging
+import time
+from threading import Thread, Lock
+from queue import PriorityQueue
+
+
+class JobQueue(object):
+    """
+    This class allows you to periodically perform tasks with the bot.
+
+    Attributes:
+        tick_interval (float):
+        queue (PriorityQueue):
+        bot (Bot):
+        running (bool):
+
+    Args:
+        bot (Bot): The bot instance that should be passed to the jobs
+        tick_interval (Optional[float]): The interval this queue should check
+            the newest task in seconds. Defaults to 1.0
+
+    """
+
+    def __init__(self, bot, tick_interval=1.0):
+        self.tick_interval = tick_interval
+        self.queue = PriorityQueue()
+        self.bot = bot
+        self.logger = logging.getLogger(__name__)
+        self.__lock = Lock()
+        self.running = False
+
+    def put(self, run, interval, repeat=True, next_t=None, prevent_autostart=False):
+        """
+        Queue a new job. If the JobQueue is not running, it will be started.
+
+        Args:
+            run (function): A function that takes the parameter `bot`
+            interval (float): The interval in seconds in which `run` should be
+                executed
+            repeat (Optional[bool]): If `False`, job will only be executed once
+            next_t (Optional[float]): Time in seconds in which run should be
+                executed first. Defaults to `interval`
+            prevent_autostart (Optional[bool]): If `True`, the job queue will
+                not be started automatically if it is not running.
+        """
+        name = run.__name__
+
+        job = JobQueue.Job()
+        job.run = run
+        job.interval = interval
+        job.name = name
+        job.repeat = repeat
+
+        if next_t is None:
+            next_t = interval
+
+        next_t += time.time()
+
+        self.logger.debug('Putting a %s with t=%f' % (job.name, next_t))
+        self.queue.put((next_t, job))
+
+        if not self.running and not prevent_autostart:
+            self.logger.debug('Auto-starting JobQueue')
+            self.start()
+
+    def tick(self):
+        """
+        Run all jobs that are due and re-enqueue them with their interval
+        """
+        now = time.time()
+
+        self.logger.debug('Ticking jobs with t=%f' % now)
+        while not self.queue.empty():
+            t, j = self.queue.queue[0]
+            self.logger.debug('Peeked at %s with t=%f' % (j.name, t))
+
+            if t < now:
+                self.queue.get()
+                self.logger.debug('Running job %s' % j.name)
+                try:
+                    j.run(self.bot)
+                except:
+                    self.logger.exception('An uncaught error was raised while '
+                                          'executing job %s' % j.name)
+                if j.repeat:
+                    self.put(j.run, j.interval)
+                continue
+
+            self.logger.debug('Next task isn\'t due yet. Finished!')
+            break
+
+    def start(self):
+        """
+        Starts the job_queue thread.
+        """
+        self.__lock.acquire()
+        if not self.running:
+            self.running = True
+            self.__lock.release()
+            job_queue_thread = Thread(target=self._start, name="job_queue")
+            job_queue_thread.start()
+            self.logger.debug('Job Queue thread started')
+        else:
+            self.__lock.release()
+
+    def _start(self):
+        """
+        Thread target of thread 'job_queue'. Runs in background and performs
+        ticks on the job queue.
+        """
+        while self.running:
+            self.tick()
+            time.sleep(self.tick_interval)
+
+        self.logger.debug('Job Queue thread stopped')
+
+    def stop(self):
+        """
+        Stops the thread
+        """
+        with self.__lock:
+            self.running = False
+
+    class Job(object):
+        """ Inner class that represents a job """
+        interval = None
+        name = None
+        repeat = None
+
+        def run(self):
+            pass
+
+        def __lt__(self, other):
+            return False

telegram/ext/messagehandler.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the MessageHandler class """
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class Filters(object):
+    """
+    Convenient namespace (class) & methods for the filter funcs of the
+    MessageHandler class.
+    """
+
+    @staticmethod
+    def text(message):
+        return message.text and not message.text.startswith('/')
+
+    @staticmethod
+    def command(message):
+        return message.text and message.text.startswith('/')
+
+    @staticmethod
+    def audio(message):
+        return bool(message.audio)
+
+    @staticmethod
+    def document(message):
+        return bool(message.document)
+
+    @staticmethod
+    def photo(message):
+        return bool(message.photo)
+
+    @staticmethod
+    def sticker(message):
+        return bool(message.sticker)
+
+    @staticmethod
+    def video(message):
+        return bool(message.video)
+
+    @staticmethod
+    def voice(message):
+        return bool(message.voice)
+
+    @staticmethod
+    def contact(message):
+        return bool(message.contact)
+
+    @staticmethod
+    def location(message):
+        return bool(message.location)
+
+    @staticmethod
+    def venue(message):
+        return bool(message.venue)
+
+    @staticmethod
+    def status_update(message):
+        return bool(message.new_chat_member or message.left_chat_member or message.new_chat_title
+                    or message.new_chat_photo or message.delete_chat_photo
+                    or message.group_chat_created or message.supergroup_chat_created
+                    or message.channel_chat_created or message.migrate_to_chat_id
+                    or message.migrate_from_chat_id or message.pinned_message)
+
+
+class MessageHandler(Handler):
+    """
+    Handler class to handle telegram messages. Messages are Telegram Updates
+    that do not contain a command. They might contain text, media or status
+    updates.
+
+    Args:
+        filters (list[function]): A list of filter functions. Standard filters
+            can be found in the Filters class above.
+          | Each `function` takes ``Update`` as arg and returns ``bool``.
+          | All messages that match at least one of those filters will be
+            accepted. If ``bool(filters)`` evaluates to ``False``, messages are
+            not filtered.
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        allow_edited (Optional[bool]): If the handler should also accept edited messages.
+            Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, filters, callback, allow_edited=False, pass_update_queue=False):
+        super(MessageHandler, self).__init__(callback, pass_update_queue)
+        self.filters = filters
+        self.allow_edited = allow_edited
+
+    def check_update(self, update):
+        if (isinstance(update, Update)
+                and (update.message or update.edited_message and self.allow_edited)):
+
+            if not self.filters:
+                res = True
+
+            else:
+                message = update.message or update.edited_message
+                res = any(func(message) for func in self.filters)
+
+        else:
+            res = False
+
+        return res
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.MessageHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/regexhandler.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the RegexHandler class """
+
+import re
+
+from future.utils import string_types
+
+from .handler import Handler
+from telegram import Update
+from telegram.utils.deprecate import deprecate
+
+
+class RegexHandler(Handler):
+    """
+    Handler class to handle Telegram updates based on a regex. It uses a
+    regular expression to check text messages. Read the documentation of the
+    ``re`` module for more information. The ``re.match`` function is used to
+    determine if an update should be handled by this handler.
+
+    Args:
+        pattern (str or Pattern): The regex pattern.
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_groups (optional[bool]): If the callback should be passed the
+            result of ``re.match(pattern, text).groups()`` as a keyword
+            argument called ``groups``. Default is ``False``
+        pass_groupdict (optional[bool]): If the callback should be passed the
+            result of ``re.match(pattern, text).groupdict()`` as a keyword
+            argument called ``groupdict``. Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self,
+                 pattern,
+                 callback,
+                 pass_groups=False,
+                 pass_groupdict=False,
+                 pass_update_queue=False):
+        super(RegexHandler, self).__init__(callback, pass_update_queue)
+
+        if isinstance(pattern, string_types):
+            pattern = re.compile(pattern)
+
+        self.pattern = pattern
+        self.pass_groups = pass_groups
+        self.pass_groupdict = pass_groupdict
+
+    def check_update(self, update):
+        if (isinstance(update, Update) and update.message and update.message.text):
+            match = re.match(self.pattern, update.message.text)
+            return bool(match)
+        else:
+            return False
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+        match = re.match(self.pattern, update.message.text)
+
+        if self.pass_groups:
+            optional_args['groups'] = match.groups()
+        if self.pass_groupdict:
+            optional_args['groupdict'] = match.groupdict()
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.RegexHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/stringcommandhandler.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the StringCommandHandler class """
+
+from .handler import Handler
+from telegram.utils.deprecate import deprecate
+
+
+class StringCommandHandler(Handler):
+    """
+    Handler class to handle string commands. Commands are string updates
+    that start with ``/``.
+
+    Args:
+        command (str): The name of the command this handler should listen for.
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_args (optional[bool]): If the handler should be passed the
+            arguments passed to the command as a keyword argument called `
+            ``args``. It will contain a list of strings, which is the text
+            following the command split on spaces. Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, command, callback, pass_args=False, pass_update_queue=False):
+        super(StringCommandHandler, self).__init__(callback, pass_update_queue)
+        self.command = command
+        self.pass_args = pass_args
+
+    def check_update(self, update):
+        return (isinstance(update, str) and update.startswith('/')
+                and update[1:].split(' ')[0] == self.command)
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        if self.pass_args:
+            optional_args['args'] = update.split(' ')[1:]
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.StringCommandHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/stringregexhandler.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the StringRegexHandler class """
+
+import re
+
+from future.utils import string_types
+
+from .handler import Handler
+from telegram.utils.deprecate import deprecate
+
+
+class StringRegexHandler(Handler):
+    """
+    Handler class to handle string updates based on a regex. It uses a
+    regular expression to check update content. Read the documentation of the
+    ``re`` module for more information. The ``re.match`` function is used to
+    determine if an update should be handled by this handler.
+
+    Args:
+        pattern (str or Pattern): The regex pattern.
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        pass_groups (optional[bool]): If the callback should be passed the
+            result of ``re.match(pattern, update).groups()`` as a keyword
+            argument called ``groups``. Default is ``False``
+        pass_groupdict (optional[bool]): If the callback should be passed the
+            result of ``re.match(pattern, update).groupdict()`` as a keyword
+            argument called ``groupdict``. Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self,
+                 pattern,
+                 callback,
+                 pass_groups=False,
+                 pass_groupdict=False,
+                 pass_update_queue=False):
+        super(StringRegexHandler, self).__init__(callback, pass_update_queue)
+
+        if isinstance(pattern, string_types):
+            pattern = re.compile(pattern)
+
+        self.pattern = pattern
+        self.pass_groups = pass_groups
+        self.pass_groupdict = pass_groupdict
+
+    def check_update(self, update):
+        return isinstance(update, string_types) and bool(re.match(self.pattern, update))
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+        match = re.match(self.pattern, update)
+
+        if self.pass_groups:
+            optional_args['groups'] = match.groups()
+        if self.pass_groupdict:
+            optional_args['groupdict'] = match.groupdict()
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.StringRegexHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/typehandler.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+""" This module contains the TypeHandler class """
+
+from .handler import Handler
+from telegram.utils.deprecate import deprecate
+
+
+class TypeHandler(Handler):
+    """
+    Handler class to handle updates of custom types.
+
+    Args:
+        type (type): The ``type`` of updates this handler should process, as
+            determined by ``isinstance``
+        callback (function): A function that takes ``bot, update`` as
+            positional arguments. It will be called when the ``check_update``
+            has determined that an update should be processed by this handler.
+        strict (optional[bool]): Use ``type`` instead of ``isinstance``.
+            Default is ``False``
+        pass_update_queue (optional[bool]): If the handler should be passed the
+            update queue as a keyword argument called ``update_queue``. It can
+            be used to insert updates. Default is ``False``
+    """
+
+    def __init__(self, type, callback, strict=False, pass_update_queue=False):
+        super(TypeHandler, self).__init__(callback, pass_update_queue)
+        self.type = type
+        self.strict = strict
+
+    def check_update(self, update):
+        if not self.strict:
+            return isinstance(update, self.type)
+        else:
+            return type(update) is self.type
+
+    def handle_update(self, update, dispatcher):
+        optional_args = self.collect_optional_args(dispatcher)
+
+        self.callback(dispatcher.bot, update, **optional_args)
+
+    # old non-PEP8 Handler methods
+    m = "telegram.TypeHandler."
+    checkUpdate = deprecate(check_update, m + "checkUpdate", m + "check_update")
+    handleUpdate = deprecate(handle_update, m + "handleUpdate", m + "handle_update")

telegram/ext/updater.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains the class Updater, which tries to make creating
+Telegram bots intuitive."""
+
+import logging
+import os
+import ssl
+from threading import Thread, Lock, current_thread, Event
+from time import sleep
+import subprocess
+from signal import signal, SIGINT, SIGTERM, SIGABRT
+from queue import Queue
+
+from telegram import Bot, TelegramError, NullHandler
+from telegram.ext import dispatcher, Dispatcher, JobQueue
+from telegram.error import Unauthorized, InvalidToken
+from telegram.utils.webhookhandler import (WebhookServer, WebhookHandler)
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+class Updater(object):
+    """
+    This class, which employs the Dispatcher class, provides a frontend to
+    telegram.Bot to the programmer, so they can focus on coding the bot. Its
+    purpose is to receive the updates from Telegram and to deliver them to said
+    dispatcher. It also runs in a separate thread, so the user can interact
+    with the bot, for example on the command line. The dispatcher supports
+    handlers for different kinds of data: Updates from Telegram, basic text
+    commands and even arbitrary types.
+    The updater can be started as a polling service or, for production, use a
+    webhook to receive updates. This is achieved using the WebhookServer and
+    WebhookHandler classes.
+
+
+    Attributes:
+
+    Args:
+        token (Optional[str]): The bot's token given by the @BotFather
+        base_url (Optional[str]):
+        workers (Optional[int]): Amount of threads in the thread pool for
+            functions decorated with @run_async
+        bot (Optional[Bot]):
+        job_queue_tick_interval(Optional[float]): The interval the queue should
+            be checked for new tasks. Defaults to 1.0
+
+    Raises:
+        ValueError: If both `token` and `bot` are passed or none of them.
+    """
+
+    def __init__(self,
+                 token=None,
+                 base_url=None,
+                 workers=4,
+                 bot=None,
+                 job_queue_tick_interval=1.0):
+        if (token is None) and (bot is None):
+            raise ValueError('`token` or `bot` must be passed')
+        if (token is not None) and (bot is not None):
+            raise ValueError('`token` and `bot` are mutually exclusive')
+
+        if bot is not None:
+            self.bot = bot
+        else:
+            self.bot = Bot(token, base_url)
+        self.update_queue = Queue()
+        self.job_queue = JobQueue(self.bot, job_queue_tick_interval)
+        self.__exception_event = Event()
+        self.dispatcher = Dispatcher(self.bot, self.update_queue, workers, self.__exception_event)
+        self.last_update_id = 0
+        self.logger = logging.getLogger(__name__)
+        self.running = False
+        self.is_idle = False
+        self.httpd = None
+        self.__lock = Lock()
+        self.__threads = []
+        """:type: list[Thread]"""
+
+    def _init_thread(self, target, name, *args, **kwargs):
+        thr = Thread(target=self._thread_wrapper, name=name, args=(target,) + args, kwargs=kwargs)
+        thr.start()
+        self.__threads.append(thr)
+
+    def _thread_wrapper(self, target, *args, **kwargs):
+        thr_name = current_thread().name
+        self.logger.debug('{0} - started'.format(thr_name))
+        try:
+            target(*args, **kwargs)
+        except Exception:
+            self.__exception_event.set()
+            self.logger.exception('unhandled exception')
+            raise
+        self.logger.debug('{0} - ended'.format(thr_name))
+
+    def start_polling(self,
+                      poll_interval=0.0,
+                      timeout=10,
+                      network_delay=5.,
+                      clean=False,
+                      bootstrap_retries=0):
+        """
+        Starts polling updates from Telegram.
+
+        Args:
+            poll_interval (Optional[float]): Time to wait between polling updates from Telegram in
+            seconds. Default is 0.0
+
+            timeout (Optional[float]): Passed to Bot.getUpdates
+
+            network_delay (Optional[float]): Passed to Bot.getUpdates
+
+            clean (Optional[bool]): Whether to clean any pending updates on Telegram servers before
+              actually starting to poll. Default is False.
+
+            bootstrap_retries (Optional[int]): Whether the bootstrapping phase of the `Updater`
+              will retry on failures on the Telegram server.
+
+                |   < 0 - retry indefinitely
+                |   0 - no retries (default)
+                |   > 0 - retry up to X times
+
+        Returns:
+            Queue: The update queue that can be filled from the main thread
+
+        """
+        with self.__lock:
+            if not self.running:
+                self.running = True
+
+                # Create & start threads
+                self._init_thread(self.dispatcher.start, "dispatcher")
+                self._init_thread(self._start_polling, "updater", poll_interval, timeout,
+                                  network_delay, bootstrap_retries, clean)
+
+                # Return the update queue so the main thread can insert updates
+                return self.update_queue
+
+    def start_webhook(self,
+                      listen='127.0.0.1',
+                      port=80,
+                      url_path='',
+                      cert=None,
+                      key=None,
+                      clean=False,
+                      bootstrap_retries=0,
+                      webhook_url=None):
+        """
+        Starts a small http server to listen for updates via webhook. If cert
+        and key are not provided, the webhook will be started directly on
+        http://listen:port/url_path, so SSL can be handled by another
+        application. Else, the webhook will be started on
+        https://listen:port/url_path
+
+        Args:
+            listen (Optional[str]): IP-Address to listen on
+            port (Optional[int]): Port the bot should be listening on
+            url_path (Optional[str]): Path inside url
+            cert (Optional[str]): Path to the SSL certificate file
+            key (Optional[str]): Path to the SSL key file
+            clean (Optional[bool]): Whether to clean any pending updates on
+                Telegram servers before actually starting the webhook. Default
+                is False.
+            bootstrap_retries (Optional[int[): Whether the bootstrapping phase
+                of the `Updater` will retry on failures on the Telegram server.
+
+                |   < 0 - retry indefinitely
+                |   0 - no retries (default)
+                |   > 0 - retry up to X times
+            webhook_url (Optional[str]): Explicitly specifiy the webhook url.
+                Useful behind NAT, reverse proxy, etc. Default is derived from
+                `listen`, `port` & `url_path`.
+
+        Returns:
+            Queue: The update queue that can be filled from the main thread
+
+        """
+        with self.__lock:
+            if not self.running:
+                self.running = True
+
+                # Create & start threads
+                self._init_thread(self.dispatcher.start, "dispatcher"),
+                self._init_thread(self._start_webhook, "updater", listen, port, url_path, cert,
+                                  key, bootstrap_retries, clean, webhook_url)
+
+                # Return the update queue so the main thread can insert updates
+                return self.update_queue
+
+    def _start_polling(self, poll_interval, timeout, network_delay, bootstrap_retries, clean):
+        """
+        Thread target of thread 'updater'. Runs in background, pulls
+        updates from Telegram and inserts them in the update queue of the
+        Dispatcher.
+
+        """
+        cur_interval = poll_interval
+        self.logger.debug('Updater thread started')
+
+        self._bootstrap(bootstrap_retries, clean=clean, webhook_url='')
+
+        while self.running:
+            try:
+                updates = self.bot.getUpdates(self.last_update_id,
+                                              timeout=timeout,
+                                              network_delay=network_delay)
+            except TelegramError as te:
+                self.logger.error("Error while getting Updates: {0}".format(te))
+
+                # Put the error into the update queue and let the Dispatcher
+                # broadcast it
+                self.update_queue.put(te)
+
+                cur_interval = self._increase_poll_interval(cur_interval)
+            else:
+                if not self.running:
+                    if len(updates) > 0:
+                        self.logger.debug('Updates ignored and will be pulled '
+                                          'again on restart.')
+                    break
+
+                if updates:
+                    for update in updates:
+                        self.update_queue.put(update)
+                    self.last_update_id = updates[-1].update_id + 1
+
+                cur_interval = poll_interval
+
+            sleep(cur_interval)
+
+    @staticmethod
+    def _increase_poll_interval(current_interval):
+        # increase waiting times on subsequent errors up to 30secs
+        if current_interval == 0:
+            current_interval = 1
+        elif current_interval < 30:
+            current_interval += current_interval / 2
+        elif current_interval > 30:
+            current_interval = 30
+        return current_interval
+
+    def _start_webhook(self, listen, port, url_path, cert, key, bootstrap_retries, clean,
+                       webhook_url):
+        self.logger.debug('Updater thread started')
+        use_ssl = cert is not None and key is not None
+        if not url_path.startswith('/'):
+            url_path = '/{0}'.format(url_path)
+
+        # Create and start server
+        self.httpd = WebhookServer((listen, port), WebhookHandler, self.update_queue, url_path)
+
+        if use_ssl:
+            self._check_ssl_cert(cert, key)
+
+            # DO NOT CHANGE: Only set webhook if SSL is handled by library
+            if not webhook_url:
+                webhook_url = self._gen_webhook_url(listen, port, url_path)
+
+            self._bootstrap(max_retries=bootstrap_retries,
+                            clean=clean,
+                            webhook_url=webhook_url,
+                            cert=open(cert, 'rb'))
+        elif clean:
+            self.logger.warning("cleaning updates is not supported if "
+                                "SSL-termination happens elsewhere; skipping")
+
+        self.httpd.serve_forever(poll_interval=1)
+
+    def _check_ssl_cert(self, cert, key):
+        # Check SSL-Certificate with openssl, if possible
+        try:
+            exit_code = subprocess.call(
+                ["openssl", "x509", "-text", "-noout", "-in", cert],
+                stdout=open(os.devnull, 'wb'),
+                stderr=subprocess.STDOUT)
+        except OSError:
+            exit_code = 0
+        if exit_code is 0:
+            try:
+                self.httpd.socket = ssl.wrap_socket(self.httpd.socket,
+                                                    certfile=cert,
+                                                    keyfile=key,
+                                                    server_side=True)
+            except ssl.SSLError as error:
+                self.logger.exception('Failed to init SSL socket')
+                raise TelegramError(str(error))
+        else:
+            raise TelegramError('SSL Certificate invalid')
+
+    @staticmethod
+    def _gen_webhook_url(listen, port, url_path):
+        return 'https://{listen}:{port}{path}'.format(listen=listen, port=port, path=url_path)
+
+    def _bootstrap(self, max_retries, clean, webhook_url, cert=None):
+        retries = 0
+        while 1:
+
+            try:
+                if clean:
+                    # Disable webhook for cleaning
+                    self.bot.setWebhook(webhook_url='')
+                    self._clean_updates()
+
+                self.bot.setWebhook(webhook_url=webhook_url, certificate=cert)
+            except (Unauthorized, InvalidToken):
+                raise
+            except TelegramError:
+                msg = 'error in bootstrap phase; try={0} max_retries={1}'.format(retries,
+                                                                                 max_retries)
+                if max_retries < 0 or retries < max_retries:
+                    self.logger.warning(msg)
+                    retries += 1
+                else:
+                    self.logger.exception(msg)
+                    raise
+            else:
+                break
+            sleep(1)
+
+    def _clean_updates(self):
+        self.logger.debug('Cleaning updates from Telegram server')
+        updates = self.bot.getUpdates()
+        while updates:
+            updates = self.bot.getUpdates(updates[-1].update_id + 1)
+
+    def stop(self):
+        """
+        Stops the polling/webhook thread, the dispatcher and the job queue
+        """
+
+        self.job_queue.stop()
+        with self.__lock:
+            if self.running or dispatcher.ASYNC_THREADS:
+                self.logger.debug('Stopping Updater and Dispatcher...')
+
+                self.running = False
+
+                self._stop_httpd()
+                self._stop_dispatcher()
+                self._join_threads()
+                # async threads must be join()ed only after the dispatcher thread was joined,
+                # otherwise we can still have new async threads dispatched
+                self._join_async_threads()
+
+    def _stop_httpd(self):
+        if self.httpd:
+            self.logger.debug('Waiting for current webhook connection to be '
+                              'closed... Send a Telegram message to the bot to exit '
+                              'immediately.')
+            self.httpd.shutdown()
+            self.httpd = None
+
+    def _stop_dispatcher(self):
+        self.logger.debug('Requesting Dispatcher to stop...')
+        self.dispatcher.stop()
+
+    def _join_async_threads(self):
+        with dispatcher.ASYNC_LOCK:
+            threads = list(dispatcher.ASYNC_THREADS)
+            total = len(threads)
+
+            # Stop all threads in the thread pool by put()ting one non-tuple per thread
+            for i in range(total):
+                dispatcher.ASYNC_QUEUE.put(None)
+
+            for i, thr in enumerate(threads):
+                self.logger.debug('Waiting for async thread {0}/{1} to end'.format(i + 1, total))
+                thr.join()
+                dispatcher.ASYNC_THREADS.remove(thr)
+                self.logger.debug('async thread {0}/{1} has ended'.format(i + 1, total))
+
+    def _join_threads(self):
+        for thr in self.__threads:
+            self.logger.debug('Waiting for {0} thread to end'.format(thr.name))
+            thr.join()
+            self.logger.debug('{0} thread has ended'.format(thr.name))
+        self.__threads = []
+
+    def signal_handler(self, signum, frame):
+        self.is_idle = False
+        if self.running:
+            self.stop()
+        else:
+            self.logger.warning('Exiting immediately!')
+            import os
+            os._exit(1)
+
+    def idle(self, stop_signals=(SIGINT, SIGTERM, SIGABRT)):
+        """
+        Blocks until one of the signals are received and stops the updater
+
+        Args:
+            stop_signals: Iterable containing signals from the signal module
+                that should be subscribed to. Updater.stop() will be called on
+                receiving one of those signals. Defaults to (SIGINT, SIGTERM,
+                SIGABRT)
+        """
+        for sig in stop_signals:
+            signal(sig, self.signal_handler)
+
+        self.is_idle = True
+
+        while self.is_idle:
+            sleep(1)

telegram/file.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,8 +16,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram File"""
+"""This module contains a object that represents a Telegram File."""
 
 from os.path import basename
 
@@ -25,7 +25,6 @@ from telegram.utils.request import download as _download
 
 
 class File(TelegramObject):
-
     """This object represents a Telegram File.
 
     Attributes:
@@ -42,9 +41,7 @@ class File(TelegramObject):
         file_path (Optional[str]):
     """
 
-    def __init__(self,
-                 file_id,
-                 **kwargs):
+    def __init__(self, file_id, **kwargs):
         # Required
         self.file_id = str(file_id)
         # Optionals
@@ -65,8 +62,7 @@ class File(TelegramObject):
 
         return File(**data)
 
-    def download(self,
-                 custom_path=None):
+    def download(self, custom_path=None):
         """
         Args:
             custom_path (str):
@@ -74,7 +70,7 @@ class File(TelegramObject):
         url = self.file_path
 
         if custom_path:
-            filename = basename(custom_path)
+            filename = custom_path
         else:
             filename = basename(url)
 

telegram/forcereply.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 #
 # A library that provides a Python interface to the Telegram Bot API
-# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser Public License as published by
@@ -15,8 +16,7 @@
 #
 # You should have received a copy of the GNU Lesser Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
-
-"""This module contains a object that represents a Telegram ForceReply"""
+"""This module contains a object that represents a Telegram ForceReply."""
 
 from telegram import ReplyMarkup
 
@@ -36,9 +36,7 @@ class ForceReply(ReplyMarkup):
         selective (Optional[bool]):
     """
 
-    def __init__(self,
-                 force_reply=True,
-                 **kwargs):
+    def __init__(self, force_reply=True, **kwargs):
         # Required
         self.force_reply = bool(force_reply)
         # Optionals

telegram/inlinekeyboardbutton.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram
+InlineKeyboardButton"""
+
+from telegram import TelegramObject
+
+
+class InlineKeyboardButton(TelegramObject):
+    """This object represents a Telegram InlineKeyboardButton.
+
+    Attributes:
+        text (str):
+        url (str):
+        callback_data (str):
+        switch_inline_query (str):
+
+    Args:
+        text (str):
+        **kwargs: Arbitrary keyword arguments.
+
+    Keyword Args:
+        url (Optional[str]):
+        callback_data (Optional[str]):
+        switch_inline_query (Optional[str]):
+
+    """
+
+    def __init__(self, text, **kwargs):
+        # Required
+        self.text = text
+
+        # Optionals
+        self.url = kwargs.get('url')
+        self.callback_data = kwargs.get('callback_data')
+        self.switch_inline_query = kwargs.get('switch_inline_query')
+
+    @staticmethod
+    def de_json(data):
+        data = super(InlineKeyboardButton, InlineKeyboardButton).de_json(data)
+
+        if not data:
+            return None
+
+        return InlineKeyboardButton(**data)
+
+    @staticmethod
+    def de_list(data):
+        if not data:
+            return []
+
+        inline_keyboards = list()
+        for inline_keyboard in data:
+            inline_keyboards.append(InlineKeyboardButton.de_json(inline_keyboard))
+
+        return inline_keyboards

telegram/inlinekeyboardmarkup.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015-2016
+# Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram
+InlineKeyboardMarkup"""
+
+from telegram import ReplyMarkup, InlineKeyboardButton
+
+
+class InlineKeyboardMarkup(ReplyMarkup):
+    """This object represents a Telegram InlineKeyboardMarkup.
+
+    Attributes:
+        inline_keyboard (List[List[:class:`telegram.InlineKeyboardButton`]]):
+
+    Args:
+        inline_keyboard (List[List[:class:`telegram.InlineKeyboardButton`]]):
+
+    """
+
+    def __init__(self, inline_keyboard, **kwargs):
+        # Required
+        self.inline_keyboard = inline_keyboard
+
+    @staticmethod
+    def de_json(data):
+        data = super(InlineKeyboardMarkup, InlineKeyboardMarkup).de_json(data)
+
+        if not data:
+            return None
+
+        data['inline_keyboard'] = [InlineKeyboardButton.de_list(inline_keyboard)
+                                   for inline_keyboard in data['inline_keyboard']]
+
+        return InlineKeyboardMarkup(**data)
+
+    def to_dict(self):
+        data = super(InlineKeyboardMarkup, self).to_dict()
+
+        data['inline_keyboard'] = []
+        for inline_keyboard in self.inline_keyboard:
+            data['inline_keyboard'].append([x.to_dict() for x in inline_keyboard])
+
+        return data

telegram/inlinequery.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+# pylint: disable=R0902,R0912,R0913
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <devs@python-telegram-bot.org>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+"""This module contains a object that represents a Telegram InlineQuery"""
+
+from telegram import TelegramObject, User, Location
+
+
+class InlineQuery(TelegramObject):
+    """This object represents a Telegram InlineQuery.
+
+    Note:
+        * In Python `from` is a reserved word, use `from_user` instead.
+
+    Attributes:
+        id (str):
+        from_user (:class:`telegram.User`):
+        query (str):
+        offset (str):
+
+    Args:
+        id (int):
+        from_user (:class:`telegram.User`):
+        query (str):
+        offset (str):
+        **kwargs: Arbitrary keyword arguments.
+
+    Keyword Args:
+        location (optional[:class:`telegram.Location`]):
+    """
+
+    def __init__(self, id, from_user, query, offset, **kwargs):
+        # Required
+        self.id = id
+        self.from_user = from_user
+        self.query = query
+        self.offset = offset
+
+        # Optional
+        self.location = kwargs.get('location')
+
+    @staticmethod
+    def de_json(data):
+        """
+        Args:
+            data (dict):
+
+        Returns:
+            telegram.InlineQuery:
+        """
+        data = super(InlineQuery, InlineQuery).de_json(data)
+
+        if not data:
+            return None
+
+        data['from_user'] = User.de_json(data.get('from'))
+        data['location'] = Location.de_json(data.get('location'))
+
+        return InlineQuery(**data)
+
+    def to_dict(self):
+        """
+        Returns:
+            dict:
+        """
+        data = super(InlineQuery, self).to_dict()
+
+        # Required
+        data['from'] = data.pop('from_user', None)
+
+        return data