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

SpotDown/downloader/youtube_downloader.py

@@ -1,6 +1,7 @@
 # 05.04.2024
 
 import io
+import logging
 import subprocess
 from typing import Dict
 
@@ -44,6 +45,7 @@ class YouTubeDownloader:
                 spotify_info.get('title', video_info.get('title', 'Unknown Title'))
             )
             output_path = music_folder / f"{filename}.%(ext)s"
+            logging.info(f"Start download: {video_info.get('url')} as {output_path}")
 
             # Download cover image if available
             cover_path = None
@@ -65,12 +67,15 @@ class YouTubeDownloader:
                                 img.save(cover_path, "JPEG")
 
                             self.console.print(f"[blue]Downloaded thumbnail: {cover_path}[/blue]")
+                            logging.info(f"Downloaded thumbnail: {cover_path}")
 
                         else:
                             cover_path = None
+                            logging.warning(f"Failed to download cover image, status code: {resp.status_code}")
                             
                 except Exception as e:
                     self.console.print(f"[yellow]Unable to download cover: {e}[/yellow]")
+                    logging.error(f"Unable to download cover: {e}")
                     cover_path = None
 
             ytdlp_options = [
@@ -94,6 +99,7 @@ class YouTubeDownloader:
                 console=self.console
             ) as progress:
                 task = progress.add_task("Downloading...", total=None)
+                logging.info(f"Running yt-dlp with options: {ytdlp_options}")
                 process = subprocess.run(
                     ytdlp_options,
                     capture_output=True,
@@ -102,30 +108,37 @@ class YouTubeDownloader:
                 progress.remove_task(task)
 
             if process.returncode == 0:
+                logging.info("yt-dlp finished successfully")
 
                 # Find the downloaded file
                 downloaded_files = list(music_folder.glob(f"{filename}.*"))
                 if downloaded_files:
                     self.console.print("[red]Download completed![/red]")
+                    logging.info(f"Download completed: {downloaded_files[0]}")
 
                     # Remove cover file after embedding
                     if cover_path and cover_path.exists():
                         try:
                             cover_path.unlink()
-                        except Exception:
-                            pass
-                        
+                            logging.info(f"Removed temporary cover file: {cover_path}")
+
+                        except Exception as ex:
+                            logging.warning(f"Failed to remove cover file: {ex}")
+
                     return True
                 
                 else:
                     self.console.print("[yellow]Download apparently succeeded but file not found[/yellow]")
+                    logging.error("Download apparently succeeded but file not found")
                     return False
-                
+            
             else:
                 self.console.print("[red]Download error:[/red]")
                 self.console.print(f"[red]{process.stderr}[/red]")
+                logging.error(f"yt-dlp error: {process.stderr}")
                 return False
 
         except Exception as e:
             self.console.print(f"[red]Error during download: {e}[/red]")
+            logging.error(f"Error during download: {e}")
             return False

SpotDown/extractor/spotify_extractor.py

@@ -31,9 +31,11 @@ class SpotifyExtractor:
         self.user_agent = get_userAgent()
         self.total_songs = None
         self.playlist_items = []
+        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(
@@ -44,6 +46,7 @@ class SpotifyExtractor:
 
     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:
@@ -61,18 +64,21 @@ class SpotifyExtractor:
             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)
 
@@ -91,18 +97,22 @@ class SpotifyExtractor:
                     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
 
         except Exception as e:
+            logging.error(f"Spotify extraction error: {e}")
             console.print(f"[cyan]Spotify extraction error: {e}")
             return None
 
     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):
@@ -130,20 +140,24 @@ class SpotifyExtractor:
             # 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
 
         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
 
@@ -154,6 +168,7 @@ class SpotifyExtractor:
             return bool(track_union.get("name") and track_union.get("firstArtist", {}).get("items"))
         
         except Exception:
+            logging.error("Error validating track data")
             return False
 
     def _parse_spotify_response(self, response: Dict) -> Dict:
@@ -202,6 +217,7 @@ class SpotifyExtractor:
             }
 
         except Exception as e:
+            logging.error(f"Error parsing Spotify response: {e}")
             console.print(f"[cyan]Error parsing Spotify response: {e}")
             return {}
 
@@ -220,6 +236,7 @@ class SpotifyExtractor:
 
     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...")
@@ -242,6 +259,7 @@ class SpotifyExtractor:
                                 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)
@@ -249,14 +267,17 @@ class SpotifyExtractor:
             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 []
 
@@ -281,9 +302,11 @@ class SpotifyExtractor:
                     unique[key] = item
             
             unique_tracks = list(unique.values())
