fixup: apply code suggestions on the manager

Author: shtlrs

pydis_core/utils/error_handling/commands/manager.py

@@ -13,49 +13,44 @@
 class CommandErrorManager:
     """A class that registers error handlers and handles all command related errors."""
 
-    def __init__(self, default: AbstractCommandErrorHandler, handlers: list[AbstractCommandErrorHandler] | None = None):
-        self.handlers = handlers or []
-        self.registered_handlers = set(type(handler).__name__ for handler in self.handlers)
-        self.default = default
+    def __init__(self, default: AbstractCommandErrorHandler):
+        self._handlers = []
+        self._registered_handlers = set()
+        self._default = default
 
     async def handle_error(
         self,
         error: Exception,
         context_or_interaction: Context | Interaction
     ) -> None:
         """
-        Handle a discord exception.
+        Handle a Discord exception.
 
-        This works simply by iterating over the available handlers, and chooses the one capable of handling the error.
-
-        Instead of having some priority system to distinguish the execution order of handlers, we will
-        let the `should_handle_error` do the job.
-
-        The default needs to always be last, since the container can either be initialized with the handlers, or
-        we can add handlers using the `register_handler` function that we don't know when it will be invoked, if ever.
+        Iterate through available handlers by registration order, and choose the first one capable of handling
+        the error as determined by `should_handle_error`; there is no priority system.
         """
-        for handler in self.handlers + [self.default]:
+        for handler in self._handlers + [self._default]:
             if await handler.should_handle_error(error):
-                callback = self._determine_callback(handler, context_or_interaction)
+                callback = self._get_callback(handler, context_or_interaction)
                 await callback(context_or_interaction, error)
                 break
 
     def register_handler(self, handler: AbstractCommandErrorHandler) -> None:
         """Register a command error handler."""
         handler_name = type(handler).__name__
-        if handler_name in self.registered_handlers:
-            log.info(f"Skipping registration of command error handler '{handler_name}' as it's already registered.")
+        if handler_name in self._registered_handlers:
+            log.info(f"Skipping registration of command error handler {handler_name!r} as it's already registered.")
             return
 
-        self.handlers.append(handler)
-        self.registered_handlers.add(type(handler).__name__)
+        self._handlers.append(handler)
+        self._registered_handlers.add(handler_name)
 
     @staticmethod
-    def _determine_callback(
+    def _get_callback(
         handler: AbstractCommandErrorHandler,
         context_or_interaction: Context | Interaction
     ) -> Callable[[Context, Exception], NoReturn] | Callable[[Interaction, Exception], NoReturn] | None:
-        """Determines the handling callback that will be used."""
+        """Get the handling callback that will be used."""
         if isinstance(context_or_interaction, Context):
             return handler.handle_text_command_error
         return handler.handle_app_command_error