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

pywire/runtime/compile_error_page.py

@@ -1,195 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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