SpotDown 1.0.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

SpotDown/downloader/youtube_downloader.py

@@ -15,7 +15,7 @@ from rich.console import Console
 
 # Internal utils
 from SpotDown.utils.config_json import config_manager
-from SpotDown.utils.file_utils import FileUtils
+from SpotDown.utils.file_utils import file_utils
 
 
 # Variable
@@ -25,7 +25,7 @@ quality = config_manager.get("DOWNLOAD", "quality")
 class YouTubeDownloader:
     def __init__(self):
         self.console = Console()
-        self.file_utils = FileUtils()
+        self.file_utils = file_utils
 
     def download(self, video_info: Dict, spotify_info: Dict) -> bool:
         """
@@ -87,6 +87,7 @@ class YouTubeDownloader:
                 '--no-playlist',
                 '--embed-metadata',
                 '--add-metadata',
+                '--ffmpeg-location', self.file_utils.ffmpeg_path
             ]
             
             if cover_path and cover_path.exists():

SpotDown/extractor/spotify_extractor.py

@@ -1,355 +1,218 @@
 # 05.04.2024
 
 import os
+import re
+import sys
 import json
 import logging
 from typing import Dict, List, Optional
+from dotenv import load_dotenv
 
 
-# External imports
+# External library
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
 from rich.console import Console
-from playwright.sync_api import sync_playwright
-
-
-# Internal utils
-from SpotDown.utils.headers import get_userAgent
-from SpotDown.utils.config_json import config_manager
+from rich.progress import Progress
 
 
 # Variable
 console = Console()
-headless = config_manager.get("BROWSER", "headless")
-timeout = config_manager.get("BROWSER", "timeout")
+load_dotenv()
+
+
+def extract_track_id(spotify_url):
+    patterns = [
+        r'track/([a-zA-Z0-9]{22})',
+        r'spotify:track:([a-zA-Z0-9]{22})'
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, spotify_url)
+        if match:
+            return match.group(1)
+    return None
+
+
+def extract_playlist_id(spotify_url):
+    patterns = [
+        r'playlist/([a-zA-Z0-9]{22})',
+        r'spotify:playlist:([a-zA-Z0-9]{22})'
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, spotify_url)
+        if match:
+            return match.group(1)
+    return None
 
 
 class SpotifyExtractor:
     def __init__(self):
-        self.playwright = None
-        self.browser = None
-        self.context = None
-        self.page = None
-        self.user_agent = get_userAgent()
-        self.total_songs = None
-        self.playlist_items = []
+        client_id = os.getenv("SPOTIPY_CLIENT_ID")
+        client_secret = os.getenv("SPOTIPY_CLIENT_SECRET")
+
+        if not client_id or not client_secret:
+            console.print("[red]Missing Spotify credentials. Please create a .env file with SPOTIFY_CLIENT_ID and SPOTIPY_CLIENT_SECRET from https://developer.spotify.com/dashboard/")
+            sys.exit(1)
+
+        self.sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(
+            client_id=client_id,
+            client_secret=client_secret
+        ))
         logging.info("SpotifyExtractor initialized")
 
     def __enter__(self):
-        """Context manager to automatically handle the browser"""
-        logging.info("Starting Playwright and launching browser")
-        self.playwright = sync_playwright().start()
-        self.browser = self.playwright.chromium.launch(headless=headless)
-        self.context = self.browser.new_context(
-            user_agent=self.user_agent, viewport={'width': 1280, 'height': 800}, ignore_https_errors=True
-        )
-        self.page = self.context.new_page()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Automatically closes the browser"""
-        logging.info("Closing browser and stopping Playwright")
-        if self.browser:
-            self.browser.close()
-        if self.playwright:
-            self.playwright.stop()
+        pass
 
     def extract_track_info(self, spotify_url: str, save_json: bool = False) -> Optional[Dict]:
-        """
-        Extracts track information from a Spotify URL
+        track_id = extract_track_id(spotify_url)
+        if not track_id:
+            logging.error("Invalid Spotify track URL")
+            return None
         
-        Args:
-            spotify_url (str): Spotify URL of the track
-            save_json (bool): If True, saves the raw Spotify API JSON response in the 'log' folder
-            
-        Returns:
-            Dict: Track information or None if an error occurs
-        """
         try:
-            logging.info(f"Analyzing Spotify URL: {spotify_url}")
-            console.print("[cyan]Analyzing Spotify URL ...")
-            
-            # Extract Spotify data by intercepting API calls
-            spotify_data, raw_json = self._extract_spotify_data(spotify_url, return_raw=True)
-
-            if not spotify_data:
-                logging.info("Unable to extract data from Spotify")
-                console.print("[cyan]Unable to extract data from Spotify")
-                return None
-
-            # Save the JSON response if requested
-            if save_json and raw_json:
-                try:
-                    logging.info("Saving Spotify API response JSON")
-                    log_dir = os.path.join(os.getcwd(), "log")
-                    os.makedirs(log_dir, exist_ok=True)
-
-                    # Use title and artist for the filename if available
-                    filename = "spotify_response.json"
-
-                    if spotify_data.get("artist") and spotify_data.get("title"):
-                        safe_artist = "".join(c for c in spotify_data["artist"] if c.isalnum() or c in " _-")
-                        safe_title = "".join(c for c in spotify_data["title"] if c.isalnum() or c in " _-")
-                        filename = f"{safe_artist} - {safe_title}.json"
-
-                    filepath = os.path.join(log_dir, filename)
-                    with open(filepath, "w", encoding="utf-8") as f:
-                        json.dump(raw_json, f, ensure_ascii=False, indent=2)
-
-                    console.print(f"[green]Spotify API response saved to {filepath}")
-
-                except Exception as e:
-                    logging.error(f"Could not save JSON file: {e}")
-                    console.print(f"[yellow]Warning: Could not save JSON file: {e}")
-
-            logging.info(f"Found track: {spotify_data['artist']} - {spotify_data['title']}")
-            console.print(f"[cyan]Found: [red]{spotify_data['artist']} - {spotify_data['title']}[/red]")
-            return spotify_data
+            # Extract track info
+            track = self.sp.track(track_id)
 
