pyrite-web 0.1.0__py3-none-any.whl

pyrite/__init__.py

@@ -0,0 +1,17 @@
+"""Websites in Python, without handwritten JavaScript or CSS."""
+
+from .core import App, Button, Card, Code, Column, Details, Heading, Link, Nav, Page, Row, Section, Text
+from .core import Form, Input, Select, Slider, Submit, query
+from .styles import Theme
+from .core import Image, Motion
+from . import requests
+from .browser import BrowserPlayground
+from .styles import Gradient
+from .live import Chat, LiveForm
+
+__all__ = ["App", "Button", "Card", "Code", "Column", "Details", "Heading", "Link", "Nav", "Page", "Row", "Section", "Text"]
+__all__ += ["Form", "Input", "Select", "Slider", "Submit", "query"]
+__all__ += ["Theme"]
+__all__ += ["Image", "Motion", "requests"]
+__all__ += ["BrowserPlayground"]
+__all__ += ["Gradient", "Chat", "LiveForm"]

pyrite/browser.py

@@ -0,0 +1,105 @@
+"""A browser-only Python editor, isolated from the application server."""
+import json
+from html import escape
+from pathlib import Path
+
+from .core import Element
+
+
+STARTER = '''from pyrite import Page, Column, Heading, Text, Card, Theme, Motion
+
+theme = Theme(
+    background="#111820", text="#eef3f8",
+    accent="#baf26b", heading_font="sans",
+)
+
+page = Page(
+    Motion(
+        Heading("I made this in Python."),
+        Card(Text("Change the words. Change the theme. Hit Run.")),
+        effect="rise",
+    ),
+    theme=theme,
+)
+'''
+
+
+class BrowserPlayground(Element):
+    """One editor per page. Pyodide runs user code in a disposable Web Worker."""
+
+    def __init__(self):
+        super().__init__("div", ())
+
+    def render(self):
+        # Ship this exact installed framework, rather than a second implementation.
+        sources = {path.name: path.read_text() for path in Path(__file__).parent.glob("*.py") if path.name != "browser.py"}
+        # The browser doesn't need to import its editor or the server-side HTTP client.
+        sources["__init__.py"] = sources["__init__.py"].replace("from .browser import BrowserPlayground", "")
+        sources["__init__.py"] = sources["__init__.py"].replace('__all__ += ["BrowserPlayground"]', "")
+        payload = json.dumps(sources).replace("<", "\\u003c")
+        return '''<div class="column">
+<label for="pyrite-editor">Python source</label>
+<textarea id="pyrite-editor" spellcheck="false">''' + escape(STARTER) + r'''</textarea>
+<div class="row"><button class="button" id="pyrite-run" type="button">Run Python</button>
+<button class="button" id="pyrite-reset" type="button">Reset example</button></div>
+<p id="pyrite-status" role="status">Ready. First run downloads Python from jsDelivr.</p>
+<iframe class="preview" id="pyrite-preview" title="Your Pyrite website" sandbox=""></iframe>
+<noscript>This editor needs JavaScript to run Python in your browser. All other pages work without it.</noscript>
+</div><script>
+(() => {
+const sources = ''' + payload + r''';
+const editor = document.getElementById('pyrite-editor');
+const initial = editor.value;
+const run = document.getElementById('pyrite-run');
+const status = document.getElementById('pyrite-status');
+const preview = document.getElementById('pyrite-preview');
+let worker, timer;
+const workerSource = `
+importScripts('https://cdn.jsdelivr.net/pyodide/v0.27.7/full/pyodide.js');
+let runtime;
+self.onmessage = async ({data}) => {
+  try {
+    if (!runtime) {
+      runtime = await loadPyodide();
+      runtime.FS.mkdirTree('/home/pyodide/pyrite');
+      for (const [name, source] of Object.entries(data.sources)) {
+        runtime.FS.writeFile('/home/pyodide/pyrite/' + name, source);
+      }
+    }
+    self.postMessage({ready: true});
+    runtime.globals.set('_editor_source', data.code);
+    const html = await runtime.runPythonAsync(\`
+from pyrite import Page
+_editor_scope = {"__name__": "__playground__"}
+exec(compile(_editor_source, "playground.py", "exec"), _editor_scope)
+_editor_page = _editor_scope.get("page")
+if not isinstance(_editor_page, Page):
+    raise TypeError("Create a Page and assign it to a variable named page. Do not call app.run().")
+_editor_page.render()
+\`);
+    self.postMessage({html});
+  } catch (error) { self.postMessage({error: String(error)}); }
+};`;
+function stop() { if (worker) worker.terminate(); clearTimeout(timer); run.disabled = false; }
+run.onclick = () => {
+  stop();
+  const url = URL.createObjectURL(new Blob([workerSource], {type: 'text/javascript'}));
+  worker = new Worker(url); URL.revokeObjectURL(url);
+  run.disabled = true; status.textContent = 'Loading Python…';
+  timer = setTimeout(() => { stop(); status.textContent = 'Python download timed out. Check your connection and try again.'; }, 120000);
+  worker.onmessage = ({data}) => {
+    if (data.ready) {
+      clearTimeout(timer); status.textContent = 'Running Python…';
+      timer = setTimeout(() => { stop(); status.textContent = 'Stopped: execution exceeded 10 seconds.'; }, 10000);
+      return;
+    }
+    if (data.html) { preview.srcdoc = data.html; status.textContent = 'Rendered. Edit and run again.'; }
+    else status.textContent = data.error;
+    stop();
+  };
+  worker.onerror = (event) => { status.textContent = event.message || 'Unable to load Python. Check your connection.'; stop(); };
+  worker.postMessage({sources, code: editor.value});
+};
+document.getElementById('pyrite-reset').onclick = () => { stop(); editor.value = initial; preview.srcdoc = ''; status.textContent = 'Example reset.'; };
+})();
+</script>'''

