CI: deploy Docker/PDM Space

pdm.lock

@@ -5,7 +5,7 @@
 groups = ["default", "dev"]
 strategy = []
 lock_version = "4.5.0"
-content_hash = "sha256:1d312cf4f8d0ef95142688d9b41975eea7bae04876d293480ed8b68062da4b05"
+content_hash = "sha256:289ac07ce37c34043f1c46e3239eabc20812a81c95ce882483c35901afab3221"
 
 [[metadata.targets]]
 requires_python = "==3.11.*"
@@ -1554,3 +1554,13 @@ files = [
     {file = "watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f"},
     {file = "watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282"},
 ]
+
+[[package]]
+name = "yt-dlp"
+version = "2025.10.22"
+requires_python = ">=3.10"
+summary = "A feature-rich command-line audio/video downloader"
+files = [
+    {file = "yt_dlp-2025.10.22-py3-none-any.whl", hash = "sha256:9c803a9598859f91d0d5bd3337f1506ecb40bbe97f6efbe93bc4461fed344fb2"},
+    {file = "yt_dlp-2025.10.22.tar.gz", hash = "sha256:db2d48133222b1d9508c6de757859c24b5cefb9568cf68ccad85dac20b07f77b"},
+]

pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "torch>=2.8.0",
     "pandas>=2.3.2",
     "opencv-python>=4.12.0.88",
+    "yt-dlp>=2025.10.22",
 ]
 requires-python = "==3.11.*"
 readme = "README.md"

services/app_service/pages/signal_watch.py

@@ -1,6 +1,11 @@
 import tempfile
 import time
 from pathlib import Path
+import re
+import subprocess
+import json
+import sys
+import shutil
 
 import cv2
 import numpy as np
@@ -57,6 +62,129 @@ MODEL_ENTRIES = _discover_model_entries()
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+
+def find_ytdlp_executable() -> str | None:
+    """Find the yt-dlp executable, checking multiple possible locations."""
+    # First try the system PATH
+    ytdlp_path = shutil.which('yt-dlp')
+    if ytdlp_path:
+        return ytdlp_path
+    
+    # Try common virtual environment locations
+    venv_paths = [
+        Path(sys.executable).parent / "yt-dlp",
+        Path(sys.executable).parent.parent / "bin" / "yt-dlp",
+        Path(__file__).parents[3] / ".venv" / "bin" / "yt-dlp",
+        Path(__file__).parents[3] / ".venv" / "Scripts" / "yt-dlp.exe",  # Windows
+    ]
+    
+    for path in venv_paths:
+        if path.exists() and path.is_file():
+            return str(path)
+    
+    return None
+
+
+def is_youtube_url(url: str) -> bool:
+    """Check if the URL is a YouTube URL."""
+    youtube_patterns = [
+        r'(?:https?://)?(?:www\.)?youtube\.com/watch\?v=',
+        r'(?:https?://)?(?:www\.)?youtu\.be/',
+        r'(?:https?://)?(?:www\.)?youtube\.com/live/',
+        r'(?:https?://)?(?:www\.)?youtube\.com/embed/',
+    ]
+    return any(re.search(pattern, url) for pattern in youtube_patterns)
+
+
+def check_ytdlp_available() -> bool:
+    """Check if yt-dlp is available on the system."""
+    ytdlp_path = find_ytdlp_executable()
+    if not ytdlp_path:
+        return False
+    
+    try:
+        result = subprocess.run([ytdlp_path, '--version'], capture_output=True, text=True, timeout=5)
+        return result.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def extract_youtube_stream_url(url: str) -> str | None:
+    """Extract the actual stream URL from a YouTube URL using yt-dlp."""
+    # Find yt-dlp executable
+    ytdlp_path = find_ytdlp_executable()
+    if not ytdlp_path:
+        st.error("yt-dlp is not installed or not available in PATH.")
+        st.info("Please install yt-dlp: `pip install yt-dlp` or `brew install yt-dlp`")
+        return None
+    
+    # Verify it's working
+    if not check_ytdlp_available():
+        st.error("yt-dlp found but not working properly.")
+        return None
+    
+    try:
+        # Show progress message
+        with st.spinner("Extracting YouTube stream URL..."):
+            # Try multiple format options
+            format_options = [
+                'best[height<=720]',
+                'best[height<=480]',
+                'best',
+                'worst'
+            ]
+            
+            for fmt in format_options:
+                cmd = [
+                    ytdlp_path,
+                    '--get-url',
+                    '--format', fmt,
+                    '--no-playlist',
+                    '--no-warnings',
+                    url
+                ]
+                
+                result = subprocess.run(cmd, 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"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, 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.")
+    except FileNotFoundError:
+        st.error("yt-dlp not found. Please install it: pip install yt-dlp")
+    except Exception as e:
+        st.error(f"Error extracting YouTube stream URL: {str(e)}")
+    
+    return None
+
 
 @st.cache_resource
 def load_model(model_key: str, device: str = DEVICE):