-        except Exception as e:
-            logging.error(f"Spotify extraction error: {e}")
-            console.print(f"[cyan]Spotify extraction error: {e}")
-            return None
+            # Extract album info
+            album = track['album']
 
-    def _extract_spotify_data(self, spotify_url: str, return_raw: bool = False) -> Optional[Dict]:
-        """Extracts Spotify data by intercepting API calls"""
-        try:
-            logging.info(f"Intercepting API calls for URL: {spotify_url}")
-            api_responses = []
-            
-            def handle_request(request):
-                if (request.method == "POST" and "/pathfinder/v2/query" in request.url):
-                    try:
-                        response = request.response()
-                        if response and response.status == 200:
-                            try:
-                                response_data = response.json()
-                                
-                                if self._is_valid_track_data(response_data):
-                                    api_responses.append(response_data)
-                                    console.print("[green]Valid API response found")
-
-                            except Exception as e:
-                                logging.warning(f"Error parsing API response: {e}")
-
-                    except Exception as e:
-                        logging.warning(f"Error accessing response: {e}")
-
-            self.page.on("requestfinished", handle_request)
-            self.page.goto(spotify_url)
-            
-            # Poll every 100ms, stop waiting as soon as a valid response is found or after 10 seconds
-            # This avoids unnecessary waiting after a valid API response is received
-            for _ in range(timeout * 10):  # 100 * 100ms = 10000ms (10 seconds max)
-                if api_responses:
-                    logging.info("Valid API response found, stopping polling")
-                    break
-
-                self.page.wait_for_timeout(timeout * 10)
-
-            if not api_responses:
-                logging.info("No valid API responses found")
-                console.print("[cyan]No valid API responses found")
-                return (None, None) if return_raw else None
-
-            # Selects the most complete response
-            best_response = max(api_responses, key=lambda x: len(json.dumps(x)))
-            parsed = self._parse_spotify_response(best_response)
-            logging.info("Returning parsed Spotify API response")
-            return (parsed, best_response) if return_raw else parsed
+            # Process extracted data
+            release_date = album['release_date']
+            year = release_date.split('-')[0] if release_date else None
 
-        except Exception as e:
-            logging.error(f"Spotify data extraction error: {e}")
-            console.print(f"[cyan]❌ Spotify data extraction error: {e}")
-            return (None, None) if return_raw else None
+            # Extract duration in seconds and formatted
+            duration_ms = track['duration_ms']
+            duration_seconds = duration_ms // 1000 if duration_ms else None
+            duration_formatted = f"{duration_seconds // 60}:{duration_seconds % 60:02d}" if duration_seconds else None
 
-    def _is_valid_track_data(self, data: Dict) -> bool:
-        """Checks if the data contains valid track information"""
-        try:
-            track_union = data.get("data", {}).get("trackUnion", {})
-            return bool(track_union.get("name") and track_union.get("firstArtist", {}).get("items"))
-        
-        except Exception:
-            logging.error("Error validating track data")
-            return False
+            # Extract cover URL
+            cover_url = album['images'][0]['url'] if album['images'] else None
 