pyrite/core.py

@@ -0,0 +1,337 @@
+"""Small, dependency-free HTML components and HTTP application."""
+
+from dataclasses import dataclass
+from contextvars import ContextVar
+from html import escape
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Callable
+from urllib.parse import parse_qs, urlsplit
+from .styles import Theme
+import json
+
+
+_query: ContextVar[dict] = ContextVar("pyrite_query", default={})
+
+
+def query(name: str, default: str = "") -> str:
+    """Read the first GET parameter for the current request."""
+    return _query.get().get(name, [default])[0]
+
+
+def _url(value: str) -> str:
+    # Reject executable schemes, including schemes disguised with whitespace.
+    normalized = "".join(value.split())
+    if urlsplit(normalized).scheme.lower() not in ("", "http", "https", "mailto", "tel"):
+        raise ValueError("Links require a relative, http, https, mailto, or tel URL")
+    return value
+
+
+@dataclass(frozen=True)
+class Element:
+    tag: str
+    children: tuple
+    attributes: tuple = ()
+
+    def render(self) -> str:
+        attributes = "".join(
+            f' {name}="{escape(str(value), quote=True)}"'
+            for name, value in self.attributes
+        )
+        content = "".join(
+            child.render() if isinstance(child, Element) else escape(str(child))
+            for child in self.children
+            if child is not None
+        )
+        if self.tag in ("input", "img"):
+            return f"<{self.tag}{attributes}>"
+        return f"<{self.tag}{attributes}>{content}</{self.tag}>"
+
+
+def Text(value: object) -> Element:
+    return Element("p", (value,))
+
+
+def Heading(value: object, *, level: int = 1) -> Element:
+    if type(level) is not int or not 1 <= level <= 6:
+        raise ValueError("Heading level must be an integer from 1 to 6")
+    return Element(f"h{level}", (value,))
+
+
+def Column(*children: object) -> Element:
+    return Element("div", children, (("class", "column"),))
+
+
+def Row(*children: object) -> Element:
+    return Element("div", children, (("class", "row"),))
+
+
+def Card(*children: object) -> Element:
+    return Element("section", children, (("class", "card"),))
+
+
+def Link(label: str, href: str) -> Element:
+    return Element("a", (label,), (("href", _url(href)),))
+
+
+def Button(label: str, href: str) -> Element:
+    """A navigation action styled as a button; no client-side runtime required."""
+    return Element("a", (label,), (("href", _url(href)), ("class", "button")))
+
+
+def Section(*children: object, id: str) -> Element:
+    return Element("section", children, (("id", id), ("class", "section column")))
+
+
+def Nav(*children: object) -> Element:
+    return Element("nav", children, (("aria-label", "Main navigation"), ("class", "navigation")))
+
+
+def Code(source: str, *, label: str = "Python") -> Element:
+    return Element("figure", (Element("figcaption", (label,)), Element("pre", (Element("code", (source,)),))), (("class", "code"),))
+
+
+def Details(question: str, *children: object) -> Element:
+    return Element("details", (Element("summary", (question,)), *children))
+
+
+def Image(src: str, alt: str) -> Element:
+    if urlsplit(src).scheme not in ("", "http", "https"):
+        raise ValueError("Images require a relative, http, or https URL")
+    return Element("img", (), (("src", src), ("alt", alt), ("loading", "lazy"), ("width", "1400"), ("height", "800"), ("class", "image")))
+
+
+def Motion(*children: object, effect: str = "rise") -> Element:
+    if effect not in ("rise", "fade", "float"):
+        raise ValueError("Motion effect must be rise, fade, or float")
+    return Element("div", children, (("class", f"column motion motion-{effect}"),))
+
+
+def Form(*children: object, action: str = "") -> Element:
+    """Submit read-only parameters with a native GET form."""
+    return Element("form", children, (("action", _url(action)), ("method", "get"), ("class", "column")))
+
+
+def Input(name: str, label: str, *, value: str = "", kind: str = "text") -> Element:
+    if kind not in ("text", "email", "number", "search", "url", "date"):
+        raise ValueError("Unsupported input kind")
+    return Element("label", (label, Element("input", (), (("name", name), ("type", kind), ("value", value)))))
+
+
+def Slider(name: str, label: str, *, value: int = 5, minimum: int = 1, maximum: int = 10) -> Element:
+    if not minimum <= value <= maximum:
+        raise ValueError("Slider value must be between minimum and maximum")
+    return Element("label", (label, Element("input", (), (("type", "range"), ("name", name), ("min", minimum), ("max", maximum), ("value", value)))))
+
+
+def Select(name: str, label: str, options: dict[str, str], *, value: str = "") -> Element:
+    return Element("label", (label, Element("select", tuple(
+        Element("option", (text,), (("value", key),) + ((("selected", "selected"),) if key == value else ()))
+        for key, text in options.items()
+    ), (("name", name),))))
+
+
+def Submit(label: str = "Submit") -> Element:
+    return Element("button", (label,), (("type", "submit"), ("class", "button")))
+
+
+_STYLE = """
+:root { color-scheme: light; font-family: system-ui, sans-serif; color: #25251f;
+  background: #f6f5ef; line-height: 1.6; }
+* { box-sizing: border-box; }
+body { margin: 0; }
+main { max-width: 960px; margin: auto; padding: 64px 24px; }
+h1,h2,h3,h4,h5,h6,p { margin: 0; }
+h1 { font-size: clamp(2.5rem, 7vw, 5rem); line-height: 1.08; letter-spacing: -.05em; }
+h2 { font-size: 1.7rem; line-height: 1.2; }
+p { max-width: 65ch; }
+a { color: inherit; text-underline-offset: .2em; }
+.column { display: flex; flex-direction: column; gap: 24px; }
+.row { display: flex; flex-wrap: wrap; gap: 24px; align-items: center; }
+.row > .card { flex: 1 1 240px; }
+.card { padding: 28px; border: 1px solid #d8d7cc; border-radius: 12px; }
+.card > * + * { margin-top: 12px; }
+.button { display: inline-block; padding: 12px 22px; background: #393e24;
+  color: white; border-radius: 6px; text-decoration: none; font-weight: 600; }
+.button:hover { background: #525a33; }
+a:focus-visible { outline: 3px solid #8b6720; outline-offset: 5px; }
+.navigation { display: flex; justify-content: space-between; align-items: center; flex-wrap: wrap; gap: 24px; padding-bottom: 32px; }
+.navigation > a:first-child { font: bold 32px Georgia, serif; text-decoration: none; }
+.section { padding: 64px 0; scroll-margin-top: 24px; }
+.section > h1 { font-family: Georgia, serif; font-weight: 400; font-size: clamp(2.5rem, 8vw, 7rem); max-width: 14ch; }
+.section > p { font-size: 20px; max-width: 48ch; }
+.code { margin: 0; background: #172c24; color: #f3f3dd; overflow: hidden; }
+.code figcaption { padding: 18px 26px; color: #d4deae; }
+.code pre { margin: 0; padding: 8px 26px 28px; overflow-x: auto; font: 15px/1.8 ui-monospace, monospace; tab-size: 4; }
+#demo { background: #e5e9d7; padding: 40px; }
+#demo > .row { align-items: stretch; }
+#demo > .row > * { flex: 1 1 280px; min-width: 0; }
+#demo .card { background: #f6f5ef; border: 0; border-radius: 0; display: flex; flex-direction: column; justify-content: center; align-items: flex-start; }
+details { background: #e5e9d7; padding: 24px; }
+summary { cursor: pointer; font-size: 20px; font-weight: 600; }
+details p { padding-top: 16px; }
+.button { transition: transform .18s ease, background .18s ease; }
+.button:hover { transform: translateY(-2px); }
+.button:active { transform: translateY(1px); }
+@media (max-width: 600px) {
+  main { padding: 24px 20px; }
+  .navigation { padding-bottom: 24px; gap: 16px; }
+  .section { padding: 40px 0; }
+  #demo { padding: 24px 16px; }
+  .code pre { font-size: 14px; padding-inline: 16px; }
+}
+@media (prefers-reduced-motion: reduce) { .button { transition: none; } }
+label { display: flex; flex-direction: column; gap: 8px; font-weight: 600; }
+input, select { font: inherit; color: inherit; background: #fff; padding: 12px;
+  border: 1px solid #8c9181; border-radius: 6px; min-width: 0; width: 100%; }
+input[type=range] { padding: 12px 0; accent-color: #393e24; }
+button { font: inherit; border: 0; cursor: pointer; align-self: flex-start; }
+input:focus-visible, select:focus-visible, button:focus-visible, summary:focus-visible {
+  outline: 3px solid #8b6720; outline-offset: 5px; }
+"""
+
+
+@dataclass(frozen=True)
+class Page:
+    content: Element
+    title: str = "Pyrite"
+    language: str = "en"
+    theme: Theme = Theme()
+
+    def render(self) -> str:
+        return (
+            f'<!doctype html><html lang="{escape(self.language, quote=True)}">'
+            '<head><meta charset="utf-8">'
+            '<meta name="viewport" content="width=device-width, initial-scale=1">'
+            f"<title>{escape(self.title)}</title><style>{_STYLE}{self.theme.css()}</style></head>"
+            f"<body><main>{self.content.render()}</main></body></html>"
+        )
+
+
+class App:
+    """Exact-path GET routes. Handlers return a Page."""
+
+    def __init__(self) -> None:
+        self._routes: dict[str, Callable[[], Page]] = {}
+        self._actions: dict[str, Callable[[dict], dict]] = {}
+
+    def action(self, path: str) -> Callable:
+        """Register a JSON POST callback. Return a JSON-serializable dictionary."""
+        if not path.startswith("/") or path.startswith("//") or "?" in path or "#" in path:
+            raise ValueError("Action must be a same-origin absolute path")
+
+        def register(handler):
+            if path in self._actions:
+                raise ValueError(f"Duplicate action: {path}")
+            self._actions[path] = handler
+            return handler
+
+        return register
+
+    def page(self, path: str) -> Callable:
+        if not path.startswith("/") or "?" in path or "#" in path:
+            raise ValueError("Route must be an absolute path without query or fragment")
+
+        def register(handler: Callable[[], Page]) -> Callable[[], Page]:
+            if path in self._routes:
+                raise ValueError(f"Duplicate route: {path}")
+            self._routes[path] = handler
+            return handler
+
+        return register
+
+    def handler(self) -> type[BaseHTTPRequestHandler]:
+        app = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self) -> None:
+                action = app._actions.get(urlsplit(self.path).path)
+                if action is None:
+                    self.send_error(404)
+                    return
+                origin = self.headers.get("Origin")
+                if self.headers.get("Sec-Fetch-Site") == "cross-site" or (
+                    origin and (urlsplit(origin).scheme not in ("http", "https") or urlsplit(origin).netloc != self.headers.get("Host"))
+                ):
+                    self.send_error(403)
+                    return
+                if self.headers.get("Content-Type", "").split(";")[0].strip().lower() != "application/json":
+                    self.send_error(415)
+                    return
+                try:
+                    length = int(self.headers.get("Content-Length", "0"))
+                except ValueError:
+                    self.send_error(400)
+                    return
+                if not 0 < length <= 16384:
+                    self.send_error(413)
+                    return
+                try:
+                    self.connection.settimeout(10)
+                    data = json.loads(self.rfile.read(length))
+                    if not isinstance(data, dict):
+                        raise ValueError("Action payload must be an object")
+                except (ValueError, UnicodeError):
+                    self.send_error(400)
+                    return
+                except OSError:
+                    self.send_error(408)
+                    return
+                try:
+                    result = action(data)
+                    if not isinstance(result, dict):
+                        raise TypeError("Actions must return dictionaries")
+                    body = json.dumps(result, ensure_ascii=False, allow_nan=False).encode()
+                except ValueError:
+                    self.send_error(400)
+                    return
+                except Exception:
+                    self.log_error("Action failed")
+                    self.send_error(500)
+                    return
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.send_header("Cache-Control", "no-store")
+                self.send_header("X-Content-Type-Options", "nosniff")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def do_GET(self) -> None:
+                route = app._routes.get(urlsplit(self.path).path)
+                if route is None:
+                    self.send_error(404)
+                    return
+                try:
+                    params = parse_qs(urlsplit(self.path).query, keep_blank_values=True, max_num_fields=100)
+                    token = _query.set(params)
+                    try:
+                        page = route()
+                        if not isinstance(page, Page):
+                            raise TypeError("Route handlers must return a Page")
+                        body = page.render().encode("utf-8")
+                    finally:
+                        _query.reset(token)
+                except ValueError:
+                    self.send_error(400)
+                    return
+                except Exception:
+                    self.log_error("Route failed")
+                    self.send_error(500)
+                    return
+                self.send_response(200)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.send_header("Content-Length", str(len(body)))
+                self.send_header("X-Content-Type-Options", "nosniff")
+                self.end_headers()
+                self.wfile.write(body)
+
+        return Handler
+
+    def run(self, host: str = "127.0.0.1", port: int = 8000) -> None:
+        """Run the local development server until interrupted."""
+        with ThreadingHTTPServer((host, port), self.handler()) as server:
+            print(f"Pyrite running at http://{host}:{server.server_port}", flush=True)
+            try:
+                server.serve_forever()
+            except KeyboardInterrupt:
+                pass

