refactor: unify sync and async callable invocation

Author: SychO3

pyrogram/dispatcher.py

@@ -18,7 +18,6 @@
 
 import asyncio
 from collections import OrderedDict
-import inspect
 import logging
 from typing import Dict
 
@@ -262,12 +261,7 @@ async def deleted_business_messages_parser(update, users, chats):
     async def start(self):
         if callable(self.client.start_handler):
             try:
-                if inspect.iscoroutinefunction(self.client.start_handler):
-                    await self.client.start_handler(self.client)
-                else:
-                    result = self.client.start_handler(self.client)
-                    if inspect.isawaitable(result):
-                        await result
+                await utils.invoke_callable(self.client.start_handler, self.client)
             except Exception as e:
                 log.exception("start_handler raised: %s", e)
 
@@ -325,12 +319,7 @@ async def stop(self, clear_handlers: bool = True):
 
         if callable(self.client.stop_handler):
             try:
-                if inspect.iscoroutinefunction(self.client.stop_handler):
-                    await self.client.stop_handler(self.client)
-                else:
-                    result = self.client.stop_handler(self.client)
-                    if inspect.isawaitable(result):
-                        await result
+                await utils.invoke_callable(self.client.stop_handler, self.client)
             except Exception as e:
                 log.exception("stop_handler raised: %s", e)
 
@@ -437,15 +426,10 @@ async def handler_worker(self, lock):
                                 continue
 
                             try:
-                                if inspect.iscoroutinefunction(handler.callback):
-                                    await handler.callback(self.client, *args)
-                                else:
-                                    await self.client.loop.run_in_executor(
-                                        self.client.executor,
-                                        handler.callback,
-                                        self.client,
-                                        *args
-                                    )
+                                await utils.invoke_callable(
+                                    handler.callback, self.client, *args,
+                                    executor=self.client.executor, loop=self.client.loop
+                                )
                             except asyncio.CancelledError:
                                 raise
                             except pyrogram.StopPropagation:
@@ -482,15 +466,11 @@ async def handle_update_handler_exception(
                         continue
 
                     try:
-                        if inspect.iscoroutinefunction(handler.callback):
-                            await handler.callback(
-                                self.client, exc, update_handler, update, users, chats
-                            )
-                        else:
-                            await self.client.loop.run_in_executor(
-                                self.client.executor, handler.callback,
-                                self.client, exc, update_handler, update, users, chats
-                            )
+                        await utils.invoke_callable(
+                            handler.callback,
+                            self.client, exc, update_handler, update, users, chats,
+                            executor=self.client.executor, loop=self.client.loop
+                        )
                     except pyrogram.StopPropagation:
                         handled = True
                         raise

pyrogram/handlers/callback_query_handler.py

@@ -17,11 +17,11 @@
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
 import asyncio
-from asyncio import iscoroutinefunction
 from typing import Callable, Tuple
 
 import pyrogram
 
+from pyrogram import utils
 from pyrogram.utils import PyromodConfig
 from pyrogram.types import CallbackQuery, Identifier, Listener
 
@@ -108,12 +108,10 @@ async def check_if_has_matching_listener(
         if listener:
             filters = listener.filters
             if callable(filters):
-                if iscoroutinefunction(filters.__call__):
-                    listener_does_match = await filters(client, query)
-                else:
-                    listener_does_match = await client.loop.run_in_executor(
-                        client.executor, filters, client, query
-                    )
+                listener_does_match = await utils.invoke_callable(
+                    filters, client, query,
+                    executor=client.executor, loop=client.loop
+                )
             else:
                 listener_does_match = True
 
@@ -135,12 +133,10 @@ async def check(self, client: "pyrogram.Client", query: CallbackQuery):
         query._matched_listener = listener if listener_does_match else None
 
         if callable(self.filters):
-            if iscoroutinefunction(self.filters.__call__):
-                handler_does_match = await self.filters(client, query)
-            else:
-                handler_does_match = await client.loop.run_in_executor(
-                    client.executor, self.filters, client, query
-                )
+            handler_does_match = await utils.invoke_callable(
+                self.filters, client, query,
+                executor=client.executor, loop=client.loop
+            )
         else:
             handler_does_match = True
 
@@ -198,12 +194,8 @@ async def resolve_future_or_callback(
                 raise pyrogram.StopPropagation
             elif listener.callback:
                 try:
-                    if iscoroutinefunction(listener.callback):
-                        await listener.callback(client, query, *args)
-                    else:
-                        listener.callback(client, query, *args)
+                    await utils.invoke_callable(listener.callback, client, query, *args)
                 except asyncio.CancelledError:
-                    # Cancelled during shutdown/interruption
                     raise pyrogram.StopPropagation
 
                 raise pyrogram.StopPropagation

pyrogram/handlers/conversation_handler.py

@@ -16,10 +16,10 @@
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
-import inspect
 from typing import Union
 
 import pyrogram
+from pyrogram import utils
 from pyrogram.types import Message, CallbackQuery
 from .message_handler import MessageHandler
 from .callback_query_handler import CallbackQueryHandler
@@ -57,21 +57,11 @@ async def check(self, client: "pyrogram.Client", update: Union[Message, Callback
 
         filters = waiter.get('filters')
         if callable(filters):
-            is_async = (
-                inspect.iscoroutinefunction(filters)
-                or inspect.iscoroutinefunction(getattr(filters, "__call__", None))
+            filtered = await utils.invoke_callable(
+                filters, client, update,
+                executor=client.executor, loop=client.loop
             )
 
-            if is_async:
-                result = filters(client, update)
-                filtered = await result if inspect.isawaitable(result) else result
-            else:
-                filtered = await client.loop.run_in_executor(
-                    client.executor,
-                    filters,
-                    client, update
-                )
-
             if not filtered or waiter['future'].done():
                 return False
 

pyrogram/handlers/handler.py

@@ -16,11 +16,11 @@
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
-import inspect
 import logging
 from typing import Callable, Optional
 
 import pyrogram
+from pyrogram import utils
 from pyrogram.filters import Filter
 from pyrogram.types import Update
 
@@ -34,14 +34,10 @@ def __init__(self, callback: Callable, filters: Optional[Filter] = None):
 
     async def check(self, client: "pyrogram.Client", update: Update):
         if callable(self.filters):
-            if inspect.iscoroutinefunction(self.filters.__call__):
-                return await self.filters(client, update)
-            else:
-                return await client.loop.run_in_executor(
-                    client.executor,
-                    self.filters,
-                    client, update
-                )
+            return await utils.invoke_callable(
+                self.filters, client, update,
+                executor=client.executor, loop=client.loop
+            )
 
         if self.filters is not None:
             log.warning("Non-callable filter %r treated as match-all", self.filters)

pyrogram/handlers/message_handler.py

@@ -17,10 +17,10 @@
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
 import asyncio
-from inspect import iscoroutinefunction
 from typing import Callable
 import pyrogram
 
+from pyrogram import utils
 from pyrogram.types import Message, Identifier
 
 from .handler import Handler
@@ -85,12 +85,10 @@ async def check_if_has_matching_listener(self, client: "pyrogram.Client", messag
         if listener:
             filters = listener.filters
             if callable(filters):
-                if iscoroutinefunction(filters.__call__):
-                    listener_does_match = await filters(client, message)
-                else:
-                    listener_does_match = await client.loop.run_in_executor(
-                        client.executor, filters, client, message
-                    )
+                listener_does_match = await utils.invoke_callable(
+                    filters, client, message,
+                    executor=client.executor, loop=client.loop
+                )
             else:
                 listener_does_match = True
 
@@ -109,12 +107,10 @@ async def check(self, client: "pyrogram.Client", message: Message):
         message._matched_listener = listener if listener_does_match else None
 
         if callable(self.filters):
-            if iscoroutinefunction(self.filters.__call__):
-                handler_does_match = await self.filters(client, message)
-            else:
-                handler_does_match = await client.loop.run_in_executor(
-                    client.executor, self.filters, client, message
-                )
+            handler_does_match = await utils.invoke_callable(
+                self.filters, client, message,
+                executor=client.executor, loop=client.loop
+            )
         else:
             handler_does_match = True
 
@@ -146,10 +142,7 @@ async def resolve_future_or_callback(self, client: "pyrogram.Client", message: M
 
                 raise pyrogram.StopPropagation
             elif listener.callback:
-                if iscoroutinefunction(listener.callback):
-                    await listener.callback(client, message, *args)
-                else:
-                    listener.callback(client, message, *args)
+                await utils.invoke_callable(listener.callback, client, message, *args)
 
                 raise pyrogram.StopPropagation
             else:

pyrogram/utils.py

@@ -18,6 +18,7 @@
 
 import asyncio
 import base64
+import inspect
 import logging
 import functools
 import hashlib
@@ -39,6 +40,12 @@
 log = logging.getLogger(__name__)
 
 
+async def invoke_callable(func, *args, executor=None, loop=None):
+    if inspect.iscoroutinefunction(func) or inspect.iscoroutinefunction(getattr(func, "__call__", None)):
+        return await func(*args)
+    return await (loop or asyncio.get_running_loop()).run_in_executor(executor, func, *args)
+
+
 def get_event_loop() -> asyncio.AbstractEventLoop:
     try:
         return asyncio.get_running_loop()