up

.gitignore

@@ -0,0 +1,11 @@
+# Python
+__pycache__/
+*.pyc
+
+# Media
+media/videos/
+*.mp4
+*.mov
+
+# System files
+.DS_Store

README.md

@@ -10,9 +10,6 @@ app_file: app.py
 pinned: false
 ---
 
-This Hugging Face Space lets users upload PDFs, generates Manim animations via Gemini LLM, renders a video, and sends it via email or uploads to Catbox.moe.
-
-=======
 # 🎬 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.
@@ -21,7 +18,7 @@ A Hugging Face Spaces Gradio app that converts any PDF into an animated Manim vi
 
 ## 🚀 Quick Start
 
-### 1. Clone / Upload to Hugging Face Spaces
+### 1. Upload to Hugging Face Spaces
 
 Create a new Space on [huggingface.co/spaces](https://huggingface.co/spaces) with:
 - **SDK:** Gradio
@@ -35,10 +32,10 @@ Upload all files in this folder.
 
 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 your login password) |
+| 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.
@@ -53,10 +50,10 @@ In your Space settings → **Secrets**, add:
 
 1. Open your Space URL.
 2. Upload a PDF file.
-3. Enter your email address.
-4. Enter your **Gemini API key** (get one free at [aistudio.google.com](https://aistudio.google.com)).
+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. Refresh the status panel until done — the video will arrive in your inbox!
+6. Watch live status updates — the generated Manim code appears in-app, and the video arrives in your inbox!
 
 ---
 
@@ -70,7 +67,7 @@ Extract Text (pypdf)
     │
     ▼
 Gemini 2.5 Flash (google-genai)
-    │  generates OutputVideo(Scene) Manim code
+    │  → generated code shown live in UI
     ▼
 Manim Render (-qm, 1280×720, 30fps)
     │
@@ -78,7 +75,6 @@ Manim Render (-qm, 1280×720, 30fps)
 Video < 24MB?  ──YES──▶ Email Attachment
     │                        │
    NO                        │
-    │                        │
     ▼                        │
 Catbox.moe Upload            │
     │                        │
@@ -93,13 +89,13 @@ Cleanup temp files
 
 ## ⚙️ Configuration
 
-| Setting | Default | Notes |
-|---------|---------|-------|
-| Max concurrent jobs | 100 | Set in `app.py` → `JobQueue(max_jobs=100)` |
-| Thread workers | 8 | Set in `app.py` → `JobQueue(max_workers=8)` |
-| Manim quality | `-qm` (720p30) | Change in `pipeline.py` |
-| Render timeout | 600s | Change in `pipeline.py` → `_render_manim` |
-| Catbox retries | 5 | Change in `utils.py` |
+| 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`                      |
 
 ---
 
@@ -107,29 +103,23 @@ Cleanup temp files
 
 ```
 .
-├── app.py              # Gradio UI + job submission
-├── pipeline.py         # Full job pipeline orchestrator
-├── queue_manager.py    # Thread-pool job queue with status tracking
+├── 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
-├── README.md           # This file
-├── media/              # Manim render outputs (auto-created)
-│   └── videos/
-│       └── <job_id>/
-│           └── 720p30/
-│               └── OutputVideo.mp4
-└── jobs/               # Per-job Manim scripts (auto-created, auto-deleted)
-    └── <job_id>/
-        └── <job_id>.py
+├── packages.txt        # System packages (LaTeX, ffmpeg, cairo…)
+└── README.md           # This file
 ```
 
 ---
 
 ## 🔒 Security Notes
 
-- Gemini API keys are passed per-request and never stored.
+- 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 are deleted after pipeline completion.
+- All temporary files deleted after pipeline completion.
 - Each job uses a UUID to prevent path collisions.
 
 ---
@@ -139,8 +129,8 @@ 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 | Ensure the PDF has selectable text (not a scanned image) |
-| Large video not emailed | Catbox fallback will be used automatically |
->>>>>>> d5995c3 (Initial commit of PDF → Manim → LLM app)
+| Empty PDF | PDF must have selectable text (not scanned image) |
+| Large video | Catbox fallback used automatically |

app.py

@@ -1,78 +1,117 @@
 """
-PDF → Manim Animation → Video → Email Pipeline
-Hugging Face Spaces Gradio App
+PDF → Manim Animation Pipeline
+Hugging Face Spaces — Gradio 6.x
 """
 
-import gradio as gr
+import asyncio
+import atexit
+import queue
 import threading
 import uuid
-import time
 from pathlib import Path
 
-from queue_manager import JobQueue, JobStatus
+import gradio as gr
+
+from queue_manager import JobQueue, State
 from pipeline import run_pipeline
 
-# ── Global queue ────────────────────────────────────────────────────────────
+# ── Asyncio cleanup fix (suppresses Invalid file descriptor errors) ───────────
+def _cleanup_event_loop():
+    try:
+        loop = asyncio.get_event_loop()
+        if not loop.is_closed():
+            loop.close()
+    except Exception:
+        pass
+
+atexit.register(_cleanup_event_loop)
+
+# ── Global queue ──────────────────────────────────────────────────────────────
 job_queue = JobQueue(max_workers=8, max_jobs=100)
 
 
-# ── Helpers ──────────────────────────────────────────────────────────────────
-def validate_inputs(pdf_file, email: str, api_key: str) -> str | None:
+# ── Pipeline streaming generator ──────────────────────────────────────────────
+def submit_and_stream(pdf_file, email: str, api_key: str):
+    """
+    Generator — yields (status_md, code_text, code_visible) tuples live.
+    Drives the entire UI update without any polling button.
+    """
+
+    # ── Validate ──────────────────────────────────────────────────────────────
     if pdf_file is None:
-        return "Please upload a PDF file."
+        yield "❌ Please upload a PDF file.", "", gr.update(visible=False)
+        return
     if not email or "@" not in email:
-        return "Please enter a valid email address."
+        yield "❌ Please enter a valid email address.", "", gr.update(visible=False)
+        return
     if not api_key or len(api_key) < 10:
-        return "Please enter a valid Gemini API key."
-    return None
-
-
-def submit_job(pdf_file, email: str, api_key: str):
-    """Validate, enqueue, and return a job_id."""
-    err = validate_inputs(pdf_file, email, api_key)
-    if err:
-        return gr.update(value=err, visible=True), gr.update(visible=False), ""
-
+        yield "❌ Please enter a valid Gemini API key.", "", gr.update(visible=False)
+        return
     if job_queue.is_full():
-        return (
-            gr.update(value="⚠️ Queue is full (max 100 jobs). Please try again later.", visible=True),
-            gr.update(visible=False),
-            "",
-        )
+        yield "⚠️ Queue is full (max 100 jobs). Please try again shortly.", "", gr.update(visible=False)
+        return
 
     job_id = uuid.uuid4().hex
-    pdf_path = pdf_file.name  # temp path from Gradio
-
-    job_queue.enqueue(
-        job_id=job_id,
-        fn=run_pipeline,
-        kwargs={
-            "job_id": job_id,
-            "pdf_path": pdf_path,
-            "email": email,
-            "gemini_api_key": api_key,
-        },
-    )
-
-    return (
-        gr.update(value="", visible=False),
-        gr.update(visible=True),
-        job_id,
-    )
-
-
-def poll_status(job_id: str):
-    """Return a status string for the given job_id."""
-    if not job_id:
-        return "—"
-    status = job_queue.get_status(job_id)
-    if status is None:
-        return "Unknown job ID."
-    return status.display()
+    pdf_path = pdf_file.name
+
+    # Thread-safe channel for status + code updates
+    update_q: queue.Queue = queue.Queue()
+
+    def status_cb(state: State, message: str = "", code: str | None = None):
+        update_q.put((state, message, code))
+
+    def _run():
+        try:
+            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))
+        except Exception as exc:
+            update_q.put((State.FAILED, str(exc), None))
+        finally:
+            update_q.put(None)  # sentinel
+
+    thread = threading.Thread(target=_run, daemon=True)
+    thread.start()
+
+    code_so_far = ""
+    yield f"⏳ **Queued** — Starting…\n\n*Job ID: `{job_id}`*", "", gr.update(visible=False)
+
+    while True:
+        item = update_q.get()
+        if item is None:
+            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:
+            code_so_far = code
+
+        yield (
+            status_text,
+            code_so_far,
+            gr.update(visible=bool(code_so_far)),
+        )
 
 
 # ── UI ────────────────────────────────────────────────────────────────────────
 with gr.Blocks(title="PDF → Manim Video") as demo:
+
     gr.Markdown(
         """
         # 🎬 PDF → Manim Animation Pipeline
@@ -80,50 +119,67 @@ with gr.Blocks(title="PDF → Manim Video") as demo:
         """
     )
 
+    # Persistent browser-side storage (survives page refresh)
+    saved_email = gr.BrowserState("")
+    saved_api_key = gr.BrowserState("")
+
     with gr.Row():
         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")
+            email_input = gr.Textbox(
+                label="📧 Your Email",
+                placeholder="you@example.com",
+            )
             api_key_input = gr.Textbox(
                 label="🔑 Gemini API Key",
-                placeholder="AIza...",
+                placeholder="AIza…",
                 type="password",
             )
             submit_btn = gr.Button("🚀 Generate Video", variant="primary")
 
         with gr.Column(scale=1):
-            error_box = gr.Markdown(visible=False, elem_id="error_box")
-            status_panel = gr.Markdown("### Job Status\n—", visible=False)
-            job_id_state = gr.State("")
-            refresh_btn = gr.Button("🔄 Refresh Status", visible=False)
-
-    # ── Events ────────────────────────────────────────────────────────────────
-    submit_btn.click(
-        fn=submit_job,
-        inputs=[pdf_input, email_input, api_key_input],
-        outputs=[error_box, status_panel, job_id_state],
-    ).then(
-        fn=lambda jid: gr.update(visible=bool(jid)),
-        inputs=[job_id_state],
-        outputs=[refresh_btn],
-    )
-
-    refresh_btn.click(
-        fn=lambda jid: gr.update(value=f"### Job Status\n{poll_status(jid)}"),
-        inputs=[job_id_state],
-        outputs=[status_panel],
-    )
+            status_md = gr.Markdown("*Submit a job to see live status here.*")
+            code_box = gr.Code(
+                label="📝 Generated Manim Code",
+                language="python",
+                visible=False,
+                interactive=False,
+            )
 
     gr.Markdown(
         """
         ---
         **Notes:**
         - Processing typically takes 2–5 minutes.
-        - The video will be emailed to you once rendered.
-        - Your Gemini API key is used only for this request and never stored.
+        - 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.
         """
     )
 
+    # ── 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],
+    )
+
+    # ── Save values to browser storage whenever they change ───────────────────
+    email_input.change(fn=lambda v: v, inputs=[email_input], outputs=[saved_email])
+    api_key_input.change(fn=lambda v: v, inputs=[api_key_input], outputs=[saved_api_key])
+
+    # ── Streaming job submission ───────────────────────────────────────────────
+    submit_btn.click(
+        fn=submit_and_stream,
+        inputs=[pdf_input, email_input, api_key_input],
+        outputs=[status_md, code_box, code_box],
+    )
+
+
 if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+    demo.launch(
+        theme=gr.themes.Soft(),
+        ssr_mode=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+    )

packages.txt

@@ -0,0 +1,14 @@
+# Full LaTeX distribution for Manim
+texlive-full
+
+# Video and rendering dependencies
+ffmpeg
+ghostscript
+
+# Tools for DVI/TeX output
+dvipng
+dvisvgm
+
+# Graphics libraries
+libcairo2-dev
+libpango1.0-dev

pipeline.py

@@ -7,8 +7,8 @@ from __future__ import annotations
 import os
 import shutil
 import subprocess
-import tempfile
 import textwrap
+import time
 from pathlib import Path
 from typing import Callable
 
@@ -21,9 +21,8 @@ from utils import (
     sanitize_manim_code,
 )
 
-# Base directory for all render outputs
 MEDIA_ROOT = Path("media/videos")
-JOBS_ROOT = Path("jobs")
+JOBS_ROOT  = Path("jobs")
 
 
 def run_pipeline(
@@ -31,56 +30,54 @@ def run_pipeline(
     pdf_path: str,
     email: str,
     gemini_api_key: str,
-    status_cb: Callable[[State, str], None],
+    status_cb: Callable[[State, str, str | None], None],
 ) -> None:
-    """
-    Full pipeline for one job. Raises on unrecoverable errors.
-    """
+    job_dir    = JOBS_ROOT / job_id
+    script_path = job_dir / f"{job_id}.py"
+    video_path  = MEDIA_ROOT / job_id / "720p30" / "OutputVideo.mp4"
 
-    job_dir = JOBS_ROOT / job_id
     job_dir.mkdir(parents=True, exist_ok=True)
 
-    script_path = job_dir / f"{job_id}.py"
-    video_path = MEDIA_ROOT / job_id / "720p30" / "OutputVideo.mp4"
-
     try:
-        # ── 1. Extract PDF text ──────────────────────────────────────────────
-        status_cb(State.RUNNING, "📖 Extracting text from PDF…")
+        # 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 to be empty or unreadable.")
+            raise ValueError("PDF appears empty or has no selectable text.")
 
-        # ── 2. Generate Manim code via Gemini ────────────────────────────────
-        status_cb(State.RUNNING, "🤖 Generating Manim animation code with Gemini…")
-        prompt = _build_prompt(pdf_text, job_id)
-        raw_code = generate_manim_code(prompt, gemini_api_key)
+        # 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)
 
+        # Surface generated code to UI
+        status_cb(State.RUNNING, "✏️ Manim code generated — starting render…", manim_code)
+
         script_path.write_text(manim_code, encoding="utf-8")
 
-        # ── 3. Render with Manim ─────────────────────────────────────────────
-        status_cb(State.RUNNING, "🎬 Rendering animation (this may take a few minutes)…")
+        # 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}")
 
-        # ── 4. Email (with Catbox fallback) ──────────────────────────────────
-        status_cb(State.SENDING, "📧 Sending video to your inbox…")
+        # 4. Deliver
+        status_cb(State.SENDING, "📧 Sending video to your inbox…", None)
         _deliver_video(str(video_path), email, status_cb)
 
     finally:
-        # ── 5. Cleanup ───────────────────────────────────────────────────────
         _cleanup(job_dir, video_path)
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
 
-def _build_prompt(pdf_text: str, job_id: str) -> str:
-    truncated = pdf_text[:12_000]  # keep within context limits
+def _build_prompt(pdf_text: str) -> str:
+    truncated = pdf_text[:12_000]
     return textwrap.dedent(f"""
         You are an expert Manim animator. Given the following document content,
-        create a concise, visually engaging Manim animation that summarizes the
+        create a concise, visually engaging Manim animation that summarises the
         key ideas. Use ONLY the class name `OutputVideo` extending `Scene`.
 
         Requirements:
@@ -88,6 +85,7 @@ def _build_prompt(pdf_text: str, job_id: 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.
         - Animations should be clear, readable, and professional.
 
         Document content:
@@ -97,40 +95,33 @@ def _build_prompt(pdf_text: str, job_id: str) -> str:
     """).strip()
 
 
-def _render_manim(script_path: Path, job_id: str) -> None:
-    """Run manim render with retries."""
+def _render_manim(script_path: Path, job_id: str, max_retries: int = 2) -> None:
     cmd = [
         "manim",
         str(script_path),
         "OutputVideo",
         "-qm",
         "--media_dir", "media",
+        "--disable_caching",
     ]
-    max_retries = 2
     for attempt in range(max_retries + 1):
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=600,  # 10 min hard limit
-        )
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
         if result.returncode == 0:
             return
-        if attempt == max_retries:
-            raise RuntimeError(
-                f"Manim render failed after {max_retries + 1} attempts.\n"
-                f"STDERR: {result.stderr[-2000:]}"
-            )
-        import time
-        time.sleep(5 * (attempt + 1))
+        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:]}"
+    )
 
 
 def _deliver_video(
     video_path: str,
     email: str,
-    status_cb: Callable[[State, str], None],
+    status_cb: Callable,
 ) -> None:
-    """Try email attachment; fall back to Catbox link."""
     file_size_mb = Path(video_path).stat().st_size / (1024 * 1024)
 
     if file_size_mb <= 24:
@@ -138,14 +129,10 @@ def _deliver_video(
             send_video_email(email, video_path)
             return
         except Exception as exc:
-            status_cb(State.UPLOADING, f"⚠️ Email attachment failed ({exc}); trying Catbox…")
+            status_cb(State.UPLOADING, f"⚠️ Attachment failed ({exc}) — uploading to Catbox…", None)
     else:
-        status_cb(
-            State.UPLOADING,
-            f"📦 Video is {file_size_mb:.1f} MB — uploading to Catbox for link delivery…",
-        )
+        status_cb(State.UPLOADING, f"📦 {file_size_mb:.1f} MB video — uploading to Catbox…", None)
 
-    # Catbox fallback
     url = upload_to_catbox(video_path)
     send_video_email(email, video_path=None, catbox_url=url)
 

requirements.txt

@@ -1,5 +1,14 @@
-gradio
-google-genai
-manim
-pypdf
-requests
+# Full LaTeX distribution for Manim
+texlive-full
+
+# Video and rendering dependencies
+ffmpeg
+ghostscript
+
+# Tools for DVI/TeX output
+dvipng
+dvisvgm
+
+# Graphics libraries
+libcairo2-dev
+libpango1.0-dev

utils.py

@@ -33,36 +33,26 @@ def extract_pdf_text(pdf_path: str) -> str:
 
 # ── Gemini LLM ────────────────────────────────────────────────────────────────
 
-def generate_manim_code(prompt_text: str, api_key: str):
-    """Stream Manim code from Gemini 3 Flash Preview and return it as a string."""
+def generate_manim_code(prompt_text: str, api_key: str) -> str:
+    """Stream Manim code from Gemini."""
     client = genai.Client(api_key=api_key)
-    model = "gemini-3-flash-preview"
-
+    model = "gemini-2.5-flash-preview-05-20"  # latest stable flash model
     contents = [
-        types.Content(
-            role="user",
-            parts=[types.Part.from_text(text=prompt_text)]
-        )
+        types.Content(role="user", parts=[types.Part.from_text(prompt_text)])
     ]
-
     config = types.GenerateContentConfig(
-        thinking_config=types.ThinkingConfig(
-            thinking_level="HIGH"
-        )
+        thinking_config=types.ThinkingConfig(thinking_budget=8192)
     )
 
     code = ""
     for chunk in client.models.generate_content_stream(
-        model=model,
-        contents=contents,
-        config=config
+        model=model, contents=contents, config=config
     ):
         if chunk.text:
             code += chunk.text
-            print(chunk.text, end="")  # optional live streaming output
-
     return code
 
+
 def sanitize_manim_code(raw: str, job_id: str) -> str:
     """
     Strip markdown fences, ensure correct imports and class name,