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

pywire/compiler/paths.py

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

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

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

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

@@ -1,194 +0,0 @@
-"""
-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,
-    )