Changed: handlers don't need to be instantiated

Author: mnot

redbot/webui/__init__.py

@@ -52,6 +52,16 @@ class RedWebUi:
     If descend is true, spider the links and present a summary.
     """
 
+    handlers = [
+        SaveHandler,
+        LoadSavedTestHandler,
+        ClientErrorHandler,
+        RunTestHandler,
+        RedirectHandler,
+        ShowHandler,
+        ErrorHandler,  # Final fallback for 404/405
+    ]
+
     def __init__(
         self,
         config: SectionProxy,
@@ -114,19 +124,9 @@ def __init__(
         self.link_generator: LinkGenerator = WebUiLinkGenerator(self)
 
         # Dispatch through handler chain
-        handlers = [
-            SaveHandler(self),
-            LoadSavedTestHandler(self),
-            ClientErrorHandler(self),
-            RunTestHandler(self),
-            RedirectHandler(self),
-            ShowHandler(self),
-            ErrorHandler(self),  # Final fallback for 404/405
-        ]
-
-        for handler in handlers:
-            if handler.can_handle():
-                handler.handle()
+        for handler in self.handlers:
+            if handler.can_handle(self):
+                handler.handle(self)
                 break
 
     def error_response(

redbot/webui/handlers/base.py

@@ -26,10 +26,8 @@ class RequestHandler(ABC):
     3. Generating URIs and HTML forms for accessing the handler
     """
 
-    def __init__(self, ui: RedWebUiProtocol) -> None:
-        self.ui = ui
-
-    def get_base_uri(self, absolute: bool = False) -> str:
+    @classmethod
+    def get_base_uri(cls, ui: RedWebUiProtocol, absolute: bool = False) -> str:
         """
         Get the base URI for links.
 
@@ -38,16 +36,17 @@ def get_base_uri(self, absolute: bool = False) -> str:
 
         The returned string is always terminated by '/'.
         """
-        ui_uri = self.ui.config.get("ui_uri", "")
+        ui_uri = ui.config.get("ui_uri", "")
         if not ui_uri.endswith("/"):
             ui_uri += "/"
 
         if absolute:
             return ui_uri
         return urlparse(ui_uri).path
 
+    @classmethod
     @abstractmethod
-    def can_handle(self) -> bool:
+    def can_handle(cls, ui: RedWebUiProtocol) -> bool:
         """
         Determine if this handler should process the request.
 
@@ -57,35 +56,39 @@ def can_handle(self) -> bool:
             True if this handler should process the request, False otherwise
         """
 
+    @classmethod
     @abstractmethod
-    def handle(self) -> None:
+    def handle(cls, ui: RedWebUiProtocol) -> None:
         """
         Handle the request and generate a response.
 
         This method is responsible for:
         - Processing the request
         - Generating appropriate response headers and body
-        - Calling self.ui.exchange.response_start(), self.ui.output(), and
-          self.ui.exchange.response_done()
+        - Calling ui.exchange.response_start(), ui.output(), and
+          ui.exchange.response_done()
         """
 
+    @classmethod
     @abstractmethod
-    def render_link(self, **kwargs: Any) -> str:
+    def render_link(cls, ui: RedWebUiProtocol, **kwargs: Any) -> str:
         """
         Generate a URI for this handler.
 
         This method generates a relative URI for the handler, including any
         parameters required. It uses the `ui_uri` from the configuration.
 
         Args:
+            ui: The WebUI instance
             **kwargs: Arguments for the link (handler-specific)
 
         Returns:
             The generated URI string
         """
         raise NotImplementedError
 
-    def render_form(self, **kwargs: Any) -> str:
+    @classmethod
+    def render_form(cls, ui: RedWebUiProtocol, **kwargs: Any) -> str:
         """
         Generate an HTML form for accessing this handler.
 
@@ -94,6 +97,7 @@ def render_form(self, **kwargs: Any) -> str:
         return a complete HTML <form> element.
 
         Args:
+            ui: The WebUI instance
             **kwargs: Handler-specific parameters for the form
 
         Returns:

redbot/webui/handlers/client_error.py

@@ -8,6 +8,7 @@
 from typing import TYPE_CHECKING
 
 from redbot.webui.handlers.base import RequestHandler
+from redbot.type import RedWebUiProtocol
 
 if TYPE_CHECKING:
     from redbot.webui import RedWebUi
@@ -22,54 +23,59 @@ class ClientErrorHandler(RequestHandler):
     response.
     """
 
