v5.3

Use Embedded ISRC Tags to check for existing files

Archived/GetMetadata.py

@@ -1,99 +0,0 @@
-import asyncio
-import zendriver as zd
-
-async def get_metadata(page):
-    max_attempts = 40
-    attempts = 0
-    
-    await asyncio.sleep(2)
-    
-    await page.evaluate("""
-        window.downloadInfo = null;
-        const originalFetch = window.fetch;
-        window.fetch = async function(...args) {
-            const [url, config] = args;
-            if (url.includes('/api/load?url=%2Fapi%2Ffetch%2Fstream%2Fv2')) {
-                const payload = JSON.parse(config.body);
-                const title = document.querySelector('h1.svelte-6pt9ji').textContent;
-                const artists = Array.from(document.querySelectorAll('h2.svelte-6pt9ji a.normal'))
-                                .map(a => a.textContent)
-                                .join(', ');
-                const cover = document.querySelector('.svelte-6pt9ji .meta.svelte-6pt9ji a').href;
-                                
-                window.downloadInfo = {
-                    url: payload.url,
-                    cover: cover,
-                    title: title,
-                    artists: artists,
-                    token: payload.token.primary,
-                    expiry: payload.token.expiry
-                };
-            }
-            return originalFetch.apply(this, args);
-        };
-    """)
-    
-    await page.evaluate("""
-        function waitForElement(selector) {
-            return new Promise(resolve => {
-                if (document.querySelector(selector)) {
-                    return resolve(document.querySelector(selector));
-                }
-
-                const observer = new MutationObserver(mutations => {
-                    if (document.querySelector(selector)) {
-                        observer.disconnect();
-                        resolve(document.querySelector(selector));
-                    }
-                });
-
-                observer.observe(document.documentElement, {
-                    childList: true,
-                    subtree: true
-                });
-            });
-        }
-
-        (async () => {
-            if (!window.location.hostname.includes('lucida.')) return;
-            
-            await Promise.race([
-                waitForElement('.d1-track button'),
-                waitForElement('button[class*="download-button"]')
-            ]);
-
-            const clickDownloadButton = () => {
-                const button = document.querySelector('.d1-track button') || 
-                              document.querySelector('button[class*="download-button"]');
-                if (button) button.click();
-            };
-
-            clickDownloadButton();
-        })();
-    """)
-    
-    while attempts < max_attempts:
-        download_info = await page.evaluate("window.downloadInfo")
-        if download_info:
-            return download_info
-        
-        await asyncio.sleep(0.5)
-        attempts += 1
-    
-    raise TimeoutError("Timeout")
-
-async def main():
-    browser = await zd.start(headless=False)
-    try:
-        track_id = "2plbrEY59IikOBgBGLjaoe"
-        url = f"https://lucida.to/?url=https%3A%2F%2Fopen.spotify.com%2Ftrack%2F{track_id}&country=auto&to=tidal"
-        
-        page = await browser.get(url)
-        download_info = await get_metadata(page)
-        print(download_info)
-        return download_info
-    finally:
-        await browser.stop()
-
-if __name__ == "__main__":
-    asyncio.run(main())

Archived/LucidaDownloader.py

@@ -1,120 +0,0 @@
-import requests
-from tqdm import tqdm
-import time
-import os
-import asyncio
-from GetMetadata import main as get_metadata
-
-class TrackDownloader:
-    def __init__(self):
-        self.client = requests.Session()
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-
-    async def get_track_info(self):
-        metadata = await get_metadata()
-        return metadata
-
-    def sanitize_filename(self, filename):
-        invalid_chars = '<>:"/\\|?*'
-        for char in invalid_chars:
-            filename = filename.replace(char, '')
-            
-        filename = ' '.join(filename.split())
-        filename = filename.replace(' ,', ',')
-        filename = filename.replace(',', ', ')
-        while '  ' in filename:
-            filename = filename.replace('  ', ' ')
-        filename = filename.rsplit('.', 1)
-        filename[0] = filename[0].strip()
-        return '.'.join(filename)
-
-    def download(self, metadata, output_dir):
-        track_url = metadata['url']
-        primary_token = metadata['token']
-        expiry = metadata['expiry']
-        
-        print(f"Starting download for: {track_url}")
-        
-        initial_request = {
-            "account": {"id": "auto", "type": "country"},
-            "compat": "false",
-            "downscale": "original",
-            "handoff": True,
-            "metadata": True,
-            "private": True,
-            "token": {
-                "expiry": expiry,
-                "primary": primary_token
-            },
-            "upload": {"enabled": False, "service": "pixeldrain"},
-            "url": track_url
-        }
-
-        response = self.client.post("https://lucida.to/api/load?url=/api/fetch/stream/v2", 
-                                    json=initial_request, 
-                                    headers=self.headers)
-        
-        csrf_token = response.cookies.get('csrf_token')
-        if csrf_token:
-            self.headers['X-CSRF-Token'] = csrf_token
-
-        initial_response = response.json()
-
-        if not initial_response.get("success", False):
-            raise Exception(f"Initial request failed: {initial_response.get('error', 'Unknown error')}")
-
-        handoff = initial_response["handoff"]
-        server = initial_response["server"]
-
-        file_name = f"{metadata['title']} - {metadata['artists']}.flac"
-        file_name = self.sanitize_filename(file_name)
-
-        completion_url = f"https://{server}.lucida.to/api/fetch/request/{handoff}"
-
-        print("Waiting for track processing to complete")
-        while True:
-            completion_response = self.client.get(completion_url, headers=self.headers).json()
-            if completion_response["status"] == "completed":
-                break
-            elif completion_response["status"] == "error":
-                raise Exception(f"API request failed: {completion_response.get('message', 'Unknown error')}")
-            time.sleep(1)
-
-        download_url = f"https://{server}.lucida.to/api/fetch/request/{handoff}/download"
-        print(f"Starting download of: {file_name}")
-        
-        response = self.client.get(download_url, stream=True, headers=self.headers)
-        total_size = int(response.headers.get('content-length', 0))
-
-        file_path = os.path.join(output_dir, file_name)
-
-        with open(file_path, 'wb') as file, tqdm(
-            desc=file_name,
-            total=total_size,
-            unit='iB',
-            unit_scale=True,
-            unit_divisor=1024,
-        ) as progress_bar:
-            for data in response.iter_content(chunk_size=1024):
-                size = file.write(data)
-                progress_bar.update(size)
-
-        print(f"Download completed: {file_path}")
-        return file_path
-
-async def main():
-    downloader = TrackDownloader()
-    output_dir = "."
-    
-    try:
-        metadata = await downloader.get_track_info()
-        
-        downloaded_file = downloader.download(metadata, output_dir)
-        print(f"File downloaded successfully: {downloaded_file}")
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-
-if __name__ == "__main__":
-    asyncio.run(main())

README.md