pyrite/live.py

@@ -0,0 +1,75 @@
+"""Components that call Python actions without navigating away."""
+from .core import Element, Input, Submit
+
+
+_RUNTIME = r'''<script>
+(() => {
+ const root = document.currentScript.previousElementSibling;
+ const form = root.querySelector('form');
+ const output = root.querySelector('.live-output');
+ const status = root.querySelector('[role=status]');
+ const button = form.querySelector('button[type=submit]');
+ const chat = root.dataset.chat === 'true';
+ let history = [];
+ form.addEventListener('submit', async event => {
+  event.preventDefault();
+  if (button.disabled) return;
+  const payload = Object.fromEntries(new FormData(form));
+  if (chat) {
+   payload.message = payload.message.trim();
+   if (!payload.message) { status.textContent = 'Write a message first.'; return; }
+   payload.history = history;
+  }
+  button.disabled = true; status.textContent = 'Waiting for Python…';
+  root.setAttribute('aria-busy', 'true');
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 30000);
+  try {
+   const response = await fetch(form.action, {
+    method: 'POST', headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify(payload), signal: controller.signal,
+   });
+   if (!response.ok) throw new Error('Request failed (' + response.status + '). Please try again.');
+   const data = await response.json();
+   const text = chat ? data.reply : data.text;
+   if (typeof text !== 'string') throw new Error('Python must return ' + (chat ? 'reply' : 'text') + ' as a string.');
+   function append(text) { const p = document.createElement('p'); p.textContent = text; output.appendChild(p); }
+   if (chat) {
+    append('You: ' + payload.message); append('Pyrite: ' + text);
+    history = [...history, {role: 'user', content: payload.message}, {role: 'assistant', content: text}].slice(-20);
+    while (output.children.length > 20) output.firstElementChild.remove();
+    if (form.elements.message.value.trim() === payload.message) form.elements.message.value = '';
+   } else { output.replaceChildren(); append(text); }
+   status.textContent = 'Updated.';
+  } catch (error) {
+   status.textContent = error.name === 'AbortError' ? 'Request timed out. Try again.' : error.message;
+  } finally {
+   clearTimeout(timer); button.disabled = false; root.removeAttribute('aria-busy');
+  }
+ });
+})();
+</script>'''
+
+
+class LiveForm(Element):
+    """Submit inputs to an @app.action endpoint returning {'text': '...'}.
+
+    JavaScript is supplied by Pyrite. The application remains Python-only.
+    """
+    def __init__(self, *children, action: str, chat: bool = False):
+        if not action.startswith("/") or action.startswith("//") or "?" in action or "#" in action:
+            raise ValueError("Live forms require a same-origin absolute action path")
+        super().__init__("section", (
+            Element("div", (), (("class", "live-output"), ("role", "log"), ("aria-live", "polite"))),
+            Element("form", children, (("action", action), ("method", "post"), ("class", "column"))),
+            Element("p", ("Ready.",), (("role", "status"),)),
+            Element("noscript", ("This live component requires JavaScript. Pyrite supplies it automatically.",)),
+        ), (("class", "column"), ("data-chat", str(chat).lower())))
+
+    def render(self):
+        return super().render() + _RUNTIME
+
+
+def Chat(*, action: str, placeholder: str = "Your message") -> LiveForm:
+    """Conversation UI. Action receives message/history and returns {'reply': '...'}."""
+    return LiveForm(Input("message", placeholder), Submit("Send message"), action=action, chat=True)

