Update Dockerfile, fix downloading issue

Dockerfile

@@ -25,11 +25,7 @@ COPY . .
 # Create directory for static files and set proper permissions
 RUN mkdir -p /data/audio && \
     chown -R nobody:nogroup /data/audio && \
-    chmod -R 777 /data/audio && \
-    # Create cookie file with proper permissions
-    touch /tmp/youtube.com_cookies.txt && \
-    chown nobody:nogroup /tmp/youtube.com_cookies.txt && \
-    chmod 666 /tmp/youtube.com_cookies.txt
+    chmod -R 777 /data/audio
 
 # Switch to non-root user
 USER nobody

app/services/youtube_service.py

@@ -8,9 +8,9 @@ from ..core.config import settings
 class YouTubeService:
     def __init__(self):
         self.output_dir = settings.AUDIO_DIR
-        # Configure yt-dlp with Docker-compatible defaults
+        # Configure yt-dlp with robust but simple defaults
         self.ydl_opts = {
-            "format": "bestaudio/best",
+            "format": "bestaudio[ext=m4a]/bestaudio/best",  # Prefer m4a format
             "postprocessors": [
                 {
                     "key": "FFmpegExtractAudio",
@@ -18,125 +18,80 @@ class YouTubeService:
                     "preferredquality": "192",
                 }
             ],
-            "quiet": False,  # Enable output for debugging
-            # Add user agent and other headers to avoid restrictions
-            "http_headers": {
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
-                "Accept-Language": "en-US,en;q=0.9",
-                "Accept-Encoding": "gzip, deflate, br",
-                "Referer": "https://www.youtube.com/",
-            },
-            # Add retries and throttling with better Docker-optimized settings
+            # Basic retry and timeout settings
             "retries": 3,
             "fragment_retries": 3,
-            "skip_unavailable_fragments": True,
-            "ignoreerrors": False,
-            "no_warnings": False,
-            "sleep_interval": 1,
-            "max_sleep_interval": 5,
-            # Add network settings
             "socket_timeout": 30,
-            "extractor_retries": 3,
-            # Add progress hooks for better logging
-            "progress_hooks": [self._progress_hook],
-            # Use cookies file if available
-            "cookiefile": "/tmp/youtube.com_cookies.txt",
+            # Output settings
+            "outtmpl": "%(id)s.%(ext)s",
+            "quiet": True,
+            "no_warnings": True,
+            # Error handling
+            "ignoreerrors": False,
+            "no_color": True,
+            # Basic request headers
+            "http_headers": {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            },
         }
 
-    def _progress_hook(self, d):
-        if d["status"] == "downloading":
-            try:
-                progress = (
-                    float(d.get("downloaded_bytes", 0))
-                    / float(d.get("total_bytes", 1))
-                    * 100
-                )
-                print(f"Downloading: {progress:.1f}%")
-            except:
-                pass
-        elif d["status"] == "error":
-            print(f"Error during download: {d.get('error')}")
-        elif d["status"] == "finished":
-            print(f"Download finished, converting to MP3...")
-
     def _extract_video_id(self, url: str) -> str:
-        query = urlparse(url)
-        if query.hostname == "youtu.be":
-            return query.path[1:]
-        if query.hostname in {"www.youtube.com", "youtube.com", "m.youtube.com"}:
-            if query.path == "/watch":
-                return parse_qs(query.query)["v"][0]
-            if query.path[:7] == "/embed/":
-                return query.path.split("/")[2]
-            if query.path[:3] == "/v/":
-                return query.path.split("/")[2]
-        raise ValueError("Invalid YouTube URL")
+        """Extract video ID from YouTube URL"""
+        try:
+            query = urlparse(url)
+            if query.hostname == "youtu.be":
+                return query.path[1:]
+            if query.hostname in {"www.youtube.com", "youtube.com", "m.youtube.com"}:
+                if query.path == "/watch":
+                    return parse_qs(query.query)["v"][0]
+                if query.path[:7] == "/embed/":
+                    return query.path.split("/")[2]
+                if query.path[:3] == "/v/":
+                    return query.path.split("/")[2]
+            raise ValueError()
+        except:
+            raise ValueError("Invalid or unsupported YouTube URL format")
 
     async def convert_to_mp3(self, url: str) -> str:
-        video_id = self._extract_video_id(url)
-        filename = f"{video_id}.mp3"
-        output_path = self.output_dir / filename
-
-        # Skip if file already exists
-        if output_path.exists():
-            return filename
+        """Convert YouTube video to MP3 and return the filename"""
+        try:
+            # Extract video ID and validate URL
+            video_id = self._extract_video_id(url)
+            filename = f"{video_id}.mp3"
+            output_path = self.output_dir / filename
 
-        # Update output template for this specific download
-        opts = {**self.ydl_opts, "outtmpl": str(output_path.with_suffix(""))}
+            # Skip if file already exists
+            if output_path.exists():
+                return filename
 
-        try:
-            # Create a new event loop for the executor
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            # Set output path for this specific download
+            opts = dict(self.ydl_opts)
+            opts["outtmpl"] = str(output_path.with_suffix(""))
 
-            # Run the download in the executor
-            await loop.run_in_executor(None, self._download_and_convert, url, opts)
+            # Try download with fallback
+            try:
+                with yt_dlp.YoutubeDL(opts) as ydl:
+                    ydl.download([url])
+            except Exception as e:
+                # If first attempt fails, try with lower quality
+                opts["format"] = "worstaudio/worst"
+                with yt_dlp.YoutubeDL(opts) as ydl:
+                    ydl.download([url])
 
+            # Verify the file was created
             if not output_path.exists():
                 raise Exception("Failed to download and convert the video")
 
             return filename
+
+        except ValueError as e:
+            # URL validation errors
+            print(f"URL validation error: {str(e)}")
+            raise
         except Exception as e:
+            # All other errors
             print(f"Error in convert_to_mp3: {str(e)}")
             raise Exception(f"Error converting video: {str(e)}")
-        finally:
-            try:
-                loop.close()
-            except:
-                pass
-
-    def _download_and_convert(self, url: str, opts: dict):
-        attempts = [
-            {
-                "format": "bestaudio[ext=m4a]/bestaudio/best",
-                "msg": "Trying with best audio quality...",
-            },
-            {
-                "format": "worstaudio[ext=m4a]/worstaudio/worst",
-                "msg": "Trying with lowest quality as fallback...",
-            },
-        ]
-
-        last_error = None
-        for attempt in attempts:
-            try:
-                print(attempt["msg"])
-                current_opts = {**opts, "format": attempt["format"]}
-
-                with yt_dlp.YoutubeDL(current_opts) as ydl:
-                    error = ydl.download([url])
-                    if not error:  # yt-dlp returns 0 on success
-                        return  # Success!
-                    raise Exception(f"yt-dlp returned error code: {error}")
-            except Exception as e:
-                print(f"Download attempt failed: {str(e)}")
-                last_error = e
-                # Wait before next attempt
-                asyncio.get_event_loop().run_in_executor(None, asyncio.sleep, 1)
-
-        # If we get here, all attempts failed
-        raise last_error or Exception("All download attempts failed")
 
 
 youtube_service = YouTubeService()