Upload 4 files

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY main.py .
+RUN mkdir -p videos
+
+# ── Env vars to set at runtime ──────────────────────────────────────────────
+# PUBLIC_URL      = https://your-api.hf.space   (where n8n sends callbacks)
+# GITHUB_TOKEN    = ghp_...
+# GITHUB_REPO     = owner/repo
+# N8N_TRIGGER_URL = https://egauto-n8n.hf.space/webhook/...
+
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,13 +1,123 @@
+# Video Download Middleware API
+
+وسيط بين الـ client وبين n8n / GitHub Action pipeline.
+
+---
+
+## الـ Flow الكامل
+
+```
+Client
+  │
+  ├─ POST /download  {"url": "https://youtube.com/..."}
+  │        ↓
+  │   API يبعت trigger لـ n8n  (webhook "run gethup action")
+  │        ↓
+  │   n8n يشغل GitHub Action
+  │        ↓
+  │   GitHub Action يحمّل الفيديو وبعدين يبعت POST على
+  │   /n8n/callback/{job_id}  ← الـ API بيستقبله ويحفظ الفيديو
+  │
+  ├─ GET /status/{job_id}   ← polling كل 5 ثواني مثلاً
+  │        ↓ لما status = "done"
+  └─ GET /file/{job_id}     ← يجيب الفيديو
+```
+
+---
+
+## Endpoints
+
+| Method | Path | الوصف |
+|--------|------|-------|
+| `POST` | `/download` | ابدأ تحميل جديد |
+| `GET`  | `/status/{job_id}` | اعرف الحالة |
+| `GET`  | `/file/{job_id}` | حمّل الفيديو |
+| `POST` | `/n8n/callback/{job_id}` | n8n بيبعت النتيجة هنا |
+| `GET`  | `/jobs` | قائمة كل الجوبز (للـ debug) |
+| `DELETE` | `/job/{job_id}` | احذف جوب وملفه |
+| `GET`  | `/health` | health check |
+
+---
+
+## مثال كامل
+
+### 1. ابدأ التحميل
+```bash
+curl -X POST https://your-api/download \
+  -H "Content-Type: application/json" \
+  -d '{"url": "https://www.youtube.com/watch?v=3Yw2SGumGQ8"}'
+
+# Response:
+# {"job_id": "abc-123", "status": "processing"}
+```
+
+### 2. اعمل polling
+```bash
+curl https://your-api/status/abc-123
+
+# بيرجع:
+# {"job_id":"abc-123","status":"processing",...}   ← لسه بيتحمل
+# {"job_id":"abc-123","status":"done","download_url":"https://your-api/file/abc-123",...}  ← خلص
+```
+
+### 3. حمّل الفيديو
+```bash
+curl -L https://your-api/file/abc-123 -o video.mp4
+```
+
+---
+
+## كيف تربطه بـ n8n
+
+في n8n، الـ node اللي كان بيبعت النتيجة (downlode video1) محتاج يبعت على:
+```
+https://YOUR_API_URL/n8n/callback/{job_id}
+```
+
+الـ `job_id` بيوصل لـ n8n في الـ inputs لما الـ API يشغل الـ workflow.
+
+### n8n يدعم حالتين:
+
+**Case A – JSON (مجرد إشعار إن الأرتيفاكت جاهز):**
+```json
+{
+  "status": "success",
+  "run_id": "25934033751",
+  "filename": "video.mp4"
+}
+```
+→ الـ API هيجيب الأرتيفاكت من GitHub بنفسه.
+
+**Case B – Raw binary (يبعت الفيديو نفسه):**
+بس يبعت binary body + header:
+```
+x-filename: video.mp4
+Content-Type: video/mp4
+```
+
 ---
