Update app.py

app.py

@@ -46,7 +46,7 @@ async def cleanup_file(filepath: Path):
     except Exception as e:
         logging.error(f"Error during cleanup of {filepath.parent}: {e}")
 
-def get_best_formats_with_fallback(data: dict, requested_quality: int):
+"""def get_best_formats_with_fallback(data: dict, requested_quality: int):
     """
     Parses the Info API response to find the best matching video format
     with a robust fallback, and the best audio format.
@@ -112,40 +112,55 @@ def get_best_formats_with_fallback(data: dict, requested_quality: int):
         raise ValueError("Could not find a suitable video and/or audio stream.")
 
     return video_url, audio_url
+"""
 
 
-
-def run_ytdlp_download(url: str, out_path: Path):
+def download_and_merge_with_ytdlp(
+    video_url: str,
+    quality: int,
+    output_path: Path
+):
     """
-    Runs a single yt-dlp download, using 'aria2c' for direct files
-    and the default (or ffmpeg) downloader for HLS/m3u8 streams.
+    Tells yt-dlp to download and merge the best formats automatically.
+    
+    This is the robust, correct way to do this.
     """
+    # This format string tells yt-dlp:
+    # 1. Find the best video with a height <= [quality] (e.g., 1080)
+    # 2. ...that ALSO has video ("vcodec!=none")
+    # 3. Find the best audio ("ba")
+    # 4. If that fails (e.g., no separate streams), fall back to the
+    #    best "muxed" stream (video+audio, "v+a")
+    # 5. ...with a height <= [quality]
+    # 6. As a final fallback, just get the best-ever stream <= [quality]
+    format_selector = (
+        f"bestvideo[height<={quality}][vcodec!=none]+bestaudio[acodec!=none]/best[v+a][height<={quality}]/best[height<={quality}]"
+    )
+
+    logging.info(f"Using yt-dlp format selector: {format_selector}")
+
     ydl_opts = {
-        'outtmpl': str(out_path),
+        'format': format_selector,
+        'outtmpl': str(output_path),
         'quiet': True,
         'noprogress': True,
-    }
-
-    # Check if the URL is an HLS playlist.
-    # If it's NOT, we assume it's a direct file and can use the aria2c optimization.
-    if ".m3u8" not in url.lower():
-        logging.info(f"Using aria2c for direct file download: {out_path.name}")
-        # --- SPEED OPTIMIZATION (FOR DIRECT FILES) ---
-        ydl_opts['external_downloader'] = 'aria2c'
-        ydl_opts['external_downloader_args'] = [
+        # 'merge_output_format': 'mp4', # yt-dlp is smart enough to use mp4 from outtmpl
+        
+        # --- SPEED OPTIMIZATION (FOR MUXED/HLS) ---
+        # We can keep aria2c! yt-dlp will ONLY use it if it finds a
+        # direct URL. If it finds an m3u8, it will ignore it and
+        # use its HLS downloader. This is safe.
+        'external_downloader': 'aria2c',
+        'external_downloader_args': [
             '--min-split-size=1M',
             '--max-connection-per-server=16',
             '--max-concurrent-downloads=16',
             '--split=16'
-        ]
-    else:
-        logging.info(f"Using default HLS downloader for m3u8 stream: {out_path.name}")
-        # For M3U8 streams, yt-dlp will use its internal HLS downloader
-        # or FFmpeg. Since FFmpeg is already required for your merge step,
-        # this will work perfectly.
-
+        ],
+    }
+    
     with YoutubeDL(ydl_opts) as ydl:
-        ydl.download([url])
+        ydl.download([video_url])
 
 async def process_in_background(
     task_id: str,
@@ -156,37 +171,34 @@ async def process_in_background(
 ):
     """
     This is the main worker function that runs in the background.
+    
+    --- SIMPLIFIED LOGIC ---
+    1. Tell yt-dlp to download, merge, and save the file.
+    2. Set status to complete.
+    3. Clean up.
     """
-    task_statuses[task_id] = {"status": "processing", "message": "Fetching video info..."}
+    task_statuses[task_id] = {"status": "processing", "message": "Processing video..."}
+    
     try:
-        # Step 1: Get video info
-        async with httpx.AsyncClient(follow_redirects=True) as client:
-            info_api_url = f"{BASE_URL.rstrip('/')}/api/info"
-            response = await client.get(info_api_url, params={"url": video_url, "playlist": "false"}, timeout=30.0)
-            response.raise_for_status()
-            video_data = response.json()
-            video_stream_url, audio_stream_url = get_best_formats_with_fallback(video_data, quality)
-
-        # Step 2: Download files
-        task_statuses[task_id]["message"] = "Downloading video and audio streams..."
+        # Step 1: Define output path
         final_output_dir = STATIC_DIR / task_id
         final_output_dir.mkdir()
-        video_path = TEMP_DIR / f"{task_id}_video.mp4"
-        audio_path = TEMP_DIR / f"{task_id}_audio.m4a"
-
-        video_dl_task = asyncio.to_thread(run_ytdlp_download, video_stream_url, video_path)
-        audio_dl_task = asyncio.to_thread(run_ytdlp_download, audio_stream_url, audio_path)
-        await asyncio.gather(video_dl_task, audio_dl_task)
-
-        # Step 3: Merge files
-        task_statuses[task_id]["message"] = "Merging files with FFmpeg..."
         final_output_path = final_output_dir / "video.mp4"
-        subprocess.run(
-            ['ffmpeg', '-i', str(video_path), '-i', str(audio_path), '-c', 'copy', str(final_output_path)],
-            check=True, capture_output=True, text=True
+
+        # Step 2: Run the complete download and merge in one go.
+        # This one function call replaces your info-fetch, two downloads,
+        # and ffmpeg merge steps.
+        task_statuses[task_id]["message"] = "Downloading and merging video..."
+        
+        await asyncio.to_thread(
+            download_and_merge_with_ytdlp,
+            video_url,
+            quality,
+            final_output_path
         )
 
-        # Step 4: Finalize and set status to complete
+        # Step 3: Finalize and set status to complete
+        task_statuses[task_id]["message"] = "Processing complete."
         download_url = f"{base_url_for_links.rstrip('/')}/static/{task_id}/video.mp4"
         task_statuses[task_id] = {
             "status": "complete",
@@ -196,11 +208,17 @@ async def process_in_background(
         background_tasks.add_task(cleanup_file, final_output_path)
 
     except Exception as e:
+        # This will now catch errors from yt-dlp directly, e.g., "video unavailable"
         logging.error(f"Task {task_id} failed: {e}")
-        task_statuses[task_id] = {"status": "failed", "error": str(e)}
+        # Add the error output from yt-dlp if available
+        error_message = str(e)
+        if "yt-dlp error" in error_message: # You can customize this
+             error_message = f"yt-dlp failed: {error_message}"
+        task_statuses[task_id] = {"status": "failed", "error": error_message}
     finally:
-        if 'video_path' in locals() and video_path.exists(): video_path.unlink()
-        if 'audio_path' in locals() and audio_path.exists(): audio_path.unlink()
+        # We no longer have temp video/audio files, so cleanup is simpler.
+        # The main cleanup_file task will handle the final directory.
+        pass
 
 
 # --- API Endpoints ---