pythonnative 0.40.0__cp314-cp314-win_amd64.whl

pythonnative/devserver/static/animation_graph.js

@@ -0,0 +1,82 @@
+// The browser evaluates the same expression contract as UIKit and Android.
+export class AnimationGraph {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.graphs = new Map(); this.values = new Map(); this.previous = new Map(); this.outputs = new Map();
+  }
+  install(graph) {
+    const ids = new Set(graph.nodes.map(node => node.id));
+    for (const [key, old] of this.graphs) if (old.nodes.some(node => ids.has(node.id))) this.graphs.delete(key);
+    if (graph.bindings.length) this.graphs.set(graph.id, graph);
+    for (const node of graph.nodes) {
+      if (!this.values.has(node.id)) this.values.set(node.id, node.value || 0);
+      if (!this.previous.has(node.id)) this.previous.set(node.id, node.previous || 0);
+    }
+    this.collect(); this.evaluate();
+  }
+  collect() {
+    const live = new Set([...this.graphs.values()].flatMap(graph => graph.nodes.map(node => node.id)));
+    for (const map of [this.values, this.previous, this.outputs]) for (const key of map.keys()) if (!live.has(key)) map.delete(key);
+  }
+  forget(tag) {
+    for (const [id, graph] of this.graphs) {
+      graph.bindings = graph.bindings.filter(binding => binding[0] !== tag);
+      if (!graph.bindings.length) this.graphs.delete(id);
+    }
+    this.collect();
+  }
+  set(id, value) { this.values.set(id, value); this.evaluate(); }
+  event(tag, name, args) {
+    const props = this.renderer.views.get(tag)?.props;
+    const fields = name.startsWith('gesture:')
+      ? props?.gestures?.[Number(name.slice(8))]?.animated_events?.[args[0]?.state]
+      : props?._pn_animated_events?.[name];
+    if (!fields || !args[0]) return;
+    for (const [field, id] of Object.entries(fields)) if (typeof args[0][field] === 'number') this.values.set(id, args[0][field]);
+    this.evaluate();
+  }
+  evaluate() {
+    for (const graph of this.graphs.values()) {
+      for (const node of graph.nodes) {
+        const [a = 0, b = 0] = (node.inputs || []).map(input => input.node ? this.values.get(input.node) || 0 : input.constant);
+        let value = 0;
+        switch (node.kind) {
+          case 'value': value = this.values.get(node.id); break;
+          case 'add': value = a + b; break;
+          case 'subtract': value = a - b; break;
+          case 'multiply': value = a * b; break;
+          case 'divide': value = b ? a / b : 0; break;
+          case 'modulo': value = b ? a % b : 0; break;
+          case 'negate': value = -a; break;
+          case 'diff_clamp':
+            value = Math.min(node.maximum, Math.max(node.minimum, (this.values.get(node.id) || 0) + a - (this.previous.get(node.id) || 0)));
+            this.previous.set(node.id, a); break;
+          case 'interpolate': value = this.interpolate(node, a); break;
+        }
+        this.values.set(node.id, Number.isFinite(value) ? value : 0);
+        if (!node.color) this.outputs.set(node.id, this.values.get(node.id));
+      }
+      for (const [tag, prop, id] of graph.bindings) {
+        const view = this.renderer.views.get(tag);
+        if (view) this.renderer.animator.set(view, prop, this.outputs.get(id));
+      }
+    }
+  }
+  interpolate(node, incoming) {
+    let x = incoming;
+    const first = node.ranges[0], last = node.ranges.at(-1);
+    const mode = x < first ? node.left : x > last ? node.right : 'extend';
+    if (mode === 'identity') return x;
+    if (mode === 'clamp') x = Math.min(last, Math.max(first, x));
+    let index = 0;
+    while (index < node.ranges.length - 2 && x >= node.ranges[index + 1]) index++;
+    const span = node.ranges[index + 1] - node.ranges[index];
+    const t = span ? (x - node.ranges[index]) / span : 0;
+    const from = node.outputs[index], to = node.outputs[index + 1];
+    if (node.color) {
+      this.outputs.set(node.id, '#' + from.map((value, i) => Math.round(value + (to[i] - value) * Math.min(1, Math.max(0, t))).toString(16).padStart(2, '0')).join(''));
+      return 0;
+    }
+    return from + (to - from) * t;
+  }
+}

pythonnative/devserver/static/bridge.js

@@ -0,0 +1,147 @@
+// The page's half of the PythonNative bridge.
+//
+// Python (`pythonnative.bridge.web.WebTransport`) sends JSON arrays over
+// one WebSocket. Fire-and-forget messages carry no id; requests carry an
+// id in slot 1 and are answered with ["res", id, result]. The same shape
+// works in the other direction: the page raises `callback(kind, tag,
+// name, payload)` as ["cb", ...] (no reply) or ["req", id, ...] (Python
+// answers with ["res", id, text]).
+//
+// Payloads that the native protocol carries as JSON *text* stay text
+// here too (`args`, `request`, `payload`, `result`), so the page and
+// Python reuse their existing codecs unchanged.
+
+export class Bridge {
+  constructor(url) {
+    this.url = url;
+    this.socket = null;
+    this.nextId = 1;
+    this.pending = new Map(); // id -> {resolve}
+    this.handlers = {}; // kind -> async (message) => result
+    this.onOpen = null;
+    this.onClose = null;
+    this.onDev = null;
+    this.connected = false;
+    this._backoff = 500;
+    this._closedByUs = false;
+  }
+
+  connect() {
+    this._closedByUs = false;
+    let socket;
+    try {
+      socket = new WebSocket(this.url);
+    } catch (err) {
+      this._scheduleReconnect();
+      return;
+    }
+    this.socket = socket;
+    socket.addEventListener("open", () => {
+      this.connected = true;
+      this._backoff = 500;
+      if (this.onOpen) this.onOpen();
+    });
+    socket.addEventListener("message", (event) => this._onMessage(event.data));
+    socket.addEventListener("close", (event) => {
+      const wasConnected = this.connected;
+      this.connected = false;
+      this.socket = null;
+      for (const waiter of this.pending.values()) waiter.resolve(null);
+      this.pending.clear();
+      if (this.onClose) this.onClose(wasConnected, event);
+      if (!this._closedByUs) this._scheduleReconnect();
+    });
+    socket.addEventListener("error", () => {
+      /* close follows */
+    });
+  }
+
+  close() {
+    this._closedByUs = true;
+    if (this.socket) this.socket.close();
+  }
+
+  _scheduleReconnect() {
+    const delay = this._backoff;
+    this._backoff = Math.min(this._backoff * 1.5, 4000);
+    setTimeout(() => this.connect(), delay);
+  }
+
+  send(message) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) return false;
+    this.socket.send(JSON.stringify(message));
+    return true;
+  }
+
+  // -- page -> Python -------------------------------------------------
+
+  /** Fire-and-forget callback: `callback(kind, tag, name, payload)`. */
+  callback(kind, tag, name, payload) {
+    return this.send(["cb", kind, tag, name, payload == null ? "" : payload]);
+  }
+
+  /** Callback that needs Python's answer (row binds, screen creation). */
+  request(kind, tag, name, payload) {
+    const id = this.nextId++;
+    return new Promise((resolve) => {
+      if (!this.send(["req", id, kind, tag, name, payload == null ? "" : payload])) {
+        resolve(null);
+        return;
+      }
+      this.pending.set(id, { resolve });
+    });
+  }
+
+  /** Dev-channel message (logs, errors) shown in the `pn start` terminal. */
+  dev(payload) {
+    return this.send(["dev", payload]);
+  }
+
+  // -- Python -> page -------------------------------------------------
+
+  async _onMessage(text) {
+    let message;
+    try {
+      message = JSON.parse(text);
+    } catch (err) {
+      console.error("[pn] malformed message", text.slice(0, 200));
+      return;
+    }
+    if (!Array.isArray(message) || message.length === 0) return;
+    const kind = message[0];
+    if (kind === "res") {
+      const waiter = this.pending.get(message[1]);
+      if (waiter) {
+        this.pending.delete(message[1]);
+        waiter.resolve(message.length > 2 ? message[2] : null);
+      }
+      return;
+    }
+    if (kind === "dev") {
+      if (this.onDev) this.onDev(message[1] || {});
+      return;
+    }
+    const handler = this.handlers[kind];
+    if (!handler) {
+      console.warn("[pn] unhandled message kind", kind);
+      if (kind !== "apply" && message.length > 1 && typeof message[1] === "number") {
+        this.send(["res", message[1], null]);
+      }
+      return;
+    }
+    const id = message[1];
+    let result = null;
+    try {
+      result = await handler(message);
+    } catch (err) {
+      this.reportError(`${kind} failed`, err);
+    }
+    if (id != null) this.send(["res", id, result === undefined ? null : result]);
+  }
+
+  reportError(context, err) {
+    const detail = err && err.stack ? err.stack : String(err);
+    console.error(`[pn] ${context}:`, err);
+    this.dev({ type: "error", text: `${context}: ${detail}` });
+  }
+}

