Handlers and Middlewares processing union

Call for handlers now union in a single function for future extension.

Plus minor fixes in storages.

telebot/__init__.py

@@ -469,6 +469,7 @@ class TeleBot:
             webhook_url = "{}://{}:{}/{}".format(protocol, listen, port, url_path)
 
         if certificate and certificate_key:
+            # noinspection PyTypeChecker
             ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
             ssl_ctx.load_cert_chain(certificate, certificate_key)
 
@@ -5875,7 +5876,7 @@ class TeleBot:
             return False
 
     # middleware check-up method
-    def _check_middleware(self, update_type):
+    def _check_middlewares(self, update_type):
         """
         Check middleware
 
@@ -5889,12 +5890,21 @@ class TeleBot:
 
     def _run_middlewares_and_handler(self, message, handlers, middlewares, update_type):
         """
-        This class is made to run handler and middleware in queue.
+        This class is made to run handlers and middlewares in queue.
 
-        :param handler: handler that should be executed.
+        :param message: received message (update part) to process with handlers and/or middlewares
-        :param middleware: middleware that should be executed.
+        :param handlers: all created handlers (not filtered)
+        :param middlewares: middlewares that should be executed (already filtered)
+        :param update_type: handler/update type (Update field name)
         :return:
         """
+
+        if not self.use_class_middlewares:
+            for message_handler in handlers:
+                if self._test_message_handler(message_handler, message):
+                    self._exec_task(message_handler['function'], message, pass_bot=message_handler['pass_bot'], task_type='handler')
+                    break
+        else:
             data = {}
             params =[]
             handler_error = None
@@ -5969,20 +5979,22 @@ class TeleBot:
         """
         Notifies command handlers.
 
-        :param handlers:
+        :param handlers: all created handlers
-        :param new_messages:
+        :param new_messages: received messages to proceed
+        :param update_type: handler/update type (Update fields)
         :return:
         """
         if not(handlers) and not(self.use_class_middlewares):
             return
 
-        for message in new_messages:
+        if self.use_class_middlewares:
-            if not self.use_class_middlewares:
+            middlewares = self._check_middlewares(update_type)
-                for message_handler in handlers:
-                    if self._test_message_handler(message_handler, message):
-                        self._exec_task(message_handler['function'], message, pass_bot=message_handler['pass_bot'], task_type='handler')
-                        break
         else:
-                middleware = self._check_middleware(update_type)
+            middlewares = None
-                self._exec_task(self._run_middlewares_and_handler, message, handlers=handlers, middlewares=middleware, update_type=update_type)
+        for message in new_messages:
-                return
+            self._exec_task(
+                self._run_middlewares_and_handler,
+                message,
+                handlers=handlers,
+                middlewares=middlewares,
+                update_type=update_type)

telebot/ext/sync/webhooks.py

@@ -1,6 +1,5 @@
 """
 This file is used by TeleBot.run_webhooks() function.
-
 Fastapi is required to run this script.
 """
 
@@ -15,15 +14,11 @@ try:
 except ImportError:
     fastapi_installed = False
 
-
 from telebot.types import Update
 
-
 from typing import Optional
 
 
-
-
 class SyncWebhookListener:
     def __init__(self, bot, 
                 secret_token: str, host: Optional[str]="127.0.0.1", 
@@ -33,13 +28,13 @@ class SyncWebhookListener:
                 debug: Optional[bool]=False
                 ) -> None:
         """
-        Aynchronous implementation of webhook listener
+        Synchronous implementation of webhook listener
-        for asynchronous version of telebot.
+        for synchronous version of telebot.
         Not supposed to be used manually by user.
-        Use AsyncTeleBot.run_webhooks() instead.
+        Use TeleBot.run_webhooks() instead.
 
-        :param bot: AsyncTeleBot instance.
+        :param bot: TeleBot instance.
-        :type bot: telebot.async_telebot.AsyncTeleBot
+        :type bot: telebot.TeleBot
 
         :param secret_token: Telegram secret token
         :type secret_token: str
@@ -77,7 +72,8 @@ class SyncWebhookListener:
         self._prepare_endpoint_urls()
 
 
-    def _check_dependencies(self):
+    @staticmethod
+    def _check_dependencies():
         if not fastapi_installed:
             raise ImportError('Fastapi or uvicorn is not installed. Please install it via pip.')
             

telebot/storage/base_storage.py

@@ -42,6 +42,9 @@ class StateStorageBase:
     def get_state(self, chat_id, user_id):
         raise NotImplementedError
 
+    def get_interactive_data(self, chat_id, user_id):
+        raise NotImplementedError
+
     def save(self, chat_id, user_id, data):
         raise NotImplementedError
 

telebot/storage/memory_storage.py

@@ -3,6 +3,7 @@ from telebot.storage.base_storage import StateStorageBase, StateContext
 
 class StateMemoryStorage(StateStorageBase):
     def __init__(self) -> None:
+        super().__init__()
         self.data = {}
         #
         # {chat_id: {user_id: {'state': None, 'data': {}}, ...}, ...}

telebot/storage/pickle_storage.py

@@ -5,8 +5,8 @@ import pickle
 
 
 class StatePickleStorage(StateStorageBase):
-    # noinspection PyMissingConstructor
     def __init__(self, file_path="./.state-save/states.pkl") -> None:
+        super().__init__()
         self.file_path = file_path
         self.create_dir()
         self.data = self.read()

telebot/storage/redis_storage.py

@@ -16,6 +16,7 @@ class StateRedisStorage(StateStorageBase):
     TeleBot(storage=StateRedisStorage())
     """
     def __init__(self, host='localhost', port=6379, db=0, password=None, prefix='telebot_'):
+        super().__init__()
         self.redis = ConnectionPool(host=host, port=port, db=db, password=password)
         #self.con = Redis(connection_pool=self.redis) -> use this when necessary
         #