SpotDown 0.0.1__py3-none-any.whl → 0.0.8__py3-none-any.whl

SpotDown/utils/console_utils.py

@@ -0,0 +1,188 @@
+# 05.04.2024
+
+import os
+import platform
+from typing import Dict, List
+
+
+# External imports
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+# Internal utils
+from SpotDown.utils.config_json import config_manager
+
+
+
+# Variable
+CLEAN_CONSOLE = config_manager.get('DEFAULT', 'clean_console')
+SHOW_MESSAGE = config_manager.get('DEFAULT', 'show_message')
+AUTO_FIRST = config_manager.get('DOWNLOAD', 'auto_first')
+
+
+class ConsoleUtils:  
+    def __init__(self):
+        self.console = Console()
+    
+    def display_spotify_info(self, spotify_info: Dict):
+        """
+        Display Spotify information
+        
+        Args:
+            spotify_info (Dict): Spotify track data
+        """
+        self.console.print("[bold green]Spotify Track Information: [/bold green]")
+        self.console.print(f"[cyan]Title: [red]{spotify_info['title']}[/red]")
+        self.console.print(f"[cyan]Artist: [red]{spotify_info['artist']}[/red]")
+        
+        if spotify_info.get('album'):
+            self.console.print(f"[cyan]Album: [red]{spotify_info['album']}[/red]")
+        if spotify_info.get('year'):
+            self.console.print(f"[cyan]Year: [red]{spotify_info['year']}[/red]")
+        if spotify_info.get('duration_formatted'):
+            self.console.print(f"[cyan]Duration: [red]{spotify_info['duration_formatted']}[/red]")
+        if spotify_info.get('label'):
+            self.console.print(f"[cyan]Label: [red]{spotify_info['label']}[/red]")
+
+    def display_youtube_results(self, youtube_results: List[Dict]):
+        """
+        Display YouTube results
+        
+        Args:
+            youtube_results (List[Dict]): List of YouTube videos
+        """
+        if not youtube_results:
+            self.console.print("[red]No results found")
+            return
+            
+        for i, video in enumerate(youtube_results, 1):
+            self.console.print(f"[green]{i}. {video['title']}[/green], Channel: [cyan]{video['channel']}[/cyan], Duration: [red]{video['duration_formatted']}[/red], Difference: [yellow]{video.get('duration_difference', 'N/A')}s[/yellow]")
+
+    def show_download_menu(self, results_count: int):
+        """
+        Show download selection menu
+        
+        Args:
+            results_count (int): Number of available results
+        """
+        self.console.print("\n[bold cyan]Download selection: [/bold cyan]")
+        self.console.print("[dim]Options:[/dim]")
+        self.console.print(f"• [green]1-{results_count}[/green]: Download the corresponding video")
+        self.console.print("• [yellow]ENTER[/yellow]: Automatically download the first (most similar)")
+        self.console.print("• [red]0[/red]: Exit without downloading")
+    
+    def get_download_choice(self, max_results: int) -> int:
+        """
+        Get user choice for download
+        
+        Args:
+            max_results (int): Maximum number of results
+            
+        Returns:
+            int: User choice (0 = exit, 1-n = video)
+        """
+        if AUTO_FIRST:
+            return 1
+        
+        while True:
+            try:
+                choice = Prompt.ask(
+                    "\n[bold purple]Which video do you want to download?[/bold purple]",
+                    default="1"
+                ).strip()
+                
+                if choice == "0":
+                    return 0
+                
+                # Default: first video
+                if choice == "" or choice == "1":
+                    return 1
+                
+                # Check for valid number
+                choice_num = int(choice)
+                if 1 <= choice_num <= max_results:
+                    return choice_num
+                else:
+                    self.console.print(f"[red]Invalid choice. Enter a number between 1 and {max_results}[/red]")
+                    continue
+                    
+            except ValueError:
+                self.console.print("[red]Enter a valid number[/red]")
+                continue
+    
+    def show_download_info(self, music_folder, filename: str):
+        """
+        Show download information
+        
+        Args:
+            music_folder: Destination folder
+            filename (str): File name
+        """
+        self.console.print(f"[blue]File name: {filename}[/blue]")
+        self.console.print(f"[blue]Destination folder: {music_folder}[/blue]")
+    
+    def show_download_start(self, video_title: str, video_url: str):
+        """
+        Show download start
+        
+        Args:
+            video_title (str): Video title
+            video_url (str): Video URL
+        """
+        self.console.print(f"[yellow]\nDownloading: {video_title}[/yellow]")
+        self.console.print(f"[dim]URL: {video_url}[/dim]")
+    
+    def show_success(self, message: str):
+        """Show success message"""
+        self.console.print(f"[green]{message}[/green]")
+    
+    def show_error(self, message: str):
+        """Show error message"""
+        self.console.print(f"[red]{message}[/red]")
+    
+    def show_warning(self, message: str):
+        """Show warning message"""
+        self.console.print(f"[yellow]{message}[/yellow]")
+    
+    def show_info(self, message: str):
+        """Show informational message"""
+        self.console.print(f"[blue]{message}[/blue]")
+    
+    def get_spotify_url(self) -> str:
+        """
+        Get Spotify URL from the user
+        
+        Returns:
+            str: Entered Spotify URL
+        """
+        while True:
+            url = Prompt.ask("[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]")
+                continue
+
+            if "/track/" in url or "/playlist/" in url:
+                return url
+            
+            self.console.print("[red]Invalid format. Please enter a valid Spotify track URL.[/red]")
+
+    def start_message(self):
+        """Display a stylized start message in the console."""
+        
+        msg = r'''                                                                               
+                 _____                                                 _   _ ___     
+                |  _  |___ ___ ___ _ _ _ ___ ___    _ _    ___ ___ ___| |_|_|  _|_ _ 
+                |     |  _|  _| . | | | | .'|  _|  |_'_|  |_ -| . | . |  _| |  _| | |
+                |__|__|_| |_| |___|_____|__,|_|    |_,_|  |___|  _|___|_| |_|_| |_  |
+                                                              |_|               |___|
+        '''
+
+        if CLEAN_CONSOLE:
+            os.system("cls" if platform.system() == 'Windows' else "clear")
+
+        if SHOW_MESSAGE:
+            self.console.print(f"[purple]{msg}")
+            separator = "_" * (self.console.width - 2)
+            self.console.print(f"[cyan]{separator}[/cyan]\n")