@@ -77,7 +205,6 @@ def load_model(model_key: str, device: str = DEVICE):
         )
     return YOLO(str(weight_path))
 
-
 def draw_yolo_dets(frame_bgr, result, show_score=True):
     out = frame_bgr.copy()
     boxes = getattr(result, "boxes", None)
@@ -119,11 +246,37 @@ if VIDEO_DIR.exists():
         if p.suffix.lower() in {".mp4", ".mov", ".avi", ".mkv"}:
             video_map[p.name] = str(p)
 
-source_options = ["Webcam (0)"] + list(video_map.keys()) + ["Custom URL…"]
+source_options = ["Webcam (0)"] + list(video_map.keys()) + ["YouTube URL", "Custom URL…"]
 src_choice = st.sidebar.selectbox("Source", source_options, index=0)
 
 custom_url = None
-if src_choice == "Custom URL…":
+youtube_url = None
+if src_choice == "YouTube URL":
+    youtube_url = st.sidebar.text_input(
+        "YouTube URL", 
+        placeholder="https://www.youtube.com/watch?v=...",
+        value="https://www.youtube.com/watch?v=57w2gYXjRic"
+    )
+    if st.sidebar.button("Test YouTube URL", help="Test if the YouTube URL can be processed"):
+        if youtube_url and youtube_url.strip():
+            st.info(f"Testing URL: {youtube_url.strip()}")
+            
+            # Debug: Show yt-dlp path
+            ytdlp_path = find_ytdlp_executable()
+            if ytdlp_path:
+                st.info(f"Found yt-dlp at: {ytdlp_path}")
+            else:
+                st.warning("yt-dlp executable not found")
+            
+            stream_url = extract_youtube_stream_url(youtube_url.strip())
+            if stream_url:
+                st.success("✅ YouTube URL is valid and can be processed!")
+                st.info(f"Stream URL: {stream_url[:100]}...")
+            else:
+                st.error("❌ Failed to process YouTube URL")
+        else:
+            st.warning("Please enter a YouTube URL first")
+elif src_choice == "Custom URL…":
     custom_url = st.sidebar.text_input(
         "RTSP/HTTP URL", placeholder="rtsp://... or https://..."
     )
@@ -148,7 +301,14 @@ model_label = st.sidebar.selectbox("Model", available_model_labels, index=0)
 model_key = label_to_key.get(model_label, "deim")
 confidence_threshold = st.sidebar.slider("Minimum Confidence", 0.0, 1.0, 0.5, 0.01)
 frame_stride = st.sidebar.slider("Process every Nth frame", 1, 10, 3, 1)
-max_seconds = st.sidebar.slider("Max seconds (webcam/live)", 3, 60, 12, 1)
+
+# Time limit options for live streams
+unlimited_mode = st.sidebar.checkbox("🔄 Unlimited Live Mode", help="Run detection indefinitely (use with caution)")
+if unlimited_mode:
+    max_seconds = None  # No time limit
+    st.sidebar.info("⚠️ Running in unlimited mode - use stop button to end")
+else:
+    max_seconds = st.sidebar.slider("Max seconds (webcam/live)", 3, 60, 12, 1)
 show_live_preview = st.sidebar.checkbox(
     "Show live preview",
     value=True,
@@ -164,15 +324,37 @@ if show_live_preview:
         40,
         help="Frames are downscaled before streaming to keep payloads small.",
     )