pyrite/requests.py

@@ -0,0 +1,61 @@
+"""Small standard-library HTTP client for server-side Python."""
+import json as _json
+from dataclasses import dataclass
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode, urlsplit
+from urllib.request import Request, urlopen
+
+
+class RequestError(RuntimeError):
+    """A network, HTTP, response-size, or decoding failure."""
+
+
+@dataclass(frozen=True)
+class Response:
+    status_code: int
+    text: str
+
+    def json(self):
+        try:
+            return _json.loads(self.text)
+        except ValueError as error:
+            raise RequestError("Response was not valid JSON") from error
+
+
+def request(method, url, *, params=None, json=None, headers=None, timeout=8):
+    """Send an HTTP request. URLs must come from trusted application code."""
+    if urlsplit(url).scheme not in ("http", "https"):
+        raise ValueError("HTTP requests require an http or https URL")
+    if params:
+        url += ("&" if "?" in url else "?") + urlencode(params)
+    body = None if json is None else _json.dumps(json).encode()
+    request_headers = {"User-Agent": "Pyrite/0.1", **(headers or {})}
+    if body is not None:
+        request_headers.setdefault("Content-Type", "application/json")
+    try:
+        with urlopen(Request(url, data=body, headers=request_headers, method=method), timeout=timeout) as response:
+            data = response.read(1_048_577)
+            if len(data) > 1_048_576:
+                raise RequestError("Response exceeded 1 MiB")
+            return Response(response.status, data.decode(response.headers.get_content_charset() or "utf-8"))
+    except HTTPError as error:
+        error.close()
+        raise RequestError(f"HTTP request failed: {error}") from error
+    except (URLError, TimeoutError, OSError, UnicodeError) as error:
+        raise RequestError(f"HTTP request failed: {error}") from error
+
+
+def get(url, **kwargs):
+    return request("GET", url, **kwargs)
+
+
+def post(url, **kwargs):
+    return request("POST", url, **kwargs)
+
+
+def put(url, **kwargs):
+    return request("PUT", url, **kwargs)
+
+
+def delete(url, **kwargs):
+    return request("DELETE", url, **kwargs)

