streamlit-remote 0.7.0__tar.gz → 0.7.2__tar.gz

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-remote
-Version: 0.7.0
+Version: 0.7.2
 Summary: Run Streamlit apps with optional remote HTTPS access.
 Author: Yuichiro Tachibana (Tsuchiya)
 Author-email: Yuichiro Tachibana (Tsuchiya) <t.yic.yt@gmail.com>
@@ -94,6 +94,8 @@ Press `r` to restart only the Streamlit server while keeping the remote tunnel p
 
 Press `t` to toggle between the live terminal display and plain prefixed log output. When switching to plain output, `st-remote` replays recent logs into the normal terminal buffer so you can copy older logs from terminal or tmux history. You can also press `p` to force plain output and `f` to force the live terminal display. In terminals where single-key input is unavailable, the Enter-based commands still work.
 
+If Streamlit or the remote tunnel exits with an error while the live terminal display is active, `st-remote` returns to the normal terminal buffer and replays recent logs before exiting.
+
 Use Ctrl+C to stop both Streamlit and the remote tunnel.
 
 ## Local HTTPS

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/README.md

@@ -68,6 +68,8 @@ Press `r` to restart only the Streamlit server while keeping the remote tunnel p
 
 Press `t` to toggle between the live terminal display and plain prefixed log output. When switching to plain output, `st-remote` replays recent logs into the normal terminal buffer so you can copy older logs from terminal or tmux history. You can also press `p` to force plain output and `f` to force the live terminal display. In terminals where single-key input is unavailable, the Enter-based commands still work.
 
+If Streamlit or the remote tunnel exits with an error while the live terminal display is active, `st-remote` returns to the normal terminal buffer and replays recent logs before exiting.
+
 Use Ctrl+C to stop both Streamlit and the remote tunnel.
 
 ## Local HTTPS

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "streamlit-remote"
-version = "0.7.0"
+version = "0.7.2"
 description = "Run Streamlit apps with optional remote HTTPS access."
 readme = "README.md"
 license = "MIT"

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/src/streamlit_remote/cli.py

@@ -31,7 +31,7 @@ from streamlit_remote.providers.ngrok import (
     planned_managed_oauth_policy,
     prepare_managed_oauth_policy,
 )
-from streamlit_remote.runtime_display import make_runtime_display
+from streamlit_remote.runtime_display import STREAMLIT_SOURCE, make_runtime_display
 from streamlit_remote.server import LocalServerConfig, is_port_available, wait_until_listening
 
 
@@ -421,7 +421,16 @@ def run(namespace: argparse.Namespace) -> int:
 
     def start_streamlit_process() -> ManagedProcess:
         display.set_status("Streamlit", "starting")
-        return start_logged_process(streamlit_command, "streamlit", write_log=display.log)
+        streamlit_env: dict[str, str] = {}
+        streamlit_columns = display.streamlit_subprocess_columns()
+        if streamlit_columns is not None:
+            streamlit_env["COLUMNS"] = str(streamlit_columns)
+        return start_logged_process(
+            streamlit_command,
+            STREAMLIT_SOURCE,
+            write_log=display.log,
+            env=streamlit_env or None,
+        )
 
     def restart_streamlit_process(current_handle: ManagedProcess) -> ManagedProcess:
         display.set_status("Streamlit", "restarting")
@@ -483,11 +492,15 @@ def run(namespace: argparse.Namespace) -> int:
             streamlit_handle = restart_streamlit_process(current_handle)
             return streamlit_handle
 