-run_detection = st.sidebar.button("🎥 Run Detection", use_container_width=True)
+
+col1, col2 = st.sidebar.columns(2)
+with col1:
+    run_detection = st.button("🎥 Run Detection", use_container_width=True)
+with col2:
+    stop_detection = st.button("⏹️ Stop", use_container_width=True, help="Stop current detection")
 
 
 # ---------- Main UI logic ----------
 
+# Initialize session state for stop functionality
+if 'stop_processing' not in st.session_state:
+    st.session_state.stop_processing = False
 
 def resolve_source():
     if src_choice == "Webcam (0)":
         return 0
+    if src_choice == "YouTube URL":
+        if youtube_url and youtube_url.strip():
+            st.info(f"Processing YouTube URL: {youtube_url.strip()}")
+            # Extract the actual stream URL from YouTube
+            stream_url = extract_youtube_stream_url(youtube_url.strip())
+            if stream_url:
+                st.info(f"Extracted stream URL: {stream_url[:50]}...")
+                return stream_url
+            else:
+                st.error("Failed to extract YouTube stream URL. Please check the URL and try again.")
+                return None
+        else:
+            st.warning("Please enter a YouTube URL.")
+            return None
     if src_choice == "Custom URL…":
         return custom_url.strip() if custom_url else None
     return video_map.get(src_choice)
@@ -204,12 +386,31 @@ def run_video_feed_detection(
         st.error(str(exc))
         return
 
+    # Handle YouTube URLs specially
+    is_youtube = isinstance(cap_source, str) and is_youtube_url(cap_source)
+    
     cap = cv2.VideoCapture(cap_source)
     if not cap.isOpened():
         st.error("Failed to open the selected source.")
         return
 
-    is_file = isinstance(cap_source, str) and Path(str(cap_source)).exists()
+    # Set buffer size for live streams to reduce latency
+    if is_youtube or isinstance(cap_source, str):
+        cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+
+    # Check if it's a local file (not a URL)
+    is_file = False
+    if isinstance(cap_source, str):
+        # If it looks like a URL (starts with http/https/rtsp), it's not a file
+        if cap_source.startswith(('http://', 'https://', 'rtsp://')):
+            is_file = False
+        else:
+            # Only check if it's a file if it doesn't look like a URL
+            try:
+                is_file = Path(cap_source).exists()
+            except (OSError, ValueError):
+                # Handle cases where the path is too long or invalid
+                is_file = False
     fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
     total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
 
@@ -268,16 +469,23 @@ def run_video_feed_detection(
 
             i += 1
 
-            # Update progress more frequently for better UX
-            if is_file and total:
-                progress = min(i / total, 1.0)
-                prog.progress(progress, text=f"Processing… {i}/{total}")
+        if is_file and total:
+            prog.progress(min(i / total, 1.0), text=f"Processing… {i}/{total}")
+        else:
+            elapsed = time.time() - start_t
+            stream_type = "YouTube" if is_youtube else "Live"
+            
+            if max_seconds is None:
+                # Unlimited mode - show elapsed time without progress limit
+                prog.progress(0.0, text=f"{stream_type}… {int(elapsed)}s (unlimited)")
+                # In unlimited mode, continue indefinitely until manually stopped
             else:
-                elapsed = time.time() - start_t
-                progress = min(elapsed / max(1, max_seconds), 1.0)
-                prog.progress(progress, text=f"Live… {int(elapsed)}s")
+                # Limited mode - show progress and check time limit
+                prog.progress(
+                    min(elapsed / max(1, max_seconds), 1.0), text=f"{stream_type}… {int(elapsed)}s"
+                )
                 if elapsed >= max_seconds:
-                    break
+                    return
 
             # Add small delay to prevent overwhelming the system
             if not is_file:  # Only for live sources
@@ -291,7 +499,8 @@ def run_video_feed_detection(
         if writer is not None:
             writer.release()
 
-    st.success("Done!")
+    stream_type = "YouTube" if is_youtube else ("Live" if not is_file else "File")
+    st.success(f"Done processing {stream_type} stream!")
     if out_path and out_path.exists():
         st.video(str(out_path))
         with open(out_path, "rb") as f:
@@ -317,4 +526,4 @@ if run_detection:
             preview_max_width=preview_width,
         )
 else:
-    st.info("Pick a video source from the sidebar and click **Run Detection**.")
+    st.info("Pick a video source from the sidebar (including YouTube URLs) and click **Run Detection**.")