Rewrite app.py with JS-based file upload, Gradio 5.12.0

README.md

@@ -4,8 +4,7 @@ emoji: 🗜️
 colorFrom: blue
 colorTo: indigo
 sdk: gradio
-sdk_version: "4.44.0"
-python_version: "3.11"
+sdk_version: "5.12.0"
 app_file: app.py
 pinned: false
 ---

app.py

@@ -1,124 +1,287 @@
-import gradio as gr
-import subprocess
+#!/usr/bin/env python3
+"""Midicoth -- Micro-Diffusion Compression -- Hugging Face Space Demo."""
+
 import os
+import base64
 import tempfile
-import shutil
+import subprocess
+import gradio as gr
 
 # ---------------------------------------------------------------------------
 # Build the mdc binary once at startup
 # ---------------------------------------------------------------------------
 
-BINARY = os.path.join(os.path.dirname(__file__), "mdc")
+BINARY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mdc")
+
 
 def _build():
-    src = os.path.join(os.path.dirname(__file__), "mdc.c")
-    result = subprocess.run(
-        ["gcc", "-O3", "-o", BINARY, src, "-lm"],
-        capture_output=True, text=True
-    )
+    src = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mdc.c")
+    result = subprocess.run(["gcc", "-O3", "-o", BINARY, src, "-lm"],
+                            capture_output=True, text=True)
     if result.returncode != 0:
-        raise RuntimeError(f"Failed to compile mdc:\n{result.stderr}")
+        raise RuntimeError(f"Compilation failed:\n{result.stderr}")
+
 
 if not os.path.isfile(BINARY):
     _build()
 
+
 # ---------------------------------------------------------------------------
-# Core helpers
+# Helpers
 # ---------------------------------------------------------------------------
 
-def _run(args, label):
-    result = subprocess.run(args, capture_output=True, text=True)
-    if result.returncode != 0:
-        raise RuntimeError(f"{label} failed:\n{result.stderr or result.stdout}")
+def _fmt(n):
+    if n < 1024:
+        return f"{n} B"
+    if n < 1024 ** 2:
+        return f"{n / 1024:.1f} KB"
+    return f"{n / 1024 ** 2:.2f} MB"
+
+
+def _download_link(b64_data, filename, label, color="#6366f1"):
+    size = len(base64.b64decode(b64_data))
+    return (
+        f'<a download="{filename}" '
+        f'href="data:application/octet-stream;base64,{b64_data}" '
+        f'style="display:inline-block;padding:10px 24px;background:{color};color:white;'
+        f'border-radius:8px;text-decoration:none;font-weight:bold;font-size:14px;'
+        f'margin-top:8px;cursor:pointer;">'
+        f'{label} ({_fmt(size)})</a>'
+    )
+
+
+# ---------------------------------------------------------------------------
+# Compress
+# ---------------------------------------------------------------------------
+
+def compress_b64(b64_data, filename):
+    if not b64_data or not b64_data.strip():
+        return "Please upload a file using the button above.", ""
 
-def compress(input_file):
-    if input_file is None:
-        raise gr.Error("Please upload a file.")
-    workdir = tempfile.mkdtemp()
     try:
-        out_path = os.path.join(workdir, os.path.basename(input_file) + ".mdc")
-        _run([BINARY, "compress", input_file, out_path], "Compression")
-        in_size  = os.path.getsize(input_file)
-        out_size = os.path.getsize(out_path)
-        ratio    = out_size / in_size * 100
-        bpb      = out_size * 8 / in_size
-        info = (
-            f"Input:  {in_size:,} bytes\n"
-            f"Output: {out_size:,} bytes\n"
-            f"Ratio:  {ratio:.1f}%  ({bpb:.3f} bpb)"
-        )
-        # Copy to a stable temp file that Gradio can serve
-        dest = tempfile.NamedTemporaryFile(
-            delete=False, suffix=".mdc",
-            dir=workdir
-        )
-        dest.close()
-        shutil.copy2(out_path, dest.name)
-        return dest.name, info
-    except RuntimeError as e:
-        shutil.rmtree(workdir, ignore_errors=True)
-        raise gr.Error(str(e))
-
-def decompress(input_file):
-    if input_file is None:
-        raise gr.Error("Please upload a .mdc file.")
-    workdir = tempfile.mkdtemp()
+        data = base64.b64decode(b64_data.strip())
+    except Exception:
+        return "**Failed to read uploaded file.**", ""
+
+    if len(data) == 0:
+        return "**Empty file.**", ""
+
+    with tempfile.TemporaryDirectory() as workdir:
+        in_path = os.path.join(workdir, "input")
+        out_path = os.path.join(workdir, "output.mdc")
+        with open(in_path, "wb") as f:
+            f.write(data)
+        result = subprocess.run([BINARY, "compress", in_path, out_path],
+                                capture_output=True, text=True)
+        if result.returncode != 0:
+            return f"**Compression failed:**\n{result.stderr or result.stdout}", ""
+        with open(out_path, "rb") as f:
+            compressed = f.read()
+
+    in_size = len(data)
+    out_size = len(compressed)
+    ratio = out_size / in_size * 100
+    bpb = out_size * 8 / in_size
+    out_name = (filename.strip() + ".mdc") if filename and filename.strip() else "compressed.mdc"
+    b64_out = base64.b64encode(compressed).decode("ascii")
+
+    md = f"""## Compression Results
+
+| | Size | Ratio |
+|---|---|---|
+| **Original** | {_fmt(in_size)} | 100% |
+| **Midicoth** | {_fmt(out_size)} | {ratio:.1f}% |
+
+**bpb:** {bpb:.3f} &nbsp;|&nbsp; **Space saved:** {100 - ratio:.1f}%
+"""
+    return md, _download_link(b64_out, out_name, f"Download {out_name}")
+
+
+# ---------------------------------------------------------------------------
+# Decompress
+# ---------------------------------------------------------------------------
+
+def decompress_b64(b64_data):
+    if not b64_data or not b64_data.strip():
+        return "Please upload a .mdc file using the button above.", ""
+
     try:
-        base = os.path.basename(input_file)
-        if base.endswith(".mdc"):
-            out_name = base[:-4] or "restored"
-        else:
-            out_name = base + ".restored"
-        out_path = os.path.join(workdir, out_name)
-        _run([BINARY, "decompress", input_file, out_path], "Decompression")
-        out_size = os.path.getsize(out_path)
-        info = f"Restored: {out_size:,} bytes"
-        dest = tempfile.NamedTemporaryFile(
-            delete=False,
-            suffix=os.path.splitext(out_name)[1] or ".bin",
-            dir=workdir
-        )
-        dest.close()
-        shutil.copy2(out_path, dest.name)
-        return dest.name, info
-    except RuntimeError as e:
-        shutil.rmtree(workdir, ignore_errors=True)
-        raise gr.Error(str(e))
+        data = base64.b64decode(b64_data.strip())
+    except Exception:
+        return "**Failed to read uploaded file.**", ""
+
+    if len(data) < 12:
+        return "**Invalid file.** Too short to be a Midicoth file.", ""
+
+    if data[:4] != b"MDC7":
+        return "**Invalid file.** Not a Midicoth file (wrong magic bytes).", ""
+
+    with tempfile.TemporaryDirectory() as workdir:
+        in_path = os.path.join(workdir, "input.mdc")
+        out_path = os.path.join(workdir, "output")
+        with open(in_path, "wb") as f:
+            f.write(data)
+        result = subprocess.run([BINARY, "decompress", in_path, out_path],
+                                capture_output=True, text=True)
+        if result.returncode != 0:
+            return f"**Decompression failed:**\n{result.stderr or result.stdout}", ""
+        with open(out_path, "rb") as f:
+            restored = f.read()
+
+    in_size = len(data)
+    out_size = len(restored)
+    b64_out = base64.b64encode(restored).decode("ascii")
+
+    md = f"""## Decompression Results
+
+- Compressed: {_fmt(in_size)}
+- Restored: {_fmt(out_size)}
+- **Lossless reconstruction successful**
+"""
+    return md, _download_link(b64_out, "decompressed.bin", "Download decompressed", color="#22c55e")
+
+
+# ---------------------------------------------------------------------------
+# JavaScript for binary file upload (reads as base64, injects into hidden Textbox)
+# ---------------------------------------------------------------------------
+
+COMPRESS_UPLOAD_JS = """
+function setupCompressUpload() {
+    const input = document.getElementById('compress-file-input');
+    if (!input) return;
+    input.addEventListener('change', function(e) {
+        const file = e.target.files[0];
+        if (!file) return;
+        const nameSpan = document.getElementById('compress-file-name');
+        if (nameSpan) nameSpan.textContent = file.name + ' (' + (file.size / 1024).toFixed(1) + ' KB)';
+        const fnBoxes = document.querySelectorAll('#compress-filename textarea');
+        if (fnBoxes.length > 0) {
+            fnBoxes[0].value = file.name;
+            fnBoxes[0].dispatchEvent(new Event('input', {bubbles: true}));
+        }
+        const reader = new FileReader();
+        reader.onload = function(ev) {
+            const b64 = ev.target.result.split(',')[1];
+            const textareas = document.querySelectorAll('#compress-b64-data textarea');
+            if (textareas.length > 0) {
+                textareas[0].value = b64;
+                textareas[0].dispatchEvent(new Event('input', {bubbles: true}));
+            }
+        };
+        reader.readAsDataURL(file);
+    });
+}
+setTimeout(setupCompressUpload, 1000);
+"""
+
+DECOMPRESS_UPLOAD_JS = """
+function setupDecompressUpload() {
+    const input = document.getElementById('decompress-file-input');
+    if (!input) return;
+    input.addEventListener('change', function(e) {
+        const file = e.target.files[0];
+        if (!file) return;
+        const nameSpan = document.getElementById('decompress-file-name');
+        if (nameSpan) nameSpan.textContent = file.name + ' (' + (file.size / 1024).toFixed(1) + ' KB)';
+        const reader = new FileReader();
+        reader.onload = function(ev) {
+            const b64 = ev.target.result.split(',')[1];
+            const textareas = document.querySelectorAll('#decompress-b64-data textarea');
+            if (textareas.length > 0) {
+                textareas[0].value = b64;
+                textareas[0].dispatchEvent(new Event('input', {bubbles: true}));
+            }
+        };
+        reader.readAsDataURL(file);
+    });
+}
+setTimeout(setupDecompressUpload, 1200);
+"""
 
 # ---------------------------------------------------------------------------
-# Gradio UI
+# UI
 # ---------------------------------------------------------------------------
 
+HEADER_HTML = """
+<div style="text-align:center;margin-bottom:0.5em;">
+    <h1 style="font-size:2em;margin-bottom:0.2em;">🗜️ Midicoth</h1>
+    <p style="font-size:1.1em;color:#aaa;margin-top:4px;">Micro-Diffusion Compression &mdash; Binary Tree Tweedie Denoising</p>
+    <p style="font-size:0.9em;">
+        <a href="https://github.com/robtacconelli/midicoth">GitHub</a> |
+        No neural network &bull; No GPU &bull; ~2,000 lines of C &bull;
+        Outperforms xz, zstd, Brotli, bzip2 on text
+    </p>
+</div>
+"""
+
 with gr.Blocks(title="Midicoth — Micro-Diffusion Compression") as demo:
-    gr.Markdown(
-        """
-# Midicoth — Micro-Diffusion Compression
-Lossless text compressor using **Binary Tree Tweedie Denoising**.
-Outperforms xz, zstd, Brotli, and bzip2 on text data. No neural network, no GPU.
-
-> **Note:** Files are processed in memory and deleted after the session.
-> Large files (>10 MB) may be slow on free-tier hardware.
-        """
-    )
+    gr.HTML(HEADER_HTML)
 
+    # ---- Tab 1: Compress ----
     with gr.Tab("Compress"):