pyrite/styles.py

@@ -0,0 +1,112 @@
+"""Validated theme settings for Pyrite's built-in components."""
+from dataclasses import dataclass
+import re
+
+
+@dataclass(frozen=True)
+class Gradient:
+    colors: tuple[str, ...] = ("#142a35", "#234936", "#111820")
+    angle: int = 120
+    moving: bool = False
+    duration: int = 12
+
+    def css(self) -> str:
+        if not 2 <= len(self.colors) <= 8 or any(not re.fullmatch(r"#[0-9a-fA-F]{6}", c) for c in self.colors):
+            raise ValueError("Gradient requires 2–8 six-digit hex colors")
+        if type(self.angle) is not int or not 0 <= self.angle <= 360:
+            raise ValueError("Gradient angle must be 0–360")
+        if type(self.moving) is not bool or type(self.duration) is not int or not 1 <= self.duration <= 120:
+            raise ValueError("Gradient moving must be boolean; duration must be 1–120 seconds")
+        return f"linear-gradient({self.angle}deg, {', '.join(self.colors)})"
+
+
+@dataclass(frozen=True)
+class Theme:
+    background: str = "#f6f5ef"
+    text: str = "#25251f"
+    surface: str = "#e5e9d7"
+    accent: str = "#393e24"
+    accent_hover: str = "#525a33"
+    on_accent: str = "#ffffff"
+    code_background: str = "#172c24"
+    code_text: str = "#f3f3dd"
+    border: str = "#8c9181"
+    focus: str = "#8b6720"
+    font: str = "sans"
+    heading_font: str = "serif"
+    width: int = 1100
+    radius: int = 8
+    spacing: int = 24
+    background_image: str = ""
+    motion: bool = True
+    motion_duration: int = 700
+    button_radius: int | None = None
+    input_radius: int | None = None
+    gradient: Gradient | None = None
+
+    def css(self) -> str:
+        for value in (self.button_radius, self.input_radius):
+            if value is not None and (type(value) is not int or not 0 <= value <= 999):
+                raise ValueError("Corner radii must be integers from 0 to 999")
+        if self.background_image and not re.fullmatch(r"(?:https?://|/)[a-zA-Z0-9/_.?=&%:+~-]+", self.background_image):
+            raise ValueError("background_image requires a safe http, https, or absolute-path URL")
+        if type(self.motion) is not bool:
+            raise ValueError("motion must be True or False")
+        colors = ("background", "text", "surface", "accent", "accent_hover",
+                  "on_accent", "code_background", "code_text", "border", "focus")
+        for name in colors:
+            if not re.fullmatch(r"#[0-9a-fA-F]{6}", getattr(self, name)):
+                raise ValueError(f"{name} must be a six-digit hex color")
+        fonts = {"sans": "system-ui, sans-serif", "serif": "Georgia, serif", "mono": "ui-monospace, monospace"}
+        if self.font not in fonts or self.heading_font not in fonts:
+            raise ValueError("Fonts must be sans, serif, or mono")
+        for name, low, high in (("width", 320, 2000), ("radius", 0, 48), ("spacing", 8, 64), ("motion_duration", 100, 5000)):
+            value = getattr(self, name)
+            if type(value) is not int or not low <= value <= high:
+                raise ValueError(f"{name} must be an integer between {low} and {high}")
+        variables = ";".join(f"--{name.replace('_', '-')}: {getattr(self, name)}" for name in colors)
+        background = f'body {{ background-image: url("{self.background_image}"); background-size: cover; background-attachment: fixed; }}' if self.background_image else ""
+        gradient = ""
+        if self.gradient is not None:
+            if not isinstance(self.gradient, Gradient):
+                raise ValueError("gradient must be a Gradient")
+            # A fixed layer keeps animation independent of page length and images.
+            gradient = f"body::before {{ content: ''; position: fixed; inset: 0; z-index: -1; background: {self.gradient.css()}; }} body {{ isolation: isolate; }}"
+            if self.gradient.moving and self.motion:
+                gradient += f"body::before {{ background-size: 300% 300%; animation: pyrite-gradient {self.gradient.duration}s ease-in-out infinite; }}"
+        motion = f"""
+.motion-rise {{ animation: pyrite-rise {self.motion_duration}ms ease both; }}
+.motion-fade {{ animation: pyrite-fade {self.motion_duration}ms ease both; }}
+.motion-float {{ animation: pyrite-float 4s ease-in-out infinite; }}
+""" if self.motion else ".motion { animation: none; }"
+        return f"""
+:root {{ {variables}; color-scheme: normal; background: var(--background); color: var(--text); font-family: {fonts[self.font]}; }}
+main {{ max-width: {self.width}px; }}
+h1,h2,h3,h4,h5,h6,.section > h1,.navigation > a:first-child {{ font-family: {fonts[self.heading_font]}; }}
+.column,.row {{ gap: {self.spacing}px; }}
+.button {{ background: var(--accent); color: var(--on-accent); border-radius: {self.radius}px; }}
+.button:hover {{ background: var(--accent-hover); }}
+.button {{ border-radius: {self.button_radius if self.button_radius is not None else self.radius}px; }}
+.card,#demo .card {{ background: var(--background); border-color: var(--border); border-radius: {self.radius}px; }}
+#demo,details {{ background: var(--surface); }}
+.code {{ background: var(--code-background); color: var(--code-text); border-radius: {self.radius}px; }}
+.code figcaption {{ color: var(--code-text); }}
+input,select {{ background: var(--background); color: var(--text); border-color: var(--border); border-radius: {self.input_radius if self.input_radius is not None else self.radius}px; }}
+input[type=range] {{ accent-color: var(--accent); }}
+:is(a,input,select,button,summary):focus-visible {{ outline-color: var(--focus); }}
+.image {{ display: block; width: 100%; height: auto; border-radius: {self.radius}px; }}
+textarea {{ width: 100%; min-height: 340px; padding: 20px; background: var(--code-background); color: var(--code-text); border: 1px solid var(--border); border-radius: {self.radius}px; font: 15px/1.7 ui-monospace, monospace; resize: vertical; }}
+iframe.preview {{ width: 100%; height: 500px; border: 1px solid var(--border); background: white; }}
+details,#demo,iframe.preview {{ border-radius: {self.radius}px; }}
+.live-output {{ display: flex; flex-direction: column; gap: 16px; overflow-wrap: anywhere; }}
+.live-output p {{ white-space: pre-wrap; background: var(--surface); padding: 16px; border-radius: {self.radius}px; }}
+button:disabled {{ opacity: .6; cursor: wait; }}
+@keyframes pyrite-rise {{ from {{ opacity: 0; transform: translateY(24px); }} to {{ opacity: 1; transform: translateY(0); }} }}
+@keyframes pyrite-fade {{ from {{ opacity: 0; }} to {{ opacity: 1; }} }}
+@keyframes pyrite-float {{ 50% {{ transform: translateY(-10px); }} }}
+@keyframes pyrite-gradient {{ 0%,100% {{ background-position: 0% 50%; }} 50% {{ background-position: 100% 50%; }} }}
+{background}
+{gradient}
+{motion}
+@media (prefers-reduced-motion: reduce) {{ .motion, body::before {{ animation: none; }} }}
+"""

