Merge pull request #2015 from Badiboy/master

Fix aioredis version check for regular redis

.github/ISSUE_TEMPLATE

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,14 @@
+## Description
+Include changes, new features and etc:
+
+## Describe your tests
+How did you test your change?
+
+Python version:
+
+OS:
+
+## Checklist:
+- [ ] I added/edited example on new feature/change (if exists)
+- [ ] My changes won't break backward compatibility
+- [ ] I made changes both for sync and async

.github/workflows/setup_python.yml

@@ -0,0 +1,35 @@
+# This is a basic workflow to help you get started with Actions
+
+name: Setup
+
+# Controls when the action will run. 
+on:
+  # Triggers the workflow on push or pull request events but only for the master branch
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+  # Allows you to run this workflow manually from the Actions tab
+  #workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "build"
+  all-setups:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [ '3.7', '3.8', '3.9', '3.10', '3.11', 'pypy-3.7', 'pypy-3.8', 'pypy-3.9']
+    name: ${{ matrix.python-version }} and tests
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup python
+        uses: actions/setup-python@v2
+        with:
+          python-version: ${{ matrix.python-version }}
+          architecture: x64
+      - run: |
+          pip3 install -r requirements.txt
+          python setup.py install
+          cd tests && py.test

.gitignore

@@ -25,6 +25,7 @@ var/
 
 .idea/
 venv/
+.venv/
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -58,4 +59,12 @@ docs/_build/
 
 # PyBuilder
 target/
-testMain.py
+testMain.py
+
+#VS Code
+.vscode/
+.DS_Store
+*.code-workspace
+
+# documentation
+_build/

.readthedocs.yaml

@@ -0,0 +1,22 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.9"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+# We recommend specifying your dependencies to enable reproducible builds:
+# https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+   install:
+   - requirements: docs/requirements.txt

.readthedocs.yml

@@ -0,0 +1,19 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+formats: all
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  version: 3.7
+  install:
+    - requirements: doc_req.txt

.travis.yml

@@ -1,9 +1,10 @@
 language: python
 python:
-    - "2.6"
-    - "2.7"
-    - "3.4"
-    - "pypy"
+    - "3.7"
+    - "3.8"
+    - "3.9"
+    - "3.10"
+    - "3.11"
     - "pypy3"
 install: "pip install -r requirements.txt"
 script:

README.md

