pywire 0.1.0__py3-none-any.whl

pywire/compiler/paths.py

@@ -0,0 +1,29 @@
+"""Helpers for PyWire filesystem paths."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def ensure_pywire_folder() -> Path:
+    """Ensure .pywire exists and has a local .gitignore."""
+    dot_pywire = Path(".pywire")
+    if not dot_pywire.exists():
+        dot_pywire.mkdir()
+
+    gitignore_path = dot_pywire / ".gitignore"
+    if not gitignore_path.exists():
+        gitignore_path.write_text("*")
+
+    return dot_pywire
+
+
+def get_pywire_path(*parts: str) -> Path:
+    """Return a path inside .pywire/."""
+    dot_pywire = ensure_pywire_folder()
+    return dot_pywire.joinpath(*parts)
+
+
+def get_build_path(*parts: str) -> Path:
+    """Return a path inside .pywire/build/."""
+    return get_pywire_path("build", *parts)

pywire/compiler/preprocessor.py

@@ -0,0 +1,43 @@
+import re
+
+
+def preprocess_python_code(code: str) -> str:
+    """
+    Pre-process Python code to handle custom PyWire syntax ($var -> var.value).
+
+    This function replaces usage of the '$' prefix on identifiers with the '.value' suffix access,
+    which is the standard way to access PyWire 'wire' primitives.
+
+    Example:
+        $count += 1  ->  count.value += 1
+
+    It respects Python string boundaries (single and triple quoted) to avoid replacing
+    text inside strings.
+    """
+    # Pattern matches:
+    # Group 1: Strings (Triple double, Triple single, Double, Single)
+    # Group 2: The $ token
+    # Group 3: The identifier
+
+    # We use non-capturing groups (?:...) for internal parts of string patterns to verify content
+    # Triple quoted strings can contain newlines ([\s\S]*?)
+    # Single quoted strings cannot contain unescaped newlines (not matching \n)
+
+    pattern = (
+        r"(\"\"\"[\s\S]*?\"\"\"|'''[\s\S]*?'''|"  # Triple quoted strings
+        r"\"(?:\\.|[^\\\"\n])*\"|'(?:\\.|[^\\'\n])*')|"  # Single quoted strings
+        r"(\$)([a-zA-Z_]\w*)"  # The syntax we want to replace
+    )
+
+    def replacer(match):
+        # If it matched a string (Group 1), return it unchanged
+        if match.group(1):
+            return match.group(1)
+
+        # If it matched our syntax ($ + Identifier)
+        if match.group(2) and match.group(3):
+            return f"{match.group(3)}.value"
+
+        return match.group(0)
+
+    return re.sub(pattern, replacer, code, flags=re.MULTILINE)

pywire/core/wire.py

@@ -0,0 +1,119 @@
+from contextvars import ContextVar
+from typing import TypeVar, Generic, Any, Optional, Tuple, cast
+from weakref import WeakSet
+
+T = TypeVar("T")
+
+_render_context: ContextVar[Optional[Tuple[Any, str]]] = ContextVar(
+    "pywire_render_context", default=None
+)
+
+
+def set_render_context(page: Any, region_id: str) -> Any:
+    return _render_context.set((page, region_id))
+
+
+def reset_render_context(token: Any) -> None:
+    _render_context.reset(token)
+
+
+class wire(Generic[T]):
+    """
+    A reactive container for state.
+
+    Usage:
+        # Single value
+        count = wire(0)
+        count.value += 1
+
+        # Namespace
+        user = wire(name="Alice", age=30)
+        user.name = "Bob"
+    """
+
+    def __init__(self, value: Optional[T] = None, **kwargs):
+        # We use strict dict manipulation to avoid triggering __setattr__
+        self.__dict__["_value"] = value
+        self.__dict__["_namespace"] = kwargs
+        self.__dict__["_pages"] = WeakSet()
+
+    def _track_read(self, field: str) -> None:
+        ctx = _render_context.get()
+        if not ctx:
+            return
+        page, region_id = ctx
+        pages = cast(WeakSet[Any], self.__dict__.get("_pages"))
+        if pages is not None:
+            pages.add(page)
+        register = getattr(page, "_register_wire_read", None)
+        if register:
+            register(self, field, region_id)
+
+    def _notify_write(self, field: str) -> None:
+        pages = cast(WeakSet[Any], self.__dict__.get("_pages"))
+        if not pages:
+            return
+        for page in list(pages):
+            invalidate = getattr(page, "_invalidate_wire", None)
+            if invalidate:
+                invalidate(self, field)
+
+    @property
+    def value(self) -> T:
+        """Access the underlying value."""
+        # strict priority: if 'value' is in namespace, return that.
+        # otherwise return the positional value.
+        if "value" in self.__dict__["_namespace"]:
+            self._track_read("value")
+            return self.__dict__["_namespace"]["value"]
+        self._track_read("value")
+        return self.__dict__["_value"]
+
+    @value.setter
+    def value(self, new_val: T):
+        if "value" in self.__dict__["_namespace"]:
+            self.__dict__["_namespace"]["value"] = new_val
+        else:
+            self.__dict__["_value"] = new_val
+        self._notify_write("value")
+
+    # Alias for shorter typing, if desired.
+    @property
+    def val(self) -> T:
+        return self.value
+
+    @val.setter
+    def val(self, new_val: T):
+        self.value = new_val
+
+    def __getattr__(self, name: str) -> Any:
+        if name in self.__dict__["_namespace"]:
+            self._track_read(name)
+            return self.__dict__["_namespace"][name]
+        raise AttributeError(f"'wire' object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, val: Any):
+        # If the attribute is 'value' or 'val', go through the property
+        if name in ("value", "val"):
+            super().__setattr__(name, val)
+            return
+
+        # If it's an internal attribute (shouldn't really happen from outside)
+        if name in self.__dict__:
+            super().__setattr__(name, val)
+            return
+
+        # Otherwise, treat it as setting a namespace key
+        # We allow adding new keys dynamically
+        self.__dict__["_namespace"][name] = val
+        self._notify_write(name)
+
+    def __repr__(self):
+        if self._namespace:
+            items = [f"{k}={v!r}" for k, v in self._namespace.items()]
+            # If we also have a positional value that isn't None (and not shadowed), show it?
+            # Typically one uses EITHER positional OR kwargs.
+            if self._value is not None and "value" not in self._namespace:
+                return f"wire({self._value!r}, {', '.join(items)})"
+            return f"wire({', '.join(items)})"
+        return f"wire({self._value!r})"

pywire/runtime/__init__.py

@@ -0,0 +1,7 @@
+"""Runtime components."""
+
+from pywire.runtime.app import PyWire
+from pywire.runtime.page import BasePage
+from pywire.runtime.router import Route, Router
+
+__all__ = ["BasePage", "Router", "Route", "PyWire"]

pywire/runtime/aioquic_server.py

@@ -0,0 +1,194 @@
+"""
+ASGI HTTP/3 + WebTransport server using aioquic directly.
+
+This module bypasses Hypercorn to use aioquic's native WebTransport support,
+which requires explicit enable_webtransport=True in H3Connection initialization.
+"""
+
+import asyncio
+from typing import Any, Callable, Optional
+
+from aioquic.asyncio import QuicConnectionProtocol, serve
+from aioquic.h3.connection import H3_ALPN, H3Connection
+from aioquic.h3.events import (
+    H3Event,
+    HeadersReceived,
+)
+from aioquic.quic.configuration import QuicConfiguration
+from aioquic.quic.events import ProtocolNegotiated, QuicEvent
+
+
+class ASGIProtocol(QuicConnectionProtocol):
+    """
+    QUIC/HTTP3 protocol handler that routes to ASGI application.
+
+    Handles WebTransport by creating H3Connection with enable_webtransport=True.
+    """
+
+    def __init__(
+        self, quic: Any, *args: Any, app_factory: Callable, **kwargs: Any
+    ) -> None:
+        super().__init__(quic, *args, **kwargs)
+        self._http: Optional[H3Connection] = None
+        self._app_factory = app_factory
+        self._app: Optional[Callable] = None
+
+    def quic_event_received(self, event: QuicEvent) -> None:
+        """Handle QUIC events, including protocol negotiation."""
+        if isinstance(event, ProtocolNegotiated):
+            if event.alpn_protocol in H3_ALPN:
+                # CRITICAL: Enable WebTransport support
+                self._http = H3Connection(self._quic, enable_webtransport=True)
+                print(
+                    "PyWire: HTTP/3 connection established with WebTransport enabled",
+                    flush=True,
+                )
+
+        # Pass events to HTTP/3 layer
+        if self._http is not None:
+            for http_event in self._http.handle_event(event):
+                self.http_event_received(http_event)
+
+    def http_event_received(self, event: H3Event) -> None:
+        """Route HTTP/3 events to ASGI application."""
+        if isinstance(event, HeadersReceived):
+            # Parse ASGI scope from headers
+            scope = self._build_scope(event)
+            print(
+                f"PyWire: Received {scope['type']} request to {scope.get('path', '/')}",
+                flush=True,
+            )
+
+            # Create ASGI handler
+            if self._app is None:
+                self._app = self._app_factory()
+
+            # Dispatch to ASGI app
+            asyncio.ensure_future(self._handle_asgi(scope, event))
+
+    def _build_scope(self, event: HeadersReceived) -> dict:
+        """Build ASGI scope dictionary from HTTP/3 headers."""
+        headers = []
+        method = ""
+        path = "/"
+        protocol = None
+
+        for header, value in event.headers:
+            if header == b":method":
+                method = value.decode()
+            elif header == b":path":
+                path = value.decode()
+            elif header == b":protocol":
+                protocol = value.decode()
+            elif header and not header.startswith(b":"):
+                headers.append((header, value))
+
+        # Determine scope type
+        if method == "CONNECT" and protocol == "webtransport":
+            scope_type = "webtransport"
+        else:
+            scope_type = "http"
+
+        return {
+            "type": scope_type,
+            "asgi": {"version": "3.0"},
+            "http_version": "3",
+            "method": method,
+            "path": path,
+            "headers": headers,
+            "server": ("localhost", 3000),
+        }
+
+    async def _handle_asgi(self, scope: dict, event: HeadersReceived) -> None:
+        """Handle ASGI application invocation."""
+        stream_id = event.stream_id
+
+        # Create receive/send callables
+        async def receive() -> dict:
+            # For WebTransport: wait for connect message
+            if scope["type"] == "webtransport":
+                return {"type": "webtransport.connect"}
+            return {"type": "http.request"}
+
+        async def send(message: dict) -> None:
+            msg_type = message["type"]
+            print(f"PyWire: Sending {msg_type} on stream {stream_id}", flush=True)
+
+            if msg_type == "webtransport.accept":
+                # Send 200 OK for WebTransport
+                if self._http:
+                    self._http.send_headers(
+                        stream_id=stream_id,
+                        headers=[
+                            (b":status", b"200"),
+                            (b"sec-webtransport-http3-draft", b"draft02"),
+                        ],
+                    )
+                print(
+                    f"PyWire: WebTransport connection accepted on stream {stream_id}",
+                    flush=True,
+                )
+            elif msg_type == "http.response.start":
+                status = message.get("status", 200)
+                response_headers = message.get("headers", [])
+                if self._http:
+                    self._http.send_headers(
+                        stream_id=stream_id,
+                        headers=[(b":status", str(status).encode())] + response_headers,
+                    )
+            elif msg_type == "http.response.body":
+                data = message.get("body", b"")
+                if self._http:
+                    self._http.send_data(
+                        stream_id=stream_id,
+                        data=data,
+                        end_stream=not message.get("more_body", False),
+                    )
+
+            self.transmit()
+
+        # Dispatch to ASGI app
+        if self._app:
+            await self._app(scope, receive, send)
+
+
+async def run_aioquic_server(
+    app_factory: Callable,
+    host: str,
+    port: int,
+    certfile: str,
+    keyfile: str,
+) -> None:
+    """
+    Run HTTP/3 + WebTransport server using aioquic directly.
+
+    Args:
+        app_factory: Callable that returns ASGI application
+        host: Host to bind to
+        port: Port to bind to
+        certfile: Path to SSL certificate
+        keyfile: Path to SSL private key
+    """
+    # Configure QUIC
+    configuration = QuicConfiguration(
+        alpn_protocols=H3_ALPN,
+        is_client=False,
+        max_datagram_frame_size=65536,
+    )
+    configuration.load_cert_chain(certfile, keyfile)
+
+    # Create protocol factory
+    # Create protocol factory
+    def create_protocol(*args: Any, **kwargs: Any) -> ASGIProtocol:
+        if "app_factory" in kwargs:
+            del kwargs["app_factory"]
+        return ASGIProtocol(*args, app_factory=app_factory, **kwargs)
+
+    # Start server
+    print(f"PyWire: Starting aioquic HTTP/3 server on {host}:{port}", flush=True)
+    await serve(
+        host,
+        port,
+        configuration=configuration,
+        create_protocol=create_protocol,
+    )