pyrite_web-0.1.0.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: pyrite-web
+Version: 0.1.0
+Summary: Code websites in Python 3, without writing JavaScript or CSS.
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Pyrite
+
+Code websites in Python 3, for JavaScript and CSS haters.
+
+Pyrite is a small, dependency-free starting point: compose Python components,
+return a page, and serve HTML with built-in responsive styling. Requires Python 3.10+.
+
+## Run the example
+
+```sh
+python3 example.py
+```
+
+Open http://127.0.0.1:8000. The example is Pyrite's first website: a homepage
+with a code/output comparison, quickstart, expandable FAQ, and a component
+guide at `/guide`. Try `/playground` for a Python-powered calculator.
+Its application source uses only Python components.
+No installation is required when running from this repository.
+
+## Build a page
+
+```python
+from pyrite import App, Column, Heading, Page, Text
+
+app = App()
+
+@app.page("/")
+def home():
+    return Page(
+        Column(Heading("Hello, Pyrite."), Text("Just Python.")),
+        title="My website",
+    )
+
+if __name__ == "__main__":
+    app.run()
+```
+
+Available components: `Heading`, `Text`, `Column`, `Row`, `Card`, `Link`, and
+`Button`, `Section`, `Nav`, `Code`, and `Details`. Nest components directly.
+`Section(..., id="start")` creates an anchor target. `Code(source, label="Python")`
+displays escaped source. `Details(question, ...)` provides a native expandable answer.
+`Heading` accepts `level=1` through `6`.
+`Link(label, href)` and `Button(label, href)` navigate to another URL.
+Text and HTML attributes are escaped automatically.
+
+Register exact paths with `@app.page("/about")`. Handlers take no arguments and
+return a `Page`. Query strings do not affect route matching. `Page` accepts
+`title` and `language`; `app.run` accepts `host` and `port`.
+
+## Current scope
+
+This version serves server-rendered pages with native GET forms and JSON POST
+callbacks through `LiveForm` and `Chat`. It does not include server sessions,
+token streaming, live reload, or a production server. The built-in
+HTTP server is for local development. Styling is supplied by Pyrite; applications
+do not need CSS files or JavaScript tooling.
+
+## Styling in Python
+
+Edit the root `styles.py` to change the example website's shared theme. Restart
+the server after editing. `Theme` supports six-digit hex colors, `sans`, `serif`,
+or `mono` fonts, page width, corner radius, and spacing. Apply a theme to any page:
+
+```python
+from pyrite import Theme
+
+theme = Theme(background="#111820", text="#eef3f8", heading_font="sans")
+page = Page(Heading("Your style."), theme=theme)
+```
+
+## Forms without JavaScript
+
+```python
+from pyrite import Form, Input, Submit, query
+
+@app.page("/hello")
+def hello():
+    return Page(Column(
+        Form(Input("name", "Your name", value=query("name")), Submit("Say hello")),
+        Text(f"Hello, {query('name', 'world')}!"),
+    ))
+```
+
+`Slider(name, label, value=5, minimum=1, maximum=10)` and
+`Select(name, label, {"value": "Label"}, value="value")` also work in forms.
+Submission reloads the page; `query` reads request-local URL parameters. GET forms
+are for read-only calculations and searches; their values appear in the URL.
+
+## Try Pyrite in Browser
+
+Visit `/try` to edit Python and render a real `Page` without installing Python.
+Assign your result to `page`; do not call `app.run()`. The editor loads Pyodide
+from jsDelivr and runs code in a disposable Web Worker, with a 10-second execution
+limit and an isolated preview. First download can take up to two minutes.
+Code is not executed on the application server. Browser networking follows CORS
+rules; the standard-library HTTP client below is for server-side Python.
+
+## Images and motion
+
+```python
+from pyrite import Image, Motion
+from styles import hero_image
+
+banner = Motion(Image(hero_image, "Mountain landscape"), effect="rise")
+```
+
+Choose `rise`, `fade`, or `float`. In `styles.py`, set `motion=False` to disable
+component animations, or change `motion_duration` (100–5000 milliseconds) for
+entrances. Reduced-motion browser preferences disable animations automatically.
+`Theme(background_image="https://example.com/background.jpg")` attaches a page
+background. `Image` accepts relative or HTTP(S) URLs and requires alt text.
+External images load directly from their host; local file serving is not included.
+
+## Requests and changing API data
+
+```python
+from pyrite import requests
+
+data = requests.get(
+    "https://api.mymemory.translated.net/get",
+    params={"q": "Good morning", "langpair": "en|uk"},
+).json()
+
+# For an API you control, with the authentication it requires:
+# requests.post("https://your-api.example/items", json={"name": "New"})
+# requests.put("https://your-api.example/items/1", json={"name": "Changed"})
+# requests.delete("https://your-api.example/items/1")
+```
+
+The dependency-free client supports `get`, `post`, `put`, and `delete`, optional
+headers, JSON bodies, query parameters, and a timeout (8 seconds by default).
+Responses expose `status_code`, `text`, and `json()`. Catch `requests.RequestError`
+for HTTP/network/decoding failures. Responses are limited to 1 MiB. Supply trusted
+URLs in application code; do not forward visitor-provided URLs to this client.
+GET page handlers should only read data. POST actions can make remote writes;
+add application authentication and authorization before exposing private data or
+operations. Pyrite's local development server does not provide authentication.
+
+`/translate` demonstrates input, a real free MyMemory request, and updated page
+content. No API key required; availability, translation quality, and quotas depend
+on MyMemory. Submitted text is sent to that service.
+
+## Corners and gradients
+
+```python
+from pyrite import Gradient, Theme
+
+theme = Theme(
+    radius=20,              # Panels, code blocks, images, details
+    button_radius=999,      # Pill buttons; 0 gives square corners
+    input_radius=12,        # Inputs and dropdowns
+    gradient=Gradient(
+        colors=("#101923", "#214a42", "#17283d"),
+        angle=120,
+        moving=True,
+        duration=14,       # Seconds per cycle
+    ),
+)
+```
+
+`button_radius` and `input_radius` inherit `radius` when omitted. Gradients accept
+2–8 hex colors; set `moving=False` for a static gradient or `gradient=None` for
+the usual background. A fixed background layer animates independently of page
+length. `motion=False` or the browser's reduced-motion preference stops its movement.
+The gradient layer sits over a background image when both are configured.
+
+## In-page requests and chat
+
+```python
+from pyrite import App, Chat, Page
+
+app = App()
+
+@app.action("/api/reply")
+def reply(data):
+    message = data["message"]
+    history = data.get("history", [])
+    # Call a model here with pyrite.requests; keep API keys on the server.
+    return {"reply": "You said: " + message}
+
+@app.page("/")
+def home():
+    return Page(Chat(action="/api/reply"))
+```
+
+Visit `/chat` for a working local rule-based chatbot and a live translation form.
+`Chat` sends `{message, history}` and displays `reply` without a page reload.
+History stays in this page's browser memory (last 20 messages), is sent with each
+request, and clears on reload. It is untrusted input; validate it in callbacks.
+This is completed-response chat, not token streaming. The demo uses no AI service.
+
+For other interfaces, use `LiveForm(Input(...), Submit(...), action="/api/action")`
+and return `{"text": "Updated result"}` from the action. All field values arrive
+as strings. Pyrite supplies the JavaScript, pending state, errors, 30-second
+client timeout, and safe text rendering. The callback can use `requests` to reach
+external APIs without exposing credentials to the browser. Aborting a request
+does not cancel Python work already running.
+
+Actions accept JSON objects up to 16 KiB and reject cross-origin browser requests.
+These checks do not authenticate users. Use application validation and authorization
+for sensitive actions. Live components require JavaScript; ordinary pages and GET
+forms continue working without it. Browser playground previews remain isolated and
+cannot call server actions.
+
+## Tests
+
+```sh
+python3 -m unittest discover -s tests -v
+```

