pywire 0.1.0__py3-none-any.whl

pywire/runtime/error_page.py

@@ -0,0 +1,64 @@
+from typing import Any, Dict
+
+from starlette.requests import Request
+from starlette.responses import HTMLResponse
+
+from pywire.runtime.page import BasePage
+
+
+class ErrorPage(BasePage):
+    """Page used to display compilation errors."""
+
+    def __init__(self, request: Request, error_title: str, error_detail: str):
+        # Initialize base directly without calling super().__init__ completely
+        # because we don't have all the normal params
+        self.request = request
+        self.error_title = error_title
+        self.error_detail = error_detail
+
+    async def render(self, init: bool = True) -> HTMLResponse:
+        """Render the error page."""
+        from pywire.runtime.error_renderer import render_template
+
+        # Determine script URL (handled in app or passed here?)
+        # For now, default to dev script as ErrorPage is mostly used in dev/mixed?
+        # Actually app._get_client_script_url handles this logic, but we don't always have app ref here.
+        # But wait, ErrorPage is usually instantiated by app or similar.
+        # Let's check constructor. It takes request. We can get app from request.app usually if Starlette?
+        # request.app is available.
+
+        script_url = "/_pywire/static/pywire.core.min.js"
+        if hasattr(self.request, "app") and hasattr(
+            self.request.app, "_get_client_script_url"
+        ):
+            # Use the private method if available (a bit hacky but correct for PyWire app)
+            # Or check debug mode directly
+            pass
+
+        # Actually, simpler: check if we are in dev mode via request.app.state if set?
+        # The prompt mentioned "attach the correct script based on the environment".
+        # PyWire app sets self.app.state.pywire = self.
+
+        try:
+            pywire_app = self.request.app.state.pywire
+            script_url = pywire_app._get_client_script_url()
+        except (AttributeError, KeyError):
+            # Fallback
+            script_url = "/_pywire/static/pywire.dev.min.js"
+
+        html_content = render_template(
+            "error/404.html",
+            {
+                "title": self.error_title,
+                "message": self.error_detail or "",
+                "script_url": script_url,
+            },
+        )
+
+        return HTMLResponse(html_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/error_renderer.py

@@ -0,0 +1,23 @@
+from typing import Any, Dict
+
+from jinja2 import Environment, PackageLoader, select_autoescape
+
+# Initialize templating environment for internal error pages
+_env = Environment(
+    loader=PackageLoader("pywire", "templates"),
+    autoescape=select_autoescape(["html", "xml"]),
+)
+
+
+def render_template(template_name: str, context: Dict[str, Any]) -> str:
+    """Render a Jinja2 template with the given context.
+
+    Args:
+        template_name: Name of the template relative to src/pywire/templates/
+        context: Dictionary of variables to pass to the template
+
+    Returns:
+        Rendered HTML string
+    """
+    template = _env.get_template(template_name)
+    return template.render(**context)

pywire/runtime/escape.py

@@ -0,0 +1,23 @@
+"""HTML escaping utilities for XSS prevention."""
+
+from typing import Any
+
+
+def escape_html(value: Any) -> str:
+    """Escape HTML special characters to prevent XSS.
+
+    Escapes: & < > "
+
+    Args:
+        value: Any value to escape (will be converted to string first)
+
+    Returns:
+        HTML-escaped string safe for embedding in HTML content
+    """
+    s = str(value)
+    return (
+        s.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+        .replace('"', "&quot;")
+    )

pywire/runtime/files.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class FileUpload:
+    """Represents an uploaded file."""
+
+    filename: str
+    content_type: str
+    size: int
+    content: bytes
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FileUpload":
+        """Create from dictionary (e.g. from JSON payload)."""
+        import base64
+
+        # content might be base64 encoded string from client
+        content_data = data.get("content", b"")
+        if isinstance(content_data, str):
+            # assume base64 if it's a string, or raw content?
+            # Client usually sends data URL: "data:image/png;base64,....."
+            if content_data.startswith("data:"):
+                header, encoded = content_data.split(",", 1)
+                content_bytes = base64.b64decode(encoded)
+            else:
+                # Fallback or raw base64
+                try:
+                    content_bytes = base64.b64decode(content_data)
+                except Exception:
+                    content_bytes = content_data.encode("utf-8")
+        else:
+            content_bytes = content_data
+
+        return cls(
+            filename=data.get("name", "unknown"),
+            content_type=data.get("type", "application/octet-stream"),
+            size=data.get("size", 0),
+            content=content_bytes,
+        )

pywire/runtime/helpers.py

@@ -0,0 +1,97 @@
+from typing import Any, AsyncIterator
+
+from pywire.core.wire import (
+    reset_render_context as _reset_render_context,
+    set_render_context as _set_render_context,
+)
+
+
+async def ensure_async_iterator(iterable: Any) -> AsyncIterator[Any]:
+    """
+    Ensure an iterable is an async iterator.
+    Handles both sync iterables (list, etc.) and async iterables.
+    """
+    if hasattr(iterable, "__aiter__"):
+        async for item in iterable:
+            yield item
+    elif hasattr(iterable, "__iter__"):
+        for item in iterable:
+            yield item
+    else:
+        # Fallback or error?
+        # Maybe it's a generator?
+        # If it's not iterable at all, standard for loop raises TypeError.
+        # We should probably let it raise, or wrapping non-iterable?
+        for item in iterable:  # This will raise if not iterable
+            yield item
+
+
+def set_render_context(page: Any, region_id: str) -> Any:
+    return _set_render_context(page, region_id)
+
+
+def reset_render_context(token: Any) -> None:
+    _reset_render_context(token)
+
+
+def unwrap_wire(value: Any) -> Any:
+    """Return the underlying value for single-value wires; passthrough otherwise."""
+    from pywire.core.wire import wire
+
+    if isinstance(value, wire):
+        if value.__dict__.get("_namespace"):
+            return value
+        return value.value
+    return value
+
+
+def render_attrs(
+    defined_attrs: dict[str, Any], spread_attrs: dict[str, Any] | None = None
+) -> str:
+    """
+    Merge and render HTML attributes.
+    defined_attrs: Attributes defined in the template (explicitly).
+    spread_attrs: Attributes passed to the component (implicit/explicit spread).
+    Rules:
+    - spread_attrs override defined_attrs, EXCEPT:
+    - class: merged (appended).
+    - style: merged (concatenated).
+    """
+    if not spread_attrs:
+        spread_attrs = {}
+
+    # Copy defined_attrs to start
+    final_attrs = defined_attrs.copy()
+
+    for k, v in spread_attrs.items():
+        if k == "class" and "class" in final_attrs:
+            final_attrs["class"] = f"{final_attrs['class']} {v}".strip()
+        elif k == "style" and "style" in final_attrs:
+            # Naive style merge: concat with semicolon if missing
+            s1 = str(final_attrs["style"]).strip()
+            s2 = str(v).strip()
+            if s1 and not s1.endswith(";"):
+                s1 += ";"
+            final_attrs["style"] = f"{s1} {s2}".strip()
+        else:
+            final_attrs[k] = v
+
+    # Render
+    parts = []
+    for k, v in final_attrs.items():
+        if v is True:  # bool attr
+            parts.append(f" {k}")
+        elif v is False or v is None:
+            continue
+        else:
+            # Escape HTML special characters in attribute values for XSS prevention
+            val = (
+                str(v)
+                .replace("&", "&")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace('"', "&quot;")
+            )
+            parts.append(f' {k}="{val}"')
+
+    return "".join(parts)

pywire/runtime/http_transport.py

@@ -0,0 +1,253 @@
+"""HTTP transport handler for PyWire fallback."""
+
+import asyncio
+import inspect
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional
+
+import msgpack
+from starlette.requests import Request
+from starlette.responses import Response
+
+from pywire.runtime.page import BasePage
+
+
+@dataclass
+class HTTPSession:
+    """Represents an HTTP polling session."""
+
+    session_id: str
+    path: str
+    page: Optional[BasePage] = None
+    pending_updates: List[Dict[str, Any]] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    last_poll: datetime = field(default_factory=datetime.now)
+    update_event: asyncio.Event = field(default_factory=asyncio.Event)
+
+    def is_expired(self, timeout_seconds: int = 300) -> bool:
+        """Check if session has expired."""
+        return datetime.now() - self.last_poll > timedelta(seconds=timeout_seconds)
+
+
+class HTTPTransportHandler:
+    """Handles HTTP long-polling connections for PyWire fallback transport."""
+
+    def __init__(self, app: Any) -> None:
+        self.app = app
+        self.sessions: Dict[str, HTTPSession] = {}
+        self._cleanup_task: Optional[asyncio.Task] = None
+
+    def start_cleanup_task(self) -> None:
+        """Start background task to clean up expired sessions."""
+        if self._cleanup_task is None:
+            self._cleanup_task = asyncio.create_task(self._cleanup_loop())
+
+    async def _cleanup_loop(self) -> None:
+        """Periodically clean up expired sessions."""
+        while True:
+            await asyncio.sleep(60)  # Check every minute
+            expired = [
+                sid for sid, session in self.sessions.items() if session.is_expired()
+            ]
+            for sid in expired:
+                del self.sessions[sid]
+            if expired:
+                print(f"PyWire: Cleaned up {len(expired)} expired HTTP sessions")
+
+    async def create_session(self, request: Request) -> Response:
+        """Create a new HTTP polling session."""
+        try:
+            body = await request.body()
+            if not body:
+                # Allow empty body for initial connect
+                data = {}
+            else:
+                try:
+                    data = msgpack.unpackb(body, raw=False)
+                except Exception:
+                    # Fallback to JSON for compatibility if needed, or error
+                    import json
+
+                    data = json.loads(body)
+
+            path = data.get("path", "/")
+        except Exception:
+            path = "/"
+
+        session_id = str(uuid.uuid4())
+        session = HTTPSession(session_id=session_id, path=path)
+
+        # Try to instantiate the page for this session
+        match = self.app.router.match(path)
+        if match:
+            page_class, params, variant_name = match
+            query = dict(request.query_params)
+
+            # Build path info dict
+            path_info = {}
+            if hasattr(page_class, "__routes__"):
+                for name in page_class.__routes__.keys():
+                    path_info[name] = name == variant_name
+            elif hasattr(page_class, "__route__"):
+                path_info["main"] = True
+
+            # Build URL helper
+            from pywire.runtime.router import URLHelper
+
+            url_helper = None
+            if hasattr(page_class, "__routes__"):
+                url_helper = URLHelper(page_class.__routes__)
+
+            session.page = page_class(
+                request, params, query, path=path_info, url=url_helper
+            )
+
+            if hasattr(self.app, "get_user"):
+                session.page.user = self.app.get_user(request)
+
+            # Run load hook
+            if hasattr(session.page, "on_load"):
+                if inspect.iscoroutinefunction(session.page.on_load):
+                    await session.page.on_load()
+                else:
+                    session.page.on_load()
+
+        self.sessions[session_id] = session
+        self.start_cleanup_task()
+
+        return Response(
+            msgpack.packb({"sessionId": session_id}), media_type="application/x-msgpack"
+        )
+
+    async def poll(self, request: Request) -> Response:
+        """Long-poll for updates."""
+        session_id = request.query_params.get("session")
+
+        if not session_id or session_id not in self.sessions:
+            return Response(
+                msgpack.packb({"error": "Session not found"}),
+                status_code=404,
+                media_type="application/x-msgpack",
+            )
+
+        session = self.sessions[session_id]
+        session.last_poll = datetime.now()
+
+        # Check if updates already pending
+        if session.pending_updates:
+            updates = session.pending_updates.copy()
+            session.pending_updates.clear()
+            session.update_event.clear()
+            return Response(msgpack.packb(updates), media_type="application/x-msgpack")
+
+        # Wait for updates with timeout
+        try:
+            await asyncio.wait_for(session.update_event.wait(), timeout=30.0)
+
+            # Event set, get updates
+            updates = session.pending_updates.copy()
+            session.pending_updates.clear()
+            session.update_event.clear()
+            return Response(msgpack.packb(updates), media_type="application/x-msgpack")
+
+        except asyncio.TimeoutError:
+            # Return empty array on timeout
+            return Response(msgpack.packb([]), media_type="application/x-msgpack")
+
+    async def handle_event(self, request: Request) -> Response:
+        """Handle an event from an HTTP client."""
+        session_id = request.headers.get("X-PyWire-Session")
+
+        if not session_id or session_id not in self.sessions:
+            return Response(
+                msgpack.packb({"error": "Session not found"}),
+                status_code=404,
+                media_type="application/x-msgpack",
+            )
+
+        session = self.sessions[session_id]
+        session.last_poll = datetime.now()
+
+        try:
+            body = await request.body()
+            data = msgpack.unpackb(body, raw=False)
+            handler_name = data.get("handler")
+            event_data = data.get("data", {})
+
+            if session.page is None:
+                # Recreate page if needed
+                match = self.app.router.match(session.path)
+                if not match:
+                    return Response(
+                        msgpack.packb({"error": "Page not found"}),
+                        status_code=404,
+                        media_type="application/x-msgpack",
+                    )
+
+                page_class, params, variant_name = match
+                query = dict(request.query_params)
+
+                # Build path info dict
+                path_info = {}
+                if hasattr(page_class, "__routes__"):
+                    for name in page_class.__routes__.keys():
+                        path_info[name] = name == variant_name
+                elif hasattr(page_class, "__route__"):
+                    path_info["main"] = True
+
+                # Build URL helper
+                from pywire.runtime.router import URLHelper
+
+                url_helper = None
+                if hasattr(page_class, "__routes__"):
+                    url_helper = URLHelper(page_class.__routes__)
+
+                session.page = page_class(
+                    request, params, query, path=path_info, url=url_helper
+                )
+
+                # Run load hook
+                if hasattr(session.page, "on_load"):
+                    if inspect.iscoroutinefunction(session.page.on_load):
+                        await session.page.on_load()
+                    else:
+                        session.page.on_load()
+
+            # Dispatch event
+            update = await session.page.handle_event(handler_name, event_data)
+
+            if isinstance(update, Response):
+                html = bytes(update.body).decode("utf-8")
+                payload: Dict[str, Any] = {"type": "update", "html": html}
+            elif isinstance(update, dict) and update.get("type") == "regions":
+                payload = {"type": "update", "regions": update.get("regions", [])}
+            elif isinstance(update, dict) and update.get("type") == "full":
+                payload = {"type": "update", "html": update.get("html", "")}
+            else:
+                payload = {"type": "error", "error": "Invalid update payload"}
+
+            return Response(
+                msgpack.packb(payload),
+                media_type="application/x-msgpack",
+            )
+
+        except Exception as e:
+            return Response(
+                msgpack.packb({"type": "error", "error": str(e)}),
+                status_code=500,
+                media_type="application/x-msgpack",
+            )
+
+    def queue_update(self, session_id: str, update: Dict[str, Any]) -> None:
+        """Queue an update to be sent to a specific session."""
+        if session_id in self.sessions:
+            self.sessions[session_id].pending_updates.append(update)
+            self.sessions[session_id].update_event.set()
+
+    def broadcast_reload(self) -> None:
+        """Queue reload message to all sessions."""
+        for session in self.sessions.values():
+            session.pending_updates.append({"type": "reload"})
+            session.update_event.set()