-        with gr.Row():
-            c_input  = gr.File(label="Input file", file_types=["*"])
-        with gr.Row():
-            c_btn    = gr.Button("Compress", variant="primary")
-        with gr.Row():
-            c_output = gr.File(label="Compressed (.mdc)")
-            c_info   = gr.Textbox(label="Stats", lines=3, interactive=False)
-        c_btn.click(compress, inputs=c_input, outputs=[c_output, c_info])
+        gr.Markdown("Upload any file to compress with Midicoth.")
+        gr.HTML(
+            '<div style="margin:8px 0;">'
+            '<label style="display:inline-block;padding:10px 24px;background:#6366f1;color:white;'
+            'border-radius:8px;cursor:pointer;font-weight:bold;font-size:14px;">'
+            'Choose file to compress'
+            '<input id="compress-file-input" type="file" style="display:none;">'
+            '</label>'
+            '<span id="compress-file-name" style="margin-left:10px;color:#aaa;"></span>'
+            '</div>'
+        )
+        compress_b64_data = gr.Textbox(visible=False, elem_id="compress-b64-data")
+        compress_filename  = gr.Textbox(visible=False, elem_id="compress-filename")
+        compress_btn       = gr.Button("Compress", variant="primary", size="lg")
+        compress_results   = gr.Markdown()
+        compress_download  = gr.HTML()
+
+        compress_btn.click(
+            fn=compress_b64,
+            inputs=[compress_b64_data, compress_filename],
+            outputs=[compress_results, compress_download],
+        )
 
+    # ---- Tab 2: Decompress ----
     with gr.Tab("Decompress"):
-        with gr.Row():
-            d_input  = gr.File(label="Input file (.mdc)", file_types=[".mdc"])
-        with gr.Row():
-            d_btn    = gr.Button("Decompress", variant="primary")
-        with gr.Row():
-            d_output = gr.File(label="Restored file")
-            d_info   = gr.Textbox(label="Stats", lines=2, interactive=False)
-        d_btn.click(decompress, inputs=d_input, outputs=[d_output, d_info])
+        gr.Markdown("Upload a `.mdc` file to decompress.")
+        gr.HTML(
+            '<div style="margin:8px 0;">'
+            '<label style="display:inline-block;padding:10px 24px;background:#6366f1;color:white;'
+            'border-radius:8px;cursor:pointer;font-weight:bold;font-size:14px;">'
+            'Upload .mdc file'
+            '<input id="decompress-file-input" type="file" accept=".mdc" style="display:none;">'
+            '</label>'
+            '<span id="decompress-file-name" style="margin-left:10px;color:#aaa;"></span>'
+            '</div>'
+        )
+        decompress_b64_data = gr.Textbox(visible=False, elem_id="decompress-b64-data")
+        decompress_btn      = gr.Button("Decompress", variant="primary", size="lg")
+        decompress_results  = gr.Markdown()
+        decompress_download = gr.HTML()
+
+        decompress_btn.click(
+            fn=decompress_b64,
+            inputs=[decompress_b64_data],
+            outputs=[decompress_results, decompress_download],
+        )
+
+    gr.Markdown("""
+---
+**How it works:** Midicoth processes input through a five-layer cascade —
+PPM (orders 0–4) → Match Model → Word Model → High-Order Context (orders 5–8) →
+Micro-Diffusion Tweedie Denoiser — feeding a 32-bit arithmetic coder.
+
+| Benchmark | Midicoth | xz -9 | Improvement |
+|-----------|----------|--------|-------------|
+| alice29.txt (152 KB) | 2.119 bpb | 2.551 bpb | +16.9% |
+| enwik8 (100 MB) | 1.753 bpb | 1.989 bpb | +11.9% |
+
+Apache 2.0 | [Roberto Tacconelli](https://github.com/robtacconelli) | [arXiv:2603.08771](https://arxiv.org/abs/2603.08771)
+""")
+
+    gr.HTML(f"<script>{COMPRESS_UPLOAD_JS}</script>")
+    gr.HTML(f"<script>{DECOMPRESS_UPLOAD_JS}</script>")
 
+demo.queue()
 demo.launch()

requirements.txt

@@ -1 +1,2 @@
-gradio==4.44.0
+spaces>=0.20.0
+gradio>=4.0.0