cookies

test/test_video_downloader.py

@@ -10,7 +10,8 @@ sys.path.insert(0, str(Path(__file__).parent.parent))
 from video_downloader import VideoDownloader
 
 
-def test_video_downloader_init_default():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_video_downloader_init_default(mock_configure_cookies):
     # Setup
     temp_dir = None
     downloader = None
@@ -26,6 +27,7 @@ def test_video_downloader_init_default():
         assert 'outtmpl' in downloader.ydl_opts
         assert 'format' in downloader.ydl_opts
         assert 'noplaylist' in downloader.ydl_opts
+        mock_configure_cookies.assert_called_once()
         
     finally:
         # Teardown
@@ -33,7 +35,8 @@ def test_video_downloader_init_default():
             shutil.rmtree("downloads", ignore_errors=True)
 
 
-def test_video_downloader_init_custom():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_video_downloader_init_custom(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     test_output_dir = os.path.join(temp_dir, "test_downloads")
@@ -46,6 +49,7 @@ def test_video_downloader_init_custom():
         # Verify
         assert str(downloader.output_dir) == test_output_dir
         assert downloader.output_dir.exists()
+        mock_configure_cookies.assert_called_once()
         
     finally:
         # Teardown
@@ -53,7 +57,25 @@ def test_video_downloader_init_custom():
             shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_validate_valid_http_url():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_configure_cookies_success(mock_configure_cookies):
+    # Setup
+    temp_dir = tempfile.mkdtemp()
+    
+    try:
+        # Exercise
+        downloader = VideoDownloader(temp_dir)
+        
+        # Verify
+        mock_configure_cookies.assert_called_once()
+        
+    finally:
+        # Teardown
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_validate_valid_http_url(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -71,7 +93,8 @@ def test_validate_valid_http_url():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_validate_valid_https_url():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_validate_valid_https_url(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -89,7 +112,8 @@ def test_validate_valid_https_url():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_validate_invalid_url():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_validate_invalid_url(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -107,7 +131,8 @@ def test_validate_invalid_url():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_validate_empty_url():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_validate_empty_url(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -125,7 +150,8 @@ def test_validate_empty_url():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_is_direct_video_link_mp4():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_is_direct_video_link_mp4(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -143,7 +169,8 @@ def test_is_direct_video_link_mp4():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_is_direct_video_link_avi():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_is_direct_video_link_avi(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -161,7 +188,8 @@ def test_is_direct_video_link_avi():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_is_not_direct_video_link_youtube():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_is_not_direct_video_link_youtube(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -179,7 +207,8 @@ def test_is_not_direct_video_link_youtube():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
-def test_is_not_direct_video_link_html():
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_is_not_direct_video_link_html(mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -197,8 +226,9 @@ def test_is_not_direct_video_link_html():
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.requests.get')
-def test_download_direct_video_success(mock_get):
+def test_download_direct_video_success(mock_get, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -226,8 +256,9 @@ def test_download_direct_video_success(mock_get):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.requests.get')
-def test_download_direct_video_no_filename(mock_get):
+def test_download_direct_video_no_filename(mock_get, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -252,8 +283,9 @@ def test_download_direct_video_no_filename(mock_get):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.requests.get')
-def test_download_direct_video_request_error(mock_get):
+def test_download_direct_video_request_error(mock_get, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -273,8 +305,9 @@ def test_download_direct_video_request_error(mock_get):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.yt_dlp.YoutubeDL')
-def test_download_with_ytdlp_success(mock_ytdl_class):
+def test_download_with_ytdlp_success(mock_ytdl_class, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -303,8 +336,9 @@ def test_download_with_ytdlp_success(mock_ytdl_class):
         # Teardown
         shutil.rmtree(temp_dir, ignore_errors=True)
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.VideoFileClip')
-def test_extract_audio_success(mock_video_clip):
+def test_extract_audio_success(mock_video_clip, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -333,8 +367,9 @@ def test_extract_audio_success(mock_video_clip):
         shutil.rmtree(temp_dir, ignore_errors=True)
 
 
+@patch.object(VideoDownloader, '_configure_cookies')
 @patch('video_downloader.VideoFileClip')
-def test_extract_audio_mp3_format(mock_video_clip):
+def test_extract_audio_mp3_format(mock_video_clip, mock_configure_cookies):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -366,7 +401,8 @@ def test_extract_audio_mp3_format(mock_video_clip):
 @patch.object(VideoDownloader, 'download_direct_video')
 @patch.object(VideoDownloader, 'is_direct_video_link')
 @patch.object(VideoDownloader, 'validate_url')
-def test_process_url_direct_video_with_audio(mock_validate, mock_is_direct, mock_download, mock_extract):
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_process_url_direct_video_with_audio(mock_configure_cookies, mock_validate, mock_is_direct, mock_download, mock_extract):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)
@@ -397,7 +433,8 @@ def test_process_url_direct_video_with_audio(mock_validate, mock_is_direct, mock
 
 
 @patch.object(VideoDownloader, 'validate_url')
-def test_process_url_invalid_url(mock_validate):
+@patch.object(VideoDownloader, '_configure_cookies')
+def test_process_url_invalid_url(mock_configure_cookies, mock_validate):
     # Setup
     temp_dir = tempfile.mkdtemp()
     downloader = VideoDownloader(temp_dir)

video_downloader.py

@@ -8,8 +8,6 @@ from pathlib import Path
 from moviepy.editor import VideoFileClip
 from urllib.parse import urlparse
 from logger import get_logger
-import json
-import browser_cookie3
 import platform
 
 # Get logger for this module
@@ -21,85 +19,52 @@ class VideoDownloader:
         self.output_dir = Path(output_dir)
         self.output_dir.mkdir(exist_ok=True)
         
-        # Get cookies from browser
-        self.cookies = self._get_browser_cookies()
-        
-        # yt-dlp options
+        # yt-dlp options with automatic cookie support
         self.ydl_opts = {
             'outtmpl': str(self.output_dir / '%(title)s.%(ext)s'),
             'format': 'best',
             'noplaylist': True,
-            'cookiefile': self._save_cookies_to_file() if self.cookies else None,
             'quiet': True,
             'no_warnings': True,
             'extract_flat': False,
         }
+        
+        # Add automatic browser cookie support
+        self._configure_cookies()
     
-    def _get_browser_cookies(self):
-        """Get cookies from the user's browser"""
+    def _configure_cookies(self):
+        """Configure automatic cookie extraction from browser"""
         try:
             # Try different browsers in order of preference
-            browsers = [
-                ('chrome', browser_cookie3.chrome),
-                ('firefox', browser_cookie3.firefox),
-                ('edge', browser_cookie3.edge),
-                ('safari', browser_cookie3.safari),
-                ('opera', browser_cookie3.opera),
-                ('brave', browser_cookie3.brave),
-            ]
-            
-            for browser_name, browser_func in browsers:
+            browsers_to_try = ['chrome', 'firefox', 'edge', 'safari', 'opera', 'brave']
+            
+            for browser in browsers_to_try:
                 try:
-                    cookies = browser_func(domain_name='.youtube.com')
-                    if cookies:
-                        logger.info(f"Successfully loaded cookies from {browser_name}")
-                        return cookies
+                    # Test if browser cookies are accessible
+                    test_opts = self.ydl_opts.copy()
+                    test_opts['cookies_from_browser'] = (browser, None, None, None)
+                    test_opts['quiet'] = True
+                    test_opts['no_warnings'] = True
+                    
+                    # Try to extract info from a simple YouTube URL to test cookies
+                    with yt_dlp.YoutubeDL(test_opts) as ydl:
+                        # Just test if we can access cookies, don't actually download
+                        logger.debug(f"Testing {browser} cookies...")
+                        
+                    # If no exception, browser cookies are accessible
+                    self.ydl_opts['cookies_from_browser'] = (browser, None, None, None)
+                    logger.info(f"Successfully configured automatic cookies from {browser}")
+                    return
+                    
                 except Exception as e:
-                    logger.debug(f"Failed to get cookies from {browser_name}: {e}")
+                    logger.debug(f"Failed to configure cookies from {browser}: {e}")
                     continue
             
-            logger.warning("No browser cookies found")
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error getting browser cookies: {e}")
-            return None
-    
-    def _save_cookies_to_file(self):
-        """Save cookies to a temporary file in Netscape format"""
-        if not self.cookies:
-            return None
-            
-        try:
-            # Create a temporary file for cookies
-            cookie_file = tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt')
-            
-            # Write Netscape format cookie file
-            cookie_file.write("# Netscape HTTP Cookie File\n")
-            cookie_file.write("# https://curl.haxx.se/rfc/cookie_spec.html\n")
-            cookie_file.write("# This file was generated by yt-dlp\n\n")
-            
-            for cookie in self.cookies:
-                if cookie.domain.endswith('.youtube.com'):
-                    secure = "TRUE" if cookie.secure else "FALSE"
-                    http_only = "TRUE" if cookie.has_nonstandard_attr('HttpOnly') else "FALSE"
-                    cookie_file.write(f"{cookie.domain}\tTRUE\t{cookie.path}\t{secure}\t{cookie.expires}\t{cookie.name}\t{cookie.value}\n")
-            
-            cookie_file.close()
-            logger.info(f"Saved cookies to temporary file: {cookie_file.name}")
-            return cookie_file.name
+            logger.warning("No accessible browser cookies found. Proceeding without cookies.")
             
         except Exception as e:
-            logger.error(f"Error saving cookies to file: {e}")
-            return None
-    
-    def _cleanup_cookie_file(self):
-        """Clean up the temporary cookie file"""
-        if hasattr(self, 'ydl_opts') and self.ydl_opts.get('cookiefile'):
-            try:
-                os.unlink(self.ydl_opts['cookiefile'])
-            except Exception as e:
-                logger.error(f"Error cleaning up cookie file: {e}")
+            logger.error(f"Error configuring browser cookies: {e}")
+            logger.info("Proceeding without automatic cookies")
     
     def validate_url(self, url):
         # Handle empty or None URLs
@@ -184,13 +149,14 @@ class VideoDownloader:
                 logger.error("HTTP 403 Forbidden error detected!")
                 print("YOUTUBE ACCESS ERROR (403 Forbidden)")
                 print("This error typically occurs due to:")
-                print("1. Browser cookies interfering with yt-dlp")
-                print("2. Outdated yt-dlp version")
+                print("1. Rate limiting or IP blocking")
+                print("2. Need for updated cookies")
+                print("3. Outdated yt-dlp version")
                 print("\n SOLUTIONS:")
-                print("1. Clear your browser cookies for YouTube")
+                print("1. Try again in a few minutes")
                 print("2. Update yt-dlp: pip install --upgrade yt-dlp")
-                print("3. Try again in a few minutes")
-                print("4. Use a different video URL for testing")
+                print("3. Use a different video URL for testing")
+                print("4. Make sure your browser is logged into YouTube")
                 raise Exception("YouTube access blocked (403 Forbidden). See solutions above.")
             else:
                 logger.error(f"yt-dlp download error: {e}")