Update bot/youtube/resume.py

bot/youtube/resume.py

@@ -1,101 +1,83 @@
 # PATH: bot/youtube/resume.py
-import asyncio
 import os
-from typing import Callable, Awaitable, Optional
+from typing import Callable, Awaitable
 import httpx
-
-from bot.core.settings import YOUTUBE_CHUNK_SIZE, HTTP_TIMEOUT_SEC
+from bot.core.settings import YOUTUBE_CHUNK_SIZE
 
 ProgressCB = Callable[[int, int], Awaitable[None]]
 
-YOUTUBE_RESUMABLE_ENDPOINT = (
-    "https://www.googleapis.com/upload/youtube/v3/videos"
-    "?uploadType=resumable&part=snippet,status"
-)
+YOUTUBE_RESUMABLE_INIT = "https://www.googleapis.com/upload/youtube/v3/videos"
+
 
-async def start_resumable_session(access_token: str, metadata: dict, mime_type: str = "video/mp4") -> str:
+async def start_resumable_session(access_token: str, metadata: dict) -> str:
+    """
+    Returns upload_url (Location header)
+    """
     headers = {
         "Authorization": f"Bearer {access_token}",
         "Content-Type": "application/json; charset=UTF-8",
-        "X-Upload-Content-Type": mime_type,
+        "X-Upload-Content-Type": "video/*",
     }
+    params = {"uploadType": "resumable", "part": "snippet,status"}
 
-    async with httpx.AsyncClient(timeout=HTTP_TIMEOUT_SEC, follow_redirects=True) as client:
-        r = await client.post(YOUTUBE_RESUMABLE_ENDPOINT, headers=headers, json=metadata)
-        if r.status_code not in (200, 201):
-            raise RuntimeError(f"initiate_failed status={r.status_code} body={r.text[:300]}")
-        upload_url = r.headers.get("Location")
+    async with httpx.AsyncClient(timeout=60, follow_redirects=True) as c:
+        r = await c.post(YOUTUBE_RESUMABLE_INIT, params=params, headers=headers, json=metadata)
+        if r.status_code >= 400:
+            raise RuntimeError(f"resumable_init_failed:{r.status_code}:{r.text[:200]}")
+        upload_url = r.headers.get("Location") or r.headers.get("location")
         if not upload_url:
-            raise RuntimeError("initiate_failed: missing Location header")
+            raise RuntimeError("resumable_init_no_location")
         return upload_url
 
-async def _query_offset(client: httpx.AsyncClient, upload_url: str, total: int) -> int:
-    r = await client.put(
-        upload_url,
-        headers={"Content-Range": f"bytes */{total}", "Content-Length": "0"},
-        content=b"",
-    )
-    if r.status_code == 308:
-        rng = r.headers.get("Range")
-        if rng and "-" in rng:
-            return int(rng.split("-")[1]) + 1
-        return 0
-    if r.status_code in (200, 201):
-        return total
-    return 0
-
-async def upload_resumable(upload_url: str, file_path: str, progress_cb: Optional[ProgressCB] = None) -> dict:
+
+async def upload_resumable(
+    upload_url: str,
+    file_path: str,
+    access_token: str,
+    *,
+    progress_cb: ProgressCB | None = None,   # ✅ keyword-only (prevents “multiple values”)
+) -> dict:
+    """
+    Upload file in chunks to upload_url.
+    Returns YouTube API JSON (contains id).
+    """
     total = os.path.getsize(file_path)
-    timeout = httpx.Timeout(HTTP_TIMEOUT_SEC, connect=HTTP_TIMEOUT_SEC)
+    sent = 0
 
-    async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
-        offset = 0
-        retries = 0
+    headers_base = {
+        "Authorization": f"Bearer {access_token}",
+    }
 
+    async with httpx.AsyncClient(timeout=120, follow_redirects=True) as c:
         with open(file_path, "rb") as f:
-            while offset < total:
-                f.seek(offset)
+            while sent < total:
                 chunk = f.read(YOUTUBE_CHUNK_SIZE)
                 if not chunk:
                     break
-                end = offset + len(chunk) - 1
-
-                try:
-                    r = await client.put(
-                        upload_url,
-                        headers={
-                            "Content-Length": str(len(chunk)),
-                            "Content-Range": f"bytes {offset}-{end}/{total}",
-                        },
-                        content=chunk,
-                    )
-                except Exception:
-                    retries += 1
-                    if retries > 5:
-                        raise
-                    await asyncio.sleep(min(5 * retries, 20))
-                    offset = await _query_offset(client, upload_url, total)
-                    continue
 
-                if r.status_code in (200, 201):
-                    if progress_cb:
-                        await progress_cb(total, total)
-                    return r.json()
+                start = sent
+                end = sent + len(chunk) - 1
+
+                headers = dict(headers_base)
+                headers["Content-Length"] = str(len(chunk))
+                headers["Content-Type"] = "video/*"
+                headers["Content-Range"] = f"bytes {start}-{end}/{total}"
 
+                r = await c.put(upload_url, headers=headers, content=chunk)
+
+                # 308 Resume Incomplete is normal for chunked upload
                 if r.status_code == 308:
-                    retries = 0
-                    rng = r.headers.get("Range")
-                    offset = (int(rng.split("-")[1]) + 1) if (rng and "-" in rng) else (end + 1)
+                    sent = end + 1
                     if progress_cb:
-                        await progress_cb(offset, total)
+                        await progress_cb(sent, total)
                     continue
 
-                if r.status_code in (500, 502, 503, 504):
-                    retries += 1
-                    await asyncio.sleep(min(5 * retries, 20))
-                    offset = await _query_offset(client, upload_url, total)
-                    continue
+                if r.status_code >= 400:
+                    raise RuntimeError(f"resumable_put_failed:{r.status_code}:{r.text[:200]}")
 
-                raise RuntimeError(f"upload_failed status={r.status_code} body={r.text[:300]}")
+                j = r.json()
+                if progress_cb:
+                    await progress_cb(total, total)
+                return j
 
     raise RuntimeError("resumable_upload_incomplete")