Update bot/youtube/resume.py

bot/youtube/resume.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import asyncio
 import os
 import re
-from typing import Awaitable, Callable, Optional, Tuple
+from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
 
 import httpx
 
@@ -15,7 +15,7 @@ ProgressCB = Callable[[int, int], Awaitable[None]]
 YOUTUBE_RESUMABLE_INIT = "https://www.googleapis.com/upload/youtube/v3/videos"
 
 
-def _parse_range_last_byte(headers: dict) -> Optional[int]:
+def _parse_range_last_byte(headers: dict) -> int | None:
     """
     Range header examples:
       - "bytes=0-1048575"
@@ -34,10 +34,8 @@ async def start_resumable_session(
     access_token: str,
     metadata: dict,
     total_bytes: int = 0,
-) -> dict:
+) -> Dict[str, Any]:
     """
-    Starts a YouTube resumable upload session.
-
     Returns:
       {"ok": True, "session_url": "..."}
       {"ok": False, "err": "...", "detail": "..."}
@@ -50,29 +48,27 @@ async def start_resumable_session(
         "Content-Type": "application/json; charset=UTF-8",
         "X-Upload-Content-Type": "video/*",
     }
-    # Helps YouTube know size (recommended)
-    if isinstance(total_bytes, int) and total_bytes > 0:
-        headers["X-Upload-Content-Length"] = str(total_bytes)
+    # Optional but helpful
+    if total_bytes and total_bytes > 0:
+        headers["X-Upload-Content-Length"] = str(int(total_bytes))
 
     params = {"uploadType": "resumable", "part": "snippet,status"}
 
-    timeout = httpx.Timeout(connect=30.0, read=60.0, write=60.0, pool=30.0)
-
     try:
-        async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as c:
+        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:
                 return {
                     "ok": False,
-                    "err": f"resumable_init_failed:{r.status_code}",
-                    "detail": (r.text or "")[:600],
+                    "err": "resumable_init_failed",
+                    "detail": f"{r.status_code}:{(r.text or '')[:400]}",
                 }
             upload_url = r.headers.get("Location") or r.headers.get("location")
             if not upload_url:
-                return {"ok": False, "err": "resumable_init_no_location", "detail": "Missing Location header"}
-            return {"ok": True, "session_url": upload_url}
+                return {"ok": False, "err": "resumable_init_no_location"}
+            return {"ok": True, "session_url": str(upload_url)}
     except Exception as e:
-        return {"ok": False, "err": f"resumable_init_exception:{type(e).__name__}", "detail": str(e)[:600]}
+        return {"ok": False, "err": "resumable_init_exception", "detail": f"{type(e).__name__}:{e}"}
 
 
 async def _query_upload_status(
@@ -80,7 +76,7 @@ async def _query_upload_status(
     upload_url: str,
     headers_base: dict,
     total: int,
-) -> Tuple[int, Optional[dict]]:
+) -> tuple[int, dict | None]:
     """
     Asks server what it has already received.
     Returns (last_received_byte, final_json_if_completed)
@@ -102,7 +98,7 @@ async def _query_upload_status(
         return total - 1, j
 
     if r.status_code >= 400:
-        raise RuntimeError(f"resumable_status_failed:{r.status_code}:{(r.text or '')[:200]}")
+        raise RuntimeError(f"resumable_status_failed:{r.status_code}:{r.text[:200]}")
 
     return -1, None
 
@@ -113,8 +109,8 @@ async def upload_resumable(
     file_path: str,
     access_token: str,
     total_bytes: int = 0,
-    progress_cb: Optional[ProgressCB] = None,
-) -> dict:
+    progress_cb: ProgressCB | None = None,
+) -> Dict[str, Any]:
     """
     Upload file in chunks to session_url.
 
@@ -122,10 +118,10 @@ async def upload_resumable(
       {"ok": True, "response": {...}}
       {"ok": False, "err": "...", "detail": "..."}
     """
-    if not session_url:
-        return {"ok": False, "err": "missing_session_url"}
     if not access_token:
         return {"ok": False, "err": "missing_access_token"}
+    if not session_url:
+        return {"ok": False, "err": "missing_session_url"}
     if not file_path or not os.path.exists(file_path):
         return {"ok": False, "err": "file_not_found"}
 
@@ -172,7 +168,7 @@ async def upload_resumable(
                         try:
                             r = await c.put(session_url, headers=headers, content=chunk)
                         except (httpx.TimeoutException, httpx.NetworkError):
-                            # Ask server status, then resume
+                            # Network issue: ask server what it has, then resume
                             last, done_json = await _query_upload_status(c, session_url, headers_base, total)
                             if done_json is not None:
                                 if progress_cb:
@@ -181,8 +177,9 @@ async def upload_resumable(
                             sent = max(sent, last + 1)
                             if progress_cb:
                                 await progress_cb(sent, total)
-                            break  # next outer loop
+                            break  # next outer loop iteration
 
+                        # 308 means "resume incomplete" - read Range
                         if r.status_code == 308:
                             last = _parse_range_last_byte(r.headers)
                             if last is None:
@@ -191,17 +188,19 @@ async def upload_resumable(
                                     if progress_cb:
                                         await progress_cb(total, total)
                                     return {"ok": True, "response": done_json}
-                            sent = max(sent, (last or -1) + 1)
+                            sent = max(sent, last + 1)
                             if progress_cb:
                                 await progress_cb(sent, total)
                             break
 
+                        # Success
                         if r.status_code in (200, 201):
                             j = r.json() if r.text else {}
                             if progress_cb:
                                 await progress_cb(total, total)
                             return {"ok": True, "response": j}
 
+                        # Retryable
                         if r.status_code in retryable and attempt < max_retries:
                             attempt += 1
                             last, done_json = await _query_upload_status(c, session_url, headers_base, total)
@@ -215,33 +214,27 @@ async def upload_resumable(
                             await asyncio.sleep(min(2 ** attempt, 20))
                             break
 
+                        # Non-retryable error
                         if r.status_code >= 400:
                             return {
                                 "ok": False,
-                                "err": f"resumable_put_failed:{r.status_code}",
-                                "detail": (r.text or "")[:600],
+                                "err": "resumable_put_failed",
+                                "detail": f"{r.status_code}:{(r.text or '')[:400]}",
                             }
 
                         return {
                             "ok": False,
-                            "err": f"resumable_put_unexpected:{r.status_code}",
-                            "detail": (r.text or "")[:600],
+                            "err": "resumable_put_unexpected",
+                            "detail": f"{r.status_code}:{(r.text or '')[:200]}",
                         }
 
-            # Final status check
-            last, done_json = await _query_upload_status(c, session_url, headers_base, total)
-            if done_json is not None:
-                if progress_cb:
-                    await progress_cb(total, total)
-                return {"ok": True, "response": done_json}
-
-            if last >= total - 1:
-                last2, done_json2 = await _query_upload_status(c, session_url, headers_base, total)
-                if done_json2 is not None:
+                # final status check
+                last, done_json = await _query_upload_status(c, session_url, headers_base, total)
+                if done_json is not None:
                     if progress_cb:
                         await progress_cb(total, total)
-                    return {"ok": True, "response": done_json2}
+                    return {"ok": True, "response": done_json}
 
         return {"ok": False, "err": "resumable_upload_incomplete"}
     except Exception as e:
-        return {"ok": False, "err": f"resumable_exception:{type(e).__name__}", "detail": str(e)[:600]}
+        return {"ok": False, "err": "resumable_exception", "detail": f"{type(e).__name__}:{e}"}