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

SpotDown/extractor/youtube_extractor.py

@@ -3,6 +3,7 @@
 import re
 import json
 import difflib
+import logging
 from urllib.parse import quote_plus
 from typing import Dict, List, Optional
 
@@ -42,6 +43,7 @@ class YouTubeExtractor:
             List[Dict]: List of found videos
         """
         try:
+            logging.info(f"Starting YouTube search for query: {query}")
             search_url = f"https://www.youtube.com/results?search_query={quote_plus(query)}"
             console.print(f"\n[bold blue]Searching on YouTube:[/bold blue] {query}")
 
@@ -49,9 +51,12 @@ class YouTubeExtractor:
                 response = client.get(search_url, headers={"User-Agent": get_userAgent()})
                 html = response.text
 
-            return self._extract_youtube_videos(html, max_results)
+            results = self._extract_youtube_videos(html, max_results)
+            logging.info(f"Found {len(results)} results for query: {query}")
+            return results
 
         except Exception as e:
+            logging.error(f"YouTube search error: {e}")
             print(f"YouTube search error: {e}")
             return []
 
@@ -63,6 +68,7 @@ class YouTubeExtractor:
             youtube_results (List[Dict]): List of YouTube videos
             target_duration (int): Target duration in seconds
         """
+        logging.info(f"Sorting {len(youtube_results)} results by duration similarity to {target_duration}s")
         for result in youtube_results:
             if result.get('duration_seconds') is not None:
                 result['duration_difference'] = abs(result['duration_seconds'] - target_duration)
@@ -80,6 +86,7 @@ class YouTubeExtractor:
             youtube_results (List[Dict]): List of YouTube videos
             spotify_info (Dict): Spotify track info
         """
+        logging.info(f"Sorting {len(youtube_results)} results by affinity and duration using Spotify info")
         target_duration = spotify_info.get('duration_seconds')
         target_title = spotify_info.get('title', '').lower()
         target_artist = spotify_info.get('artist', '').lower()
@@ -123,7 +130,9 @@ class YouTubeExtractor:
         """Extract videos from YouTube HTML"""
         try:
             yt_match = re.search(r'var ytInitialData = ({.+?});', html, re.DOTALL)
+
             if not yt_match:
+                logging.warning("ytInitialData not found in HTML")
                 return []
 
             yt_data = json.loads(yt_match.group(1))
@@ -152,9 +161,11 @@ class YouTubeExtractor:
                 if len(results) >= max_results:
                     break
 
+            logging.info(f"Extracted {len(results)} video(s) from HTML")
             return results
 
         except Exception as e:
+            logging.error(f"Video extraction error: {e}")
             print(f"Video extraction error: {e}")
             return []
 
@@ -163,6 +174,7 @@ class YouTubeExtractor:
         try:
             video_id = video_data.get('videoId')
             if not video_id:
+                logging.warning("videoId not found in video_data")
                 return None
 
             # Title
@@ -187,6 +199,7 @@ class YouTubeExtractor:
             # Published date
             published = self._extract_text(video_data.get('publishedTimeText', {}))
 
+            logging.info(f"Parsed video: {title} (ID: {video_id})")
             return {
                 'video_id': video_id,
                 'url': f'https://www.youtube.com/watch?v={video_id}',
@@ -200,6 +213,7 @@ class YouTubeExtractor:
             }
 
         except Exception as e:
+            logging.error(f"Video parsing error: {e}")
             print(f"Video parsing error: {e}")
             return None
 

SpotDown/main.py

@@ -1,12 +1,14 @@
 # 05.04.2024
 
 import time
-import logging
 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
 from SpotDown.extractor.youtube_extractor import YouTubeExtractor
 from SpotDown.downloader.youtube_downloader import YouTubeDownloader
@@ -17,11 +19,6 @@ from SpotDown.downloader.youtube_downloader import YouTubeDownloader
 console = ConsoleUtils()
 
 
-def setup_logging():
-    """Initialize basic logging configuration"""
-    logging.basicConfig(level=logging.ERROR)
-
-
 def extract_spotify_data(spotify_url: str, max_retry: int = 3) -> Optional[Dict]:
     """Extract data from Spotify URL with retry mechanism"""
     for attempt in range(1, max_retry + 1):
@@ -108,11 +105,12 @@ def handle_single_track_download(spotify_info: Dict, max_results: int):
 
 def run():
     """Main execution function"""
-    setup_logging()
+    Logger()
 
     console = ConsoleUtils()
     console.start_message()
-    #git_update()
+    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__ = '0.1.1'
+__version__ = '1.3.0'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download music'
-__copyright__ = 'Copyright 2025'
+__copyright__ = 'Copyright 2025'

SpotDown/utils/config_json.py

@@ -44,7 +44,7 @@ class ConfigManager:
         
     def download_config(self) -> None:
         """Download config.json from the Arrowar/SpotDown GitHub repository."""
-        url = "https://raw.githubusercontent.com/Arrowar/SpotDown/main/config.json"
+        url = "https://raw.githubusercontent.com/Arrowar/SpotDown/refs/heads/main/config.json"
         try:
             with httpx.Client(timeout=10, headers=get_headers()) as client:
                 response = client.get(url)
@@ -220,4 +220,4 @@ class ConfigManager:
         return section in config_source
 
 
-config_manager = ConfigManager()
+config_manager = ConfigManager()

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()