pywire 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pywire/runtime/compile_error_page.py

@@ -0,0 +1,195 @@
+import html
+import linecache
+import os
+import traceback
+from typing import Any, Dict, Optional, Union, cast
+
+from starlette.requests import Request
+from starlette.responses import HTMLResponse
+
+from pywire.compiler.exceptions import PyWireSyntaxError
+from pywire.runtime.page import BasePage
+
+
+class CompileErrorPage(BasePage):
+    """Page used to display compilation errors with helpful context.
+
+    Handles both PyWireSyntaxError (with known file/line) and generic
+    exceptions (extracting info from traceback).
+    """
+
+    def __init__(
+        self,
+        request: Request,
+        error: Union[PyWireSyntaxError, Exception],
+        file_path: Optional[str] = None,
+    ):
+        self.request = request
+        self.error = error
+        self._file_path = file_path
+        self.error_file: Optional[str] = None
+        self.error_line: Optional[int] = None
+
+        # Extract file/line info based on error type
+        if isinstance(error, PyWireSyntaxError):
+            self.error_file = error.file_path
+            self.error_line = error.line
+            self.error_message = error.message
+            self.traceback_lines = None  # No traceback for syntax errors
+        else:
+            # Generic exception - extract from traceback
+            self.error_message = f"{type(error).__name__}: {str(error)}"
+            self.traceback_lines = traceback.format_exception(
+                type(error), error, error.__traceback__
+            )
+
+            # Try to find the most relevant frame (last user code frame)
+            self.error_file = file_path
+            self.error_line = None
+            if error.__traceback__:
+                tb_summary = traceback.extract_tb(error.__traceback__)
+                for frame in reversed(tb_summary):
+                    # Prefer .pywire files
+                    if frame.filename.endswith(".pywire"):
+                        self.error_file = frame.filename
+                        self.error_line = frame.lineno
+                        break
+                    # Otherwise use last non-framework frame
+                    if (
+                        "pywire/src/pywire" not in frame.filename
+                        and "site-packages" not in frame.filename
+                    ):
+                        self.error_file = frame.filename
+                        self.error_line = frame.lineno
+                        break
+                # Fallback to last frame if nothing better found
+                if self.error_line is None and tb_summary:
+                    self.error_file = tb_summary[-1].filename
+                    self.error_line = tb_summary[-1].lineno
+
+    async def render(self, init: bool = True) -> HTMLResponse:
+        """Render the compile error page."""
+        # Read the context around the error line
+        context_lines = []
+        if self.error_file and self.error_line and os.path.exists(self.error_file):
+            try:
+                # Force cache update
+                linecache.checkcache(self.error_file)
+                lines = linecache.getlines(self.error_file)
+                start = max(1, self.error_line - 5)
+                end = min(len(lines), self.error_line + 5)
+
+                for i in range(start, end + 1):
+                    if i <= len(lines):
+                        context_lines.append(
+                            {
+                                "num": i,
+                                "content": lines[i - 1].rstrip(),
+                                "is_current": i == self.error_line,
+                            }
+                        )
+            except Exception:
+                pass
+
+        # Generate code context HTML
+        context_html = ""
+        for line in context_lines:
+            content = cast(str, line["content"])
+            cls = "line-current" if line["is_current"] else "line"
+            context_html += (
+                f"<div class='{cls}'><span class='line-num'>{line['num']}</span> "
+                f"<span class='code'>{html.escape(content)}</span></div>"
+            )
+
+        # Shorten file path for display
+        file_display = self.error_file or "unknown"
+        try:
+            cwd = os.getcwd()
+            if file_display.startswith(cwd):
+                file_display = os.path.relpath(file_display, cwd)
+        except Exception:
+            pass
+
+        # Error title based on type
+        if isinstance(self.error, PyWireSyntaxError):
+            error_title = "PyWire Syntax Error"
+        else:
+            error_title = "Compilation Error"
+
+        # Traceback section for generic exceptions
+        traceback_html = ""
+        if self.traceback_lines:
+            tb_text = "".join(self.traceback_lines)
+            traceback_html = f"""
+            <div class="traceback-section">
+                <h3>Full Traceback</h3>
+                <pre class="traceback">{html.escape(tb_text)}</pre>
+            </div>
+            """
+
+        content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>{error_title}</title>
+            <style>
+                body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI",
+                                     Roboto, sans-serif;
+                       background: #1a1a1a; color: #e0e0e0; margin: 0; padding: 20px; }}
+                h1 {{ color: #ff6b6b; font-size: 24px; margin-bottom: 5px; }}
+                h3 {{ color: #aaa; font-size: 16px; margin-top: 30px; margin-bottom: 10px; }}
+                .exc-msg {{ font-size: 16px; color: #fff; margin-bottom: 20px;
+                           white-space: pre-wrap; font-family: monospace;
+                           line-height: 1.6; }}
+                .container {{ max-width: 1000px; margin: 0 auto; }}
+                .error-location {{ background: #2d2d2d; border-radius: 8px; padding: 15px;
+                                 margin-bottom: 20px; border-left: 4px solid #ff6b6b; }}
+                .file-info {{ color: #ffd43b; font-family: monospace; font-size: 14px;
+                            margin-bottom: 10px; }}
+                .code-context {{ padding: 10px 0; background: #222; font-family: "Fira Code",
+                               monospace; font-size: 13px; overflow-x: auto; border-radius: 4px; }}
+                .line {{ padding: 2px 15px; color: #888; display: flex; }}
+                .line-current {{ padding: 2px 15px; background: #3c1e1e; color: #ffcccc;
+                               display: flex; border-left: 3px solid #ff6b6b; }}
+                .line-num {{ width: 40px; text-align: right; margin-right: 15px; opacity: 0.5;
+                           user-select: none; }}
+                .code {{ white-space: pre; }}
+                .traceback-section {{ margin-top: 20px; }}
+                .traceback {{ background: #222; padding: 15px; border-radius: 8px; font-size: 12px;
+                             overflow-x: auto; color: #ccc; white-space: pre-wrap;
+                             word-break: break-word; }}
+                .header-block {{ border-bottom: 1px solid #333; padding-bottom: 20px;
+                                margin-bottom: 20px; }}
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <div class="header-block">
+                    <h1>{error_title}</h1>
+                </div>
+
+                <div class="error-location">
+                    <div class="file-info">{html.escape(file_display)}{
+            ":" + str(self.error_line) if self.error_line else ""
+        }</div>
+                    <div class="exc-msg">{html.escape(self.error_message)}</div>
+                </div>
+
+                {
+            f'<div class="code-context">{context_html}</div>' if context_html else ""
+        }
+
+                {traceback_html}
+            </div>
+            <!-- Standard PyWire Client Script for Hot Reload -->
+            <script src="/_pywire/static/pywire.dev.min.js"></script>
+        </body>
+        </html>
+        """
+        return HTMLResponse(content)
+
+    async def handle_event(
+        self, handler_name: str, data: Dict[str, Any]
+    ) -> dict[str, Any]:
+        """No-op for error page."""
+        return await self.render_update(init=False)

pywire/runtime/debug.py

@@ -0,0 +1,203 @@
+import linecache
+import os
+import traceback
+import urllib.parse
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+from starlette.responses import HTMLResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from pywire.compiler.exceptions import PyWireSyntaxError
+
+
+class DevErrorMiddleware:
+    """
+    Middleware to catch exceptions and render a helpful debug page.
+    Active only in development mode.
+    """
+
+    def __init__(self, app: ASGIApp):
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:
+            # Check if headers already sent? Starlette handles this if we return Response?
+            # If we are midway through streaming, we might be in trouble, but for now catch all.
+            response = self.render_error_page(exc)
+            await response(scope, receive, send)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.app, name)
+
+    def render_error_page(self, exc: Exception) -> HTMLResponse:
+        # Check if this is a compile-time error
+        if isinstance(exc, PyWireSyntaxError):
+            return self._render_compile_error(exc)
+
+        exc_type = type(exc).__name__
+        exc_msg = str(exc)
+
+        # Get traceback
+        tb = exc.__traceback__
+
+        # Skip top-level framework frames to focus on user code/relevant calls
+        # (optional refinement)
+
+        frames = self._get_frames(tb)
+        is_framework_error = (
+            self._is_framework_error(frames[-1]["filename"]) if frames else False
+        )
+
+        html_content = self._generate_html(
+            exc_type, exc_msg, frames, is_framework_error
+        )
+        return HTMLResponse(html_content, status_code=500)
+
+    def _render_compile_error(self, exc: PyWireSyntaxError) -> HTMLResponse:
+        """Render a specialized error page for compile-time syntax errors."""
+        from pywire.runtime.error_renderer import render_template
+
+        # Script URL logic for 500 pages (usually dev mode)
+        script_url = "/_pywire/static/pywire.dev.min.js"
+        if hasattr(self.app, "state") and hasattr(self.app.state, "pywire"):
+            script_url = self.app.state.pywire._get_client_script_url()
+
+        # Context lines logic reused...
+        # (Alternatively, could we reuse CompileErrorPage?
+        # No, DevErrorMiddleware catches exceptions, CompileErrorPage is a page.
+        # But logic is identical. For now, copying logic for simplicity
+        # as CompileErrorPage might have different lifecycle).
+
+        context_lines_data = []
+        if exc.file_path and exc.line and os.path.exists(exc.file_path):
+            try:
+                linecache.checkcache(exc.file_path)
+                lines = linecache.getlines(exc.file_path)
+                start = max(1, exc.line - 5)
+                end = min(len(lines), exc.line + 5)
+
+                for i in range(start, end + 1):
+                    if i <= len(lines):
+                        context_lines_data.append(
+                            {
+                                "num": i,
+                                "content": lines[i - 1].rstrip(),
+                                "is_current": i == exc.line,
+                            }
+                        )
+            except Exception:
+                pass
+
+        short_path = (
+            self._shorten_path(exc.file_path) if exc.file_path else "unknown file"
+        )
+
+        html_content = render_template(
+            "error/compile_error.html",
+            {
+                "file_display": short_path,
+                "error_line": exc.line,
+                "error_message": exc.message,
+                "context_lines": context_lines_data,
+                "script_url": script_url,
+                "title": "PyWire Syntax Error",
+            },
+        )
+        return HTMLResponse(html_content, status_code=500)
+
+    def _get_frames(self, tb: Optional["TracebackType"]) -> List[Dict[str, Any]]:
+        frames = []
+        for frame, lineno in traceback.walk_tb(tb):
+            filename = frame.f_code.co_filename
+            func_name = frame.f_code.co_name
+            context = []
+
+            # Simple context reading for frames
+            try:
+                if os.path.exists(filename):
+                    # linecache handles reading
+                    start = max(1, lineno - 5)
+                    end = lineno + 5
+                    lines = linecache.getlines(filename)  # Will return [] if fails?
+                    if lines:
+                        for i in range(start, end + 1):
+                            if i <= len(lines):
+                                context.append(
+                                    {
+                                        "num": i,
+                                        "content": lines[i - 1].rstrip(),
+                                        "is_current": i == lineno,
+                                    }
+                                )
+            except Exception:
+                pass
+
+            frames.append(
+                {
+                    "filename": filename,
+                    "short_filename": self._shorten_path(filename),
+                    "func_name": func_name,
+                    "lineno": lineno,
+                    "context": context,
+                    "is_user_code": self._is_user_code(filename),
+                }
+            )
+        return frames
+
+    def _is_framework_error(self, filename: str) -> bool:
+        return "pywire/src/pywire" in filename or "site-packages/pywire" in filename
+
+    def _is_user_code(self, filename: str) -> bool:
+        return not self._is_framework_error(filename) and "<frozen" not in filename
+
+    def _shorten_path(self, path: str) -> str:
+        cwd = os.getcwd()
+        if path.startswith(cwd):
+            return os.path.relpath(path, cwd)
+        return path
+
+    def _generate_html(
+        self,
+        exc_type: str,
+        exc_msg: str,
+        frames: List[Dict[str, Any]],
+        is_framework_error: bool,
+    ) -> str:
+        from pywire.runtime.error_renderer import render_template
+
+        script_url = "/_pywire/static/pywire.dev.min.js"
+        if hasattr(self.app, "state") and hasattr(self.app.state, "pywire"):
+            script_url = self.app.state.pywire._get_client_script_url()
+
+        issue_title = urllib.parse.quote(f"Bug: {exc_type}: {exc_msg}")
+        issue_body = urllib.parse.quote(
+            f"### Description\nEncountered an error in PyWire.\n\n"
+            f"### Error\n`{exc_type}: {exc_msg}`\n\n### Traceback\n"
+            f"(Please paste relevant traceback here)"
+        )
+        github_url = f"https://github.com/pywire/pywire/issues/new?title={issue_title}&body={issue_body}"
+
+        return render_template(
+            "error/500.html",
+            {
+                "exc_type": exc_type,
+                "exc_msg": exc_msg,
+                "frames": frames,
+                "is_framework_error": is_framework_error,
+                "github_url": github_url,
+                "script_url": script_url,
+                "title": exc_type,
+            },
+        )
+
+
+# import urllib.parse  # Moved to top