Public demo with Nuitka-compiled wheel

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+polygen-0.1.0b1-cp313-cp313-linux_x86_64.whl filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,32 @@
+# Docker Space for the polygen tokenization demo (public).
+#
+# A gradio-SDK Space cannot install the wheel (HF mounts requirements.txt and
+# runs pip before copying repo files), and polygen requires Python 3.13. A
+# Docker base solves both. The wheel is Nuitka-compiled (a binary .so, no
+# readable source), so a public Space does not expose the SDK source;
+# mlx[cpu] resolves at install on Linux x86.
+FROM python:3.13-slim
+
+WORKDIR /app
+
+# git: required by HF Spaces' build wrapper (git config / dev-mode steps),
+# which the slim base lacks. curl is handy for healthchecks.
+RUN apt-get update && apt-get install -y --no-install-recommends git curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Deps first (wheel + requirements) so this layer caches across code edits.
+COPY requirements.txt polygen-0.1.0b1-cp313-cp313-linux_x86_64.whl ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# App code.
+COPY . .
+
+# gradio binds all interfaces on the HF app port; analytics off.
+ENV GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_SERVER_PORT=7860 \
+    GRADIO_ANALYTICS_ENABLED=False \
+    GRADIO_SSR_MODE=False \
+    GRADIO_TEMP_DIR=/tmp/gradio
+
+EXPOSE 7860
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,57 @@
 ---
-title: Polygen Demo
-emoji: 🌍
-colorFrom: red
-colorTo: yellow
+title: Datasent's Polygen Tokenization Demo
+emoji: 📈
+colorFrom: indigo
+colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Datasent's Polygen Tokenization Demo
+
+An interactive demo of Datasent's Polygen SDK on numeric signals. Pick a sample (or
+upload a CSV), and it tokenizes the signal through the real SDK and reports:
+
+- **Lossless round-trip** -- EXACT decode is bit-faithful to the 1/scale grid.
+- **COARSE analytics archive** -- coefficients only, tens to hundreds of times
+  smaller than raw, and directly queryable (the coefficients are a feature
+  vector).
+- **Per-segment anomaly signal** (sigma_R) -- a free quality marker; segments
+  the model fits poorly stand out.
+- **EXACT lossless size** shown honestly against gzip (it sits at parity --
+  polygen is a tokenizer, not a byte-compression replacement).
+
+Everything goes through the supported SDK surface: `DataMatrix.from_float` ->
+`PolygenTokenizer.tokenize(..., parallel=False)` with `BinaryEncoder` for a
+real token, and `tokenizer.decode` for EXACT / COARSE. The in-process
+`parallel=False` path means no multiprocessing pool, which keeps the Space
+light.
+
+## Running locally
+
+```bash
+pip install -r requirements.txt
+# plus polygen on the path (editable dev install or the stable wheel)
+POLYGEN_DEMO_LOCAL_MOCK=1 python app.py
+```
+
+`POLYGEN_DEMO_LOCAL_MOCK=1` generates a self-consistent throwaway license for
+local dev (the same pattern `tests/conftest.py` uses). Do not set it in
+production.
+
+## Deploying to a HuggingFace Space
+
+1. Install `polygen` via `requirements.txt` (point at the stable wheel URL).
+2. Set the `POLYGEN_LICENSE` secret to a real JWT issued for that wheel.
+   - Note: this depends on the license keypair being aligned (audit finding
+     F8). The bundled public key must match the key that signed the JWT.
+3. Leave `POLYGEN_DEMO_LOCAL_MOCK` unset so the SDK validates the real license.
+
+## Notes
+
+- This is a prototype. CPU-only; no GPU / RunPod needed (polygen tokenization
+  is CPU-light). RunPod is only warranted for GPU demos such as the VLM Space.
+- Decide stable-vs-dev SDK before a customer-facing deploy. This prototype
+  uses dev-only surface (`from_float`, `sigma_r`, `DecodeMode`, the
+  `parallel=False` path). The frozen stable wheel currently lacks some of it.

app.py