pythonnative/devserver/static/colors.js

@@ -0,0 +1,70 @@
+// Color parsing that matches PNColor.swift / Colors.kt: `#RGB`, `#RGBA`,
+// `#RRGGBB`, `#AARRGGBB` (alpha first, the PythonNative convention),
+// `rgb()` / `rgba()`, CSS names, raw ARGB integers, `"transparent"`, and
+// `{"light": c, "dark": c}` dynamic colors resolved for the current
+// scheme. Returns a CSS color string or null.
+
+const COLOR_KEY = /(^|_)(color|colour)$/;
+
+export function isColorProp(key) {
+  return COLOR_KEY.test(key) || key === "tint" || key === "shadow_color";
+}
+
+export function color(value, scheme = "light") {
+  if (value == null) return null;
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const light = value.light ?? value.default;
+    const dark = value.dark;
+    if (light == null && dark == null) return null;
+    const pick = scheme === "dark" ? (dark ?? light) : (light ?? dark);
+    return color(pick, scheme);
+  }
+  if (typeof value === "number") return fromARGB(value);
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  if (!text) return null;
+  const lower = text.toLowerCase();
+  if (lower === "transparent" || lower === "clear" || lower === "none") return "transparent";
+  if (text.startsWith("#")) return parseHex(text.slice(1));
+  if (lower.startsWith("rgb")) return text;
+  if (/^[0-9a-f]{6}$|^[0-9a-f]{8}$/i.test(text)) return parseHex(text);
+  // Any other CSS color the browser knows (named colors and beyond).
+  return CSS.supports("color", text) ? text : null;
+}
+
+function fromARGB(value) {
+  let argb = Math.trunc(value);
+  if (argb < 0) argb += 0x1_0000_0000;
+  const a = ((argb >>> 24) & 0xff) / 255;
+  const r = (argb >>> 16) & 0xff;
+  const g = (argb >>> 8) & 0xff;
+  const b = argb & 0xff;
+  return `rgba(${r}, ${g}, ${b}, ${round(a)})`;
+}
+
+function parseHex(digits) {
+  let hex = digits;
+  switch (hex.length) {
+    case 3:
+      hex = "FF" + [...hex].map((c) => c + c).join("");
+      break;
+    case 4: {
+      const e = [...hex].map((c) => c + c);
+      hex = e[3] + e[0] + e[1] + e[2];
+      break;
+    }
+    case 6:
+      hex = "FF" + hex;
+      break;
+    case 8:
+      break;
+    default:
+      return null;
+  }
+  if (!/^[0-9a-f]{8}$/i.test(hex)) return null;
+  return fromARGB(parseInt(hex, 16));
+}
+
+function round(v) {
+  return Math.round(v * 1000) / 1000;
+}