SpotDown/utils/file_utils.py

@@ -0,0 +1,129 @@
+# 05.04.2024
+
+import re
+from pathlib import Path
+from typing import Optional
+
+
+# External imports
+from unidecode import unidecode
+
+
+class FileUtils:
+
+    @staticmethod
+    def get_music_folder() -> Path:
+        """
+        Gets the path to the Music folder.
+        
+        Returns:
+            Path: Path to the Music folder
+        """
+        music_folder = Path.home() / "Music"
+        if not music_folder.exists():
+
+            # If "Music" does not exist, check for Italian "Musica" and rename it to "Music"
+            musica_folder = Path.home() / "Musica"
+            if musica_folder.exists():
+                musica_folder.rename(music_folder)
+            else:
+                music_folder.mkdir(exist_ok=True)
+
+        return music_folder
+    
+    @staticmethod
+    def sanitize_filename(filename: str) -> str:
+        """
+        Cleans the filename of invalid characters and applies transliteration.
+        
+        Args:
+            filename (str): Filename to clean
+            
+        Returns:
+            str: Cleaned filename
+        """
+        # Transliterate to ASCII
+        filename = unidecode(filename)
+        
+        # Remove/replace invalid characters for filenames
+        invalid_chars = '<>:"/\\|?*'
+        for char in invalid_chars:
+            filename = filename.replace(char, '')
+        
+        # Remove multiple spaces and trim
+        filename = re.sub(r'\s+', ' ', filename).strip()
+        
+        if len(filename) > 200:
+            filename = filename[:200]
+            
+        return filename
+    
+    @staticmethod
+    def create_filename(artist: str, title: str, extension: str = "mp3") -> str:
+        """
+        Creates a filename in the format: Artist - Title.extension
+        
+        Args:
+            artist (str): Artist name
+            title (str): Song title
+            extension (str): File extension
+            
+        Returns:
+            str: Formatted filename
+        """
+        clean_artist = FileUtils.sanitize_filename(artist)
+        clean_title = FileUtils.sanitize_filename(title)
+        
+        # Create format: Artist - Title
+        filename = f"{clean_artist} - {clean_title}"
+        
+        return filename
+    
+    @staticmethod
+    def get_download_path(artist: str, title: str) -> Path:
+        """
+        Gets the full path for the download.
+        
+        Args:
+            artist (str): Artist name
+            title (str): Song title
+            
+        Returns:
+            Path: Full file path
+        """
+        music_folder = FileUtils.get_music_folder()
+        filename = FileUtils.create_filename(artist, title)
+
+        return music_folder / filename
+    
+    @staticmethod
+    def file_exists(filepath: Path) -> bool:
+        """
+        Checks if a file exists.
+        
+        Args:
+            filepath (Path): File path
+            
+        Returns:
+            bool: True if the file exists
+        """
+        return filepath.exists()
+    
+    @staticmethod
+    def find_downloaded_file(base_path: Path, pattern: str) -> Optional[Path]:
+        """
+        Finds a downloaded file using a pattern.
+        
+        Args:
+            base_path (Path): Base folder for the search
+            pattern (str): Search pattern
+            
+        Returns:
+            Path: First file found or None
+        """
+        try:
+            files = list(base_path.glob(pattern))
+            return files[0] if files else None
+        
+        except Exception:
+            return None

SpotDown/utils/headers.py

@@ -0,0 +1,18 @@
+# 05.04.2024
+
+
+# External library
+import ua_generator
+
+
+# Variable
+ua =  ua_generator.generate(device='desktop', browser=('chrome', 'edge'))
+
+
+def get_userAgent() -> str:
+    return ua_generator.generate(device='desktop', browser=('chrome', 'edge')).text
+
+
+
+def get_headers() -> dict:
+    return ua.headers.get()