-    def _parse_spotify_response(self, response: Dict) -> Dict:
-        """Parses the Spotify API response"""
-        try:
-            # Extract title
-            track_data = response.get("data", {}).get("trackUnion", {})
-            title = track_data.get("name", "").strip()
-            
-            # Extract artist
-            artist_items = track_data.get("firstArtist", {}).get("items", [])
-            artist = artist_items[0].get("profile", {}).get("name", "") if artist_items else ""
-            
-            # Extract album
-            album_data = track_data.get("albumOfTrack", {})
-            album = album_data.get("name", "")
-            
-            # Extract year
-            release_date = album_data.get("date", {})
-            year = release_date.get("year") if release_date else None
-            
-            # Extract duration
-            duration_ms = track_data.get("duration", {}).get("totalMilliseconds")
-            duration_seconds = duration_ms // 1000 if duration_ms else None
-            duration_formatted = self._format_seconds(duration_seconds) if duration_seconds else None
-            
-            # Extract cover art
-            cover_url = ""
-            cover_sources = album_data.get("coverArt", {}).get("sources", [])
-
-            if cover_sources:
-                largest = max(
-                    cover_sources,
-                    key=lambda x: max(x.get("width", 0), x.get("height", 0))
-                )
-                cover_url = largest.get("url", "")
-
-            return {
-                'title': title,
-                'artist': artist,
-                'album': album,
+            # Extract artists
+            artists = [artist['name'] for artist in track['artists']]
+
+            # Compile track info
+            track_info = {
+                'artist': ', '.join(artists),
+                'title': track['name'],
+                'album': album['name'],
                 'year': year,
                 'duration_seconds': duration_seconds,
                 'duration_formatted': duration_formatted,
                 'cover_url': cover_url
             }
 
+            if save_json:
+                log_dir = os.path.join(os.getcwd(), "log")
+                os.makedirs(log_dir, exist_ok=True)
+
+                # Create JSON file for track info
+                filename = f"{track_info['artist']} - {track_info['title']}.json"
+                filepath = os.path.join(log_dir, filename)
+
+                # Save track info to JSON
+                with open(filepath, "w", encoding="utf-8") as f:
+                    json.dump(track_info, f, ensure_ascii=False, indent=2)
+
+            return track_info
         except Exception as e:
-            logging.error(f"Error parsing Spotify response: {e}")
-            console.print(f"[cyan]Error parsing Spotify response: {e}")
-            return {}
-
-    def _format_seconds(self, seconds: int) -> str:
-        """Formats seconds into mm:ss or hh:mm:ss"""
-        if seconds < 3600:
-            minutes = seconds // 60
-            secs = seconds % 60
-            return f"{minutes}:{secs:02d}"
-        
-        else:
-            hours = seconds // 3600
-            minutes = (seconds % 3600) // 60
-            secs = seconds % 60
-            return f"{hours}:{minutes:02d}:{secs:02d}"
+            error_msg = str(e)
+            logging.error(f"Spotify extraction error: {error_msg}")
+
+            if "invalid_client" in error_msg:
+                console.print("[red]Spotify credentials are invalid. Please check your .env file and obtain valid credentials from https://developer.spotify.com/dashboard/. Exiting.")
+                sys.exit(0)
+                
+            return None
 
     def extract_playlist_tracks(self, playlist_url: str) -> List[Dict]:
-        """Extracts all tracks from a Spotify playlist URL"""
-        logging.info(f"Extracting playlist tracks from: {playlist_url}")
-        self.total_songs = None
-        self.playlist_items = []
-        console.print("[cyan]Extracting playlist tracks...")
+        playlist_id = extract_playlist_id(playlist_url)
 
+        if not playlist_id:
+            logging.error("Invalid Spotify playlist URL")
+            return []
+        
         try:
-            def handle_request(response):
-                try:
-                    if "pathfinder/v2/query" in response.url and response.request.method == "POST":
-                        json_data = response.json()
-                        if (
-                            "data" in json_data and
-                            "playlistV2" in json_data["data"] and
-                            "content" in json_data["data"]["playlistV2"]
-                        ):
-                            if self.total_songs is None:
-                                self.total_songs = json_data["data"]["playlistV2"]["content"].get("totalCount", 0)
-                            items = json_data["data"]["playlistV2"]["content"].get("items", [])
-                            for item in items:
-                                parsed_item = self._parse_spotify_playlist_item(item)
-                                if parsed_item:
-                                    self.playlist_items.append(parsed_item)
-                except Exception as e:
-                    logging.error(f"Error processing playlist request: {e}")
-                    console.print(f"Error processing request: {e}")
-
-            self.page.on("response", handle_request)
-            self.page.goto(playlist_url)
-            self.page.wait_for_timeout(5000)
-
-            if self.total_songs is None:
-                logging.error("Could not extract the total number of songs")
-                console.print("Error: Could not extract the total number of songs.")
-                return []
-
-            logging.info(f"Playlist has {self.total_songs} tracks")
-            console.print(f"[cyan]The playlist has [green]{self.total_songs}[/green] tracks")
-
-            try:
-                self.page.wait_for_selector('div[data-testid="playlist-tracklist"]', timeout=15000)
-            except Exception:
-                logging.error("Playlist table did not load")
-                console.print("Error: Playlist table did not load")
-                return []
-
-            last_item_count = len(self.playlist_items)
-            with console.status("[cyan]Loading tracks...") as status:
-                while len(self.playlist_items) < self.total_songs:
-                    status.update(f"[cyan]Progress: {len(self.playlist_items)}/{self.total_songs} tracks loaded")
-                    rows = self.page.locator('div[role="row"]')
-                    row_count = rows.count()
-                    last_row = rows.nth(row_count - 1)
-                    last_row.scroll_into_view_if_needed()
-                    current_items = len(self.playlist_items)
-                    if current_items > last_item_count:
-                        last_item_count = current_items
-                    self.page.wait_for_timeout(300)
+
+            # Extract playlist info
+            playlist = self.sp.playlist(playlist_id)
+            total_tracks = playlist['tracks']['total']
+            tracks_info = []
+            offset = 0
+            limit = 100
+            console.print(f"[green]Playlist has [red]{total_tracks}[/red] tracks.")
+
+            with Progress() as progress:
+                task = progress.add_task("[cyan]Extracting tracks...", total=total_tracks)
+
+                while offset < total_tracks:
+                    progress.update(task, advance=0, description=f"[cyan]Loading tracks {offset + 1}-{min(offset + limit, total_tracks)} of {total_tracks}...")
+                    results = self.sp.playlist_items(
+                        playlist_id,
+                        offset=offset,
+                        limit=limit,
+                        fields='items(track(name,artists(name),album(name,release_date,images),duration_ms))'
+                    )
+
+                    if not results['items']:
+                        break
+
+                    for idx, item in enumerate(results['items']):
+                        if item['track'] is None:
+                            continue
+                        
+                        # Extract track details
+                        track = item['track']
+
+                        # Extract album info
+                        album = track['album']
+
+                        # Process extracted data
+                        #release_date = album['release_date']
+                        #year = release_date.split('-')[0] if release_date else None
+
+                        # Extract duration in seconds
+                        duration_ms = track['duration_ms']
+                        duration_seconds = duration_ms // 1000 if duration_ms else None
+
+                        # Extract cover URL
+                        cover_url = album['images'][0]['url'] if album['images'] else None
+
+                        # Extract artists
+                        artists = [artist['name'] for artist in track['artists']]
+
+                        # Compile track info
+                        track_info = {
+                            "title": track['name'],
+                            "artist": ', '.join(artists),
+                            "album": album['name'],
+                            "added_at": None,
+                            "cover_art": cover_url,
+                            "duration_ms": duration_ms,
+                            "duration_seconds": duration_seconds,
+                            "play_count": None
+                        }
+
+                        # Append to list
+                        tracks_info.append(track_info)
+                        progress.update(task, advance=1)
+                    offset += limit
 
             # Remove duplicates based on title and artist
             unique = {}
-            for item in self.playlist_items:
+            for item in tracks_info:
                 key = (item.get("title", ""), item.get("artist", ""))
                 if key not in unique:
                     unique[key] = item
-            
+
+            # Convert back to list
             unique_tracks = list(unique.values())
-            logging.info(f"Extracted {len(unique_tracks)} unique tracks from playlist")
+            console.print(f"[green]Extracted [red]{len(unique_tracks)}[/red] unique tracks from playlist")
             return unique_tracks
-
-        except Exception as e:
-            logging.error(f"Error extracting playlist: {e}")
-            console.print(f"Error extracting playlist: {e}")
-            return []
-
-    def _parse_spotify_playlist_item(self, item: Dict) -> Dict:
-        """Parses a single playlist item from Spotify API response"""
-        try:
-            # Extract added date
-            added_at = item.get("addedAt", {}).get("isoString", "")
-            
-            # Extract track data
-            track_data = item.get("itemV2", {}).get("data", {})
-            
-            # Extract album name
-            album_data = track_data.get("albumOfTrack", {})
-            album_name = album_data.get("name", "")
-            
-            # Extract cover art URL
-            cover_art = album_data.get("coverArt", {}).get("sources", [{}])[0].get("url", "")
-            
-            # Extract artist name
-            artist_items = album_data.get("artists", {}).get("items", [])
-            artist_name = artist_items[0].get("profile", {}).get("name", "") if artist_items else ""
-            
-            # Extract track title
-            track_title = track_data.get("name", "")
-            
-            # Extract duration in ms
-            duration_ms = track_data.get("trackDuration", {}).get("totalMilliseconds", 0)
-            
-            # Extract play count
-            play_count = track_data.get("playcount", 0)
-            
-            return {
-                "title": track_title,
-                "artist": artist_name,
-                "album": album_name,
-                "added_at": added_at,
-                "cover_art": cover_art,
-                "duration_ms": duration_ms,
-                "play_count": play_count
-            }
         
         except Exception as e:
-            logging.error(f"Error parsing playlist item: {e}")
-            console.print(f"Error parsing playlist item: {e}")
-            return {}
+            logging.error(f"Error extracting playlist: {e}")
+            return []

SpotDown/main.py

@@ -6,6 +6,7 @@ from typing import Dict, List, Optional
 
 # Internal utils
 from SpotDown.utils.logger import Logger
+from SpotDown.utils.file_utils import file_utils
 from SpotDown.utils.console_utils import ConsoleUtils
 from SpotDown.upload.update import update as git_update
 from SpotDown.extractor.spotify_extractor import SpotifyExtractor
@@ -109,6 +110,7 @@ def run():
     console = ConsoleUtils()
     console.start_message()
     git_update()
+    file_utils.get_system_summary()
 
     spotify_url = console.get_spotify_url()
     max_results = 5

SpotDown/upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'SpotDown'
-__version__ = '1.0.0'
+__version__ = '1.3.0'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download music'
 __copyright__ = 'Copyright 2025'

SpotDown/utils/console_utils.py

@@ -157,7 +157,7 @@ class ConsoleUtils:
             str: Entered Spotify URL
         """
         while True:
-            url = Prompt.ask("[purple]Enter Spotify URL[/purple][green]").strip()
+            url = Prompt.ask("\n[purple]Enter Spotify URL[/purple][green]").strip()
 
             if not url:
                 self.console.print("[red]URL cannot be empty. Please enter a Spotify track URL.[/red]")

SpotDown/utils/ffmpeg_installer.py

@@ -0,0 +1,374 @@
+# 24.01.2024
+
+import os
+import glob
+import gzip
+import shutil
+import logging
+import platform
+import subprocess
+from typing import Optional, Tuple
+
+
+# External library
+import requests
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
+
+
+# Variable
+console = Console()
+
+
+FFMPEG_CONFIGURATION = {
+    'windows': {
+        'base_dir': lambda home: os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary'),
+        'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-win32-{arch}.gz',
+        'file_extension': '.gz',
+        'executables': ['ffmpeg-win32-{arch}', 'ffprobe-win32-{arch}']
+    },
+    'darwin': {
+        'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
+        'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-darwin-{arch}.gz',
+        'file_extension': '.gz',
+        'executables': ['ffmpeg-darwin-{arch}', 'ffprobe-darwin-{arch}']
+    },
+    'linux': {
+        'base_dir': lambda home: os.path.join(home, '.local', 'bin', 'binary'),
+        'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-linux-{arch}.gz',
+        'file_extension': '.gz',
+        'executables': ['ffmpeg-linux-{arch}', 'ffprobe-linux-{arch}']
+    }
+}
+
+
+class FFMPEGDownloader:
+    def __init__(self):
+        self.os_name = self._detect_system()
+        self.arch = self._detect_arch()
+        self.home_dir = os.path.expanduser('~')
+        self.base_dir = self._get_base_directory()
+
+    def _detect_system(self) -> str:
+        """
+        Detect and normalize the operating system name.
+
+        Returns:
+            str: Normalized operating system name ('windows', 'darwin', or 'linux')
+        """
+        system = platform.system().lower()
+        if system in FFMPEG_CONFIGURATION:
+            return system
+        raise ValueError(f"Unsupported operating system: {system}")
+
+    def _detect_arch(self) -> str:
+        """
+        Detect and normalize the system architecture.
+
+        Returns:
+            str: Normalized architecture name (e.g., 'x86_64', 'arm64')
+        """
+        machine = platform.machine().lower()
+        arch_map = {
+            'amd64': 'x64', 
+            'x86_64': 'x64',
+            'x64': 'x64',
+            'arm64': 'arm64',
+            'aarch64': 'arm64',
+            'armv7l': 'arm',
+            'i386': 'ia32',
+            'i686': 'ia32'
+        }
+        return arch_map.get(machine, machine)
+
+    def _get_base_directory(self) -> str:
+        """
+        Get and create the base directory for storing FFmpeg binaries.
+
+        Returns:
+            str: Path to the base directory
+        """
+        base_dir = FFMPEG_CONFIGURATION[self.os_name]['base_dir'](self.home_dir)
+        os.makedirs(base_dir, exist_ok=True)
+        return base_dir
+
+    def _check_existing_binaries(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """
+        Check if FFmpeg binaries already exist in the base directory.
+        Enhanced to check both the binary directory and system paths on macOS.
+        """
+        config = FFMPEG_CONFIGURATION[self.os_name]
+        executables = config['executables']
+        found_executables = []
+
+        # For macOS, check both binary directory and system paths
+        if self.os_name == 'darwin':
+            potential_paths = [
+                '/usr/local/bin',
+                '/opt/homebrew/bin',
+                '/usr/bin',
+                self.base_dir
+            ]
+            
+            for executable in executables:
+                found = None
+                for path in potential_paths:
+                    full_path = os.path.join(path, executable)
+                    if os.path.exists(full_path) and os.access(full_path, os.X_OK):
+                        found = full_path
+                        break
+                found_executables.append(found)
+        else:
+
+            # Original behavior for other operating systems
+            for executable in executables:
+                exe_paths = glob.glob(os.path.join(self.base_dir, executable))
+                found_executables.append(exe_paths[0] if exe_paths else None)
+
+        return tuple(found_executables) if len(found_executables) == 3 else (None, None, None)
+
+    def _get_latest_version(self, repo: str) -> Optional[str]:
+        """
+        Get the latest FFmpeg version from the GitHub releases page.
+
+        Returns:
+            Optional[str]: The latest version string, or None if retrieval fails.
+        """
+        try:
+            # Use GitHub API to fetch the latest release
+            response = requests.get(f'https://api.github.com/repos/{repo}/releases/latest')
+            response.raise_for_status()
+            latest_release = response.json()
+
+            # Extract the tag name or version from the release
+            return latest_release.get('tag_name')
+        
+        except Exception as e:
+            logging.error(f"Unable to get version from GitHub: {e}")
+            return None
+
+    def _download_file(self, url: str, destination: str) -> bool:
+        """
+        Download a file from URL with a Rich progress bar display.
+
+        Parameters:
+            url (str): The URL to download the file from. Should be a direct download link.
+            destination (str): Local file path where the downloaded file will be saved.
+
+        Returns:
+            bool: True if download was successful, False otherwise.
+        """
+        try:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+            total_size = int(response.headers.get('content-length', 0))
+            
+            with open(destination, 'wb') as file, \
+                Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    BarColumn(),
+                    TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+                    TimeRemainingColumn()
+                ) as progress:
+                
+                download_task = progress.add_task("[green]Downloading FFmpeg", total=total_size)
+                for chunk in response.iter_content(chunk_size=8192):
+                    size = file.write(chunk)
+                    progress.update(download_task, advance=size)
+            return True
+        
+        except Exception as e:
+            logging.error(f"Download error: {e}")
+            return False
+
+    def _extract_file(self, gz_path: str, final_path: str) -> bool:
+        """
+        Extract a gzipped file and set proper permissions.
+
+        Parameters:
+            gz_path (str): Path to the gzipped file
+            final_path (str): Path where the extracted file should be saved
+
+        Returns:
+            bool: True if extraction was successful, False otherwise
+        """
+        try:
+            logging.info(f"Attempting to extract {gz_path} to {final_path}")
+            
+            # Check if source file exists and is readable
+            if not os.path.exists(gz_path):
+                logging.error(f"Source file {gz_path} does not exist")
+                return False
+                
+            if not os.access(gz_path, os.R_OK):
+                logging.error(f"Source file {gz_path} is not readable")
+                return False
+
+            # Extract the file
+            with gzip.open(gz_path, 'rb') as f_in:
+                # Test if the gzip file is valid
+                try:
+                    f_in.read(1)
+                    f_in.seek(0)
+                except Exception as e:
+                    logging.error(f"Invalid gzip file {gz_path}: {e}")
+                    return False
+
+                # Extract the file
+                with open(final_path, 'wb') as f_out:
+                    shutil.copyfileobj(f_in, f_out)
+
+            # Set executable permissions
+            os.chmod(final_path, 0o755)
+            logging.info(f"Successfully extracted {gz_path} to {final_path}")
+            
+            # Remove the gzip file
+            os.remove(gz_path)
+            return True
+
+        except Exception as e:
+            logging.error(f"Extraction error for {gz_path}: {e}")
+            return False
+
+    def download(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+        """
+        Main method to download and set up FFmpeg executables.
+
+        Returns:
+            Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
+        """
+        if self.os_name == 'linux':
+            try:
+                # Attempt to install FFmpeg using apt
+                console.print("[bold blue]Trying to install FFmpeg using 'sudo apt install ffmpeg'[/]")
+                result = subprocess.run(
+                    ['sudo', 'apt', 'install', '-y', 'ffmpeg'],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True
+                )
+                if result.returncode == 0:
+                    ffmpeg_path = shutil.which('ffmpeg')
+                    ffprobe_path = shutil.which('ffprobe')
+
+                    if ffmpeg_path and ffprobe_path:
+                        console.print("[bold green]FFmpeg successfully installed via apt[/]")
+                        return ffmpeg_path, ffprobe_path, None
+                else:
+                    console.print("[bold yellow]Failed to install FFmpeg via apt. Proceeding with static download.[/]")
+                    
+            except Exception as e:
+                logging.error(f"Error during 'sudo apt install ffmpeg': {e}")
+                console.print("[bold red]Error during 'sudo apt install ffmpeg'. Proceeding with static download.[/]")
+
+        # Proceed with static download if apt installation fails or is not applicable
+        config = FFMPEG_CONFIGURATION[self.os_name]
+        executables = [exe.format(arch=self.arch) for exe in config['executables']]
+        successful_extractions = []
+
+        for executable in executables:
+            try:
+                download_url = f"https://github.com/eugeneware/ffmpeg-static/releases/latest/download/{executable}.gz"
+                download_path = os.path.join(self.base_dir, f"{executable}.gz")
+                final_path = os.path.join(self.base_dir, executable)
+                
+                # Log the current operation
+                logging.info(f"Processing {executable}")
+                console.print(f"[bold blue]Downloading {executable} from GitHub[/]")
+                
+                # Download the file
+                if not self._download_file(download_url, download_path):
+                    console.print(f"[bold red]Failed to download {executable}[/]")
+                    continue
+
+                # Extract the file
+                if self._extract_file(download_path, final_path):
+                    successful_extractions.append(final_path)
+                    console.print(f"[bold green]Successfully installed {executable}[/]")
+                else:
+                    console.print(f"[bold red]Failed to extract {executable}[/]")
+
+            except Exception as e:
+                logging.error(f"Error processing {executable}: {e}")
+                console.print(f"[bold red]Error processing {executable}: {str(e)}[/]")
+                continue
+
+        # Return the results based on successful extractions
+        return (
+            successful_extractions[0] if len(successful_extractions) > 0 else None,
+            successful_extractions[1] if len(successful_extractions) > 1 else None,
+            None  # ffplay is not included in the current implementation
+        )
+
+def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """
+    Check for FFmpeg executables in the system and download them if not found.
+    Enhanced detection for macOS systems.
+
+    Returns:
+        Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
+    """
+    try:
+        system_platform = platform.system().lower()
+        
+        # Special handling for macOS
+        if system_platform == 'darwin':
+
+            # Common installation paths on macOS
+            potential_paths = [
+                '/usr/local/bin',                               # Homebrew default
+                '/opt/homebrew/bin',                            # Apple Silicon Homebrew
+                '/usr/bin',                                     # System default
+                os.path.expanduser('~/Applications/binary'),    # Custom installation
+                '/Applications/binary'                          # Custom installation
+            ]
+            
+            for path in potential_paths:
+                ffmpeg_path = os.path.join(path, 'ffmpeg')
+                ffprobe_path = os.path.join(path, 'ffprobe')
+                ffplay_path = os.path.join(path, 'ffplay')
+                
+                if (os.path.exists(ffmpeg_path) and os.path.exists(ffprobe_path) and 
+                    os.access(ffmpeg_path, os.X_OK) and os.access(ffprobe_path, os.X_OK)):
+                    
+                    # Return found executables, with ffplay being optional
+                    ffplay_path = ffplay_path if os.path.exists(ffplay_path) else None
+                    return ffmpeg_path, ffprobe_path, ffplay_path
+
+        # Windows detection
+        elif system_platform == 'windows':
+            try:
+                ffmpeg_path = subprocess.check_output(
+                    ['where', 'ffmpeg'], stderr=subprocess.DEVNULL, text=True
+                ).strip().split('\n')[0]
+                
+                ffprobe_path = subprocess.check_output(
+                    ['where', 'ffprobe'], stderr=subprocess.DEVNULL, text=True
+                ).strip().split('\n')[0]
+                
+                ffplay_path = subprocess.check_output(
+                    ['where', 'ffplay'], stderr=subprocess.DEVNULL, text=True
+                ).strip().split('\n')[0]
+
+                return ffmpeg_path, ffprobe_path, ffplay_path
+            
+            except subprocess.CalledProcessError:
+                logging.warning("One or more FFmpeg binaries were not found with command where")
+
+        # Linux detection
+        else:
+            ffmpeg_path = shutil.which('ffmpeg')
+            ffprobe_path = shutil.which('ffprobe')
+            ffplay_path = shutil.which('ffplay')
+            
+            if ffmpeg_path and ffprobe_path:
+                return ffmpeg_path, ffprobe_path, ffplay_path
+
+        # If executables were not found, attempt to download FFmpeg
+        downloader = FFMPEGDownloader()
+        return downloader.download()
+
+    except Exception as e:
+        logging.error(f"Error checking or downloading FFmpeg executables: {e}")
+        return None, None, None

SpotDown/utils/file_utils.py

@@ -1,15 +1,30 @@
 # 05.04.2024
 
 import re
+import os
+import sys
+import glob
 from pathlib import Path
 from typing import Optional
+import platform
 
 
 # External imports
+from rich.console import Console
 from unidecode import unidecode
 
 
+# Internal logic
+from .ffmpeg_installer import check_ffmpeg
+
+
+# Variable
+console = Console()
+
+
 class FileUtils:
+    ffmpeg_path = None
+    ffprobe_path = None
 
     @staticmethod
     def get_music_folder() -> Path:
@@ -126,4 +141,93 @@ class FileUtils:
             return files[0] if files else None
         
         except Exception:
-            return None
+            return None
+    
+    @staticmethod
+    def get_binary_directory():
+        """Get the binary directory based on OS."""
+        system = platform.system().lower()
+        home = os.path.expanduser('~')
+
+        if system == 'windows':
+            return os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary')
+        elif system == 'darwin':
+            return os.path.join(home, 'Applications', 'binary')
+        else:  # linux
+            return os.path.join(home, '.local', 'bin', 'binary')
+        
+    @staticmethod
+    def get_ffmpeg_path():
+        """Returns the path of FFmpeg."""
+        return FileUtils.ffmpeg_path
+
+    @staticmethod
+    def get_ffprobe_path():
+        """Returns the path of FFprobe."""
+        return FileUtils.ffprobe_path
+    
+    @staticmethod
+    def check_python_version():
+        """
+        Check if the installed Python is the official CPython distribution.
+        Exits with a message if not the official version.
+        """
+        python_implementation = platform.python_implementation()
+        python_version = platform.python_version()
+
+        if python_implementation != "CPython":
+            console.print(f"[bold red]Warning: You are using a non-official Python distribution: {python_implementation}.[/bold red]")
+            console.print("Please install the official Python from [bold blue]https://www.python.org[/bold blue] and try again.", style="bold yellow")
+            sys.exit(0)
+
+        console.print(f"[cyan]Python version: [bold red]{python_version}[/bold red]")
+
+    @staticmethod
+    def get_system_summary():
+        FileUtils.check_python_version()
+
+        # FFmpeg detection
+        binary_dir = FileUtils.get_binary_directory()
+        system = platform.system().lower()
+        arch = platform.machine().lower()
+
+        # Map architecture names
+        arch_map = {
+            'amd64': 'x64',
+            'x86_64': 'x64',
+            'x64': 'x64',
+            'arm64': 'arm64',
+            'aarch64': 'arm64',
+            'armv7l': 'arm',
+            'i386': 'ia32',
+            'i686': 'ia32'
+        }
+        arch = arch_map.get(arch, arch)
+
+        # Check FFmpeg binaries
+        if os.path.exists(binary_dir):
+            ffmpeg_files = glob.glob(os.path.join(binary_dir, f'*ffmpeg*{arch}*'))
+            ffprobe_files = glob.glob(os.path.join(binary_dir, f'*ffprobe*{arch}*'))
+
+            if ffmpeg_files and ffprobe_files:
+                FileUtils.ffmpeg_path = ffmpeg_files[0]
+                FileUtils.ffprobe_path = ffprobe_files[0]
+
+                if system != 'windows':
+                    os.chmod(FileUtils.ffmpeg_path, 0o755)
+                    os.chmod(FileUtils.ffprobe_path, 0o755)
+            else:
+                FileUtils.ffmpeg_path, FileUtils.ffprobe_path, ffplay_path = check_ffmpeg()
+        else:
+            FileUtils.ffmpeg_path, FileUtils.ffprobe_path, ffplay_path = check_ffmpeg()
+
+        if not FileUtils.ffmpeg_path or not FileUtils.ffprobe_path:
+            console.log("[red]Can't locate ffmpeg or ffprobe")
+            sys.exit(0)
+
+        ffmpeg_str = f"'{FileUtils.ffmpeg_path}'" if FileUtils.ffmpeg_path else "None"
+        ffprobe_str = f"'{FileUtils.ffprobe_path}'" if FileUtils.ffprobe_path else "None"
+        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]{ffmpeg_str}[/bold yellow][white], [red]ffprobe [bold yellow]{ffprobe_str}[/bold yellow][white].")
+
+
+file_utils = FileUtils()

{spotdown-1.0.0.dist-info → spotdown-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SpotDown
-Version: 1.0.0
+Version: 1.3.0
 Summary: A command-line program to download music
 Home-page: https://github.com/Arrowar/spotdown
 Author: Arrowar
@@ -13,12 +13,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich
 Requires-Dist: httpx
-Requires-Dist: playwright
 Requires-Dist: unidecode
 Requires-Dist: ua-generator
 Requires-Dist: unidecode
 Requires-Dist: yt-dlp
 Requires-Dist: Pillow
+Requires-Dist: spotipy
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -42,6 +42,13 @@ Dynamic: summary
 
 [![Donate PayPal](https://img.shields.io/badge/💳_Donate-PayPal-00457C?style=for-the-badge&logo=paypal&logoColor=white&labelColor=2d3748)](https://www.paypal.com/donate/?hosted_button_id=UXTWMT8P6HE2C)
 
+## 🚀 Download & Install
+
+[![Windows](https://img.shields.io/badge/🪟_Windows-0078D4?style=for-the-badge&logo=windows&logoColor=white&labelColor=2d3748)](https://github.com/Arrowar/spotdown/releases/latest/download/spotdown_win.exe)
+[![macOS](https://img.shields.io/badge/🍎_macOS-000000?style=for-the-badge&logo=apple&logoColor=white&labelColor=2d3748)](https://github.com/Arrowar/spotdown/releases/latest/download/spotdown_mac)
+[![Linux latest](https://img.shields.io/badge/🐧_Linux_latest-FCC624?style=for-the-badge&logo=linux&logoColor=black&labelColor=2d3748)](https://github.com/Arrowar/spotdown/releases/latest/download/spotdown_linux_latest)
+[![Linux 22.04](https://img.shields.io/badge/🐧_Linux_22.04-FCC624?style=for-the-badge&logo=linux&logoColor=black&labelColor=2d3748)](https://github.com/Arrowar/spotdown/releases/latest/download/spotdown_linux_previous)
+
 ---
 
 *⚡ **Quick Start:** `pip install spotdown && spotdown`*
@@ -52,9 +59,9 @@ Dynamic: summary
 
 - [✨ Features](#features)
 - [🛠️ Installation](#️installation)
+- [⚙️ Setup](#setup)
 - [⚙️ Configuration](#configuration)
 - [💻 Usage](#usage)
-- [⚠️ Disclaimer](#disclaimer)
 
 ## Features
 
@@ -99,6 +106,24 @@ After installation, run this one-time setup command:
 playwright install chromium
 ```
 
+## Setup
+
+1. Go to the [Spotify Developer Dashboard](https://developer.spotify.com/dashboard/)
+2. Log in and create a new application
+3. Copy your **Client ID** and **Client Secret**
+4. Create a file named `.env` in the SpotDown directory with the following content:
+
+```
+SPOTIFY_CLIENT_ID=your_client_id_here
+SPOTIPY_CLIENT_SECRET=your_client_secret_here
+```
+
+5. Save the file. SpotDown will automatically load these credentials.
+
+### Error Handling
+- If the credentials are missing, SpotDown will log an error and exit.
+- If the credentials are invalid, SpotDown will log an error and exit. Please double-check your `.env` file and credentials.
+
 ## Configuration
 
 SpotDown uses a JSON configuration file with the following structure:
@@ -112,10 +137,6 @@ SpotDown uses a JSON configuration file with the following structure:
     "DOWNLOAD": {
         "auto_first": false,
         "quality": "320K"
-    },
-    "BROWSER": {
-        "headless": true,
-        "timeout": 8
     }
 }
 ```
@@ -130,10 +151,6 @@ SpotDown uses a JSON configuration file with the following structure:
 - **`auto_first`**: Automatically select first search result
 - **`quality`**: Audio quality (320K recommended for best quality)
 
-#### BROWSER Settings
-- **`headless`**: Run browser in background (recommended: true)
-- **`timeout`**: Browser timeout in seconds
-
 ## Usage
 
 ### Starting SpotDown

spotdown-1.3.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+SpotDown/__init__.py,sha256=ebKRxKh14_cO7UWvOgE4R1RqIFBdekg50xtzc1LU6DU,59
+SpotDown/main.py,sha256=qTNHAyXdxe6BMwwTMssuFBdpfdxMEYwFM6LweGiBBYI,5084
+SpotDown/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+SpotDown/downloader/youtube_downloader.py,sha256=i4Iq7jFKD8dFxpWHPcxgE2_hykwHf6TQXZSal_FHUAY,5557
+SpotDown/extractor/__init__.py,sha256=pQtkjMzB4D8AVEFQ3pnp_UQI-KbYaQhZbKuDnMImN0o,161
+SpotDown/extractor/spotify_extractor.py,sha256=gI4iJvs_MYV7MO-zcuUXavqtQo5jDAuXNqXs2ScTjDE,7755
+SpotDown/extractor/youtube_extractor.py,sha256=v1JDV_NHBpc56UU5kk4tfaRjPB0Jy23_F5r4LE2gOlU,10442
+SpotDown/upload/version.py,sha256=uvgDGChIXb3JAYtO_GQPGc-au8t6sDfzX40RkqQex14,161
+SpotDown/utils/__init__.py,sha256=ZhJJhNQkUd4XG6vkoVQSC3qvSlaArhsRjscn4bfC9WA,128
+SpotDown/utils/config_json.py,sha256=q_9lQhGLmsaZfM1WU-kOMByf8y1Wt9QWnZT5g_IR4Lg,7447
+SpotDown/utils/console_utils.py,sha256=oW7jD3UjrSlYoZ8R7VJAV8WPymD2NZGs1SS5BUUQ3Zk,6825
+SpotDown/utils/ffmpeg_installer.py,sha256=kFcjr9HqQyxu01mpWumt8d_0D9aEkxMb5sSBJqSkR0w,14889
+SpotDown/utils/file_utils.py,sha256=eNb0JT99FyeMGCoVzFkyhF-39FZE-yogwtUgKSbaTCs,7132
+SpotDown/utils/headers.py,sha256=nSF2rEQEl7g2tIJMjz9c5mAQfLiugfWwdlJBhtMfBSo,312
+SpotDown/utils/logger.py,sha256=Bzje-6nwGxL7TzMVhJfhPe7mv-9upYylFvx_zjWJX3M,3290
+spotdown-1.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spotdown-1.3.0.dist-info/METADATA,sha256=apC3RZd0_akzY0ujIZ_EdcdqWkBsx-9gxMM0CaUh9CA,6836
+spotdown-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+spotdown-1.3.0.dist-info/entry_points.txt,sha256=qHq6M94aU-XQL0y9R4yFKoqnHjU2nsN53Bj4OuHp3vQ,47
+spotdown-1.3.0.dist-info/top_level.txt,sha256=1E-ZZ8rsrXmBPAsseY_kEfHfNo9w9PtSCaS6pM63-tw,9
+spotdown-1.3.0.dist-info/RECORD,,

spotdown-1.0.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-SpotDown/__init__.py,sha256=ebKRxKh14_cO7UWvOgE4R1RqIFBdekg50xtzc1LU6DU,59
-SpotDown/main.py,sha256=HWhik7Kr1OAnvJPNvaqpO_YqHWCbtyaUIVzaicL3jhg,4999
-SpotDown/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-SpotDown/downloader/youtube_downloader.py,sha256=7Qs1IhSKZqMCm5tuMSCoI-BItGO-28aRLmAdcchcq7w,5492
-SpotDown/extractor/__init__.py,sha256=pQtkjMzB4D8AVEFQ3pnp_UQI-KbYaQhZbKuDnMImN0o,161
-SpotDown/extractor/spotify_extractor.py,sha256=55jndORplGMNb2GiRzo2MkN_v_OrfpEqpKnGjzy6BQo,15130
-SpotDown/extractor/youtube_extractor.py,sha256=v1JDV_NHBpc56UU5kk4tfaRjPB0Jy23_F5r4LE2gOlU,10442
-SpotDown/upload/version.py,sha256=ff4spj6Qs71lt0V8utidpPgidmzTDRCnhGGafOJXvoU,161
-SpotDown/utils/__init__.py,sha256=ZhJJhNQkUd4XG6vkoVQSC3qvSlaArhsRjscn4bfC9WA,128
-SpotDown/utils/config_json.py,sha256=q_9lQhGLmsaZfM1WU-kOMByf8y1Wt9QWnZT5g_IR4Lg,7447
-SpotDown/utils/console_utils.py,sha256=A1zNRyB9yG7BqWzlQgfVZ25cWUjMmYQooRKyeqVlcDw,6823
-SpotDown/utils/file_utils.py,sha256=Lgq_Nu1r-bVIH37H7Mx73WgotN_nrgMUAT2STDyEYoY,3495
-SpotDown/utils/headers.py,sha256=nSF2rEQEl7g2tIJMjz9c5mAQfLiugfWwdlJBhtMfBSo,312
-SpotDown/utils/logger.py,sha256=Bzje-6nwGxL7TzMVhJfhPe7mv-9upYylFvx_zjWJX3M,3290
-spotdown-1.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spotdown-1.0.0.dist-info/METADATA,sha256=DTDziAY2-Bql3Vews8smKT78jQC6qQfXSjFuajbeL1A,5522
-spotdown-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-spotdown-1.0.0.dist-info/entry_points.txt,sha256=qHq6M94aU-XQL0y9R4yFKoqnHjU2nsN53Bj4OuHp3vQ,47
-spotdown-1.0.0.dist-info/top_level.txt,sha256=1E-ZZ8rsrXmBPAsseY_kEfHfNo9w9PtSCaS6pM63-tw,9
-spotdown-1.0.0.dist-info/RECORD,,