CI: deploy Docker/PDM Space

services/app_service/pages/signal_watch.py

@@ -1,3 +1,4 @@
+import hashlib
 import re
 import shutil
 import subprocess
@@ -88,6 +89,42 @@ with st.sidebar:
     # Render device information
     model_manager.render_device_info()
 
+    st.sidebar.markdown("---")
+    st.sidebar.header("YouTube cookies (optional)")
+    cookies_file = st.file_uploader(
+        "Upload YouTube cookies.txt (optional)",
+        type=["txt"],
+        key="yt_cookies_upload",
+        help=(
+            "**Required if YouTube blocks video access:**\n\n"
+            "1. Install browser extension: 'Get cookies.txt' or 'cookies.txt'\n"
+            "2. Go to YouTube.com and log in\n"
+            "3. Export cookies to cookies.txt file\n"
+            "4. Upload the file here\n\n"
+            "**Alternative:** Make sure you're logged into YouTube in Chrome/Firefox/Safari/Edge\n\n"
+            "⚠️ Keep cookies private; they contain your login session"
+        ),
+    )
+
+if cookies_file is not None:
+    try:
+        cookie_bytes = cookies_file.getvalue()
+        if cookie_bytes:
+            cookie_hash = hashlib.sha256(cookie_bytes).hexdigest()[:16]
+            cookie_path_obj = (
+                Path(tempfile.gettempdir()) / f"yt_cookies_{cookie_hash}.txt"
+            )
+            cookie_path_obj.write_bytes(cookie_bytes)
+            cookies_path = str(cookie_path_obj)
+        else:
+            cookies_path = None
+            st.warning("Uploaded cookies file is empty; ignoring it.")
+    except Exception as exc:
+        cookies_path = None
+        st.error(f"Failed to cache uploaded cookies: {exc!s}")
+else:
+    cookies_path = None
+
 
 def find_ytdlp_executable() -> str | None:
     """Find the yt-dlp executable, checking multiple possible locations."""
@@ -169,7 +206,7 @@ def is_live_youtube_stream(url: str) -> bool:
     return False
 
 
-def extract_youtube_stream_url(url: str) -> str | None:
+def extract_youtube_stream_url(url: str, cookies_path: str | None = None) -> str | None:
     """Extract the actual stream URL from a YouTube URL using yt-dlp."""
     # Find yt-dlp executable
     ytdlp_path = find_ytdlp_executable()
@@ -186,9 +223,77 @@ def extract_youtube_stream_url(url: str) -> str | None:
     try:
         # Show progress message
         with st.spinner("Extracting YouTube stream URL..."):
-            # Try multiple format options
+            # Try multiple format options with different cookie strategies
             format_options = ["best[height<=720]", "best[height<=480]", "best", "worst"]
 
