Added run_webhooks for asynctelebot

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 = '123.12.33.22' # 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/webhook_examples/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.
+
+import telebot
+
+API_TOKEN = 'TOKEN'
+
+bot = telebot.TeleBot(API_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 = '123.12.33.22' # 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'])
+def send_welcome(message):
+    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)
+def echo_message(message):
+    bot.reply_to(message, message.text)
+
+
+bot.run_webhooks(
+    listen=DOMAIN,
+    certificate=WEBHOOK_SSL_CERT,
+    certificate_key=WEBHOOK_SSL_PRIV
+)

telebot/__init__.py

@@ -375,7 +375,7 @@ def run_webhooks(self,
         ssl_context = (certificate, certificate_key) if certificate else None
         self.webhook_listener = SyncWebhookListener(self, secret_token, listen, port, ssl_context, '/'+url_path, debug)
         self.webhook_listener.run_app()
-        return self.webhook_listener
+
 
 
     def delete_webhook(self, drop_pending_updates=None, timeout=None):

telebot/async_telebot.py

@@ -30,6 +30,13 @@
     types.ReplyKeyboardRemove, types.ForceReply]
 
 
+# for webhooks
+from telebot.extensions import AsyncWebhookListener
+import string
+import random
+import ssl
+
+
 """
 Module : telebot
 """
@@ -1438,6 +1445,82 @@ async def set_webhook(self, url=None, certificate=None, max_connections=None, al
                                      drop_pending_updates, timeout, secret_token)
 
 
+    async def run_webhooks(self,
+                    listen: Optional[str]="127.0.0.1",
+                    port: Optional[int]=443,
+                    url_path: Optional[str]=None,
+                    certificate: Optional[str]=None,
+                    certificate_key: Optional[str]=None,
+                    webhook_url: Optional[str]=None,
+                    max_connections: Optional[int]=None,
+                    allowed_updates: Optional[List]=None,
+                    ip_address: Optional[str]=None,
+                    drop_pending_updates: Optional[bool] = None,
+                    timeout: Optional[int]=None,
+                    secret_token: Optional[str]=None,
+                    secret_token_length: Optional[int]=20,
+                    debug: Optional[bool]=False):
+        """
+        This class sets webhooks and listens to a given url and port.
+
+        :param listen: IP address to listen to. Defaults to
+            0.0.0.0
+        :param port: A port which will be used to listen to webhooks.
+        :param url_path: Path to the webhook. Defaults to /token
+        :param certificate: Path to the certificate file.
+        :param certificate_key: Path to the certificate key file.
+        :param webhook_url: Webhook URL.
+        :param max_connections: Maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40. Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
+        :param allowed_updates: A JSON-serialized list of the update types you want your bot to receive. For example, specify [“message”, “edited_channel_post”, “callback_query”] to only receive updates of these types. See Update for a complete list of available update types. Specify an empty list to receive all updates regardless of type (default). If not specified, the previous setting will be used.
+        :param ip_address: The fixed IP address which will be used to send webhook requests instead of the IP address resolved through DNS
+        :param drop_pending_updates: Pass True to drop all pending updates
+        :param timeout: Integer. Request connection timeout
+        :param secret_token: Secret token to be used to verify the webhook request.
+        :return:
+        """
+
+        # generate secret token if not set
+        if not secret_token:
+            secret_token = ''.join(random.choices(string.ascii_uppercase + string.digits, k=secret_token_length))
+
+
+        if not url_path:
+            url_path = self.token + '/'
+        if url_path[-1] != '/': url_path += '/'
+
+
+
+        protocol = "https" if certificate else "http"
+        if not webhook_url:
+            webhook_url = "{}://{}:{}/{}".format(protocol, listen, port, url_path)
+
+        if certificate and certificate_key:
+            ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            ssl_ctx.load_cert_chain(certificate, certificate_key)
+        else:
+            ssl_ctx = None
+
+        # open certificate if it exists
+        cert_file = open(certificate, 'rb') if certificate else None
+        await self.set_webhook(
+            url=webhook_url,
+            certificate=cert_file,
+            max_connections=max_connections,
+            allowed_updates=allowed_updates,
+            ip_address=ip_address,
+            drop_pending_updates=drop_pending_updates,
+            timeout=timeout,
+            secret_token=secret_token
+        )
+        if cert_file: cert_file.close()
+
+        ssl_context = (certificate, certificate_key) if certificate else (None, None)
+        self.webhook_listener = AsyncWebhookListener(self, secret_token, listen, port, ssl_context, '/'+url_path, debug)
+        # create a new loop, set it, and pass it
+        asyncio.set_event_loop(asyncio.new_event_loop())
+        await self.webhook_listener.run_app()
+
+
 
     async def delete_webhook(self, drop_pending_updates=None, timeout=None):
         """

telebot/extensions/__init__.py

@@ -1,7 +1,8 @@
-from .webhooks import SyncWebhookListener
+from .webhooks import SyncWebhookListener, AsyncWebhookListener
 
 
 
 __all__ = [
-    'SyncWebhookListener'
-]
+    'SyncWebhookListener',
+    'AsyncWebhookListener'
+]

telebot/extensions/webhooks.py

@@ -2,19 +2,35 @@
 This file is used by TeleBot.run_webhooks() &
 AsyncTeleBot.run_webhooks() functions.
 
-Flask/Aiohttp is required to run this script.
+Flask/fastapi is required to run this script.
 """
 