+        def report_process_error(handle: ManagedProcess, returncode: int) -> None:
+            display.report_process_exit(handle.prefix, returncode)
+
         return supervise_processes(
             streamlit_handle,
             tunnel_handle,
             restart_requested,
             restart_and_track,
+            report_process_error=report_process_error,
             display_toggle_requested=display_toggle_requested,
             toggle_display=display.toggle_display,
             plain_output_requested=plain_output_requested,
@@ -662,6 +675,7 @@ def supervise_processes(
     restart_requested: threading.Event,
     restart_streamlit: Callable[[ManagedProcess], ManagedProcess],
     poll_interval: float = 0.2,
+    report_process_error: Callable[[ManagedProcess, int], None] | None = None,
     display_toggle_requested: threading.Event | None = None,
     toggle_display: Callable[[], bool] | None = None,
     plain_output_requested: threading.Event | None = None,
@@ -695,20 +709,25 @@ def supervise_processes(
             continue
 
         if tunnel_handle is not None and tunnel_handle.process.poll() is not None:
-            if tunnel_handle.process.returncode is not None:
-                return tunnel_handle.process.returncode
-            return 1
+            return report_process_returncode(tunnel_handle, report_process_error)
 
         if current_streamlit_handle.process.poll() is not None:
-            return (
-                current_streamlit_handle.process.returncode
-                if current_streamlit_handle.process.returncode is not None
-                else 1
-            )
+            return report_process_returncode(current_streamlit_handle, report_process_error)
 
         time.sleep(poll_interval)
 
 
+def report_process_returncode(
+    handle: ManagedProcess,
+    report_process_error: Callable[[ManagedProcess, int], None] | None,
+) -> int:
+    returncode = handle.process.returncode if handle.process.returncode is not None else 1
+    if returncode != 0 and report_process_error is not None:
+        handle.output_thread.join(timeout=1.0)
+        report_process_error(handle, returncode)
+    return returncode
+
+
 def prepare_cli_https_material(namespace: argparse.Namespace) -> HttpsMaterial | None:
     if namespace.dry_run and namespace.https_mode == "self-signed":
         return planned_self_signed_material(namespace.host)

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/src/streamlit_remote/process.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 import subprocess
 import threading
 import time
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import suppress
 from dataclasses import dataclass
+from os import environ
 
 LineHandler = Callable[[str], None]
 LinePredicate = Callable[[str], bool]
@@ -25,7 +26,13 @@ def start_logged_process(
     on_line: LineHandler | None = None,
     should_print_line: LinePredicate | None = None,
     write_log: LogWriter | None = None,
+    env: Mapping[str, str] | None = None,
 ) -> ManagedProcess:
+    process_env = None
+    if env is not None:
+        process_env = environ.copy()
+        process_env.update(env)
+
     process = subprocess.Popen(
         list(command),
         stdout=subprocess.PIPE,
@@ -34,6 +41,7 @@ def start_logged_process(
         encoding="utf-8",
         errors="replace",
         bufsize=1,
+        env=process_env,
     )
 
     def pump_output() -> None:

{streamlit_remote-0.7.0 → streamlit_remote-0.7.2}/src/streamlit_remote/runtime_display.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 import sys
 import threading
 from collections import deque
@@ -12,6 +13,9 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+STREAMLIT_SOURCE = "streamlit"
+
 
 class RuntimeDisplay(Protocol):
     def start(self) -> None: ...
@@ -24,6 +28,8 @@ class RuntimeDisplay(Protocol):
 
     def toggle_display(self) -> bool: ...
 
+    def report_process_exit(self, source: str, returncode: int) -> None: ...
+
     def set_local_url(self, url: str) -> None: ...
 
     def set_remote_url(self, url: str) -> None: ...
@@ -32,6 +38,8 @@ class RuntimeDisplay(Protocol):
 
     def set_shortcuts_visible(self, visible: bool) -> None: ...
 
+    def streamlit_subprocess_columns(self) -> int | None: ...
+
     def info(self, message: str) -> None: ...
 
     def error(self, message: str) -> None: ...
@@ -59,6 +67,9 @@ class PlainRuntimeDisplay(RuntimeDisplay):
     def toggle_display(self) -> bool:
         return False
 
+    def report_process_exit(self, source: str, returncode: int) -> None:
+        self.error(f"error: {source} exited with code {returncode}.")
+
     def set_local_url(self, url: str) -> None:
         self.info("Streamlit local URL:")
         self.info(f"  {url}")
@@ -75,6 +86,9 @@ class PlainRuntimeDisplay(RuntimeDisplay):
             self.info("Runtime shortcuts:")
             self.info("  r: restart Streamlit while keeping the tunnel running")
 
+    def streamlit_subprocess_columns(self) -> int | None:
+        return None
+
     def info(self, message: str) -> None:
         print(message, file=self._output, flush=True)
 
@@ -92,6 +106,7 @@ class RichRuntimeDisplay(RuntimeDisplay):
     _PANEL_HORIZONTAL_OVERHEAD = 4
     _LOG_SOURCE_WIDTH = 11
     _LOG_SOURCE_SEPARATOR_WIDTH = 1
+    _RICH_TRACEBACK_CHARS = frozenset("╭╮╰╯│─")
 
     def __init__(
         self,
@@ -137,6 +152,9 @@ class RichRuntimeDisplay(RuntimeDisplay):
     def toggle_display(self) -> bool:
         return False
 
+    def report_process_exit(self, source: str, returncode: int) -> None:
+        pass
+
     def set_local_url(self, url: str) -> None:
         with self._lock:
             self._local_url = url
@@ -157,6 +175,11 @@ class RichRuntimeDisplay(RuntimeDisplay):
             self._shortcuts_visible = visible
             self._refresh()
 
+    def streamlit_subprocess_columns(self) -> int | None:
+        # Streamlit formats Rich tracebacks before we can render them without a
+        # source prefix, so give it the prefix-less log panel width.
+        return self._log_panel_content_width()
+
     def info(self, message: str) -> None:
         self.log("st-remote", message)
 
@@ -242,9 +265,13 @@ class RichRuntimeDisplay(RuntimeDisplay):
 
         lines = Text()
         visible_logs = self._visible_logs(panel_height=panel_height)
+        raw_traceback_indexes = self._raw_streamlit_traceback_indexes(visible_logs)
         for index, (source, line) in enumerate(visible_logs):
-            lines.append(f"{source:>11} ", style=self._source_style(source))
-            lines.append(self._format_log_line(line))
+            if index in raw_traceback_indexes:
+                lines.append(self._format_raw_streamlit_traceback_line(line))
+            else:
+                lines.append(f"{source:>11} ", style=self._source_style(source))
+                lines.append(self._format_log_line(line, width=self._log_line_width()))
             if index < len(visible_logs) - 1:
                 lines.append("\n")
         return Panel(lines, title="Logs", height=panel_height)
@@ -252,24 +279,142 @@ class RichRuntimeDisplay(RuntimeDisplay):
     def _visible_logs(self, *, panel_height: int | None = None) -> list[tuple[str, str]]:
         log_panel_height = panel_height or self._layout_heights()[1]
         available_rows = max(1, log_panel_height - self._PANEL_FRAME_ROWS)
-        return list(self._logs)[-available_rows:]
+        logs = self._move_interleaved_logs_after_tracebacks(list(self._logs))
+        return self._select_visible_logs(logs, available_rows=available_rows)
 
-    def _format_log_line(self, line: str) -> str:
+    def _select_visible_logs(
+        self,
+        logs: list[tuple[str, str]],
+        *,
+        available_rows: int,
+    ) -> list[tuple[str, str]]:
+        if len(logs) <= available_rows:
+            return logs
+
+        traceback_spans = self._streamlit_traceback_spans(logs)
+        traceback_span = traceback_spans[-1] if traceback_spans else None
+        if traceback_span is None:
+            return logs[-available_rows:]
+
+        start, end = traceback_span
+        if any(source == STREAMLIT_SOURCE for source, _ in logs[end:]):
+            return logs[-available_rows:]
+
+        traceback_logs = logs[start:end]
+        if len(traceback_logs) >= available_rows:
+            return traceback_logs[-available_rows:]
+
+        following_rows = available_rows - len(traceback_logs)
+        following_logs = logs[end:][-following_rows:] if following_rows else []
+        selected_logs = [*traceback_logs, *following_logs]
+
+        preceding_rows = available_rows - len(selected_logs)
+        if preceding_rows:
+            selected_logs = [*logs[:start][-preceding_rows:], *selected_logs]
+        return selected_logs
+
+    def _move_interleaved_logs_after_tracebacks(
+        self,
+        logs: list[tuple[str, str]],
+    ) -> list[tuple[str, str]]:
+        arranged_logs: list[tuple[str, str]] = []
+        deferred_logs: list[tuple[str, str]] = []
+        in_streamlit_traceback = False
+
+        for source, line in logs:
+            if self._is_streamlit_traceback_marker(source, line):
+                in_streamlit_traceback = True
+                arranged_logs.append((source, line))
+            elif in_streamlit_traceback and source != STREAMLIT_SOURCE:
+                deferred_logs.append((source, line))
+            else:
+                arranged_logs.append((source, line))
+
+        arranged_logs.extend(deferred_logs)
+        return arranged_logs
+
+    def _raw_streamlit_traceback_indexes(self, logs: list[tuple[str, str]]) -> set[int]:
+        raw_indexes: set[int] = set()
+        for start, end in self._streamlit_traceback_spans(logs):
+            raw_indexes.update(range(start, end))
+        return raw_indexes
+
+    def _streamlit_traceback_spans(self, logs: list[tuple[str, str]]) -> list[tuple[int, int]]:
+        marker_indexes = [
+            index
+            for index, (source, line) in enumerate(logs)
+            if self._is_streamlit_traceback_marker(source, line)
+        ]
+        spans: list[tuple[int, int]] = []
+        for marker_index in marker_indexes:
+            start = marker_index
+            while start > 0 and logs[start - 1][0] == STREAMLIT_SOURCE:
+                start -= 1
+
+            end = marker_index + 1
+            while end < len(logs) and logs[end][0] == STREAMLIT_SOURCE:
+                end += 1
+
+            if spans and start <= spans[-1][1]:
+                spans[-1] = (spans[-1][0], max(spans[-1][1], end))
+            else:
+                spans.append((start, end))
+        return spans
+
+    def _is_streamlit_traceback_marker(self, source: str, line: str) -> bool:
+        if source != STREAMLIT_SOURCE:
+            return False
+        return any(char in _ANSI_ESCAPE_RE.sub("", line) for char in self._RICH_TRACEBACK_CHARS)
+
+    def _format_raw_streamlit_traceback_line(self, line: str) -> Text:
+        text = Text.from_ansi(line)
+        plain = text.plain
+        start = 0
+        end = len(plain)
+
+        leading_border_match = re.match(r"^\s*│ ?", plain)
+        if leading_border_match is not None:
+            start = leading_border_match.end()
+
+        trailing_border_match = re.search(r"\s+│\s*$", plain)
+        if trailing_border_match is not None and trailing_border_match.start() >= start:
+            end = trailing_border_match.start()
+
+        end = min(end, len(plain[:end].rstrip()))
+        formatted_text = text[start:end]
+        return self._format_raw_streamlit_traceback_text(formatted_text)
+
+    def _format_raw_streamlit_traceback_text(self, text: Text) -> Text:
+        width = self._log_panel_content_width()
+        formatted_text = text.copy()
+        if len(formatted_text.plain) > width:
+            if width <= 3:
+                formatted_text = Text("." * width)
+            else:
+                formatted_text = formatted_text[: width - 3]
+                formatted_text.append("...")
+        formatted_text.pad_right(width - len(formatted_text.plain))
+        return formatted_text
+
+    def _format_log_line(self, line: str, *, width: int) -> str:
         line = line.replace("\n", r"\n").replace("\r", r"\r")
-        line_width = self._log_line_width()
-        if len(line) <= line_width:
+        if len(line) <= width:
             return line
-        if line_width <= 3:
-            return "." * line_width
-        return f"{line[: line_width - 3]}..."
+        if width <= 3:
+            return "." * width
+        return f"{line[: width - 3]}..."
 
     def _log_line_width(self) -> int:
-        content_width = self._console.size.width - self._PANEL_HORIZONTAL_OVERHEAD
         return max(
             1,
-            content_width - self._LOG_SOURCE_WIDTH - self._LOG_SOURCE_SEPARATOR_WIDTH,
+            self._log_panel_content_width()
+            - self._LOG_SOURCE_WIDTH
+            - self._LOG_SOURCE_SEPARATOR_WIDTH,
         )
 
+    def _log_panel_content_width(self) -> int:
+        return max(1, self._console.size.width - self._PANEL_HORIZONTAL_OVERHEAD)
+
     def _render_shortcuts_panel(self, *, height: int | None = None) -> Panel:
         if not self._shortcuts_visible:
             return Panel(
@@ -288,7 +433,7 @@ class RichRuntimeDisplay(RuntimeDisplay):
         return Panel(shortcuts, title="Shortcuts", border_style="green", height=height)
 
     def _source_style(self, source: str) -> str:
-        if source == "streamlit":
+        if source == STREAMLIT_SOURCE:
             return "blue"
         if source in {"cloudflared", "ngrok"}:
             return "magenta"
@@ -381,6 +526,24 @@ class SwitchableRuntimeDisplay(RuntimeDisplay):
                 return self.switch_to_plain()
             return self.switch_to_rich()
 
+    def report_process_exit(self, source: str, returncode: int) -> None:
+        with self._lock:
+            if self._active_display is self._plain_display:
+                self._plain_display.report_process_exit(source, returncode)
+                return
+
+            was_started = self._started
+            if was_started:
+                self._rich_display.stop()
+            self._active_display = self._plain_display
+            if was_started:
+                self._plain_display.start()
+
+            self._plain_display.report_process_exit(source, returncode)
+            self._plain_display.info("Recent logs:")
+            for log_source, line in self._logs:
+                self._plain_display.log(log_source, line)
+
     def set_local_url(self, url: str) -> None:
         with self._lock:
             self._local_url = url
@@ -401,6 +564,10 @@ class SwitchableRuntimeDisplay(RuntimeDisplay):
             self._shortcuts_visible = visible
             self._active_display.set_shortcuts_visible(visible)
 
+    def streamlit_subprocess_columns(self) -> int | None:
+        with self._lock:
+            return self._active_display.streamlit_subprocess_columns()
+
     def info(self, message: str) -> None:
         with self._lock:
             self._logs.append(("st-remote", message))