Spaces:

robtacconelli
/

midicoth

Running

App Files Files Community

st4ck commited on 29 days ago

Commit

a5d3f72

1 Parent(s): 9924fec

Replace Gradio with Flask: no analytics, no network deps, pure HTTP

Browse files

Files changed (3) hide show

Dockerfile +1 -4
app.py +122 -156
requirements.txt +1 -0

Dockerfile CHANGED Viewed

@@ -8,11 +8,8 @@ COPY . .
 # Pre-compile the binary at image build time
 RUN gcc -O2 -o mdc mdc.c -lm
-RUN pip install --no-cache-dir gradio==4.44.0 huggingface_hub==0.22.2
 EXPOSE 7860
-ENV GRADIO_SERVER_NAME=0.0.0.0
-ENV GRADIO_SERVER_PORT=7860
-ENV GRADIO_ANALYTICS_ENABLED=False
 CMD ["python", "app.py"]

 # Pre-compile the binary at image build time
 RUN gcc -O2 -o mdc mdc.c -lm
+RUN pip install --no-cache-dir flask
 EXPOSE 7860
 CMD ["python", "app.py"]

app.py CHANGED Viewed

@@ -1,167 +1,133 @@
 #!/usr/bin/env python3
-"""Midicoth -- Micro-Diffusion Compression -- Hugging Face Space Demo."""
-import os
-import base64
-import tempfile
-import subprocess
-import gradio as gr
-# ---------------------------------------------------------------------------
-# Lazy build
-# ---------------------------------------------------------------------------
-_DIR   = os.path.dirname(os.path.abspath(__file__))
-BINARY = os.path.join(_DIR, "mdc")
-def _ensure_built():
-    return None  # compiled at Docker build time
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-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 _dl(b64, name, label, color="#6366f1"):
-    sz = len(base64.b64decode(b64))
-    return (f'<a download="{name}" href="data:application/octet-stream;base64,{b64}" '
-            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;">{label} ({_fmt(sz)})</a>')
-# ---------------------------------------------------------------------------
-# Core functions (inputs/outputs are plain strings — no gr.File)
-# ---------------------------------------------------------------------------
-def compress(b64_data, filename):
-    err = _ensure_built()
-    if err:
-        return f"**Build error:** {err}", ""
-    if not b64_data:
-        return "Upload a file first.", ""
-    try:
-        data = base64.b64decode(b64_data.strip())
-    except Exception:
-        return "**Could not decode file.**", ""
     with tempfile.TemporaryDirectory() as d:
-        inp = os.path.join(d, "in")
-        out = os.path.join(d, "out.mdc")
-        open(inp, "wb").write(data)
         r = subprocess.run([BINARY, "compress", inp, out], capture_output=True, text=True)
         if r.returncode != 0:
-            return f"**Compression failed:** {r.stderr}", ""
-        compressed = open(out, "rb").read()
-    in_sz, out_sz = len(data), len(compressed)
-    bpb = out_sz * 8 / in_sz
-    name = (filename.strip() + ".mdc") if filename and filename.strip() else "compressed.mdc"
-    md = (f"| | Size | Ratio |\n|---|---|---|\n"
-          f"| **Original** | {_fmt(in_sz)} | 100% |\n"
-          f"| **Midicoth** | {_fmt(out_sz)} | {out_sz/in_sz*100:.1f}% |\n\n"
-          f"**bpb:** {bpb:.3f} — **Space saved:** {100 - out_sz/in_sz*100:.1f}%")
-    return md, _dl(base64.b64encode(compressed).decode(), name, f"Download {name}")
-def decompress(b64_data):
-    err = _ensure_built()
-    if err:
-        return f"**Build error:** {err}", ""
-    if not b64_data:
-        return "Upload a .mdc file first.", ""
-    try:
-        data = base64.b64decode(b64_data.strip())
-    except Exception:
-        return "**Could not decode file.**", ""
-    if len(data) < 12 or data[:4] != b"MDC7":
-        return "**Not a valid Midicoth file.**", ""
     with tempfile.TemporaryDirectory() as d:
-        inp = os.path.join(d, "in.mdc")
-        out = os.path.join(d, "out")
-        open(inp, "wb").write(data)
         r = subprocess.run([BINARY, "decompress", inp, out], capture_output=True, text=True)
         if r.returncode != 0:
-            return f"**Decompression failed:** {r.stderr}", ""
-        restored = open(out, "rb").read()
-    md = f"Restored **{_fmt(len(restored))}** — lossless OK"
-    return md, _dl(base64.b64encode(restored).decode(), "restored.bin", "Download restored", "#22c55e")
-# ---------------------------------------------------------------------------
-# JS: read file as base64, inject into hidden Textbox
-# ---------------------------------------------------------------------------
-JS = """
-function setupUploads() {
-    function wire(inputId, nameId, b64Id, fnId) {
-        var input = document.getElementById(inputId);
-        if (!input) return;
-        input.addEventListener('change', function(e) {
-            var file = e.target.files[0];
-            if (!file) return;
-            var nameEl = document.getElementById(nameId);
-            if (nameEl) nameEl.textContent = file.name + ' (' + (file.size/1024).toFixed(1) + ' KB)';
-            if (fnId) {
-                var fn = document.querySelectorAll('#' + fnId + ' textarea');
-                if (fn.length) { fn[0].value = file.name; fn[0].dispatchEvent(new Event('input',{bubbles:true})); }
-            }
-            var reader = new FileReader();
-            reader.onload = function(ev) {
-                var b64 = ev.target.result.split(',')[1];
-                var ta = document.querySelectorAll('#' + b64Id + ' textarea');
-                if (ta.length) { ta[0].value = b64; ta[0].dispatchEvent(new Event('input',{bubbles:true})); }
-            };
-            reader.readAsDataURL(file);
-        });
-    }
-    wire('c-input', 'c-name', 'c-b64', 'c-fn');
-    wire('d-input', 'd-name', 'd-b64', null);
-}
-setTimeout(setupUploads, 800);
-"""
-BTN = ('display:inline-block;padding:10px 24px;background:#6366f1;color:white;'
-       'border-radius:8px;cursor:pointer;font-weight:bold;font-size:14px;')
-# ---------------------------------------------------------------------------
-# UI
-# ---------------------------------------------------------------------------
-print("Building UI...", flush=True)
-with gr.Blocks(title="Midicoth — Micro-Diffusion Compression", analytics_enabled=False) as demo:
-    gr.Markdown("# 🗜️ Midicoth — Micro-Diffusion Compression\n"
-                "Lossless compression via Binary Tree Tweedie Denoising. "
-                "No neural network · No GPU · Outperforms xz/zstd/Brotli on text.")
-    with gr.Tab("Compress"):
-        gr.HTML(f'<label style="{BTN}">Choose file'
-                f'<input id="c-input" type="file" style="display:none;"></label>'
-                f'<span id="c-name" style="margin-left:10px;color:#aaa;"></span>')
-        c_b64 = gr.Textbox(visible=False, elem_id="c-b64")
-        c_fn  = gr.Textbox(visible=False, elem_id="c-fn")
-        c_btn = gr.Button("Compress", variant="primary")
-        c_res = gr.Markdown()
-        c_dl  = gr.HTML()
-        c_btn.click(compress, inputs=[c_b64, c_fn], outputs=[c_res, c_dl], api_name=False)
-    with gr.Tab("Decompress"):
-        gr.HTML(f'<label style="{BTN}">Upload .mdc file'
-                f'<input id="d-input" type="file" accept=".mdc" style="display:none;"></label>'
-                f'<span id="d-name" style="margin-left:10px;color:#aaa;"></span>')
-        d_b64 = gr.Textbox(visible=False, elem_id="d-b64")
-        d_btn = gr.Button("Decompress", variant="primary")
-        d_res = gr.Markdown()
-        d_dl  = gr.HTML()
-        d_btn.click(decompress, inputs=[d_b64], outputs=[d_res, d_dl], api_name=False)
-    gr.HTML(f"<script>{JS}</script>")
-print("Launching server...", flush=True)
-demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)
-print("Server launched.", flush=True)

 #!/usr/bin/env python3
+"""Midicoth — Micro-Diffusion Compression — HuggingFace Space Demo."""
+import os, subprocess, tempfile
+from flask import Flask, request, send_file, render_template_string
+app = Flask(__name__)
+BINARY = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mdc")
+HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Midicoth — Micro-Diffusion Compression</title>
+<style>
+  body{font-family:system-ui,sans-serif;max-width:720px;margin:40px auto;padding:0 20px;background:#0f172a;color:#e2e8f0}
+  h1{font-size:1.8em;margin-bottom:4px}
+  p.sub{color:#94a3b8;margin-top:0}
+  .card{background:#1e293b;border-radius:12px;padding:24px;margin:20px 0}
+  h2{font-size:1.1em;margin-top:0;color:#7dd3fc}
+  label{display:block;margin-bottom:8px;font-size:.9em;color:#94a3b8}
+  input[type=file]{width:100%;padding:10px;background:#0f172a;border:1px solid #334155;border-radius:8px;color:#e2e8f0;box-sizing:border-box}
+  button{margin-top:12px;padding:10px 28px;background:#6366f1;color:white;border:none;border-radius:8px;font-size:1em;font-weight:600;cursor:pointer}
+  button:hover{background:#4f46e5}
+  .error{color:#f87171;margin-top:10px;font-size:.9em}
+  .stats{margin-top:10px;font-size:.9em;color:#94a3b8;background:#0f172a;padding:10px;border-radius:6px}
+  a.dl{display:inline-block;margin-top:10px;padding:10px 24px;background:#22c55e;color:white;border-radius:8px;text-decoration:none;font-weight:600}
+  footer{margin-top:40px;font-size:.8em;color:#475569;text-align:center}
+  table{border-collapse:collapse;width:100%;margin-top:10px}
+  td,th{padding:6px 12px;border:1px solid #334155;font-size:.9em}
+  th{color:#7dd3fc;font-weight:600}
+</style>
+</head>
+<body>
+<h1>🗜️ Midicoth</h1>
+<p class="sub">Micro-Diffusion Compression · Binary Tree Tweedie Denoising · No neural network · No GPU</p>
+<div class="card">
+  <h2>Compress</h2>
+  <form method="post" action="/compress" enctype="multipart/form-data">
+    <label>Upload any file:</label>
+    <input type="file" name="file" required>
+    <button type="submit">Compress →</button>
+  </form>
+  {% if compress_error %}<p class="error">{{ compress_error }}</p>{% endif %}
+</div>
+<div class="card">
+  <h2>Decompress</h2>
+  <form method="post" action="/decompress" enctype="multipart/form-data">
+    <label>Upload a <code>.mdc</code> file:</label>
+    <input type="file" name="file" accept=".mdc" required>
+    <button type="submit">Decompress →</button>
+  </form>
+  {% if decompress_error %}<p class="error">{{ decompress_error }}</p>{% endif %}
+</div>
+<div class="card" style="font-size:.88em;color:#94a3b8">
+  <b style="color:#e2e8f0">How it works:</b> PPM (orders 0–4) → Match Model → Word Model →
+  High-Order Context (orders 5–8) → Micro-Diffusion Tweedie Denoiser → Arithmetic Coder.<br><br>
+  <table>
+    <tr><th>Benchmark</th><th>Midicoth</th><th>xz -9</th><th>Improvement</th></tr>
+    <tr><td>alice29.txt (152 KB)</td><td>2.119 bpb</td><td>2.551 bpb</td><td>+16.9%</td></tr>
+    <tr><td>enwik8 (100 MB)</td><td>1.753 bpb</td><td>1.989 bpb</td><td>+11.9%</td></tr>
+  </table>
+</div>
+<footer>Apache 2.0 · <a href="https://github.com/robtacconelli/midicoth" style="color:#6366f1">GitHub</a>
+· <a href="https://arxiv.org/abs/2603.08771" style="color:#6366f1">arXiv:2603.08771</a></footer>
+</body></html>"""
+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"
+@app.route("/")
+def index():
+    return render_template_string(HTML)
+@app.route("/compress", methods=["POST"])
+def compress():
+    f = request.files.get("file")
+    if not f or not f.filename:
+        return render_template_string(HTML, compress_error="No file uploaded.")
     with tempfile.TemporaryDirectory() as d:
+        inp = os.path.join(d, "input")
+        out = os.path.join(d, "output.mdc")
+        f.save(inp)
         r = subprocess.run([BINARY, "compress", inp, out], capture_output=True, text=True)
         if r.returncode != 0:
+            return render_template_string(HTML, compress_error=f"Compression failed: {r.stderr}")
+        in_sz  = os.path.getsize(inp)
+        out_sz = os.path.getsize(out)
+        bpb    = out_sz * 8 / in_sz
+        stats  = (f"Original: {fmt(in_sz)} → Compressed: {fmt(out_sz)} "
+                  f"({out_sz/in_sz*100:.1f}%, {bpb:.3f} bpb, "
+                  f"saved {100-out_sz/in_sz*100:.1f}%)")
+        return send_file(out, as_attachment=True,
+                         download_name=f.filename + ".mdc",
+                         mimetype="application/octet-stream")
+@app.route("/decompress", methods=["POST"])
+def decompress():
+    f = request.files.get("file")
+    if not f or not f.filename:
+        return render_template_string(HTML, decompress_error="No file uploaded.")
     with tempfile.TemporaryDirectory() as d:
+        inp = os.path.join(d, "input.mdc")
+        out = os.path.join(d, "output")
+        f.save(inp)
+        # Validate magic
+        with open(inp, "rb") as fh:
+            magic = fh.read(4)
+        if magic != b"MDC7":
+            return render_template_string(HTML, decompress_error="Not a valid Midicoth (.mdc) file.")
         r = subprocess.run([BINARY, "decompress", inp, out], capture_output=True, text=True)
         if r.returncode != 0:
+            return render_template_string(HTML, decompress_error=f"Decompression failed: {r.stderr}")
+        name = f.filename[:-4] if f.filename.endswith(".mdc") else f.filename + ".restored"
+        return send_file(out, as_attachment=True,
+                         download_name=name,
+                         mimetype="application/octet-stream")
+if __name__ == "__main__":
+    print("Starting Midicoth server on 0.0.0.0:7860", flush=True)
+    app.run(host="0.0.0.0", port=7860, debug=False)

requirements.txt CHANGED Viewed

	@@ -0,0 +1 @@


1	+ flask