@@ -1,33 +1,22 @@
-[![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotifyFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotifyFLAC/releases)
+[![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotiFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotiFLAC/releases)
 
-![spotifyflac](https://github.com/user-attachments/assets/a11fde95-e756-4592-982f-b567d4a85f3c)
+![SpotiFLAC](https://github.com/user-attachments/assets/b4c4f403-edbd-4a71-b74b-c7d433d47d06)
 
 <div align="center">
-<b>Spotify FLAC</b> allows you to download Spotify tracks in true FLAC format through services like Tidal, Amazon Music and Qobuz with the help of Lucida.
+<b>SpotiFLAC</b> allows you to download Spotify tracks in true FLAC format through services like Tidal & Deezer.
 </div>
 
-### [Download](https://github.com/afkarxyz/SpotifyFLAC/releases/download/v1.5/SpotifyFLAC.exe)
+### [Download](https://github.com/afkarxyz/SpotiFLAC/releases/download/v5.2/SpotiFLAC.exe)
-
-#
-
-> [!NOTE]  
-> Requires **Google Chrome**
-
-> [!WARNING] 
-Sometimes, the **download speed** from Lucida can be fast or slow; it varies unpredictably.
 
 ## Screenshots
 
-![image](https://github.com/user-attachments/assets/c2057543-7f15-470e-beeb-2451a3764d15)
+![image](https://github.com/user-attachments/assets/416fca55-b885-45c0-af2a-b8b7ce5d5ef3)
 
-> - When **Headless** is enabled, the browser runs in the background without a graphical interface, improving performance and allowing seamless automation.
+![image](https://github.com/user-attachments/assets/f9b11da4-dbc3-435e-8954-5627ebe2ccdc)
-> - When **Fallback** is enabled, it will use the backup server Lucida.su
-> - **Filename: Title** means the filename format is `Title - Artist`, and vice versa.
-> - I highly recommend **Tidal** or **Amazon Music** because `Qobuz` occasionally experience issues.
 
-![image](https://github.com/user-attachments/assets/75a61cef-05a8-4f2c-b40b-ba5d49885ffe)
+![image](https://github.com/user-attachments/assets/7507e58d-e228-4edf-adf7-675731731019)
 
-![image](https://github.com/user-attachments/assets/84dfcfec-7c9d-4b5b-8624-3558cd3155be)
+![image](https://github.com/user-attachments/assets/e81f69f3-1552-4c12-a4e3-2f6d4b322d84)
 
 ## Lossless Audio Check
 
@@ -35,4 +24,4 @@ Sometimes, the **download speed** from Lucida can be fast or slow; it varies unp
 
 ![image](https://github.com/user-attachments/assets/7649e6e1-d5d1-49b3-b83f-965d44651d05)
 
-### [Download](https://github.com/afkarxyz/SpotifyFLAC/releases/download/v0/FLAC-Checker.zip) FLAC Checker
+#### [Download](https://github.com/afkarxyz/SpotiFLAC/releases/download/v0/FLAC-Checker.zip) FLAC Checker

SpotifyFLAC.py

@@ -1,608 +0,0 @@
-import sys
-import asyncio
-import os
-import time
-from pathlib import Path
-from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, 
-                            QHBoxLayout, QLabel, QLineEdit, QPushButton, 
-                            QProgressBar, QFileDialog, QCheckBox, QRadioButton, 
-                            QGroupBox, QComboBox)
-from PyQt6.QtCore import QThread, pyqtSignal, Qt, QSettings, QSize
-from PyQt6.QtGui import QIcon, QPixmap, QCursor
-from getMetadata import get_metadata
-from getTracks import TrackDownloader
-
-class ImageDownloader(QThread):
-    finished = pyqtSignal(bytes)
-    
-    def __init__(self, url):
-        super().__init__()
-        self.url = url
-        
-    def run(self):
-        import requests
-        response = requests.get(self.url)
-        if response.status_code == 200:
-            self.finished.emit(response.content)
-
-class MetadataFetcher(QThread):
-    finished = pyqtSignal(dict)
-    error = pyqtSignal(str)
-    
-    def __init__(self, url, headless=True, service="tidal", use_fallback=False):
-        super().__init__()
-        self.url = url
-        self.headless_mode = headless
-        self.service = service
-        self.use_fallback = use_fallback
-        self.max_retries = 3
-
-    def extract_track_id(self, url):
-        if "track/" in url:
-            return url.split("track/")[1].split("?")[0]
-        return None
-
-    async def fetch_metadata(self, track_id):
-        import zendriver as zd
-        from asyncio import sleep
-        
-        domain = "lucida.su" if self.use_fallback else "lucida.to"
-        
-        for attempt in range(self.max_retries):
-            try:
-                lucida_url = f"https://{domain}/?url=https%3A%2F%2Fopen.spotify.com%2Ftrack%2F{track_id}&country=auto&to={self.service}"
-                browser = await zd.start(headless=self.headless_mode)
-                try:
-                    page = await browser.get(lucida_url)
-                    return await get_metadata(page)
-                finally:
-                    await browser.stop()
-            except Exception as e:
-                if "refused" in str(e).lower() and attempt < self.max_retries - 1:
-                    await sleep(2 * (attempt + 1))
-                    continue
-                raise e
-
-    def run(self):
-        try:
-            track_id = self.extract_track_id(self.url)
-            if not track_id:
-                self.error.emit("Invalid Spotify URL")
-                return
-
-            metadata = asyncio.run(self.fetch_metadata(track_id))
-            if metadata:
-                self.finished.emit(metadata)
-            else:
-                self.error.emit("Failed to fetch track metadata")
-
-        except Exception as e:
-            error_msg = str(e)
-            if "refused" in error_msg.lower():
-                self.error.emit("Connection refused. Please check your internet connection and try again.")
-            elif "timeout" in error_msg.lower():
-                self.error.emit("Connection timed out. Please check your internet connection and try again.")
-            else:
-                self.error.emit(f"Error: {error_msg}")
-
-class DownloaderWorker(QThread):
-    progress = pyqtSignal(int)
-    status = pyqtSignal(str)
-    finished = pyqtSignal(str)
-    error = pyqtSignal(str)
-    
-    def __init__(self, metadata, output_dir, filename_format='title_artist', use_fallback=False):
-        super().__init__()
-        self.metadata = metadata
-        self.output_dir = output_dir
-        self.filename_format = filename_format
-        self.use_fallback = use_fallback
-        self.downloader = TrackDownloader(use_fallback=use_fallback)
-        self.last_update_time = 0
-        self.last_downloaded_size = 0
-        
-    def format_size(self, size_bytes):
-        units = ['B', 'KB', 'MB', 'GB']
-        index = 0
-        while size_bytes >= 1024 and index < len(units) - 1:
-            size_bytes /= 1024
-            index += 1
-        return f"{size_bytes:.2f}{units[index]}"
-        
-    def format_speed(self, speed_bytes):
-        speed_bits = speed_bytes * 8
-        
-        if speed_bits >= 1024 * 1024:
-            speed_mbps = speed_bits / (1024 * 1024)
-            return f"{speed_mbps:.2f}Mbps"
-        else:
-            speed_kbps = speed_bits / 1024
-            return f"{speed_kbps:.2f}Kbps"
-        
-    def progress_callback(self, downloaded_size, total_size):
-        current_time = time.time()
-        if current_time - self.last_update_time >= 0.5:
-            progress = int((downloaded_size / total_size) * 100) if total_size > 0 else 0
-            self.progress.emit(progress)
-            
-            time_diff = current_time - self.last_update_time
-            if time_diff > 0:
-                speed = (downloaded_size - self.last_downloaded_size) / time_diff
-                status = f"Downloading... {self.format_size(downloaded_size)}/{self.format_size(total_size)} | {self.format_speed(speed)}"
-                self.status.emit(status)
-            
-            self.last_update_time = current_time
-            self.last_downloaded_size = downloaded_size
-        
-    def run(self):
-        try:
-            self.status.emit("Preparing...")
-            self.downloader.set_progress_callback(self.progress_callback)
-            self.downloader.set_filename_format(self.filename_format)
-            self.progress.emit(0)
-            downloaded_file = self.downloader.download(self.metadata, self.output_dir)
-            self.progress.emit(100)
-            self.finished.emit("Download complete!")
-        except Exception as e:
-            self.error.emit(f"Error: {str(e)}")
-
-class ServiceComboBox(QComboBox):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setIconSize(QSize(16, 16))
-        self.setup_items()
-        
-    def setup_items(self):
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        icons_dir = os.path.join(current_dir, 'icons')
-        
-        if not os.path.exists(icons_dir):
-            os.makedirs(icons_dir)
-            
-        services = [
-            {'id': 'tidal', 'name': 'Tidal', 'icon': 'tidal.png'},
-            {'id': 'amazon', 'name': 'Amazon Music', 'icon': 'amazon.png'},
-            {'id': 'qobuz', 'name': 'Qobuz', 'icon': 'qobuz.png'}
-        ]
-        
-        for service in services:
-            icon_path = os.path.join(icons_dir, service['icon'])
-            if not os.path.exists(icon_path):
-                self.create_placeholder_icon(icon_path)
-            
-            icon = QIcon(icon_path)
-            self.addItem(icon, service['name'], service['id'])
-    
-    def create_placeholder_icon(self, path):
-        pixmap = QPixmap(16, 16)
-        pixmap.fill(Qt.GlobalColor.transparent)
-        pixmap.save(path)
-
-class SpotifyFlacGUI(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.settings = QSettings('SpotifyFlac', 'Settings')
-        self.setWindowTitle("Spotify FLAC")
-        
-        icon_path = os.path.join(os.path.dirname(__file__), "icon.svg")
-        if os.path.exists(icon_path):
-            self.setWindowIcon(QIcon(icon_path))
-        
-        self.setFixedWidth(600)
-        self.setFixedHeight(180)
-        
-        self.default_music_dir = str(Path.home() / "Music")
-        if not os.path.exists(self.default_music_dir):
-            os.makedirs(self.default_music_dir)
-        
-        self.metadata = None
-        self.init_ui()
-        self.url_input.textChanged.connect(self.validate_url)
-        self.load_settings()
-        self.setup_settings_persistence()
-        
-    def load_settings(self):
-        headless = self.settings.value('headless', True, type=bool)
-        fallback = self.settings.value('fallback', False, type=bool)
-        service = self.settings.value('service', 'tidal')
-        format_type = self.settings.value('format', 'title_artist')
-        output_dir = self.settings.value('output_dir', self.default_music_dir)
-        
-        self.headless_checkbox.setChecked(headless)
-        self.fallback_checkbox.setChecked(fallback)
-        
-        for i in range(self.service_combo.count()):
-            if self.service_combo.itemData(i) == service:
-                self.service_combo.setCurrentIndex(i)
-                break
-                
-        self.format_title_artist.setChecked(format_type == 'title_artist')
-        self.format_artist_title.setChecked(format_type == 'artist_title')
-        self.dir_input.setText(output_dir)
-        
-    def setup_settings_persistence(self):
-        self.headless_checkbox.stateChanged.connect(
-            lambda x: self.settings.setValue('headless', bool(x)))
-        self.fallback_checkbox.stateChanged.connect(
-            lambda x: self.settings.setValue('fallback', bool(x)))
-        self.service_combo.currentIndexChanged.connect(
-            lambda i: self.settings.setValue('service', self.service_combo.itemData(i)))
-        self.format_title_artist.toggled.connect(
-            lambda x: self.settings.setValue('format', 'title_artist' if x else 'artist_title'))
-        self.dir_input.textChanged.connect(
-            lambda x: self.settings.setValue('output_dir', x))
-
-    def init_ui(self):
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-        self.main_layout = QVBoxLayout(central_widget)
-        self.main_layout.setContentsMargins(10, 10, 10, 10)
-
-        self.input_widget = QWidget()
-        input_layout = QVBoxLayout(self.input_widget)
-        input_layout.setSpacing(10)
-
-        url_layout = QHBoxLayout()
-        url_label = QLabel("Track URL:")
-        url_label.setFixedWidth(100)
-        self.url_input = QLineEdit()
-        self.url_input.setPlaceholderText("Please enter track URL")
-        self.url_input.setClearButtonEnabled(True)
-        self.fetch_button = QPushButton("Fetch")
-        self.fetch_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.fetch_button.setFixedWidth(100)
-        self.fetch_button.setEnabled(False)
-        self.fetch_button.clicked.connect(self.fetch_track_info)
-        url_layout.addWidget(url_label)
-        url_layout.addWidget(self.url_input)
-        url_layout.addWidget(self.fetch_button)
-        input_layout.addLayout(url_layout)
-
-        dir_layout = QHBoxLayout()
-        dir_label = QLabel("Output Directory:")
-        dir_label.setFixedWidth(100)
-        self.dir_input = QLineEdit(self.default_music_dir)
-        self.dir_button = QPushButton("Browse")
-        self.dir_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.dir_button.setFixedWidth(100)
-        dir_layout.addWidget(dir_label)
-        dir_layout.addWidget(self.dir_input)
-        dir_layout.addWidget(self.dir_button)
-        self.dir_button.clicked.connect(self.select_directory)
-        input_layout.addLayout(dir_layout)
-
-        settings_group = QGroupBox("Settings")
-        settings_layout = QHBoxLayout(settings_group)
-        settings_layout.setContentsMargins(10, 0, 10, 10)
-        settings_layout.setSpacing(10)
-        
-        settings_container = QWidget()
-        settings_container_layout = QHBoxLayout(settings_container)
-        settings_container_layout.setContentsMargins(0, 0, 0, 0)
-        settings_container_layout.setSpacing(10)
-        
-        self.headless_checkbox = QCheckBox("Headless")
-        self.headless_checkbox.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.headless_checkbox.setChecked(True)
-        settings_container_layout.addWidget(self.headless_checkbox)
-        
-        self.fallback_checkbox = QCheckBox("Fallback")
-        self.fallback_checkbox.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.fallback_checkbox.setChecked(False)
-        settings_container_layout.addWidget(self.fallback_checkbox)
-        
-        service_widget = QWidget()
-        service_layout = QHBoxLayout(service_widget)
-        service_layout.setContentsMargins(0, 0, 0, 0)
-        service_layout.setSpacing(10)
-        
-        service_label = QLabel("Service:")
-        self.service_combo = ServiceComboBox()
-        self.service_combo.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        
-        service_layout.addWidget(service_label)
-        service_layout.addWidget(self.service_combo)
-        
-        settings_container_layout.addWidget(service_widget)
-        
-        format_widget = QWidget()
-        format_layout = QHBoxLayout(format_widget)
-        format_layout.setContentsMargins(0, 0, 0, 0)
-        format_layout.setSpacing(10)
-        
-        format_label = QLabel("Filename:")
-        self.format_title_artist = QRadioButton("Title")
-        self.format_artist_title = QRadioButton("Artist")
-        self.format_title_artist.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.format_artist_title.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.format_title_artist.setChecked(True)
-        
-        format_layout.addWidget(format_label)
-        format_layout.addWidget(self.format_title_artist)
-        format_layout.addWidget(self.format_artist_title)
-        
-        settings_container_layout.addWidget(format_widget)
-        
-        settings_layout.addStretch()
-        settings_layout.addWidget(settings_container)
-        settings_layout.addStretch()
-        
-        input_layout.addWidget(settings_group)
-        self.main_layout.addWidget(self.input_widget)
-
-        self.track_widget = QWidget()
-        self.track_widget.hide()
-        track_layout = QHBoxLayout(self.track_widget)
-        track_layout.setContentsMargins(0, 0, 0, 0)
-        track_layout.setSpacing(10)
-
-        cover_container = QWidget()
-        cover_layout = QVBoxLayout(cover_container)
-        cover_layout.setContentsMargins(0, 0, 0, 0)
-        cover_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
-        
-        self.cover_label = QLabel()
-        self.cover_label.setFixedSize(100, 100)
-        self.cover_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        cover_layout.addWidget(self.cover_label)
-        track_layout.addWidget(cover_container)
-
-        track_details_container = QWidget()
-        track_details_layout = QVBoxLayout(track_details_container)
-        track_details_layout.setContentsMargins(0, 0, 0, 0)
-        track_details_layout.setSpacing(2)
-        track_details_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
-
-        self.title_label = QLabel()
-        self.title_label.setStyleSheet("font-size: 14px; font-weight: bold;")
-        self.title_label.setWordWrap(True)
-        self.title_label.setMinimumWidth(400)
-        
-        self.artist_label = QLabel()
-        self.artist_label.setStyleSheet("font-size: 12px;")
-        self.artist_label.setWordWrap(True)
-        self.artist_label.setMinimumWidth(400)
-
-        track_details_layout.addWidget(self.title_label)
-        track_details_layout.addWidget(self.artist_label)
-        track_layout.addWidget(track_details_container, stretch=1)
-        track_layout.addStretch()
-        self.main_layout.addWidget(self.track_widget)
-
-        self.download_button = QPushButton("Download")
-        self.download_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.download_button.setFixedWidth(100)
-        self.download_button.clicked.connect(self.button_clicked)
-        self.download_button.hide()
-
-        self.cancel_button = QPushButton("Cancel")
-        self.cancel_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.cancel_button.setFixedWidth(100)
-        self.cancel_button.clicked.connect(self.cancel_clicked)
-        self.cancel_button.hide()
-
-        self.open_button = QPushButton("Open")
-        self.open_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.open_button.setFixedWidth(100)
-        self.open_button.clicked.connect(self.open_output_directory)
-        self.open_button.hide()
-
-        download_layout = QHBoxLayout()
-        download_layout.addStretch()
-        download_layout.addWidget(self.open_button)
-        download_layout.addWidget(self.download_button)
-        download_layout.addWidget(self.cancel_button)
-        download_layout.addStretch()
-        self.main_layout.addLayout(download_layout)
-
-        self.progress_bar = QProgressBar()
-        self.progress_bar.hide()
-        self.main_layout.addWidget(self.progress_bar)
-
-        bottom_layout = QHBoxLayout()
-        
-        self.status_label = QLabel("")
-        bottom_layout.addWidget(self.status_label, stretch=1)
-        
-        self.update_button = QPushButton()
-        icon_path = os.path.join(os.path.dirname(__file__), "update.svg")
-        if os.path.exists(icon_path):
-            self.update_button.setIcon(QIcon(icon_path))
-        self.update_button.setFixedSize(16, 16)
-        self.update_button.setStyleSheet("""
-            QPushButton {
-                border: none;
-                background: transparent;
-            }
-            QPushButton:hover {
-                background: transparent;
-            }
-        """)
-        self.update_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-        self.update_button.setToolTip("Check for Updates")
-        self.update_button.clicked.connect(self.open_update_page)
-        
-        bottom_layout.addWidget(self.update_button)
-        
-        self.main_layout.addLayout(bottom_layout)
-        
-    def open_update_page(self):
-        import webbrowser
-        webbrowser.open('https://github.com/afkarxyz/SpotifyFLAC/releases')
-        
-    def validate_url(self, url):
-        url = url.strip()
-        self.fetch_button.setEnabled(False)
-        if not url:
-            self.status_label.clear()
-            return
-        if "open.spotify.com/" not in url:
-            self.status_label.setText("Please enter a valid Spotify URL")
-            return
-        if "/album/" in url:
-            self.status_label.setText("Album URLs are not supported. Please enter a track URL.")
-            return
-        if "/playlist/" in url:
-            self.status_label.setText("Playlist URLs are not supported. Please enter a track URL.")
-            return
-        if "/track/" not in url:
-            self.status_label.setText("Please enter a valid Spotify track URL")
-            return
-        self.fetch_button.setEnabled(True)
-        self.status_label.clear()
-
-    def fetch_track_info(self):
-        url = self.url_input.text().strip()
-        if not url:
-            self.status_label.setText("Please enter a Track URL")
-            return
-        self.fetch_button.setEnabled(False)
-        self.status_label.setText("Fetching track information...")
-        headless = self.headless_checkbox.isChecked()
-        fallback = self.fallback_checkbox.isChecked()
-        service = self.service_combo.currentData()
-        self.fetcher = MetadataFetcher(url, headless=headless, service=service, use_fallback=fallback)
-        self.fetcher.finished.connect(self.handle_track_info)
-        self.fetcher.error.connect(self.handle_fetch_error)
-        self.fetcher.start()
-
-    def handle_track_info(self, metadata):
-        self.metadata = metadata
-        self.fetch_button.setEnabled(True)
-        self.title_label.setText(metadata['title'].strip())
-        self.artist_label.setText(metadata['artists'].strip())
-        self.image_downloader = ImageDownloader(metadata['cover'])
-        self.image_downloader.finished.connect(self.update_cover_art)
-        self.image_downloader.start()
-        self.input_widget.hide()
-        self.track_widget.show()
-        self.download_button.show()
-        self.cancel_button.show()
-        self.update_button.hide()
-        self.status_label.clear()
-        self.adjustWindowHeight()
-
-    def adjustWindowHeight(self):
-        title_height = self.title_label.sizeHint().height()
-        artist_height = self.artist_label.sizeHint().height()
-        base_height = 180
-        additional_height = max(0, (title_height + artist_height) - 40)
-        new_height = min(300, base_height + additional_height)
-        self.setFixedHeight(int(new_height))
-
-    def update_cover_art(self, image_data):
-        pixmap = QPixmap()
-        pixmap.loadFromData(image_data)
-        scaled_pixmap = pixmap.scaled(100, 100, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
-        self.cover_label.setPixmap(scaled_pixmap)
-
-    def handle_fetch_error(self, error):
-        self.fetch_button.setEnabled(True)
-        self.status_label.setText(f"Error fetching track info: {error}")
-
-    def select_directory(self):
-        directory = QFileDialog.getExistingDirectory(self, "Select Output Directory")
-        if directory:
-            self.dir_input.setText(directory)
-
-    def open_output_directory(self):
-        output_dir = self.dir_input.text().strip() or self.default_music_dir
-        os.startfile(output_dir)
-
-    def cancel_clicked(self):
-        self.track_widget.hide()
-        self.input_widget.show()
-        self.download_button.hide()
-        self.cancel_button.hide()
-        self.progress_bar.hide()
-        self.progress_bar.setValue(0)
-        self.status_label.clear()
-        self.metadata = None
-        self.fetch_button.setEnabled(True)
-        self.update_button.show()
-        self.setFixedHeight(180)
-
-    def button_clicked(self):
-        if self.download_button.text() == "Clear":
-            self.clear_form()
-        else:
-            self.start_download()
-
-    def clear_form(self):
-        self.url_input.clear()
-        self.progress_bar.hide()
-        self.progress_bar.setValue(0)
-        self.status_label.clear()
-        self.download_button.setText("Download")
-        self.download_button.hide()
-        self.cancel_button.hide()
-        self.open_button.hide()
-        self.track_widget.hide()
-        self.input_widget.show()
-        self.metadata = None
-        self.update_button.show()
-        self.setFixedHeight(180)
-
-    def start_download(self):
-        output_dir = self.dir_input.text().strip()
-        if not self.metadata:
-            self.status_label.setText("Please fetch track information first")
-            return
-        if not output_dir:
-            output_dir = self.default_music_dir
-            self.dir_input.setText(output_dir)
-        
-        self.download_button.hide()
-        self.cancel_button.hide()
-        self.progress_bar.show()
-        self.progress_bar.setValue(0)
-        self.status_label.setText("Preparing...")
-        
-        format_type = 'artist_title' if self.format_artist_title.isChecked() else 'title_artist'
-        fallback = self.fallback_checkbox.isChecked()
-        
-        self.worker = DownloaderWorker(
-            metadata=self.metadata, 
-            output_dir=output_dir,
-            filename_format=format_type,
-            use_fallback=fallback
-        )
-        
-        self.worker.progress.connect(self.update_progress)
-        self.worker.status.connect(self.update_status)
-        self.worker.finished.connect(self.download_finished)
-        self.worker.error.connect(self.download_error)
-        self.worker.start()
-
-    def update_status(self, status):
-        self.status_label.setText(status)
-
-    def update_progress(self, value):
-        self.progress_bar.setValue(value)
-
-    def download_finished(self, message):
-        self.progress_bar.hide()
-        self.status_label.setText(message)
-        self.open_button.show()
-        self.download_button.setText("Clear") 
-        self.download_button.show()
-        self.cancel_button.hide()
-        self.download_button.setEnabled(True)
-
-    def download_error(self, error_message):
-        self.progress_bar.hide()
-        self.status_label.setText(error_message)
-        self.download_button.setText("Retry")
-        self.download_button.show()
-        self.cancel_button.show()
-        self.download_button.setEnabled(True)
-        self.cancel_button.setEnabled(True)
-
-def main():
-    app = QApplication(sys.argv)
-    window = SpotifyFlacGUI()
-    window.show()
-    sys.exit(app.exec())
-
-if __name__ == "__main__":
-    main()

deezerDL.py

@@ -0,0 +1,241 @@
+import requests
+import asyncio
+import os
+import sys
+from mutagen.flac import FLAC
+from random import randrange
+
+def get_random_user_agent():
+    return f"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_{randrange(11, 15)}_{randrange(4, 9)}) AppleWebKit/{randrange(530, 537)}.{randrange(30, 37)} (KHTML, like Gecko) Chrome/{randrange(80, 105)}.0.{randrange(3000, 4500)}.{randrange(60, 125)} Safari/{randrange(530, 537)}.{randrange(30, 36)}"
+
+class DeezerDownloader:
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': get_random_user_agent()
+        })
+        self.progress_callback = None
+    
+    def set_progress_callback(self, callback):
+        self.progress_callback = callback
+    
+    def get_track_by_isrc(self, isrc):
+        try:
+            url = f"https://api.deezer.com/2.0/track/isrc:{isrc}"
+            response = self.session.get(url)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            if 'error' in data:
+                print(f"Error from Deezer API: {data['error']['message']}")
+                return None
+            
+            return data
+        except requests.exceptions.RequestException as e:
+            print(f"Error fetching track data: {e}")
+            return None
+    
+    def extract_metadata(self, track_data):
+        metadata = {}
+        
+        metadata['title'] = track_data.get('title', '')
+        metadata['title_short'] = track_data.get('title_short', '')
+        metadata['duration'] = track_data.get('duration', 0)
+        metadata['track_position'] = track_data.get('track_position', 1)
+        metadata['disk_number'] = track_data.get('disk_number', 1)
+        metadata['isrc'] = track_data.get('isrc', '')
+        metadata['release_date'] = track_data.get('release_date', '')
+        metadata['explicit_lyrics'] = track_data.get('explicit_lyrics', False)
+        
+        if 'artist' in track_data:
+            metadata['artist'] = track_data['artist'].get('name', '')
+            metadata['artist_id'] = track_data['artist'].get('id', '')
+        
+        if 'contributors' in track_data:
+            artists = []
+            for contributor in track_data['contributors']:
+                if contributor.get('role') == 'Main':
+                    artists.append(contributor.get('name', ''))
+            metadata['artists'] = ', '.join(artists) if artists else metadata.get('artist', '')
+        
+        if 'album' in track_data:
+            album = track_data['album']
+            metadata['album'] = album.get('title', '')
+            metadata['album_id'] = album.get('id', '')
+            metadata['cover_url'] = album.get('cover_xl', album.get('cover_big', ''))
+            metadata['cover_md5'] = album.get('md5_image', '')
+        
+        metadata['deezer_link'] = track_data.get('link', '')
+        metadata['preview_url'] = track_data.get('preview', '')
+        
+        return metadata
+    
+    def download_cover_art(self, cover_url, filename):
+        if not cover_url:
+            return None
+        
+        try:
+            response = self.session.get(cover_url)
+            response.raise_for_status()
+            
+            cover_path = f"{filename}_cover.jpg"
+            with open(cover_path, 'wb') as f:
+                f.write(response.content)
+            
+            return cover_path
+        except Exception as e:
+            print(f"Error downloading cover art: {e}")
+            return None
+    
+    def embed_metadata(self, file_path, metadata, cover_path=None):
+        try:
+            audio = FLAC(file_path)
+            
+            audio.clear()
+            
+            if metadata.get('title'):
+                audio['TITLE'] = metadata['title']
+            if metadata.get('artists'):
+                audio['ARTIST'] = metadata['artists']
+            elif metadata.get('artist'):
+                audio['ARTIST'] = metadata['artist']
+            if metadata.get('album'):
+                audio['ALBUM'] = metadata['album']
+            if metadata.get('release_date'):
+                audio['DATE'] = metadata['release_date']
+            if metadata.get('track_position'):
+                audio['TRACKNUMBER'] = str(metadata['track_position'])
+            if metadata.get('disk_number'):
+                audio['DISCNUMBER'] = str(metadata['disk_number'])
+            if metadata.get('isrc'):
+                audio['ISRC'] = metadata['isrc']
+            
+            if cover_path and os.path.exists(cover_path):
+                with open(cover_path, 'rb') as f:
+                    cover_data = f.read()
+                
+                from mutagen.flac import Picture
+                picture = Picture()
+                picture.type = 3
+                picture.mime = 'image/jpeg'
+                picture.desc = 'Cover'
+                picture.data = cover_data
+                audio.add_picture(picture)
+            
+            audio.save()
+            print(f"Metadata embedded successfully in {file_path}")
+            
+        except Exception as e:
+            print(f"Error embedding metadata: {e}")
+    
+    async def download_by_isrc(self, isrc, output_dir="."):
+        print(f"Fetching track info for ISRC: {isrc}")
+        
+        track_data = self.get_track_by_isrc(isrc)
+        if not track_data:
+            print("Failed to get track data from Deezer API")
+            return False
+        
+        metadata = self.extract_metadata(track_data)
+        print(f"Found track: {metadata.get('artists', 'Unknown')} - {metadata.get('title', 'Unknown')}")
+        
+        track_id = track_data.get('id')
+        if not track_id:
+            print("No track ID found in Deezer API response")
+            return False
+        
+        print(f"Using track ID: {track_id}")
+        
+        api_url = f"https://api.deezmate.com/dl/{track_id}"
+        print(f"Requesting download links from: {api_url}")
+        
+        try:
+            response = self.session.get(api_url)
+            response.raise_for_status()
+            api_data = response.json()
+            
+            if not api_data.get('success'):
+                print("API request failed")
+                return False
+            
+            links = api_data.get('links', {})
+            flac_url = links.get('flac')
+            
+            if not flac_url:
+                print("No FLAC download link found in API response")
+                return False
+            
+            print(f"Successfully obtained FLAC download URL")
+            
+        except Exception as e:
+            print(f"Error getting download URL from API: {e}")
+            return False
+        
+        print("Downloading FLAC file...")
+        try:
+            response = self.session.get(flac_url)
+            response.raise_for_status()
+            
+            safe_title = "".join(c for c in metadata.get('title', 'Unknown') if c.isalnum() or c in (' ', '-', '_')).rstrip()
+            safe_artist = "".join(c for c in metadata.get('artists', 'Unknown') if c.isalnum() or c in (' ', '-', '_')).rstrip()
+            filename = f"{safe_artist} - {safe_title}.flac"
+            file_path = os.path.join(output_dir, filename)
+            
+            with open(file_path, 'wb') as f:
+                f.write(response.content)
+            
+            downloaded = len(response.content)
+            print(f"File size: {downloaded} bytes ({downloaded / (1024*1024):.2f} MB)")
+            
+            if self.progress_callback:
+                self.progress_callback(downloaded, downloaded)
+            
+            print(f"Downloaded: {file_path}")
+            
+            cover_path = None
+            if metadata.get('cover_url'):
+                print("Downloading cover art...")
+                cover_path = self.download_cover_art(metadata['cover_url'], 
+                                                   os.path.join(output_dir, f"{safe_artist} - {safe_title}"))
+            
+            print("Embedding metadata...")
+            self.embed_metadata(file_path, metadata, cover_path)
+            
+            if cover_path and os.path.exists(cover_path):
+                os.remove(cover_path)
+            
+            print(f"Successfully downloaded and tagged: {filename}")
+            return True
+            
+        except Exception as e:
+            print(f"Error downloading file: {e}")
+            return False
+
+async def main():
+    print("=== DeezerDL - Deezer Downloader ===")
+    downloader = DeezerDownloader()
+    
+    isrc = "USAT22409172"
+    output_dir = "."
+    
+    success = await downloader.download_by_isrc(isrc, output_dir)
+    if success:
+        print("Download completed successfully!")
+    else:
+        print("Download failed!")
+
+if __name__ == "__main__":
+    try:
+        import sys
+        if sys.platform == "win32":
+            import os
+            os.system("chcp 65001 > nul")
+            try:
+                sys.stdout.reconfigure(encoding='utf-8')
+            except:
+                pass
+    except:
+        pass
+        
+    asyncio.run(main())

getMetadata.py

@@ -1,99 +1,740 @@
-import asyncio
+from time import sleep
-import zendriver as zd
+from urllib.parse import urlparse, parse_qs
-
+from pathlib import Path
-async def get_metadata(page, headless=True):
+import requests
-    max_attempts = 40
+import json
-    attempts = 0
+import time
-    
+import pyotp
-    await asyncio.sleep(2)
+import base64
-    
+from random import randrange
-    await page.evaluate("""
+from typing import Dict, Any, List, Tuple
-        window.downloadInfo = null;
+
-        const originalFetch = window.fetch;
+# https://github.com/visagenull/Spotify-Free
-        window.fetch = async function(...args) {
+def get_random_user_agent():
-            const [url, config] = args;
+    return f"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_{randrange(11, 15)}_{randrange(4, 9)}) AppleWebKit/{randrange(530, 537)}.{randrange(30, 37)} (KHTML, like Gecko) Chrome/{randrange(80, 105)}.0.{randrange(3000, 4500)}.{randrange(60, 125)} Safari/{randrange(530, 537)}.{randrange(30, 36)}"
-            if (url.includes('/api/load?url=%2Fapi%2Ffetch%2Fstream%2Fv2')) {
+
-                const payload = JSON.parse(config.body);
+# https://github.com/xyloflake/spot-secrets-go
-                const title = document.querySelector('h1.svelte-6pt9ji').textContent.trim();
+def generate_totp():
-                const artists = Array.from(document.querySelectorAll('h2.svelte-6pt9ji a.normal'))
+    local_path = Path.home() / ".spotify-secret" / "secretBytes.json"
-                                .map(a => a.textContent.trim())
+    used_local = False
-                                .join(', ');
+    
-                const cover = document.querySelector('.svelte-6pt9ji .meta.svelte-6pt9ji a').href;
+    try:
-                                
+        url = "https://raw.githubusercontent.com/afkarxyz/secretBytes/refs/heads/main/secrets/secretBytes.json"
-                window.downloadInfo = {
+        resp = requests.get(url, timeout=10)
-                    url: payload.url,
+        if resp.status_code != 200:
-                    cover: cover,
+            raise Exception(f"GitHub fetch failed with status: {resp.status_code}")
-                    title: title,
+        secrets_list = resp.json()
-                    artists: artists,
+    except Exception as github_error:
-                    token: payload.token.primary,
+        try:
-                    expiry: payload.token.expiry
+            if local_path.exists():
-                };
+                with open(local_path, 'r') as f:
-            }
+                    secrets_list = json.load(f)
-            return originalFetch.apply(this, args);
+                used_local = True
-        };
+            else:
-    """)
+                raise Exception(f"GitHub failed ({github_error}) and no local file found at {local_path}")
-    
+        except Exception as local_error:
-    await page.evaluate("""
+            raise Exception(f"Failed to fetch secrets from both GitHub and local: {local_error}")
-        function waitForElement(selector) {
+    
-            return new Promise(resolve => {
+    try:
-                if (document.querySelector(selector)) {
+        latest_entry = max(secrets_list, key=lambda x: x["version"])
-                    return resolve(document.querySelector(selector));
+        version = latest_entry["version"]
-                }
+        secret_cipher = latest_entry["secret"]
-
+    except Exception as e:
-                const observer = new MutationObserver(mutations => {
+        raise Exception(f"Failed to process secrets: {str(e)}")
-                    if (document.querySelector(selector)) {
+
-                        observer.disconnect();
+    processed = [byte ^ ((i % 33) + 9) for i, byte in enumerate(secret_cipher)]
-                        resolve(document.querySelector(selector));
+    processed_str = "".join(map(str, processed))
-                    }
+    utf8_bytes = processed_str.encode('utf-8')
-                });
+    hex_str = utf8_bytes.hex()
-
+    secret_bytes = bytes.fromhex(hex_str)
-                observer.observe(document.documentElement, {
+    b32_secret = base64.b32encode(secret_bytes).decode('utf-8')
-                    childList: true,
+    totp = pyotp.TOTP(b32_secret)
-                    subtree: true
+
-                });
+    headers = {
-            });
+        "Host": "open.spotify.com",
-        }
+        "User-Agent": get_random_user_agent(),
-
+        "Accept": "*/*",
-        (async () => {
+    }
-            if (!window.location.hostname.includes('lucida.')) return;
+
-            
+    try:
-            await Promise.race([
+        resp = requests.get("https://open.spotify.com/api/server-time", headers=headers, timeout=10)
-                waitForElement('.d1-track button'),
+        if resp.status_code != 200:
-                waitForElement('button[class*="download-button"]')
+            raise Exception(f"Failed to get server time. Status code: {resp.status_code}")
-            ]);
+        data = resp.json()
-
+        server_time = data.get("serverTime")
-            const clickDownloadButton = () => {
+        if server_time is None:
-                const button = document.querySelector('.d1-track button') || 
+            raise Exception("Failed to fetch server time from Spotify")
-                              document.querySelector('button[class*="download-button"]');
+        return totp, server_time, version
-                if (button) button.click();
+    except Exception as e:
-            };
+        raise Exception(f"Error getting server time: {str(e)}")
-
+
-            clickDownloadButton();
+token_url = 'https://open.spotify.com/api/token'
-        })();
+playlist_base_url = 'https://api.spotify.com/v1/playlists/{}'
-    """)
+album_base_url = 'https://api.spotify.com/v1/albums/{}'
-    
+track_base_url = 'https://api.spotify.com/v1/tracks/{}'
-    while attempts < max_attempts:
+artist_base_url = 'https://api.spotify.com/v1/artists/{}'
-        download_info = await page.evaluate("window.downloadInfo")
+artist_albums_url = 'https://api.spotify.com/v1/artists/{}/albums'
-        if download_info:
+headers = {
-            return download_info
+    'User-Agent': get_random_user_agent(),
-        
+    'Accept': 'application/json',
-        await asyncio.sleep(0.5)
+    'Accept-Language': 'en-US,en;q=0.9',
-        attempts += 1
+    'Accept-Encoding': 'gzip, deflate, br',
-    
+    'sec-ch-ua-platform': '"Windows"',
-    raise TimeoutError("Timeout")
+    'sec-fetch-dest': 'empty',
-
+    'sec-fetch-mode': 'cors',
-async def main(headless=True):
+    'sec-fetch-site': 'same-origin',
-    browser = await zd.start(headless=headless)
+    'Referer': 'https://open.spotify.com/',
-    try:
+    'Origin': 'https://open.spotify.com'
-        track_id = "2plbrEY59IikOBgBGLjaoe"
+}
-        url = f"https://lucida.to/?url=https%3A%2F%2Fopen.spotify.com%2Ftrack%2F{track_id}&country=auto&to=tidal"
+
-        
+class SpotifyInvalidUrlException(Exception):
-        page = await browser.get(url)
+    pass
-        download_info = await get_metadata(page)
+
-        print(download_info)
+class SpotifyWebsiteParserException(Exception):
-        return download_info
+    pass
-    finally:
+
-        await browser.stop()
+def parse_uri(uri):
-
+    u = urlparse(uri)
-if __name__ == "__main__":
+    if u.netloc == "embed.spotify.com":
-    asyncio.run(main())
+        if not u.query:
+            raise SpotifyInvalidUrlException("ERROR: url {} is not supported".format(uri))
+        qs = parse_qs(u.query)
+        return parse_uri(qs['uri'][0])
+
+    if not u.scheme and not u.netloc:
+        return {"type": "playlist", "id": u.path}
+
+    if u.scheme == "spotify":
+        parts = uri.split(":")
+    else:
+        if u.netloc != "open.spotify.com" and u.netloc != "play.spotify.com":
+            raise SpotifyInvalidUrlException("ERROR: url {} is not supported".format(uri))
+        parts = u.path.split("/")
+
+    if parts[1] == "embed":
+        parts = parts[1:]
+
+    if len(parts) > 1 and parts[1].startswith("intl-"):
+        parts = parts[1:]
+
+    l = len(parts)
+    if l == 3 and parts[1] in ["album", "track", "playlist", "artist"]:
+        return {"type": parts[1], "id": parts[2]}
+    if l == 5 and parts[3] == "playlist":
+        return {"type": parts[3], "id": parts[4]}
+    if l >= 4 and parts[1] == "artist" and len(parts) >= 4:
+        if parts[3] == "discography":
+            discography_type = "all"
+            if len(parts) >= 5 and parts[4] in ["all", "album", "single", "compilation"]:
+                discography_type = parts[4]
+            return {"type": "artist_discography", "id": parts[2], "discography_type": discography_type}
+        else:
+            return {"type": "artist", "id": parts[2]}
+
+    raise SpotifyInvalidUrlException("ERROR: unable to determine Spotify URL type or type is unsupported.")
+
+def get_json_from_api(api_url, access_token):
+    headers.update({'Authorization': 'Bearer {}'.format(access_token)})
+    
+    req = requests.get(api_url, headers=headers, timeout=10)
+
+    if req.status_code == 429:
+        seconds = int(req.headers.get("Retry-After", "5")) + 1
+        print(f"INFO: rate limited! Sleeping for {seconds} seconds")
+        sleep(seconds)
+        return None
+
+    if req.status_code != 200:
+        raise SpotifyWebsiteParserException(f"ERROR: {api_url} gave us not a 200. Instead: {req.status_code}")
+        
+    return req.json()
+
+def get_access_token():
+    try:
+        totp, server_time, totp_version = generate_totp()
+        otp_code = totp.at(int(server_time))
+        timestamp_ms = int(time.time() * 1000)
+        
+        params = {
+            'reason': 'init',
+            'productType': 'web-player',
+            'totp': otp_code,
+            'totpServerTime': server_time,
+            'totpVer': str(totp_version),
+            'sTime': server_time,
+            'cTime': timestamp_ms,
+            'buildVer': 'web-player_2025-07-02_1720000000000_12345678',
+            'buildDate': '2025-07-02'
+        }
+        
+        req = requests.get(token_url, headers=headers, params=params, timeout=10)
+        if req.status_code != 200:
+            return {"error": f"Failed to get access token. Status code: {req.status_code}"}
+        return req.json()
+    except Exception as e:
+        return {"error": f"Failed to get access token: {str(e)}"}
+
+def fetch_tracks_in_batches(url: str, access_token: str, batch_size: int = 100, delay: float = 1.0) -> Tuple[List[Dict[str, Any]], int]:
+    all_tracks = []
+    current_batch = 0
+    
+    while url:
+        print(f"Batch : {current_batch}")
+        
+        url_parts = url.split("offset=")
+        if len(url_parts) > 1:
+            offset_part = url_parts[1].split("&")[0]
+            print(f"Offset : {offset_part}")
+        print("-------------")
+        
+        track_data = get_json_from_api(url, access_token)
+        if not track_data:
+            break
+        
+        items = track_data.get('items', [])
+        all_tracks.extend(items)
+        
+        url = track_data.get('next')
+        if url and "&locale=" in url:
+            url = url.split("&locale=")[0]
+            
+        if url and delay > 0:
+            sleep(delay)
+        
+        current_batch += 1
+        
+    return all_tracks, current_batch
+
+def get_raw_spotify_data(spotify_url, batch: bool = False, delay: float = 1.0):
+    url_info = parse_uri(spotify_url)
+    token = get_access_token()
+    
+    if "error" in token:
+        return token
+    
+    access_token = token["accessToken"]
+    raw_data = {}
+    
+    if url_info['type'] == "playlist":
+        try:
+            playlist_data = get_json_from_api(
+                playlist_base_url.format(url_info["id"]), 
+                access_token
+            )
+            if not playlist_data:
+                return {"error": "Failed to get playlist data"}
+                
+            raw_data = playlist_data
+            total_tracks = playlist_data.get('tracks', {}).get('total', 0)
+            
+            if batch:
+                tracks_url = f'https://api.spotify.com/v1/playlists/{url_info["id"]}/tracks?limit=100'
+                tracks, num_batches = fetch_tracks_in_batches(tracks_url, access_token, 100, delay)
+                raw_data['tracks']['items'] = tracks
+                raw_data['_batch_count'] = num_batches
+                raw_data['_batch_enabled'] = True
+                
+                if len(tracks) < total_tracks:
+                    last_offset = len(tracks)
+                    remaining_tracks = []
+                    
+                    while last_offset < total_tracks:
+                        print(f"Batch : {num_batches}")
+                        print(f"Offset : {last_offset}")
+                        print("-------------")
+                        
+                        remainder_url = f'https://api.spotify.com/v1/playlists/{url_info["id"]}/tracks?offset={last_offset}&limit=100'
+                        track_data = get_json_from_api(remainder_url, access_token)
+                        
+                        if not track_data or not track_data.get('items'):
+                            break
+                            
+                        items = track_data.get('items', [])
+                        remaining_tracks.extend(items)
+                        
+                        if len(items) < 100:
+                            break
+                            
+                        last_offset += len(items)
+                        num_batches += 1
+                        
+                        if delay > 0:
+                            sleep(delay)
+                    
+                    tracks.extend(remaining_tracks)
+                    raw_data['tracks']['items'] = tracks
+                    raw_data['_batch_count'] = num_batches
+            else:
+                tracks = []
+                tracks_url = f'https://api.spotify.com/v1/playlists/{url_info["id"]}/tracks?limit=100'
+                while tracks_url:
+                    track_data = get_json_from_api(tracks_url, access_token)
+                    if not track_data:
+                        break
+                        
+                    tracks.extend(track_data['items'])
+                    tracks_url = track_data.get('next')
+                    if tracks_url and "&locale=" in tracks_url:
+                        tracks_url = tracks_url.split("&locale=")[0]
+                    
+                raw_data['tracks']['items'] = tracks
+                raw_data['_batch_enabled'] = False
+                
+        except Exception as e:
+            return {"error": f"Failed to get playlist data: {str(e)}"}
+            
+    elif url_info["type"] == "album":
+        try:
+            album_data = get_json_from_api(
+                album_base_url.format(url_info["id"]),
+                access_token
+            )
+            if not album_data:
+                return {"error": "Failed to get album data"}
+                
+            album_data['_token'] = access_token
+            raw_data = album_data
+            total_tracks = album_data.get('total_tracks', 0)
+            
+            if batch:
+                tracks_url = f'{album_base_url.format(url_info["id"])}/tracks?limit=50'
+                tracks, num_batches = fetch_tracks_in_batches(tracks_url, access_token, 50, delay)
+                raw_data['tracks']['items'] = tracks
+                raw_data['_batch_count'] = num_batches
+                raw_data['_batch_enabled'] = True
+                
+                if len(tracks) < total_tracks:
+                    last_offset = len(tracks)
+                    remaining_tracks = []
+                    
+                    while last_offset < total_tracks:
+                        print(f"Batch : {num_batches}")
+                        print(f"Offset : {last_offset}")
+                        print("-------------")
+                        
+                        remainder_url = f'{album_base_url.format(url_info["id"])}/tracks?offset={last_offset}&limit=50'
+                        track_data = get_json_from_api(remainder_url, access_token)
+                        
+                        if not track_data or not track_data.get('items'):
+                            break
+                            
+                        items = track_data.get('items', [])
+                        remaining_tracks.extend(items)
+                        
+                        if len(items) < 50:
+                            break
+                            
+                        last_offset += len(items)
+                        num_batches += 1
+                        
+                        if delay > 0:
+                            sleep(delay)
+                    
+                    tracks.extend(remaining_tracks)
+                    raw_data['tracks']['items'] = tracks
+                    raw_data['_batch_count'] = num_batches
+            else:
+                tracks = []
+                tracks_url = f'{album_base_url.format(url_info["id"])}/tracks?limit=50'
+                while tracks_url:
+                    track_data = get_json_from_api(tracks_url, access_token)
+                    if not track_data:
+                        break
+                        
+                    tracks.extend(track_data['items'])
+                    tracks_url = track_data.get('next')
+                    if tracks_url and "&locale=" in tracks_url:
+                        tracks_url = tracks_url.split("&locale=")[0]
+                    
+                raw_data['tracks']['items'] = tracks
+                raw_data['_batch_enabled'] = False
+                
+        except Exception as e:
+            return {"error": f"Failed to get album data: {str(e)}"}
+                
+    elif url_info["type"] == "track":
+        try:
+            track_data = get_json_from_api(
+                track_base_url.format(url_info["id"]),
+                access_token
+            )
+            if not track_data:
+                return {"error": "Failed to get track data"}
+                
+            raw_data = track_data
+        except Exception as e:
+            return {"error": f"Failed to get track data: {str(e)}"}
+            
+    elif url_info["type"] == "artist_discography":
+        try:
+            artist_data = get_json_from_api(
+                artist_base_url.format(url_info["id"]),
+                access_token
+            )
+            if not artist_data:
+                return {"error": "Failed to get artist data"}
+            
+            discography_type = url_info.get("discography_type", "all")
+            if discography_type == "all":
+                include_groups = "album,single,compilation"
+            else:
+                include_groups = discography_type
+            
+            albums = []
+            albums_url = f'{artist_albums_url.format(url_info["id"])}?include_groups={include_groups}&limit=50'
+            
+            if batch:
+                albums, num_batches = fetch_tracks_in_batches(albums_url, access_token, 50, delay)
+                raw_data = {
+                    "artist_info": artist_data,
+                    "albums": albums,
+                    "discography_type": discography_type,
+                    "_batch_count": num_batches,
+                    "_batch_enabled": True
+                }
+            else:
+                while albums_url:
+                    album_data = get_json_from_api(albums_url, access_token)
+                    if not album_data:
+                        break
+                        
+                    albums.extend(album_data['items'])
+                    albums_url = album_data.get('next')
+                    if albums_url and "&locale=" in albums_url:
+                        albums_url = albums_url.split("&locale=")[0]
+                
+                raw_data = {
+                    "artist_info": artist_data,
+                    "albums": albums,
+                    "discography_type": discography_type,
+                    "_batch_enabled": False
+                }
+                
+            raw_data['_token'] = access_token
+            
+        except Exception as e:
+            return {"error": f"Failed to get artist discography data: {str(e)}"}
+            
+    elif url_info["type"] == "artist":
+        try:
+            artist_data = get_json_from_api(
+                artist_base_url.format(url_info["id"]),
+                access_token
+            )
+            if not artist_data:
+                return {"error": "Failed to get artist data"}
+                
+            raw_data = artist_data
+        except Exception as e:
+            return {"error": f"Failed to get artist data: {str(e)}"}
+
+    return raw_data
+
+def format_track_data(track_data):
+    artists = []
+    for artist in track_data.get('artists', []):
+        artists.append(artist['name'])
+    
+    image_url = track_data.get('album', {}).get('images', [{}])[0].get('url', '') if track_data.get('album', {}).get('images') else ''
+    
+    isrc = track_data.get('external_ids', {}).get('isrc', '')
+    
+    return {
+        "track": {
+            "artists": ", ".join(artists),
+            "name": track_data.get('name', ''),
+            "album_name": track_data.get('album', {}).get('name', ''),
+            "duration_ms": track_data.get('duration_ms', 0),
+            "images": image_url,
+            "release_date": track_data.get('album', {}).get('release_date', ''),
+            "track_number": track_data.get('track_number', 0),
+            "external_urls": track_data.get('external_urls', {}).get('spotify', ''),
+            "isrc": isrc  
+        }
+    }
+
+def format_album_data(album_data):
+    artists = []
+    for artist in album_data.get('artists', []):
+        artists.append(artist['name'])
+    
+    image_url = album_data.get('images', [{}])[0].get('url', '') if album_data.get('images') else ''
+    
+    track_list = []
+    for track in album_data.get('tracks', {}).get('items', []):
+        track_artists = []
+        for artist in track.get('artists', []):
+            track_artists.append(artist['name'])
+        
+        track_id = track.get('id', '')
+        track_isrc = ''
+        
+        if track_id and album_data.get('_token'):
+            try:
+                full_track_data = get_json_from_api(
+                    track_base_url.format(track_id),
+                    album_data.get('_token')
+                )
+                if full_track_data:
+                    track_isrc = full_track_data.get('external_ids', {}).get('isrc', '')
+            except:
+                pass
+            
+        track_list.append({
+            "artists": ", ".join(track_artists),
+            "name": track.get('name', ''),
+            "album_name": album_data.get('name', ''),
+            "duration_ms": track.get('duration_ms', 0),
+            "images": image_url,
+            "release_date": album_data.get('release_date', ''),
+            "track_number": track.get('track_number', 0),
+            "external_urls": track.get('external_urls', {}).get('spotify', ''),
+            "isrc": track_isrc  
+        })
+    
+    album_info = {
+        "total_tracks": album_data.get('total_tracks', 0),
+        "name": album_data.get('name', ''),
+        "release_date": album_data.get('release_date', ''),
+        "artists": ", ".join(artists),
+        "images": image_url
+    }
+    
+    if album_data.get('_batch_enabled', False):
+        album_info["batch"] = f"{album_data.get('_batch_count', 1)}"
+    
+    return {
+        "album_info": album_info,
+        "track_list": track_list
+    }
+
+def format_playlist_data(playlist_data):
+    image_url = playlist_data.get('images', [{}])[0].get('url', '') if playlist_data.get('images') else ''
+    
+    track_list = []
+    for item in playlist_data.get('tracks', {}).get('items', []):
+        track = item.get('track', {})
+        if not track:
+            continue
+            
+        artists = []
+        for artist in track.get('artists', []):
+            artists.append(artist['name'])
+            
+        track_image = ''
+        if track.get('album', {}).get('images'):
+            track_image = track.get('album', {}).get('images', [{}])[0].get('url', '')
+        
+        track_isrc = track.get('external_ids', {}).get('isrc', '')
+        
+        track_list.append({
+            "artists": ", ".join(artists),
+            "name": track.get('name', ''),
+            "album_name": track.get('album', {}).get('name', ''),
+            "duration_ms": track.get('duration_ms', 0),
+            "images": track_image,
+            "release_date": track.get('album', {}).get('release_date', ''),
+            "track_number": track.get('track_number', 0),
+            "external_urls": track.get('external_urls', {}).get('spotify', ''),
+            "isrc": track_isrc  
+        })
+    
+    playlist_info = {
+        "tracks": {"total": playlist_data.get('tracks', {}).get('total', 0)},
+        "followers": {"total": playlist_data.get('followers', {}).get('total', 0)},
+        "owner": {
+            "display_name": playlist_data.get('owner', {}).get('display_name', ''),
+            "name": playlist_data.get('name', ''),
+            "images": image_url
+        }
+    }
+    
+    if playlist_data.get('_batch_enabled', False):
+        playlist_info["batch"] = f"{playlist_data.get('_batch_count', 1)}"
+    
+    return {
+        "playlist_info": playlist_info,
+        "track_list": track_list
+    }
+
+def format_artist_discography_data(discography_data):
+    artist_info = discography_data.get('artist_info', {})
+    albums = discography_data.get('albums', [])
+    access_token = discography_data.get('_token', '')
+    
+    artist_image = ''
+    if artist_info.get('images'):
+        artist_image = artist_info.get('images', [{}])[0].get('url', '')
+    
+    formatted_artist_info = {
+        "name": artist_info.get('name', ''),
+        "followers": artist_info.get('followers', {}).get('total', 0),
+        "genres": artist_info.get('genres', []),
+        "images": artist_image,
+        "external_urls": artist_info.get('external_urls', {}).get('spotify', ''),
+        "discography_type": discography_data.get('discography_type', 'all'),
+        "total_albums": len(albums)
+    }
+    
+    if discography_data.get('_batch_enabled', False):
+        formatted_artist_info["batch"] = f"{discography_data.get('_batch_count', 1)}"
+    
+    album_list = []
+    all_tracks = []
+    
+    for album in albums:
+        album_image = ''
+        if album.get('images'):
+            album_image = album.get('images', [{}])[0].get('url', '')
+        
+        album_artists = []
+        for artist in album.get('artists', []):
+            album_artists.append(artist['name'])
+        
+        album_info = {
+            "id": album.get('id', ''),
+            "name": album.get('name', ''),
+            "album_type": album.get('album_type', ''),
+            "release_date": album.get('release_date', ''),
+            "total_tracks": album.get('total_tracks', 0),
+            "artists": ", ".join(album_artists),
+            "images": album_image,
+            "external_urls": album.get('external_urls', {}).get('spotify', '')
+        }
+        
+        album_list.append(album_info)
+        
+        if access_token and album.get('id'):
+            try:
+                album_tracks_data = get_json_from_api(
+                    f'{album_base_url.format(album.get("id"))}/tracks?limit=50',
+                    access_token
+                )
+                
+                if album_tracks_data:
+                    tracks = []
+                    tracks_url = f'{album_base_url.format(album.get("id"))}/tracks?limit=50'
+                    
+                    while tracks_url:
+                        track_data = get_json_from_api(tracks_url, access_token)
+                        if not track_data:
+                            break
+                            
+                        tracks.extend(track_data['items'])
+                        tracks_url = track_data.get('next')
+                        if tracks_url and "&locale=" in tracks_url:
+                            tracks_url = tracks_url.split("&locale=")[0]
+                    
+                    for track in tracks:
+                        track_artists = []
+                        for artist in track.get('artists', []):
+                            track_artists.append(artist['name'])
+                        
+                        track_id = track.get('id', '')
+                        track_isrc = ''
+                        
+                        if track_id:
+                            try:
+                                full_track_data = get_json_from_api(
+                                    track_base_url.format(track_id),
+                                    access_token
+                                )
+                                if full_track_data:
+                                    track_isrc = full_track_data.get('external_ids', {}).get('isrc', '')
+                            except:
+                                pass
+                        
+                        formatted_track = {
+                            "artists": ", ".join(track_artists),
+                            "name": track.get('name', ''),
+                            "album_name": album.get('name', ''),
+                            "album_type": album.get('album_type', ''),
+                            "duration_ms": track.get('duration_ms', 0),
+                            "images": album_image,
+                            "release_date": album.get('release_date', ''),
+                            "track_number": track.get('track_number', 0),
+                            "external_urls": track.get('external_urls', {}).get('spotify', ''),
+                            "isrc": track_isrc
+                        }
+                        
+                        all_tracks.append(formatted_track)
+                        
+            except Exception as e:
+                print(f"Error getting tracks for album {album.get('name', '')}: {str(e)}")
+                continue
+    
+    return {
+        "artist_info": formatted_artist_info,
+        "album_list": album_list,
+        "track_list": all_tracks
+    }
+
+def format_artist_data(artist_data):
+    artist_image = ''
+    if artist_data.get('images'):
+        artist_image = artist_data.get('images', [{}])[0].get('url', '')
+    
+    return {
+        "artist": {
+            "name": artist_data.get('name', ''),
+            "followers": artist_data.get('followers', {}).get('total', 0),
+            "genres": artist_data.get('genres', []),
+            "images": artist_image,
+            "external_urls": artist_data.get('external_urls', {}).get('spotify', ''),
+            "popularity": artist_data.get('popularity', 0)
+        }
+    }
+
+def process_spotify_data(raw_data, data_type):
+    if not raw_data or "error" in raw_data:
+        return {"error": "Invalid data provided"}
+        
+    try:
+        if data_type == "track":
+            return format_track_data(raw_data)
+        elif data_type == "album":
+            return format_album_data(raw_data)
+        elif data_type == "playlist":
+            return format_playlist_data(raw_data)
+        elif data_type == "artist_discography":
+            return format_artist_discography_data(raw_data)
+        elif data_type == "artist":
+            return format_artist_data(raw_data)
+        else:
+            return {"error": "Invalid data type"}
+    except Exception as e:
+        return {"error": f"Error processing data: {str(e)}"}
+
+def get_filtered_data(spotify_url, batch=False, delay=1.0):
+    raw_data = get_raw_spotify_data(spotify_url, batch=batch, delay=delay)
+    if raw_data and "error" not in raw_data:
+        url_info = parse_uri(spotify_url)
+        filtered_data = process_spotify_data(raw_data, url_info['type'])
+        return filtered_data
+    return {"error": "Failed to get raw data"}
+
+if __name__ == '__main__':
+    playlist = "https://open.spotify.com/playlist/37i9dQZEVXbNG2KDcFcKOF"
+    album = "https://open.spotify.com/album/6J84szYCnMfzEcvIcfWMFL"
+    song = "https://open.spotify.com/track/7so0lgd0zP2Sbgs2d7a1SZ"
+    
+    artist_discography_all = "https://open.spotify.com/artist/0du5cEVh5yTK9QJze8zA0C/discography/all"
+    artist_discography_albums = "https://open.spotify.com/artist/0du5cEVh5yTK9QJze8zA0C/discography/album"
+    artist_discography_singles = "https://open.spotify.com/artist/0du5cEVh5yTK9QJze8zA0C/discography/single"
+    artist_discography_compilations = "https://open.spotify.com/artist/0du5cEVh5yTK9QJze8zA0C/discography/compilation"
+    
+    print("=== Testing Artist Discography (All) ===")
+    filtered_discography = get_filtered_data(artist_discography_all, batch=True, delay=0.1)
+    print(json.dumps(filtered_discography, indent=2))
+    
+    print("\n=== Testing Playlist ===")
+    filtered_playlist = get_filtered_data(playlist, batch=True, delay=0.1)
+    print(json.dumps(filtered_playlist, indent=2))
+    
+    print("\n=== Testing Album ===")
+    filtered_album = get_filtered_data(album)
+    print(json.dumps(filtered_album, indent=2))
+    
+    print("\n=== Testing Track ===")
+    filtered_track = get_filtered_data(song)
+    print(json.dumps(filtered_track, indent=2))

getSecret.py

@@ -0,0 +1,95 @@
+import json
+import time
+from pathlib import Path
+from DrissionPage import ChromiumPage, ChromiumOptions
+
+def summarise(caps):
+    real = {}
+    for cap in caps:
+        sec = cap.get("secret")
+        if not sec or not isinstance(sec, str):
+            continue
+        ver = cap.get("version") or cap.get("obj", {}).get("version")
+        if ver and ver != 0:
+            real[str(int(ver))] = sec
+    
+    if not real:
+        return False, "No secrets found."
+    
+    versions = sorted(int(k) for k in real.keys())
+    secret_bytes = [
+        {"version": v, "secret": [ord(c) for c in real[str(v)]]}
+        for v in versions
+    ]
+    
+    secrets_dir = Path.home() / ".spotify-secret"
+    secrets_dir.mkdir(exist_ok=True)
+    
+    output_file = secrets_dir / "secretBytes.json"
+    with open(output_file, "w") as f:
+        json.dump(secret_bytes, f, indent=2)
+    
+    return True, f"Saved to: {output_file}"
+
+def grab_live(progress_callback=None):
+    def emit_progress(msg):
+        if progress_callback:
+            progress_callback(msg)
+        else:
+            print(msg)
+    
+    stealth = """(()=>{
+        Object.defineProperty(navigator,'webdriver',{get:()=>false});
+        Object.defineProperty(navigator,'languages',{get:()=>['en-US','en']});
+        Object.defineProperty(navigator,'plugins',{get:()=>[1,2,3,4,5]});
+        window.chrome={runtime:{}};
+        const q=navigator.permissions.query;
+        navigator.permissions.query=p=>p.name==='notifications'?Promise.resolve({state:Notification.permission}):q(p);
+        const g=WebGLRenderingContext.prototype.getParameter;
+        WebGLRenderingContext.prototype.getParameter=function(p){
+            if(p===37445)return'Intel Inc.';if(p===37446)return'Intel Iris OpenGL Engine';return g.call(this,p);
+        };
+    })();"""
+    
+    hook = """(()=>{if(globalThis.__secretHookInstalled)return;
+    globalThis.__secretHookInstalled=true;globalThis.__captures=[];
+    Object.defineProperty(Object.prototype,'secret',{configurable:true,set:function(v){
+        try{__captures.push({secret:v,version:this.version,obj:this});}catch(e){}
+        Object.defineProperty(this,'secret',{value:v,writable:true,configurable:true,enumerable:true});}});
+    })();"""
+    
+    co = ChromiumOptions()
+    co.headless(True)
+    co.set_argument('--disable-blink-features=AutomationControlled')
+    co.set_argument('--no-sandbox')
+    
+    page = ChromiumPage(addr_or_opts=co)
+    try:
+        page.run_cdp('Page.addScriptToEvaluateOnNewDocument', source=stealth)
+        page.run_cdp('Page.addScriptToEvaluateOnNewDocument', source=hook)
+        emit_progress("Opening Spotify...")
+        page.get("https://open.spotify.com")
+        time.sleep(3)
+        caps = page.run_js("return globalThis.__captures || []")
+        for c in caps:
+            if isinstance(c, dict) and c.get("secret") and c.get("version"):
+                emit_progress(f"Secret({int(c['version'])}): {c['secret']}")
+        return caps or []
+    finally:
+        page.quit()
+
+def scrape_and_save(progress_callback=None):
+    try:
+        caps = grab_live(progress_callback)
+        return summarise(caps)
+    except Exception as e:
+        return False, f"Error: {str(e)}"
+
+def main():
+    success, message = scrape_and_save()
+    print(message)
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

getTracks.py

@@ -1,143 +0,0 @@
-import requests
-import time
-import os
-import asyncio
-from GetMetadata import main as get_metadata
-
-class TrackDownloader:
-    def __init__(self, use_fallback=False):
-        self.client = requests.Session()
-        self.headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-        self.progress_callback = None
-        self.filename_format = 'title_artist'
-        self.use_fallback = use_fallback
-        self.base_domain = "lucida.su" if use_fallback else "lucida.to"
-
-    def set_progress_callback(self, callback):
-        self.progress_callback = callback
-        
-    def set_filename_format(self, format_type):
-        self.filename_format = format_type
-
-    def generate_filename(self, metadata):
-        if self.filename_format == 'artist_title':
-            filename = f"{metadata['artists']} - {metadata['title']}.flac"
-        else:
-            filename = f"{metadata['title']} - {metadata['artists']}.flac"
-        return self.sanitize_filename(filename)
-
-    async def get_track_info(self):
-        metadata = await get_metadata()
-        return metadata
-
-    def sanitize_filename(self, filename):
-        invalid_chars = '<>:"/\\|?*'
-        for char in invalid_chars:
-            filename = filename.replace(char, '')
-            
-        filename = ' '.join(filename.split())
-        filename = filename.replace(' ,', ',')
-        filename = filename.replace(',', ', ')
-        while '  ' in filename:
-            filename = filename.replace('  ', ' ')
-        filename = filename.rsplit('.', 1)
-        filename[0] = filename[0].strip()
-        return '.'.join(filename)
-
-    def download(self, metadata, output_dir):
-        track_url = metadata['url']
-        primary_token = metadata['token']
-        expiry = metadata['expiry']
-        
-        print(f"Starting download for: {track_url}")
-        
-        initial_request = {
-            "account": {"id": "auto", "type": "country"},
-            "compat": "false",
-            "downscale": "original",
-            "handoff": True,
-            "metadata": True,
-            "private": True,
-            "token": {
-                "expiry": expiry,
-                "primary": primary_token
-            },
-            "upload": {"enabled": False, "service": "pixeldrain"},
-            "url": track_url
-        }
-
-        response = self.client.post(f"https://{self.base_domain}/api/load?url=/api/fetch/stream/v2", 
-                                    json=initial_request, 
-                                    headers=self.headers)
-        
-        csrf_token = response.cookies.get('csrf_token')
-        if csrf_token:
-            self.headers['X-CSRF-Token'] = csrf_token
-
-        initial_response = response.json()
-
-        if not initial_response.get("success", False):
-            raise Exception(f"Initial request failed: {initial_response.get('error', 'Unknown error')}")
-
-        handoff = initial_response["handoff"]
-        server = initial_response["server"]
-
-        file_name = self.generate_filename(metadata)
-
-        completion_url = f"https://{server}.{self.base_domain}/api/fetch/request/{handoff}"
-
-        print("Waiting for track processing to complete")
-        while True:
-            completion_response = self.client.get(completion_url, headers=self.headers).json()
-            if completion_response["status"] == "completed":
-                break
-            elif completion_response["status"] == "error":
-                raise Exception(f"API request failed: {completion_response.get('message', 'Unknown error')}")
-            time.sleep(1)
-
-        download_url = f"https://{server}.{self.base_domain}/api/fetch/request/{handoff}/download"
-        print(f"Starting download of: {file_name}")
-        
-        response = self.client.get(download_url, stream=True, headers=self.headers)
-        total_size = int(response.headers.get('content-length', 0))
-        downloaded_size = 0
-
-        file_path = os.path.join(output_dir, file_name)
-
-        try:
-            with open(file_path, 'wb') as file:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        file.write(chunk)
-                        downloaded_size += len(chunk)
-                        if self.progress_callback:
-                            self.progress_callback(downloaded_size, total_size)
-                
-                if downloaded_size == 0:
-                    raise Exception("No data received from server")
-                
-            return file_path
-            
-        except Exception as e:
-            if os.path.exists(file_path) and os.path.getsize(file_path) == 0:
-                try:
-                    os.remove(file_path)
-                except:
-                    pass
-            raise e
-
-async def main():
-    downloader = TrackDownloader()
-    output_dir = "."
-    
-    try:
-        metadata = await downloader.get_track_info()
-        downloaded_file = downloader.download(metadata, output_dir)
-        print(f"File downloaded successfully: {downloaded_file}")
-    except Exception as e:
-        print(f"An error occurred: {str(e)}")
-
-if __name__ == "__main__":
-    asyncio.run(main())

icons/circle-x.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <circle cx="12" cy="12" r="10"/>
+  <line x1="15" y1="9" x2="9" y2="15"/>
+  <line x1="9" y1="9" x2="15" y2="15"/>
+</svg>

icons/download.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/>
+  <polyline points="7 10 12 15 17 10"/>
+  <line x1="12" y1="15" x2="12" y2="3"/>
+</svg>

icons/icon.svg

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 28.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 512 512"
+	 style="enable-background:new 0 0 512 512;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:#FF0000;stroke:#373435;stroke-width:0.5669;stroke-miterlimit:10;}
+	.st1{fill-rule:evenodd;clip-rule:evenodd;fill:#FFFF00;stroke:#373435;stroke-width:0.5669;stroke-miterlimit:10;}
+	.st2{fill-rule:evenodd;clip-rule:evenodd;fill:#2AA125;stroke:#373435;stroke-width:0.5669;stroke-miterlimit:10;}
+</style>
+<g id="SVGRepo_bgCarrier">
+</g>
+<g id="SVGRepo_tracerCarrier">
+</g>
+<g id="Layer_x0020_1">
+	<g id="_1818452274576">
+		<g id="SVGRepo_bgCarrier_00000044893734704698182460000014884511992085247122_">
+		</g>
+		<g id="SVGRepo_tracerCarrier_00000067939915892718314930000001743019108017086612_">
+		</g>
+		<g id="SVGRepo_iconCarrier_00000176000695080737548300000008661679408724292005_">
+			<path d="M407.1,227.2c-54.7-27.6-119.3-43.8-187.6-43.8c-38.9,0-76.5,5.2-112.3,15l3-0.7c-2.1,0.7-4.5,1.1-7,1.1
+				c-13,0-23.5-10.5-23.5-23.5c0-10.5,6.8-19.3,16.3-22.4l0.2-0.1c90.9-26.9,240.6-21.8,335.4,34.6c7.3,4.4,12.1,12.3,12.1,21.3
+				c0,4.4-1.2,8.6-3.2,12.2l0.1-0.1c-5,5.9-12.3,9.6-20.6,9.6c-4.7,0-9-1.2-12.8-3.3L407.1,227.2L407.1,227.2z M404.5,298.9
+				c-3.4,5.7-9.6,9.4-16.6,9.4c-3.8,0-7.4-1.1-10.4-3l0.1,0.1c-46.8-26.8-102.8-42.5-162.5-42.5c-32.9,0-64.6,4.8-94.6,13.7l2.3-0.6
+				c-1.7,0.5-3.7,0.9-5.8,0.9c-10.7,0-19.4-8.7-19.4-19.4c0-8.7,5.7-16,13.5-18.5l0.1,0c30.8-9.1,66.2-14.4,102.8-14.4
+				c68.1,0,132,18.2,187,49.9l-1.8-1c5.1,3.3,8.4,8.9,8.4,15.3C407.7,292.5,406.5,296,404.5,298.9L404.5,298.9L404.5,298.9
+				L404.5,298.9z M373.8,369.3c-2.7,4.6-7.6,7.7-13.3,7.7c-3.2,0-6.1-1-8.6-2.6l0.1,0c-40.9-23-89.7-36.5-141.7-36.5
+				c-29.8,0-58.6,4.5-85.7,12.7l2.1-0.5c-1.1,0.3-2.5,0.5-3.8,0.5c-8.7,0-15.8-7.1-15.8-15.8c0-7.4,5.1-13.6,11.9-15.3l0.1,0
+				c27-8,58-12.6,90.1-12.6c58.1,0,112.6,15.1,159.9,41.7l-1.7-0.9c5.2,2.6,8.6,7.8,8.6,13.8C376,364.3,375.2,367.1,373.8,369.3
+				L373.8,369.3L373.8,369.3L373.8,369.3z M256-0.6L256-0.6C114.6-0.6,0,114,0,255.4s114.6,256,256,256s256-114.6,256-256l0,0
+				C511.6,114.2,397.2-0.2,256-0.6L256-0.6L256-0.6L256-0.6z"/>
+		</g>
+	</g>
+	<path class="st0" d="M406.9,227.2c0,0,0.1,0,0.1,0.1L406.9,227.2z M107.1,198.5c35.8-9.8,73.4-15,112.3-15
+		c68.3,0,132.8,16.1,187.5,43.7c3.8,2.1,8.2,3.3,12.8,3.3c8.2,0,15.6-3.7,20.5-9.6c0,0,0,0,0,0c2-3.6,3.1-7.7,3.1-12
+		c0-9-4.8-16.8-12.1-21.3c-94.7-56.4-244.5-61.5-335.4-34.6l-0.2,0.1c-9.4,3.1-16.3,11.9-16.3,22.4c0,13,10.5,23.5,23.5,23.5
+		c2.5,0,4.9-0.4,7-1.1L107.1,198.5L107.1,198.5z"/>
+	<path class="st1" d="M401.2,274.3c-55-31.8-118.9-49.9-187-49.9c-36.6,0-72,5.3-102.8,14.4l-0.1,0c-7.9,2.5-13.5,9.9-13.5,18.5
+		c0,10.7,8.7,19.4,19.4,19.4c1.3,0,2.5-0.1,3.6-0.3c29.9-8.8,61.5-13.6,94.3-13.6c59.7,0,115.7,15.7,162.4,42.5l0.1,0.1
+		c3,1.9,6.5,3,10.3,3c7,0,13.1-3.7,16.6-9.4l0,0c2-2.9,3.2-6.5,3.2-10.3c0-6.4-3.3-12-8.4-15.3L401.2,274.3L401.2,274.3z"/>
+	<path class="st2" d="M352,374.4C352,374.4,352,374.4,352,374.4L352,374.4z M373.8,369.3C373.8,369.3,373.7,369.4,373.8,369.3
+		L373.8,369.3L373.8,369.3z M367.8,347.8l-0.4-0.2C367.5,347.6,367.6,347.7,367.8,347.8z M369,348.4
+		c-47.3-26.5-101.8-41.7-159.9-41.7c-32.1,0-63.1,4.6-90.1,12.6l-0.1,0c-6.8,1.8-11.9,8-11.9,15.3c0,8.7,7.1,15.8,15.8,15.8
+		c1,0,1.9-0.1,2.8-0.3c26.8-8.1,55.2-12.4,84.6-12.4c52,0,100.8,13.5,141.7,36.5l0,0c2.4,1.6,5.4,2.6,8.5,2.6
+		c5.7,0,10.6-3.1,13.3-7.7h0c1.4-2.3,2.2-5,2.2-7.9c0-5.9-3.3-11-8.2-13.6L369,348.4L369,348.4z"/>
+</g>
+</svg>

icons/tool.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.77-3.77a6 6 0 0 1-7.94 7.94l-6.91 6.91a2.12 2.12 0 0 1-3-3l6.91-6.91a6 6 0 0 1 7.94-7.94l-3.76 3.76z"/>
+</svg>

icons/trash.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <polyline points="3 6 5 6 21 6"/>
+  <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+  <line x1="10" y1="11" x2="10" y2="17"/>
+  <line x1="14" y1="11" x2="14" y2="17"/>
+</svg>

requirements.txt

@@ -0,0 +1,9 @@
+PyQt6
+pyqt6-tools
+pyqtdarktheme
+requests
+mutagen
+pyotp
+packaging
+pyinstaller
+DrissionPage

tidalDL.py

@@ -0,0 +1,509 @@
+import os
+import re
+import time
+import base64
+import requests
+import json
+from mutagen.flac import FLAC, Picture
+from mutagen.id3 import PictureType
+
+class ProgressCallback:
+    def __call__(self, current, total):
+        if total > 0:
+            percent = (current / total) * 100
+            print(f"\r{percent:.2f}% ({current}/{total})", end="")
+        else:
+            print(f"\r{current / (1024 * 1024):.2f} MB", end="")
+
+class TidalDownloader:
+    def __init__(self, timeout=30, max_retries=3, api_url=None):
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.download_chunk_size = 256 * 1024
+        self.progress_callback = ProgressCallback()
+        self.client_id = base64.b64decode("NkJEU1JkcEs5aHFFQlRnVQ==").decode()
+        self.client_secret = base64.b64decode("eGV1UG1ZN25icFo5SUliTEFjUTkzc2hrYTFWTmhlVUFxTjZJY3N6alRHOD0=").decode()
+        self.api_url = api_url or "https://hifi.401658.xyz"
+    
+    @staticmethod
+    def get_available_apis():
+        try:
+            response = requests.get("https://status.monochrome.tf/api/stream", timeout=10, stream=True)
+            
+            for line in response.iter_lines():
+                if line:
+                    line_str = line.decode('utf-8')
+                    if line_str.startswith('data: '):
+                        data = json.loads(line_str[6:])
+                        
+                        api_instances = [
+                            inst for inst in data.get('instances', [])
+                            if inst.get('instance_type') == 'api' and inst.get('last_check', {}).get('success')
+                        ]
+                        
+                        api_instances.sort(key=lambda x: x.get('avg_response_time', 9999))
+                        
+                        return api_instances
+                        
+        except Exception as e:
+            print(f"Failed to fetch API list: {e}")
+            return []
+    
+    @staticmethod
+    def select_api_interactive():
+        apis = TidalDownloader.get_available_apis()
+        
+        if not apis:
+            print("No APIs available, using default: https://hifi.401658.xyz")
+            return "https://hifi.401658.xyz"
+        
+        print("\n=== Available API Instances ===")
+        print(f"{'No':<4} {'URL':<40} {'Status':<8} {'Uptime':<8} {'Avg Response':<12}")
+        print("-" * 80)
+        
+        for i, api in enumerate(apis, 1):
+            url = api.get('url', 'N/A')
+            status = "UP" if api.get('last_check', {}).get('success') else "DOWN"
+            uptime = f"{api.get('uptime', 0):.1f}%"
+            avg_time = f"{api.get('avg_response_time', 0)}ms"
+            
+            print(f"{i:<4} {url:<40} {status:<8} {uptime:<8} {avg_time:<12}")
+        
+        print("\n0    Use default (https://hifi.401658.xyz)")
+        print("-" * 80)
+        
+        while True:
+            try:
+                choice = input(f"\nSelect API (0-{len(apis)}) [1 for fastest]: ").strip()
+                
+                if not choice:
+                    choice = "1"
+                
+                choice_num = int(choice)
+                
+                if choice_num == 0:
+                    return "https://hifi.401658.xyz"
+                elif 1 <= choice_num <= len(apis):
+                    selected_url = apis[choice_num - 1]['url']
+                    print(f"\nSelected: {selected_url}")
+                    return selected_url
+                else:
+                    print(f"Invalid choice. Please enter 0-{len(apis)}")
+            except ValueError:
+                print("Invalid input. Please enter a number.")
+            except KeyboardInterrupt:
+                print("\nUsing default API")
+                return "https://hifi.401658.xyz"
+
+    def set_progress_callback(self, callback):
+        self.progress_callback = callback
+
+    def sanitize_filename(self, filename):
+        if not filename: 
+            return "Unknown Track"
+        sanitized = re.sub(r'[\\/*?:"<>|]', "", str(filename))
+        return re.sub(r'\s+', ' ', sanitized).strip() or "Unnamed Track"
+
+    def get_access_token(self):
+        refresh_url = "https://auth.tidal.com/v1/oauth2/token"
+        
+        payload = {
+            "client_id": self.client_id,
+            "grant_type": "client_credentials",
+        }
+        
+        try:
+            response = requests.post(
+                url=refresh_url,
+                data=payload,
+                auth=(self.client_id, self.client_secret),
+                timeout=self.timeout
+            )
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                return token_data.get("access_token")
+            else:
+                return None
+                
+        except:
+            return None
+
+    def search_tracks(self, query):
+        try:
+            tidal_token = self.get_access_token()
+            if not tidal_token:
+                raise Exception("Failed to get access token")
+
+            search_url = f"https://api.tidal.com/v1/search/tracks?query={query}&limit=25&offset=0&countryCode=US"
+            header = {"authorization": f"Bearer {tidal_token}"}
+
+            search_data = requests.get(url=search_url, headers=header, timeout=self.timeout)
+            response_data = search_data.json()
+            
+            filtered_items = [{
+                "id": item.get("id"),
+                "title": item.get("title"),
+                "url": item.get("url"),
+                "isrc": item.get("isrc"),
+                "audioQuality": item.get("audioQuality"),
+                "mediaMetadata": item.get("mediaMetadata"),
+                "album": item.get("album", {}),
+                "artists": item.get("artists", []),
+                "artist": item.get("artist", {}),
+                "trackNumber": item.get("trackNumber"),
+                "volumeNumber": item.get("volumeNumber"),
+                "duration": item.get("duration"),
+                "copyright": item.get("copyright"),
+                "explicit": item.get("explicit")
+            } for item in response_data.get("items", [])]
+            
+            return {
+                "limit": response_data.get("limit"),
+                "offset": response_data.get("offset"),
+                "totalNumberOfItems": response_data.get("totalNumberOfItems"),
+                "items": filtered_items
+            }
+
+        except Exception as e:
+            raise Exception(f"Search error: {str(e)}")
+
+    def get_track_info(self, query, isrc=None):
+        print(f"Fetching: {query}" + (f" (ISRC: {isrc})" if isrc else ""))
+        
+        try:
+            result = self.search_tracks(query)
+            
+            if not result or not result.get("items"):
+                raise Exception(f"No tracks found for query: {query}")
+            
+            selected_track = None
+            if isrc:
+                isrc_items = [item for item in result["items"] if item.get("isrc") == isrc]
+                
+                if len(isrc_items) > 1:
+                    hires_items = []
+                    for item in isrc_items:
+                        media_metadata = item.get("mediaMetadata", {})
+                        tags = media_metadata.get("tags", []) if media_metadata else []
+                        if "HIRES_LOSSLESS" in tags:
+                            hires_items.append(item)
+                    
+                    if hires_items:
+                        selected_track = hires_items[0]
+                    else:
+                        selected_track = isrc_items[0]
+                elif len(isrc_items) == 1:
+                    selected_track = isrc_items[0]
+                else:
+                    selected_track = result["items"][0]
+            else:
+                selected_track = result["items"][0]
+                
+            if not selected_track:
+                raise Exception(f"Track not found: {query}" + (f" (ISRC: {isrc})" if isrc else ""))
+                
+            title = selected_track.get('title', 'Unknown')
+            quality = selected_track.get('audioQuality', 'Unknown')
+            print(f"Found: {title} ({quality})")
+            return selected_track
+            
+        except Exception as e:
+            raise Exception(f"Error getting track info: {str(e)}")
+
+    def get_download_url(self, track_id, quality="LOSSLESS"):
+        print("Fetching URL...")
+        download_api_url = f"{self.api_url}/track/?id={track_id}&quality={quality}"
+        
+        try:
+            response = requests.get(download_api_url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                for item in data:
+                    if "OriginalTrackUrl" in item:
+                        print("URL found")
+                        return {
+                            "download_url": item["OriginalTrackUrl"],
+                            "track_info": data[0] if data else {}
+                        }
+                
+                raise Exception("Download URL not found in response")
+            else:
+                raise Exception(f"API returned status code: {response.status_code}")
+                
+        except Exception as e:
+            raise Exception(f"Error getting download URL: {str(e)}")
+
+    def download_album_art(self, album_id, size="1280x1280"):
+        try:
+            art_url = f"https://resources.tidal.com/images/{album_id.replace('-', '/')}/{size}.jpg"
+            
+            response = requests.get(art_url, timeout=self.timeout)
+            
+            if response.status_code == 200:
+                return response.content
+            else:
+                print(f"Failed to download album art: HTTP {response.status_code}")
+                return None
+                
+        except Exception as e:
+            print(f"Error downloading album art: {str(e)}")
+            return None
+
+    def download_file(self, url, filepath, is_paused_callback=None, is_stopped_callback=None):
+        file_dir = os.path.dirname(filepath)
+        if file_dir and not os.path.exists(file_dir):
+            os.makedirs(file_dir, exist_ok=True)
+        
+        temp_filepath = filepath + ".part"
+        retry_count = 0
+        
+        while retry_count <= self.max_retries:
+            try:
+                response = requests.get(url, timeout=60.0)
+                if response.status_code != 200:
+                    raise Exception(f"HTTP {response.status_code}")
+                
+                if is_stopped_callback and is_stopped_callback():
+                    raise Exception("Download stopped")
+                    
+                while is_paused_callback and is_paused_callback():
+                    time.sleep(0.1)
+                    if is_stopped_callback and is_stopped_callback():
+                        raise Exception("Download stopped")
+                
+                with open(temp_filepath, 'wb') as f:
+                    f.write(response.content)
+                
+                downloaded_size = len(response.content)
+                
+                if self.progress_callback:
+                    self.progress_callback(downloaded_size, downloaded_size)
+                    
+                os.rename(temp_filepath, filepath)
+                print("Download complete")
+                return {"success": True, "size": downloaded_size}
+                
+            except Exception as e:
+                retry_count += 1
+                if retry_count > self.max_retries:
+                    if os.path.exists(temp_filepath):
+                        try:
+                            os.remove(temp_filepath)
+                        except:
+                            pass
+                    raise Exception(f"Download error after {self.max_retries} retries: {str(e)}")
+                
+                print(f"Download error (attempt {retry_count}/{self.max_retries}): {str(e)}")
+                print(f"Retrying in {retry_count * 2} seconds...")
+                time.sleep(retry_count * 2)
+
+    def embed_metadata(self, filepath, track_info, search_info=None):
+        try:
+            print("Embedding metadata...")
+            audio = FLAC(filepath)
+            audio.clear()
+            audio.clear_pictures()
+            
+            if track_info.get("title"):
+                audio["TITLE"] = track_info["title"]
+            
+            artists_list = []
+            if search_info and search_info.get("artists"):
+                for artist in search_info["artists"]:
+                    if artist.get("name"):
+                        artists_list.append(artist["name"])
+            elif search_info and search_info.get("artist") and search_info["artist"].get("name"):
+                artists_list.append(search_info["artist"]["name"])
+            elif track_info.get("artists"):
+                for artist in track_info["artists"]:
+                    if artist.get("name"):
+                        artists_list.append(artist["name"])
+            elif track_info.get("artist") and track_info["artist"].get("name"):
+                artists_list.append(track_info["artist"]["name"])
+            
+            if artists_list:
+                audio["ARTIST"] = artists_list[0]  
+                if len(artists_list) > 1:
+                    audio["ALBUMARTIST"] = "; ".join(artists_list)
+                else:
+                    audio["ALBUMARTIST"] = artists_list[0]
+            
+            album_info = search_info.get("album", {}) if search_info else track_info.get("album", {})
+            if album_info.get("title"):
+                audio["ALBUM"] = album_info["title"]
+            
+            if search_info and search_info.get("trackNumber"):
+                audio["TRACKNUMBER"] = str(search_info["trackNumber"])
+            elif track_info.get("trackNumber"):
+                audio["TRACKNUMBER"] = str(track_info["trackNumber"])
+            
+            if search_info and search_info.get("volumeNumber"):
+                audio["DISCNUMBER"] = str(search_info["volumeNumber"])
+            elif track_info.get("volumeNumber"):
+                audio["DISCNUMBER"] = str(track_info["volumeNumber"])
+            
+            duration = search_info.get("duration") if search_info else track_info.get("duration")
+            if duration:
+                audio["LENGTH"] = str(duration)
+            
+            isrc = search_info.get("isrc") if search_info else track_info.get("isrc")
+            if isrc:
+                audio["ISRC"] = isrc
+            
+            copyright_info = search_info.get("copyright") if search_info else track_info.get("copyright")
+            if copyright_info:
+                audio["COPYRIGHT"] = copyright_info
+            
+            if album_info.get("releaseDate"):
+                audio["DATE"] = album_info["releaseDate"][:4]
+                try:
+                    audio["YEAR"] = album_info["releaseDate"][:4]
+                except:
+                    pass
+            
+            if track_info.get("genre"):
+                audio["GENRE"] = track_info["genre"]
+            
+            if track_info.get("audioQuality"):
+                audio["COMMENT"] = f"Tidal {track_info['audioQuality']}"
+            
+            if album_info.get("cover"):
+                album_art = self.download_album_art(album_info["cover"])
+                if album_art:
+                    picture = Picture()
+                    picture.data = album_art
+                    picture.type = PictureType.COVER_FRONT
+                    picture.mime = "image/jpeg"
+                    picture.desc = "Cover"
+                    audio.add_picture(picture)
+                    print("Album art embedded")
+            
+            audio.save()
+            print(f"Metadata embedded successfully for: {track_info.get('title', 'Unknown')}")
+            return True
+            
+        except Exception as e:
+            print(f"Error embedding metadata: {str(e)}")
+            return False
+
+    def download(self, query, isrc=None, output_dir=".", quality="LOSSLESS", is_paused_callback=None, is_stopped_callback=None, auto_fallback=False):
+        if output_dir != ".":
+            try:
+                os.makedirs(output_dir, exist_ok=True)
+            except OSError as e:
+                raise Exception(f"Directory error: {e}")
+        
+        if auto_fallback:
+            apis = self.get_available_apis()
+            if not apis:
+                print("No APIs available for fallback, using current API")
+                return self._download_single(query, isrc, output_dir, quality, is_paused_callback, is_stopped_callback)
+            
+            last_error = None
+            for i, api in enumerate(apis, 1):
+                api_url = api.get('url')
+                try:
+                    print(f"[Auto Fallback {i}/{len(apis)}] Trying: {api_url}")
+                    
+                    fallback_downloader = TidalDownloader(api_url=api_url)
+                    fallback_downloader.set_progress_callback(self.progress_callback)
+                    
+                    result = fallback_downloader._download_single(
+                        query, isrc, output_dir, quality, 
+                        is_paused_callback, is_stopped_callback
+                    )
+                    
+                    print(f"✓ Success with: {api_url}")
+                    return result
+                    
+                except Exception as e:
+                    last_error = str(e)
+                    print(f"✗ Failed with {api_url}: {last_error[:80]}")
+                    continue
+            
+            raise Exception(f"All {len(apis)} APIs failed. Last error: {last_error}")
+        
+        return self._download_single(query, isrc, output_dir, quality, is_paused_callback, is_stopped_callback)
+    
+    def _download_single(self, query, isrc, output_dir, quality, is_paused_callback, is_stopped_callback):
+        track_info = self.get_track_info(query, isrc)
+        track_id = track_info.get("id")
+        
+        if not track_id:
+            raise Exception("No track ID found")
+        
+        artists_list = []
+        if track_info.get("artists"):
+            for artist in track_info["artists"]:
+                if artist.get("name"):
+                    artists_list.append(artist["name"])
+        elif track_info.get("artist") and track_info["artist"].get("name"):
+            artists_list.append(track_info["artist"]["name"])
+        
+        artist_name = ", ".join(artists_list) if artists_list else "Unknown Artist"
+        artist_name = self.sanitize_filename(artist_name)
+        track_title = self.sanitize_filename(track_info.get("title", f"track_{track_id}"))
+        
+        output_filename = os.path.join(output_dir, f"{artist_name} - {track_title}.flac")
+        
+        if os.path.exists(output_filename):
+            file_size = os.path.getsize(output_filename)
+            if file_size > 0:
+                print(f"File already exists: {output_filename} ({file_size / (1024 * 1024):.2f} MB)")
+                return output_filename
+        
+        download_info = self.get_download_url(track_id, quality)
+        download_url = download_info["download_url"]
+        download_track_info = download_info["track_info"]
+        
+        print(f"Downloading to: {output_filename}")
+        self.download_file(
+            download_url, 
+            output_filename, 
+            is_paused_callback=is_paused_callback, 
+            is_stopped_callback=is_stopped_callback
+        )
+        
+        print("Adding metadata...")
+        try:
+            self.embed_metadata(output_filename, download_track_info, track_info)
+            print("Metadata saved")
+        except Exception as e:
+            print(f"Tagging failed: {e}")
+        
+        print("Done")
+        return output_filename
+
+def main():
+    print("=== TidalDL - Tidal Downloader ===")
+    
+    selected_api = TidalDownloader.select_api_interactive()
+    downloader = TidalDownloader(timeout=30, max_retries=3, api_url=selected_api)
+    
+    query = "APT."
+    isrc = "USAT22409172"
+    output_dir = "."
+    
+    try:
+        downloaded_file = downloader.download(query, isrc, output_dir)
+        print(f"Success: File saved as {downloaded_file}")
+    except Exception as e:
+        print(f"Error: {str(e)}")
+
+if __name__ == "__main__":
+    try:
+        import sys
+        if sys.platform == "win32":
+            import os
+            os.system("chcp 65001 > nul")
+            try:
+                sys.stdout.reconfigure(encoding='utf-8')
+            except:
+                pass
+    except:
+        pass
+        
+    main()

version.json

@@ -0,0 +1,3 @@
+{
+  "version": "5.2"
+}