+            logging.info(f"Extracted {len(unique_tracks)} 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 []
 
@@ -327,5 +350,6 @@ class SpotifyExtractor:
             }
         
         except Exception as e:
+            logging.error(f"Error parsing playlist item: {e}")
             console.print(f"Error parsing playlist item: {e}")
             return {}

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,13 @@
 # 05.04.2024
 
 import time
-import logging
 from typing import Dict, List, Optional
 
 
 # Internal utils
+from SpotDown.utils.logger import Logger
 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 +18,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 +104,11 @@ 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()
 
     spotify_url = console.get_spotify_url()
     max_results = 5

SpotDown/upload/version.py

@@ -0,0 +1,5 @@
+__title__ = 'SpotDown'
+__version__ = '1.0.0'
+__author__ = 'Arrowar'
+__description__ = 'A command-line program to download music'
+__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/logger.py

@@ -0,0 +1,90 @@
+# 05.04.2024
+
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+
+
+# Internal utils
+from SpotDown.utils.config_json import config_manager
+
+
+
+class Logger:
+    _instance = None
+    
+    def __new__(cls):
+        # Singleton pattern to avoid multiple logger instances
+        if cls._instance is None:
+            cls._instance = super(Logger, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+        
+    def __init__(self):
+        # Initialize only once
+        if getattr(self, '_initialized', False):
+            return
+        
+        # Configure root logger
+        self.debug_mode = config_manager.get_bool('DEFAULT', "debug")
+        self.logger = logging.getLogger('')
+        
+        # Remove any existing handlers to avoid duplication
+        for handler in self.logger.handlers[:]:
+            self.logger.removeHandler(handler)
+        
+        # Reduce logging level for external libraries
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+        logging.getLogger("httpcore").setLevel(logging.WARNING)
+        
+        # Set logging level based on debug_mode
+        if self.debug_mode:
+            self.logger.setLevel(logging.DEBUG)
+            # In debug mode: log SOLO nel file, non nel terminale
+            self._configure_console_log_file()
+        else:
+            self.logger.setLevel(logging.ERROR)
+            # In modalità normale: log solo nel terminale per gli errori
+            self._configure_console_logging()
+        
+        self._initialized = True
+        
+    def _configure_console_logging(self):
+        """Configure console logging output to terminal."""
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.ERROR)  # Solo errori nel terminale
+        formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
+        console_handler.setFormatter(formatter)
+        self.logger.addHandler(console_handler)
+            
+    def _configure_console_log_file(self):
+        """Create a console.log file only when debug mode is enabled."""
+        console_log_path = "console.log"
+        try:
+            # Remove existing file if present
+            if os.path.exists(console_log_path):
+                os.remove(console_log_path)
+                
+            # Create handler for console.log
+            console_file_handler = RotatingFileHandler(
+                console_log_path,
+                maxBytes=5*1024*1024,  # 5 MB
+                backupCount=3
+            )
+            console_file_handler.setLevel(logging.DEBUG)
+            formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
+            console_file_handler.setFormatter(formatter)
+            self.logger.addHandler(console_file_handler)
+            
+        except Exception as e:
+            print(f"Error creating console.log: {e}")
+            
+    @staticmethod
+    def get_logger(name=None):
+        """
+        Get a specific logger for a module/component.
+        If name is None, returns the root logger.
+        """
+        # Ensure Logger instance is initialized
+        Logger()
+        return logging.getLogger(name)

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

@@ -1,20 +1,34 @@
 Metadata-Version: 2.4
 Name: SpotDown
-Version: 0.1.0
-Home-page: https://github.com/Arrowar/SpotDown
+Version: 1.0.0
+Summary: A command-line program to download music
+Home-page: https://github.com/Arrowar/spotdown
 Author: Arrowar
-Project-URL: Bug Reports, https://github.com/Arrowar/SpotDown/issues
-Project-URL: Source, https://github.com/Arrowar/SpotDown
+Author-email: author@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 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
 Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license-file
-Dynamic: project-url
+Dynamic: requires-dist
 Dynamic: requires-python
+Dynamic: summary
 
 <div align="center">
 