@@ -0,0 +1,155 @@
+"""Polygen tokenization demo -- Gradio Space.
+
+Tokenizes a numeric signal through the polygen SDK and shows what the
+tokenizer buys you beyond byte compression: a lossless round-trip, a compact
+queryable analytics archive (COARSE), and a per-segment anomaly signal
+(sigma_R). EXACT lossless is shown honestly -- it sits at gzip parity; the
+wins are the analytics archive, the coefficients-as-features, and the anomaly
+signal, none of which a byte codec can provide.
+
+Local: ``POLYGEN_DEMO_LOCAL_MOCK=1 python app.py``.
+Deploy: set the ``POLYGEN_LICENSE`` secret on the Space.
+"""
+
+import license_bootstrap
+
+license_bootstrap.ensure_license()  # must run before polygen is imported
+
+import gradio as gr  # noqa: E402
+import numpy as np  # noqa: E402
+
+import demo_core  # noqa: E402
+import plots  # noqa: E402
+
+# Datasent 2026 brand: Minsk purple primary, bright blue accent, lavender
+# light shades, white page. Mirrors docs/polygen_theme/custom.css and the
+# qwen2vl_polygen Space, so the two demos share a house style.
+THEME = gr.themes.Soft(
+    primary_hue="indigo",
+    neutral_hue="slate",
+    text_size=gr.themes.sizes.text_md,
+    radius_size=gr.themes.sizes.radius_lg,
+).set(
+    block_border_width="1px",
+    block_shadow="*shadow_drop_lg",
+    button_primary_text_color="white",
+)
+
+BRAND_CSS = """
+:root {
+  --ds-minsk:#3c3475; --ds-blue:#4caaff; --ds-dark-3:#6464a0;
+  --ds-light-2:#ced8f8; --ds-light-4:#e6ebfc;
+}
+#ds-hero { text-align:center; padding:14px 0 4px 0; }
+#ds-hero img { height:34px; display:block; margin:0 auto 10px; }
+#ds-hero .eyebrow { font-size:0.8em; letter-spacing:0.18em; text-transform:uppercase;
+  color:var(--ds-dark-3); margin-bottom:6px; }
+#ds-hero h1 { margin:0 0 8px 0; font-size:2.1em; line-height:1.1; color:var(--ds-minsk); }
+#ds-hero .tagline { color:#555; font-size:1.05em; max-width:680px; margin:0 auto; }
+#ds-summary h3 { color:var(--ds-minsk); }
+#ds-summary strong { color:var(--ds-minsk); }
+#ds-summary a { color:var(--ds-blue); }
+#ds-summary table th { background:var(--ds-light-4); color:var(--ds-minsk); }
+#ds-summary table tr:nth-child(even) td { background:var(--ds-light-4); }
+"""
+
+HERO_HTML = """
+<div id="ds-hero">
+  <img src="https://datasent-demo.com/images/datasent-logo.svg" alt="Datasent"
+       onerror="this.style.display='none'"/>
+  <div class="eyebrow">Datasent &middot; Polygen</div>
+  <h1>Tokenization Demo</h1>
+  <div class="tagline">Fit a compact model to each window of a numeric signal and
+    store it as a token. Lossless when you want it, a tiny queryable archive when
+    you don't, and a built-in anomaly signal either way.</div>
+</div>
+"""
+
+
+def _load_signal(sample_name: str, csv_file) -> np.ndarray:
+    if csv_file is not None:
+        # gradio 5 returns a filepath string; 6 may return an object with .name.
+        path = getattr(csv_file, "name", csv_file)
+        raw = np.genfromtxt(path, delimiter=",", skip_header=0)
+        arr = np.asarray(raw, dtype=np.float32)
+        if arr.ndim == 1:
+            arr = arr.reshape(-1, 1)
+        # Drop all-NaN columns (header rows etc.) and NaN rows.
+        arr = arr[:, ~np.all(np.isnan(arr), axis=0)]
+        arr = arr[~np.any(np.isnan(arr), axis=1)]
+        if arr.size == 0:
+            raise gr.Error("Could not parse numeric columns from the CSV.")
+        return arr
+    return demo_core.SAMPLES[sample_name]()
+
+
+def _summary(r: dict) -> str:
+    anom = int(np.sum(r["sigma_r"] > np.mean(r["sigma_r"]) + 2 * np.std(r["sigma_r"]))) if r["segments"] > 1 else 0
+    bases = ", ".join(f"{k} x{v}" for k, v in r["bases_used"].items())
+    picker = "MDL chose" if r["basis_mode"] == "auto" else "fixed"
+    return f"""
+### Results -- {r["n"]:,} rows x {r["d"]} channel(s), {r["segments"]} segments
+
+| What | Result |
+|---|---|
+| **Bases ({picker})** | {bases} |
+| **Lossless round-trip** | max error **{r["max_err"]:.1e}** (exact to the 1/{r["scale"]} grid) |
+| **COARSE analytics archive** | **{r["coarse_ratio_vs_raw"]:.0f}x** smaller than raw -- coefficients only, queryable directly |
+| **EXACT lossless archive** | {r["token_size"] / 1024:.1f} KB vs gzip {r["gzip_size"] / 1024:.1f} KB (**{r["ratio_vs_gzip"]:.2f}x**) |
+| **Anomaly segments flagged** | **{anom}** of {r["segments"]} (sigma_R > mean + 2 sigma) |
+
+Polygen is a tokenizer, not a gzip replacement. With **MDL multi-basis** the
+SDK picks the best basis family per segment. EXACT lossless sits near gzip; the
+value a byte codec cannot match is the COARSE archive (the signal's shape at a
+fraction of the size), the coefficients as a ready-to-use feature vector, and a
+per-segment anomaly score for free.
+""".strip()
+
+
+def run(sample_name: str, csv_file, basis_mode: str, degree: int, segment_length: int):
+    signal = _load_signal(sample_name, csv_file)
+    r = demo_core.run_demo(
+        signal, basis_mode=basis_mode, degree=int(degree), segment_length=int(segment_length),
+    )
+    return _summary(r), plots.fig_reconstruction(r), plots.fig_sigma(r), plots.fig_sizes(r)
+
+
+def build_ui() -> gr.Blocks:
+    with gr.Blocks(title="Datasent's Polygen Tokenization Demo", theme=THEME, css=BRAND_CSS) as ui:
+        gr.HTML(HERO_HTML)
+        with gr.Row():
+            with gr.Column(scale=1):
+                sample = gr.Dropdown(
+                    choices=list(demo_core.SAMPLES), value=list(demo_core.SAMPLES)[0],
+                    label="Sample signal",
+                )
+                csv = gr.File(label="...or upload a numeric CSV", file_types=[".csv"])
+                basis_mode = gr.Radio(
+                    choices=[("MDL multi-basis (auto)", "auto"), ("Chebyshev only", "chebyshev")],
+                    value="auto",
+                    label="Basis selection",
+                )
+                degree = gr.Slider(1, 10, value=5, step=1, label="Polynomial degree")
+                seg = gr.Slider(100, 2000, value=500, step=100, label="Segment length")
+                go = gr.Button("Tokenize", variant="primary")
+            with gr.Column(scale=2):
+                summary = gr.Markdown(elem_id="ds-summary")
+        recon = gr.Plot(label="Reconstruction")
+        with gr.Row():
+            sigma = gr.Plot(label="Anomaly signal")
+            sizes = gr.Plot(label="Stored size")
+        inputs = [sample, csv, basis_mode, degree, seg]
+        outputs = [summary, recon, sigma, sizes]
+        go.click(run, inputs, outputs)
+        ui.load(run, inputs, outputs)
+    return ui
+
+
+# HuggingFace Spaces auto-launches a module-level ``demo``. Building it at
+# import requires a valid license: the POLYGEN_LICENSE secret on the Space,
+# or POLYGEN_DEMO_LOCAL_MOCK=1 locally (handled by ensure_license above).
+demo = build_ui()
+
+if __name__ == "__main__":
+    # ssr_mode=False: gradio 5 SSR renders blank behind HF Spaces' proxy.
+    demo.launch(ssr_mode=False)

demo_core.py

@@ -0,0 +1,221 @@
+"""Core polygen demo logic: tokenize a numeric signal through the SDK and
+measure real compression, lossless round-trip, and the per-segment anomaly
+signal.
+
+Pure compute -- no Gradio, no license handling. Import only after polygen is
+importable (see ``license_bootstrap`` for local runs). Everything here goes
+through the supported SDK surface: ``DataMatrix.from_float`` ->
+``PolygenTokenizer.tokenize(..., parallel=False)`` -> ``BinaryEncoder`` for a
+real token, and ``tokenizer.decode`` for EXACT / COARSE reconstruction. The
+in-process ``parallel=False`` path keeps the demo free of a multiprocessing
+pool, which matters in a hosted Space.
+"""
+
+import gzip
+import io
+from collections import Counter
+
+import numpy as np
+import zstandard as zstd
+
+from polygen.data import DataMatrix
+from polygen.encoder import BinaryEncoder
+from polygen.tokenizer import DecodeMode, PolygenTokenizer
+from polygen.tokenizer.basis import BASIS_REGISTRY, ChebyshevBasis
+
+SCALE = 1000
+
+
+def _basis_name(basis_id: int) -> str:
+    """Human label for a segment's chosen basis family."""
+    if basis_id == 0:
+        return "Chebyshev"  # explicit (non-MDL) path stores basis_id 0
+    cls = BASIS_REGISTRY.get(basis_id)
+    return cls.__name__.replace("Basis", "") if cls is not None else f"id{basis_id}"
+
+
+def _as_2d_float32(signal: np.ndarray) -> np.ndarray:
+    """Coerce input to a 2D float32 array with shape ``(N, D)``."""
+    arr = np.asarray(signal, dtype=np.float32)
+    if arr.ndim == 1:
+        arr = arr.reshape(-1, 1)
+    if arr.ndim != 2:
+        raise ValueError(f"Expected 1D or 2D numeric data, got shape {arr.shape}.")
+    return arr
+
+
+def run_demo(
+    signal: np.ndarray,
+    *,
+    basis_mode: str = "auto",
+    degree: int = 5,
+    segment_length: int = 200,
+) -> dict:
+    """Tokenize ``signal`` with the polygen SDK and return metrics + arrays.
+
+    Args:
+        signal: 1D or 2D numeric array. Columns are channels.
+        basis_mode: ``"auto"`` runs the per-segment MDL selector across all
+            basis families (multi-basis); ``"chebyshev"`` applies a single
+            fixed Chebyshev basis to every segment.
+        degree: polynomial degree (coefficient budget is degree + 1); for
+            ``"auto"`` it is the MDL base degree.
+        segment_length: rows per fitted window.
+
+    Returns:
+        A dict of measured sizes, ratios, the max lossless-decode error, the
+        chosen-basis breakdown, and the arrays needed to plot.
+    """
+    data = _as_2d_float32(signal)
+    n, d = data.shape
+    segment_length = int(max(16, min(segment_length, n)))
+
+    matrix = DataMatrix.from_float(data, scale=SCALE)
+
+    if basis_mode == "auto":
+        # Per-segment MDL selection across the basis registry (multi-basis).
+        tokenizer = PolygenTokenizer(
+            basis="auto",
+            degree=degree,
+            encoder=BinaryEncoder(),
+            preprocess=True,
+            fast_profile=True,
+        )
+    else:
+        tokenizer = PolygenTokenizer(
+            basis=ChebyshevBasis,
+            degree=degree,
+            encoder=BinaryEncoder(),
+            preprocess=True,
+        )
+
+    # Real binary token -> a true compressed-size number, not an estimate.
+    buf = io.BytesIO()
+    output = tokenizer.tokenize(
+        matrix,
+        segment_length=segment_length,
+        encode=True,
+        encoder_options={"output": buf},
+        parallel=False,
+    )
+    token_size = len(buf.getvalue())
+
+    metas = [c[0] for c in output.components]
+    coeffs = [c[1] for c in output.components]
+    resids = [c[2] for c in output.components]
+
+    # EXACT = lossless (prediction + residual). COARSE = prediction only.
+    exact = np.asarray(
+        tokenizer.decode((n, d), metas, coeffs, resids, mode=DecodeMode.EXACT),
+    )
+    coarse = np.asarray(
+        tokenizer.decode((n, d), metas, coeffs, resids, mode=DecodeMode.COARSE),
+    )
+    exact_float = exact / SCALE
+    coarse_float = coarse / SCALE
+    max_err = float(np.max(np.abs(exact_float - data)))
+
+    # Baselines measured on the same raw float32 bytes.
+    raw_bytes = data.astype(np.float32).tobytes()
+    raw_size = len(raw_bytes)
+    gzip_size = len(gzip.compress(raw_bytes, 6))
+
+    # Coefficients-only ("analytics" / COARSE delivery) size: the same Zstd
+    # codec the encoder uses, applied to just the coefficient block.
+    coeff_blob = (
+        np.concatenate([np.asarray(c).ravel() for c in coeffs])
+        .astype(np.float32)
+        .tobytes()
+    )
+    coeff_size = len(zstd.ZstdCompressor(level=3).compress(coeff_blob))
+
+    sigma_r = np.array([float(m.sigma_r) for m in metas], dtype=float)
+    seg_starts = np.array([int(m.start) for m in metas], dtype=int)
+    bases_used = dict(
+        sorted(Counter(_basis_name(m.basis_id) for m in metas).items(), key=lambda kv: -kv[1]),
+    )
+
+    return {
+        "n": n,
+        "d": d,
+        "segments": len(metas),
+        "segment_length": segment_length,
+        "degree": degree,
+        "scale": SCALE,
+        "basis_mode": basis_mode,
+        "bases_used": bases_used,
+        "raw_size": raw_size,
+        "gzip_size": gzip_size,
+        "token_size": token_size,
+        "coeff_size": coeff_size,
+        "ratio_vs_raw": raw_size / token_size if token_size else 0.0,
+        "ratio_vs_gzip": gzip_size / token_size if token_size else 0.0,
+        "coarse_ratio_vs_raw": raw_size / coeff_size if coeff_size else 0.0,
+        "max_err": max_err,
+        "original": data,
+        "exact": exact_float,
+        "coarse": coarse_float,
+        "sigma_r": sigma_r,
+        "seg_starts": seg_starts,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Synthetic sample signals (deterministic; no external data dependency).
+# ---------------------------------------------------------------------------
+
+def _mixed_character(n: int = 16000) -> np.ndarray:
+    # Smooth polynomial first half, high-frequency oscillation second half.
+    # MDL should pick a polynomial family for the smooth segments and an
+    # oscillatory family (Fourier / Wavelet) for the rest -- a real mix.
+    rng = np.random.default_rng(4)
+    t = np.linspace(0, 1, n)
+    half = n // 2
+    x = np.empty(n)
+    x[:half] = 3.0 * t[:half] ** 2 - 1.5 * t[:half] + 0.5
+    x[half:] = 0.8 * np.sin(2 * np.pi * 60 * t[half:]) + 0.4 * np.sin(2 * np.pi * 140 * t[half:])
+    return (x + rng.normal(0, 0.02, n)).astype(np.float32)
+
+
+def _temperature(n: int = 16000) -> np.ndarray:
+    rng = np.random.default_rng(0)
+    t = np.linspace(0, 8, n)
+    trend = 18.0 + 0.4 * t
+    daily = 6.0 * np.sin(2 * np.pi * t)
+    return (trend + daily + rng.normal(0, 0.3, n)).astype(np.float32)
+
+
+def _ecg_like(n: int = 16000) -> np.ndarray:
+    rng = np.random.default_rng(1)
+    x = np.zeros(n, dtype=np.float64)
+    period = 80
+    for c in range(0, n, period):
+        peak = min(c + 6, n)
+        x[c:peak] += np.hanning(2 * (peak - c))[: peak - c] * 3.0
+    x += 0.2 * np.sin(np.linspace(0, 40 * np.pi, n)) + rng.normal(0, 0.05, n)
+    return x.astype(np.float32)
+
+
+def _vibration_with_anomaly(n: int = 16000) -> np.ndarray:
+    rng = np.random.default_rng(2)
+    t = np.linspace(0, 1, n)
+    base = np.sin(2 * np.pi * 12 * t) + 0.5 * np.sin(2 * np.pi * 30 * t)
+    # Injected transient burst in one region -> should light up sigma_R there.
+    burst = np.zeros(n)
+    s = int(n * 0.62)
+    burst[s : s + 120] = 4.0 * np.sin(2 * np.pi * 90 * t[s : s + 120])
+    return (base + burst + rng.normal(0, 0.05, n)).astype(np.float32)
+
+
+def _random_walk(n: int = 16000) -> np.ndarray:
+    rng = np.random.default_rng(3)
+    return np.cumsum(rng.normal(0, 1, n)).astype(np.float32)
+
+
+SAMPLES = {
+    "Mixed character (smooth then oscillatory)": _mixed_character,
+    "Temperature sensor (smooth + daily cycle)": _temperature,
+    "ECG-like (periodic spikes)": _ecg_like,
+    "Vibration with injected anomaly": _vibration_with_anomaly,
+    "Random walk (hard to compress -- honest baseline)": _random_walk,
+}

license_bootstrap.py

@@ -0,0 +1,78 @@
+"""License bootstrap for the polygen demo.
+
+The polygen SDK validates a license at import time. Two modes:
+
+- **Deploy (HuggingFace Space):** set the ``POLYGEN_LICENSE`` secret to a real
+  JWT issued for the deployed wheel. Leave ``POLYGEN_DEMO_LOCAL_MOCK`` unset;
+  ``ensure_license`` is then a no-op and the SDK validates normally.
+- **Local dev:** set ``POLYGEN_DEMO_LOCAL_MOCK=1``. This generates a
+  self-consistent RSA keypair, signs a short-lived JWT with it, and patches
+  the SDK's public-key lookup to the matching key -- the same pattern
+  ``tests/conftest.py`` uses for ad-hoc scripts. No real license needed.
+
+``ensure_license`` MUST run before ``import polygen``.
+"""
+
+import os
+
+
+def apply_local_mock() -> None:
+    """Generate a self-consistent license and patch the SDK key lookup."""
+    import datetime
+    from pathlib import Path
+    from unittest import mock
+
+    import jwt
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric import rsa
+
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=4096)
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+    os.environ["POLYGEN_LICENSE"] = jwt.encode(
+        {
+            "iss": "https://license.datasent.com",
+            "sub": "polygen demo (local mock)",
+            "aud": "polygen-sdk",
+            "email": "demo@datasent.com",
+            "iat": now,
+            "exp": now + datetime.timedelta(hours=12),
+        },
+        key=private_pem,
+        algorithm="PS512",
+    )
+
+    mock_path = mock.Mock(spec=Path)
+    mock_path.joinpath.return_value = mock_path
+    mock_path.__truediv__ = mock.Mock(return_value=mock_path)
+    mock_path.read_text.return_value = public_pem
+
+    # Scope the patch to polygen's license lookup ONLY. A global patch of
+    # importlib.resources.files (as in tests/conftest.py) breaks any other
+    # library that locates package resources -- e.g. gradio/starlette loading
+    # Jinja templates. Delegate every other anchor to the real ``files``.
+    import importlib.resources as _ir
+
+    real_files = _ir.files
+
+    def fake_files(*args, **kwargs):
+        if args and args[0] == "polygen._license":
+            return mock_path
+        return real_files(*args, **kwargs)
+
+    mock.patch("importlib.resources.files", side_effect=fake_files).start()
+
+
+def ensure_license() -> None:
+    """Apply the local mock when requested; otherwise rely on POLYGEN_LICENSE."""
+    if os.environ.get("POLYGEN_DEMO_LOCAL_MOCK") == "1":
+        apply_local_mock()

