Update app.py

app.py

@@ -1,69 +1,154 @@
+import os
+import subprocess
+import pathlib
+import hashlib
+import requests
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
+
+# ----------------------------------------------------------------------
+# 1️⃣  Download a static FFmpeg build (Linux x86_64, CPU only)
+# ----------------------------------------------------------------------
+FFMPEG_URL = (
+    "https://github.com/BtbN/FFmpeg-Builds/releases/download"
+    "/latest/ffmpeg-master-latest-linux64-gpl.tar.xz"
+)
+FFMPEG_DIR = pathlib.Path("ffmpeg")
+BINARY_PATH = FFMPEG_DIR / "ffmpeg"
+
+def _download_and_extract():
+    """Download and extract FFmpeg if not already present."""
+    if BINARY_PATH.is_file():
+        return
+
+    # Create directory
+    FFMPEG_DIR.mkdir(parents=True, exist_ok=True)
+    tar_path = FFMPEG_DIR / "ffmpeg.tar.xz"
+
+    # Stream download (avoids loading whole file into memory)
+    with requests.get(FFMPEG_URL, stream=True, timeout=30) as r:
+        r.raise_for_status()
+        with open(tar_path, "wb") as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+    # Extract only the binary (no need for docs, etc.)
+    import tarfile
+    with tarfile.open(tar_path, "r:xz") as tar:
+        # Find the member that ends with '/ffmpeg'
+        for member in tar.getmembers():
+            if member.name.endswith("/ffmpeg"):
+                member.path = os.path.basename(member.name)  # flatten
+                tar.extract(member, path=FFMPEG_DIR)
+                break
+
+    # Clean up archive
+    tar_path.unlink()
+
+    # Make binary executable
+    BINARY_PATH.chmod(0o755)
+
+_download_and_extract()
+
+# ----------------------------------------------------------------------
+# 2️⃣  Helper: run FFmpeg safely
+# ----------------------------------------------------------------------
+def run_ffmpeg(input_bytes: bytes, args: str) -> bytes:
     """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+    Execute a very limited FFmpeg command.
+
+    Parameters
+    ----------
+    input_bytes : bytes
+        Raw input file (e.g., video or audio) uploaded by the user.
+    args : str
+        Command‑line arguments *after* the input and before the output.
+        Example: "-c:a aac -b:a 128k" (convert audio to AAC).
+
+    Returns
+    -------
+    bytes
+        Output file produced by FFmpeg.
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
+    # Validate arguments – allow only a whitelist of safe flags
+    allowed_flags = {
+        "-c:a", "-c:v", "-b:a", "-b:v", "-ar", "-ac", "-vn", "-an",
+        "-map", "-f", "-y", "-loglevel", "quiet"
+    }
+    tokenised = args.split()
+    if any(tok not in allowed_flags and not tok.startswith("-") for tok in tokenised):
+        raise ValueError("Unsupported FFmpeg flag detected.")
+
+    # Write input to a temporary file
+    input_path = pathlib.Path("input.tmp")
+    output_path = pathlib.Path("output.tmp")
+    input_path.write_bytes(input_bytes)
+
+    # Build the command
+    cmd = [
+        str(BINARY_PATH),
+        "-loglevel", "quiet",               # suppress noisy output
+        "-i", str(input_path),              # input file
+        *tokenised,                         # user‑provided args
+        str(output_path)                    # output file
+    ]
+
+    # Run FFmpeg; enforce a short timeout (e.g., 30 s) to keep the Space alive
+    try:
+        subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=30,
+        )
+    finally:
+        # Clean up input regardless of success/failure
+        if input_path.exists():
+            input_path.unlink()
+
+    if not output_path.is_file():
+        raise RuntimeError("FFmpeg did not produce an output file.")
+
+    # Return output bytes and clean up
+    out_bytes = output_path.read_bytes()
+    output_path.unlink()
+    return out_bytes
+
+# ----------------------------------------------------------------------
+# 3️⃣  Gradio UI
+# ----------------------------------------------------------------------
+def ffmpeg_interface(file: gr.File, args: str) -> gr.File:
+    """
+    Gradio wrapper that takes an uploaded file and FFmpeg args,
+    returns the processed file.
+    """
+    output_bytes = run_ffmpeg(file.read(), args)
+    # Heuristic MIME type based on args; fallback to generic binary
+    mime = "application/octet-stream"
+    if "-c:a aac" in args or ".aac" in args:
+        mime = "audio/aac"
+    elif "-c:v libx264" in args or ".mp4" in args:
+        mime = "video/mp4"
+    return gr.File.update(value=output_bytes, mime_type=mime)
+
+iface = gr.Interface(
+    fn=ffmpeg_interface,
+    inputs=[
+        gr.File(label="Upload video/audio file"),
+        gr.Textbox(
+            label="FFmpeg arguments (after input, before output)",
+            placeholder="-c:a aac -b:a 128k",
         ),
     ],
+    outputs=gr.File(label="Processed file"),
+    title=" FFmpeg on Hugging Face Spaces (CPU‑only)",
+    description=(
+        "Upload a media file and supply a limited set of FFmpeg flags. "
+        "The app runs on a free‑tier CPU space, so keep jobs short."
+    ),
+    allow_flagging="never",
+    analytics_enabled=False,
 )
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
-
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()