-title: EGDownloader API
-emoji: 🏆
-colorFrom: gray
-colorTo: blue
-sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
+
+## Environment Variables
+
+```env
+PUBLIC_URL=https://your-api-public-url.com   # مهم جداً عشان n8n يعرف يرد
+GITHUB_TOKEN=ghp_...
+GITHUB_REPO=expher510/AutoClip-Pipeline
+WORKFLOW_FILE=video-download.yml
+N8N_TRIGGER_URL=https://egauto-n8n.hf.space/webhook/run%20gethup%20action
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## تشغيل محلي
+
+```bash
+pip install -r requirements.txt
+PUBLIC_URL=https://xxxx.ngrok.io uvicorn main:app --reload --port 8000
+```
+
+## تشغيل على Hugging Face Spaces (Docker)
+
+1. ارفع الملفات على Space جديد (Docker SDK)
+2. حط الـ env vars في Settings → Repository secrets
+3. الـ port هو `7860`

main.py

@@ -0,0 +1,313 @@
+"""
+Video Download Middleware API
+==============================
+Flow:
+  1. POST /download  → triggers GitHub Action → returns job_id
+  2. GET  /status/{job_id} → returns pending / processing / done / failed
+  3. GET  /file/{job_id}   → streams the video file (only when done)
+
+n8n webhooks:
+  - POST /n8n/callback  → n8n calls this when the video is ready (from "downlode video1" node)
+"""
+
+import os
+import uuid
+import time
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import aiofiles
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel
+
+# ─── Config ────────────────────────────────────────────────────────────────────
+GITHUB_TOKEN   = os.getenv("GITHUB_TOKEN", "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")
+GITHUB_REPO    = os.getenv("GITHUB_REPO",  "expher510/AutoClip-Pipeline")
+WORKFLOW_FILE  = os.getenv("WORKFLOW_FILE", "video-download.yml")
+
+# Public URL of THIS api (so n8n can call back)
+# e.g. https://my-api.hf.space  or  https://xxxxx.ngrok.io
+PUBLIC_URL     = os.getenv("PUBLIC_URL", "https://your-api-public-url.com")
+
+N8N_TRIGGER_URL = os.getenv(
+    "N8N_TRIGGER_URL",
+    "https://egauto-n8n.hf.space/webhook/run%20gethup%20action"
+)
+
+VIDEOS_DIR = Path("videos")
+VIDEOS_DIR.mkdir(exist_ok=True)
+
+# ─── In-memory job store ────────────────────────────────────────────────────────
+# job_id → {status, filename, file_path, video_url, error, created_at, run_id}
+jobs: dict[str, dict] = {}
+
+# ─── App ───────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Video Download Middleware",
+    description="Bridges client ↔ n8n/GitHub Action video pipeline",
+    version="1.0.0",
+)
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+log = logging.getLogger(__name__)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 1. REQUEST DOWNLOAD
+# ══════════════════════════════════════════════════════════════════════════════
+class DownloadRequest(BaseModel):
+    url: str
+    cookies_txt: Optional[str] = ""   # optional – paste Netscape cookie text
+
+
+@app.post("/download", summary="Start a video download job")
+async def start_download(body: DownloadRequest):
+    """
+    Triggers the n8n → GitHub Action pipeline.
+    Returns a job_id you can poll with GET /status/{job_id}.
+    """
+    job_id = str(uuid.uuid4())
+
+    jobs[job_id] = {
+        "status":     "pending",
+        "video_url":  body.url,
+        "filename":   None,
+        "file_path":  None,
+        "run_id":     None,
+        "error":      None,
+        "created_at": time.time(),
+    }
+
+    # Build the payload n8n expects (mirrors the "run action" webhook pinData)
+    payload = {
+        "url":         body.url,
+        "cookies_txt": body.cookies_txt or "",
+        # Tell n8n where to POST the finished file
+        "n8n_webhook": f"{PUBLIC_URL}/n8n/callback/{job_id}",
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=15) as client:
+            r = await client.post(N8N_TRIGGER_URL, json=payload)
+            r.raise_for_status()
+        jobs[job_id]["status"] = "processing"
+        log.info(f"[{job_id}] job triggered → n8n responded {r.status_code}")
+    except Exception as exc:
+        jobs[job_id]["status"] = "failed"
+        jobs[job_id]["error"]  = str(exc)
+        log.error(f"[{job_id}] failed to trigger n8n: {exc}")
+        raise HTTPException(status_code=502, detail=f"Could not trigger pipeline: {exc}")
+
+    return {"job_id": job_id, "status": "processing"}
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2. POLL STATUS
+# ══════════════════════════════════════════════════════════════════════════════
+@app.get("/status/{job_id}", summary="Poll download status")
+async def get_status(job_id: str):
+    """
+    Returns one of: pending | processing | done | failed
+    When done, also returns filename & download_url.
+    """
+    job = jobs.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    resp = {
+        "job_id":    job_id,
+        "status":    job["status"],
+        "video_url": job["video_url"],
+        "created_at": job["created_at"],
+    }
+
+    if job["status"] == "done":
+        resp["filename"]     = job["filename"]
+        resp["download_url"] = f"{PUBLIC_URL}/file/{job_id}"
+
+    if job["status"] == "failed":
+        resp["error"] = job["error"]
+
+    return resp
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 3. DOWNLOAD FILE
+# ══════════════════════════════════════════════════════════════════════════════
+@app.get("/file/{job_id}", summary="Download the finished video")
+async def download_file(job_id: str):
+    job = jobs.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job["status"] != "done":
+        raise HTTPException(status_code=425, detail=f"Not ready yet – status: {job['status']}")
+
+    file_path: Path = job["file_path"]
+    if not file_path or not file_path.exists():
+        raise HTTPException(status_code=410, detail="File no longer available on server")
+
+    filename = job["filename"] or file_path.name
+
+    async def file_streamer():
+        async with aiofiles.open(file_path, "rb") as f:
+            while chunk := await f.read(1024 * 512):   # 512 KB chunks
+                yield chunk
+
+    return StreamingResponse(
+        file_streamer(),
+        media_type="video/mp4",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 4. n8n CALLBACK  (n8n POSTs the finished binary here)
+#    This replaces the "downlode video1" webhook that was in n8n
+# ══════════════════════════════════════════════════════════════════════════════
+@app.post("/n8n/callback/{job_id}", summary="[Internal] n8n posts the video here")
+async def n8n_callback(job_id: str, request: Request):
+    """
+    n8n calls this endpoint (instead of its own 'downlode video1' webhook).
+    It sends either:
+      a) A JSON body with {status, run_id, filename, video_url}  → we then
+         fetch the artifact from GitHub ourselves, OR
+      b) Raw binary (the video file) directly in the body.
+    """
+    job = jobs.get(job_id)
+    if not job:
+        log.warning(f"[{job_id}] callback for unknown job")
+        return {"ok": False, "reason": "unknown job"}
+
+    content_type = request.headers.get("content-type", "")
+
+    # ── Case A: JSON notification (status + run_id) ──────────────────────────
+    if "application/json" in content_type:
+        data = await request.json()
+        log.info(f"[{job_id}] JSON callback: {data}")
+
+        if data.get("status") == "success":
+            run_id   = data.get("run_id")
+            filename = data.get("filename", f"{job_id}.mp4")
+            jobs[job_id]["run_id"]   = run_id
+            jobs[job_id]["filename"] = filename
+
+            # Fetch the artifact binary from GitHub in the background
+            asyncio.create_task(_fetch_github_artifact(job_id, run_id, filename))
+        else:
+            jobs[job_id]["status"] = "failed"
+            jobs[job_id]["error"]  = data.get("error", "n8n reported failure")
+
+        return {"ok": True}
+
+    # ── Case B: Raw binary video ──────────────────────────────────────────────
+    body = await request.body()
+    if not body:
+        jobs[job_id]["status"] = "failed"
+        jobs[job_id]["error"]  = "empty callback body"
+        return {"ok": False}
+
+    filename  = request.headers.get("x-filename", f"{job_id}.mp4")
+    file_path = VIDEOS_DIR / f"{job_id}_{filename}"
+
+    async with aiofiles.open(file_path, "wb") as f:
+        await f.write(body)
+
+    jobs[job_id]["status"]    = "done"
+    jobs[job_id]["filename"]  = filename
+    jobs[job_id]["file_path"] = file_path
+    log.info(f"[{job_id}] saved {file_path} ({len(body)/1024/1024:.1f} MB)")
+
+    return {"ok": True}
+
+
+# ══════════════════════════════���═══════════════════════════════════════════════
+# 5. BACKGROUND: fetch artifact from GitHub (used in Case A above)
+# ══════════════════════════════════════════════════════════════════════════════
+async def _fetch_github_artifact(job_id: str, run_id: str, filename: str):
+    """Polls GitHub until the artifact is ready, then downloads it."""
+    artifacts_url = f"https://api.github.com/repos/{GITHUB_REPO}/actions/runs/{run_id}/artifacts"
+    headers = {
+        "Authorization": f"token {GITHUB_TOKEN}",
+        "Accept": "application/vnd.github+json",
+    }
+
+    for attempt in range(20):          # up to ~5 minutes
+        await asyncio.sleep(15)
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                r = await client.get(artifacts_url, headers=headers)
+                r.raise_for_status()
+                artifacts = r.json().get("artifacts", [])
+
+            if not artifacts:
+                log.info(f"[{job_id}] no artifacts yet (attempt {attempt+1})")
+                continue
+
+            artifact = artifacts[0]
+            dl_url   = artifact["archive_download_url"]
+
+            # Download the zip (GitHub wraps artifacts in a zip)
+            async with httpx.AsyncClient(
+                timeout=300,
+                follow_redirects=True,
+                headers=headers,
+            ) as client:
+                resp = await client.get(dl_url)
+                resp.raise_for_status()
+
+            # Save & unzip
+            zip_path  = VIDEOS_DIR / f"{job_id}.zip"
+            async with aiofiles.open(zip_path, "wb") as f:
+                await f.write(resp.content)
+
+            # Extract the video
+            import zipfile
+            with zipfile.ZipFile(zip_path, "r") as z:
+                names = z.namelist()
+                video_name = next((n for n in names if n.endswith(".mp4")), names[0])
+                z.extract(video_name, VIDEOS_DIR)
+                extracted = VIDEOS_DIR / video_name
+
+            zip_path.unlink(missing_ok=True)
+
+            jobs[job_id]["status"]    = "done"
+            jobs[job_id]["filename"]  = video_name
+            jobs[job_id]["file_path"] = extracted
+            log.info(f"[{job_id}] artifact saved → {extracted}")
+            return
+
+        except Exception as exc:
+            log.error(f"[{job_id}] artifact fetch error: {exc}")
+
+    jobs[job_id]["status"] = "failed"
+    jobs[job_id]["error"]  = "artifact never became available"
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 6. EXTRA UTILS
+# ══════════════════════════════════════════════════════════════════════════════
+@app.get("/jobs", summary="List all jobs (debug)")
+async def list_jobs():
+    return {
+        jid: {k: v for k, v in j.items() if k != "file_path"}
+        for jid, j in jobs.items()
+    }
+
+
+@app.delete("/job/{job_id}", summary="Delete a finished job and its file")
+async def delete_job(job_id: str):
+    job = jobs.pop(job_id, None)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job.get("file_path") and Path(job["file_path"]).exists():
+        Path(job["file_path"]).unlink()
+    return {"deleted": job_id}
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "jobs": len(jobs)}

requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.110.0
+uvicorn[standard]>=0.29.0
+httpx>=0.27.0
+aiofiles>=23.2.1
+python-multipart>=0.0.9