-
+# modules required
 flask_installed = True
+fastapi_installed = True
+uvicorn_installed = True
+
 try:
     import flask
     from werkzeug.serving import _TSSLContextArg
 except ImportError:
     flask_installed = False
     _TSSLContextArg = None
 
+try:
+    import fastapi
+    from fastapi.responses import JSONResponse
+except ImportError:
+    fastapi_installed = False
+
+
+try:
+    from uvicorn import Server, Config
+except ImportError:
+    uvicorn_installed = False
+
 
+import asyncio
 from telebot.types import Update
 
 
@@ -85,4 +101,85 @@ def run_app(self):
             ssl_context=self._ssl_context,
             debug=self._debug
         )
-        return self
+
+
+
+
+class AsyncWebhookListener:
+    def __init__(self, bot, 
+                secret_token: str, host: Optional[str]="127.0.0.1", 
+                port: Optional[int]=8000,
+                ssl_context: Optional[_TSSLContextArg]=None,
+                url_path: Optional[str]=None,
+                debug: Optional[bool]=False
+                ) -> None:
+        """
+        Synchronous implementation of webhook listener
+        for synchronous version of telebot.
+
+        :param bot: TeleBot instance
+        :param secret_token: Telegram secret token
+        :param host: Webhook host
+        :param port: Webhook port
+        :param ssl_context: SSL context
+        """
+        self._check_dependencies()
+
+        self.app = fastapi.FastAPI()
+        self._secret_token = secret_token
+        self._bot = bot
+        self._port = port
+        self._host = host
+        self._ssl_context = ssl_context
+        self._url_path = url_path
+        self._debug = debug
+        self._prepare_endpoint_urls()
+
+
+    def _check_dependencies(self):
+        if not fastapi_installed:
+            raise ImportError('Fastapi is not installed. Please install it via pip.')
+        if not uvicorn_installed:
+            raise ImportError('Uvicorn is not installed. Please install it via pip.')
+
+        import starlette
+        if starlette.__version__ < '0.20.2':
+            raise ImportError('Starlette version is too old. Please upgrade it.')
+        return
+
+
+    def _prepare_endpoint_urls(self):
+        self.app.add_api_route(endpoint=self.process_update,path= self._url_path, methods=["POST"])
+
+
+    async def process_update(self, request: fastapi.Request):
+        """
+        Processes updates.
+        """
+        # header containsX-Telegram-Bot-Api-Secret-Token
+        if request.headers.get('X-Telegram-Bot-Api-Secret-Token') != self._secret_token:
+            # secret token didn't match
+            return JSONResponse(status_code=403, content={"error": "Forbidden"})
+        if request.headers.get('content-type') == 'application/json':
+            json_string = await request.json()
+            asyncio.create_task(self._bot.process_new_updates([Update.de_json(json_string)]))
+            return JSONResponse('', status_code=200)
+
+        return JSONResponse(status_code=403, content={"error": "Forbidden"})
+
+
+    async def run_app(self):
+        """
+        Run app with the given parameters.
+        """
+
+        config = Config(app=self.app,
+            host=self._host,
+            port=self._port,
+            debug=self._debug,
+            ssl_certfile=self._ssl_context[0],
+            ssl_keyfile=self._ssl_context[1]
+        )
+        server = Server(config)
+        await server.serve()
+        await self._bot.close_session()