plots.py

@@ -0,0 +1,62 @@
+"""Matplotlib figures for the polygen demo. No Gradio dependency, so the
+plots can be rendered and tested independently of the UI."""
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+ACCENT, EXACT_C, COARSE_C, ANOM_C = "#2b2bff", "#1a1a1a", "#d08400", "#c0392b"
+
+
+def fig_reconstruction(r: dict):
+    """Original vs EXACT (lossless) vs COARSE (smooth fit only), channel 0."""
+    fig, ax = plt.subplots(figsize=(8, 3.2))
+    ch = r["original"][:, 0]
+    view = slice(0, min(len(ch), 2000))  # readable window
+    x = np.arange(len(ch))[view]
+    ax.plot(x, ch[view], color="#bbbbbb", lw=2.4, label="original")
+    ax.plot(x, r["exact"][:, 0][view], color=EXACT_C, lw=0.9, label="EXACT decode (lossless)")
+    ax.plot(x, r["coarse"][:, 0][view], color=COARSE_C, lw=1.2, ls="--", label="COARSE (smooth fit only)")
+    ax.set_title("Reconstruction: EXACT is bit-faithful; COARSE is the smooth fit")
+    ax.set_xlabel("position")
+    ax.legend(loc="upper right", fontsize=8, frameon=False)
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    return fig
+
+
+def fig_sigma(r: dict):
+    """Per-segment sigma_R, with anomalies (mean + 2 sigma) highlighted."""
+    fig, ax = plt.subplots(figsize=(8, 2.8))
+    s = r["sigma_r"]
+    idx = np.arange(len(s))
+    thresh = float(np.mean(s) + 2 * np.std(s)) if len(s) > 1 else float("inf")
+    colors = [ANOM_C if v > thresh else ACCENT for v in s]
+    ax.bar(idx, s, color=colors)
+    if np.isfinite(thresh):
+        ax.axhline(thresh, color=ANOM_C, ls="--", lw=1, label="mean + 2 sigma")
+        ax.legend(loc="upper right", fontsize=8, frameon=False)
+    ax.set_title("Per-segment anomaly signal (sigma_R) -- free, no extra model")
+    ax.set_xlabel("segment")
+    ax.set_ylabel("sigma_R")
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    return fig
+
+
+def fig_sizes(r: dict):
+    """Stored size: raw / gzip / polygen EXACT / polygen COARSE (log scale)."""
+    fig, ax = plt.subplots(figsize=(8, 2.8))
+    labels = ["raw\nfloat32", "gzip", "polygen\nEXACT", "polygen\nCOARSE\n(coeffs)"]
+    vals = [r["raw_size"] / 1024, r["gzip_size"] / 1024, r["token_size"] / 1024, r["coeff_size"] / 1024]
+    ax.bar(labels, vals, color=["#bbbbbb", "#888888", EXACT_C, COARSE_C])
+    ax.set_yscale("log")
+    ax.set_ylabel("KB (log scale)")
+    ax.set_title("Stored size: EXACT ~ gzip parity; COARSE is the analytics archive")
+    for i, v in enumerate(vals):
+        ax.text(i, v, f"{v:.1f}", ha="center", va="bottom", fontsize=8)
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    return fig

polygen-0.1.0b1-cp313-cp313-linux_x86_64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25b627c7938e1a3b6bac70b05658b22eedd5c72781c0558f62da12f3669d7544
+size 1032097

requirements.txt

@@ -0,0 +1,7 @@
+# Demo dependencies. polygen -- and its mlx[cpu] backend on Linux -- comes
+# from the vendored Nuitka-compiled wheel (a binary .so, no readable source;
+# the matching demo JWT is the POLYGEN_LICENSE Space secret).
+gradio==5.34.0
+requests
+matplotlib
+./polygen-0.1.0b1-cp313-cp313-linux_x86_64.whl