Update app.py

app.py

@@ -1,177 +1,56 @@
-"""
-Streamlit Universal File-Format Converter
-----------------------------------------
-A Streamlit app for Hugging Face Spaces that **actually converts** file
-contents across a wide array of formats, leveraging local libraries
-(no API keys needed):
-
-• **Images** via Pillow (JPEG, PNG, GIF, BMP, TIFF, ICO, WebP)
-• **Text & markup** via pypandoc (MD, HTML, LaTeX, DOCX, PDF, etc.)
-• **Office docs** via unoconv + LibreOffice headless (PDF, DOCX, PPTX, XLSX)
-• **Audio/video** via ffmpeg-python (MP3, WAV, MP4, AVI, MKV, MOV, etc.)
-• **MIME detection** via python-magic
-
-Disallowed uploads: `.exe`, `.bin`
-All outputs are streamed into a ZIP for download.
-
-Created 2025-05-22 • v3
-"""
-from __future__ import annotations
-
-# Set up a writable Streamlit home BEFORE importing streamlit
-import os, pathlib
-os.environ.setdefault("STREAMLIT_HOME", "/tmp/.streamlit")
-os.environ.setdefault("HOME", "/tmp")
-pathlib.Path(os.environ["STREAMLIT_HOME"]).mkdir(parents=True, exist_ok=True)
-
-import io
-import zipfile
-import tempfile
-import subprocess
-from datetime import datetime
-from pathlib import Path
-
-import streamlit as st
-from PIL import Image
-import pypandoc
-import ffmpeg
-import magic  # python-magic for mime detection
-
-# -----------------------------------------------------------------------------
-# Supported extensions
-# -----------------------------------------------------------------------------
-IMAGE_EXTS = {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".tiff", ".ico", ".webp"}
-TEXT_EXTS = {".txt", ".md", ".csv", ".json", ".xml", ".html", ".css", ".js"}
-MEDIA_EXTS = {".mp3", ".wav", ".mp4", ".avi", ".mkv", ".mov"}
-DOC_EXTS   = {".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".odt", ".ods"}
-
-ALLOWED_TARGET_EXTS = sorted(IMAGE_EXTS | TEXT_EXTS | MEDIA_EXTS | DOC_EXTS)
-DISALLOWED_SOURCE_EXTS = {".exe", ".bin"}
-
-# -----------------------------------------------------------------------------
-# UI elements
-# -----------------------------------------------------------------------------
-def sidebar_target_extension() -> str:
-    st.sidebar.header("Settings")
-    query = st.sidebar.text_input("Filter extensions… (optional)")
-    choices = [e for e in ALLOWED_TARGET_EXTS if query.lower() in e]
-    if not choices:
-        st.sidebar.error("No extension matches that filter.")
-        choices = ALLOWED_TARGET_EXTS
-    return st.sidebar.selectbox(
-        "Target extension for **all** files", choices, index=choices.index(".pdf") if ".pdf" in choices else 0
-    )
-
-def uploader():
-    return st.file_uploader(
-        "Upload files to convert", type=None, accept_multiple_files=True
-    )
-
-# -----------------------------------------------------------------------------
-# Conversion functions
-# -----------------------------------------------------------------------------
-def convert_image(data: bytes, target_ext: str) -> bytes:
-    img = Image.open(io.BytesIO(data))
-    buf = io.BytesIO()
-    fmt = {".jpg":"JPEG", ".jpeg":"JPEG", ".png":"PNG", ".gif":"GIF",
-           ".bmp":"BMP", ".tiff":"TIFF", ".ico":"ICO", ".webp":"WEBP"}[target_ext]
-    img.save(buf, format=fmt)
-    return buf.getvalue()
-
-
-def convert_text_markup(data: bytes, orig_ext: str, target_ext: str) -> bytes:
-    text = data.decode("utf-8", errors="ignore")
-    return pypandoc.convert_text(text, to=target_ext.lstrip('.'), format=orig_ext.lstrip('.')).encode('utf-8')
-
-
-def convert_office(temp_dir: str, data: bytes, orig_ext: str, target_ext: str) -> bytes:
-    # Use unoconv to convert office files
-    suffix_in = orig_ext
-    suffix_out = target_ext
-    in_path = Path(temp_dir) / f"input{suffix_in}"
-    out_path = Path(temp_dir) / f"output{suffix_out}"
-    in_path.write_bytes(data)
-    subprocess.run(["unoconv", "-f", suffix_out.lstrip('.'), "-o", str(out_path), str(in_path)], check=True)
-    return out_path.read_bytes()
-
-
-def convert_media(data: bytes, target_ext: str) -> bytes:
-    # ffmpeg-python streaming
-    process = (
-        ffmpeg.input('pipe:0')
-              .output('pipe:1', format=target_ext.lstrip('.'))
-              .run_async(pipe_stdin=True, pipe_stdout=True, pipe_stderr=True)
-    )
-    out, err = process.communicate(data)
-    return out
-
-
-def convert_file(file: st.runtime.uploaded_file_manager.UploadedFile, target_ext: str) -> tuple[bytes, str]:
-    name = Path(file.name)
-    orig_ext = name.suffix.lower()
-    raw = file.read()
-
-    if orig_ext in DISALLOWED_SOURCE_EXTS:
-        raise ValueError(f"Disallowed: {orig_ext}")
-
-    mime = magic.from_buffer(raw, mime=True) or ''
-
-    try:
-        if orig_ext in IMAGE_EXTS and target_ext in IMAGE_EXTS:
-            return convert_image(raw, target_ext), "image converted"
-        if mime.startswith('text/') or orig_ext in TEXT_EXTS:
-            if orig_ext != target_ext:
-                return convert_text_markup(raw, orig_ext, target_ext), "text/markup converted"
-        if orig_ext in DOC_EXTS or target_ext in DOC_EXTS:
-            with tempfile.TemporaryDirectory() as tmp:
-                return convert_office(tmp, raw, orig_ext, target_ext), "office/doc converted"
-        if mime.startswith(('audio/','video/')) or orig_ext in MEDIA_EXTS:
-            if orig_ext != target_ext:
-                return convert_media(raw, target_ext), "media converted"
-    except Exception as e:
-        st.warning(f"⚠️ Conversion failed for {file.name}: {e}. Falling back to rename.")
-
-    # Fallback: no conversion, just rename
-    return raw, "renamed only"
-
-# -----------------------------------------------------------------------------
-# ZIP packaging
-# -----------------------------------------------------------------------------
-def package_zip(files: list[st.runtime.uploaded_file_manager.UploadedFile], target_ext: str) -> io.BytesIO:
-    buf = io.BytesIO()
-    with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zf:
-        for file in files:
-            name = Path(file.name)
-            if name.suffix.lower() in DISALLOWED_SOURCE_EXTS:
-                st.warning(f"Skipping disallowed file: {name.name}")
-                continue
-            data, note = convert_file(file, target_ext)
-            out_name = name.with_suffix(target_ext).name
-            zf.writestr(out_name, data)
-            st.success(f"{note}: {name.name} → {out_name}")
-    buf.seek(0)
-    return buf
-
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
-
-def main():
-    st.set_page_config("Universal Converter", page_icon="🔄", layout="centered")
-    st.title("🔄 Universal File-Format Converter")
-    st.write("Upload files of any format; choose a new extension; download a ZIP of converted files.")
-
-    target_ext = sidebar_target_extension()
-    files = uploader()
-
-    if files and st.button("Convert & Download 🚀"):
-        zip_buf = package_zip(files, target_ext)
-        ts = datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')
-        st.download_button("⬇️ Download ZIP", zip_buf,
-                            file_name=f"converted_{ts}.zip",
-                            mime='application/zip')
-
-    st.caption("© 2025 Universal Converter • Streamlit • Hugging Face Spaces")
-
-if __name__ == '__main__':
-    main()
+# app.py
+import fitz                     # PyMuPDF
+from markdownify import markdownify as md
+import json
+import gradio as gr
+
+def convert_pdf_to_markdown(path):
+    """Extract each page as HTML, convert to Markdown."""
+    doc = fitz.open(path)
+    pages_md = []
+    for i, page in enumerate(doc, start=1):
+        html = page.get_text("html") or ""
+        # Clean conversion: collapse multiple newlines
+        page_md = md(html).strip()
+        pages_md.append({"page": i, "markdown": page_md})
+    return pages_md
+
+def process_upload(pdf_file, output_format):
+    """
+    pdf_file: tempfile-like object from Gradio
+    output_format: "markdown" or "json"
+    """
+    # Convert and collect
+    pages = convert_pdf_to_markdown(pdf_file.name)
+    
+    if output_format == "markdown":
+        # Join all pages
+        full_md = "\n\n---\n\n".join(p["markdown"] for p in pages)
+        return full_md
+    else:
+        # Return pretty JSON
+        return json.dumps({"pages": pages}, indent=2, ensure_ascii=False)
+
+# Gradio interface
+demo = gr.Interface(
+    fn=process_upload,
+    inputs=[
+        gr.File(label="Upload your PDF", file_types=[".pdf"]),
+        gr.Radio(choices=["markdown", "json"],
+                 value="markdown",
+                 label="Output format")
+    ],
+    outputs=gr.Code(label="Converted Output"),
+    title="PDF → Markdown/JSON Converter",
+    description=(
+        "Upload a PDF and get back a professionally converted Markdown "
+        "or a structured JSON with each page’s Markdown. "
+        "PDFs with images or complex tables may still need manual review."
+    ),
+    examples=[
+        # you can add example PDFs here if desired
+    ]
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)