@@ -27,16 +41,10 @@ Dynamic: requires-python
 ## 💝 Support the Project
 
 [![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` or download the executable for your platform above*
+*⚡ **Quick Start:** `pip install spotdown && spotdown`*
 
 </div>
 
@@ -54,36 +62,41 @@ Dynamic: requires-python
 - 📋 **Download entire playlists** with ease
 - 🔍 **No authentication required** - uses web scraping
 - 🎨 **Automatic cover art embedding** (JPEG format)
+- ⚡ **Simple command-line interface** - just run `spotdown`!
 
 ## Installation
 
-### Prerequisites
-
-- **Python 3.8+**
-- **FFmpeg** (for audio processing)
-- **yt-dlp** (for downloading)
-
-### 1. Install Python Dependencies
+### Method 1: PyPI (Recommended)
 
 ```bash
-pip install -r requirements.txt
+pip install spotdown
 ```
 
-### 2. Install Playwright Chromium
+That's it! You can now run `spotdown` from anywhere in your terminal.
+
+### Method 2: From Source
+
+If you prefer to install from source:
 
 ```bash
-playwright install chromium
+git clone https://github.com/Arrowar/spotdown.git
+cd spotdown
+pip install -e .
 ```
 
-### 3. Quick Start
+### Prerequisites
 
-Create a simple launcher script:
+The following dependencies will be automatically installed:
 
-```python
-from spotdown.run import main
+- **Python 3.8+**
+- **FFmpeg** (for audio processing)
+- **yt-dlp** (for downloading)
+- **Playwright** (for web scraping)
+
+After installation, run this one-time setup command:
 
-if __name__ == "__main__":
-    main()
+```bash
+playwright install chromium
 ```
 
 ## Configuration
@@ -102,7 +115,7 @@ SpotDown uses a JSON configuration file with the following structure:
     },
     "BROWSER": {
         "headless": true,
-        "timeout": 6
+        "timeout": 8
     }
 }
 ```
@@ -123,15 +136,19 @@ SpotDown uses a JSON configuration file with the following structure:
 
 ## Usage
 
-### Basic Usage
+### Starting SpotDown
+
+Simply run the following command in your terminal:
 
 ```bash
-python run.py
+spotdown
 ```
 
+The interactive interface will guide you through the download process.
+
 ### Download Individual Songs
 
-1. Run the script
+1. Run `spotdown`
 2. Paste the Spotify song URL when prompted
 3. The script will automatically:
    - Extract song information
@@ -140,15 +157,28 @@ python run.py
 
 ### Download Playlists
 
-1. Run the script  
+1. Run `spotdown`
 2. Paste the Spotify playlist URL when prompted
 3. All songs in the playlist will be downloaded automatically
 
+### Example Usage
+
+```bash
+$ spotdown
+🎵 Welcome to SpotDown!
+Please paste your Spotify URL: https://open.spotify.com/track/4iV5W9uYEdYUVa79Axb7Rh
+🔍 Processing: Song Name - Artist Name
+⬇️ Downloading...
+✅ Download complete!
+```
+
 ## To Do
 
 - [ ] Implement batch download queue
 - [ ] Add GUI interface option
 - [ ] Support for additional music platforms
+- [ ] Album art quality selection
+- [ ] Custom output directory configuration
 
 ## Disclaimer
 

spotdown-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+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,,

spotdown-0.1.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-SpotDown/__init__.py,sha256=ebKRxKh14_cO7UWvOgE4R1RqIFBdekg50xtzc1LU6DU,59
-SpotDown/main.py,sha256=TjxUMIe0ee8IMbnYhXekO2MoLRiY6pJ5CCPgz7pOpHg,5042
-SpotDown/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-SpotDown/downloader/youtube_downloader.py,sha256=zHl98F2Ax72wTg3n8pohmkBZgBIPff0NrD9QKhG-TBM,4589
-SpotDown/extractor/__init__.py,sha256=pQtkjMzB4D8AVEFQ3pnp_UQI-KbYaQhZbKuDnMImN0o,161
-SpotDown/extractor/spotify_extractor.py,sha256=abE48E4M8s3xf95a28IYD8L4K2-QFDaYoZC5V0Jqu-4,13486
-SpotDown/extractor/youtube_extractor.py,sha256=XIPNWEBb5oUkGP1DrQ4h4XTJvHlBlbVIkAFNdpFE-Rc,9586
-SpotDown/utils/__init__.py,sha256=ZhJJhNQkUd4XG6vkoVQSC3qvSlaArhsRjscn4bfC9WA,128
-SpotDown/utils/config_json.py,sha256=Z_fuM2mYQVPc51sQ_-LXrX-ArTPL-lRDcQ3lLM_hmck,7435
-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-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spotdown-0.1.0.dist-info/METADATA,sha256=hSndrBHX3Cojvz0QgmbvsxHe8ryhaZRaXrIneggzYuw,5365
-spotdown-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-spotdown-0.1.0.dist-info/entry_points.txt,sha256=qHq6M94aU-XQL0y9R4yFKoqnHjU2nsN53Bj4OuHp3vQ,47
-spotdown-0.1.0.dist-info/top_level.txt,sha256=1E-ZZ8rsrXmBPAsseY_kEfHfNo9w9PtSCaS6pM63-tw,9
-spotdown-0.1.0.dist-info/RECORD,,