@@ -1,11 +1,23 @@
+
+[![PyPi Package Version](https://img.shields.io/pypi/v/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/pyTelegramBotAPI.svg)](https://pypi.python.org/pypi/pyTelegramBotAPI)
+[![Documentation Status](https://readthedocs.org/projects/pytba/badge/?version=latest)](https://pytba.readthedocs.io/en/latest/?badge=latest)
+[![PyPi downloads](https://img.shields.io/pypi/dm/pyTelegramBotAPI.svg)](https://pypi.org/project/pyTelegramBotAPI/)
+[![PyPi status](https://img.shields.io/pypi/status/pytelegrambotapi.svg?style=flat-square)](https://pypi.python.org/pypi/pytelegrambotapi)
+
 # <p align="center">pyTelegramBotAPI
 
-<p align="center">A simple, but extensible Python implementation for the [Telegram Bot API](https://core.telegram.org/bots/api).
+<p align="center">A simple, but extensible Python implementation for the <a href="https://core.telegram.org/bots/api">Telegram Bot API</a>.</p>
+<p align="center">Both synchronous and asynchronous.</p>
 
+## <p align="center">Supported Bot API version: <a href="https://core.telegram.org/bots/api#april-21-2023">6.7</a>!
 
-<p align="center">[![Build Status](https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master)](https://travis-ci.org/eternnoir/pyTelegramBotAPI)
+<h2><a href='https://pytba.readthedocs.io/en/latest/index.html'>Official documentation</a></h2>
+<h2><a href='https://pytba.readthedocs.io/ru/latest/index.html'>Official ru documentation</a></h2>
+	
+## Contents
 
-  * [Getting started.](#getting-started)
+  * [Getting started](#getting-started)
   * [Writing your first bot](#writing-your-first-bot)
     * [Prerequisites](#prerequisites)
     * [A simple echo bot](#a-simple-echo-bot)
@@ -14,26 +26,53 @@
     * [Methods](#methods)
     * [General use of the API](#general-use-of-the-api)
       * [Message handlers](#message-handlers)
+      * [Edited Message handler](#edited-message-handler)
+      * [Channel Post handler](#channel-post-handler)
+      * [Edited Channel Post handler](#edited-channel-post-handler)
+      * [Callback Query handlers](#callback-query-handler)
+      * [Shipping Query Handler](#shipping-query-handler)
+      * [Pre Checkout Query Handler](#pre-checkout-query-handler)
+      * [Poll Handler](#poll-handler)
+      * [Poll Answer Handler](#poll-answer-handler)
+      * [My Chat Member Handler](#my-chat-member-handler)
+      * [Chat Member Handler](#chat-member-handler)
+      * [Chat Join request handler](#chat-join-request-handler)
+    * [Inline Mode](#inline-mode)
+      * [Inline handler](#inline-handler)
+      * [Chosen Inline handler](#chosen-inline-handler)
+      * [Answer Inline Query](#answer-inline-query)
+    * [Additional API features](#additional-api-features)
+      * [Middleware handlers](#middleware-handlers)
+      * [Custom filters](#custom-filters)
       * [TeleBot](#telebot)
       * [Reply markup](#reply-markup)
   * [Advanced use of the API](#advanced-use-of-the-api)
-    * [Asynchronous delivery of messages](#asynchronous-delivery-of-messages)
+    * [Using local Bot API Server](#using-local-bot-api-sever)
+    * [Asynchronous TeleBot](#asynchronous-telebot)
     * [Sending large text messages](#sending-large-text-messages)
     * [Controlling the amount of Threads used by TeleBot](#controlling-the-amount-of-threads-used-by-telebot)
     * [The listener mechanism](#the-listener-mechanism)
     * [Using web hooks](#using-web-hooks)
     * [Logging](#logging)
+    * [Proxy](#proxy)
+    * [Testing](#testing)
+  * [API conformance limitations](#api-conformance-limitations)
+  * [AsyncTeleBot](#asynctelebot)
   * [F.A.Q.](#faq)
     * [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)
+    * [How can I handle reocurring ConnectionResetErrors?](#how-can-i-handle-reocurring-connectionreseterrors)
   * [The Telegram Chat Group](#the-telegram-chat-group)
+  * [Telegram Channel](#telegram-channel)
   * [More examples](#more-examples)
+  * [Code Template](#code-template)
+  * [Bots using this library](#bots-using-this-library)
 
-## Getting started.
+## Getting started
 
-This API is tested with Python 2.6, Python 2.7, Python 3.4, Pypy and Pypy 3.
+This API is tested with Python 3.7-3.11 and Pypy 3.
 There are two ways to install the library:
 
-* Installation using pip (a Python package manager)*:
+* Installation using pip (a Python package manager):
 
 ```
 $ pip install pyTelegramBotAPI
@@ -45,10 +84,17 @@ $ git clone https://github.com/eternnoir/pyTelegramBotAPI.git
 $ cd pyTelegramBotAPI
 $ python setup.py install
 ```
+or:
+```
+$ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
+```
 
 It is generally recommended to use the first option.
 
-**While the API is production-ready, it is still under development and it has regular updates, do not forget to update it regularly by calling `pip install pytelegrambotapi --upgrade`*
+*While the API is production-ready, it is still under development and it has regular updates, do not forget to update it regularly by calling*
+```
+pip install pytelegrambotapi --upgrade
+```
 
 ## Writing your first bot
 
@@ -66,7 +112,7 @@ Then, open the file and create an instance of the TeleBot class.
 ```python
 import telebot
 
-bot = telebot.TeleBot("TOKEN")
+bot = telebot.TeleBot("TOKEN", parse_mode=None) # You can set parse_mode by default. HTML or MARKDOWN
 ```
 *Note: Make sure to actually replace TOKEN with your own API token.*
 
@@ -92,13 +138,13 @@ This one echoes all incoming text messages back to the sender. It uses a lambda
 
 We now have a basic bot which replies a static message to "/start" and "/help" commands and which echoes the rest of the sent messages. To start the bot, add the following to our source file:
 ```python
-bot.polling()
+bot.infinity_polling()
 ```
 Alright, that's it! Our source file now looks like this:
 ```python
 import telebot
 
-bot = telebot.TeleBot("TOKEN")
+bot = telebot.TeleBot("YOUR_BOT_TOKEN")
 
 @bot.message_handler(commands=['start', 'help'])
 def send_welcome(message):
@@ -108,7 +154,7 @@ def send_welcome(message):
 def echo_all(message):
 	bot.reply_to(message, message.text)
 
-bot.polling()
+bot.infinity_polling()
 ```
 To start the bot, simply open up a terminal and enter `python echo_bot.py` to run the bot! Test it by sending commands ('/start' and '/help') and arbitrary text messages.
 
@@ -118,8 +164,12 @@ To start the bot, simply open up a terminal and enter `python echo_bot.py` to ru
 
 All types are defined in types.py. They are all completely in line with the [Telegram API's definition of the types](https://core.telegram.org/bots/api#available-types), except for the Message's `from` field, which is renamed to `from_user` (because `from` is a Python reserved token). Thus, attributes such as `message_id` can be accessed directly with `message.message_id`. Note that `message.chat` can be either an instance of `User` or `GroupChat` (see [How can I distinguish a User and a GroupChat in message.chat?](#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat)).
 
-The Message object also has a `content_type`attribute, which defines the type of the Message. `content_type` can be one of the following strings: 
-'text', 'audio', 'document', 'photo', 'sticker', 'video', 'location', 'contact', 'new_chat_participant', 'left_chat_participant', 'new_chat_title', 'new_chat_photo', 'delete_chat_photo', 'group_chat_created'.
+The Message object also has a `content_type`attribute, which defines the type of the Message. `content_type` can be one of the following strings:
+`text`, `audio`, `document`, `photo`, `sticker`, `video`, `video_note`, `voice`, `location`, `contact`, `new_chat_members`, `left_chat_member`, `new_chat_title`, `new_chat_photo`, `delete_chat_photo`, `group_chat_created`, `supergroup_chat_created`, `channel_chat_created`, `migrate_to_chat_id`, `migrate_from_chat_id`, `pinned_message`, `web_app_data`.
+
+You can use some types in one function. Example:
+
+```content_types=["text", "sticker", "pinned_message", "photo", "audio"]```
 
 ### Methods
 
@@ -131,7 +181,7 @@ Outlined below are some general use cases of the API.
 
 #### Message handlers
 A message handler is a function that is decorated with the `message_handler` decorator of a TeleBot instance. Message handlers consist of one or multiple filters.
-Each filter much return True for a certain message in order for a message handler to become eligible to handle that message. A message handler is declared in the following way (provided `bot` is an instance of TeleBot):
+Each filter must return True for a certain message in order for a message handler to become eligible to handle that message. A message handler is declared in the following way (provided `bot` is an instance of TeleBot):
 ```python
 @bot.message_handler(filters)
 def function_name(message):
@@ -145,11 +195,13 @@ TeleBot supports the following filters:
 |name|argument(s)|Condition|
 |:---:|---| ---|
 |content_types|list of strings (default `['text']`)|`True` if message.content_type is in the list of strings.|
-|regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html)|
+|regexp|a regular expression as a string|`True` if `re.search(regexp_arg)` returns `True` and `message.content_type == 'text'` (See [Python Regular Expressions](https://docs.python.org/2/library/re.html))|
 |commands|list of strings|`True` if `message.content_type == 'text'` and `message.text` starts with a command that is in the list of strings.|
-|func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`
-
+|chat_types|list of chat types|`True` if `message.chat.type` in your filter|
+|func|a function (lambda or function reference)|`True` if the lambda or function reference returns `True`|
+	
 Here are some examples of using the filters and message handlers:
+
 ```python
 import telebot
 bot = telebot.TeleBot("TOKEN")
@@ -169,20 +221,199 @@ def handle_docs_audio(message):
 def handle_message(message):
 	pass
 
-#Handles all messages for which the lambda returns True
+# Handles all messages for which the lambda returns True
 @bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
 def handle_text_doc(message):
 	pass
 
-#Which could also be defined as:
+# Which could also be defined as:
 def test_message(message):
-	return message.document.mime_type == 'text/plan'
+	return message.document.mime_type == 'text/plain'
 
 @bot.message_handler(func=test_message, content_types=['document'])
-def handle_text_doc(message)
+def handle_text_doc(message):
 	pass
+
+# Handlers can be stacked to create a function which will be called if either message_handler is eligible
+# This handler will be called if the message starts with '/hello' OR is some emoji
+@bot.message_handler(commands=['hello'])
+@bot.message_handler(func=lambda msg: msg.text.encode("utf-8") == SOME_FANCY_EMOJI)
+def send_something(message):
+    pass
 ```
 **Important: all handlers are tested in the order in which they were declared**
+
+#### Edited Message handler
+Handle edited messages
+`@bot.edited_message_handler(filters) # <- passes a Message type object to your function`
+
+#### Channel Post handler
+Handle channel post messages
+`@bot.channel_post_handler(filters) # <- passes a Message type object to your function`
+
+#### Edited Channel Post handler
+Handle edited channel post messages
+`@bot.edited_channel_post_handler(filters) # <- passes a Message type object to your function`
+
+#### Callback Query Handler
+Handle callback queries
+```python
+@bot.callback_query_handler(func=lambda call: True)
+def test_callback(call): # <- passes a CallbackQuery type object to your function
+    logger.info(call)
+```
+
+#### Shipping Query Handler
+Handle shipping queries
+`@bot.shipping_query_handler() # <- passes a ShippingQuery type object to your function`
+
+#### Pre Checkout Query Handler
+Handle pre checkoupt queries
+`@bot.pre_checkout_query_handler() # <- passes a PreCheckoutQuery type object to your function`
+
+#### Poll Handler
+Handle poll updates
+`@bot.poll_handler() # <- passes a Poll type object to your function`
+
+#### Poll Answer Handler
+Handle poll answers
+`@bot.poll_answer_handler() # <- passes a PollAnswer type object to your function`
+
+#### My Chat Member Handler
+Handle updates of a the bot's member status in a chat
+`@bot.my_chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`
+
+#### Chat Member Handler
+Handle updates of a chat member's status in a chat
+`@bot.chat_member_handler() # <- passes a ChatMemberUpdated type object to your function`
+*Note: "chat_member" updates are not requested by default. If you want to allow all update types, set `allowed_updates` in `bot.polling()` / `bot.infinity_polling()` to `util.update_types`*
+
+#### Chat Join Request Handler	
+Handle chat join requests using:
+`@bot.chat_join_request_handler() # <- passes ChatInviteLink type object to your function`
+
+### Inline Mode
+
+More information about [Inline mode](https://core.telegram.org/bots/inline).
+
+#### Inline handler
+
+Now, you can use inline_handler to get inline queries in telebot.
+
+```python
+
+@bot.inline_handler(lambda query: query.query == 'text')
+def query_text(inline_query):
+    # Query message is text
+```
+
+#### Chosen Inline handler
+
+Use chosen_inline_handler to get chosen_inline_result in telebot. Don't forgot add the /setinlinefeedback
+command for @Botfather.
+
+More information : [collecting-feedback](https://core.telegram.org/bots/inline#collecting-feedback)
+
+```python
+@bot.chosen_inline_handler(func=lambda chosen_inline_result: True)
+def test_chosen(chosen_inline_result):
+    # Process all chosen_inline_result.
+```
+
+#### Answer Inline Query
+
+```python
+@bot.inline_handler(lambda query: query.query == 'text')
+def query_text(inline_query):
+    try:
+        r = types.InlineQueryResultArticle('1', 'Result', types.InputTextMessageContent('Result message.'))
+        r2 = types.InlineQueryResultArticle('2', 'Result2', types.InputTextMessageContent('Result message2.'))
+        bot.answer_inline_query(inline_query.id, [r, r2])
+    except Exception as e:
+        print(e)
+
+```
+
+### Additional API features
+
+#### Middleware Handlers
+
+A middleware handler is a function that allows you to modify requests or the bot context as they pass through the 
+Telegram to the bot. You can imagine middleware as a chain of logic connection handled before any other handlers are
+executed. Middleware processing is disabled by default, enable it by setting `apihelper.ENABLE_MIDDLEWARE = True`. 
+
+```python
+apihelper.ENABLE_MIDDLEWARE = True
+
+@bot.middleware_handler(update_types=['message'])
+def modify_message(bot_instance, message):
+    # modifying the message before it reaches any other handler 
+    message.another_text = message.text + ':changed'
+
+@bot.message_handler(commands=['start'])
+def start(message):
+    # the message is already modified when it reaches message handler
+    assert message.another_text == message.text + ':changed'
+```
+There are other examples using middleware handler in the [examples/middleware](examples/middleware) directory.
+
+#### Class-based middlewares
+There are class-based middlewares. 
+Basic class-based middleware looks like this:
+```python
+class Middleware(BaseMiddleware):
+    def __init__(self):
+        self.update_types = ['message']
+    def pre_process(self, message, data):
+        data['foo'] = 'Hello' # just for example
+        # we edited the data. now, this data is passed to handler.
+        # return SkipHandler() -> this will skip handler
+        # return CancelUpdate() -> this will cancel update
+    def post_process(self, message, data, exception=None):
+        print(data['foo'])
+        if exception: # check for exception
+            print(exception)
+```
+Class-based middleware should have to functions: post and pre process.
+So, as you can see, class-based middlewares work before and after handler execution.
+For more, check out in [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/middleware/class_based)	
+	
+#### Custom filters
+Also, you can use built-in custom filters. Or, you can create your own filter.	
+
+[Example of custom filter](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/general_custom_filters.py)
+	
+Also, we have examples on them. Check this links:
+	
+You can check some built-in filters in source [code](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/telebot/custom_filters.py)
+	
+Example of [filtering by id](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/id_filter_example.py)
+	
+Example of [filtering by text](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/custom_filters/text_filter_example.py)
+	
+If you want to add some built-in filter, you are welcome to add it in custom_filters.py file.
+	
+Here is example of creating filter-class:
+	
+```python
+class IsAdmin(telebot.custom_filters.SimpleCustomFilter):
+    # Class will check whether the user is admin or creator in group or not
+    key='is_chat_admin'
+    @staticmethod
+    def check(message: telebot.types.Message):
+        return bot.get_chat_member(message.chat.id,message.from_user.id).status in ['administrator','creator']
+	
+# To register filter, you need to use method add_custom_filter.
+bot.add_custom_filter(IsAdmin())
+	
+# Now, you can use it in handler.
+@bot.message_handler(is_chat_admin=True)
+def admin_of_group(message):
+	bot.send_message(message.chat.id, 'You are admin of this group!')
+
+```
+	
+
 #### TeleBot
 ```python
 import telebot
@@ -191,21 +422,29 @@ TOKEN = '<token_string>'
 tb = telebot.TeleBot(TOKEN)	#create a new Telegram Bot object
 
 # Upon calling this function, TeleBot starts polling the Telegram servers for new messages.
-# - none_stop: True/False (default False) - Don't stop polling when receiving an error from the Telegram servers
-# - interval: True/False (default False) - The interval between polling requests
-#           Note: Editing this parameter harms the bot's response time
-# - block: True/False (default True) - Blocks upon calling this function
-tb.polling(none_stop=False, interval=0, block=True)
+# - interval: int (default 0) - The interval between polling requests
+# - timeout: integer (default 20) - Timeout in seconds for long polling.
+# - allowed_updates: List of Strings (default None) - List of update types to request 
+tb.infinity_polling(interval=0, timeout=20)
 
 # getMe
 user = tb.get_me()
 
+# setWebhook
+tb.set_webhook(url="http://example.com", certificate=open('mycert.pem'))
+# unset webhook
+tb.remove_webhook()
+
 # getUpdates
 updates = tb.get_updates()
+# or
 updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):
 
 # sendMessage
-tb.send_message(chatid, text)
+tb.send_message(chat_id, text)
+
+# editMessageText
+tb.edit_message_text(new_text, chat_id, message_id)
 
 # forwardMessage
 tb.forward_message(to_chat_id, from_chat_id, message_id)
@@ -244,6 +483,11 @@ video = open('/tmp/video.mp4', 'rb')
 tb.send_video(chat_id, video)
 tb.send_video(chat_id, "FILEID")
 
+# sendVideoNote
+videonote = open('/tmp/videonote.mp4', 'rb')
+tb.send_video_note(chat_id, videonote)
+tb.send_video_note(chat_id, "FILEID")
+
 # sendLocation
 tb.send_location(chat_id, lat, lon)
 
@@ -263,7 +507,7 @@ file = requests.get('https://api.telegram.org/file/bot{0}/{1}'.format(API_TOKEN,
 
 ```
 #### Reply markup
-All `send_xyz` functions of TeleBot take an optional `reply_markup` argument. This argument must be an instance of `ReplyKeyboardMarkup`, `ReplyKeyboardHide` or `ForceReply`, which are defined in types.py.
+All `send_xyz` functions of TeleBot take an optional `reply_markup` argument. This argument must be an instance of `ReplyKeyboardMarkup`, `ReplyKeyboardRemove` or `ForceReply`, which are defined in types.py.
 
 ```python
 from telebot import types
@@ -277,23 +521,31 @@ from telebot import types
 # row_width is used in combination with the add() function.
 # It defines how many buttons are fit on each row before continuing on the next row.
 markup = types.ReplyKeyboardMarkup(row_width=2)
-markup.add('a', 'v', 'd')
+itembtn1 = types.KeyboardButton('a')
+itembtn2 = types.KeyboardButton('v')
+itembtn3 = types.KeyboardButton('d')
+markup.add(itembtn1, itembtn2, itembtn3)
 tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
 
-# or add strings one row at a time:
+# or add KeyboardButton one row at a time:
 markup = types.ReplyKeyboardMarkup()
-markup.row('a', 'v')
-markup.row('c', 'd', 'e')
+itembtna = types.KeyboardButton('a')
+itembtnv = types.KeyboardButton('v')
+itembtnc = types.KeyboardButton('c')
+itembtnd = types.KeyboardButton('d')
+itembtne = types.KeyboardButton('e')
+markup.row(itembtna, itembtnv)
+markup.row(itembtnc, itembtnd, itembtne)
 tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
 ```
 The last example yields this result:
 
-![ReplyKeyboardMarkup](https://pp.vk.me/c624430/v624430512/473e5/_mxxW7FPe4U.jpg "ReplyKeyboardMarkup")
+![ReplyKeyboardMarkup](https://farm3.staticflickr.com/2933/32418726704_9ef76093cf_o_d.jpg "ReplyKeyboardMarkup")
 
 ```python
-# ReplyKeyboardHide: hides a previously sent ReplyKeyboardMarkup
+# ReplyKeyboardRemove: hides a previously sent ReplyKeyboardMarkup
 # Takes an optional selective argument (True/False, default False)
-markup = types.ReplyKeyboardHide(selective=False)
+markup = types.ReplyKeyboardRemove(selective=False)
 tb.send_message(chat_id, message, reply_markup=markup)
 ```
 
@@ -305,30 +557,59 @@ tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
 ```
 ForceReply:
 
-![ForceReply](https://pp.vk.me/c624430/v624430512/473ec/602byyWUHcs.jpg "ForceReply")
+![ForceReply](https://farm4.staticflickr.com/3809/32418726814_d1baec0fc2_o_d.jpg "ForceReply")
+
+
+### Working with entities
+This object represents one special entity in a text message. For example, hashtags, usernames, URLs, etc.
+Attributes:
+* `type`
+* `url`
+* `offset`
+* `length`
+* `user`
+
+
+**Here's an Example:**`message.entities[num].<attribute>`<br>
+Here `num` is the entity number or order of entity in a reply, for if incase there are multiple entities in the reply/message.<br>
+`message.entities` returns a list of entities object. <br>
+`message.entities[0].type` would give the type of the first entity<br>
+Refer [Bot Api](https://core.telegram.org/bots/api#messageentity) for extra details
 
 ## Advanced use of the API
 
-### Asynchronous delivery of messages
-There exists an implementation of TeleBot which executes all `send_xyz` and the `get_me` functions asynchronously. This can speed up you bot __significantly__, but it has unwanted side effects if used without caution.
+### Using local Bot API Sever
+Since version 5.0 of the Bot API, you have the possibility to run your own [Local Bot API Server](https://core.telegram.org/bots/api#using-a-local-bot-api-server).
+pyTelegramBotAPI also supports this feature.
+```python
+from telebot import apihelper
+
+apihelper.API_URL = "http://localhost:4200/bot{0}/{1}"
+```
+**Important: Like described [here](https://core.telegram.org/bots/api#logout), you have to log out your bot from the Telegram server before switching to your local API server. in pyTelegramBotAPI use `bot.log_out()`**
+
+*Note: 4200 is an example port*
+
+### Asynchronous TeleBot
+New: There is an asynchronous implementation of telebot.
 To enable this behaviour, create an instance of AsyncTeleBot instead of TeleBot.
 ```python
 tb = telebot.AsyncTeleBot("TOKEN")
 ```
-Now, every function that calls the Telegram API is executed in a separate Thread. The functions are modified to return an AsyncTask instance (defined in util.py). Using AsyncTeleBot allows you to do the following:
+Now, every function that calls the Telegram API is executed in a separate asynchronous task.
+Using AsyncTeleBot allows you to do the following:
 ```python
 import telebot
 
 tb = telebot.AsyncTeleBot("TOKEN")
-task = tb.get_me() # Execute an API call
-# Do some other operations...
-a = 0
-for a in range(100):
-	a += 10
 
-result = task.wait() # Get the result of the execution
+@tb.message_handler(commands=['start'])
+async def start_message(message):
+	await bot.send_message(message.chat.id, 'Hello!')
+
 ```
-*Note: if you execute send_xyz functions after eachother without calling wait(), the order in which messages are delivered might be wrong.*
+
+See more in [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/asynchronous_telebot)
 
 ### Sending large text messages
 Sometimes you must send messages that exceed 5000 characters. The Telegram API can not handle that many characters in one request, so we need to split the message in multiples. Here is how to do that using the API:
@@ -339,33 +620,49 @@ large_text = open("large_text.txt", "rb").read()
 # Split the text each 3000 characters.
 # split_string returns a list with the splitted text.
 splitted_text = util.split_string(large_text, 3000)
+
+for text in splitted_text:
+	tb.send_message(chat_id, text)
+```
+
+Or you can use the new `smart_split` function to get more meaningful substrings:
+```python
+from telebot import util
+large_text = open("large_text.txt", "rb").read()
+# Splits one string into multiple strings, with a maximum amount of `chars_per_string` (max. 4096)
+# Splits by last '\n', '. ' or ' ' in exactly this priority.
+# smart_split returns a list with the splitted text.
+splitted_text = util.smart_split(large_text, chars_per_string=3000)
 for text in splitted_text:
 	tb.send_message(chat_id, text)
 ```
 ### Controlling the amount of Threads used by TeleBot
 The TeleBot constructor takes the following optional arguments:
 
- - create_threads: True/False (default True). A flag to indicate whether
+ - threaded: True/False (default True). A flag to indicate whether
    TeleBot should execute message handlers on it's polling Thread.
- - num_threads: integer (default 4). Controls the amount of WorkerThreads created for the internal thread pool that TeleBot uses to execute message handlers. Is not used when create_threads is False.
 
 ### The listener mechanism
-As an alternative to the message handlers, one can also register a function as a listener to TeleBot. Example:
+As an alternative to the message handlers, one can also register a function as a listener to TeleBot.
+
+NOTICE: handlers won't disappear! Your message will be processed both by handlers and listeners. Also, it's impossible to predict which will work at first because of threading. If you use threaded=False, custom listeners will work earlier, after them handlers will be called. 
+Example:
 ```python
 def handle_messages(messages):
-	for message in messsages:
+	for message in messages:
 		# Do something with the message
 		bot.reply_to(message, 'Hi')
 
 bot.set_update_listener(handle_messages)
-bot.polling()
+bot.infinity_polling()
 ```
 
 ### Using web hooks
-If you prefer using web hooks to the getUpdates method, you can use the `process_new_messages(messages)` function in TeleBot to make it process the messages that you supply. It takes a list of Message objects. This function is still incubating.
+When using webhooks telegram sends one Update per call, for processing it you should call process_new_messages([update.message]) when you recieve it.
+
+There are some examples using webhooks in the [examples/webhook_examples](examples/webhook_examples) directory.
 
 ### Logging
-
 You can use the Telebot module logger to log debug info about Telebot. Use `telebot.logger` to get the logger of the TeleBot module.
 It is possible to add custom logging Handlers to the logger. Refer to the [Python logging module page](https://docs.python.org/2/library/logging.html) for more info.
 
@@ -376,34 +673,224 @@ logger = telebot.logger
 telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
 ```
 
+### Proxy
+For sync:
+
+You can use proxy for request. `apihelper.proxy` object will use by call `requests` proxies argument.
+
+```python
+from telebot import apihelper
+
+apihelper.proxy = {'http':'http://127.0.0.1:3128'}
+```
+
+If you want to use socket5 proxy you need install dependency `pip install requests[socks]` and make sure, that you have the latest version of `gunicorn`, `PySocks`, `pyTelegramBotAPI`, `requests` and `urllib3`.
+
+```python
+apihelper.proxy = {'https':'socks5://userproxy:password@proxy_address:port'}
+```
+
+For async:
+```python
+from telebot import asyncio_helper
+
+asyncio_helper.proxy = 'http://127.0.0.1:3128' #url
+```
+
+
+### Testing
+You can disable or change the interaction with real Telegram server by using
+```python
+apihelper.CUSTOM_REQUEST_SENDER = your_handler
+```
+parameter. You can pass there your own function that will be called instead of _requests.request_.
+
+For example:
+```python
+def custom_sender(method, url, **kwargs):
+    print("custom_sender. method: {}, url: {}, params: {}".format(method, url, kwargs.get("params")))
+    result = util.CustomRequestResponse('{"ok":true,"result":{"message_id": 1, "date": 1, "chat": {"id": 1, "type": "private"}}}')
+    return result
+```
+
+Then you can use API and proceed requests in your handler code.
+```python
+apihelper.CUSTOM_REQUEST_SENDER = custom_sender
+tb = TeleBot("test")
+res = tb.send_message(123, "Test")
+```
+
+Result will be:
+
+`custom_sender. method: post, url: https://api.telegram.org/botololo/sendMessage, params: {'chat_id': '123', 'text': 'Test'}`
+
+
+
+## API conformance limitations
+* ➕ [Bot API 4.5](https://core.telegram.org/bots/api-changelog#december-31-2019) - No nested MessageEntities and Markdown2 support
+* ➕ [Bot API 4.1](https://core.telegram.org/bots/api-changelog#august-27-2018)   - No Passport support
+* ➕ [Bot API 4.0](https://core.telegram.org/bots/api-changelog#july-26-2018)     - No Passport support
+
+
+## AsyncTeleBot
+### Asynchronous version of telebot
+We have a fully asynchronous version of TeleBot.
+This class is not controlled by threads. Asyncio tasks are created to execute all the stuff.
+
+### EchoBot
+Echo Bot example on AsyncTeleBot:
+	
+```python
+# This is a simple echo bot using the decorator mechanism.
+# It echoes any incoming text messages.
+
+from telebot.async_telebot import AsyncTeleBot
+import asyncio
+bot = AsyncTeleBot('TOKEN')
+
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+async def send_welcome(message):
+    await bot.reply_to(message, """\
+Hi there, I am EchoBot.
+I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
+""")
+
+
+# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
+@bot.message_handler(func=lambda message: True)
+async def echo_message(message):
+    await bot.reply_to(message, message.text)
+
+
+asyncio.run(bot.polling())
+```
+As you can see here, keywords are await and async. 
+	
+### Why should I use async?
+Asynchronous tasks depend on processor performance. Many asynchronous tasks can run parallelly, while thread tasks will block each other.
+
+### Differences in AsyncTeleBot
+AsyncTeleBot is asynchronous. It uses aiohttp instead of requests module.
+	
+### Examples
+See more examples in our [examples](https://github.com/eternnoir/pyTelegramBotAPI/tree/master/examples/asynchronous_telebot) folder
+	
+
 ## F.A.Q.
 
 ### How can I distinguish a User and a GroupChat in message.chat?
-There are two ways to do this:
+Telegram Bot API support new type Chat for message.chat.
 
- - Checking the instance of message.chat with `isinstance`:
+- Check the ```type``` attribute in ```Chat``` object:
 ```python
-def is_user(chat):
-	return isinstance(chat, types.User)
+if message.chat.type == "private":
+    # private chat message
 
-print is_user(message.chat) # True or False
-```
- - Checking whether the chat id is negative or positive. If the chat id is negative, the chat is a GroupChat, if it is positive, it is a User. Example:
-```python
-def is_user(chat):
-	return chat.id > 0
+if message.chat.type == "group":
+	# group chat message
+
+if message.chat.type == "supergroup":
+	# supergroup chat message
+
+if message.chat.type == "channel":
+	# channel message
 
-print is_user(message.chat) # True or False
 ```
 
+### How can I handle reocurring ConnectionResetErrors?
+
+Bot instances that were idle for a long time might be rejected by the server when sending a message due to a timeout of the last used session. Add `apihelper.SESSION_TIME_TO_LIVE = 5 * 60` to your initialisation to force recreation after 5 minutes without any activity. 
+
 ## The Telegram Chat Group
 
 Get help. Discuss. Chat.
 
-Join the [pyTelegramBotAPI Telegram Chat Group](https://telegram.me/joinchat/067e22c60035523fda8f6025ee87e30b).
+* Join the [pyTelegramBotAPI Telegram Chat Group](https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A)
+	
+## Telegram Channel
 
+Join the [News channel](https://t.me/pyTelegramBotAPI). Here we will post releases and updates.
+	
 ## More examples
 
 * [Echo Bot](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py)
 * [Deep Linking](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/deep_linking.py)
 * [next_step_handler Example](https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/step_example.py)
+
+## Code Template
+Template is a ready folder that contains architecture of basic project.
+Here are some examples of template:
+	
+* [AsyncTeleBot template](https://github.com/coder2020official/asynctelebot_template)
+* [TeleBot template](https://github.com/coder2020official/telebot_template)
+	
+	
+## Bots using this library
+* [SiteAlert bot](https://telegram.me/SiteAlert_bot) ([source](https://github.com/ilteoood/SiteAlert-Python)) by *ilteoood* - Monitors websites and sends a notification on changes
+* [TelegramLoggingBot](https://github.com/aRandomStranger/TelegramLoggingBot) by *aRandomStranger*
+* [Telegram LMGTFY_bot](https://github.com/GabrielRF/telegram-lmgtfy_bot) by *GabrielRF* - Let me Google that for you.
+* [Telegram Proxy Bot](https://github.com/mrgigabyte/proxybot) by *mrgigabyte* 
+* [RadRetroRobot](https://github.com/Tronikart/RadRetroRobot) by *Tronikart* - Multifunctional Telegram Bot RadRetroRobot.
+* [League of Legends bot](https://telegram.me/League_of_Legends_bot) ([source](https://github.com/i32ropie/lol)) by *i32ropie*
+* [NeoBot](https://github.com/neoranger/NeoBot) by [@NeoRanger](https://github.com/neoranger)
+* [ColorCodeBot](https://t.me/colorcodebot) ([source](https://github.com/andydecleyre/colorcodebot)) - Share code snippets as beautifully syntax-highlighted HTML and/or images.
+* [ComedoresUGRbot](http://telegram.me/ComedoresUGRbot) ([source](https://github.com/alejandrocq/ComedoresUGRbot)) by [*alejandrocq*](https://github.com/alejandrocq) - Telegram bot to check the menu of Universidad de Granada dining hall.
+* [proxybot](https://github.com/p-hash/proxybot) - Simple Proxy Bot for Telegram. by p-hash
+* [DonantesMalagaBot](https://github.com/vfranch/DonantesMalagaBot) - DonantesMalagaBot facilitates information to Malaga blood donors about the places where they can donate today or in the incoming days. It also records the date of the last donation so that it helps the donors to know when they can donate again. - by vfranch
+* [DuttyBot](https://github.com/DmytryiStriletskyi/DuttyBot) by *Dmytryi Striletskyi* - Timetable for one university in Kiev.
+* [wat-bridge](https://github.com/rmed/wat-bridge) by [*rmed*](https://github.com/rmed) - Send and receive messages to/from WhatsApp through Telegram
+* [filmratingbot](http://t.me/filmratingbot)([source](https://github.com/jcolladosp/film-rating-bot)) by [*jcolladosp*](https://github.com/jcolladosp) - Telegram bot using the Python API that gets films rating from IMDb and metacritic
+* [Send2Kindlebot](http://t.me/Send2KindleBot) ([source](https://github.com/GabrielRF/Send2KindleBot)) by *GabrielRF* - Send to Kindle service.
+* [RastreioBot](http://t.me/RastreioBot) ([source](https://github.com/GabrielRF/RastreioBot)) by *GabrielRF* - Bot used to track packages on the Brazilian Mail Service.
+* [Spbu4UBot](http://t.me/Spbu4UBot)([link](https://github.com/EeOneDown/spbu4u)) by *EeOneDown* - Bot with timetables for SPbU students.
+* [SmartySBot](http://t.me/ZDU_bot)([link](https://github.com/0xVK/SmartySBot)) by *0xVK* - Telegram timetable bot, for Zhytomyr Ivan Franko State University students.
+* [LearnIt](https://t.me/LearnItbot)([link](https://github.com/tiagonapoli/LearnIt)) - A Telegram Bot created to help people to memorize other languages’ vocabulary.
+* [Bot-Telegram-Shodan ](https://github.com/rubenleon/Bot-Telegram-Shodan) by [rubenleon](https://github.com/rubenleon)
+* [VigoBusTelegramBot](https://t.me/vigobusbot) ([GitHub](https://github.com/Pythoneiro/VigoBus-TelegramBot)) - Bot that provides buses coming to a certain stop and their remaining time for the city of Vigo (Galicia - Spain)
+* [kaishnik-bot](https://t.me/kaishnik_bot) ([source](https://github.com/airatk/kaishnik-bot)) by *airatk* - bot which shows all the necessary information to KNTRU-KAI students.
+* [Robbie](https://t.me/romdeliverybot) ([source](https://github.com/FacuM/romdeliverybot_support)) by @FacuM - Support Telegram bot for developers and maintainers.
+* [AsadovBot](https://t.me/asadov_bot) ([source](https://github.com/desexcile/BotApi)) by @DesExcile - Сatalog of poems by Eduard Asadov.
+* [thesaurus_com_bot](https://t.me/thesaurus_com_bot) ([source](https://github.com/LeoSvalov/words-i-learn-bot)) by @LeoSvalov - words and synonyms from [dictionary.com](https://www.dictionary.com) and [thesaurus.com](https://www.thesaurus.com) in the telegram.
+* [InfoBot](https://t.me/info2019_bot) ([source](https://github.com/irevenko/info-bot)) by @irevenko - An all-round bot that displays some statistics (weather, time, crypto etc...)
+* [FoodBot](https://t.me/ChensonUz_bot) ([source](https://github.com/Fliego/old_restaurant_telegram_chatbot)) by @Fliego - a simple bot for food ordering
+* [Sporty](https://t.me/SportydBot) ([source](https://github.com/0xnu/sporty)) by @0xnu - Telegram bot for displaying the latest news, sports schedules and injury updates.
+* [JoinGroup Silencer Bot](https://t.me/joingroup_silencer_bot) ([source](https://github.com/zeph1997/Telegram-Group-Silencer-Bot)) by [@zeph1997](https://github.com/zeph1997) - A Telegram Bot to remove "join group" and "removed from group" notifications.
+* [TasksListsBot](https://t.me/TasksListsBot) ([source](https://github.com/Pablo-Davila/TasksListsBot)) by [@Pablo-Davila](https://github.com/Pablo-Davila) - A (tasks) lists manager bot for Telegram.
+* [MyElizaPsychologistBot](https://t.me/TasksListsBot) ([source](https://github.com/Pablo-Davila/MyElizaPsychologistBot)) by [@Pablo-Davila](https://github.com/Pablo-Davila) - An implementation of the famous Eliza psychologist chatbot.
+* [Frcstbot](https://t.me/frcstbot) ([source](https://github.com/Mrsqd/frcstbot_public)) by [Mrsqd](https://github.com/Mrsqd). A Telegram bot that will always be happy to show you the weather forecast.
+* [MineGramBot](https://github.com/ModischFabrications/MineGramBot) by [ModischFabrications](https://github.com/ModischFabrications). This bot can start, stop and monitor a minecraft server.
+* [Tabletop DiceBot](https://github.com/dexpiper/tabletopdicebot) by [dexpiper](https://github.com/dexpiper). This bot can roll multiple dices for RPG-like games, add positive and negative modifiers and show short descriptions to the rolls.
+* [BarnameKon](https://t.me/BarnameKonBot) by [Anvaari](https://github.com/anvaari). This Bot make "Add to google calendar" link for your events. It give information about event and return link. It work for Jalali calendar and in Tehran Time. [Source code](https://github.com/anvaari/BarnameKon)
+* [Translator bot](https://github.com/AREEG94FAHAD/translate_text_bot) by Areeg Fahad. This bot can be used to translate texts. 
+* [Digital Cryptocurrency bot](https://github.com/AREEG94FAHAD/currencies_bot) by Areeg Fahad. With this bot, you can now monitor the prices of more than 12 digital Cryptocurrency. 
+* [Anti-Tracking Bot](https://t.me/AntiTrackingBot) by Leon Heess [(source)](https://github.com/leonheess/AntiTrackingBot). Send any link, and the bot tries its best to remove all tracking from the link you sent.
+* [Developer Bot](https://t.me/IndDeveloper_bot) by [Vishal Singh](https://github.com/vishal2376) [(source code)](https://github.com/vishal2376/telegram-bot) This telegram bot can do tasks like GitHub search & clone,provide c++ learning resources ,Stackoverflow search, Codeforces(profile visualizer,random problems)
+* [oneIPO bot](https://github.com/aaditya2200/IPO-proj) by [Aadithya](https://github.com/aaditya2200) & [Amol Soans](https://github.com/AmolDerickSoans) This Telegram bot provides live updates , data and documents on current and upcoming IPOs(Initial Public Offerings) 
+* [CoronaGraphsBot](https://t.me/CovidGraph_bot) ([source](https://github.com/TrevorWinstral/CoronaGraphsBot)) by *TrevorWinstral* - Gets live COVID Country data, plots it, and briefs the user
+* [ETHLectureBot](https://t.me/ETHLectureBot) ([source](https://github.com/TrevorWinstral/ETHLectureBot)) by *TrevorWinstral* - Notifies ETH students when their lectures have been uploaded
+* [Vlun Finder Bot](https://github.com/resinprotein2333/Vlun-Finder-bot) by [Resinprotein2333](https://github.com/resinprotein2333). This bot can help you to find The information of CVE vulnerabilities.
+* [ETHGasFeeTrackerBot](https://t.me/ETHGasFeeTrackerBot) ([Source](https://github.com/DevAdvik/ETHGasFeeTrackerBot]) by *DevAdvik* - Get Live Ethereum Gas Fees in GWEI
+* [Google Sheet Bot](https://github.com/JoachimStanislaus/Tele_Sheet_bot) by [JoachimStanislaus](https://github.com/JoachimStanislaus). This bot can help you to track your expenses by uploading your bot entries to your google sheet.
+* [GrandQuiz Bot](https://github.com/Carlosma7/TFM-GrandQuiz) by [Carlosma7](https://github.com/Carlosma7). This bot is a trivia game that allows you to play with people from different ages. This project addresses the use of a system through chatbots to carry out a social and intergenerational game as an alternative to traditional game development.
+* [Diccionario de la RAE](https://t.me/dleraebot) ([source](https://github.com/studentenherz/dleraebot)) This bot lets you find difinitions of words in Spanish using [RAE's dictionary](https://dle.rae.es/). It features direct message and inline search.
+* [remoteTelegramShell](https://github.com/EnriqueMoran/remoteTelegramShell) by [EnriqueMoran](https://github.com/EnriqueMoran). Control your LinuxOS computer through Telegram.
+* [Commerce Telegram Bot](https://github.com/ayitinya/commerce-telegram-bot/). Make purchases of items in a store with an Admin panel for data control and notifications.
+* [Pyfram-telegram-bot](https://github.com/skelly37/pyfram-telegram-bot) Query wolframalpha.com and make use of its API through Telegram.
+* [TranslateThisVideoBot](https://gitlab.com/WuerfelDev/translatethisvideo) This Bot can understand spoken text in videos and translate it to English
+* [Zyprexa](https://t.me/mathemathicsBot) ([source](https://github.com/atif5/zyprexa)) Zyprexa can solve, help you solve any mathematical problem you encounter and convert your regular mathematical expressions into beautiful imagery using LaTeX.
+* [Bincode-telegram-bot](https://github.com/tusharhero/bincode-telegram-bot) by [tusharhero](https://github.com/tusharhero) - Makes [bincodes](https://github.com/tusharhero/bincode) from text provides and also converts them back to text.
+* [hydrolib_bot](https://github.com/Mayson90/hydrolib_bot) Toolset for Hydrophilia tabletop game (game cards, rules, structure...).
+* [Gugumoe-bot](http://t.me/gugumoe_bot) ([source](https://github.com/GooGuJiang/Gugumoe-bot)) by [咕谷酱](https://gmoe.cc) GuXiaoJiang is a multi-functional robot, such as OSU game information query, IP test, animation screenshot search and other functions.
+* [Feedback-bot](https://github.com/coder2020official/feedbackbot) A feedback bot for user-admin communication. Made on AsyncTeleBot, using [template](https://github.com/coder2020official/asynctelebot_template).
+* [TeleServ](https://github.com/ablakely/TeleServ) by [ablakely](https://github.com/ablakely) This is a Telegram to IRC bridge which links as an IRC server and makes Telegram users appear as native IRC users.
+* [Simple Store Bot](https://github.com/AntonGlyzin/myshopbot) by [Anton Glyzin](https://github.com/AntonGlyzin) This is a simple telegram-store with an admin panel. Designed according to a template.
+* [Media Rating Bot](https://t.me/mediaratingbot) ([source](https://github.com/CommanderCRM/MediaRatingBot))by [CommanderCRM](https://github.com/CommanderCRM). This bot aggregates media (movies, TV series, etc.) ratings from IMDb, Rotten Tomatoes, Metacritic, TheMovieDB, FilmAffinity and also provides number of votes of said media on IMDb. 
+* [Spot Seek Bot](https://t.me/SpotSeekBot) ([source](https://github.com/arashnm80/spot-seek-bot)) by [Arashnm80](https://github.com/arashnm80). This is a free & open source telegram bot for downloading tracks, albums or playlists from spotify.
+* [CalendarIT Bot](https://t.me/calendarit_bot) ([source](https://github.com/codebyzen/CalendarIT_Telegram_Bot))by [CodeByZen](https://github.com/codebyzen). A simple, but extensible Python Telegram bot, can post acquainted with what is happening today, tomorrow or what happened 20 years ago to channel. 
+* [DownloadMusicBOT](https://github.com/fcoagz/DownloadMusicBOT) by *Francisco Griman* - It is a simple bot that downloads audio from YouTube videos on Telegram.
+* [AwesomeChatGPTBot](https://github.com/Kourva/AwesomeChatGPTBot) - Simple ChatGTP-3.5 bot. It is FREE and can remember chat history for a while With pre-defined roles!
+
+**Want to have your bot listed here? Just make a pull request. Only bots with public source code are accepted.**

README.rst

@@ -1,528 +0,0 @@
-#
-
-.. raw:: html
-
-   <p align="center">
-
-pyTelegramBotAPI
-
-.. raw:: html
-
-   <p align="center">
-
-A simple, but extensible Python implementation for the `Telegram Bot
-API <https://core.telegram.org/bots/api>`__.
-
-.. raw:: html
-
-   <p align="center">
-
-|Build Status|
-
--  `Getting started. <#getting-started>`__
--  `Writing your first bot <#writing-your-first-bot>`__
-
-   -  `Prerequisites <#prerequisites>`__
-   -  `A simple echo bot <#a-simple-echo-bot>`__
-
--  `General API Documentation <#general-api-documentation>`__
-
-   -  `Types <#types>`__
-   -  `Methods <#methods>`__
-   -  `General use of the API <#general-use-of-the-api>`__
-   -  `Message handlers <#message-handlers>`__
-   -  `TeleBot <#telebot>`__
-   -  `Reply markup <#reply-markup>`__
-
--  `Advanced use of the API <#advanced-use-of-the-api>`__
-
-   -  `Asynchronous delivery of
-      messages <#asynchronous-delivery-of-messages>`__
-   -  `Sending large text messages <#sending-large-text-messages>`__
-   -  `Controlling the amount of Threads used by
-      TeleBot <#controlling-the-amount-of-threads-used-by-telebot>`__
-   -  `The listener mechanism <#the-listener-mechanism>`__
-   -  `Using web hooks <#using-web-hooks>`__
-   -  `Logging <#logging>`__
-
--  `F.A.Q. <#faq>`__
-
-   -  `How can I distinguish a User and a GroupChat in
-      message.chat? <#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat>`__
-
--  `The Telegram Chat Group <#the-telegram-chat-group>`__
--  `More examples <#more-examples>`__
-
-Getting started.
-================
-
-This API is tested with Python 2.6, Python 2.7, Python 3.4, Pypy and
-Pypy 3. There are two ways to install the library:
-
--  Installation using pip (a Python package manager)\*:
-
-::
-
-    $ pip install pyTelegramBotAPI
-
--  Installation from source (requires git):
-
-::
-
-    $ git clone https://github.com/eternnoir/pyTelegramBotAPI.git
-    $ cd pyTelegramBotAPI
-    $ python setup.py install
-
-It is generally recommended to use the first option.
-
-\*\*While the API is production-ready, it is still under development and
-it has regular updates, do not forget to update it regularly by calling
-``pip install pytelegrambotapi --upgrade``\ \*
-
-Writing your first bot
-======================
-
-Prerequisites
--------------
-
-It is presumed that you [have obtained an API token with
-@BotFather](https://core.telegram.org/bots#botfather). We will call this
-token ``TOKEN``. Furthermore, you have basic knowledge of the Python
-programming language and more importantly `the Telegram Bot
-API <https://core.telegram.org/bots/api>`__.
-
-A simple echo bot
------------------
-
-The TeleBot class (defined in \_\_init\_\_.py) encapsulates all API
-calls in a single class. It provides functions such as ``send_xyz``
-(``send_message``, ``send_document`` etc.) and several ways to listen
-for incoming messages.
-
-Create a file called ``echo_bot.py``. Then, open the file and create an
-instance of the TeleBot class.
-
-.. code:: python
-
-    import telebot
-
-    bot = telebot.TeleBot("TOKEN")
-
-*Note: Make sure to actually replace TOKEN with your own API token.*
-
-After that declaration, we need to register some so-called message
-handlers. Message handlers define filters which a message must pass. If
-a message passes the filter, the decorated function is called and the
-incoming message is passed as an argument.
-
-Let's define a message handler which handles incoming ``/start`` and
-``/help`` commands.
-
-.. code:: python
-
-    @bot.message_handler(commands=['start', 'help'])
-    def send_welcome(message):
-        bot.reply_to(message, "Howdy, how are you doing?")
-
-A function which is decorated by a message handler **can have an
-arbitrary name, however, it must have only one parameter (the
-message)**.
-
-Let's add another handler:
-
-.. code:: python
-
-    @bot.message_handler(func=lambda m: True)
-    def echo_all(message):
-        bot.reply_to(message, message.text)
-
-This one echoes all incoming text messages back to the sender. It uses a
-lambda function to test a message. If the lambda returns True, the
-message is handled by the decorated function. Since we want all messages
-to be handled by this function, we simply always return True.
-
-*Note: all handlers are tested in the order in which they were declared*
-
-We now have a basic bot which replies a static message to "/start" and
-"/help" commands and which echoes the rest of the sent messages. To
-start the bot, add the following to our source file:
-
-.. code:: python
-
-    bot.polling()
-
-Alright, that's it! Our source file now looks like this:
-
-.. code:: python
-
-    import telebot
-
-    bot = telebot.TeleBot("TOKEN")
-
-    @bot.message_handler(commands=['start', 'help'])
-    def send_welcome(message):
-        bot.reply_to(message, "Howdy, how are you doing?")
-
-    @bot.message_handler(func=lambda message: True)
-    def echo_all(message):
-        bot.reply_to(message, message.text)
-
-    bot.polling()
-
-To start the bot, simply open up a terminal and enter
-``python echo_bot.py`` to run the bot! Test it by sending commands
-('/start' and '/help') and arbitrary text messages.
-
-General API Documentation
-=========================
-
-Types
------
-
-All types are defined in types.py. They are all completely in line with
-the `Telegram API's definition of the
-types <https://core.telegram.org/bots/api#available-types>`__, except
-for the Message's ``from`` field, which is renamed to ``from_user``
-(because ``from`` is a Python reserved token). Thus, attributes such as
-``message_id`` can be accessed directly with ``message.message_id``.
-Note that ``message.chat`` can be either an instance of ``User`` or
-``GroupChat`` (see `How can I distinguish a User and a GroupChat in
-message.chat? <#how-can-i-distinguish-a-user-and-a-groupchat-in-messagechat>`__).
-
-The Message object also has a ``content_type``\ attribute, which defines
-the type of the Message. ``content_type`` can be one of the following
-strings: 'text', 'audio', 'document', 'photo', 'sticker', 'video',
-'location', 'contact', 'new\_chat\_participant',
-'left\_chat\_participant', 'new\_chat\_title', 'new\_chat\_photo',
-'delete\_chat\_photo', 'group\_chat\_created'.
-
-Methods
--------
-
-All `API
-methods <https://core.telegram.org/bots/api#available-methods>`__ are
-located in the TeleBot class. They are renamed to follow common Python
-naming conventions. E.g. ``getMe`` is renamed to ``get_me`` and
-``sendMessage`` to ``send_message``.
-
-General use of the API
-----------------------
-
-Outlined below are some general use cases of the API.
-
-Message handlers
-~~~~~~~~~~~~~~~~
-
-A message handler is a function which is decorated with the
-``message_handler`` decorator of a TeleBot instance. The following
-examples illustrate the possibilities of message handlers:
-
-.. code:: python
-
-    import telebot
-    bot = telebot.TeleBot("TOKEN")
-
-    # Handles all text messages that contains the commands '/start' or '/help'.
-    @bot.message_handler(commands=['start', 'help'])
-    def handle_start_help(message):
-        pass
-
-    # Handles all sent documents and audio files
-    @bot.message_handler(content_types=['document', 'audio'])
-    def handle_docs_audio(message):
-        pass
-
-    # Handles all text messages that match the regular expression
-    @bot.message_handler(regexp="SOME_REGEXP")
-    def handle_message(message):
-        pass
-
-    #Handles all messages for which the lambda returns True
-    @bot.message_handler(func=lambda message: message.document.mime_type == 'text/plain', content_types=['document'])
-    def handle_text_doc(message):
-        pass
-
-    #Which could also be defined as:
-    def test_message(message):
-        return message.document.mime_type == 'text/plan'
-
-    @bot.message_handler(func=test_message, content_types=['document'])
-    def handle_text_doc(message)
-        pass
-
-*Note: all handlers are tested in the order in which they were declared*
-#### TeleBot
-
-.. code:: python
-
-    import telebot
-
-    TOKEN = '<token_string>'
-    tb = telebot.TeleBot(TOKEN) #create a new Telegram Bot object
-
-    # Upon calling this function, TeleBot starts polling the Telegram servers for new messages.
-    # - none_stop: True/False (default False) - Don't stop polling when receiving an error from the Telegram servers
-    # - interval: True/False (default False) - The interval between polling requests
-    #           Note: Editing this parameter harms the bot's response time
-    # - block: True/False (default True) - Blocks upon calling this function
-    tb.polling(none_stop=False, interval=0, block=True)
-
-    # getMe
-    user = tb.get_me()
-
-    # getUpdates
-    updates = tb.get_updates()
-    updates = tb.get_updates(1234,100,20) #get_Updates(offset, limit, timeout):
-
-    # sendMessage
-    tb.send_message(chatid, text)
-
-    # forwardMessage
-    tb.forward_message(to_chat_id, from_chat_id, message_id)
-
-    # All send_xyz functions which can take a file as an argument, can also take a file_id instead of a file.
-    # sendPhoto
-    photo = open('/tmp/photo.png', 'rb')
-    tb.send_photo(chat_id, photo)
-    tb.send_photo(chat_id, "FILEID")
-
-    # sendAudio
-    audio = open('/tmp/audio.mp3', 'rb')
-    tb.send_audio(chat_id, audio)
-    tb.send_audio(chat_id, "FILEID")
-
-    ## sendAudio with duration, performer and title.
-    tb.send_audio(CHAT_ID, file_data, 1, 'eternnoir', 'pyTelegram')
-
-    # sendVoice
-    voice = open('/tmp/voice.ogg', 'rb')
-    tb.send_voice(chat_id, voice)
-    tb.send_voice(chat_id, "FILEID")
-
-    # sendDocument
-    doc = open('/tmp/file.txt', 'rb')
-    tb.send_document(chat_id, doc)
-    tb.send_document(chat_id, "FILEID")
-
-    # sendSticker
-    sti = open('/tmp/sti.webp', 'rb')
-    tb.send_sticker(chat_id, sti)
-    tb.send_sticker(chat_id, "FILEID")
-
-    # sendVideo
-    video = open('/tmp/video.mp4', 'rb')
-    tb.send_video(chat_id, video)
-    tb.send_video(chat_id, "FILEID")
-
-    # sendLocation
-    tb.send_location(chat_id, lat, lon)
-
-    # sendChatAction
-    # action_string can be one of the following strings: 'typing', 'upload_photo', 'record_video', 'upload_video',
-    # 'record_audio', 'upload_audio', 'upload_document' or 'find_location'.
-    tb.send_chat_action(chat_id, action_string)
-
-Reply markup
-~~~~~~~~~~~~
-
-All ``send_xyz`` functions of TeleBot take an optional ``reply_markup``
-argument. This argument must be an instance of ``ReplyKeyboardMarkup``,
-``ReplyKeyboardHide`` or ``ForceReply``, which are defined in types.py.
-
-.. code:: python
-
-    from telebot import types
-
-    # Using the ReplyKeyboardMarkup class
-    # It's constructor can take the following optional arguments:
-    # - resize_keyboard: True/False (default False)
-    # - one_time_keyboard: True/False (default False)
-    # - selective: True/False (default False)
-    # - row_width: integer (default 3)
-    # row_width is used in combination with the add() function.
-    # It defines how many buttons are fit on each row before continuing on the next row.
-    markup = types.ReplyKeyboardMarkup(row_width=2)
-    markup.add('a', 'v', 'd')
-    tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
-
-    # or add strings one row at a time:
-    markup = types.ReplyKeyboardMarkup()
-    markup.row('a', 'v')
-    markup.row('c', 'd', 'e')
-    tb.send_message(chat_id, "Choose one letter:", reply_markup=markup)
-
-The last example yields this result:
-
-.. figure:: https://pp.vk.me/c624430/v624430512/473e5/_mxxW7FPe4U.jpg
-   :alt: ReplyKeyboardMarkup
-
-   ReplyKeyboardMarkup
-
-.. code:: python
-
-    # ReplyKeyboardHide: hides a previously sent ReplyKeyboardMarkup
-    # Takes an optional selective argument (True/False, default False)
-    markup = types.ReplyKeyboardHide(selective=False)
-    tb.send_message(chat_id, message, reply_markup=markup)
-
-.. code:: python
-
-    # ForceReply: forces a user to reply to a message
-    # Takes an optional selective argument (True/False, default False)
-    markup = types.ForceReply(selective=False)
-    tb.send_message(chat_id, "Send me another word:", reply_markup=markup)
-
-ForceReply:
-
-.. figure:: https://pp.vk.me/c624430/v624430512/473ec/602byyWUHcs.jpg
-   :alt: ForceReply
-
-   ForceReply
-
-Advanced use of the API
-=======================
-
-Asynchronous delivery of messages
----------------------------------
-
-There exists an implementation of TeleBot which executes all
-``send_xyz`` and the ``get_me`` functions asynchronously. This can speed
-up you bot **significantly**, but it has unwanted side effects if used
-without caution. To enable this behaviour, create an instance of
-AsyncTeleBot instead of TeleBot.
-
-.. code:: python
-
-    tb = telebot.AsyncTeleBot("TOKEN")
-
-Now, every function that calls the Telegram API is executed in a
-separate Thread. The functions are modified to return an AsyncTask
-instance (defined in util.py). Using AsyncTeleBot allows you to do the
-following:
-
-.. code:: python
-
-    import telebot
-
-    tb = telebot.AsyncTeleBot("TOKEN")
-    task = tb.get_me() # Execute an API call
-    # Do some other operations...
-    a = 0
-    for a in range(100):
-        a += 10
-
-    result = task.wait() # Get the result of the execution
-
-*Note: if you execute send\_xyz functions after eachother without
-calling wait(), the order in which messages are delivered might be
-wrong.*
-
-Sending large text messages
----------------------------
-
-Sometimes you must send messages that exceed 5000 characters. The
-Telegram API can not handle that many characters in one request, so we
-need to split the message in multiples. Here is how to do that using the
-API:
-
-.. code:: python
-
-    from telebot import util
-    large_text = open("large_text.txt", "rb").read()
-
-    # Split the text each 3000 characters.
-    # split_string returns a list with the splitted text.
-    splitted_text = util.split_string(large_text, 3000)
-    for text in splitted_text:
-        tb.send_message(chat_id, text)
-
-Controlling the amount of Threads used by TeleBot
--------------------------------------------------
-
-The TeleBot constructor takes the following optional arguments:
-
--  create\_threads: True/False (default True). A flag to indicate
-   whether TeleBot should execute message handlers on it's polling
-   Thread.
--  num\_threads: integer (default 4). Controls the amount of
-   WorkerThreads created for the internal thread pool that TeleBot uses
-   to execute message handlers. Is not used when create\_threads is
-   False.
-
-The listener mechanism
-----------------------
-
-As an alternative to the message handlers, one can also register a
-function as a listener to TeleBot. Example:
-
-.. code:: python
-
-    def handle_messages(messages):
-        for message in messsages:
-            # Do something with the message
-            bot.reply_to(message, 'Hi')
-
-    bot.set_update_listener(handle_messages)
-    bot.polling()
-
-Using web hooks
----------------
-
-If you prefer using web hooks to the getUpdates method, you can use the
-``process_new_messages(messages)`` function in TeleBot to make it
-process the messages that you supply. It takes a list of Message
-objects. This function is still incubating.
-
-Logging
--------
-
-You can use the Telebot module logger to log debug info about Telebot.
-Use ``telebot.logger`` to get the logger of the TeleBot module.
-
-.. code:: python
-
-    logger = telebot.logger
-    formatter = logging.Formatter('[%(asctime)s] %(thread)d {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
-                                      '%m-%d %H:%M:%S')
-    ch = logging.StreamHandler(sys.stdout)
-    logger.addHandler(ch)
-    logger.setLevel(logging.DEBUG)  # or use logging.INFO
-    ch.setFormatter(formatter)
-
-F.A.Q.
-======
-
-How can I distinguish a User and a GroupChat in message.chat?
--------------------------------------------------------------
-
-There are two ways to do this:
-
--  Checking the instance of message.chat with ``isinstance``:
-   \`\`\`python def is\_user(chat): return isinstance(chat, types.User)
-
-print is\_user(message.chat) # True or False
-``- Checking whether the chat id is negative or positive. If the chat id is negative, the chat is a GroupChat, if it is positive, it is a User. Example:``\ python
-def is\_user(chat): return chat.id > 0
-
-print is\_user(message.chat) # True or False \`\`\`
-
-The Telegram Chat Group
-=======================
-
-Get help. Discuss. Chat.
-
-Join the `pyTelegramBotAPI Telegram Chat
-Group <https://telegram.me/joinchat/067e22c60035523fda8f6025ee87e30b>`__.
-
-More examples
-=============
-
--  `Echo
-   Bot <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/echo_bot.py>`__
--  `Deep
-   Linking <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/deep_linking.py>`__
--  `next\_step\_handler
-   Example <https://github.com/eternnoir/pyTelegramBotAPI/blob/master/examples/step_example.py>`__
-
-.. |Build Status| image:: https://travis-ci.org/eternnoir/pyTelegramBotAPI.svg?branch=master
-   :target: https://travis-ci.org/eternnoir/pyTelegramBotAPI

doc_req.txt

@@ -0,0 +1,5 @@
+-r requirements.txt
+
+furo
+sphinx_copybutton
+git+https://github.com/eternnoir/pyTelegramBotAPI.git

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/source/async_version/index.rst

@@ -0,0 +1,48 @@
+====================
+AsyncTeleBot
+====================
+
+
+.. meta::
+   :description: Asynchronous pyTelegramBotAPI
+   :keywords: ptba, pytba, pyTelegramBotAPI, asynctelebot, documentation
+
+
+AsyncTeleBot methods
+--------------------
+
+.. automodule:: telebot.async_telebot
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+
+Asyncio filters
+---------------
+
+.. automodule:: telebot.asyncio_filters
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+Asyncio handler backends
+------------------------
+
+
+
+.. automodule:: telebot.asyncio_handler_backends
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Extensions
+------------------------
+
+
+
+.. automodule:: telebot.ext.aio.webhooks
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/source/calldata.rst

@@ -0,0 +1,17 @@
+
+=====================
+Callback data factory
+=====================
+
+.. meta::
+   :description: Callback data factory in pyTelegramBotAPI
+   :keywords: ptba, pytba, pyTelegramBotAPI, callbackdatafactory, guide, callbackdata, factory
+
+
+callback\_data file
+-----------------------------
+
+.. automodule:: telebot.callback_data
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/source/conf.py

@@ -0,0 +1,72 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# 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
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'pyTelegramBotAPI Documentation'
+copyright = '2022-2023, coder2020official'
+author = 'coder2020official'
+
+# The full version, including alpha/beta/rc tags
+release = '4.12.0'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autosectionlabel',
+    'sphinx.ext.autodoc',
+    "sphinx.ext.autosummary",
+    "sphinx.ext.napoleon",
+    "sphinx_copybutton",
+    
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'furo'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+#html_logo = 'logo.png'
+html_theme_options = {
+    "light_css_variables": {
+        "color-brand-primary": "#7C4DFF",
+        "color-brand-content": "#7C4DFF",
+    },
+    "light_logo": "logo.png",
+    "dark_logo": "logo2.png",
+}
+
+locale_dirs = ["locales/"]

docs/source/formatting.rst

@@ -0,0 +1,12 @@
+==================
+Formatting options
+==================
+
+.. meta::
+   :description: Formatting options in pyTelegramBotAPI
+   :keywords: html, markdown, parse_mode, formatting, ptba, pytba, pyTelegramBotAPI
+
+.. automodule:: telebot.formatting
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/source/index.rst

@@ -0,0 +1,69 @@
+.. pyTelegramBotAPI documentation master file, created by
+   sphinx-quickstart on Fri Feb 18 20:58:37 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+
+Welcome to pyTelegramBotAPI's documentation!
+============================================
+
+.. meta::
+   :description: Official documentation of pyTelegramBotAPI
+   :keywords: ptba, pytba, pyTelegramBotAPI, documentation, guide
+
+
+=======
+TeleBot
+=======
+TeleBot is synchronous and asynchronous implementation of  `Telegram Bot API <https://core.telegram.org/bots/api>`_.
+
+Chats
+-----
+English chat: `Private chat <https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A>`__
+
+Russian chat: `@pytelegrambotapi_talks_ru <https://t.me/pytelegrambotapi_talks_ru>`__
+
+News: `@pyTelegramBotAPI <https://t.me/pytelegrambotapi>`__
+
+Pypi: `Pypi <https://pypi.org/project/pyTelegramBotAPI/>`__
+
+Source: `Github repository <https://github.com/eternnoir/pyTelegramBotAPI>`__
+
+Some features:
+--------------
+Easy to learn and use.
+
+Easy to understand.
+
+Both sync and async.
+
+Examples on features.
+
+States
+
+And more...
+
+Content
+--------
+.. toctree::
+
+   install
+   quick_start
+   types
+   sync_version/index
+   async_version/index
+   calldata
+   util
+   formatting
+
+
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+
+   

docs/source/install.rst

@@ -0,0 +1,45 @@
+==================
+Installation Guide
+==================
+
+.. meta::
+   :description: Installation of pyTelegramBotAPI
+   :keywords: ptba, pytba, pyTelegramBotAPI, installation, guide
+
+
+Using PIP
+----------
+.. code-block:: bash
+
+    $ pip install pyTelegramBotAPI
+
+Using pipenv
+------------
+.. code-block:: bash
+
+    $ pipenv install pyTelegramBotAPI
+
+By cloning repository
+---------------------
+.. code-block:: bash
+
+    $ git clone https://github.com/eternnoir/pyTelegramBotAPI.git
+    $ cd pyTelegramBotAPI
+    $ python setup.py install
+
+Directly using pip
+------------------
+.. code-block:: bash
+
+    $ pip install git+https://github.com/eternnoir/pyTelegramBotAPI.git
+
+
+It is generally recommended to use the first option.
+
+While the API is production-ready, it is still under development and it has regular updates, do not forget to update it regularly by calling:
+
+.. code-block:: bash
+
+    $ pip install pytelegrambotapi --upgrade
+
+

docs/source/locales/en/LC_MESSAGES/calldata.po

@@ -0,0 +1,127 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../calldata.rst:4
+msgid "Callback data factory"
+msgstr ""
+
+#: ../../calldata.rst:6
+msgid "Callback data factory in pyTelegramBotAPI"
+msgstr ""
+
+#: ../../calldata.rst:6
+msgid ""
+"ptba, pytba, pyTelegramBotAPI, callbackdatafactory, guide, callbackdata, "
+"factory"
+msgstr ""
+
+#: ../../calldata.rst:12
+msgid "callback\\_data file"
+msgstr ""
+
+#: of telebot.callback_data:1
+msgid "Callback data factory's file."
+msgstr ""
+
+#: of telebot.callback_data.CallbackData:1
+#: telebot.callback_data.CallbackDataFilter:1
+msgid "Bases: :py:class:`object`"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData:1
+msgid "Callback data factory This class will help you to work with CallbackQuery"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter:1
+msgid "Generate filter"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter
+#: telebot.callback_data.CallbackData.new
+#: telebot.callback_data.CallbackData.parse
+#: telebot.callback_data.CallbackDataFilter.check
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter:3
+msgid "specified named parameters will be checked with CallbackQuery.data"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter
+#: telebot.callback_data.CallbackData.new
+#: telebot.callback_data.CallbackData.parse
+#: telebot.callback_data.CallbackDataFilter.check
+msgid "Returns"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter:4
+msgid "CallbackDataFilter class"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.new:1
+msgid "Generate callback data"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.new:3
+msgid "positional parameters of CallbackData instance parts"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.new:4
+msgid "named parameters"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.new:5
+msgid "str"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.parse:1
+msgid "Parse data from the callback data"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.parse:3
+msgid ""
+"string, use to telebot.types.CallbackQuery to parse it from string to a "
+"dict"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.parse:4
+msgid "dict parsed from callback data"
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter:1
+msgid "Filter for CallbackData."
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter.check:1
+msgid "Checks if query.data appropriates to specified config"
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter.check:3
+msgid "telebot.types.CallbackQuery"
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter.check:6
+msgid "True if query.data appropriates to specified config"
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter.check
+msgid "Return type"
+msgstr ""
+

docs/source/locales/en/LC_MESSAGES/formatting.po

@@ -0,0 +1,251 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../formatting.rst:3
+msgid "Formatting options"
+msgstr ""
+
+#: ../../formatting.rst:5
+msgid "Formatting options in pyTelegramBotAPI"
+msgstr ""
+
+#: ../../formatting.rst:5
+msgid "html, markdown, parse_mode, formatting, ptba, pytba, pyTelegramBotAPI"
+msgstr ""
+
+#: of telebot.formatting:1
+msgid "Markdown & HTML formatting functions."
+msgstr ""
+
+#: of telebot.formatting.escape_html:1
+msgid "Escapes HTML characters in a string of HTML."
+msgstr ""
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.formatting.escape_html:3
+msgid "The string of HTML to escape."
+msgstr ""
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Returns"
+msgstr ""
+
+#: of telebot.formatting.escape_html:6 telebot.formatting.escape_markdown:8
+msgid "The escaped string."
+msgstr ""
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Return type"
+msgstr ""
+
+#: of telebot.formatting.escape_html:7 telebot.formatting.escape_markdown:9
+#: telebot.formatting.format_text:17 telebot.formatting.hbold:10
+#: telebot.formatting.hcode:10 telebot.formatting.hide_link:7
+#: telebot.formatting.hitalic:10 telebot.formatting.hlink:13
+#: telebot.formatting.hpre:10 telebot.formatting.hspoiler:10
+#: telebot.formatting.hstrikethrough:10 telebot.formatting.hunderline:10
+#: telebot.formatting.mbold:10 telebot.formatting.mcode:10
+#: telebot.formatting.mitalic:10 telebot.formatting.mlink:13
+#: telebot.formatting.mspoiler:10 telebot.formatting.mstrikethrough:10
+#: telebot.formatting.munderline:10
+msgid ":obj:`str`"
+msgstr ""
+
+#: of telebot.formatting.escape_markdown:1
+msgid "Escapes Markdown characters in a string of Markdown."
+msgstr ""
+
+#: of telebot.formatting.escape_markdown:3
+msgid "Credits to: simonsmh"
+msgstr ""
+
+#: of telebot.formatting.escape_markdown:5
+msgid "The string of Markdown to escape."
+msgstr ""
+
+#: of telebot.formatting.format_text:1
+msgid "Formats a list of strings into a single string."
+msgstr ""
+
+#: of telebot.formatting.format_text:10
+msgid "Strings to format."
+msgstr ""
+
+#: of telebot.formatting.format_text:13
+msgid "The separator to use between each string."
+msgstr ""
+
+#: of telebot.formatting.format_text:16 telebot.formatting.hbold:9
+#: telebot.formatting.hcode:9 telebot.formatting.hitalic:9
+#: telebot.formatting.hlink:12 telebot.formatting.hpre:9
+#: telebot.formatting.hspoiler:9 telebot.formatting.hstrikethrough:9
+#: telebot.formatting.hunderline:9 telebot.formatting.mbold:9
+#: telebot.formatting.mcode:9 telebot.formatting.mitalic:9
+#: telebot.formatting.mlink:12 telebot.formatting.mspoiler:9
+#: telebot.formatting.mstrikethrough:9 telebot.formatting.munderline:9
+msgid "The formatted string."
+msgstr ""
+
+#: of telebot.formatting.hbold:1
+msgid "Returns an HTML-formatted bold string."
+msgstr ""
+
+#: of telebot.formatting.hbold:3 telebot.formatting.mbold:3
+msgid "The string to bold."
+msgstr ""
+
+#: of telebot.formatting.hbold:6 telebot.formatting.hcode:6
+#: telebot.formatting.hitalic:6 telebot.formatting.hlink:9
+#: telebot.formatting.hpre:6 telebot.formatting.hspoiler:6
+#: telebot.formatting.hstrikethrough:6 telebot.formatting.hunderline:6
+#: telebot.formatting.mbold:6 telebot.formatting.mcode:6
+#: telebot.formatting.mitalic:6 telebot.formatting.mlink:9
+#: telebot.formatting.mspoiler:6 telebot.formatting.mstrikethrough:6
+#: telebot.formatting.munderline:6
+msgid "True if you need to escape special characters. Defaults to True."
+msgstr ""
+
+#: of telebot.formatting.hcode:1
+msgid "Returns an HTML-formatted code string."
+msgstr ""
+
+#: of telebot.formatting.hcode:3 telebot.formatting.mcode:3
+msgid "The string to code."
+msgstr ""
+
+#: of telebot.formatting.hide_link:1
+msgid "Hide url of an image."
+msgstr ""
+
+#: of telebot.formatting.hide_link:3
+msgid "The url of the image."
+msgstr ""
+
+#: of telebot.formatting.hide_link:6
+msgid "The hidden url."
+msgstr ""
+
+#: of telebot.formatting.hitalic:1
+msgid "Returns an HTML-formatted italic string."
+msgstr ""
+
+#: of telebot.formatting.hitalic:3 telebot.formatting.mitalic:3
+msgid "The string to italicize."
+msgstr ""
+
+#: of telebot.formatting.hlink:1
+msgid "Returns an HTML-formatted link string."
+msgstr ""
+
+#: of telebot.formatting.hlink:3 telebot.formatting.mlink:3
+msgid "The string to link."
+msgstr ""
+
+#: of telebot.formatting.hlink:6 telebot.formatting.mlink:6
+msgid "The URL to link to."
+msgstr ""
+
+#: of telebot.formatting.hpre:1
+msgid "Returns an HTML-formatted preformatted string."
+msgstr ""
+
+#: of telebot.formatting.hpre:3
+msgid "The string to preformatted."
+msgstr ""
+
+#: of telebot.formatting.hspoiler:1
+msgid "Returns an HTML-formatted spoiler string."
+msgstr ""
+
+#: of telebot.formatting.hspoiler:3 telebot.formatting.mspoiler:3
+msgid "The string to spoiler."
+msgstr ""
+
+#: of telebot.formatting.hstrikethrough:1
+msgid "Returns an HTML-formatted strikethrough string."
+msgstr ""
+
+#: of telebot.formatting.hstrikethrough:3 telebot.formatting.mstrikethrough:3
+msgid "The string to strikethrough."
+msgstr ""
+
+#: of telebot.formatting.hunderline:1
+msgid "Returns an HTML-formatted underline string."
+msgstr ""
+
+#: of telebot.formatting.hunderline:3 telebot.formatting.munderline:3
+msgid "The string to underline."
+msgstr ""
+
+#: of telebot.formatting.mbold:1
+msgid "Returns a Markdown-formatted bold string."
+msgstr ""
+
+#: of telebot.formatting.mcode:1
+msgid "Returns a Markdown-formatted code string."
+msgstr ""
+
+#: of telebot.formatting.mitalic:1
+msgid "Returns a Markdown-formatted italic string."
+msgstr ""
+
+#: of telebot.formatting.mlink:1
+msgid "Returns a Markdown-formatted link string."
+msgstr ""
+
+#: of telebot.formatting.mspoiler:1
+msgid "Returns a Markdown-formatted spoiler string."
+msgstr ""
+
+#: of telebot.formatting.mstrikethrough:1
+msgid "Returns a Markdown-formatted strikethrough string."
+msgstr ""
+
+#: of telebot.formatting.munderline:1
+msgid "Returns a Markdown-formatted underline string."
+msgstr ""
+

docs/source/locales/en/LC_MESSAGES/index.po

@@ -0,0 +1,120 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../index.rst:8
+msgid "Welcome to pyTelegramBotAPI's documentation!"
+msgstr ""
+
+#: ../../index.rst:10
+msgid "Official documentation of pyTelegramBotAPI"
+msgstr ""
+
+#: ../../index.rst:10
+msgid "ptba, pytba, pyTelegramBotAPI, documentation, guide"
+msgstr ""
+
+#: ../../index.rst:17
+msgid "TeleBot"
+msgstr ""
+
+#: ../../index.rst:18
+msgid ""
+"TeleBot is synchronous and asynchronous implementation of  `Telegram Bot "
+"API <https://core.telegram.org/bots/api>`_."
+msgstr ""
+
+#: ../../index.rst:21
+msgid "Chats"
+msgstr ""
+
+#: ../../index.rst:22
+msgid ""
+"English chat: `Private chat "
+"<https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A>`__"
+msgstr ""
+
+#: ../../index.rst:24
+msgid ""
+"Russian chat: `@pytelegrambotapi_talks_ru "
+"<https://t.me/pytelegrambotapi_talks_ru>`__"
+msgstr ""
+
+#: ../../index.rst:26
+msgid "News: `@pyTelegramBotAPI <https://t.me/pytelegrambotapi>`__"
+msgstr ""
+
+#: ../../index.rst:28
+msgid "Pypi: `Pypi <https://pypi.org/project/pyTelegramBotAPI/>`__"
+msgstr ""
+
+#: ../../index.rst:30
+msgid ""
+"Source: `Github repository "
+"<https://github.com/eternnoir/pyTelegramBotAPI>`__"
+msgstr ""
+
+#: ../../index.rst:33
+msgid "Some features:"
+msgstr ""
+
+#: ../../index.rst:34
+msgid "Easy to learn and use."
+msgstr ""
+
+#: ../../index.rst:36
+msgid "Easy to understand."
+msgstr ""
+
+#: ../../index.rst:38
+msgid "Both sync and async."
+msgstr ""
+
+#: ../../index.rst:40
+msgid "Examples on features."
+msgstr ""
+
+#: ../../index.rst:42
+msgid "States"
+msgstr ""
+
+#: ../../index.rst:44
+msgid "And more..."
+msgstr ""
+
+#: ../../index.rst:47
+msgid "Content"
+msgstr ""
+
+#: ../../index.rst:63
+msgid "Indices and tables"
+msgstr ""
+
+#: ../../index.rst:65
+msgid ":ref:`genindex`"
+msgstr ""
+
+#: ../../index.rst:66
+msgid ":ref:`modindex`"
+msgstr ""
+
+#: ../../index.rst:67
+msgid ":ref:`search`"
+msgstr ""
+

docs/source/locales/en/LC_MESSAGES/install.po

@@ -0,0 +1,58 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../install.rst:3
+msgid "Installation Guide"
+msgstr ""
+
+#: ../../install.rst:5
+msgid "Installation of pyTelegramBotAPI"
+msgstr ""
+
+#: ../../install.rst:5
+msgid "ptba, pytba, pyTelegramBotAPI, installation, guide"
+msgstr ""
+
+#: ../../install.rst:11
+msgid "Using PIP"
+msgstr ""
+
+#: ../../install.rst:17
+msgid "Using pipenv"
+msgstr ""
+
+#: ../../install.rst:23
+msgid "By cloning repository"
+msgstr ""
+
+#: ../../install.rst:31
+msgid "Directly using pip"
+msgstr ""
+
+#: ../../install.rst:37
+msgid "It is generally recommended to use the first option."
+msgstr ""
+
+#: ../../install.rst:39
+msgid ""
+"While the API is production-ready, it is still under development and it "
+"has regular updates, do not forget to update it regularly by calling:"
+msgstr ""
+

docs/source/locales/en/LC_MESSAGES/quick_start.po

@@ -0,0 +1,40 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../quick_start.rst:4
+msgid "Quick start"
+msgstr ""
+
+#: ../../quick_start.rst:6
+msgid "Quickstart guide"
+msgstr ""
+
+#: ../../quick_start.rst:6
+msgid "ptba, pytba, pyTelegramBotAPI, quickstart, guide"
+msgstr ""
+
+#: ../../quick_start.rst:11
+msgid "Synchronous TeleBot"
+msgstr ""
+
+#: ../../quick_start.rst:16
+msgid "Asynchronous TeleBot"
+msgstr ""
+

docs/source/locales/en/LC_MESSAGES/util.po

@@ -0,0 +1,355 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2023-07-08 23:07+0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../source/util.rst:3
+msgid "Utils"
+msgstr ""
+
+#: ../../source/util.rst:5
+msgid "Utils in pyTelegramBotAPI"
+msgstr ""
+
+#: ../../source/util.rst:5
+msgid "ptba, pytba, pyTelegramBotAPI, utils, guide"
+msgstr ""
+
+#: ../../source/util.rst:11
+msgid "util file"
+msgstr ""
+
+#: of telebot.util.antiflood:1
+msgid ""
+"Use this function inside loops in order to avoid getting TooManyRequests "
+"error. Example:"
+msgstr ""
+
+#: of telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.antiflood
+#: telebot.util.escape telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.parse_web_app_data telebot.util.quick_markup
+#: telebot.util.smart_split telebot.util.split_string telebot.util.user_link
+#: telebot.util.validate_web_app_data telebot.util.webhook_google_functions
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.util.antiflood:10
+msgid "The function to call"
+msgstr ""
+
+#: of telebot.util.antiflood:13
+msgid "Number of retries to send"
+msgstr ""
+
+#: of telebot.util.antiflood:16
+msgid "The arguments to pass to the function"
+msgstr ""
+
+#: of telebot.util.antiflood:19
+msgid "The keyword arguments to pass to the function"
+msgstr ""
+
+#: of telebot.service_utils.generate_random_token
+#: telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.antiflood
+#: telebot.util.escape telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.parse_web_app_data telebot.util.quick_markup
+#: telebot.util.smart_split telebot.util.split_string telebot.util.user_link
+#: telebot.util.validate_web_app_data telebot.util.webhook_google_functions
+msgid "Returns"
+msgstr ""
+
+#: of telebot.util.antiflood:22
+msgid "None"
+msgstr ""
+
+#: of telebot.service_utils.chunks:1
+msgid "Yield successive n-sized chunks from lst."
+msgstr ""
+
+#: ../../docstring of telebot.util.content_type_media:1
+msgid "Contains all media content types."
+msgstr ""
+
+#: ../../docstring of telebot.util.content_type_service:1
+msgid "Contains all service content types such as `User joined the group`."
+msgstr ""
+
+#: of telebot.util.escape:1
+msgid ""
+"Replaces the following chars in `text` ('&' with '&amp;', '<' with '&lt;'"
+" and '>' with '&gt;')."
+msgstr ""
+
+#: of telebot.util.escape:3
+msgid "the text to escape"
+msgstr ""
+
+#: of telebot.util.escape:4
+msgid "the escaped text"
+msgstr ""
+
+#: of telebot.util.extract_arguments:1
+msgid "Returns the argument after the command."
+msgstr ""
+
+#: of telebot.util.extract_arguments:3 telebot.util.extract_command:4
+msgid "Examples:"
+msgstr ""
+
+#: of telebot.util.extract_arguments:10
+msgid "String to extract the arguments from a command"
+msgstr ""
+
+#: of telebot.util.extract_arguments:13
+msgid "the arguments if `text` is a command (according to is_command), else None."
+msgstr ""
+
+#: of telebot.service_utils.generate_random_token
+#: telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.quick_markup telebot.util.smart_split telebot.util.split_string
+#: telebot.util.user_link
+msgid "Return type"
+msgstr ""
+
+#: of telebot.util.extract_arguments:14 telebot.util.extract_command:16
+msgid ":obj:`str` or :obj:`None`"
+msgstr ""
+
+#: of telebot.util.extract_command:1
+msgid ""
+"Extracts the command from `text` (minus the '/') if `text` is a command "
+"(see is_command). If `text` is not a command, this function returns None."
+msgstr ""
+
+#: of telebot.util.extract_command:12
+msgid "String to extract the command from"
+msgstr ""
+
+#: of telebot.util.extract_command:15
+msgid "the command if `text` is a command (according to is_command), else None."
+msgstr ""
+
+#: of telebot.service_utils.generate_random_token:1
+msgid ""
+"Generates a random token consisting of letters and digits, 16 characters "
+"long."
+msgstr ""
+
+#: of telebot.service_utils.generate_random_token:3
+msgid "a random token"
+msgstr ""
+
+#: of telebot.service_utils.generate_random_token:4 telebot.util.user_link:22
+msgid ":obj:`str`"
+msgstr ""
+
+#: of telebot.service_utils.is_bytes:1
+msgid "Returns True if the given object is a bytes object."
+msgstr ""
+
+#: of telebot.service_utils.is_bytes:3 telebot.service_utils.is_dict:3
+#: telebot.service_utils.is_pil_image:3
+msgid "object to be checked"
+msgstr ""
+
+#: of telebot.service_utils.is_bytes:6
+msgid "True if the given object is a bytes object."
+msgstr ""
+
+#: of telebot.service_utils.is_bytes:7 telebot.service_utils.is_dict:7
+#: telebot.service_utils.is_pil_image:7 telebot.util.is_command:7
+msgid ":obj:`bool`"
+msgstr ""
+
+#: of telebot.util.is_command:1
+msgid ""
+"Checks if `text` is a command. Telegram chat commands start with the '/' "
+"character."
+msgstr ""
+
+#: of telebot.util.is_command:3
+msgid "Text to check."
+msgstr ""
+
+#: of telebot.util.is_command:6
+msgid "True if `text` is a command, else False."
+msgstr ""
+
+#: of telebot.service_utils.is_dict:1
+msgid "Returns True if the given object is a dictionary."
+msgstr ""
+
+#: of telebot.service_utils.is_dict:6
+msgid "True if the given object is a dictionary."
+msgstr ""
+
+#: of telebot.service_utils.is_pil_image:1
+msgid "Returns True if the given object is a PIL.Image.Image object."
+msgstr ""
+
+#: of telebot.service_utils.is_pil_image:6
+msgid "True if the given object is a PIL.Image.Image object."
+msgstr ""
+
+#: of telebot.service_utils.is_string:1
+msgid "Returns True if the given object is a string."
+msgstr ""
+
+#: of telebot.util.parse_web_app_data:1
+msgid "Parses web app data."
+msgstr ""
+
+#: of telebot.util.parse_web_app_data:3 telebot.util.validate_web_app_data:3
+msgid "The bot token"
+msgstr ""
+
+#: of telebot.util.parse_web_app_data:6 telebot.util.validate_web_app_data:6
+msgid "The raw init data"
+msgstr ""
+
+#: of telebot.util.parse_web_app_data:9 telebot.util.validate_web_app_data:9
+msgid "The parsed init data"
+msgstr ""
+
+#: of telebot.util.quick_markup:1
+msgid ""
+"Returns a reply markup from a dict in this format: {'text': kwargs} This "
+"is useful to avoid always typing 'btn1 = InlineKeyboardButton(...)' 'btn2"
+" = InlineKeyboardButton(...)'"
+msgstr ""
+
+#: of telebot.util.quick_markup:4 telebot.util.user_link:5
+msgid "Example:"
+msgstr ""
+
+#: of telebot.util.quick_markup:6
+msgid "Using quick_markup:"
+msgstr ""
+
+#: of telebot.util.quick_markup:31
+msgid ""
+"a dict containing all buttons to create in this format: {text: kwargs} "
+"{str:}"
+msgstr ""
+
+#: of telebot.util.quick_markup:34
+msgid "number of :class:`telebot.types.InlineKeyboardButton` objects on each row"
+msgstr ""
+
+#: of telebot.util.quick_markup:37
+msgid "InlineKeyboardMarkup"
+msgstr ""
+
+#: of telebot.util.quick_markup:38
+msgid ":obj:`types.InlineKeyboardMarkup`"
+msgstr ""
+
+#: of telebot.util.smart_split:1
+msgid ""
+"Splits one string into multiple strings, with a maximum amount of "
+"`chars_per_string` characters per string. This is very useful for "
+"splitting one giant message into multiples. If `chars_per_string` > 4096:"
+" `chars_per_string` = 4096. Splits by '\\n', '. ' or ' ' in exactly this "
+"priority."
+msgstr ""
+
+#: of telebot.util.smart_split:6 telebot.util.split_string:4
+msgid "The text to split"
+msgstr ""
+
+#: of telebot.util.smart_split:9
+msgid "The number of maximum characters per part the text is split to."
+msgstr ""
+
+#: of telebot.util.smart_split:12 telebot.util.split_string:10
+msgid "The splitted text as a list of strings."
+msgstr ""
+
+#: of telebot.util.smart_split:13 telebot.util.split_string:11
+msgid ":obj:`list` of :obj:`str`"
+msgstr ""
+
+#: of telebot.util.split_string:1
+msgid ""
+"Splits one string into multiple strings, with a maximum amount of "
+"`chars_per_string` characters per string. This is very useful for "
+"splitting one giant message into multiples."
+msgstr ""
+
+#: of telebot.util.split_string:7
+msgid "The number of characters per line the text is split into."
+msgstr ""
+
+#: ../../docstring of telebot.util.update_types:1
+msgid "All update types, should be used for allowed_updates parameter in polling."
+msgstr ""
+
+#: of telebot.util.user_link:1
+msgid ""
+"Returns an HTML user link. This is useful for reports. Attention: Don't "
+"forget to set parse_mode to 'HTML'!"
+msgstr ""
+
+#: of telebot.util.user_link:11
+msgid ""
+"You can use formatting.* for all other formatting options(bold, italic, "
+"links, and etc.) This method is kept for backward compatibility, and it "
+"is recommended to use formatting.* for more options."
+msgstr ""
+
+#: of telebot.util.user_link:15
+msgid "the user (not the user_id)"
+msgstr ""
+
+#: of telebot.util.user_link:18
+msgid "include the user_id"
+msgstr ""
+
+#: of telebot.util.user_link:21
+msgid "HTML user link"
+msgstr ""
+
+#: of telebot.util.validate_web_app_data:1
+msgid "Validates web app data."
+msgstr ""
+
+#: of telebot.util.webhook_google_functions:1
+msgid "A webhook endpoint for Google Cloud Functions FaaS."
+msgstr ""
+
+#: of telebot.util.webhook_google_functions:3
+msgid "The bot instance"
+msgstr ""
+
+#: of telebot.util.webhook_google_functions:6
+msgid "The request object"
+msgstr ""
+
+#: of telebot.util.webhook_google_functions:9
+msgid "The response object"
+msgstr ""
+
+#~ msgid "int row width"
+#~ msgstr ""
+

docs/source/locales/ru/LC_MESSAGES/calldata.po

@@ -0,0 +1,130 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../calldata.rst:4
+msgid "Callback data factory"
+msgstr "Фабрика callback data"
+
+#: ../../calldata.rst:6
+msgid "Callback data factory in pyTelegramBotAPI"
+msgstr "Фабрика callback data в pyTelegramBotAPI"
+
+#: ../../calldata.rst:6
+msgid ""
+"ptba, pytba, pyTelegramBotAPI, callbackdatafactory, guide, callbackdata, "
+"factory"
+msgstr ""
+"ptba, pytba, pyTelegramBotAPI, callbackdatafactory, гайд, callbackdata, "
+"фабрика"
+
+#: ../../calldata.rst:12
+msgid "callback\\_data file"
+msgstr "Файл callback\\_data"
+
+#: of telebot.callback_data:1
+msgid "Callback data factory's file."
+msgstr "Файл фабрики callback data."
+
+#: of telebot.callback_data.CallbackData:1
+#: telebot.callback_data.CallbackDataFilter:1
+msgid "Bases: :py:class:`object`"
+msgstr "Базовые классы: :py:class:`object`"
+
+#: of telebot.callback_data.CallbackData:1
+msgid "Callback data factory This class will help you to work with CallbackQuery"
+msgstr "Фабрика Callback data. Этот класс поможет вам в работе с CallbackQuery"
+
+#: of telebot.callback_data.CallbackData.filter:1
+msgid "Generate filter"
+msgstr "Сгенерировать фильтр"
+
+#: of telebot.callback_data.CallbackData.filter
+#: telebot.callback_data.CallbackData.new
+#: telebot.callback_data.CallbackData.parse
+#: telebot.callback_data.CallbackDataFilter.check
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter:3
+msgid "specified named parameters will be checked with CallbackQuery.data"
+msgstr "заданные именованные параметры будут проверены в CallbackQuery.data"
+
+#: of telebot.callback_data.CallbackData.filter
+#: telebot.callback_data.CallbackData.new
+#: telebot.callback_data.CallbackData.parse
+#: telebot.callback_data.CallbackDataFilter.check
+msgid "Returns"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.filter:4
+msgid "CallbackDataFilter class"
+msgstr "Класс CallbackDataFilter"
+
+#: of telebot.callback_data.CallbackData.new:1
+msgid "Generate callback data"
+msgstr "Сгенерировать callback data"
+
+#: of telebot.callback_data.CallbackData.new:3
+msgid "positional parameters of CallbackData instance parts"
+msgstr "позиционные параметры экземпляра CallbackData"
+
+#: of telebot.callback_data.CallbackData.new:4
+msgid "named parameters"
+msgstr "именованные параметры"
+
+#: of telebot.callback_data.CallbackData.new:5
+msgid "str"
+msgstr ""
+
+#: of telebot.callback_data.CallbackData.parse:1
+msgid "Parse data from the callback data"
+msgstr "Получить данные из callback data"
+
+#: of telebot.callback_data.CallbackData.parse:3
+msgid ""
+"string, use to telebot.types.CallbackQuery to parse it from string to a "
+"dict"
+msgstr ""
+"string, примените к telebot.types.CallbackQuery, чтобы преобразовать "
+"callback_data из строки (str) в словарь (dict)"
+
+#: of telebot.callback_data.CallbackData.parse:4
+msgid "dict parsed from callback data"
+msgstr "словарь (dict), полученный из callback data"
+
+#: of telebot.callback_data.CallbackDataFilter:1
+msgid "Filter for CallbackData."
+msgstr "Фильтр для CallbackData."
+
+#: of telebot.callback_data.CallbackDataFilter.check:1
+msgid "Checks if query.data appropriates to specified config"
+msgstr "Проверяет, соответствует ли query.data заданной конфигурации"
+
+#: of telebot.callback_data.CallbackDataFilter.check:3
+msgid "telebot.types.CallbackQuery"
+msgstr ""
+
+#: of telebot.callback_data.CallbackDataFilter.check:6
+msgid "True if query.data appropriates to specified config"
+msgstr "True, если query.data соответствует заданной конфигурации"
+
+#: of telebot.callback_data.CallbackDataFilter.check
+msgid "Return type"
+msgstr ""

docs/source/locales/ru/LC_MESSAGES/formatting.po

@@ -0,0 +1,251 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../formatting.rst:3
+msgid "Formatting options"
+msgstr "Параметры форматирования"
+
+#: ../../formatting.rst:5
+msgid "Formatting options in pyTelegramBotAPI"
+msgstr "Параметры форматирования в pyTelegramBotAPI"
+
+#: ../../formatting.rst:5
+msgid "html, markdown, parse_mode, formatting, ptba, pytba, pyTelegramBotAPI"
+msgstr "html, markdown, parse_mode, форматирование, ptba, pytba, pyTelegramBotAPI"
+
+#: of telebot.formatting:1
+msgid "Markdown & HTML formatting functions."
+msgstr "Функции форматирования Markdown & HTML."
+
+#: of telebot.formatting.escape_html:1
+msgid "Escapes HTML characters in a string of HTML."
+msgstr "Пропускает HTML символы в HTML строке."
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.formatting.escape_html:3
+msgid "The string of HTML to escape."
+msgstr "HTML строка, которую нужно пропустить."
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Returns"
+msgstr ""
+
+#: of telebot.formatting.escape_html:6 telebot.formatting.escape_markdown:8
+msgid "The escaped string."
+msgstr "Пропускаемая строка."
+
+#: of telebot.formatting.escape_html telebot.formatting.escape_markdown
+#: telebot.formatting.format_text telebot.formatting.hbold
+#: telebot.formatting.hcode telebot.formatting.hide_link
+#: telebot.formatting.hitalic telebot.formatting.hlink telebot.formatting.hpre
+#: telebot.formatting.hspoiler telebot.formatting.hstrikethrough
+#: telebot.formatting.hunderline telebot.formatting.mbold
+#: telebot.formatting.mcode telebot.formatting.mitalic telebot.formatting.mlink
+#: telebot.formatting.mspoiler telebot.formatting.mstrikethrough
+#: telebot.formatting.munderline
+msgid "Return type"
+msgstr ""
+
+#: of telebot.formatting.escape_html:7 telebot.formatting.escape_markdown:9
+#: telebot.formatting.format_text:17 telebot.formatting.hbold:10
+#: telebot.formatting.hcode:10 telebot.formatting.hide_link:7
+#: telebot.formatting.hitalic:10 telebot.formatting.hlink:13
+#: telebot.formatting.hpre:10 telebot.formatting.hspoiler:10
+#: telebot.formatting.hstrikethrough:10 telebot.formatting.hunderline:10
+#: telebot.formatting.mbold:10 telebot.formatting.mcode:10
+#: telebot.formatting.mitalic:10 telebot.formatting.mlink:13
+#: telebot.formatting.mspoiler:10 telebot.formatting.mstrikethrough:10
+#: telebot.formatting.munderline:10
+msgid ":obj:`str`"
+msgstr ""
+
+#: of telebot.formatting.escape_markdown:1
+msgid "Escapes Markdown characters in a string of Markdown."
+msgstr "Пропускает Markdown символы в Markdown строке."
+
+#: of telebot.formatting.escape_markdown:3
+msgid "Credits to: simonsmh"
+msgstr ""
+
+#: of telebot.formatting.escape_markdown:5
+msgid "The string of Markdown to escape."
+msgstr "Markdown строка, которую нужно пропустить."
+
+#: of telebot.formatting.format_text:1
+msgid "Formats a list of strings into a single string."
+msgstr "Преобразовывает набор строк в одну."
+
+#: of telebot.formatting.format_text:10
+msgid "Strings to format."
+msgstr "Строки для преобразования."
+
+#: of telebot.formatting.format_text:13
+msgid "The separator to use between each string."
+msgstr "Символ для разделения строк."
+
+#: of telebot.formatting.format_text:16 telebot.formatting.hbold:9
+#: telebot.formatting.hcode:9 telebot.formatting.hitalic:9
+#: telebot.formatting.hlink:12 telebot.formatting.hpre:9
+#: telebot.formatting.hspoiler:9 telebot.formatting.hstrikethrough:9
+#: telebot.formatting.hunderline:9 telebot.formatting.mbold:9
+#: telebot.formatting.mcode:9 telebot.formatting.mitalic:9
+#: telebot.formatting.mlink:12 telebot.formatting.mspoiler:9
+#: telebot.formatting.mstrikethrough:9 telebot.formatting.munderline:9
+msgid "The formatted string."
+msgstr "Преобразованная строка."
+
+#: of telebot.formatting.hbold:1
+msgid "Returns an HTML-formatted bold string."
+msgstr "Возвращает выделенную жирным шрифтом HTML строку."
+
+#: of telebot.formatting.hbold:3 telebot.formatting.mbold:3
+msgid "The string to bold."
+msgstr "Строка для выделения жирным шрифтом."
+
+#: of telebot.formatting.hbold:6 telebot.formatting.hcode:6
+#: telebot.formatting.hitalic:6 telebot.formatting.hlink:9
+#: telebot.formatting.hpre:6 telebot.formatting.hspoiler:6
+#: telebot.formatting.hstrikethrough:6 telebot.formatting.hunderline:6
+#: telebot.formatting.mbold:6 telebot.formatting.mcode:6
+#: telebot.formatting.mitalic:6 telebot.formatting.mlink:9
+#: telebot.formatting.mspoiler:6 telebot.formatting.mstrikethrough:6
+#: telebot.formatting.munderline:6
+msgid "True if you need to escape special characters. Defaults to True."
+msgstr "True если вам нужно пропустить спец. символы. По умолчанию True."
+
+#: of telebot.formatting.hcode:1
+msgid "Returns an HTML-formatted code string."
+msgstr "Возвращает выделенную как код HTML строку."
+
+#: of telebot.formatting.hcode:3 telebot.formatting.mcode:3
+msgid "The string to code."
+msgstr "Строка для выделения как код."
+
+#: of telebot.formatting.hide_link:1
+msgid "Hide url of an image."
+msgstr "Делает невидимым URL изображения."
+
+#: of telebot.formatting.hide_link:3
+msgid "The url of the image."
+msgstr "URL изображения."
+
+#: of telebot.formatting.hide_link:6
+msgid "The hidden url."
+msgstr "Невидимый URL."
+
+#: of telebot.formatting.hitalic:1
+msgid "Returns an HTML-formatted italic string."
+msgstr "Возвращает выделенную курсивом HTML строку."
+
+#: of telebot.formatting.hitalic:3 telebot.formatting.mitalic:3
+msgid "The string to italicize."
+msgstr "Строка для выделения курсивом."
+
+#: of telebot.formatting.hlink:1
+msgid "Returns an HTML-formatted link string."
+msgstr "Возвращает HTML строку с гиперссылкой."
+
+#: of telebot.formatting.hlink:3 telebot.formatting.mlink:3
+msgid "The string to link."
+msgstr "Строка для добавления гиперссылки."
+
+#: of telebot.formatting.hlink:6 telebot.formatting.mlink:6
+msgid "The URL to link to."
+msgstr "URL для создания гиперссылки."
+
+#: of telebot.formatting.hpre:1
+msgid "Returns an HTML-formatted preformatted string."
+msgstr "Возвращает предварительно отформатированную HTML строку."
+
+#: of telebot.formatting.hpre:3
+msgid "The string to preformatted."
+msgstr "Строка для предварительного форматирования."
+
+#: of telebot.formatting.hspoiler:1
+msgid "Returns an HTML-formatted spoiler string."
+msgstr "Возвращает выделенную как спойлер HTML строку."
+
+#: of telebot.formatting.hspoiler:3 telebot.formatting.mspoiler:3
+msgid "The string to spoiler."
+msgstr "Строка для выделения как спойлер."
+
+#: of telebot.formatting.hstrikethrough:1
+msgid "Returns an HTML-formatted strikethrough string."
+msgstr "Возвращает зачеркнутую HTML строку."
+
+#: of telebot.formatting.hstrikethrough:3 telebot.formatting.mstrikethrough:3
+msgid "The string to strikethrough."
+msgstr "Строка для зачеркивания."
+
+#: of telebot.formatting.hunderline:1
+msgid "Returns an HTML-formatted underline string."
+msgstr "Возвращает подчеркнутую HTML строку."
+
+#: of telebot.formatting.hunderline:3 telebot.formatting.munderline:3
+msgid "The string to underline."
+msgstr "Строка для подчёркивания."
+
+#: of telebot.formatting.mbold:1
+msgid "Returns a Markdown-formatted bold string."
+msgstr "Возвращает выделенную жирным шрифтом Markdown строку."
+
+#: of telebot.formatting.mcode:1
+msgid "Returns a Markdown-formatted code string."
+msgstr "Возвращает выделенную как код Markdown строку."
+
+#: of telebot.formatting.mitalic:1
+msgid "Returns a Markdown-formatted italic string."
+msgstr "Возвращает выделенную курсивом Markdown строку."
+
+#: of telebot.formatting.mlink:1
+msgid "Returns a Markdown-formatted link string."
+msgstr "Возвращает Markdown строку с гиперссылкой."
+
+#: of telebot.formatting.mspoiler:1
+msgid "Returns a Markdown-formatted spoiler string."
+msgstr "Возвращает выделенную как спойлер Markdown строку."
+
+#: of telebot.formatting.mstrikethrough:1
+msgid "Returns a Markdown-formatted strikethrough string."
+msgstr "Возвращает зачеркнутую Markdown строку."
+
+#: of telebot.formatting.munderline:1
+msgid "Returns a Markdown-formatted underline string."
+msgstr "Возвращает подчеркнутую Markdown строку."
+

docs/source/locales/ru/LC_MESSAGES/index.po

@@ -0,0 +1,128 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../index.rst:8
+msgid "Welcome to pyTelegramBotAPI's documentation!"
+msgstr "Добро пожаловать в документацию pyTelegramBotAPI!"
+
+#: ../../index.rst:10
+msgid "Official documentation of pyTelegramBotAPI"
+msgstr "Официальная документация pyTelegramBotAPI"
+
+#: ../../index.rst:10
+msgid "ptba, pytba, pyTelegramBotAPI, documentation, guide"
+msgstr "ptba, pytba, pyTelegramBotAPI, документация, гайд"
+
+#: ../../index.rst:17
+msgid "TeleBot"
+msgstr ""
+
+#: ../../index.rst:18
+msgid ""
+"TeleBot is synchronous and asynchronous implementation of  `Telegram Bot "
+"API <https://core.telegram.org/bots/api>`_."
+msgstr ""
+"TeleBot это синхронная и асинхронная реализация `Telegram Bot "
+"API <https://core.telegram.org/bots/api>`_."
+
+#: ../../index.rst:21
+msgid "Chats"
+msgstr "Чаты"
+
+#: ../../index.rst:22
+msgid ""
+"English chat: `Private chat "
+"<https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A>`__"
+msgstr ""
+"Англоязычный чат: `Private chat "
+"<https://telegram.me/joinchat/Bn4ixj84FIZVkwhk2jag6A>`__"
+
+#: ../../index.rst:24
+msgid ""
+"Russian chat: `@pytelegrambotapi_talks_ru "
+"<https://t.me/pytelegrambotapi_talks_ru>`__"
+msgstr ""
+"Русскоязычный чат: `@pytelegrambotapi_talks_ru "
+"<https://t.me/pytelegrambotapi_talks_ru>`__"
+
+#: ../../index.rst:26
+msgid "News: `@pyTelegramBotAPI <https://t.me/pytelegrambotapi>`__"
+msgstr "Новости: `@pyTelegramBotAPI <https://t.me/pytelegrambotapi>`__"
+
+#: ../../index.rst:28
+msgid "Pypi: `Pypi <https://pypi.org/project/pyTelegramBotAPI/>`__"
+msgstr ""
+
+#: ../../index.rst:30
+msgid ""
+"Source: `Github repository "
+"<https://github.com/eternnoir/pyTelegramBotAPI>`__"
+msgstr ""
+"Исходники: `Github repository "
+"<https://github.com/eternnoir/pyTelegramBotAPI>`__"
+
+#: ../../index.rst:33
+msgid "Some features:"
+msgstr "Некоторые особенности:"
+
+#: ../../index.rst:34
+msgid "Easy to learn and use."
+msgstr "Простой в изучении и использовании."
+
+#: ../../index.rst:36
+msgid "Easy to understand."
+msgstr "Простой в понимании."
+
+#: ../../index.rst:38
+msgid "Both sync and async."
+msgstr "И синхронный, и асинхронный."
+
+#: ../../index.rst:40
+msgid "Examples on features."
+msgstr "Примеры возможностей."
+
+#: ../../index.rst:42
+msgid "States"
+msgstr "Состояния (стейты, FSM)"
+
+#: ../../index.rst:44
+msgid "And more..."
+msgstr "И другое..."
+
+#: ../../index.rst:47
+msgid "Content"
+msgstr "Содержимое"
+
+#: ../../index.rst:63
+msgid "Indices and tables"
+msgstr "Ссылки"
+
+#: ../../index.rst:65
+msgid ":ref:`genindex`"
+msgstr ""
+
+#: ../../index.rst:66
+msgid ":ref:`modindex`"
+msgstr ""
+
+#: ../../index.rst:67
+msgid ":ref:`search`"
+msgstr ""
+

docs/source/locales/ru/LC_MESSAGES/install.po

@@ -0,0 +1,59 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../install.rst:3
+msgid "Installation Guide"
+msgstr "Гайд по установке"
+
+#: ../../install.rst:5
+msgid "Installation of pyTelegramBotAPI"
+msgstr "Установка pyTelegramBotAPI"
+
+#: ../../install.rst:5
+msgid "ptba, pytba, pyTelegramBotAPI, installation, guide"
+msgstr "ptba, pytba, pyTelegramBotAPI, установка, гайд"
+
+#: ../../install.rst:11
+msgid "Using PIP"
+msgstr "Используя PIP"
+
+#: ../../install.rst:17
+msgid "Using pipenv"
+msgstr "Используя pipenv"
+
+#: ../../install.rst:23
+msgid "By cloning repository"
+msgstr "Клонируя репозиторий"
+
+#: ../../install.rst:31
+msgid "Directly using pip"
+msgstr "Напрямую используя pip"
+
+#: ../../install.rst:37
+msgid "It is generally recommended to use the first option."
+msgstr "Рекомендуется использовать первый вариант."
+
+#: ../../install.rst:39
+msgid ""
+"While the API is production-ready, it is still under development and it "
+"has regular updates, do not forget to update it regularly by calling:"
+msgstr "Новые версии библиотеки имеют больше фич, улучшений и баг фиксов. Не забывайте"
+" обновляться вызывая:"
+

docs/source/locales/ru/LC_MESSAGES/quick_start.po

@@ -0,0 +1,40 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2022-11-29 14:44+0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../quick_start.rst:4
+msgid "Quick start"
+msgstr "Быстрый старт"
+
+#: ../../quick_start.rst:6
+msgid "Quickstart guide"
+msgstr "Быстрый старт - гайд"
+
+#: ../../quick_start.rst:6
+msgid "ptba, pytba, pyTelegramBotAPI, quickstart, guide"
+msgstr "ptba, pytba, pyTelegramBotAPI, быстрый старт, гайд"
+
+#: ../../quick_start.rst:11
+msgid "Synchronous TeleBot"
+msgstr "Синхронный телебот"
+
+#: ../../quick_start.rst:16
+msgid "Asynchronous TeleBot"
+msgstr "Асинхронный телебот"
+

docs/source/locales/ru/LC_MESSAGES/util.po

@@ -0,0 +1,393 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) 2022, coder2020official
+# This file is distributed under the same license as the pyTelegramBotAPI
+# Documentation package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: pyTelegramBotAPI Documentation \n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2023-07-08 23:07+0500\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: ../../source/util.rst:3
+msgid "Utils"
+msgstr "Утилиты"
+
+#: ../../source/util.rst:5
+msgid "Utils in pyTelegramBotAPI"
+msgstr "Утилиты в pyTelegramBotAPI"
+
+#: ../../source/util.rst:5
+msgid "ptba, pytba, pyTelegramBotAPI, utils, guide"
+msgstr "ptba, pytba, pyTelegramBotAPI, утилиты, гайд"
+
+#: ../../source/util.rst:11
+msgid "util file"
+msgstr "Файл util"
+
+#: of telebot.util.antiflood:1
+msgid ""
+"Use this function inside loops in order to avoid getting TooManyRequests "
+"error. Example:"
+msgstr ""
+"Используйте эту функцию в циклах, чтобы избежать ошибки TooManyRequests. "
+"Пример:"
+
+#: of telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.antiflood
+#: telebot.util.escape telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.parse_web_app_data telebot.util.quick_markup
+#: telebot.util.smart_split telebot.util.split_string telebot.util.user_link
+#: telebot.util.validate_web_app_data telebot.util.webhook_google_functions
+msgid "Parameters"
+msgstr ""
+
+#: of telebot.util.antiflood:10
+msgid "The function to call"
+msgstr "Вызываемая функция"
+
+#: of telebot.util.antiflood:13
+msgid "Number of retries to send"
+msgstr ""
+
+#: of telebot.util.antiflood:16
+msgid "The arguments to pass to the function"
+msgstr "Аргументы, для передачи в функцию"
+
+#: of telebot.util.antiflood:19
+msgid "The keyword arguments to pass to the function"
+msgstr "Именованные аргументы для передачи в функцию"
+
+#: of telebot.service_utils.generate_random_token
+#: telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.antiflood
+#: telebot.util.escape telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.parse_web_app_data telebot.util.quick_markup
+#: telebot.util.smart_split telebot.util.split_string telebot.util.user_link
+#: telebot.util.validate_web_app_data telebot.util.webhook_google_functions
+msgid "Returns"
+msgstr ""
+
+#: of telebot.util.antiflood:22
+msgid "None"
+msgstr ""
+
+#: of telebot.service_utils.chunks:1
+msgid "Yield successive n-sized chunks from lst."
+msgstr "Генерирует последовательные части списка, состоящие из n элементов."
+
+#: ../../docstring of telebot.util.content_type_media:1
+msgid "Contains all media content types."
+msgstr "Содержит все виды медиа."
+
+#: ../../docstring of telebot.util.content_type_service:1
+msgid "Contains all service content types such as `User joined the group`."
+msgstr "Содержит все виды сервисных сообщений, такие как `User joined the group`."
+
+#: of telebot.util.escape:1
+msgid ""
+"Replaces the following chars in `text` ('&' with '&amp;', '<' with '&lt;'"
+" and '>' with '&gt;')."
+msgstr ""
+"Заменяет следующие символы в `text` ('&' на '&amp;', '<' на '&lt;' и '>' "
+"на '&gt;')."
+
+#: of telebot.util.escape:3
+msgid "the text to escape"
+msgstr "Текст для замены символов"
+
+#: of telebot.util.escape:4
+msgid "the escaped text"
+msgstr "Отформатированный текст"
+
+#: of telebot.util.extract_arguments:1
+msgid "Returns the argument after the command."
+msgstr "Возвращает аргументы команды."
+
+#: of telebot.util.extract_arguments:3 telebot.util.extract_command:4
+msgid "Examples:"
+msgstr "Примеры:"
+
+#: of telebot.util.extract_arguments:10
+msgid "String to extract the arguments from a command"
+msgstr "Строка для извлечения аргументов команды"
+
+#: of telebot.util.extract_arguments:13
+msgid "the arguments if `text` is a command (according to is_command), else None."
+msgstr ""
+"Аргументы, если `text` является командой (согласно is_command), в "
+"остальных случаях None."
+
+#: of telebot.service_utils.generate_random_token
+#: telebot.service_utils.is_bytes telebot.service_utils.is_dict
+#: telebot.service_utils.is_pil_image telebot.util.extract_arguments
+#: telebot.util.extract_command telebot.util.is_command
+#: telebot.util.quick_markup telebot.util.smart_split telebot.util.split_string
+#: telebot.util.user_link
+msgid "Return type"
+msgstr ""
+
+#: of telebot.util.extract_arguments:14 telebot.util.extract_command:16
+msgid ":obj:`str` or :obj:`None`"
+msgstr ":obj:`str` или :obj:`None`"
+
+#: of telebot.util.extract_command:1
+msgid ""
+"Extracts the command from `text` (minus the '/') if `text` is a command "
+"(see is_command). If `text` is not a command, this function returns None."
+msgstr ""
+"Извлекает команду из `text` (исключает '/') если `text` является командой"
+" (см. is_command). Если `text` не является командой, эта функция "
+"возвращает None."
+
+#: of telebot.util.extract_command:12
+msgid "String to extract the command from"
+msgstr "Строка, из которой нужно извлечь команду"
+
+#: of telebot.util.extract_command:15
+msgid "the command if `text` is a command (according to is_command), else None."
+msgstr ""
+"Команда, если `text` является командой (согласно is_command), в остальных"
+" случаях None."
+
+#: of telebot.service_utils.generate_random_token:1
+msgid ""
+"Generates a random token consisting of letters and digits, 16 characters "
+"long."
+msgstr ""
+"Генерирует рандомный токен, состоящий из латинских букв и цифр длиной 16 "
+"символов."
+
+#: of telebot.service_utils.generate_random_token:3
+msgid "a random token"
+msgstr "Сгенерированный токен"
+
+#: of telebot.service_utils.generate_random_token:4 telebot.util.user_link:22
+msgid ":obj:`str`"
+msgstr ""
+
+#: of telebot.service_utils.is_bytes:1
+msgid "Returns True if the given object is a bytes object."
+msgstr "Возвращает True если полученный объект является bytes."
+
+#: of telebot.service_utils.is_bytes:3 telebot.service_utils.is_dict:3
+#: telebot.service_utils.is_pil_image:3
+msgid "object to be checked"
+msgstr "Объект для проверки"
+
+#: of telebot.service_utils.is_bytes:6
+msgid "True if the given object is a bytes object."
+msgstr "True, если полученный объект является bytes."
+
+#: of telebot.service_utils.is_bytes:7 telebot.service_utils.is_dict:7
+#: telebot.service_utils.is_pil_image:7 telebot.util.is_command:7
+msgid ":obj:`bool`"
+msgstr ""
+
+#: of telebot.util.is_command:1
+msgid ""
+"Checks if `text` is a command. Telegram chat commands start with the '/' "
+"character."
+msgstr ""
+"Проверяет, является ли `text` командой. Команды в Telegram начинаются с "
+"символа '/'."
+
+#: of telebot.util.is_command:3
+msgid "Text to check."
+msgstr "Текст для проверки."
+
+#: of telebot.util.is_command:6
+msgid "True if `text` is a command, else False."
+msgstr "True, если `text` является командой, иначе False."
+
+#: of telebot.service_utils.is_dict:1
+msgid "Returns True if the given object is a dictionary."
+msgstr "Возвращает True, если полученный объект является словарём (dict)."
+
+#: of telebot.service_utils.is_dict:6
+msgid "True if the given object is a dictionary."
+msgstr "True, если полученный объект является словарём (dict)."
+
+#: of telebot.service_utils.is_pil_image:1
+msgid "Returns True if the given object is a PIL.Image.Image object."
+msgstr "Возвращает True, если полученный объект является PIL.Image.Image."
+
+#: of telebot.service_utils.is_pil_image:6
+msgid "True if the given object is a PIL.Image.Image object."
+msgstr "True, если полученный объект является PIL.Image.Image."
+
+#: of telebot.service_utils.is_string:1
+msgid "Returns True if the given object is a string."
+msgstr "Возвращает True, если полученный объект является строкой (str)."
+
+#: of telebot.util.parse_web_app_data:1
+msgid "Parses web app data."
+msgstr "Обрабатывает данные, полученные от web app."
+
+#: of telebot.util.parse_web_app_data:3 telebot.util.validate_web_app_data:3
+msgid "The bot token"
+msgstr "Токен бота"
+
+#: of telebot.util.parse_web_app_data:6 telebot.util.validate_web_app_data:6
+msgid "The raw init data"
+msgstr "Необработанные данные"
+
+#: of telebot.util.parse_web_app_data:9 telebot.util.validate_web_app_data:9
+msgid "The parsed init data"
+msgstr "Обработанные данные"
+
+#: of telebot.util.quick_markup:1
+msgid ""
+"Returns a reply markup from a dict in this format: {'text': kwargs} This "
+"is useful to avoid always typing 'btn1 = InlineKeyboardButton(...)' 'btn2"
+" = InlineKeyboardButton(...)'"
+msgstr ""
+"Возвращает reply markup из словаря следующего формата: {'text': kwargs}. "
+"Удобно использовать вместо постоянного использования 'btn1 = "
+"InlineKeyboardButton(...)' 'btn2 = InlineKeyboardButton(...)'"
+
+#: of telebot.util.quick_markup:4 telebot.util.user_link:5
+msgid "Example:"
+msgstr "Пример:"
+
+#: of telebot.util.quick_markup:6
+msgid "Using quick_markup:"
+msgstr "Используя quick_markup:"
+
+#: of telebot.util.quick_markup:31
+msgid ""
+"a dict containing all buttons to create in this format: {text: kwargs} "
+"{str:}"
+msgstr ""
+"Словарь, содержащий все кнопки для создания reply markup в следующем "
+"формате: {text: kwargs} {str:}"
+
+#: of telebot.util.quick_markup:34
+msgid "number of :class:`telebot.types.InlineKeyboardButton` objects on each row"
+msgstr ""
+
+#: of telebot.util.quick_markup:37
+msgid "InlineKeyboardMarkup"
+msgstr ""
+
+#: of telebot.util.quick_markup:38
+msgid ":obj:`types.InlineKeyboardMarkup`"
+msgstr ""
+
+#: of telebot.util.smart_split:1
+msgid ""
+"Splits one string into multiple strings, with a maximum amount of "
+"`chars_per_string` characters per string. This is very useful for "
+"splitting one giant message into multiples. If `chars_per_string` > 4096:"
+" `chars_per_string` = 4096. Splits by '\\n', '. ' or ' ' in exactly this "
+"priority."
+msgstr ""
+"Разбивает строку на несколько, каждая из которых будет не длиннее "
+"`characters_per_string`. Удобно использовать для разбиения одного "
+"гигантского сообщения на несколько. Если `chars_per_string` > 4096: "
+"`chars_per_string` = 4096. Разбивает строку по '\\n', '. ' или ' ' именно"
+" в таком порядке."
+
+#: of telebot.util.smart_split:6 telebot.util.split_string:4
+msgid "The text to split"
+msgstr "Текст для разбиения"
+
+#: of telebot.util.smart_split:9
+msgid "The number of maximum characters per part the text is split to."
+msgstr ""
+"Максимальное количество символов в части текста, на которые он будет "
+"разбит."
+
+#: of telebot.util.smart_split:12 telebot.util.split_string:10
+msgid "The splitted text as a list of strings."
+msgstr "Список частей разбитого текста."
+
+#: of telebot.util.smart_split:13 telebot.util.split_string:11
+msgid ":obj:`list` of :obj:`str`"
+msgstr ""
+
+#: of telebot.util.split_string:1
+msgid ""
+"Splits one string into multiple strings, with a maximum amount of "
+"`chars_per_string` characters per string. This is very useful for "
+"splitting one giant message into multiples."
+msgstr ""
+"Разбивает одну строку на несколько, каждая из которых будет не длиннее "
+"`characters_per_string`. Удобно использовать для разбиения одного "
+"гигантского сообщения на несколько."
+
+#: of telebot.util.split_string:7
+msgid "The number of characters per line the text is split into."
+msgstr "Количество символов в одной строке, на которые будет разбит текст."
+
+#: ../../docstring of telebot.util.update_types:1
+msgid "All update types, should be used for allowed_updates parameter in polling."
+msgstr ""
+"Все виды апдейтов, рекомендуется использовать в качестве параметра "
+"allowed_updates функции polling."
+
+#: of telebot.util.user_link:1
+msgid ""
+"Returns an HTML user link. This is useful for reports. Attention: Don't "
+"forget to set parse_mode to 'HTML'!"
+msgstr ""
+"Возвращает HTML ссылку на пользователя. Удобно использовать для отчетов. "
+"Важно: Не забудьте установить значение 'HTML' в parse_mode!"
+
+#: of telebot.util.user_link:11
+msgid ""
+"You can use formatting.* for all other formatting options(bold, italic, "
+"links, and etc.) This method is kept for backward compatibility, and it "
+"is recommended to use formatting.* for more options."
+msgstr ""
+"Вы можете использовать formatting.* во всех остальных вариантах "
+"форматирования(bold, italic, links, и прочее). Этот метод сохранён для "
+"обратной совместимости, рекомендуется использовать formatting.* для "
+"большего количества вариантов."
+
+#: of telebot.util.user_link:15
+msgid "the user (not the user_id)"
+msgstr "Пользователь (не id пользователя)"
+
+#: of telebot.util.user_link:18
+msgid "include the user_id"
+msgstr "Добавить id пользователя"
+
+#: of telebot.util.user_link:21
+msgid "HTML user link"
+msgstr "Ссылка на пользователя в формате HTML"
+
+#: of telebot.util.validate_web_app_data:1
+msgid "Validates web app data."
+msgstr "Проверяет данные, полученные от web app."
+
+#: of telebot.util.webhook_google_functions:1
+msgid "A webhook endpoint for Google Cloud Functions FaaS."
+msgstr "Endpoint вебхука для Google Cloud Functions FaaS."
+
+#: of telebot.util.webhook_google_functions:3
+msgid "The bot instance"
+msgstr "Инстанс бота"
+
+#: of telebot.util.webhook_google_functions:6
+msgid "The request object"
+msgstr "HTTP-запрос"
+
+#: of telebot.util.webhook_google_functions:9
+msgid "The response object"
+msgstr "Объект, полученный в качестве ответа"
+
+#~ msgid "int row width"
+#~ msgstr "Количество кнопок в одной строке, int"
+

docs/source/quick_start.rst

@@ -0,0 +1,20 @@
+
+===========
+Quick start
+===========
+
+.. meta::
+   :description: Quickstart guide
+   :keywords: ptba, pytba, pyTelegramBotAPI, quickstart, guide
+
+Synchronous TeleBot
+-------------------
+.. literalinclude:: ../../examples/echo_bot.py
+    :language: python
+
+Asynchronous TeleBot
+--------------------
+.. literalinclude:: ../../examples/asynchronous_telebot/echo_bot.py
+    :language: python
+
+

docs/source/sync_version/index.rst

@@ -0,0 +1,41 @@
+===============
+TeleBot version
+===============
+
+.. meta::
+   :description: Synchronous pyTelegramBotAPI documentation
+   :keywords: ptba, pytba, pyTelegramBotAPI, methods, guide, files, sync
+
+TeleBot methods
+---------------
+.. automodule:: telebot
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+custom_filters file
+------------------------------
+
+.. automodule:: telebot.custom_filters
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+handler_backends file
+--------------------------------
+
+.. automodule:: telebot.handler_backends
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Extensions
+------------------------
+
+
+
+.. automodule:: telebot.ext.sync.webhooks
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/source/types.rst

@@ -0,0 +1,10 @@
+============
+Types of API
+============
+
+
+
+.. automodule:: telebot.types
+   :members:
+   :undoc-members:
+   :show-inheritance:

docs/source/util.rst

@@ -0,0 +1,16 @@
+============
+Utils
+============
+
+.. meta::
+   :description: Utils in pyTelegramBotAPI
+   :keywords: ptba, pytba, pyTelegramBotAPI, utils, guide
+
+
+util file
+-------------------
+
+.. automodule:: telebot.util
+   :members:
+   :undoc-members:
+   :show-inheritance:

examples/anonymous_bot.py

@@ -0,0 +1,117 @@
+# This bot is needed to connect two people and their subsequent anonymous communication
+#
+# Avaiable commands:
+# `/start` - Just send you a messsage how to start
+# `/find` - Find a person you can contact
+# `/stop` - Stop active conversation
+
+import telebot
+from telebot import types
+
+# Initialize bot with your token
+bot = telebot.TeleBot('TOKEN')
+
+# The `users` variable is needed to contain chat ids that are either in the search or in the active dialog, like {chat_id, chat_id}
+users = {}
+# The `freeid` variable is needed to contain chat id, that want to start conversation
+# Or, in other words: chat id of user in the search
+freeid = None
+
+# `/start` command handler
+#
+# That command only sends you 'Just use /find command!'
+@bot.message_handler(commands=['start'])
+def start(message: types.Message):
+    bot.send_message(message.chat.id, 'Just use /find command!')
+
+# `/find` command handler
+#
+# That command finds opponent for you
+#
+# That command according to the following principle:
+# 1. You have written `/find` command
+# 2. If you are already in the search or have an active dialog, bot sends you 'Shut up!'
+# 3. If not:
+#   3.1. Bot sends you 'Finding...'
+#   3.2. If there is no user in the search:
+#       3.2.2. `freeid` updated with `your_chat_id`
+#   3.3. If there is user in the search:
+#       3.3.1. Both you and the user in the search recieve the message 'Founded!'
+#       3.3.2. `users` updated with a {user_in_the_search_chat_id, your_chat_id}
+#       3.3.3. `users` updated with a {your_chat_id, user_in_the_search_id}
+#       3.3.4. `freeid` updated with `None`
+@bot.message_handler(commands=['find'])
+def find(message: types.Message):
+    global freeid
+
+    if message.chat.id not in users:
+        bot.send_message(message.chat.id, 'Finding...')
+
+        if freeid is None:
+            freeid = message.chat.id
+        else:
+            # Question:
+            # Is there any way to simplify this like `bot.send_message([message.chat.id, freeid], 'Founded!')`?
+            bot.send_message(message.chat.id, 'Founded!')
+            bot.send_message(freeid, 'Founded!')
+
+            users[freeid] = message.chat.id
+            users[message.chat.id] = freeid
+            freeid = None
+
+        print(users, freeid) # Debug purpose, you can remove that line
+    else:
+        bot.send_message(message.chat.id, 'Shut up!')
+
+# `/stop` command handler
+#
+# That command stops your current conversation (if it exist)
+#
+# That command according to the following principle:
+# 1. You have written `/stop` command
+# 2. If you are not have active dialog or you are not in search, bot sends you 'You are not in search!'
+# 3. If you are in active dialog:
+#   3.1. Bot sends you 'Stopping...'
+#   3.2. Bot sends 'Your opponent is leavin`...' to your opponent
+#   3.3. {your_opponent_chat_id, your_chat_id} removes from `users`
+#   3.4. {your_chat_id, your_opponent_chat_id} removes from `users`
+# 4. If you are only in search:
+#   4.1. Bot sends you 'Stopping...'
+#   4.2. `freeid` updated with `None`
+@bot.message_handler(commands=['stop'])
+def stop(message: types.Message):
+    global freeid
+
+    if message.chat.id in users:
+        bot.send_message(message.chat.id, 'Stopping...')
+        bot.send_message(users[message.chat.id], 'Your opponent is leavin`...')
+
+        del users[users[message.chat.id]]
+        del users[message.chat.id]
+        
+        print(users, freeid) # Debug purpose, you can remove that line
+    elif message.chat.id == freeid:
+        bot.send_message(message.chat.id, 'Stopping...')
+        freeid = None
+
+        print(users, freeid) # Debug purpose, you can remove that line
+    else:
+        bot.send_message(message.chat.id, 'You are not in search!')
+
+# message handler for conversation
+#
+# That handler needed to send message from one opponent to another
+# If you are not in `users`, you will recieve a message 'No one can hear you...'
+# Otherwise all your messages are sent to your opponent
+#
+# Questions:
+# 1. Is there any way to improve readability like `content_types=['all']`?
+# 2. Is there any way to register this message handler only when i found the opponent?
+@bot.message_handler(content_types=['animation', 'audio', 'contact', 'dice', 'document', 'location', 'photo', 'poll', 'sticker', 'text', 'venue', 'video', 'video_note', 'voice'])
+def chatting(message: types.Message):
+    if message.chat.id in users:
+        bot.copy_message(users[message.chat.id], users[users[message.chat.id]], message.id)
+    else:
+        bot.send_message(message.chat.id, 'No one can hear you...')
+
+bot.infinity_polling(skip_pending=True)

examples/asynchronous_telebot/callback_data_examples/advanced_calendar_example/filters.py

@@ -0,0 +1,26 @@
+from telebot import types
+from telebot.async_telebot import AsyncTeleBot
+from telebot.asyncio_filters import AdvancedCustomFilter
+from telebot.callback_data import CallbackData, CallbackDataFilter
+
+calendar_factory = CallbackData("year", "month", prefix="calendar")
+calendar_zoom = CallbackData("year", prefix="calendar_zoom")
+
+
+class CalendarCallbackFilter(AdvancedCustomFilter):
+    key = 'calendar_config'
+
+    async def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+class CalendarZoomCallbackFilter(AdvancedCustomFilter):
+    key = 'calendar_zoom_config'
+
+    async def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+def bind_filters(bot: AsyncTeleBot):
+    bot.add_custom_filter(CalendarCallbackFilter())
+    bot.add_custom_filter(CalendarZoomCallbackFilter())

examples/asynchronous_telebot/callback_data_examples/advanced_calendar_example/keyboards.py

@@ -0,0 +1,92 @@
+import calendar
+from datetime import date, timedelta
+
+from filters import calendar_factory, calendar_zoom
+from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+EMTPY_FIELD = '1'
+WEEK_DAYS = [calendar.day_abbr[i] for i in range(7)]
+MONTHS = [(i, calendar.month_name[i]) for i in range(1, 13)]
+
+
+def generate_calendar_days(year: int, month: int):
+    keyboard = InlineKeyboardMarkup(row_width=7)
+    today = date.today()
+
+    keyboard.add(
+        InlineKeyboardButton(
+            text=date(year=year, month=month, day=1).strftime('%b %Y'),
+            callback_data=EMTPY_FIELD
+        )
+    )
+    keyboard.add(*[
+        InlineKeyboardButton(
+            text=day,
+            callback_data=EMTPY_FIELD
+        )
+        for day in WEEK_DAYS
+    ])
+
+    for week in calendar.Calendar().monthdayscalendar(year=year, month=month):
+        week_buttons = []
+        for day in week:
+            day_name = ' '
+            if day == today.day and today.year == year and today.month == month:
+                day_name = '🔘'
+            elif day != 0:
+                day_name = str(day)
+            week_buttons.append(
+                InlineKeyboardButton(
+                    text=day_name,
+                    callback_data=EMTPY_FIELD
+                )
+            )
+        keyboard.add(*week_buttons)
+
+    previous_date = date(year=year, month=month, day=1) - timedelta(days=1)
+    next_date = date(year=year, month=month, day=1) + timedelta(days=31)
+
+    keyboard.add(
+        InlineKeyboardButton(
+            text='Previous month',
+            callback_data=calendar_factory.new(year=previous_date.year, month=previous_date.month)
+        ),
+        InlineKeyboardButton(
+            text='Zoom out',
+            callback_data=calendar_zoom.new(year=year)
+        ),
+        InlineKeyboardButton(
+            text='Next month',
+            callback_data=calendar_factory.new(year=next_date.year, month=next_date.month)
+        ),
+    )
+
+    return keyboard
+
+
+def generate_calendar_months(year: int):
+    keyboard = InlineKeyboardMarkup(row_width=3)
+    keyboard.add(
+        InlineKeyboardButton(
+            text=date(year=year, month=1, day=1).strftime('Year %Y'),
+            callback_data=EMTPY_FIELD
+        )
+    )
+    keyboard.add(*[
+        InlineKeyboardButton(
+            text=month,
+            callback_data=calendar_factory.new(year=year, month=month_number)
+        )
+        for month_number, month in MONTHS
+    ])
+    keyboard.add(
+        InlineKeyboardButton(
+            text='Previous year',
+            callback_data=calendar_zoom.new(year=year - 1)
+        ),
+        InlineKeyboardButton(
+            text='Next year',
+            callback_data=calendar_zoom.new(year=year + 1)
+        )
+    )
+    return keyboard

examples/asynchronous_telebot/callback_data_examples/advanced_calendar_example/main.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you an advanced usage of CallbackData.
+In this example calendar was implemented
+"""
+import asyncio
+from datetime import date
+
+from filters import calendar_factory, calendar_zoom, bind_filters
+from keyboards import generate_calendar_days, generate_calendar_months, EMTPY_FIELD
+from telebot import types
+from telebot.async_telebot import AsyncTeleBot
+
+API_TOKEN = ''
+bot = AsyncTeleBot(API_TOKEN)
+
+
+@bot.message_handler(commands='start')
+async def start_command_handler(message: types.Message):
+    await bot.send_message(message.chat.id,
+                           f"Hello {message.from_user.first_name}. This bot is an example of calendar keyboard."
+                           "\nPress /calendar to see it.")
+
+
+@bot.message_handler(commands='calendar')
+async def calendar_command_handler(message: types.Message):
+    now = date.today()
+    await bot.send_message(message.chat.id, 'Calendar',
+                           reply_markup=generate_calendar_days(year=now.year, month=now.month))
+
+
+@bot.callback_query_handler(func=None, calendar_config=calendar_factory.filter())
+async def calendar_action_handler(call: types.CallbackQuery):
+    callback_data: dict = calendar_factory.parse(callback_data=call.data)
+    year, month = int(callback_data['year']), int(callback_data['month'])
+
+    await bot.edit_message_reply_markup(call.message.chat.id, call.message.id,
+                                        reply_markup=generate_calendar_days(year=year, month=month))
+
+
+@bot.callback_query_handler(func=None, calendar_zoom_config=calendar_zoom.filter())
+async def calendar_zoom_out_handler(call: types.CallbackQuery):
+    callback_data: dict = calendar_zoom.parse(callback_data=call.data)
+    year = int(callback_data.get('year'))
+
+    await bot.edit_message_reply_markup(call.message.chat.id, call.message.id,
+                                        reply_markup=generate_calendar_months(year=year))
+
+
+@bot.callback_query_handler(func=lambda call: call.data == EMTPY_FIELD)
+async def callback_empty_field_handler(call: types.CallbackQuery):
+    await bot.answer_callback_query(call.id)
+
+
+if __name__ == '__main__':
+    bind_filters(bot)
+    asyncio.run(bot.infinity_polling())

examples/asynchronous_telebot/callback_data_examples/simple_products_example.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you how to use CallbackData
+"""
+
+from telebot.callback_data import CallbackData, CallbackDataFilter
+from telebot import types
+from telebot.async_telebot import AsyncTeleBot
+from telebot.asyncio_filters import AdvancedCustomFilter
+
+API_TOKEN = 'TOKEN'
+PRODUCTS = [
+    {'id': '0', 'name': 'xiaomi mi 10', 'price': 400},
+    {'id': '1', 'name': 'samsung s20', 'price': 800},
+    {'id': '2', 'name': 'iphone 13', 'price': 1300}
+]
+
+bot = AsyncTeleBot(API_TOKEN)
+products_factory = CallbackData('product_id', prefix='products')
+
+
+def products_keyboard():
+    return types.InlineKeyboardMarkup(
+        keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=product['name'],
+                    callback_data=products_factory.new(product_id=product["id"])
+                )
+            ]
+            for product in PRODUCTS
+        ]
+    )
+
+
+def back_keyboard():
+    return types.InlineKeyboardMarkup(
+        keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text='⬅',
+                    callback_data='back'
+                )
+            ]
+        ]
+    )
+
+
+class ProductsCallbackFilter(AdvancedCustomFilter):
+    key = 'config'
+
+    async def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+@bot.message_handler(commands=['products'])
+async def products_command_handler(message: types.Message):
+    await bot.send_message(message.chat.id, 'Products:', reply_markup=products_keyboard())
+
+
+# Only product with field - product_id = 2
+@bot.callback_query_handler(func=None, config=products_factory.filter(product_id='2'))
+async def product_one_callback(call: types.CallbackQuery):
+    await bot.answer_callback_query(callback_query_id=call.id, text='Not available :(', show_alert=True)
+
+
+# Any other products
+@bot.callback_query_handler(func=None, config=products_factory.filter())
+async def products_callback(call: types.CallbackQuery):
+    callback_data: dict = products_factory.parse(callback_data=call.data)
+    product_id = int(callback_data['product_id'])
+    product = PRODUCTS[product_id]
+
+    text = f"Product name: {product['name']}\n" \
+           f"Product price: {product['price']}"
+    await bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
+                          text=text, reply_markup=back_keyboard())
+
+
+@bot.callback_query_handler(func=lambda c: c.data == 'back')
+async def back_callback(call: types.CallbackQuery):
+    await bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
+                          text='Products:', reply_markup=products_keyboard())
+
+
+bot.add_custom_filter(ProductsCallbackFilter())
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/chat_join_request.py

@@ -0,0 +1,12 @@
+from telebot.async_telebot import AsyncTeleBot
+
+import telebot
+bot = AsyncTeleBot('TOKEN')
+
+@bot.chat_join_request_handler()
+async def make_some(message: telebot.types.ChatJoinRequest):
+    await bot.send_message(message.chat.id, 'I accepted a new user!')
+    await bot.approve_chat_join_request(message.chat.id, message.from_user.id)
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/chat_member_example.py

@@ -0,0 +1,34 @@
+from telebot import types,util
+from telebot.async_telebot import AsyncTeleBot
+
+bot = AsyncTeleBot('TOKEN')
+
+#chat_member_handler. When status changes, telegram gives update. check status from old_chat_member and new_chat_member.
+@bot.chat_member_handler()
+async def chat_m(message: types.ChatMemberUpdated):
+    old = message.old_chat_member
+    new = message.new_chat_member
+    if new.status == "member":
+        await bot.send_message(message.chat.id,"Hello {name}!".format(name=new.user.first_name)) # Welcome message
+
+#if bot is added to group, this handler will work
+@bot.my_chat_member_handler()
+async def my_chat_m(message: types.ChatMemberUpdated):
+    old = message.old_chat_member
+    new = message.new_chat_member
+    if new.status == "member":
+        await bot.send_message(message.chat.id,"Somebody added me to group") # Welcome message, if bot was added to group
+        await bot.leave_chat(message.chat.id)
+
+#content_Type_service is:
+#'new_chat_members', 'left_chat_member', 'new_chat_title', 'new_chat_photo', 'delete_chat_photo', 'group_chat_created',
+#'supergroup_chat_created', 'channel_chat_created', 'migrate_to_chat_id', 'migrate_from_chat_id', 'pinned_message',
+#'proximity_alert_triggered', 'video_chat_scheduled', 'video_chat_started', 'video_chat_ended', 
+#'video_chat_participants_invited', 'message_auto_delete_timer_changed'
+# this handler deletes service messages
+
+@bot.message_handler(content_types=util.content_type_service)
+async def delall(message: types.Message):
+    await bot.delete_message(message.chat.id,message.message_id)
+import asyncio
+asyncio.run(bot.polling(allowed_updates=util.update_types))

examples/asynchronous_telebot/continue_handling.py

@@ -0,0 +1,27 @@
+from telebot.async_telebot import AsyncTeleBot
+from telebot.asyncio_handler_backends import ContinueHandling
+
+
+bot = AsyncTeleBot('TOKEN')
+
+@bot.message_handler(commands=['start'])
+async def start(message):
+    await bot.send_message(message.chat.id, 'Hello World!')
+    return ContinueHandling()
+
+@bot.message_handler(commands=['start'])
+async def start2(message):
+    """
+    This handler comes after the first one, but it will never be called.
+    But you can call it by returning ContinueHandling() in the first handler.
+
+    If you return ContinueHandling() in the first handler, the next 
+    registered handler with appropriate filters will be called.
+    """
+    await bot.send_message(message.chat.id, 'Hello World2!')
+
+import asyncio 
+asyncio.run(bot.polling()) # just a reminder that infinity polling
+# wraps polling into try/except block just as sync version,
+# but you can use any of them because neither of them stops if you
+# pass non_stop=True

examples/asynchronous_telebot/custom_filters/admin_filter_example.py

@@ -0,0 +1,14 @@
+from telebot.async_telebot import AsyncTeleBot
+from telebot import asyncio_filters
+bot = AsyncTeleBot('TOKEN')
+
+# Handler
+@bot.message_handler(chat_types=['supergroup'], is_chat_admin=True)
+async def answer_for_admin(message):
+    await bot.send_message(message.chat.id,"hello my admin")
+
+# Register filter
+bot.add_custom_filter(asyncio_filters.IsAdminFilter(bot))
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_filters/advanced_text_filter.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you usage of TextFilter
+In this example you will see how to use TextFilter
+with (message_handler, callback_query_handler, poll_handler)
+"""
+import asyncio
+
+from telebot import types
+from telebot.async_telebot import AsyncTeleBot
+from telebot.asyncio_filters import TextMatchFilter, TextFilter, IsReplyFilter
+
+bot = AsyncTeleBot("")
+
+
+@bot.message_handler(text=TextFilter(equals='hello'))
+async def hello_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(equals='hello', ignore_case=True))
+async def hello_handler_ignore_case(message: types.Message):
+    await bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(contains=['good', 'bad']))
+async def contains_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(contains=['good', 'bad'], ignore_case=True))
+async def contains_handler_ignore_case(message: types.Message):
+    await bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(starts_with='st'))  # stArk, steve, stONE
+async def starts_with_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(starts_with='st', ignore_case=True))  # STark, sTeve, stONE
+async def starts_with_handler_ignore_case(message: types.Message):
+    await bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(ends_with='ay'))  # wednesday, SUNday, WeekDay
+async def ends_with_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(ends_with='ay', ignore_case=True))  # wednesdAY, sundAy, WeekdaY
+async def ends_with_handler_ignore_case(message: types.Message):
+    await bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(equals='/callback'))
+async def send_callback(message: types.Message):
+    keyboard = types.InlineKeyboardMarkup(
+        keyboard=[
+            [types.InlineKeyboardButton(text='callback data', callback_data='example')],
+            [types.InlineKeyboardButton(text='ignore case callback data', callback_data='ExAmPLe')]
+        ]
+    )
+    await bot.send_message(message.chat.id, message.text, reply_markup=keyboard)
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(equals='example'))
+async def callback_query_handler(call: types.CallbackQuery):
+    await bot.answer_callback_query(call.id, call.data, show_alert=True)
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(equals='example', ignore_case=True))
+async def callback_query_handler_ignore_case(call: types.CallbackQuery):
+    await bot.answer_callback_query(call.id, call.data + " ignore case", show_alert=True)
+
+
+@bot.message_handler(text=TextFilter(equals='/poll'))
+async def send_poll(message: types.Message):
+    await bot.send_poll(message.chat.id, question='When do you prefer to work?', options=['Morning', 'Night'])
+    await bot.send_poll(message.chat.id, question='WHEN DO you pRefeR to worK?', options=['Morning', 'Night'])
+
+
+@bot.poll_handler(func=None, text=TextFilter(equals='When do you prefer to work?'))
+async def poll_question_handler(poll: types.Poll):
+    print(poll.question)
+
+
+@bot.poll_handler(func=None, text=TextFilter(equals='When do you prefer to work?', ignore_case=True))
+async def poll_question_handler_ignore_case(poll: types.Poll):
+    print(poll.question + ' ignore case')
+
+
+# either hi or contains one of (привет, salom)
+@bot.message_handler(text=TextFilter(equals="hi", contains=('привет', 'salom'), ignore_case=True))
+async def multiple_patterns_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+# starts with one of (mi, mea) for ex. minor, milk, meal, meat
+@bot.message_handler(text=TextFilter(starts_with=['mi', 'mea'], ignore_case=True))
+async def multiple_starts_with_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+# ends with one of (es, on) for ex. Jones, Davies, Johnson, Wilson
+@bot.message_handler(text=TextFilter(ends_with=['es', 'on'], ignore_case=True))
+async def multiple_ends_with_handler(message: types.Message):
+    await bot.send_message(message.chat.id, message.text)
+
+
+# !ban /ban .ban !бан /бан .бан
+@bot.message_handler(is_reply=True,
+                     text=TextFilter(starts_with=('!', '/', '.'), ends_with=['ban', 'бан'], ignore_case=True))
+async def ban_command_handler(message: types.Message):
+    if len(message.text) == 4 and message.chat.type != 'private':
+        try:
+            await bot.ban_chat_member(message.chat.id, message.reply_to_message.from_user.id)
+            await bot.reply_to(message.reply_to_message, 'Banned.')
+        except Exception as err:
+            print(err.args)
+            return
+
+
+if __name__ == '__main__':
+    bot.add_custom_filter(TextMatchFilter())
+    bot.add_custom_filter(IsReplyFilter())
+    asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_filters/general_custom_filters.py

@@ -0,0 +1,44 @@
+from telebot.async_telebot import AsyncTeleBot
+import telebot
+bot = AsyncTeleBot('TOKEN')
+
+
+# AdvancedCustomFilter is for list, string filter values
+class MainFilter(telebot.asyncio_filters.AdvancedCustomFilter):
+    key='text'
+    @staticmethod
+    async def check(message, text):
+        return message.text in text
+
+# SimpleCustomFilter is for boolean values, such as is_admin=True
+class IsAdmin(telebot.asyncio_filters.SimpleCustomFilter):
+    key='is_admin'
+    @staticmethod
+    async def check(message: telebot.types.Message):
+        result = await bot.get_chat_member(message.chat.id,message.from_user.id)
+        return result.status in ['administrator','creator']
+
+
+@bot.message_handler(is_admin=True, commands=['admin']) # Check if user is admin
+async def admin_rep(message):
+    await bot.send_message(message.chat.id, "Hi admin")
+
+@bot.message_handler(is_admin=False, commands=['admin']) # If user is not admin
+async def not_admin(message):
+    await bot.send_message(message.chat.id, "You are not admin")
+
+@bot.message_handler(text=['hi']) # Response to hi message
+async def welcome_hi(message):
+    await bot.send_message(message.chat.id, 'You said hi')
+
+@bot.message_handler(text=['bye']) # Response to bye message
+async def bye_user(message):
+    await bot.send_message(message.chat.id, 'You said bye')
+
+
+# Do not forget to register filters
+bot.add_custom_filter(MainFilter())
+bot.add_custom_filter(IsAdmin())
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_filters/id_filter_example.py

@@ -0,0 +1,18 @@
+from telebot.async_telebot import AsyncTeleBot
+import telebot
+bot = AsyncTeleBot('TOKEN')
+
+
+# Chat id can be private or supergroups.
+@bot.message_handler(chat_id=[12345678], commands=['admin']) # chat_id checks id corresponds to your list or not.
+async def admin_rep(message):
+    await bot.send_message(message.chat.id, "You are allowed to use this command.")
+
+@bot.message_handler(commands=['admin'])
+async def not_admin(message):
+    await bot.send_message(message.chat.id, "You are not allowed to use this command")
+
+# Do not forget to register
+bot.add_custom_filter(telebot.asyncio_filters.ChatFilter())
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_filters/is_filter_example.py

@@ -0,0 +1,23 @@
+from telebot.async_telebot import AsyncTeleBot
+import telebot
+
+bot = AsyncTeleBot('TOKEN')
+
+
+
+# Check if message is a reply
+@bot.message_handler(is_reply=True)
+async def start_filter(message):
+    await bot.send_message(message.chat.id, "Looks like you replied to my message.")
+
+# Check if message was forwarded
+@bot.message_handler(is_forwarded=True)
+async def text_filter(message):
+    await bot.send_message(message.chat.id, "I do not accept forwarded messages!")
+
+# Do not forget to register filters
+bot.add_custom_filter(telebot.asyncio_filters.IsReplyFilter())
+bot.add_custom_filter(telebot.asyncio_filters.ForwardFilter())
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_filters/text_filter_example.py

@@ -0,0 +1,21 @@
+from telebot.async_telebot import AsyncTeleBot
+import telebot
+bot = AsyncTeleBot('TOKEN')
+
+
+# Check if message starts with @admin tag
+@bot.message_handler(text_startswith="@admin")
+async def start_filter(message):
+    await bot.send_message(message.chat.id, "Looks like you are calling admin, wait...")
+
+# Check if text is hi or hello
+@bot.message_handler(text=['hi','hello'])
+async def text_filter(message):
+    await bot.send_message(message.chat.id, "Hi, {name}!".format(name=message.from_user.first_name))
+
+# Do not forget to register filters
+bot.add_custom_filter(telebot.asyncio_filters.TextMatchFilter())
+bot.add_custom_filter(telebot.asyncio_filters.TextStartsFilter())
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/custom_states.py

@@ -0,0 +1,91 @@
+from telebot import asyncio_filters
+from telebot.async_telebot import AsyncTeleBot
+
+# list of storages, you can use any storage
+from telebot.asyncio_storage import StateMemoryStorage
+
+# new feature for states.
+from telebot.asyncio_handler_backends import State, StatesGroup
+
+# default state storage is statememorystorage
+bot = AsyncTeleBot('TOKEN', state_storage=StateMemoryStorage())
+
+
+# Just create different statesgroup
+class MyStates(StatesGroup):
+    name = State() # statesgroup should contain states
+    surname = State()
+    age = State()
+
+
+
+# set_state -> sets a new state
+# delete_state -> delets state if exists
+# get_state -> returns state if exists
+
+
+@bot.message_handler(commands=['start'])
+async def start_ex(message):
+    """
+    Start command. Here we are starting state
+    """
+    await bot.set_state(message.from_user.id, MyStates.name, message.chat.id)
+    await bot.send_message(message.chat.id, 'Hi, write me a name')
+ 
+
+ 
+@bot.message_handler(state="*", commands='cancel')
+async def any_state(message):
+    """
+    Cancel state
+    """
+    await bot.send_message(message.chat.id, "Your state was cancelled.")
+    await bot.delete_state(message.from_user.id, message.chat.id)
+
+@bot.message_handler(state=MyStates.name)
+async def name_get(message):
+    """
+    State 1. Will process when user's state is MyStates.name.
+    """
+    await bot.send_message(message.chat.id, f'Now write me a surname')
+    await bot.set_state(message.from_user.id, MyStates.surname, message.chat.id)
+    async with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        data['name'] = message.text
+ 
+ 
+@bot.message_handler(state=MyStates.surname)
+async def ask_age(message):
+    """
+    State 2. Will process when user's state is MyStates.surname.
+    """
+    await bot.send_message(message.chat.id, "What is your age?")
+    await bot.set_state(message.from_user.id, MyStates.age, message.chat.id)
+    async with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        data['surname'] = message.text
+ 
+# result
+@bot.message_handler(state=MyStates.age, is_digit=True)
+async def ready_for_answer(message):
+    """
+    State 3. Will process when user's state is MyStates.age.
+    """
+    async with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        await bot.send_message(message.chat.id, "Ready, take a look:\n<b>Name: {name}\nSurname: {surname}\nAge: {age}</b>".format(name=data['name'], surname=data['surname'], age=message.text), parse_mode="html")
+    await bot.delete_state(message.from_user.id, message.chat.id)
+
+#incorrect number
+@bot.message_handler(state=MyStates.age, is_digit=False)
+async def age_incorrect(message):
+    """
+    Will process for wrong input when state is MyState.age
+    """
+    await bot.send_message(message.chat.id, 'Looks like you are submitting a string in the field age. Please enter a number')
+
+# register filters
+
+bot.add_custom_filter(asyncio_filters.StateFilter(bot))
+bot.add_custom_filter(asyncio_filters.IsDigitFilter())
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/detect_changes.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+
+# This is a simple echo bot using the decorator mechanism.
+# It echoes any incoming text messages.
+
+from telebot.async_telebot import AsyncTeleBot
+bot = AsyncTeleBot('TOKEN')
+
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+async def send_welcome(message):
+    await bot.reply_to(message, """\
+Hi there, I am EchoBot.
+I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
+""")
+
+
+# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
+@bot.message_handler(func=lambda message: True)
+async def echo_message(message):
+    await bot.reply_to(message, message.text)
+
+
+import asyncio
+# only for versions 4.7.0+
+asyncio.run(bot.polling(restart_on_change=True))

examples/asynchronous_telebot/download_file_example.py

@@ -0,0 +1,21 @@
+
+import telebot
+from telebot.async_telebot import AsyncTeleBot
+
+
+
+bot = AsyncTeleBot('TOKEN')
+
+
+@bot.message_handler(content_types=['photo'])
+async def new_message(message: telebot.types.Message):
+    result_message = await bot.send_message(message.chat.id, '<i>Downloading your photo...</i>', parse_mode='HTML', disable_web_page_preview=True)
+    file_path = await bot.get_file(message.photo[-1].file_id)
+    downloaded_file = await bot.download_file(file_path.file_path)
+    with open('file.jpg', 'wb') as new_file:
+        new_file.write(downloaded_file)
+    await bot.edit_message_text(chat_id=message.chat.id, message_id=result_message.id, text='<i>Done!</i>', parse_mode='HTML')
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/echo_bot.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+
+# This is a simple echo bot using the decorator mechanism.
+# It echoes any incoming text messages.
+
+from telebot.async_telebot import AsyncTeleBot
+bot = AsyncTeleBot('TOKEN')
+
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+async def send_welcome(message):
+    await bot.reply_to(message, """\
+Hi there, I am EchoBot.
+I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
+""")
+
+
+# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
+@bot.message_handler(func=lambda message: True)
+async def echo_message(message):
+    await bot.reply_to(message, message.text)
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/exception_handler.py

@@ -0,0 +1,28 @@
+
+import telebot
+from telebot.async_telebot import AsyncTeleBot
+
+
+import logging
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
+
+class ExceptionHandler(telebot.ExceptionHandler):
+    def handle(self, exception):
+        logger.error(exception)
+
+bot = AsyncTeleBot('TOKEN',exception_handler=ExceptionHandler())
+
+
+
+
+@bot.message_handler(commands=['photo'])
+async def photo_send(message: telebot.types.Message):
+    await bot.send_message(message.chat.id, 'Hi, this is an example of exception handlers.')
+    raise Exception('test') # Exception goes to ExceptionHandler if it is set
+    
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/formatting_example.py

@@ -0,0 +1,54 @@
+from telebot.async_telebot import AsyncTeleBot
+from telebot import formatting
+
+bot = AsyncTeleBot('token')
+
+
+@bot.message_handler(commands=['start'])
+async def start_message(message):
+    await bot.send_message(
+        message.chat.id,
+        # function which connects all strings
+        formatting.format_text(
+            formatting.mbold(message.from_user.first_name),
+            formatting.mitalic(message.from_user.first_name),
+            formatting.munderline(message.from_user.first_name),
+            formatting.mstrikethrough(message.from_user.first_name),
+            formatting.mcode(message.from_user.first_name),
+            separator=" " # separator separates all strings
+        ),
+        parse_mode='MarkdownV2'
+    )
+
+    # just a bold text using markdownv2
+    await bot.send_message(
+        message.chat.id,
+        formatting.mbold(message.from_user.first_name),
+        parse_mode='MarkdownV2'
+    )
+
+    # html
+    await bot.send_message(
+        message.chat.id,
+        formatting.format_text(
+            formatting.hbold(message.from_user.first_name),
+            formatting.hitalic(message.from_user.first_name),
+            formatting.hunderline(message.from_user.first_name),
+            formatting.hstrikethrough(message.from_user.first_name),
+            formatting.hcode(message.from_user.first_name),
+            # hide_link is only for html
+            formatting.hide_link('https://telegra.ph/file/c158e3a6e2a26a160b253.jpg'),
+            separator=" "
+        ),
+        parse_mode='HTML'
+    )
+
+    # just a bold text in html
+    await bot.send_message(
+        message.chat.id,
+        formatting.hbold(message.from_user.first_name),
+        parse_mode='HTML'
+    )
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/middleware/flooding_middleware.py

@@ -0,0 +1,38 @@
+# Just a little example of middleware handlers
+
+from telebot.asyncio_handler_backends import BaseMiddleware, CancelUpdate
+from telebot.async_telebot import AsyncTeleBot
+bot = AsyncTeleBot('TOKEN')
+
+
+class SimpleMiddleware(BaseMiddleware):
+    def __init__(self, limit) -> None:
+        self.last_time = {}
+        self.limit = limit
+        self.update_types = ['message']
+        # Always specify update types, otherwise middlewares won't work
+
+
+    async def pre_process(self, message, data):
+        if not message.from_user.id in self.last_time:
+            # User is not in a dict, so lets add and cancel this function
+            self.last_time[message.from_user.id] = message.date
+            return
+        if message.date - self.last_time[message.from_user.id] < self.limit:
+            # User is flooding
+            await bot.send_message(message.chat.id, 'You are making request too often')
+            return CancelUpdate()
+        self.last_time[message.from_user.id] = message.date
+
+        
+    async def post_process(self, message, data, exception):
+        pass
+
+bot.setup_middleware(SimpleMiddleware(2))
+
+@bot.message_handler(commands=['start'])
+async def start(message):
+    await bot.send_message(message.chat.id, 'Hello!')
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/middleware/i18n.py

@@ -0,0 +1,49 @@
+#!/usr/bin/python
+
+# This example shows how to implement i18n (internationalization) l10n (localization) to create
+# multi-language bots with middleware handler.
+#
+# Also, you could check language code in handler itself too.
+# But this example just to show the work of middlewares.
+
+import telebot
+from telebot.async_telebot import AsyncTeleBot
+from telebot import asyncio_handler_backends
+import logging
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
+
+TRANSLATIONS = {
+    'hello': {
+        'en': 'hello',
+        'ru': 'привет',
+        'uz': 'salom'
+    }
+}
+
+
+
+bot = AsyncTeleBot('TOKEN')
+
+
+class LanguageMiddleware(asyncio_handler_backends.BaseMiddleware):
+    def __init__(self):
+        self.update_types = ['message'] # Update types that will be handled by this middleware.
+    async def pre_process(self, message, data):
+        data['response'] = TRANSLATIONS['hello'][message.from_user.language_code]
+    async def post_process(self, message, data, exception):
+        if exception: # You can get exception occured in handler.
+            logger.exception(str(exception))
+
+bot.setup_middleware(LanguageMiddleware()) # do not forget to setup
+
+@bot.message_handler(commands=['start'])
+async def start(message, data: dict):
+    # you can get the data in handler too.
+    # Not necessary to create data parameter in handler function.
+    await bot.send_message(message.chat.id, data['response'])
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/middleware/i18n_middleware_example/i18n_base_midddleware.py

@@ -0,0 +1,120 @@
+import contextvars
+import gettext
+import os
+
+from telebot.asyncio_handler_backends import BaseMiddleware
+
+try:
+    from babel.support import LazyProxy
+
+    babel_imported = True
+except ImportError:
+    babel_imported = False
+
+
+class I18N(BaseMiddleware):
+    """
+    This middleware provides high-level tool for internationalization
+    It is based on gettext util.
+    """
+
+    context_lang = contextvars.ContextVar('language', default=None)
+
+    def __init__(self, translations_path, domain_name: str):
+        super().__init__()
+        self.update_types = self.process_update_types()
+
+        self.path = translations_path
+        self.domain = domain_name
+        self.translations = self.find_translations()
+
+    @property
+    def available_translations(self):
+        return list(self.translations)
+
+    def gettext(self, text: str, lang: str = None):
+        """
+        Singular translations
+        """
+
+        if lang is None:
+            lang = self.context_lang.get()
+
+        if lang not in self.translations:
+            return text
+
+        translator = self.translations[lang]
+        return translator.gettext(text)
+
+    def ngettext(self, singular: str, plural: str, lang: str = None, n=1):
+        """
+        Plural translations
+        """
+        if lang is None:
+            lang = self.context_lang.get()
+
+        if lang not in self.translations:
+            if n == 1:
+                return singular
+            return plural
+
+        translator = self.translations[lang]
+        return translator.ngettext(singular, plural, n)
+
+    def lazy_gettext(self, text: str, lang: str = None):
+        if not babel_imported:
+            raise RuntimeError('babel module is not imported. Check that you installed it.')
+        return LazyProxy(self.gettext, text, lang, enable_cache=False)
+
+    def lazy_ngettext(self, singular: str, plural: str, lang: str = None, n=1):
+        if not babel_imported:
+            raise RuntimeError('babel module is not imported. Check that you installed it.')
+        return LazyProxy(self.ngettext, singular, plural, lang, n, enable_cache=False)
+
+    async def get_user_language(self, obj):
+        """
+        You need to override this method and return user language
+        """
+        raise NotImplementedError
+
+    def process_update_types(self) -> list:
+        """
+        You need to override this method and return any update types which you want to be processed
+        """
+        raise NotImplementedError
+
+    async def pre_process(self, message, data):
+        """
+        context language variable will be set each time when update from 'process_update_types' comes
+        value is the result of 'get_user_language' method
+        """
+        self.context_lang.set(await self.get_user_language(obj=message))
+
+    async def post_process(self, message, data, exception):
+        pass
+
+    def find_translations(self):
+        """
+        Looks for translations with passed 'domain' in passed 'path'
+        """
+        if not os.path.exists(self.path):
+            raise RuntimeError(f"Translations directory by path: {self.path!r} was not found")
+
+        result = {}
+
+        for name in os.listdir(self.path):
+            translations_path = os.path.join(self.path, name, 'LC_MESSAGES')
+
+            if not os.path.isdir(translations_path):
+                continue
+
+            po_file = os.path.join(translations_path, self.domain + '.po')
+            mo_file = po_file[:-2] + 'mo'
+
+            if os.path.isfile(po_file) and not os.path.isfile(mo_file):
+                raise FileNotFoundError(f"Translations for: {name!r} were not compiled!")
+
+            with open(mo_file, 'rb') as file:
+                result[name] = gettext.GNUTranslations(file)
+
+        return result

examples/asynchronous_telebot/middleware/i18n_middleware_example/keyboards.py

@@ -0,0 +1,34 @@
+from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+
+
+def languages_keyboard():
+    return InlineKeyboardMarkup(
+        keyboard=[
+            [
+                InlineKeyboardButton(text="English", callback_data='en'),
+                InlineKeyboardButton(text="Русский", callback_data='ru'),
+                InlineKeyboardButton(text="O'zbekcha", callback_data='uz_Latn')
+            ]
+        ]
+    )
+
+
+def clicker_keyboard(_):
+    return InlineKeyboardMarkup(
+        keyboard=[
+            [
+                InlineKeyboardButton(text=_("click"), callback_data='click'),
+            ]
+        ]
+    )
+
+
+def menu_keyboard(_):
+    keyboard = ReplyKeyboardMarkup(resize_keyboard=True)
+    keyboard.add(
+        KeyboardButton(text=_("My user id")),
+        KeyboardButton(text=_("My user name")),
+        KeyboardButton(text=_("My first name"))
+    )
+
+    return keyboard

examples/asynchronous_telebot/middleware/i18n_middleware_example/locales/en/LC_MESSAGES/messages.po

@@ -0,0 +1,81 @@
+# English translations for PROJECT.
+# Copyright (C) 2022 ORGANIZATION
+# This file is distributed under the same license as the PROJECT project.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
+"POT-Creation-Date: 2022-02-19 18:37+0500\n"
+"PO-Revision-Date: 2022-02-18 16:22+0500\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: en\n"
+"Language-Team: en <LL@li.org>\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: keyboards.py:20
+msgid "click"
+msgstr ""
+
+#: keyboards.py:29
+msgid "My user id"
+msgstr ""
+
+#: keyboards.py:30
+msgid "My user name"
+msgstr ""
+
+#: keyboards.py:31
+msgid "My first name"
+msgstr ""
+
+#: main.py:97
+msgid ""
+"Hello, {user_fist_name}!\n"
+"This is the example of multilanguage bot.\n"
+"Available commands:\n"
+"\n"
+"/lang - change your language\n"
+"/plural - pluralization example\n"
+"/menu - text menu example"
+msgstr ""
+
+#: main.py:121
+msgid "Language has been changed"
+msgstr ""
+
+#: main.py:130 main.py:150
+#, fuzzy
+msgid "You have {number} click"
+msgid_plural "You have {number} clicks"
+msgstr[0] ""
+msgstr[1] ""
+
+#: main.py:135 main.py:155
+msgid ""
+"This is clicker.\n"
+"\n"
+msgstr ""
+
+#: main.py:163
+msgid "This is ReplyKeyboardMarkup menu example in multilanguage bot."
+msgstr ""
+
+#: main.py:203
+msgid "Seems you confused language"
+msgstr ""
+
+#~ msgid ""
+#~ "Hello, {user_fist_name}!\n"
+#~ "This is the example of multilanguage bot.\n"
+#~ "Available commands:\n"
+#~ "\n"
+#~ "/lang - change your language\n"
+#~ "/plural - pluralization example"
+#~ msgstr ""
+

examples/asynchronous_telebot/middleware/i18n_middleware_example/locales/ru/LC_MESSAGES/messages.po

@@ -0,0 +1,82 @@
+# Russian translations for PROJECT.
+# Copyright (C) 2022 ORGANIZATION
+# This file is distributed under the same license as the PROJECT project.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
+"POT-Creation-Date: 2022-02-19 18:37+0500\n"
+"PO-Revision-Date: 2022-02-18 16:22+0500\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: ru\n"
+"Language-Team: ru <LL@li.org>\n"
+"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
+"n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: keyboards.py:20
+msgid "click"
+msgstr "Клик"
+
+#: keyboards.py:29
+msgid "My user id"
+msgstr "Мой user id"
+
+#: keyboards.py:30
+msgid "My user name"
+msgstr "Мой user name"
+
+#: keyboards.py:31
+msgid "My first name"
+msgstr "Мой first name"
+
+#: main.py:97
+msgid ""
+"Hello, {user_fist_name}!\n"
+"This is the example of multilanguage bot.\n"
+"Available commands:\n"
+"\n"
+"/lang - change your language\n"
+"/plural - pluralization example\n"
+"/menu - text menu example"
+msgstr ""
+"Привет, {user_fist_name}!\n"
+"Это пример мультиязычного бота.\n"
+"Доступные команды:\n"
+"\n"
+"/lang - изменить язык\n"
+"/plural - пример плюрализации\n"
+"/menu - Пример текстового меню"
+
+#: main.py:121
+msgid "Language has been changed"
+msgstr "Язык был сменён"
+
+#: main.py:130 main.py:150
+msgid "You have {number} click"
+msgid_plural "You have {number} clicks"
+msgstr[0] "У вас {number} клик"
+msgstr[1] "У вас {number} клика"
+msgstr[2] "У вас {number} кликов"
+
+#: main.py:135 main.py:155
+msgid ""
+"This is clicker.\n"
+"\n"
+msgstr ""
+"Это кликер.\n"
+"\n"
+
+#: main.py:163
+msgid "This is ReplyKeyboardMarkup menu example in multilanguage bot."
+msgstr "Это пример ReplyKeyboardMarkup меню в мультиязычном боте."
+
+#: main.py:203
+msgid "Seems you confused language"
+msgstr "Кажется, вы перепутали язык"
+

examples/asynchronous_telebot/middleware/i18n_middleware_example/locales/uz_Latn/LC_MESSAGES/messages.po

@@ -0,0 +1,80 @@
+# Uzbek (Latin) translations for PROJECT.
+# Copyright (C) 2022 ORGANIZATION
+# This file is distributed under the same license as the PROJECT project.
+# FIRST AUTHOR <EMAIL@ADDRESS>, 2022.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: PROJECT VERSION\n"
+"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
+"POT-Creation-Date: 2022-02-19 18:37+0500\n"
+"PO-Revision-Date: 2022-02-18 16:22+0500\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language: uz_Latn\n"
+"Language-Team: uz_Latn <LL@li.org>\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=utf-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Generated-By: Babel 2.9.1\n"
+
+#: keyboards.py:20
+msgid "click"
+msgstr "clik"
+
+#: keyboards.py:29
+msgid "My user id"
+msgstr "Mani user id"
+
+#: keyboards.py:30
+msgid "My user name"
+msgstr "Mani user name"
+
+#: keyboards.py:31
+msgid "My first name"
+msgstr "Mani first name"
+
+#: main.py:97
+msgid ""
+"Hello, {user_fist_name}!\n"
+"This is the example of multilanguage bot.\n"
+"Available commands:\n"
+"\n"
+"/lang - change your language\n"
+"/plural - pluralization example\n"
+"/menu - text menu example"
+msgstr ""
+"Salom, {user_fist_name}!\n"
+"Bu multilanguage bot misoli.\n"
+"Mavjud buyruqlar:\n"
+"\n"
+"/lang - tilni ozgartirish\n"
+"/plural - pluralizatsiya misoli\n"
+"/menu - text menu misoli"
+
+#: main.py:121
+msgid "Language has been changed"
+msgstr "Til ozgartirildi"
+
+#: main.py:130 main.py:150
+msgid "You have {number} click"
+msgid_plural "You have {number} clicks"
+msgstr[0] "Sizda {number}ta clik"
+msgstr[1] "Sizda {number}ta clik"
+
+#: main.py:135 main.py:155
+msgid ""
+"This is clicker.\n"
+"\n"
+msgstr ""
+"Bu clicker.\n"
+"\n"
+
+#: main.py:163
+msgid "This is ReplyKeyboardMarkup menu example in multilanguage bot."
+msgstr "Bu multilanguage bot da replykeyboardmarkup menyu misoli."
+
+#: main.py:203
+msgid "Seems you confused language"
+msgstr "Tilni adashtirdiz"
+

examples/asynchronous_telebot/middleware/i18n_middleware_example/main.py

@@ -0,0 +1,214 @@
+"""
+In this example you will learn how to adapt your bot to different languages
+Using built-in middleware I18N.
+
+You need to install babel package 'https://pypi.org/project/Babel/'
+Babel provides a command-line interface for working with message catalogs
+After installing babel package you have a script called 'pybabel'
+Too see all the commands open terminal and type 'pybabel --help'
+Full description for pybabel commands can be found here: 'https://babel.pocoo.org/en/latest/cmdline.html'
+
+Create a directory 'locales' where our translations will be stored
+
+First we need to extract texts:
+    pybabel extract -o locales/{domain_name}.pot --input-dirs .
+{domain_name}.pot - is the file where all translations are saved
+The name of this file should be the same as domain which you pass to I18N class
+In this example domain_name will be 'messages'
+
+For gettext (singular texts) we use '_' alias and it works perfect
+You may also you some alias for ngettext (plural texts) but you can face with a problem that
+your plural texts are not being extracted
+That is because by default 'pybabel extract' recognizes the following keywords:
+ _, gettext, ngettext, ugettext, ungettext, dgettext, dngettext, N_
+To add your own keyword you can use '-k' flag
+In this example for 'ngettext' i will assign double underscore alias '__'
+
+Full command with pluralization support will look so:
+    pybabel extract -o locales/{domain_name}.pot -k __:1,2 --input-dirs .
+
+Then create directories with translations (get list of all locales: 'pybabel --list-locales'):
+    pybabel init -i locales/{domain_name}.pot -d locales -l en
+    pybabel init -i locales/{domain_name}.pot -d locales -l ru
+    pybabel init -i locales/{domain_name}.pot -d locales -l uz_Latn
+
+Now you can translate the texts located in locales/{language}/LC_MESSAGES/{domain_name}.po
+After you translated all the texts you need to compile .po files:
+    pybabel compile -d locales
+
+When you delete/update your texts you also need to update them in .po files:
+    pybabel extract -o locales/{domain_name}.pot -k __:1,2 --input-dirs .
+    pybabel update -i locales/{domain_name}.pot -d locales
+    - translate
+    pybabel compile -d locales
+
+If you have any exceptions check:
+    - you have installed babel
+    - translations are ready, so you just compiled it
+    - in the commands above you replaced {domain_name} to messages
+    - you are writing commands from correct path in terminal
+"""
+
+import asyncio
+from typing import Union
+
+import keyboards
+from telebot import types
+from telebot.async_telebot import AsyncTeleBot
+from telebot.asyncio_filters import TextMatchFilter, TextFilter
+from i18n_base_middleware import I18N
+from telebot.asyncio_storage.memory_storage import StateMemoryStorage
+
+
+class I18NMiddleware(I18N):
+
+    def process_update_types(self) -> list:
+        """
+        Here you need to return a list of update types which you want to be processed
+        """
+        return ['message', 'callback_query']
+
+    async def get_user_language(self, obj: Union[types.Message, types.CallbackQuery]):
+        """
+        This method is called when new update comes (only updates which you return in 'process_update_types' method)
+        Returned language will be used in 'pre_process' method of parent class
+        Returned language will be set to context language variable.
+        If you need to get translation with user's actual language you don't have to pass it manually
+        It will be automatically passed from context language value.
+        However if you need some other language you can always pass it.
+        """
+
+        user_id = obj.from_user.id
+
+        if user_id not in users_lang:
+            users_lang[user_id] = 'en'
+
+        return users_lang[user_id]
+
+
+storage = StateMemoryStorage()
+bot = AsyncTeleBot("", state_storage=storage)
+
+i18n = I18NMiddleware(translations_path='locales', domain_name='messages')
+_ = i18n.gettext  # for singular translations
+__ = i18n.ngettext  # for plural translations
+
+# These are example storages, do not use it in a production development
+users_lang = {}
+users_clicks = {}
+
+
+@bot.message_handler(commands='start')
+async def start_handler(message: types.Message):
+    text = _("Hello, {user_fist_name}!\n"
+             "This is the example of multilanguage bot.\n"
+             "Available commands:\n\n"
+             "/lang - change your language\n"
+             "/plural - pluralization example\n"
+             "/menu - text menu example")
+
+    # remember don't use f string for interpolation, use .format method instead
+    text = text.format(user_fist_name=message.from_user.first_name)
+    await bot.send_message(message.from_user.id, text)
+
+
+@bot.message_handler(commands='lang')
+async def change_language_handler(message: types.Message):
+    await bot.send_message(message.chat.id, "Choose language\nВыберите язык\nTilni tanlang",
+                           reply_markup=keyboards.languages_keyboard())
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(contains=['en', 'ru', 'uz_Latn']))
+async def language_handler(call: types.CallbackQuery):
+    lang = call.data
+    users_lang[call.from_user.id] = lang
+
+    # When you changed user language, you have to pass it manually beacause it is not changed in context
+    await bot.edit_message_text(_("Language has been changed", lang=lang), call.from_user.id, call.message.id)
+
+
+@bot.message_handler(commands='plural')
+async def pluralization_handler(message: types.Message):
+    if not users_clicks.get(message.from_user.id):
+        users_clicks[message.from_user.id] = 0
+    clicks = users_clicks[message.from_user.id]
+
+    text = __(
+        singular="You have {number} click",
+        plural="You have {number} clicks",
+        n=clicks
+    )
+    text = _("This is clicker.\n\n") + text.format(number=clicks)
+
+    await bot.send_message(message.chat.id, text, reply_markup=keyboards.clicker_keyboard(_))
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(equals='click'))
+async def click_handler(call: types.CallbackQuery):
+    if not users_clicks.get(call.from_user.id):
+        users_clicks[call.from_user.id] = 1
+    else:
+        users_clicks[call.from_user.id] += 1
+
+    clicks = users_clicks[call.from_user.id]
+
+    text = __(
+        singular="You have {number} click",
+        plural="You have {number} clicks",
+        n=clicks
+    )
+    text = _("This is clicker.\n\n") + text.format(number=clicks)
+
+    await bot.edit_message_text(text, call.from_user.id, call.message.message_id,
+                                reply_markup=keyboards.clicker_keyboard(_))
+
+
+@bot.message_handler(commands='menu')
+async def menu_handler(message: types.Message):
+    text = _("This is ReplyKeyboardMarkup menu example in multilanguage bot.")
+    await bot.send_message(message.chat.id, text, reply_markup=keyboards.menu_keyboard(_))
+
+
+# For lazy tranlations
+# lazy gettext is used when you don't know user's locale
+# It can be used for example to handle text buttons in multilanguage bot
+# The actual translation will be delayed until update comes and context language is set
+l_ = i18n.lazy_gettext
+
+
+# Handlers below will handle text according to user's language
+@bot.message_handler(text=l_("My user id"))
+async def return_user_id(message: types.Message):
+    await bot.send_message(message.chat.id, str(message.from_user.id))
+
+
+@bot.message_handler(text=l_("My user name"))
+async def return_user_id(message: types.Message):
+    username = message.from_user.username
+    if not username:
+        username = '-'
+    await bot.send_message(message.chat.id, username)
+
+
+# You can make it case insensitive
+@bot.message_handler(text=TextFilter(equals=l_("My first name"), ignore_case=True))
+async def return_user_id(message: types.Message):
+    await bot.send_message(message.chat.id, message.from_user.first_name)
+
+
+all_menu_texts = []
+for language in i18n.available_translations:
+    for menu_text in ("My user id", "My user name", "My first name"):
+        all_menu_texts.append(_(menu_text, language))
+
+
+# When user confused language. (handles all menu buttons texts)
+@bot.message_handler(text=TextFilter(contains=all_menu_texts, ignore_case=True))
+async def missed_message(message: types.Message):
+    await bot.send_message(message.chat.id, _("Seems you confused language"), reply_markup=keyboards.menu_keyboard(_))
+
+
+if __name__ == '__main__':
+    bot.setup_middleware(i18n)
+    bot.add_custom_filter(TextMatchFilter())
+    asyncio.run(bot.infinity_polling())

examples/asynchronous_telebot/multibot/README.MD

@@ -0,0 +1,17 @@
+You probably have seen bots which allow you to send them token of your bot and then handle updates providing some functionality for your bot.
+<br>
+This type of bots are called <b>multibots</b>. They are created using webhooks.
+<br>
+
+This is the example of simple multibot.<br>
+In order to reproduce this example you need to have <b>domain and ssl connection</b>.
+<br>
+If you have, go to config.py and specify your data.
+<br>
+There is also file called <b>nginx_conf.conf</b>,  we will use nginx as proxy-server and this file is example nginx.conf file.
+<br>
+Make sure that server_name and port are the same in both config and nginx_conf
+<br>
+(nginx_conf.conf IS NOT complete, you would probably use tools like certbot to add ssl connection to it)
+<br>
+Also, in this example I used dictionary as tokens storage, but in production you should use database so that you can re-set webhooks in case bot restarts.

examples/asynchronous_telebot/multibot/config.py

@@ -0,0 +1,6 @@
+MAIN_BOT_TOKEN = "your_main_bot_token"
+
+WEBHOOK_HOST = "your_domain.com"
+WEBHOOK_PATH = "telegram_webhook"
+WEBAPP_HOST = "0.0.0.0"
+WEBAPP_PORT = 3500

examples/asynchronous_telebot/multibot/handlers.py

@@ -0,0 +1,15 @@
+from telebot.async_telebot import AsyncTeleBot
+from telebot import types
+
+
+async def hello_handler(message: types.Message, bot: AsyncTeleBot):
+    await bot.send_message(message.chat.id, "Hi :)")
+
+
+async def echo_handler(message: types.Message, bot: AsyncTeleBot):
+    await bot.send_message(message.chat.id, message.text)
+
+
+def register_handlers(bot: AsyncTeleBot):
+    bot.register_message_handler(hello_handler, func=lambda message: message.text == 'Hello', pass_bot=True)
+    bot.register_message_handler(echo_handler, pass_bot=True)

examples/asynchronous_telebot/multibot/main.py

@@ -0,0 +1,56 @@
+import asyncio
+
+from aiohttp import web
+from telebot import types, util
+from telebot.async_telebot import AsyncTeleBot
+from handlers import register_handlers
+
+import config
+
+main_bot = AsyncTeleBot(config.MAIN_BOT_TOKEN)
+app = web.Application()
+tokens = {config.MAIN_BOT_TOKEN: True}
+
+
+async def webhook(request):
+    token = request.match_info.get('token')
+    if not tokens.get(token):
+        return web.Response(status=404)
+
+    if request.headers.get('content-type') != 'application/json':
+        return web.Response(status=403)
+
+    json_string = await request.json()
+    update = types.Update.de_json(json_string)
+    if token == main_bot.token:
+        await main_bot.process_new_updates([update])
+        return web.Response()
+
+    from_update_bot = AsyncTeleBot(token)
+    register_handlers(from_update_bot)
+    await from_update_bot.process_new_updates([update])
+    return web.Response()
+
+
+app.router.add_post("/" + config.WEBHOOK_PATH + "/{token}", webhook)
+
+
+@main_bot.message_handler(commands=['add_bot'])
+async def add_bot(message: types.Message):
+    token = util.extract_arguments(message.text)
+    tokens[token] = True
+
+    new_bot = AsyncTeleBot(token)
+    await new_bot.delete_webhook()
+    await new_bot.set_webhook(f"{config.WEBHOOK_HOST}/{config.WEBHOOK_PATH}/{token}")
+
+    await new_bot.send_message(message.chat.id, "Webhook was set.")
+
+
+async def main():
+    await main_bot.delete_webhook()
+    await main_bot.set_webhook(f"{config.WEBHOOK_HOST}/{config.WEBHOOK_PATH}/{config.MAIN_BOT_TOKEN}")
+    web.run_app(app, host=config.WEBAPP_HOST, port=config.WEBAPP_PORT)
+
+if __name__ == '__main__':
+    asyncio.run(main())

examples/asynchronous_telebot/multibot/nginx_conf.conf

@@ -0,0 +1,8 @@
+server {
+    server_name your_domain.com;
+
+    location /telegram_webhook/ {
+        proxy_pass http://localhost:3500;
+    }
+
+}

examples/asynchronous_telebot/register_handler.py

@@ -0,0 +1,20 @@
+from telebot.async_telebot import AsyncTeleBot
+bot = AsyncTeleBot('TOKEN')
+
+async def start_executor(message):
+    await bot.send_message(message.chat.id, 'Hello!')
+
+bot.register_message_handler(start_executor, commands=['start']) # Start command executor
+
+# See also
+# bot.register_callback_query_handler(*args, **kwargs)
+# bot.register_channel_post_handler(*args, **kwargs)
+# bot.register_chat_member_handler(*args, **kwargs)
+# bot.register_inline_handler(*args, **kwargs)
+# bot.register_my_chat_member_handler(*args, **kwargs)
+# bot.register_edited_message_handler(*args, **kwargs)
+# And other functions..
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/send_file_example.py

@@ -0,0 +1,29 @@
+
+import telebot
+from telebot.async_telebot import AsyncTeleBot
+
+
+
+bot = AsyncTeleBot('TOKEN')
+
+
+@bot.message_handler(commands=['photo'])
+async def photo_send(message: telebot.types.Message):
+    with open('test.png', 'rb') as new_file:
+        await bot.send_photo(message.chat.id, new_file)
+
+@bot.message_handler(commands=['document'])
+async def document_send(message: telebot.types.Message):
+    with open('test.docx', 'rb') as new_file:
+        await bot.send_document(message.chat.id, new_file)
+
+@bot.message_handler(commands=['photos'])
+async def photos_send(message: telebot.types.Message):
+    with open('test.png', 'rb') as new_file, open('test2.png', 'rb') as new_file2:
+        await bot.send_media_group(message.chat.id, [telebot.types.InputMediaPhoto(new_file), telebot.types.InputMediaPhoto(new_file2)])
+    
+
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/set_command_example.py

@@ -0,0 +1,35 @@
+#!/usr/bin/python
+
+# This is a set_my_commands example.
+# Press on [/] button in telegram client.
+# Important, to update the command menu, be sure to exit the chat with the bot and log in again
+# Important, command for chat_id and for group have a higher priority than for all
+
+import asyncio
+import telebot
+from telebot.async_telebot import AsyncTeleBot
+
+
+API_TOKEN = '<api_token>'
+bot = AsyncTeleBot(API_TOKEN)
+
+
+async def main():
+    # use in for delete with the necessary scope and language_code if necessary
+    await bot.delete_my_commands(scope=None, language_code=None)
+
+    await bot.set_my_commands(
+        commands=[
+            telebot.types.BotCommand("command1", "command1 description"),
+            telebot.types.BotCommand("command2", "command2 description")
+        ],
+        # scope=telebot.types.BotCommandScopeChat(12345678)  # use for personal command menu for users
+        # scope=telebot.types.BotCommandScopeAllPrivateChats()  # use for all private chats
+    )
+    
+    cmd = await bot.get_my_commands(scope=None, language_code=None)
+    print([c.to_json() for c in cmd])
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

examples/asynchronous_telebot/skip_updates_example.py

@@ -0,0 +1,15 @@
+from telebot.async_telebot import AsyncTeleBot
+
+bot = AsyncTeleBot('TOKEN')
+
+@bot.message_handler(commands=['start', 'help'])
+async def send_welcome(message):
+	await bot.reply_to(message, "Howdy, how are you doing?")
+
+@bot.message_handler(func=lambda message: True)
+async def echo_all(message):
+	await bot.reply_to(message, message.text)
+
+
+import asyncio
+asyncio.run(bot.polling(skip_pending=True)) # to skip updates

examples/asynchronous_telebot/timer_bot_async.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python3
+
+# This is a simple bot with schedule timer 
+# https://github.com/ibrb/python-aioschedule
+# https://schedule.readthedocs.io
+
+import asyncio
+import aioschedule
+from telebot.async_telebot import AsyncTeleBot
+
+API_TOKEN = '<api_token>'
+bot = AsyncTeleBot(API_TOKEN)
+
+
+async def beep(chat_id) -> None:
+    """Send the beep message."""
+    await bot.send_message(chat_id, text='Beep!')
+    aioschedule.clear(chat_id)  # return schedule.CancelJob not working in aioschedule use tag for delete
+
+
+@bot.message_handler(commands=['help', 'start'])
+async def send_welcome(message):
+    await bot.reply_to(message, "Hi! Use /set <seconds> to set a timer")
+
+
+@bot.message_handler(commands=['set'])
+async def set_timer(message):
+    args = message.text.split()
+    if len(args) > 1 and args[1].isdigit():
+        sec = int(args[1])
+        aioschedule.every(sec).seconds.do(beep, message.chat.id).tag(message.chat.id)
+    else:
+        await bot.reply_to(message, 'Usage: /set <seconds>')
+
+
+@bot.message_handler(commands=['unset'])
+def unset_timer(message):
+    aioschedule.clean(message.chat.id)
+
+
+async def scheduler():
+    while True:
+        await aioschedule.run_pending()
+        await asyncio.sleep(1)
+
+
+async def main():
+    await asyncio.gather(bot.infinity_polling(), scheduler())
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

examples/asynchronous_telebot/update_listener.py

@@ -0,0 +1,16 @@
+from telebot.async_telebot import AsyncTeleBot
+
+# Update listeners are functions that are called when any update is received.
+
+bot = AsyncTeleBot(token='TOKEN')
+
+async def update_listener(messages):
+    for message in messages:
+        if message.text == '/start':
+            await bot.send_message(message.chat.id, 'Hello!')
+
+bot.set_update_listener(update_listener)
+
+
+import asyncio
+asyncio.run(bot.polling())

examples/asynchronous_telebot/webhooks/async_webhook_aiohttp_echo_bot.py

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

examples/asynchronous_telebot/webhooks/run_webhooks.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python
+
+# This is a simple echo bot using the decorator mechanism.
+# It echoes any incoming text messages.
+# Example on built-in function to receive and process webhooks.
+
+from telebot.async_telebot import AsyncTeleBot
+import asyncio
+bot = AsyncTeleBot('TOKEN')
+
+
+WEBHOOK_SSL_CERT = './webhook_cert.pem'  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = './webhook_pkey.pem'  # Path to the ssl private key
+DOMAIN = '1.2.3.4' # either domain, or ip address of vps
+
+# Quick'n'dirty SSL certificate generation:
+#
+# openssl genrsa -out webhook_pkey.pem 2048
+# openssl req -new -x509 -days 3650 -key webhook_pkey.pem -out webhook_cert.pem
+#
+# When asked for "Common Name (e.g. server FQDN or YOUR name)" you should reply
+# with the same value in you put in WEBHOOK_HOST
+
+
+# Handle '/start' and '/help'
+@bot.message_handler(commands=['help', 'start'])
+async def send_welcome(message):
+    await bot.reply_to(message, """\
+Hi there, I am EchoBot.
+I am here to echo your kind words back to you. Just say anything nice and I'll say the exact same thing to you!\
+""")
+
+
+# Handle all other messages with content_type 'text' (content_types defaults to ['text'])
+@bot.message_handler(func=lambda message: True)
+async def echo_message(message):
+    await bot.reply_to(message, message.text)
+
+
+# it uses fastapi + uvicorn
+asyncio.run(bot.run_webhooks(
+    listen=DOMAIN,
+    certificate=WEBHOOK_SSL_CERT,
+    certificate_key=WEBHOOK_SSL_PRIV
+))

examples/asynchronous_telebot/webhooks/webhook_starlette_echo_bot.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+"""
+Asynchronous Telegram Echo Bot example.
+
+This is a simple bot that echoes each message that is received onto the chat.
+It uses the Starlette ASGI framework to receive updates via webhook requests.
+"""
+
+import uvicorn
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, Response
+from starlette.routing import Route
+from telebot.async_telebot import AsyncTeleBot
+from telebot.types import Message, Update
+
+API_TOKEN = "TOKEN"
+
+WEBHOOK_HOST = "<ip/domain>"
+WEBHOOK_PORT = 8443  # 443, 80, 88 or 8443 (port need to be 'open')
+WEBHOOK_LISTEN = "0.0.0.0"
+WEBHOOK_SSL_CERT = "./webhook_cert.pem"  # Path to the ssl certificate
+WEBHOOK_SSL_PRIV = "./webhook_pkey.pem"  # Path to the ssl private key
+WEBHOOK_URL = f"https://{WEBHOOK_HOST}:{WEBHOOK_PORT}/telegram"
+WEBHOOK_SECRET_TOKEN = "SECRET_TOKEN"
+
+logger = telebot.logger
+telebot.logger.setLevel(logging.INFO)
+
+bot = AsyncTeleBot(token=API_TOKEN)
+
+# BOT HANDLERS
+@bot.message_handler(commands=["help", "start"])
+async def send_welcome(message: Message):
+    """
+    Handle '/start' and '/help'
+    """
+    await bot.reply_to(
+        message,
+        ("Hi there, I am EchoBot.\n" "I am here to echo your kind words back to you."),
+    )
+
+
+@bot.message_handler(func=lambda _: True, content_types=["text"])
+async def echo_message(message: Message):
+    """
+    Handle all other messages
+    """
+    await bot.reply_to(message, message.text)
+
+
+# WEBSERVER HANDLERS
+async def telegram(request: Request) -> Response:
+    """Handle incoming Telegram updates."""
+    token_header_name = "X-Telegram-Bot-Api-Secret-Token"
+    if request.headers.get(token_header_name) != WEBHOOK_SECRET_TOKEN:
+        return PlainTextResponse("Forbidden", status_code=403)
+    await bot.process_new_updates([Update.de_json(await request.json())])
+    return Response()
+
+
+async def startup() -> None:
+    """Register webhook for telegram updates."""
+    webhook_info = await bot.get_webhook_info(30)
+    if WEBHOOK_URL != webhook_info.url:
+        logger.debug(
+            f"updating webhook url, old: {webhook_info.url}, new: {WEBHOOK_URL}"
+        )
+        if not await bot.set_webhook(
+            url=WEBHOOK_URL, secret_token=WEBHOOK_SECRET_TOKEN
+        ):
+            raise RuntimeError("unable to set webhook")
+
+
+app = Starlette(
+    routes=[
+        Route("/telegram", telegram, methods=["POST"]),
+    ],
+    on_startup=[startup],
+)
+
+
+uvicorn.run(
+    app,
+    host=WEBHOOK_HOST,
+    port=WEBHOOK_LISTEN,
+    ssl_certfile=WEBHOOK_SSL_CERT,
+    ssl_keyfile=WEBHOOK_SSL_PRIV,
+)

examples/callback_data_examples/advanced_calendar_example/filters.py

@@ -0,0 +1,25 @@
+import telebot
+from telebot import types, AdvancedCustomFilter
+from telebot.callback_data import CallbackData, CallbackDataFilter
+
+calendar_factory = CallbackData("year", "month", prefix="calendar")
+calendar_zoom = CallbackData("year", prefix="calendar_zoom")
+
+
+class CalendarCallbackFilter(AdvancedCustomFilter):
+    key = 'calendar_config'
+
+    def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+class CalendarZoomCallbackFilter(AdvancedCustomFilter):
+    key = 'calendar_zoom_config'
+
+    def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+def bind_filters(bot: telebot.TeleBot):
+    bot.add_custom_filter(CalendarCallbackFilter())
+    bot.add_custom_filter(CalendarZoomCallbackFilter())

examples/callback_data_examples/advanced_calendar_example/keyboards.py

@@ -0,0 +1,92 @@
+import calendar
+from datetime import date, timedelta
+
+from examples.callback_data_examples.advanced_calendar_example.filters import calendar_factory, calendar_zoom
+from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton
+
+EMTPY_FIELD = '1'
+WEEK_DAYS = [calendar.day_abbr[i] for i in range(7)]
+MONTHS = [(i, calendar.month_name[i]) for i in range(1, 13)]
+
+
+def generate_calendar_days(year: int, month: int):
+    keyboard = InlineKeyboardMarkup(row_width=7)
+    today = date.today()
+
+    keyboard.add(
+        InlineKeyboardButton(
+            text=date(year=year, month=month, day=1).strftime('%b %Y'),
+            callback_data=EMTPY_FIELD
+        )
+    )
+    keyboard.add(*[
+        InlineKeyboardButton(
+            text=day,
+            callback_data=EMTPY_FIELD
+        )
+        for day in WEEK_DAYS
+    ])
+
+    for week in calendar.Calendar().monthdayscalendar(year=year, month=month):
+        week_buttons = []
+        for day in week:
+            day_name = ' '
+            if day == today.day and today.year == year and today.month == month:
+                day_name = '🔘'
+            elif day != 0:
+                day_name = str(day)
+            week_buttons.append(
+                InlineKeyboardButton(
+                    text=day_name,
+                    callback_data=EMTPY_FIELD
+                )
+            )
+        keyboard.add(*week_buttons)
+
+    previous_date = date(year=year, month=month, day=1) - timedelta(days=1)
+    next_date = date(year=year, month=month, day=1) + timedelta(days=31)
+
+    keyboard.add(
+        InlineKeyboardButton(
+            text='Previous month',
+            callback_data=calendar_factory.new(year=previous_date.year, month=previous_date.month)
+        ),
+        InlineKeyboardButton(
+            text='Zoom out',
+            callback_data=calendar_zoom.new(year=year)
+        ),
+        InlineKeyboardButton(
+            text='Next month',
+            callback_data=calendar_factory.new(year=next_date.year, month=next_date.month)
+        ),
+    )
+
+    return keyboard
+
+
+def generate_calendar_months(year: int):
+    keyboard = InlineKeyboardMarkup(row_width=3)
+    keyboard.add(
+        InlineKeyboardButton(
+            text=date(year=year, month=1, day=1).strftime('Year %Y'),
+            callback_data=EMTPY_FIELD
+        )
+    )
+    keyboard.add(*[
+        InlineKeyboardButton(
+            text=month,
+            callback_data=calendar_factory.new(year=year, month=month_number)
+        )
+        for month_number, month in MONTHS
+    ])
+    keyboard.add(
+        InlineKeyboardButton(
+            text='Previous year',
+            callback_data=calendar_zoom.new(year=year - 1)
+        ),
+        InlineKeyboardButton(
+            text='Next year',
+            callback_data=calendar_zoom.new(year=year + 1)
+        )
+    )
+    return keyboard

examples/callback_data_examples/advanced_calendar_example/main.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you an advanced usage of CallbackData.
+In this example calendar was implemented
+"""
+
+from datetime import date
+
+from examples.callback_data_examples.advanced_calendar_example.keyboards import generate_calendar_days, \
+    generate_calendar_months, EMTPY_FIELD
+from filters import calendar_factory, calendar_zoom, bind_filters
+from telebot import types, TeleBot
+
+API_TOKEN = ''
+bot = TeleBot(API_TOKEN)
+
+
+@bot.message_handler(commands='start')
+def start_command_handler(message: types.Message):
+    bot.send_message(message.chat.id,
+                     f"Hello {message.from_user.first_name}. This bot is an example of calendar keyboard."
+                     "\nPress /calendar to see it.")
+
+
+@bot.message_handler(commands='calendar')
+def calendar_command_handler(message: types.Message):
+    now = date.today()
+    bot.send_message(message.chat.id, 'Calendar', reply_markup=generate_calendar_days(year=now.year, month=now.month))
+
+
+@bot.callback_query_handler(func=None, calendar_config=calendar_factory.filter())
+def calendar_action_handler(call: types.CallbackQuery):
+    callback_data: dict = calendar_factory.parse(callback_data=call.data)
+    year, month = int(callback_data['year']), int(callback_data['month'])
+
+    bot.edit_message_reply_markup(call.message.chat.id, call.message.id,
+                                  reply_markup=generate_calendar_days(year=year, month=month))
+
+
+@bot.callback_query_handler(func=None, calendar_zoom_config=calendar_zoom.filter())
+def calendar_zoom_out_handler(call: types.CallbackQuery):
+    callback_data: dict = calendar_zoom.parse(callback_data=call.data)
+    year = int(callback_data.get('year'))
+
+    bot.edit_message_reply_markup(call.message.chat.id, call.message.id,
+                                  reply_markup=generate_calendar_months(year=year))
+
+
+@bot.callback_query_handler(func=lambda call: call.data == EMTPY_FIELD)
+def callback_empty_field_handler(call: types.CallbackQuery):
+    bot.answer_callback_query(call.id)
+
+
+if __name__ == '__main__':
+    bind_filters(bot)
+    bot.infinity_polling()

examples/callback_data_examples/simple_products_example.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you how to use CallbackData
+"""
+
+from telebot.callback_data import CallbackData, CallbackDataFilter
+from telebot import types, TeleBot
+from telebot.custom_filters import AdvancedCustomFilter
+
+API_TOKEN = ''
+PRODUCTS = [
+    {'id': '0', 'name': 'xiaomi mi 10', 'price': 400},
+    {'id': '1', 'name': 'samsung s20', 'price': 800},
+    {'id': '2', 'name': 'iphone 13', 'price': 1300}
+]
+
+bot = TeleBot(API_TOKEN)
+products_factory = CallbackData('product_id', prefix='products')
+
+
+def products_keyboard():
+    return types.InlineKeyboardMarkup(
+        keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text=product['name'],
+                    callback_data=products_factory.new(product_id=product["id"])
+                )
+            ]
+            for product in PRODUCTS
+        ]
+    )
+
+
+def back_keyboard():
+    return types.InlineKeyboardMarkup(
+        keyboard=[
+            [
+                types.InlineKeyboardButton(
+                    text='⬅',
+                    callback_data='back'
+                )
+            ]
+        ]
+    )
+
+
+class ProductsCallbackFilter(AdvancedCustomFilter):
+    key = 'config'
+
+    def check(self, call: types.CallbackQuery, config: CallbackDataFilter):
+        return config.check(query=call)
+
+
+@bot.message_handler(commands=['products'])
+def products_command_handler(message: types.Message):
+    bot.send_message(message.chat.id, 'Products:', reply_markup=products_keyboard())
+
+
+# Only product with field - product_id = 2
+@bot.callback_query_handler(func=None, config=products_factory.filter(product_id='2'))
+def product_one_callback(call: types.CallbackQuery):
+    bot.answer_callback_query(callback_query_id=call.id, text='Not available :(', show_alert=True)
+
+
+# Any other products
+@bot.callback_query_handler(func=None, config=products_factory.filter())
+def products_callback(call: types.CallbackQuery):
+    callback_data: dict = products_factory.parse(callback_data=call.data)
+    product_id = int(callback_data['product_id'])
+    product = PRODUCTS[product_id]
+
+    text = f"Product name: {product['name']}\n" \
+           f"Product price: {product['price']}"
+    bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
+                          text=text, reply_markup=back_keyboard())
+
+
+@bot.callback_query_handler(func=lambda c: c.data == 'back')
+def back_callback(call: types.CallbackQuery):
+    bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id,
+                          text='Products:', reply_markup=products_keyboard())
+
+
+bot.add_custom_filter(ProductsCallbackFilter())
+bot.infinity_polling()

examples/chat_join_request.py

@@ -0,0 +1,11 @@
+import telebot
+
+
+bot = telebot.TeleBot('TOKEN')
+
+@bot.chat_join_request_handler()
+def make_some(message: telebot.types.ChatJoinRequest):
+    bot.send_message(message.chat.id, 'I accepted a new user!')
+    bot.approve_chat_join_request(message.chat.id, message.from_user.id)
+
+bot.infinity_polling(allowed_updates=telebot.util.update_types)

examples/chat_member_example.py

@@ -0,0 +1,33 @@
+import telebot
+from telebot import types,util
+
+bot = telebot.TeleBot("token")
+
+#chat_member_handler. When status changes, telegram gives update. check status from old_chat_member and new_chat_member.
+@bot.chat_member_handler()
+def chat_m(message: types.ChatMemberUpdated):
+    old = message.old_chat_member
+    new = message.new_chat_member
+    if new.status == "member":
+        bot.send_message(message.chat.id,"Hello {name}!".format(name=new.user.first_name)) # Welcome message
+
+#if bot is added to group, this handler will work
+@bot.my_chat_member_handler()
+def my_chat_m(message: types.ChatMemberUpdated):
+    old = message.old_chat_member
+    new = message.new_chat_member
+    if new.status == "member":
+        bot.send_message(message.chat.id,"Somebody added me to group") # Welcome message, if bot was added to group
+        bot.leave_chat(message.chat.id)
+
+#content_Type_service is:
+#'new_chat_members', 'left_chat_member', 'new_chat_title', 'new_chat_photo', 'delete_chat_photo', 'group_chat_created',
+#'supergroup_chat_created', 'channel_chat_created', 'migrate_to_chat_id', 'migrate_from_chat_id', 'pinned_message',
+#'proximity_alert_triggered', 'video_chat_scheduled', 'video_chat_started', 'video_chat_ended',
+#'video_chat_participants_invited', 'message_auto_delete_timer_changed'
+# this handler deletes service messages
+
+@bot.message_handler(content_types=util.content_type_service)
+def delall(message: types.Message):
+    bot.delete_message(message.chat.id,message.message_id)
+bot.infinity_polling(allowed_updates=util.update_types)

examples/continue_handling.py

@@ -0,0 +1,23 @@
+from telebot import TeleBot
+from telebot.handler_backends import ContinueHandling
+
+
+bot = TeleBot('TOKEN')
+
+@bot.message_handler(commands=['start'])
+def start(message):
+    bot.send_message(message.chat.id, 'Hello World!')
+    return ContinueHandling()
+
+@bot.message_handler(commands=['start'])
+def start2(message):
+    """
+    This handler comes after the first one, but it will never be called.
+    But you can call it by returning ContinueHandling() in the first handler.
+
+    If you return ContinueHandling() in the first handler, the next 
+    registered handler with appropriate filters will be called.
+    """
+    bot.send_message(message.chat.id, 'Hello World2!')
+
+bot.infinity_polling()

examples/create_invite_link.py

@@ -0,0 +1,33 @@
+import telebot
+from time import sleep, time
+from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton #Only for creating Inline Buttons, not necessary for creating Invite Links
+
+Token = "api_token" #Your Bot Access Token
+Group_ID = -1234567890 #Group ID for which invite link is to be created
+
+bot = telebot.TeleBot(Token, parse_mode="HTML")
+
+#/start command message
+@bot.message_handler(commands=['start'])
+def startmsg(msg):
+    bot.reply_to(msg, "Hey there, I'm a bot made by pyTelegramBotAPI!")
+
+#Get notified of incoming members in group
+@bot.message_handler(content_types=['new_chat_members'])
+def newmember(msg):
+    #Create an invite link class that contains info about the created invite link using create_chat_invite_link() with parameters
+    invite = bot.create_chat_invite_link(Group_ID, member_limit=1, expire_date=int(time())+45) #Here, the link will auto-expire in 45 seconds
+    InviteLink = invite.invite_link #Get the actual invite link from 'invite' class
+    
+    mrkplink = InlineKeyboardMarkup() #Created Inline Keyboard Markup
+    mrkplink.add(InlineKeyboardButton("Join our group 🚀", url=InviteLink)) #Added Invite Link to Inline Keyboard
+    
+    bot.send_message(msg.chat.id, f"Hey there {msg.from_user.first_name}, Click the link below to join our Official Group.", reply_markup=mrkplink)
+    
+    #This will send a message with the newly-created invite link as markup button.
+    #The member limit will be 1 and expiring time will be 45 sec.
+
+
+
+
+bot.infinity_polling()

examples/custom_filters/admin_filter_example.py

@@ -0,0 +1,12 @@
+import telebot
+from telebot import custom_filters
+bot = telebot.TeleBot('TOKEN')
+
+# Handler
+@bot.message_handler(chat_types=['supergroup'], is_chat_admin=True)
+def answer_for_admin(message):
+    bot.send_message(message.chat.id,"hello my admin")
+
+# Register filter
+bot.add_custom_filter(custom_filters.IsAdminFilter(bot))
+bot.infinity_polling()

examples/custom_filters/advanced_text_filter.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+"""
+This Example will show you usage of TextFilter
+In this example you will see how to use TextFilter
+with (message_handler, callback_query_handler, poll_handler)
+"""
+
+from telebot import TeleBot, types
+from telebot.custom_filters import TextFilter, TextMatchFilter, IsReplyFilter
+
+bot = TeleBot("")
+
+
+@bot.message_handler(text=TextFilter(equals='hello'))
+def hello_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(equals='hello', ignore_case=True))
+def hello_handler_ignore_case(message: types.Message):
+    bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(contains=['good', 'bad']))
+def contains_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(contains=['good', 'bad'], ignore_case=True))
+def contains_handler_ignore_case(message: types.Message):
+    bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(starts_with='st'))  # stArk, steve, stONE
+def starts_with_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(starts_with='st', ignore_case=True))  # STark, sTeve, stONE
+def starts_with_handler_ignore_case(message: types.Message):
+    bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(ends_with='ay'))  # wednesday, SUNday, WeekDay
+def ends_with_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+@bot.message_handler(text=TextFilter(ends_with='ay', ignore_case=True))  # wednesdAY, sundAy, WeekdaY
+def ends_with_handler_ignore_case(message: types.Message):
+    bot.send_message(message.chat.id, message.text + ' ignore case')
+
+
+@bot.message_handler(text=TextFilter(equals='/callback'))
+def send_callback(message: types.Message):
+    keyboard = types.InlineKeyboardMarkup(
+        keyboard=[
+            [types.InlineKeyboardButton(text='callback data', callback_data='example')],
+            [types.InlineKeyboardButton(text='ignore case callback data', callback_data='ExAmPLe')]
+        ]
+    )
+    bot.send_message(message.chat.id, message.text, reply_markup=keyboard)
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(equals='example'))
+def callback_query_handler(call: types.CallbackQuery):
+    bot.answer_callback_query(call.id, call.data, show_alert=True)
+
+
+@bot.callback_query_handler(func=None, text=TextFilter(equals='example', ignore_case=True))
+def callback_query_handler_ignore_case(call: types.CallbackQuery):
+    bot.answer_callback_query(call.id, call.data + " ignore case", show_alert=True)
+
+
+@bot.message_handler(text=TextFilter(equals='/poll'))
+def send_poll(message: types.Message):
+    bot.send_poll(message.chat.id, question='When do you prefer to work?', options=['Morning', 'Night'])
+    bot.send_poll(message.chat.id, question='WHEN DO you pRefeR to worK?', options=['Morning', 'Night'])
+
+
+@bot.poll_handler(func=None, text=TextFilter(equals='When do you prefer to work?'))
+def poll_question_handler(poll: types.Poll):
+    print(poll.question)
+
+
+@bot.poll_handler(func=None, text=TextFilter(equals='When do you prefer to work?', ignore_case=True))
+def poll_question_handler_ignore_case(poll: types.Poll):
+    print(poll.question + ' ignore case')
+
+
+# either hi or contains one of (привет, salom)
+@bot.message_handler(text=TextFilter(equals="hi", contains=('привет', 'salom'), ignore_case=True))
+def multiple_patterns_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+# starts with one of (mi, mea) for ex. minor, milk, meal, meat
+@bot.message_handler(text=TextFilter(starts_with=['mi', 'mea'], ignore_case=True))
+def multiple_starts_with_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+# ends with one of (es, on) for ex. Jones, Davies, Johnson, Wilson
+@bot.message_handler(text=TextFilter(ends_with=['es', 'on'], ignore_case=True))
+def multiple_ends_with_handler(message: types.Message):
+    bot.send_message(message.chat.id, message.text)
+
+
+# !ban /ban .ban !бан /бан .бан
+@bot.message_handler(is_reply=True,
+                     text=TextFilter(starts_with=('!', '/', '.'), ends_with=['ban', 'бан'], ignore_case=True))
+def ban_command_handler(message: types.Message):
+    if len(message.text) == 4 and message.chat.type != 'private':
+        try:
+            bot.ban_chat_member(message.chat.id, message.reply_to_message.from_user.id)
+            bot.reply_to(message.reply_to_message, 'Banned.')
+        except Exception as err:
+            print(err.args)
+            return
+
+
+if __name__ == '__main__':
+    bot.add_custom_filter(TextMatchFilter())
+    bot.add_custom_filter(IsReplyFilter())
+    bot.infinity_polling()

examples/custom_filters/general_custom_filters.py

@@ -0,0 +1,42 @@
+import telebot
+
+bot = telebot.TeleBot('TOKEN')
+
+
+# AdvancedCustomFilter is for list, string filter values
+class MainFilter(telebot.custom_filters.AdvancedCustomFilter):
+    key='text'
+    @staticmethod
+    def check(message, text):
+        return message.text in text
+
+# SimpleCustomFilter is for boolean values, such as is_admin=True
+class IsAdmin(telebot.custom_filters.SimpleCustomFilter):
+    key='is_admin'
+    @staticmethod
+    def check(message: telebot.types.Message):
+        return bot.get_chat_member(message.chat.id,message.from_user.id).status in ['administrator','creator']
+
+
+@bot.message_handler(is_admin=True, commands=['admin']) # Check if user is admin
+def admin_rep(message):
+    bot.send_message(message.chat.id, "Hi admin")
+
+@bot.message_handler(is_admin=False, commands=['admin']) # If user is not admin
+def not_admin(message):
+    bot.send_message(message.chat.id, "You are not admin")
+
+@bot.message_handler(text=['hi']) # Response to hi message
+def welcome_hi(message):
+    bot.send_message(message.chat.id, 'You said hi')
+
+@bot.message_handler(text=['bye']) # Response to bye message
+def bye_user(message):
+    bot.send_message(message.chat.id, 'You said bye')
+
+
+# Do not forget to register filters
+bot.add_custom_filter(MainFilter())
+bot.add_custom_filter(IsAdmin())
+
+bot.infinity_polling(skip_pending=True) # Skip old updates

examples/custom_filters/id_filter_example.py

@@ -0,0 +1,19 @@
+import telebot
+from telebot import custom_filters
+
+bot = telebot.TeleBot('token')
+
+
+# Chat id can be private or supergroups.
+@bot.message_handler(chat_id=[12345678], commands=['admin']) # chat_id checks id corresponds to your list or not.
+def admin_rep(message):
+    bot.send_message(message.chat.id, "You are allowed to use this command.")
+
+@bot.message_handler(commands=['admin'])
+def not_admin(message):
+    bot.send_message(message.chat.id, "You are not allowed to use this command")
+
+# Do not forget to register
+bot.add_custom_filter(custom_filters.ChatFilter())
+
+bot.infinity_polling()

examples/custom_filters/is_filter_example.py

@@ -0,0 +1,21 @@
+import telebot
+from telebot import custom_filters
+
+bot = telebot.TeleBot('TOKEN')
+
+
+# Check if message is a reply
+@bot.message_handler(is_reply=True)
+def start_filter(message):
+    bot.send_message(message.chat.id, "Looks like you replied to my message.")
+
+# Check if message was forwarded
+@bot.message_handler(is_forwarded=True)
+def text_filter(message):
+    bot.send_message(message.chat.id, "I do not accept forwarded messages!")
+
+# Do not forget to register filters
+bot.add_custom_filter(custom_filters.IsReplyFilter())
+bot.add_custom_filter(custom_filters.ForwardFilter())
+
+bot.infinity_polling()

examples/custom_filters/text_filter_example.py

@@ -0,0 +1,21 @@
+import telebot
+from telebot import custom_filters
+
+bot = telebot.TeleBot('TOKEN')
+
+
+# Check if message starts with @admin tag
+@bot.message_handler(text_startswith="@admin")
+def start_filter(message):
+    bot.send_message(message.chat.id, "Looks like you are calling admin, wait...")
+
+# Check if text is hi or hello
+@bot.message_handler(text=['hi','hello'])
+def text_filter(message):
+    bot.send_message(message.chat.id, "Hi, {name}!".format(name=message.from_user.first_name))
+
+# Do not forget to register filters
+bot.add_custom_filter(custom_filters.TextMatchFilter())
+bot.add_custom_filter(custom_filters.TextStartsFilter())
+
+bot.infinity_polling()

examples/custom_states.py

@@ -0,0 +1,106 @@
+import telebot # telebot
+
+from telebot import custom_filters
+from telebot.handler_backends import State, StatesGroup #States
+
+# States storage
+from telebot.storage import StateMemoryStorage
+
+
+# Starting from version 4.4.0+, we support storages.
+# StateRedisStorage -> Redis-based storage.
+# StatePickleStorage -> Pickle-based storage.
+# For redis, you will need to install redis.
+# Pass host, db, password, or anything else,
+# if you need to change config for redis.
+# Pickle requires path. Default path is in folder .state-saves.
+# If you were using older version of pytba for pickle, 
+# you need to migrate from old pickle to new by using
+# StatePickleStorage().convert_old_to_new()
+
+
+
+# Now, you can pass storage to bot.
+state_storage = StateMemoryStorage() # you can init here another storage
+
+bot = telebot.TeleBot("TOKEN",
+state_storage=state_storage)
+
+
+# States group.
+class MyStates(StatesGroup):
+    # Just name variables differently
+    name = State() # creating instances of State class is enough from now
+    surname = State()
+    age = State()
+
+
+
+
+@bot.message_handler(commands=['start'])
+def start_ex(message):
+    """
+    Start command. Here we are starting state
+    """
+    bot.set_state(message.from_user.id, MyStates.name, message.chat.id)
+    bot.send_message(message.chat.id, 'Hi, write me a name')
+ 
+
+# Any state
+@bot.message_handler(state="*", commands=['cancel'])
+def any_state(message):
+    """
+    Cancel state
+    """
+    bot.send_message(message.chat.id, "Your state was cancelled.")
+    bot.delete_state(message.from_user.id, message.chat.id)
+
+@bot.message_handler(state=MyStates.name)
+def name_get(message):
+    """
+    State 1. Will process when user's state is MyStates.name.
+    """
+    bot.send_message(message.chat.id, 'Now write me a surname')
+    bot.set_state(message.from_user.id, MyStates.surname, message.chat.id)
+    with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        data['name'] = message.text
+ 
+ 
+@bot.message_handler(state=MyStates.surname)
+def ask_age(message):
+    """
+    State 2. Will process when user's state is MyStates.surname.
+    """
+    bot.send_message(message.chat.id, "What is your age?")
+    bot.set_state(message.from_user.id, MyStates.age, message.chat.id)
+    with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        data['surname'] = message.text
+ 
+# result
+@bot.message_handler(state=MyStates.age, is_digit=True)
+def ready_for_answer(message):
+    """
+    State 3. Will process when user's state is MyStates.age.
+    """
+    with bot.retrieve_data(message.from_user.id, message.chat.id) as data:
+        msg = ("Ready, take a look:\n<b>"
+               f"Name: {data['name']}\n"
+               f"Surname: {data['surname']}\n"
+               f"Age: {message.text}</b>")
+        bot.send_message(message.chat.id, msg, parse_mode="html")
+    bot.delete_state(message.from_user.id, message.chat.id)
+
+#incorrect number
+@bot.message_handler(state=MyStates.age, is_digit=False)
+def age_incorrect(message):
+    """
+    Wrong response for MyStates.age
+    """
+    bot.send_message(message.chat.id, 'Looks like you are submitting a string in the field age. Please enter a number')
+
+# register filters
+
+bot.add_custom_filter(custom_filters.StateFilter(bot))
+bot.add_custom_filter(custom_filters.IsDigitFilter())
+
+bot.infinity_polling(skip_pending=True)

examples/deep_linking.py

@@ -1,3 +1,5 @@
+#!/usr/bin/python
+
 # This example shows how to implement deep linking (https://core.telegram.org/bots#deep-linking)
 # with the pyTelegramBotAPI.
 # Note: This is not a working, production-ready sample.
@@ -31,34 +33,38 @@
 # steps are not shown here. Only steps 5 to 7 are illustrated, some in pseudo-code, with this example.
 
 import telebot
-import time
 
 bot = telebot.TeleBot('TOKEN')
 
+
 def extract_unique_code(text):
     # Extracts the unique_code from the sent /start command.
     return text.split()[1] if len(text.split()) > 1 else None
 
+
 def in_storage(unique_code):
     # (pseudo-code) Should check if a unique code exists in storage
     return True
 
+
 def get_username_from_storage(unique_code):
     # (pseudo-code) Does a query to the storage, retrieving the associated username
     # Should be replaced by a real database-lookup.
     return "ABC" if in_storage(unique_code) else None
 
+
 def save_chat_id(chat_id, username):
     # (pseudo-code) Save the chat_id->username to storage
     # Should be replaced by a real database query.
     pass
 
+
 @bot.message_handler(commands=['start'])
 def send_welcome(message):
     unique_code = extract_unique_code(message.text)
-    if unique_code: # if the '/start' command contains a unique_code
+    if unique_code:  # if the '/start' command contains a unique_code
         username = get_username_from_storage(unique_code)
-        if username: # if the username exists in our database
+        if username:  # if the username exists in our database
             save_chat_id(message.chat.id, username)
             reply = "Hello {0}, how are you?".format(username)
         else:
@@ -67,4 +73,5 @@ def send_welcome(message):
         reply = "Please visit me via a provided URL from the website."
     bot.reply_to(message, reply)
 
-bot.polling()
+
+bot.infinity_polling()

examples/detailed_example/detailed_example.py

@@ -2,9 +2,10 @@
 This is a detailed example using almost every command of the API
 """
 
+import time
+
 import telebot
 from telebot import types
-import time
 
 TOKEN = '<token_string>'
 
@@ -12,16 +13,16 @@ knownUsers = []  # todo: save these in a file,
 userStep = {}  # so they won't reset every time the bot restarts
 
 commands = {  # command description used in the "help" command
-              'start': 'Get used to the bot',
-              'help': 'Gives you information about the available commands',
-              'sendLongText': 'A test using the \'send_chat_action\' command',
-              'getImage': 'A test using multi-stage messages, custom keyboard, and media sending'
+    'start'       : 'Get used to the bot',
+    'help'        : 'Gives you information about the available commands',
+    'sendLongText': 'A test using the \'send_chat_action\' command',
+    'getImage'    : 'A test using multi-stage messages, custom keyboard, and media sending'
 }
 
 imageSelect = types.ReplyKeyboardMarkup(one_time_keyboard=True)  # create the image selection keyboard
-imageSelect.add('cock', 'pussy')
+imageSelect.add('Mickey', 'Minnie')
 
-hideBoard = types.ReplyKeyboardHide()  # if sent as reply_markup, will hide the keyboard
+hideBoard = types.ReplyKeyboardRemove()  # if sent as reply_markup, will hide the keyboard
 
 
 # error handling if user isn't known yet
@@ -33,7 +34,7 @@ def get_user_step(uid):
     else:
         knownUsers.append(uid)
         userStep[uid] = 0
-        print "New user detected, who hasn't used \"/start\" yet"
+        print("New user detected, who hasn't used \"/start\" yet")
         return 0
 
 
@@ -45,7 +46,7 @@ def listener(messages):
     for m in messages:
         if m.content_type == 'text':
             # print the sent message to the console
-            print str(m.chat.first_name) + " [" + str(m.chat.id) + "]: " + m.text
+            print(str(m.chat.first_name) + " [" + str(m.chat.id) + "]: " + m.text)
 
 
 bot = telebot.TeleBot(TOKEN)
@@ -104,15 +105,15 @@ def msg_image_select(m):
     # for some reason the 'upload_photo' status isn't quite working (doesn't show at all)
     bot.send_chat_action(cid, 'typing')
 
-    if text == "cock":  # send the appropriate image based on the reply to the "/getImage" command
+    if text == 'Mickey':  # send the appropriate image based on the reply to the "/getImage" command
         bot.send_photo(cid, open('rooster.jpg', 'rb'),
                        reply_markup=hideBoard)  # send file and hide keyboard, after image is sent
         userStep[cid] = 0  # reset the users step back to 0
-    elif text == "pussy":
+    elif text == 'Minnie':
         bot.send_photo(cid, open('kitten.jpg', 'rb'), reply_markup=hideBoard)
         userStep[cid] = 0
     else:
-        bot.send_message(cid, "Don't type bullsh*t, if I give you a predefined keyboard!")
+        bot.send_message(cid, "Please, use the predefined keyboard!")
         bot.send_message(cid, "Please try again")
 
 
@@ -128,4 +129,5 @@ def command_default(m):
     # this is the standard reply to a normal message
     bot.send_message(m.chat.id, "I don't understand \"" + m.text + "\"\nMaybe try the help page at /help")
 
-bot.polling()
+
+bot.infinity_polling()