+            # First try with cookies if provided
+            if cookies_path and Path(cookies_path).exists():
+                st.info("Using provided cookies for YouTube authentication...")
+                for fmt in format_options:
+                    cmd = [
+                        ytdlp_path,
+                        "--get-url",
+                        "--format",
+                        fmt,
+                        "--no-playlist",
+                        "--no-warnings",
+                        "--cookies",
+                        cookies_path,
+                        url,
+                    ]
+
+                    result = subprocess.run(
+                        cmd, check=False, capture_output=True, text=True, timeout=30
+                    )
+
+                    if result.returncode == 0:
+                        stream_url = result.stdout.strip()
+                        if stream_url and stream_url.startswith("http"):
+                            st.success(
+                                f"Successfully extracted YouTube stream URL! (format: {fmt})"
+                            )
+                            return stream_url
+                    else:
+                        st.warning(f"yt-dlp failed with format {fmt}: {result.stderr}")
+
+            # Try with browser cookies (Chrome, Firefox, Safari)
+            st.info("Trying to use browser cookies for YouTube authentication...")
+            browsers = ["chrome", "firefox", "safari", "edge"]
+
+            for browser in browsers:
+                for fmt in format_options:
+                    cmd = [
+                        ytdlp_path,
+                        "--get-url",
+                        "--format",
+                        fmt,
+                        "--no-playlist",
+                        "--no-warnings",
+                        "--cookies-from-browser",
+                        browser,
+                        url,
+                    ]
+
+                    result = subprocess.run(
+                        cmd, check=False, capture_output=True, text=True, timeout=30
+                    )
+
+                    if result.returncode == 0:
+                        stream_url = result.stdout.strip()
+                        if stream_url and stream_url.startswith("http"):
+                            st.success(
+                                f"Successfully extracted YouTube stream URL using {browser} cookies! (format: {fmt})"
+                            )
+                            return stream_url
+                    else:
+                        # Only show warning for the first browser attempt
+                        if fmt == format_options[0]:
+                            st.warning(
+                                f"Failed to use {browser} cookies: {result.stderr[:100]}..."
+                            )
+
+            # Try without cookies (might work for some videos)
+            st.info("Trying without authentication cookies...")
             for fmt in format_options:
                 cmd = [
                     ytdlp_path,
@@ -208,32 +313,12 @@ def extract_youtube_stream_url(url: str) -> str | None:
                     stream_url = result.stdout.strip()
                     if stream_url and stream_url.startswith("http"):
                         st.success(
-                            f"Successfully extracted YouTube stream URL! (format: {fmt})"
+                            f"Successfully extracted YouTube stream URL without cookies! (format: {fmt})"
                         )
                         return stream_url
-                    else:
-                        st.warning(
-                            f"Invalid stream URL extracted with format {fmt}: {stream_url}"
-                        )
                 else:
                     st.warning(f"yt-dlp failed with format {fmt}: {result.stderr}")
 
-            # If all formats failed, try a different approach
-            st.warning("Trying alternative extraction method...")
-            cmd = [ytdlp_path, "--get-url", "--format", "best", "--no-playlist", url]
-
-            result = subprocess.run(
-                cmd, check=False, capture_output=True, text=True, timeout=30
-            )
-
-            if result.returncode == 0:
-                stream_url = result.stdout.strip()
-                if stream_url and stream_url.startswith("http"):
-                    st.success(
-                        "Successfully extracted YouTube stream URL with fallback method!"
-                    )
-                    return stream_url
-
     except subprocess.TimeoutExpired:
         st.error(
             "Timeout while extracting YouTube stream URL. The video might be unavailable."
@@ -243,6 +328,25 @@ def extract_youtube_stream_url(url: str) -> str | None:
     except Exception as e:
         st.error(f"Error extracting YouTube stream URL: {e!s}")
 
+    # Show helpful error message with instructions
+    st.error("""
+    **YouTube Authentication Required**
+    
+    YouTube is blocking the video download. To fix this, you need to provide authentication cookies:
+    
+    **Option 1: Export cookies from your browser**
+    1. Install a browser extension like "Get cookies.txt" or "cookies.txt"
+    2. Go to YouTube.com and make sure you're logged in
+    3. Export cookies to a file (usually cookies.txt)
+    4. Upload the cookies file using the file uploader below
+    
+    **Option 2: Use browser cookies directly**
+    Make sure you're logged into YouTube in Chrome, Firefox, Safari, or Edge
+    
+    **Option 3: Try a different video**
+    Some YouTube videos are restricted and cannot be accessed programmatically
+    """)
+
     return None
 
 
@@ -259,7 +363,7 @@ if "stop_processing" not in st.session_state:
     st.session_state.stop_processing = False
 
 
-def resolve_video_source(src_choice: str):
+def resolve_video_source(src_choice: str, cookies_path: str | None = None):
     """Resolve the video source, extracting YouTube stream URLs if needed."""
     if src_choice == "Webcam":
         return 0
@@ -267,7 +371,7 @@ def resolve_video_source(src_choice: str):
     if src_choice in youtube_urls:
         youtube_url = youtube_urls[src_choice]
         # Extract the actual stream URL using yt-dlp
-        stream_url = extract_youtube_stream_url(youtube_url)
+        stream_url = extract_youtube_stream_url(youtube_url, cookies_path)
         if stream_url:
             return stream_url
         else:
@@ -441,7 +545,7 @@ def run_video_feed_detection(
 
 
 if run_detection:
-    src = resolve_video_source(src_choice)
+    src = resolve_video_source(src_choice, cookies_path)
     if not src:
         st.warning("Please select a valid source (pick a file or enter a URL).")
     else: