Update main.py

main.py

@@ -31,13 +31,13 @@ logger = logging.getLogger(__name__)
 # Pydantic models
 class VideoInfoRequest(BaseModel):
     url: HttpUrl
-    use_cookies: bool = False
+    use_cookies: bool = None  # Changed to None to allow auto-detection
     
 class DownloadRequest(BaseModel):
     url: HttpUrl
     quality: str = "best"
     audio_only: bool = False
-    use_cookies: bool = False
+    use_cookies: bool = None  # Changed to None to allow auto-detection
 
 class VideoInfo(BaseModel):
     title: str
@@ -70,7 +70,7 @@ class HealthResponse(BaseModel):
 app = FastAPI(
     title="Cookie-Enhanced YouTube Video Downloader",
     description="Download YouTube videos with proper cookie support and troubleshooting",
-    version="3.0.0",
+    version="3.1.0",
     docs_url="/docs",
     redoc_url="/redoc"
 )
@@ -175,6 +175,10 @@ class CookieManager:
         if validation["valid"]:
             return str(self.cookie_file)
         return None
+    
+    def has_valid_cookies(self) -> bool:
+        """Check if valid cookies are available"""
+        return self.get_cookie_path() is not None
 
 class EnhancedYouTubeDownloader:
     """Enhanced YouTube downloader with cookie support and troubleshooting"""
@@ -217,15 +221,24 @@ class EnhancedYouTubeDownloader:
                 logger.error(f"Failed to install yt-dlp: {e}")
                 raise RuntimeError("Could not install yt-dlp")
     
-    def _build_command(self, base_cmd: List[str], use_cookies: bool = False) -> List[str]:
+    def _should_use_cookies(self, use_cookies: Optional[bool]) -> bool:
+        """Determine whether to use cookies based on request and availability"""
+        if use_cookies is None:
+            # Auto-detect: use cookies if available
+            return self.cookie_manager.has_valid_cookies()
+        return use_cookies and self.cookie_manager.has_valid_cookies()
+    
+    def _build_command(self, base_cmd: List[str], use_cookies: Optional[bool] = None) -> List[str]:
         """Build yt-dlp command with proper options"""
         cmd = base_cmd.copy()
         
         # Add user agent
         cmd.extend(['--user-agent', random.choice(self.user_agents)])
         
-        # Cookie handling
-        if use_cookies:
+        # Cookie handling with improved logic
+        should_use_cookies = self._should_use_cookies(use_cookies)
+        
+        if should_use_cookies:
             cookie_path = self.cookie_manager.get_cookie_path()
             if cookie_path:
                 cmd.extend(['--cookies', cookie_path])
@@ -252,9 +265,9 @@ class EnhancedYouTubeDownloader:
             '--add-header', 'Upgrade-Insecure-Requests:1',
         ])
         
-        return cmd
+        return cmd, should_use_cookies
     
-    def get_video_info(self, url: str, use_cookies: bool = False, retry_count: int = 0) -> Optional[Dict[str, Any]]:
+    def get_video_info(self, url: str, use_cookies: Optional[bool] = None, retry_count: int = 0) -> Optional[Dict[str, Any]]:
         """Get video information with cookie support"""
         max_retries = 3
         
@@ -266,9 +279,9 @@ class EnhancedYouTubeDownloader:
                 str(url)
             ]
             
-            cmd = self._build_command(base_cmd, use_cookies)
+            cmd, actual_cookie_usage = self._build_command(base_cmd, use_cookies)
             
-            logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {use_cookies})")
+            logger.info(f"Getting video info (attempt {retry_count + 1}, cookies: {actual_cookie_usage})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=60)
             video_info = json.loads(result.stdout)
@@ -298,8 +311,9 @@ class EnhancedYouTubeDownloader:
                     return self.get_video_info(url, use_cookies, retry_count + 1)
             
             elif "sign in" in error_msg or "bot" in error_msg:
-                if not use_cookies and retry_count == 0:
-                    logger.warning("Bot detection triggered, retrying with cookies if available")
+                # If not using cookies and we have them available, try with cookies
+                if not self._should_use_cookies(use_cookies) and self.cookie_manager.has_valid_cookies() and retry_count == 0:
+                    logger.warning("Bot detection triggered, retrying with cookies")
                     return self.get_video_info(url, True, retry_count + 1)
                 elif retry_count < max_retries:
                     wait_time = (retry_count + 1) * 60
@@ -307,7 +321,7 @@ class EnhancedYouTubeDownloader:
                     time.sleep(wait_time)
                     return self.get_video_info(url, use_cookies, retry_count + 1)
             
-            elif "cookies" in error_msg and use_cookies:
+            elif "cookies" in error_msg and self._should_use_cookies(use_cookies):
                 logger.error("Cookie-related error - cookies may be expired or invalid")
                 # Try without cookies as fallback
                 if retry_count == 0:
@@ -325,7 +339,7 @@ class EnhancedYouTubeDownloader:
             return None
     
     def download_video(self, url: str, quality: str = "best", 
-                      audio_only: bool = False, use_cookies: bool = False, 
+                      audio_only: bool = False, use_cookies: Optional[bool] = None, 
                       retry_count: int = 0) -> Optional[str]:
         """Download video with cookie support"""
         max_retries = 2
@@ -350,9 +364,9 @@ class EnhancedYouTubeDownloader:
             
             base_cmd.append(str(url))
             
-            cmd = self._build_command(base_cmd, use_cookies)
+            cmd, actual_cookie_usage = self._build_command(base_cmd, use_cookies)
             
-            logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {use_cookies})")
+            logger.info(f"Downloading video (attempt {retry_count + 1}, cookies: {actual_cookie_usage})")
             
             result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300)
             
@@ -372,8 +386,9 @@ class EnhancedYouTubeDownloader:
             if ("429" in error_msg or "too many requests" in error_msg or 
                 "sign in" in error_msg or "bot" in error_msg):
                 
-                if not use_cookies and retry_count == 0:
-                    logger.warning("Download blocked, retrying with cookies if available")
+                # If not using cookies and we have them available, try with cookies
+                if not self._should_use_cookies(use_cookies) and self.cookie_manager.has_valid_cookies() and retry_count == 0:
+                    logger.warning("Download blocked, retrying with cookies")
                     return self.download_video(url, quality, audio_only, True, retry_count + 1)
                 elif retry_count < max_retries:
                     wait_time = (retry_count + 1) * 60
@@ -475,6 +490,14 @@ async def read_root():
                 margin: 20px 0;
                 color: #155724;
             }
+            .info {
+                background: #d1ecf1;
+                border: 1px solid #bee5eb;
+                border-radius: 5px;
+                padding: 15px;
+                margin: 20px 0;
+                color: #0c5460;
+            }
             input[type="file"] {
                 margin: 10px 0;
             }
@@ -487,6 +510,11 @@ async def read_root():
                 <p>Upload your YouTube cookies for better success rates</p>
             </div>
             
+            <div class="info">
+                <strong>🔄 Auto-Cookie Detection:</strong> This version automatically uses cookies when available. 
+                You no longer need to manually enable cookies in API requests!
+            </div>
+            
             <div class="warning">
                 <strong>⚠️ Cookie Issues?</strong> If your cookies aren't working, they might be:
                 <ul>
@@ -577,7 +605,7 @@ async def upload_cookies(cookie_file: UploadFile = File(...)):
             validation = downloader.cookie_manager.validate_cookies()
             return {
                 "success": True,
-                "message": f"Cookies uploaded successfully. Found {validation.get('youtube_cookies', 0)} YouTube cookies.",
+                "message": f"Cookies uploaded successfully. Found {validation.get('youtube_cookies', 0)} YouTube cookies. Auto-detection enabled.",
                 "validation": validation
             }
         else:
@@ -599,6 +627,8 @@ async def cookie_status():
     validation = downloader.cookie_manager.validate_cookies()
     return {
         "cookie_file_exists": downloader.cookie_manager.cookie_file.exists(),
+        "has_valid_cookies": downloader.cookie_manager.has_valid_cookies(),
+        "auto_detection_enabled": True,
         "validation": validation
     }
 
@@ -612,6 +642,7 @@ async def health_check():
         yt_dlp_available = False
     
     strategies = [
+        "Auto Cookie Detection",
         "Cookie Support",
         "User-Agent Rotation",
         "Smart Retry Logic",
@@ -630,7 +661,7 @@ async def health_check():
 
 @app.post("/video/info", response_model=Dict[str, Any])
 async def get_video_info(request: VideoInfoRequest):
-    """Get video information with cookie support"""
+    """Get video information with automatic cookie detection"""
     try:
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
@@ -641,11 +672,15 @@ async def get_video_info(request: VideoInfoRequest):
             executor, 
             downloader.get_video_info, 
             url_str, 
-            request.use_cookies
+            request.use_cookies  # This can be None for auto-detection
         )
         
         if info:
-            return {"success": True, "info": info}
+            return {
+                "success": True, 
+                "info": info,
+                "cookies_used": downloader._should_use_cookies(request.use_cookies)
+            }
         else:
             raise HTTPException(
                 status_code=503, 
@@ -660,7 +695,7 @@ async def get_video_info(request: VideoInfoRequest):
 
 @app.post("/video/download", response_model=DownloadResponse)
 async def download_video(request: DownloadRequest, background_tasks: BackgroundTasks):
-    """Download video with cookie support"""
+    """Download video with automatic cookie detection"""
     try:
         url_str = str(request.url)
         if not any(domain in url_str for domain in ['youtube.com', 'youtu.be']):
@@ -672,7 +707,7 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             executor, 
             downloader.get_video_info, 
             url_str, 
-            request.use_cookies
+            request.use_cookies  # This can be None for auto-detection
         )
         if not info:
             raise HTTPException(
@@ -687,7 +722,7 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             url_str, 
             request.quality, 
             request.audio_only,
-            request.use_cookies
+            request.use_cookies  # This can be None for auto-detection
         )
         
         if downloaded_file:
@@ -697,9 +732,11 @@ async def download_video(request: DownloadRequest, background_tasks: BackgroundT
             # Schedule cleanup after 2 hours
             background_tasks.add_task(cleanup_file, downloaded_file, delay=7200)
             
+            cookies_used = downloader._should_use_cookies(request.use_cookies)
+            
             return DownloadResponse(
                 success=True,
-                message="Video downloaded successfully with cookie support",
+                message=f"Video downloaded successfully {'with' if cookies_used else 'without'} cookies",
                 filename=filename,
                 file_size=file_size,
                 video_info=VideoInfo(**info),