-    def can_handle(self) -> bool:
+    @classmethod
+    def can_handle(cls, ui: RedWebUiProtocol) -> bool:
         """
         Determine if this handler should process the request.
 
         Handles POST requests with 'client_error' in query string.
         """
         return (
-            self.ui.method == "POST"
-            and len(self.ui.path) > 0
-            and self.ui.path[0] == "client_error"
+            ui.method == "POST"
+            and len(ui.path) > 0
+            and ui.path[0] == "client_error"
         )
 
-    def handle(self) -> None:
+    @classmethod
+    def handle(cls, ui: RedWebUiProtocol) -> None:
         """
         Handle the client error by logging it.
 
         Extracts the error message from the request body, sanitizes it,
         and logs it to the console. Returns a 204 No Content response.
         """
         # Extract and sanitize the error message
-        body = self.ui.req_body.decode("ascii", "replace")[:255].replace("\n", "")
+        body = ui.req_body.decode("ascii", "replace")[:255].replace("\n", "")
         body_safe = "".join([x for x in body if x in string.printable])
 
         # Log the error
-        self.ui.error_log(f"Client JS -> {body_safe}")
+        ui.error_log(f"Client JS -> {body_safe}")
 
         # Return 204 No Content
-        self.ui.exchange.response_start(
+        ui.exchange.response_start(
             b"204",
             b"No Content",
             [],
         )
-        self.ui.exchange.response_done([])
+        ui.exchange.response_done([])
 
-    def render_link(self, absolute: bool = False, **kwargs: str) -> str:
+    @classmethod
+    def render_link(cls, ui: RedWebUiProtocol, absolute: bool = False, **kwargs: str) -> str:
         """
         Generate a URI for reporting client errors.
 
         Args:
+            ui: The WebUI instance
             absolute: If True, return absolute URI
             **kwargs: Not used for this handler
 
         Returns:
             URI for the client error endpoint
         """
-        return f"{self.get_base_uri(absolute)}client_error"
+        return f"{cls.get_base_uri(ui, absolute)}client_error"
 
-    def render_form(self, **kwargs: str) -> str:
+    @classmethod
+    def render_form(cls, ui: RedWebUiProtocol, **kwargs: str) -> str:
         """
         Client error reporting doesn't use forms.
 

redbot/webui/handlers/error.py

@@ -7,6 +7,7 @@
 from typing import TYPE_CHECKING
 
 from redbot.webui.handlers.base import RequestHandler
+from redbot.type import RedWebUiProtocol
 
 if TYPE_CHECKING:
     from redbot.webui import RedWebUi
@@ -20,7 +21,8 @@ class ErrorHandler(RequestHandler):
     and returns appropriate error responses.
     """
 
-    def can_handle(self) -> bool:
+    @classmethod
+    def can_handle(cls, ui: RedWebUiProtocol) -> bool:
         """
         Determine if this handler should process the request.
 
@@ -29,7 +31,8 @@ def can_handle(self) -> bool:
         """
         return True  # Always matches as the final fallback
 
-    def handle(self) -> None:
+    @classmethod
+    def handle(cls, ui: RedWebUiProtocol) -> None:
         """
         Handle the error by returning 405 or 404 as appropriate.
 
@@ -38,13 +41,14 @@ def handle(self) -> None:
         """
         # Get the HTTP method from the request
         # For now, we'll treat everything as 404 since we're the final fallback
-        self.ui.error_response(
+        ui.error_response(
             b"404",
             b"Not Found",
             "The requested resource was not found",
         )
 
-    def render_link(self, **kwargs: str) -> str:
+    @classmethod
+    def render_link(cls, ui: RedWebUiProtocol, **kwargs: str) -> str:
         """
         Error handler doesn't generate links.
 
@@ -53,7 +57,8 @@ def render_link(self, **kwargs: str) -> str:
         """
         return ""
 
-    def render_form(self, **kwargs: str) -> str:
+    @classmethod
+    def render_form(cls, ui: RedWebUiProtocol, **kwargs: str) -> str:
         """
         Error handler doesn't generate forms.