Patch gradio_log.Log in-place for per-session tailing

The SessionLog subclass introduced earlier caused 404s on its
templates/component/{index.js,style.css} when deployed to HF Spaces.
Reason: gradio/routes.py custom_component_path resolves frontend
assets relative to the component's __module__ file. Subclassing in
app.py made Gradio look for <app_dir>/templates/component/index.js,
which doesn't exist, so the bundle was never served and the SPA
hung in a loading loop.

Subclassing with __module__ = "gradio_log.log" also breaks because
Gradio's component_meta generates a .pyi stub at class-definition
time via inspect.getsource(), which then can't locate the source.

Monkey-patch Log.read_to_end / Log.get_current_reading_pos on the
upstream class instead. Log.__init__ captures value=self.read_to_end
at construction, so binding takes effect for a vanilla Log() call;
no subclass, no @gr .render, no asset-path drift.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

app.py

@@ -139,56 +139,64 @@ def _cleanup_session_log(path: str | None) -> None:
         Path(path).unlink(missing_ok=True)
 
 
-class SessionLog(Log):
-    """gradio_log.Log variant that tails {LOG_DIR}/{session_hash}.log instead of
-    a single shared file. The base class polls read_to_end(session_hash) on a
-    timer (with the caller's own session_hash injected by Gradio), so deriving
-    the file path from that argument gives perfect per-session isolation —
-    without the @gr.render reshuffling that triggered KeyError: <fn_index> in
-    Gradio's queue when the Log was being re-rendered.
-    """
+# Per-session tailing patched onto gradio_log.Log.
+#
+# Why monkey-patch the upstream class instead of subclassing:
+#   1. @gr.render rebuilds the component on every state update, which shuffles
+#      Gradio's fn_index registry and triggers KeyError: <int> in the queue.
+#   2. Subclassing Log inside app.py changes the component's __module__, and
+#      Gradio's custom-component asset route serves templates/component/{js,css}
+#      relative to that module's directory — so the bundle 404s on HF Spaces
+#      where <app_dir>/templates/component/ doesn't exist.
+#   3. Log.__init__ captures `value=self.read_to_end` at construction, so
+#      patching the instance after the fact wouldn't change what the timer
+#      actually polls; we have to patch the class before any Log() call.
+def _session_path(session_hash: str) -> Path:
+    return LOG_DIR / f"{session_hash}.log"
+
+
+def _session_log_find_start(self: Log, path: Path) -> int:
+    with path.open("rb") as f:
+        f.seek(0, 2)
+        file_size = f.tell()
+        lines_found = 0
+        block_size = 1024
+        blocks: list[bytes] = []
+        while f.tell() > 0 and lines_found <= self.tail:
+            f.seek(max(f.tell() - block_size, 0))
+            block = f.read(block_size)
+            blocks.append(block)
+            lines_found += block.count(b"\n")
+            f.seek(-len(block), 1)
+        lines = b"".join(reversed(blocks)).splitlines()
+        if self.tail >= len(lines):
+            return 0
+        last_lines = b"\n".join(lines[-self.tail :])
+        return file_size - len(last_lines) - 1
+
+
+def _session_log_get_pos(self: Log, session_hash: str) -> int:
+    if session_hash not in self.current_reading_positions:
+        path = _session_path(session_hash)
+        self.current_reading_positions[session_hash] = (
+            _session_log_find_start(self, path) if path.exists() else 0
+        )
+    return self.current_reading_positions[session_hash]
+
+
+def _session_log_read_to_end(self: Log, session_hash: str) -> str:
+    path = _session_path(session_hash)
+    if not path.exists():
+        return ""
+    with path.open("rb") as f:
+        f.seek(_session_log_get_pos(self, session_hash))
+        data = f.read().decode()
+        self.current_reading_positions[session_hash] = f.tell()
+        return data
 
-    def _session_path(self, session_hash: str) -> Path:
-        return LOG_DIR / f"{session_hash}.log"
-
-    def _find_start_position(self, path: Path) -> int:
-        with path.open("rb") as f:
-            f.seek(0, 2)
-            file_size = f.tell()
-            lines_found = 0
-            block_size = 1024
-            blocks = []
-            while f.tell() > 0 and lines_found <= self.tail:
-                f.seek(max(f.tell() - block_size, 0))
-                block = f.read(block_size)
-                blocks.append(block)
-                lines_found += block.count(b"\n")
-                f.seek(-len(block), 1)
-            all_read_bytes = b"".join(reversed(blocks))
-            lines = all_read_bytes.splitlines()
-            if self.tail >= len(lines):
-                return 0
-            last_lines = b"\n".join(lines[-self.tail:])
-            return file_size - len(last_lines) - 1
-
-    def get_current_reading_pos(self, session_hash: str) -> int:
-        if session_hash not in self.current_reading_positions:
-            path = self._session_path(session_hash)
-            self.current_reading_positions[session_hash] = (
-                self._find_start_position(path) if path.exists() else 0
-            )
-        return self.current_reading_positions[session_hash]
 
-    def read_to_end(self, session_hash: str) -> str:
-        path = self._session_path(session_hash)
-        if not path.exists():
-            return ""
-        with path.open("rb") as f:
-            current_pos = self.get_current_reading_pos(session_hash)
-            f.seek(current_pos)
-            data = f.read().decode()
-            self.current_reading_positions[session_hash] = f.tell()
-            return data
+Log.get_current_reading_pos = _session_log_get_pos
+Log.read_to_end = _session_log_read_to_end
 
 
 def _resolve_device() -> None:
@@ -976,7 +984,7 @@ with gr.Blocks(
     session_log_path = gr.State(delete_callback=_cleanup_session_log)
 
     with gr.Accordion("Application Logs", open=True):
-        SessionLog(str(_LOG_PLACEHOLDER), dark=True, height=300)
+        Log(str(_LOG_PLACEHOLDER), dark=True, height=300)
 
 
     gr.Markdown(""" **Links:**