pyrite_web-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyrite/__init__.py,sha256=ShUfS3EgLTJu2prtAI6oSE5EYZxZgjrAKaf6KG0ZB_k,749
+pyrite/browser.py,sha256=8KXYnRTH1paKkg1Kd0BcjItwpFo6yzE6n7ctgIXj2Lw,4551
+pyrite/core.py,sha256=Eti4EzBBxKRerIfix8qhdjSRckn_fqjhrWRAX2sXBGw,14289
+pyrite/live.py,sha256=QtqRptfn4i8rxsp7Iegqgh4OBDGrqB-tbBaBJ116m3Y,3611
+pyrite/requests.py,sha256=zaWnO6_lckkCyY1cZnQ8iooNTBanmJx_tt2nU6ZAZIo,2125
+pyrite/styles.py,sha256=YNy3QzhblkGe7N5FhA9cLFp0Phc2pHkcAqqX-ll8SCE,6781
+pyrite_web-0.1.0.dist-info/licenses/LICENSE,sha256=M4sUwAu6voRvOQrGbExBNqseFcaMgBqOOd-IIpDhGAo,1076
+pyrite_web-0.1.0.dist-info/METADATA,sha256=dGjWHp03sPRR9ifs9TRz82Svkjv8Q8wcn3nwjfVzDD8,8262
+pyrite_web-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyrite_web-0.1.0.dist-info/top_level.txt,sha256=lhj7_y_qa1CX0aM9Dj2y8mw-6fBxyTJTPMr7F-cfe94,7
+pyrite_web-0.1.0.dist-info/RECORD,,

pyrite_web-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyrite_web-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pyrite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrite_web-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyrite