Update app.py

app.py

@@ -1,542 +1,145 @@
-# app.py
 import os
 import re
-import shutil
 import aiofiles
-import asyncio
-import mimetypes
-import subprocess
 from pathlib import Path
-from typing import Optional, Tuple
-
-from fastapi import FastAPI, UploadFile, File, Request, HTTPException
-from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-
-# ---------- Config ----------
-BASE_DIR = Path("/tmp/videos")          # ephemeral storage suitable for HF Spaces free tier
-BASE_DIR.mkdir(parents=True, exist_ok=True)
-ALLOWED_EXT = {".mp4", ".webm", ".ogg", ".mov", ".mkv", ".avi", ".flv", ".ts", ".m4v"}
-MAX_FILENAME_LEN = 150
-CHUNK_SIZE = 1024 * 1024  # 1MB
-
-FFMPEG_PATH = shutil.which("ffmpeg")  # None if not installed
-
-app = FastAPI(title="FastAPI Video Player (complete)")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ---------- Utilities ----------
-def secure_filename(filename: str) -> str:
-    """
-    Sanitize filename:
-    - Keep ascii letters, digits, dot, underscore, hyphen
-    - Replace other chars with underscore
-    - Trim long names to avoid issues
-    """
-    name = os.path.basename(filename)
-    # Normalize unicode -> ascii (drop accents)
-    try:
-        import unicodedata
-        name = unicodedata.normalize("NFKD", name).encode("ascii", "ignore").decode("ascii")
-    except Exception:
-        pass
-    name = re.sub(r"[^A-Za-z0-9._-]", "_", name)
-    if len(name) > MAX_FILENAME_LEN:
-        base, ext = os.path.splitext(name)
-        name = base[:100] + ext
-    if name == "" or name in {".", ".."}:
-        name = "file"
-    return name
-
+from fastapi import FastAPI, UploadFile, Request
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+import mimetypes
 
-def needs_transcode(ext: str) -> bool:
-    """
-    Decide if we should transcode for browser compatibility.
-    Browsers commonly support mp4 (h264/aac), webm (vp9/vp8), ogg.
-    We will transcode if file is .mkv (common problem) or .avi, .flv etc.
-    """
-    ext = ext.lower()
-    return ext in {".mkv", ".avi", ".flv", ".ts", ".m4v"}
+app = FastAPI()
 
+VIDEO_DIR = Path("/tmp/videos")
+VIDEO_DIR.mkdir(parents=True, exist_ok=True)
 
-def parse_range(range_header: Optional[str], file_size: int) -> Optional[Tuple[int, int]]:
-    if not range_header:
-        return None
-    try:
-        units, rng = range_header.split("=")
-        if units.strip() != "bytes":
-            return None
-        start_str, end_str = rng.split("-")
-        if start_str == "":
-            # suffix bytes: -500
-            length = int(end_str)
-            start = file_size - length
-            end = file_size - 1
-        else:
-            start = int(start_str)
-            end = int(end_str) if end_str else file_size - 1
-        if start < 0:
-            start = 0
-        if end >= file_size:
-            end = file_size - 1
-        if start > end:
-            return None
-        return start, end
-    except Exception:
-        return None
+app.mount("/videos", StaticFiles(directory=VIDEO_DIR), name="videos")
 
 
-async def transcode_to_mp4(src: Path, dest: Path) -> bool:
-    """
-    Transcode using ffmpeg to mp4 (H.264 AAC). Returns True if success.
-    Blocking ffmpeg run executed asynchronously via asyncio to avoid blocking loop.
-    """
-    if not FFMPEG_PATH:
-        return False
-    cmd = [
-        FFMPEG_PATH,
-        "-y",
-        "-i", str(src),
-        "-c:v", "libx264",
-        "-preset", "fast",
-        "-crf", "23",
-        "-c:a", "aac",
-        "-b:a", "128k",
-        str(dest)
-    ]
-    proc = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-    stdout, stderr = await proc.communicate()
-    return proc.returncode == 0
+def safe_filename(filename: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9._-]", "_", filename)
 
 
-# ---------- Routes ----------
 @app.get("/", response_class=HTMLResponse)
 async def index():
-    # Embedded HTML + JS (single-page app)
-    # Contains: upload form (xhr progress), file list, player with controls
-    html = f"""
-<!doctype html>
-<html>
-<head>
-  <meta charset="utf-8"/>
-  <title>FastAPI Video Player</title>
-  <meta name="viewport" content="width=device-width,initial-scale=1"/>
-  <style>
-    :root{{--bg:#0b1020;--card:#0f1724;--muted:#9aa7bb;--accent1:#3b82f6;--accent2:#06b6d4;--glass: rgba(255,255,255,0.03)}}
-    body{{margin:0;font-family:Inter,system-ui,-apple-system,Segoe UI,Roboto;color:#e6eef8;background:linear-gradient(180deg,var(--bg),#071029);padding:20px}}
-    .wrap{{max-width:1100px;margin:0 auto}}
-    .card{{background:var(--card);padding:18px;border-radius:12px;box-shadow:0 8px 30px rgba(2,6,23,0.6)}}
-    h1{{
-      margin:0 0 8px 0;font-size:20px;
-    }}
-    .row{{display:flex;gap:12px;align-items:center;flex-wrap:wrap}}
-    .uploader{{border:1px dashed var(--glass);padding:14px;border-radius:10px;display:flex;gap:12px;align-items:center}}
-    .btn{{background:transparent;border:1px solid rgba(255,255,255,0.06);padding:8px 12px;border-radius:10px;color:inherit;cursor:pointer}}
-    input[type=file]{{color:transparent}}
-    video{{width:100%;max-height:62vh;border-radius:8px;background:#000;margin-top:12px}}
-    .controls{{display:flex;gap:8px;align-items:center;margin-top:8px;flex-wrap:wrap}}
-    .progress-wrap{{margin-top:12px;display:none}}
-    .progress{{height:14px;background:rgba(255,255,255,0.06);border-radius:10px;overflow:hidden}}
-    .progress > .fill{{height:100%;width:0%;background:linear-gradient(90deg,var(--accent1),var(--accent2));transition:width .12s}}
-    .status{{font-size:13px;color:var(--muted);margin-top:6px}}
-    ul.files{{list-style:none;padding:0;margin:8px 0 0 0;display:grid;grid-template-columns:1fr;gap:8px}}
-    li.file{{background:rgba(255,255,255,0.02);padding:8px;border-radius:8px;display:flex;justify-content:space-between;align-items:center;gap:8px}}
-    .meta{{font-size:13px;color:var(--muted)}}
-    .small{{font-size:13px;color:var(--muted)}}
-    .actions a{margin-left:8px;color:var(--muted);text-decoration:none}
-    @media(min-width:700px){{ul.files{{grid-template-columns:1fr 1fr}}}}
-  </style>
-</head>
-<body>
-  <div class="wrap">
-    <div class="card">
-      <h1>FastAPI Video Player — Upload & Play (/tmp/videos)</h1>
-      <div class="small">Files are stored in <code>/tmp/videos</code> (ephemeral on free Spaces). MKV/AVI auto-transcode to MP4 if <code>ffmpeg</code> is installed.</div>
-
-      <div style="height:12px"></div>
-
-      <div class="uploader row">
-        <input id="fileInput" type="file" accept="video/*,video/x-matroska,.mkv,.mp4,.webm,.avi,.mov,.flv,.ts"/>
-        <button id="uploadBtn" class="btn">Upload</button>
-        <div style="flex:1"></div>
-        <button id="refreshBtn" class="btn">Refresh List</button>
-        <button id="clearBtn" class="btn">Clear /tmp</button>
-      </div>
-
-      <div class="progress-wrap" id="progressWrap">
-        <div class="progress"><div class="fill" id="progressFill"></div></div>
-        <div class="status" id="status">Idle</div>
-      </div>
-
-      <video id="player" controls preload="metadata">
-        <source id="source" src=""/>
-        Your browser does not support HTML5 video.
-      </video>
-
-      <div class="controls">
-        <button id="playPause" class="btn">Play/Pause</button>
-        <button id="muteBtn" class="btn">Mute/Unmute</button>
-        <label class="small">Rate:
-          <select id="rate">
-            <option value="0.5">0.5x</option><option value="0.75">0.75x</option>
-            <option value="1" selected>1x</option><option value="1.25">1.25x</option>
-            <option value="1.5">1.5x</option><option value="2">2x</option>
-          </select>
-        </label>
-        <label class="small">Vol:
-          <input type="range" id="volume" min="0" max="1" step="0.01" value="1">
-        </label>
-        <button id="pipBtn" class="btn">Picture-in-Picture</button>
-        <button id="fsBtn" class="btn">Fullscreen</button>
-        <div style="flex:1"></div>
-        <div id="playInfo" class="small">No file loaded</div>
-      </div>
-
-      <hr style="border:none;border-top:1px solid rgba(255,255,255,0.03);margin:12px 0"/>
-
-      <h3>Files in /tmp/videos</h3>
-      <ul class="files" id="fileList"></ul>
-
-    </div>
-  </div>
-
-<script>
-const uploadBtn = document.getElementById('uploadBtn');
-const fileInput = document.getElementById('fileInput');
-const progressWrap = document.getElementById('progressWrap');
-const progressFill = document.getElementById('progressFill');
-const statusEl = document.getElementById('status');
-const refreshBtn = document.getElementById('refreshBtn');
-const clearBtn = document.getElementById('clearBtn');
-const fileList = document.getElementById('fileList');
-const player = document.getElementById('player');
-const source = document.getElementById('source');
-const playPause = document.getElementById('playPause');
-const muteBtn = document.getElementById('muteBtn');
-const rate = document.getElementById('rate');
-const volume = document.getElementById('volume');
-const pipBtn = document.getElementById('pipBtn');
-const fsBtn = document.getElementById('fsBtn');
-const playInfo = document.getElementById('playInfo');
-
-let currentFile = null;
-
-function fmtBytes(bytes) {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B','KB','MB','GB','TB'];
-  const i = Math.floor(Math.log(bytes)/Math.log(k));
-  return parseFloat((bytes / Math.pow(k,i)).toFixed(2)) + ' ' + sizes[i];
-}
-
-async function fetchList(){
-  try {
-    const res = await fetch('/list');
-    const arr = await res.json();
-    fileList.innerHTML = '';
-    if (!arr.length) {
-      fileList.innerHTML = '<li class="file small">No files uploaded yet.</li>';
-      return;
-    }
-    for (let item of arr){
-      const li = document.createElement('li');
-      li.className = 'file';
-      const left = document.createElement('div');
-      left.innerHTML = `<div style="font-weight:600">${item.name}</div><div class="meta">${item.size_human} • ${item.mtime}</div>`;
-      const right = document.createElement('div');
-      right.className = 'actions';
-      right.innerHTML = `
-        <a href="#" onclick="playFile('${encodeURIComponent(item.name)}');return false;" title="Play">▶️ Play</a>
-        <a href="/video/${encodeURIComponent(item.name)}" target="_blank" title="Open">⤴ Open</a>
-        <a href="/download/${encodeURIComponent(item.name)}" title="Download">⬇️</a>
-        <a href="#" onclick="deleteFile('${encodeURIComponent(item.name)}');return false;" title="Delete">🗑️</a>
-      `;
-      li.appendChild(left); li.appendChild(right);
-      fileList.appendChild(li);
-    }
-  } catch (e) {
-    console.error(e);
-    fileList.innerHTML = '<li class="file small">Failed to load files</li>';
-  }
-}
-
-async function playFile(nameEncoded){
-  const name = decodeURIComponent(nameEncoded);
-  currentFile = name;
-  source.src = '/video/' + encodeURIComponent(name);
-  player.load();
-  try { await player.play(); } catch(e) {}
-  playInfo.textContent = name;
-}
-
-uploadBtn.addEventListener('click', async ()=>{
-  const file = fileInput.files[0];
-  if (!file) { alert('Pick a file first'); return; }
-
-  const form = new FormData();
-  form.append('file', file);
-
-  const xhr = new XMLHttpRequest();
-  xhr.open('POST', '/upload', true);
-
-  let startTime = 0;
-  xhr.upload.onloadstart = function(){ startTime = Date.now(); progressWrap.style.display='block'; progressFill.style.width='0%'; statusEl.textContent = 'Starting upload...'; }
-  xhr.upload.onprogress = function(e){
-    if (e.lengthComputable){
-      const pct = (e.loaded / e.total) * 100;
-      progressFill.style.width = pct.toFixed(2) + '%';
-      const elapsed = (Date.now() - startTime)/1000;
-      const speed = e.loaded / elapsed; // bytes/sec
-      const speedStr = fmtBytes(speed) + '/s';
-      const remain = (e.total - e.loaded) / (speed || 1);
-      const eta = Math.max(0, remain).toFixed(1) + 's';
-      statusEl.textContent = `Uploading ${pct.toFixed(1)}% • ${speedStr} • ETA ${eta}`;
-    }
-  };
-  xhr.onreadystatechange = function(){
-    if (xhr.readyState === 4){
-      if (xhr.status === 200){
-        try {
-          const json = JSON.parse(xhr.responseText);
-          // server may return {"status":"ok","transcoded":true,"filename":"x.mp4"}
-          statusEl.textContent = 'Upload complete. ' + (json.transcoded ? 'Transcoded to MP4.' : 'Stored.');
-        } catch(e){
-          statusEl.textContent = 'Upload complete.';
-        }
-        setTimeout(()=>{ progressWrap.style.display='none'; progressFill.style.width='0%'; }, 900);
-        fetchList();
-      } else {
-        statusEl.textContent = 'Upload failed: ' + xhr.responseText;
-      }
-    }
-  };
-
-  xhr.send(form);
-});
-
-refreshBtn.addEventListener('click', fetchList);
-window.addEventListener('load', fetchList);
-
-clearBtn.addEventListener('click', async ()=>{
-  if (!confirm('Delete ALL files in /tmp/videos?')) return;
-  const res = await fetch('/clear_tmp', { method:'POST' });
-  if (res.ok) { fetchList(); alert('Cleared'); } else alert('Clear failed');
-});
-
-async function deleteFile(nameEncoded){
-  const name = decodeURIComponent(nameEncoded);
-  if (!confirm('Delete ' + name + '?')) return;
-  const res = await fetch('/delete/' + encodeURIComponent(name), { method:'DELETE' });
-  if (res.ok) { fetchList(); } else alert('Delete failed');
-}
-
-// Player controls
-playPause.addEventListener('click', ()=>{ if (player.paused) player.play(); else player.pause(); });
-muteBtn.addEventListener('click', ()=>{ player.muted = !player.muted; muteBtn.textContent = player.muted ? 'Unmute' : 'Mute'; });
-rate.addEventListener('change', ()=>{ player.playbackRate = parseFloat(rate.value); });
-volume.addEventListener('input', ()=>{ player.volume = parseFloat(volume.value); });
-
-pipBtn.addEventListener('click', async ()=>{
-  if (document.pictureInPictureElement) {
-    await document.exitPictureInPicture();
-  } else {
-    try { await player.requestPictureInPicture(); } catch(e){ alert('PiP not supported'); }
-  }
-});
-
-fsBtn.addEventListener('click', ()=>{
-  if (!document.fullscreenElement) player.requestFullscreen().catch(()=>{});
-  else document.exitFullscreen();
-});
-
-player.addEventListener('timeupdate', ()=> {
-  // you can update a progress indicator here if you want
-});
-
-// expose helper for play links
-window.playFile = playFile;
-window.deleteFile = deleteFile;
-</script>
-</body>
-</html>
-    """
-    return HTMLResponse(content=html)
+    return HTMLResponse(f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>FastAPI Video Player</title>
+        <style>
+            body {{ font-family: Arial, sans-serif; background: #121212; color: white; text-align: center; }}
+            .upload-section {{ margin: 20px; }}
+            .progress-container {{ width: 60%; margin: auto; background: #333; border-radius: 10px; }}
+            .progress-bar {{ width: 0%; height: 20px; background: lime; border-radius: 10px; }}
+            video {{ width: 80%; margin-top: 20px; border: 2px solid #444; border-radius: 8px; }}
+            .controls button {{ margin: 5px; padding: 10px; }}
+            ul {{ list-style: none; padding: 0; }}
+            li {{ margin: 5px; }}
+            a {{ color: #0af; text-decoration: none; }}
+        </style>
+    </head>
+    <body>
+        <h1>🎥 FastAPI Video Player</h1>
+        <div class="upload-section">
+            <input type="file" id="fileInput" />
+            <button onclick="uploadFile()">Upload</button>
+            <div class="progress-container">
+                <div class="progress-bar" id="progressBar"></div>
+            </div>
+            <p id="status"></p>
+        </div>
+        <h2>Available Videos</h2>
+        <ul id="videoList"></ul>
+        <video id="player" controls></video>
+        <div class="controls">
+            <button onclick="document.getElementById('player').play()">▶ Play</button>
+            <button onclick="document.getElementById('player').pause()">⏸ Pause</button>
+            <button onclick="document.getElementById('player').muted=!document.getElementById('player').muted">🔇 Mute/Unmute</button>
+            <button onclick="document.getElementById('player').playbackRate-=0.25">⏪ Slower</button>
+            <button onclick="document.getElementById('player').playbackRate+=0.25">⏩ Faster</button>
+        </div>
+        <script>
+            async function fetchList() {{
+                const res = await fetch('/list');
+                const data = await res.json();
+                const list = document.getElementById('videoList');
+                list.innerHTML = '';
+                data.forEach(file => {{
+                    const li = document.createElement('li');
+                    const a = document.createElement('a');
+                    a.href = '#';
+                    a.textContent = file;
+                    a.onclick = () => {{
+                        document.getElementById('player').src = '/videos/' + file;
+                        document.getElementById('player').play();
+                    }};
+                    li.appendChild(a);
+                    list.appendChild(li);
+                }});
+            }}
+
+            async function uploadFile() {{
+                const fileInput = document.getElementById('fileInput');
+                if (!fileInput.files.length) return alert("Select a file first!");
+                const file = fileInput.files[0];
+                const formData = new FormData();
+                formData.append("file", file);
+
+                const xhr = new XMLHttpRequest();
+                xhr.open("POST", "/upload", true);
+
+                xhr.upload.onprogress = function(event) {{
+                    if (event.lengthComputable) {{
+                        let percent = (event.loaded / event.total) * 100;
+                        document.getElementById("progressBar").style.width = percent + "%";
+                        document.getElementById("status").innerText = "Uploading " + Math.round(percent) + "%";
+                    }}
+                }};
+
+                xhr.onload = function() {{
+                    if (xhr.status === 200) {{
+                        document.getElementById("status").innerText = "✅ Upload complete";
+                        fetchList();
+                    }} else {{
+                        document.getElementById("status").innerText = "❌ Error: " + xhr.responseText;
+                    }}
+                }};
+
+                xhr.send(formData);
+            }}
+
+            fetchList();
+        </script>
+    </body>
+    </html>
+    """)
 
 
 @app.post("/upload")
-async def upload(file: UploadFile = File(...)):
-    """
-    Upload file, sanitize filename, save in /tmp/videos.
-    If file type needs transcode and ffmpeg is available, transcode to MP4 and return transcoded filename.
-    """
-    orig_name = secure_filename(file.filename)
-    ext = Path(orig_name).suffix.lower()
-    if ext not in ALLOWED_EXT:
-        raise HTTPException(status_code=400, detail=f"Extension '{ext}' not allowed.")
-
-    # ensure unique name
-    dest = BASE_DIR / orig_name
-    base, extn = os.path.splitext(dest)
-    counter = 1
-    while dest.exists():
-        dest = Path(f"{base}_{counter}{extn}")
-        counter += 1
-
-    # save uploaded file in chunks
+async def upload(file: UploadFile):
+    filename = safe_filename(file.filename)
+    final_path = VIDEO_DIR / filename
     try:
-        async with aiofiles.open(dest, "wb") as out_f:
-            while True:
-                chunk = await file.read(CHUNK_SIZE)
-                if not chunk:
-                    break
-                await out_f.write(chunk)
-    except PermissionError:
-        raise HTTPException(status_code=500, detail="Permission denied writing to storage.")
+        async with aiofiles.open(final_path, "wb") as out_file:
+            while chunk := await file.read(1024 * 1024):
+                await out_file.write(chunk)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-    # If transcode is recommended, try to transcode synchronously (blocking)
-    transcoded = False
-    if needs_transcode(ext) and FFMPEG_PATH:
-        target = dest.with_suffix(".mp4")
-        # avoid re-transcoding if existing
-        try:
-            # run transcode
-            success = await transcode_to_mp4(dest, target)
-            if success:
-                # remove original (to save space) and set dest to mp4
-                try:
-                    dest.unlink(missing_ok=True)
-                except Exception:
-                    pass
-                dest = target
-                transcoded = True
-            else:
-                # transcode failed: keep original
-                transcoded = False
-        except Exception:
-            transcoded = False
-
-    return JSONResponse({"status": "ok", "filename": dest.name, "transcoded": transcoded})
+        return JSONResponse({"error": str(e)}, status_code=500)
+    return {"filename": filename}
 
 
 @app.get("/list")
-async def list_files():
-    """
-    Return JSON list of files with name, size, modified time.
-    """
-    files = []
-    for p in sorted(BASE_DIR.glob("*")):
-        if p.is_file():
-            stat = p.stat()
-            files.append({
-                "name": p.name,
-                "size": stat.st_size,
-                "size_human": human_readable_size(stat.st_size),
-                "mtime": format_mtime(stat.st_mtime)
-            })
-    return JSONResponse(files)
-
-
-def human_readable_size(n: int) -> str:
-    for unit in ['B','KB','MB','GB','TB']:
-        if n < 1024.0:
-            return f"{n:.2f} {unit}"
-        n /= 1024.0
-    return f"{n:.2f} PB"
-
+async def list_videos():
+    files = [f.name for f in VIDEO_DIR.iterdir() if f.is_file()]
+    return files
 
-def format_mtime(ts: float) -> str:
-    from datetime import datetime
-    return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S")
 
-
-@app.get("/video/{name}")
-async def stream_video(request: Request, name: str):
-    """
-    Stream with Range support for seeking.
-    """
-    filename = secure_filename(name)
-    path = BASE_DIR / filename
-    if not path.exists():
-        raise HTTPException(status_code=404, detail="File not found")
-    file_size = path.stat().st_size
-    range_header = request.headers.get("range")
-    range_parsed = parse_range(range_header, file_size)
-
-    mime_type, _ = mimetypes.guess_type(str(path))
+@app.get("/videos/{filename}")
+async def serve_video(filename: str):
+    file_path = VIDEO_DIR / filename
+    if not file_path.exists():
+        return JSONResponse({"error": "File not found"}, status_code=404)
+    mime_type, _ = mimetypes.guess_type(str(file_path))
     if mime_type is None:
-        mime_type = "application/octet-stream"
-
-    if range_parsed:
-        start, end = range_parsed
-        chunk_size = (end - start) + 1
-        async def iter_file():
-            with open(path, "rb") as f:
-                f.seek(start)
-                remaining = chunk_size
-                while remaining > 0:
-                    read_bytes = min(CHUNK_SIZE, remaining)
-                    data = f.read(read_bytes)
-                    if not data:
-                        break
-                    remaining -= len(data)
-                    yield data
-        headers = {
-            "Content-Range": f"bytes {start}-{end}/{file_size}",
-            "Accept-Ranges": "bytes",
-            "Content-Length": str(chunk_size),
-            "Content-Type": mime_type
-        }
-        return StreamingResponse(iter_file(), status_code=206, headers=headers)
-    else:
-        return FileResponse(path, media_type=mime_type, filename=path.name)
-
-
-@app.get("/download/{name}")
-async def download(name: str):
-    filename = secure_filename(name)
-    path = BASE_DIR / filename
-    if not path.exists():
-        raise HTTPException(status_code=404)
-    return FileResponse(path, media_type="application/octet-stream", filename=path.name)
-
-
-@app.delete("/delete/{name}")
-async def delete(name: str):
-    filename = secure_filename(name)
-    path = BASE_DIR / filename
-    if not path.exists():
-        raise HTTPException(status_code=404)
-    try:
-        path.unlink()
-        return JSONResponse({"status":"ok"})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/clear_tmp")
-async def clear_tmp():
-    try:
-        for f in BASE_DIR.iterdir():
-            if f.is_file():
-                f.unlink()
-            elif f.is_dir():
-                shutil.rmtree(f)
-        return JSONResponse({"status":"ok"})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ---------- Run ----------
-# Use uvicorn externally: uvicorn app:app --host 0.0.0.0 --port 7860
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)
+        mime_type = "video/mp4"
+    return FileResponse(file_path, media_type=mime_type)