refactor(error_handler): better code consistency

HitaloM · HitaloM · commit 2c8de1d8f703 · 2024-07-20T18:14:48.000-03:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -11,7 +11,7 @@ repos:
       - id: check-yaml
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.3
+    rev: v0.5.4
     hooks:
       - id: ruff-format
       - id: ruff
diff --git a/hydrogram/dispatcher.py b/hydrogram/dispatcher.py
@@ -232,10 +232,9 @@ async def _process_packet(self, packet, lock):
 
     async def _handle_update(self, handler, handler_type, parsed_update, update, users, chats):
         try:
-            if isinstance(handler, handler_type) and await handler.check(
-                self.client, parsed_update
-            ):
-                await self._execute_callback(handler, parsed_update)
+            if isinstance(handler, handler_type):
+                if await handler.check(self.client, parsed_update):
+                    await self._execute_callback(handler, parsed_update)
             elif isinstance(handler, RawUpdateHandler):
                 await self._execute_callback(handler, update, users, chats)
         except (hydrogram.StopPropagation, hydrogram.ContinuePropagation) as e:
@@ -249,17 +248,17 @@ async def _handle_exception(self, parsed_update, exception):
         for error_handler in self.error_handlers:
             try:
                 if await error_handler.check(self.client, parsed_update, exception):
-                    await error_handler.callback(self.client, parsed_update, exception)
                     handled_error = True
                     break
             except hydrogram.StopPropagation:
                 raise
-            except (hydrogram.ContinuePropagation, Exception) as inner_exception:
-                if isinstance(inner_exception, Exception):
-                    log.exception(inner_exception)
+            except hydrogram.ContinuePropagation:
+                continue
+            except Exception as inner_exception:
+                log.exception("Error in error handler: %s", inner_exception)
 
         if not handled_error:
-            log.exception(exception)
+            log.exception("Unhandled exception: %s", exception)
 
     async def _execute_callback(self, handler, *args):
         if inspect.iscoroutinefunction(handler.callback):
diff --git a/hydrogram/handlers/error_handler.py b/hydrogram/handlers/error_handler.py
@@ -40,7 +40,7 @@ class ErrorHandler(Handler):
             Pass a function that will be called when a new Error arrives. It takes *(client, error)*
             as positional arguments (look at the section below for a detailed description).
 
-        errors (``Exception`` | Iterable of ``Exception``, *optional*):
+        exceptions (``Exception`` | Iterable of ``Exception``, *optional*):
             Pass one or more exception classes to allow only a subset of errors to be passed
             in your callback function.
 
@@ -58,19 +58,22 @@ class ErrorHandler(Handler):
     def __init__(
         self,
         callback: Callable,
-        errors: type[Exception] | Iterable[type[Exception]] | None = None,
+        exceptions: type[Exception] | Iterable[type[Exception]] | None = None,
     ):
-        self.errors = (
-            tuple(errors)
-            if isinstance(errors, Iterable)
-            else (errors,)
-            if errors
+        self.exceptions = (
+            tuple(exceptions)
+            if isinstance(exceptions, Iterable)
+            else (exceptions,)
+            if exceptions
             else (Exception,)
         )
         super().__init__(callback)
 
-    async def check(self, client: hydrogram.Client, update: Update, error: Exception) -> bool:
-        return isinstance(error, self.errors)
+    async def check(self, client: hydrogram.Client, update: Update, exception: Exception) -> bool:
+        if isinstance(exception, self.exceptions):
+            await self.callback(client, update, exception)
+            return True
+        return False
 
-    def check_remove(self, error: Exception) -> bool:
-        return isinstance(error, self.errors)
+    def check_remove(self, error: type[Exception] | Iterable[type[Exception]]) -> bool:
+        return isinstance(error, self.exceptions)
diff --git a/hydrogram/methods/utilities/remove_error_handler.py b/hydrogram/methods/utilities/remove_error_handler.py
@@ -28,14 +28,19 @@
 
 class RemoveErrorHandler:
     def remove_error_handler(
-        self: hydrogram.Client, error: type[Exception] | Iterable[type[Exception]] = Exception
+        self: hydrogram.Client,
+        exception: type[Exception] | Iterable[type[Exception]] = Exception,
     ):
-        """Remove a previously-registered error handler. (using exception classes)
+        """Remove a previously registered error handler using exception classes.
 
         Parameters:
-            error (``Exception`` | Iterable of ``Exception``, *optional*):
-                The error(s) for handlers to be removed.
+            exception (``Exception`` | Iterable of ``Exception``, *optional*):
+                The error(s) for handlers to be removed. Defaults to Exception.
         """
-        for handler in self.dispatcher.error_handlers:
-            if handler.check_remove(error):
-                self.dispatcher.error_handlers.remove(handler)
+        to_remove = [
+            handler
+            for handler in self.dispatcher.error_handlers
+            if handler.check_remove(exception)
+        ]
+        for handler in to_remove:
+            self.dispatcher.error_handlers.remove(handler)
diff --git a/pyproject.toml b/pyproject.toml
@@ -51,7 +51,7 @@ build-backend = "hatchling.build"
 [tool.rye]
 managed = true
 dev-dependencies = [
-    "ruff>=0.5.3",
+    "ruff>=0.5.4",
     "pytest>=7.4.3",
     "pytest-asyncio>=0.23.2",
     "pytest-cov>=4.1.0",
@@ -61,7 +61,7 @@ dev-dependencies = [
 
 [project.optional-dependencies]
 docs = [
-    "Sphinx>=7.4.6",
+    "sphinx>=7.4.7",
     "furo>=2024.7.18",
     "sphinx-autobuild>=2024.4.16",
     "sphinx-copybutton>=0.5.2",
