up

README.md

@@ -12,48 +12,27 @@ pinned: false
 
 # 🎬 PDF → Manim Animation Pipeline
 
-A Hugging Face Spaces Gradio app that converts any PDF into an animated Manim video and delivers it to your inbox.
+Upload a PDF → Gemini generates a Manim animation → watch it in-app and download the artifacts.
 
 ---
 
-## 🚀 Quick Start
+## 🚀 Deploy on Hugging Face Spaces
 
-### 1. Upload to Hugging Face Spaces
-
-Create a new Space on [huggingface.co/spaces](https://huggingface.co/spaces) with:
-- **SDK:** Gradio
-- **Hardware:** CPU Basic (or better — more RAM = faster renders)
-
-Upload all files in this folder.
-
----
-
-### 2. Set Environment Secrets
-
-In your Space settings → **Secrets**, add:
-
-| Secret Name     | Value                                      |
-|-----------------|--------------------------------------------|
-| `SMTP_EMAIL`    | Your Gmail address (e.g. `you@gmail.com`)  |
-| `SMTP_PASSWORD` | Gmail App Password (16-char, not login pw) |
-
-**How to get a Gmail App Password:**
-1. Enable 2-Step Verification on your Google account.
-2. Go to [myaccount.google.com/apppasswords](https://myaccount.google.com/apppasswords).
-3. Create a new app password for "Mail".
-
-> ⚠️ **Never commit secrets to your repo.** Only use the Spaces secret store.
+1. Create a new Space (SDK: Gradio, any CPU hardware).
+2. Upload all files in this folder.
+3. No secrets required — users supply their own Gemini API key in the UI.
 
 ---
 
-### 3. Usage
+## 🖥️ Usage
 
-1. Open your Space URL.
-2. Upload a PDF file.
-3. Enter your email address *(saved in browser — no need to re-enter)*.
-4. Enter your **Gemini API key** *(saved in browser)* — get one free at [aistudio.google.com](https://aistudio.google.com).
-5. Click **Generate Video**.
-6. Watch live status updates — the generated Manim code appears in-app, and the video arrives in your inbox!
+1. Upload a PDF.
+2. Enter your **Gemini API key** (saved in your browser — enter once).
+3. Click **Generate Video**.
+4. Watch live status and the generated Manim code appear in real time.
+5. When complete:
+   - ▶️ **Video player** — watch the animation directly in the browser.
+   - ⬇️ **Artifacts ZIP** — download `<job_id>.py` + `OutputVideo.mp4`.
 
 ---
 
@@ -66,61 +45,39 @@ PDF Upload
 Extract Text (pypdf)
     │
     ▼
-Gemini 2.5 Flash (google-genai)
-    │  → generated code shown live in UI
-    ▼
-Manim Render (-qm, 1280×720, 30fps)
+Gemini 3 Flash Preview  →  code shown live in UI
     │
     ▼
-Video < 24MB?  ──YES──▶ Email Attachment
-    │                        │
-   NO                        │
-    ▼                        │
-Catbox.moe Upload            │
-    │                        │
-    ▼                        │
-Email Link ◀─────────────────┘
+Manim Render (-qm, 1280×720, 30fps)
     │
     ▼
-Cleanup temp files
+Video Player + artifacts_<job_id>.zip download
 ```
 
 ---
 
-## ⚙️ Configuration
-
-| Setting            | Default      | Location                        |
-|--------------------|--------------|---------------------------------|
-| Max concurrent jobs| 100          | `app.py` → `JobQueue(max_jobs=)`|
-| Thread workers     | 8            | `app.py` → `JobQueue(max_workers=)`|
-| Manim quality      | `-qm` 720p30 | `pipeline.py` → `_render_manim` |
-| Render timeout     | 600s         | `pipeline.py` → `_render_manim` |
-| Catbox retries     | 5            | `utils.py`                      |
-
----
-
 ## 📁 File Structure
 
 ```
 .
-├── app.py              # Gradio UI + streaming status + BrowserState persistence
-├── pipeline.py         # Job pipeline orchestrator
-├── queue_manager.py    # Thread-pool queue with state tracking
-├── utils.py            # PDF, Gemini, email, Catbox helpers
-├── requirements.txt    # Python dependencies
-├── packages.txt        # System packages (LaTeX, ffmpeg, cairo…)
-└── README.md           # This file
+├── app.py              # Gradio UI — streaming status, video player, zip download
+├── pipeline.py         # Job orchestrator
+├── queue_manager.py    # Thread-pool queue (max 100 jobs)
+├── utils.py            # PDF extraction, Gemini streaming, code sanitisation
+├── requirements.txt    # Python deps
+├── packages.txt        # System deps (LaTeX, ffmpeg, cairo…)
+└── README.md
 ```
 
 ---
 
-## 🔒 Security Notes
+## ⚙️ System Packages (`packages.txt`)
+
+Manim requires LaTeX and ffmpeg. These are installed automatically by HF Spaces:
 
-- Gemini API keys are passed per-request and **never stored server-side**.
-- Email/API key persisted in **browser localStorage** (client only).
-- SMTP credentials live only in HF Secrets (env vars).
-- All temporary files deleted after pipeline completion.
-- Each job uses a UUID to prevent path collisions.
+- `ffmpeg`, `libcairo2-dev`, `libpango1.0-dev`
+- `texlive-latex-base`, `texlive-latex-extra`, `texlive-fonts-recommended`
+- `dvipng`, `dvisvgm`, `ghostscript`
 
 ---
 
@@ -128,9 +85,7 @@ Cleanup temp files
 
 | Issue | Fix |
 |-------|-----|
-| `SMTP_EMAIL not set` | Add the secret in HF Space settings |
-| `latex not found` | Ensure `packages.txt` is in your Space root |
-| Render timeout | Use a higher-tier Space hardware |
-| Gemini API error | Check your API key and quota |
-| Empty PDF | PDF must have selectable text (not scanned image) |
-| Large video | Catbox fallback used automatically |
+| `latex not found` | Ensure `packages.txt` is at the repo root |
+| Render timeout | Use higher-tier hardware or shorten animation in prompt |
+| Gemini API error | Check API key and quota at aistudio.google.com |
+| Empty PDF | PDF must have selectable text (not a scanned image) |

app.py

@@ -8,14 +8,13 @@ import atexit
 import queue
 import threading
 import uuid
-from pathlib import Path
 
 import gradio as gr
 
 from queue_manager import JobQueue, State
 from pipeline import run_pipeline
 
-# ── Asyncio cleanup fix (suppresses Invalid file descriptor errors) ───────────
+# ── Asyncio cleanup (suppresses "Invalid file descriptor" noise on shutdown) ──
 def _cleanup_event_loop():
     try:
         loop = asyncio.get_event_loop()
@@ -26,60 +25,79 @@ def _cleanup_event_loop():
 
 atexit.register(_cleanup_event_loop)
 
-# ── Global queue ──────────────────────────────────────────────────────────────
+# ── Global job queue ──────────────────────────────────────────────────────────
 job_queue = JobQueue(max_workers=8, max_jobs=100)
 
 
-# ── Pipeline streaming generator ──────────────────────────────────────────────
-def submit_and_stream(pdf_file, email: str, api_key: str):
+# ── Streaming pipeline ────────────────────────────────────────────────────────
+def submit_and_stream(pdf_file, api_key: str):
     """
-    Generator — yields (status_md, code_text, code_visible) tuples live.
-    Drives the entire UI update without any polling button.
+    Generator — yields tuples:
+        (status_md, code_str, code_visible, video_path, video_visible,
+         zip_path, zip_visible)
+    live-streamed to the Gradio UI.
     """
 
+    def _emit(status, code="", code_vis=False, video=None, vid_vis=False, zip_p=None, zip_vis=False):
+        return (
+            status,
+            code,
+            gr.update(visible=code_vis),
+            video,
+            gr.update(visible=vid_vis),
+            zip_p,
+            gr.update(visible=zip_vis),
+        )
+
     # ── Validate ──────────────────────────────────────────────────────────────
     if pdf_file is None:
-        yield "❌ Please upload a PDF file.", "", gr.update(visible=False)
-        return
-    if not email or "@" not in email:
-        yield "❌ Please enter a valid email address.", "", gr.update(visible=False)
+        yield _emit("❌ Please upload a PDF file.")
         return
     if not api_key or len(api_key) < 10:
-        yield "❌ Please enter a valid Gemini API key.", "", gr.update(visible=False)
+        yield _emit("❌ Please enter a valid Gemini API key.")
         return
     if job_queue.is_full():
-        yield "⚠️ Queue is full (max 100 jobs). Please try again shortly.", "", gr.update(visible=False)
+        yield _emit("⚠️ Queue is full (max 100 jobs). Please try again shortly.")
         return
 
-    job_id = uuid.uuid4().hex
+    job_id   = uuid.uuid4().hex
     pdf_path = pdf_file.name
+    job_queue.register(job_id)
 
-    # Thread-safe channel for status + code updates
+    # Thread-safe update channel
     update_q: queue.Queue = queue.Queue()
 
     def status_cb(state: State, message: str = "", code: str | None = None):
         update_q.put((state, message, code))
 
+    result_holder: dict = {}
+
     def _run():
         try:
-            run_pipeline(
+            result = run_pipeline(
                 job_id=job_id,
                 pdf_path=pdf_path,
-                email=email,
                 gemini_api_key=api_key,
                 status_cb=status_cb,
             )
-            update_q.put((State.DONE, "Video sent to your inbox! 🎉", None))
+            result_holder.update(result)
+            update_q.put((State.DONE, "✅ Render complete!", result.get("code")))
         except Exception as exc:
-            update_q.put((State.FAILED, str(exc), None))
+            update_q.put((State.FAILED, f"❌ {exc}", None))
         finally:
             update_q.put(None)  # sentinel
 
-    thread = threading.Thread(target=_run, daemon=True)
-    thread.start()
+    threading.Thread(target=_run, daemon=True).start()
+
+    icons = {
+        State.QUEUED:  "⏳",
+        State.RUNNING: "⚙️",
+        State.DONE:    "✅",
+        State.FAILED:  "❌",
+    }
 
     code_so_far = ""
-    yield f"⏳ **Queued** — Starting…\n\n*Job ID: `{job_id}`*", "", gr.update(visible=False)
+    yield _emit(f"⏳ **Queued** — Starting…\n\n*Job `{job_id}`*")
 
     while True:
         item = update_q.get()
@@ -87,58 +105,50 @@ def submit_and_stream(pdf_file, email: str, api_key: str):
             break
 
         state, message, code = item
-
-        icons = {
-            State.QUEUED: "⏳",
-            State.RUNNING: "⚙️",
-            State.UPLOADING: "☁️",
-            State.SENDING: "📧",
-            State.DONE: "✅",
-            State.FAILED: "❌",
-        }
-        icon = icons.get(state, "❓")
-        status_text = f"{icon} **{state.value.title()}** — {message}\n\n*Job ID: `{job_id}`*"
-
-        if code is not None:
+        if code:
             code_so_far = code
 
-        yield (
+        status_text = (
+            f"{icons.get(state,'❓')} **{state.value.title()}** — {message}"
+            f"\n\n*Job `{job_id}`*"
+        )
+        is_done   = state == State.DONE
+        is_failed = state == State.FAILED
+
+        yield _emit(
             status_text,
-            code_so_far,
-            gr.update(visible=bool(code_so_far)),
+            code        = code_so_far,
+            code_vis    = bool(code_so_far),
+            video       = result_holder.get("video_path") if is_done else None,
+            vid_vis     = is_done,
+            zip_p       = result_holder.get("zip_path") if is_done else None,
+            zip_vis     = is_done,
         )
 
 
 # ── UI ────────────────────────────────────────────────────────────────────────
 with gr.Blocks(title="PDF → Manim Video") as demo:
 
-    gr.Markdown(
-        """
-        # 🎬 PDF → Manim Animation Pipeline
-        Upload a PDF, enter your details, and receive an animated video in your inbox.
-        """
-    )
+    gr.Markdown("# 🎬 PDF → Manim Animation Pipeline\nUpload a PDF and get a downloadable Manim animation.")
 
-    # Persistent browser-side storage (survives page refresh)
-    saved_email = gr.BrowserState("")
-    saved_api_key = gr.BrowserState("")
+    saved_api_key = gr.BrowserState("")          # persisted in browser localStorage
 
     with gr.Row():
+        # ── Left column: inputs ───────────────────────────────────────────────
         with gr.Column(scale=1):
             pdf_input = gr.File(label="📄 Upload PDF", file_types=[".pdf"])
-            email_input = gr.Textbox(
-                label="📧 Your Email",
-                placeholder="you@example.com",
-            )
             api_key_input = gr.Textbox(
                 label="🔑 Gemini API Key",
                 placeholder="AIza…",
                 type="password",
+                info="Saved in your browser — you only need to enter this once.",
             )
             submit_btn = gr.Button("🚀 Generate Video", variant="primary")
 
+        # ── Right column: outputs ─────────────────────────────────────────────
         with gr.Column(scale=1):
             status_md = gr.Markdown("*Submit a job to see live status here.*")
+
             code_box = gr.Code(
                 label="📝 Generated Manim Code",
                 language="python",
@@ -146,33 +156,38 @@ with gr.Blocks(title="PDF → Manim Video") as demo:
                 interactive=False,
             )
 
+            video_player = gr.Video(
+                label="🎬 Rendered Animation",
+                visible=False,
+                interactive=False,
+            )
+
+            zip_download = gr.File(
+                label="⬇️ Download Artifacts (.py + .mp4)",
+                visible=False,
+                interactive=False,
+            )
+
     gr.Markdown(
         """
         ---
-        **Notes:**
-        - Processing typically takes 2–5 minutes.
-        - The video will be emailed once rendered; large files use a Catbox.moe link.
-        - Your Gemini API key is used only for this request and never stored server-side.
-        - Requires `SMTP_EMAIL` and `SMTP_PASSWORD` environment secrets on the Space.
-        """
-    )
+        **Notes:** Processing typically takes 2–5 minutes depending on animation complexity.  
+        The artifacts ZIP contains the generated `.py` source and the rendered `.mp4`.  
+        Your API key is never stored server-side.  
 
-    # ── Restore persisted values on page load ─────────────────────────────────
-    demo.load(
-        fn=lambda e, k: (e, k),
-        inputs=[saved_email, saved_api_key],
-        outputs=[email_input, api_key_input],
+        Have fun! 🎬 If you liked it, feel free to share it with your friends and family.
+        """
     )
 
-    # ── Save values to browser storage whenever they change ───────────────────
-    email_input.change(fn=lambda v: v, inputs=[email_input], outputs=[saved_email])
+    # ── Restore API key from browser on load ──────────────────────────────────
+    demo.load(fn=lambda k: k, inputs=[saved_api_key], outputs=[api_key_input])
     api_key_input.change(fn=lambda v: v, inputs=[api_key_input], outputs=[saved_api_key])
 
-    # ── Streaming job submission ───────────────────────────────────────────────
+    # ── Streaming submit ───────────────────────────────────────────────────────
     submit_btn.click(
         fn=submit_and_stream,
-        inputs=[pdf_input, email_input, api_key_input],
-        outputs=[status_md, code_box, code_box],
+        inputs=[pdf_input, api_key_input],
+        outputs=[status_md, code_box, code_box, video_player, video_player, zip_download, zip_download],
     )
 
 

packages.txt

@@ -1,15 +1,11 @@
-build-essential
-python3-dev
-libcairo2-dev
-libpango1.0-dev
 ffmpeg
-sox
-ghostscript
-dvipng
-dvisvgm
-texlive
+texlive-latex-base
 texlive-latex-extra
+texlive-fonts-recommended
 texlive-fonts-extra
-texlive-latex-recommended
 texlive-science
-tipa
+dvipng
+dvisvgm
+ghostscript
+libcairo2-dev
+libpango1.0-dev

pipeline.py

@@ -1,74 +1,79 @@
 """
-pipeline.py — Main pipeline: PDF → Gemini → Manim → Upload/Email → Cleanup
+pipeline.py — PDF → Gemini → Manim render → return artifacts
 """
 
 from __future__ import annotations
 
-import os
-import shutil
 import subprocess
 import textwrap
 import time
+import zipfile
 from pathlib import Path
 from typing import Callable
 
 from queue_manager import State
-from utils import (
-    extract_pdf_text,
-    generate_manim_code,
-    send_video_email,
-    upload_to_catbox,
-    sanitize_manim_code,
-)
+from utils import extract_pdf_text, generate_manim_code, sanitize_manim_code
 
-MEDIA_ROOT = Path("media/videos")
-JOBS_ROOT  = Path("jobs")
+MEDIA_ROOT   = Path("media/videos")
+JOBS_ROOT    = Path("jobs")
+ARTIFACTS    = Path("artifacts")
 
 
 def run_pipeline(
     job_id: str,
     pdf_path: str,
-    email: str,
     gemini_api_key: str,
     status_cb: Callable[[State, str, str | None], None],
-) -> None:
-    job_dir    = JOBS_ROOT / job_id
+) -> dict:
+    """
+    Run the full pipeline and return:
+        {
+            "video_path": str,   # absolute path to the rendered .mp4
+            "zip_path":   str,   # absolute path to artifacts_<job_id>.zip
+            "code":       str,   # generated Manim source
+        }
+    """
+    job_dir     = JOBS_ROOT / job_id
     script_path = job_dir / f"{job_id}.py"
     video_path  = MEDIA_ROOT / job_id / "720p30" / "OutputVideo.mp4"
+    zip_path    = ARTIFACTS / f"artifacts_{job_id}.zip"
 
     job_dir.mkdir(parents=True, exist_ok=True)
+    ARTIFACTS.mkdir(parents=True, exist_ok=True)
 
-    try:
-        # 1. Extract PDF
-        status_cb(State.RUNNING, "📖 Extracting text from PDF…", None)
-        pdf_text = extract_pdf_text(pdf_path)
-        if not pdf_text.strip():
-            raise ValueError("PDF appears empty or has no selectable text.")
+    # 1. Extract PDF text
+    status_cb(State.RUNNING, "📖 Extracting text from PDF…", None)
+    pdf_text = extract_pdf_text(pdf_path)
+    if not pdf_text.strip():
+        raise ValueError("PDF appears empty or has no selectable text.")
 
-        # 2. Generate Manim code via Gemini
-        status_cb(State.RUNNING, "🤖 Generating Manim code with Gemini…", None)
-        prompt     = _build_prompt(pdf_text)
-        raw_code   = generate_manim_code(prompt, gemini_api_key)
-        manim_code = sanitize_manim_code(raw_code, job_id)
+    # 2. Generate Manim code via Gemini
+    status_cb(State.RUNNING, "🤖 Generating Manim code with Gemini…", None)
+    prompt     = _build_prompt(pdf_text)
+    raw_code   = generate_manim_code(prompt, gemini_api_key)
+    manim_code = sanitize_manim_code(raw_code)
 
-        # Surface generated code to UI
-        status_cb(State.RUNNING, "✏️ Manim code generated — starting render…", manim_code)
+    status_cb(State.RUNNING, "✏️ Code generated — starting render…", manim_code)
+    script_path.write_text(manim_code, encoding="utf-8")
 
-        script_path.write_text(manim_code, encoding="utf-8")
+    # 3. Render
+    status_cb(State.RUNNING, "🎬 Rendering animation (this may take a few minutes)…", None)
+    _render_manim(script_path)
 
-        # 3. Render
-        status_cb(State.RUNNING, "🎬 Rendering animation (this may take a few minutes)…", None)
-        _render_manim(script_path, job_id)
+    if not video_path.exists():
+        raise FileNotFoundError(f"Rendered video not found at {video_path}")
 
-        if not video_path.exists():
-            raise FileNotFoundError(f"Rendered video not found at {video_path}")
+    # 4. Package artifacts zip
+    status_cb(State.RUNNING, "📦 Packaging artifacts zip…", None)
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.write(script_path, arcname=f"{job_id}.py")
+        zf.write(video_path,  arcname="OutputVideo.mp4")
 
-        # 4. Deliver
-        status_cb(State.SENDING, "📧 Sending video to your inbox…", None)
-        _deliver_video(str(video_path), email, status_cb)
-
-    finally:
-        _cleanup(job_dir, video_path)
+    return {
+        "video_path": str(video_path.resolve()),
+        "zip_path":   str(zip_path.resolve()),
+        "code":       manim_code,
+    }
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
@@ -85,7 +90,7 @@ def _build_prompt(pdf_text: str) -> str:
         - Use only standard Manim Community v0.18+ API.
         - Output ONLY valid Python code. No explanations, no markdown fences.
         - Keep runtime under 90 seconds.
-        - Avoid custom LaTeX; prefer Text() over MathTex() where possible.
+        - Avoid custom LaTeX preambles; prefer Text() over MathTex() where possible.
         - Animations should be clear, readable, and professional.
 
         Document content:
@@ -95,7 +100,7 @@ def _build_prompt(pdf_text: str) -> str:
     """).strip()
 
 
-def _render_manim(script_path: Path, job_id: str, max_retries: int = 2) -> None:
+def _render_manim(script_path: Path, max_retries: int = 2) -> None:
     cmd = [
         "manim",
         str(script_path),
@@ -104,48 +109,15 @@ def _render_manim(script_path: Path, job_id: str, max_retries: int = 2) -> None:
         "--media_dir", "media",
         "--disable_caching",
     ]
+    stderr_tail = ""
     for attempt in range(max_retries + 1):
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
         if result.returncode == 0:
             return
+        stderr_tail = result.stderr[-3000:]
         if attempt < max_retries:
             time.sleep(5 * (attempt + 1))
 
     raise RuntimeError(
-        f"Manim render failed after {max_retries + 1} attempts.\n"
-        f"STDERR: {result.stderr[-3000:]}"
+        f"Manim render failed after {max_retries + 1} attempts.\nSTDERR: {stderr_tail}"
     )
-
-
-def _deliver_video(
-    video_path: str,
-    email: str,
-    status_cb: Callable,
-) -> None:
-    file_size_mb = Path(video_path).stat().st_size / (1024 * 1024)
-
-    if file_size_mb <= 24:
-        try:
-            send_video_email(email, video_path)
-            return
-        except Exception as exc:
-            status_cb(State.UPLOADING, f"⚠️ Attachment failed ({exc}) — uploading to Catbox…", None)
-    else:
-        status_cb(State.UPLOADING, f"📦 {file_size_mb:.1f} MB video — uploading to Catbox…", None)
-
-    url = upload_to_catbox(video_path)
-    send_video_email(email, video_path=None, catbox_url=url)
-
-
-def _cleanup(*paths) -> None:
-    for p in paths:
-        if p is None:
-            continue
-        path = Path(p)
-        try:
-            if path.is_dir():
-                shutil.rmtree(path, ignore_errors=True)
-            elif path.is_file():
-                path.unlink(missing_ok=True)
-        except Exception:
-            pass

queue_manager.py

@@ -1,5 +1,5 @@
 """
-queue_manager.py — Thread-pool-based job queue with status tracking.
+queue_manager.py — Thread-pool job queue with status tracking.
 """
 
 from __future__ import annotations
@@ -13,12 +13,10 @@ from typing import Any, Callable
 
 
 class State(str, Enum):
-    QUEUED = "queued"
-    RUNNING = "running"
-    UPLOADING = "uploading"
-    SENDING = "sending"
-    DONE = "done"
-    FAILED = "failed"
+    QUEUED   = "queued"
+    RUNNING  = "running"
+    DONE     = "done"
+    FAILED   = "failed"
 
 
 @dataclass
@@ -34,66 +32,33 @@ class JobStatus:
         self.message = message
         self.updated_at = time.time()
 
-    def display(self) -> str:
-        icons = {
-            State.QUEUED: "⏳",
-            State.RUNNING: "⚙️",
-            State.UPLOADING: "☁️",
-            State.SENDING: "📧",
-            State.DONE: "✅",
-            State.FAILED: "❌",
-        }
-        icon = icons.get(self.state, "❓")
-        lines = [f"{icon} **{self.state.value.title()}**"]
-        if self.message:
-            lines.append(self.message)
-        lines.append(f"*Job ID: `{self.job_id}`*")
-        return "\n\n".join(lines)
-
 
 class JobQueue:
     def __init__(self, max_workers: int = 8, max_jobs: int = 100) -> None:
-        self._max_jobs = max_jobs
-        self._executor = ThreadPoolExecutor(max_workers=max_workers)
+        self._max_jobs  = max_jobs
+        self._executor  = ThreadPoolExecutor(max_workers=max_workers)
         self._jobs: dict[str, JobStatus] = {}
         self._lock = threading.Lock()
 
     def is_full(self) -> bool:
         with self._lock:
             active = sum(
-                1
-                for s in self._jobs.values()
-                if s.state in (State.QUEUED, State.RUNNING, State.UPLOADING, State.SENDING)
+                1 for s in self._jobs.values()
+                if s.state in (State.QUEUED, State.RUNNING)
             )
             return active >= self._max_jobs
 
-    def enqueue(self, job_id: str, fn: Callable, kwargs: dict[str, Any]) -> JobStatus:
-        status = JobStatus(job_id=job_id)
+    def get_status(self, job_id: str) -> JobStatus | None:
         with self._lock:
-            self._jobs[job_id] = status
-
-        def _run():
-            with self._lock:
-                self._jobs[job_id].update(State.RUNNING, "Pipeline started…")
-            try:
-                fn(status_cb=self._make_cb(job_id), **kwargs)
-                with self._lock:
-                    self._jobs[job_id].update(State.DONE, "Video sent to your inbox! 🎉")
-            except Exception as exc:
-                with self._lock:
-                    self._jobs[job_id].update(State.FAILED, f"Error: {exc}")
-
-        self._executor.submit(_run)
-        return status
-
-    def _make_cb(self, job_id: str) -> Callable[[State, str], None]:
-        def cb(state: State, message: str = "") -> None:
-            with self._lock:
-                if job_id in self._jobs:
-                    self._jobs[job_id].update(state, message)
+            return self._jobs.get(job_id)
 
-        return cb
+    def _set_state(self, job_id: str, state: State, message: str = "") -> None:
+        with self._lock:
+            if job_id in self._jobs:
+                self._jobs[job_id].update(state, message)
 
-    def get_status(self, job_id: str) -> JobStatus | None:
+    def register(self, job_id: str) -> JobStatus:
+        status = JobStatus(job_id=job_id)
         with self._lock:
-            return self._jobs.get(job_id)
+            self._jobs[job_id] = status
+        return status

utils.py

@@ -1,21 +1,15 @@
 """
-utils.py — PDF extraction, Gemini LLM, email, Catbox upload helpers.
+utils.py — PDF extraction, Gemini LLM, and Manim code helpers.
 """
 
 from __future__ import annotations
 
-import os
 import re
-import smtplib
-import ssl
-import time
-from email.message import EmailMessage
-from pathlib import Path
 
-import requests
 from google import genai
 from google.genai import types
 
+
 # ── PDF Text Extraction ───────────────────────────────────────────────────────
 
 def extract_pdf_text(pdf_path: str) -> str:
@@ -33,7 +27,7 @@ def extract_pdf_text(pdf_path: str) -> str:
 
 # ── Gemini LLM ────────────────────────────────────────────────────────────────
 
-def generate_manim_code(prompt_text: str, api_key: str):
+def generate_manim_code(prompt_text: str, api_key: str) -> str:
     """Stream Manim code from Gemini 3 Flash Preview and return it as a string."""
     client = genai.Client(api_key=api_key)
     model = "gemini-3-flash-preview"
@@ -59,20 +53,20 @@ def generate_manim_code(prompt_text: str, api_key: str):
     ):
         if chunk.text:
             code += chunk.text
-            print(chunk.text, end="")  # optional live streaming output
+            print(chunk.text, end="", flush=True)
 
     return code
 
-def sanitize_manim_code(raw: str, job_id: str) -> str:
+
+# ── Manim Code Sanitisation ───────────────────────────────────────────────────
+
+def sanitize_manim_code(raw: str) -> str:
     """
-    Strip markdown fences, ensure correct imports and class name,
-    and add job-specific media dir hint.
+    Strip markdown fences, ensure correct imports and class name.
     """
-    # Remove ```python ... ``` fences
     code = re.sub(r"^```(?:python)?\s*", "", raw.strip(), flags=re.MULTILINE)
     code = re.sub(r"\s*```$", "", code.strip(), flags=re.MULTILINE)
 
-    # Ensure manim import is present
     if "from manim import" not in code and "import manim" not in code:
         code = "from manim import *\n\n" + code
 
@@ -80,96 +74,3 @@ def sanitize_manim_code(raw: str, job_id: str) -> str:
     code = re.sub(r"class\s+\w+\s*\(\s*Scene\s*\)", "class OutputVideo(Scene)", code)
 
     return code
-
-
-# ── Email ─────────────────────────────────────────────────────────────────────
-
-def send_video_email(
-    to_email: str,
-    video_path: str | None = None,
-    catbox_url: str | None = None,
-) -> None:
-    """Send email with video attachment or Catbox link."""
-    smtp_email = os.environ["SMTP_EMAIL"]
-    smtp_password = os.environ["SMTP_PASSWORD"]
-
-    msg = EmailMessage()
-    msg["Subject"] = "🎬 Your Manim Animation is Ready!"
-    msg["From"] = smtp_email
-    msg["To"] = to_email
-
-    if catbox_url:
-        body = (
-            "Your animated video has been generated and uploaded.\n\n"
-            f"Download it here (link valid for ~3 days):\n{catbox_url}\n\n"
-            "Enjoy your animation!"
-        )
-        msg.set_content(body)
-    else:
-        msg.set_content(
-            "Your animated video is attached to this email.\n\nEnjoy your animation!"
-        )
-        with open(video_path, "rb") as f:
-            msg.add_attachment(
-                f.read(),
-                maintype="video",
-                subtype="mp4",
-                filename="animation.mp4",
-            )
-
-    context = ssl.create_default_context()
-    _smtp_send_with_retry(msg, smtp_email, smtp_password, context)
-
-    # Delete video after successful send
-    if video_path and Path(video_path).exists():
-        Path(video_path).unlink(missing_ok=True)
-
-
-def _smtp_send_with_retry(
-    msg: EmailMessage,
-    smtp_email: str,
-    smtp_password: str,
-    context: ssl.SSLContext,
-    max_retries: int = 3,
-) -> None:
-    backoff = 2
-    for attempt in range(max_retries):
-        try:
-            with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
-                server.login(smtp_email, smtp_password)
-                server.send_message(msg)
-            return
-        except smtplib.SMTPException as exc:
-            if attempt == max_retries - 1:
-                raise
-            time.sleep(backoff)
-            backoff *= 2
-
-
-# ── Catbox Upload ─────────────────────────────────────────────────────────────
-
-API_URL = "https://catbox.moe/user/api.php"
-
-
-def upload_to_catbox(path: str, max_retries: int = 5) -> str:
-    """Upload a file to Catbox.moe with exponential backoff."""
-    file_path = Path(path)
-    backoff = 1
-    for attempt in range(max_retries):
-        try:
-            with file_path.open("rb") as f:
-                r = requests.post(
-                    API_URL,
-                    data={"reqtype": "fileupload"},
-                    files={"fileToUpload": f},
-                    timeout=120,
-                )
-            if r.status_code == 200 and r.text.startswith("https://files.catbox.moe/"):
-                return r.text.strip()
-            raise RuntimeError(f"Catbox returned unexpected response: {r.text[:200]}")
-        except Exception:
-            if attempt == max_retries - 1:
-                raise
-            time.sleep(backoff)
-            backoff *= 2
-    raise RuntimeError("Catbox upload failed after all retries.")