v3.4

README.md

@@ -1,29 +1,31 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotiFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotiFLAC/releases)
 
-![spotiflac](https://github.com/user-attachments/assets/a233a276-14a4-4f4c-b267-f182dd3912a0)
+![SpotiFLAC](https://github.com/user-attachments/assets/b4c4f403-edbd-4a71-b74b-c7d433d47d06)
 
 <div align="center">
-<b>SpotiFLAC</b> allows you to download Spotify tracks in true FLAC format through services like Tidal, Amazon Music and Deezer with the help of Lucida.
+<b>SpotiFLAC</b> allows you to download Spotify tracks in true FLAC format through services like Tidal, Amazon Music, and Deezer <code>(via Lucida)</code>, as well as Qobuz <code>(via SquidWTF)</code>.
 </div>
 
-### [Download](https://github.com/afkarxyz/SpotiFLAC/releases/download/v2.3/SpotiFLAC.exe)
+### [Download](https://github.com/afkarxyz/SpotiFLAC/releases/download/v3.3/SpotiFLAC.exe)
 
 #
 
-> [!WARNING] 
+> [!Note] 
-Sometimes, the **download speed** from Lucida can be fast or slow; it varies unpredictably.
+**Download speed** from Lucida is unpredictable—sometimes fast, sometimes slow. Join their [Discord](https://discord.com/invite/dXEGRWqEbS) for updates.
 
 ## Screenshots
 
-![image](https://github.com/user-attachments/assets/611b8b52-6615-44fe-b6f8-905c07801c47)
+![image](https://github.com/user-attachments/assets/70a5dceb-3374-4255-8f6a-4afb5ee534b0)
 
-![image](https://github.com/user-attachments/assets/81e65977-11f0-4162-96f3-90730dd87e74)
+![image](https://github.com/user-attachments/assets/9f0d6aa5-456b-4a90-b48a-7e0c22819ebd)
 
-![image](https://github.com/user-attachments/assets/4dd37c0a-30e3-479a-9b3d-57fd360d87b3)
+![image](https://github.com/user-attachments/assets/be9a79b5-260e-4948-9f72-10c735210ab7)
 
-![image](https://github.com/user-attachments/assets/66f1ae70-e049-4b4c-ba81-1df5054d0e7d)
+![image](https://github.com/user-attachments/assets/c4403934-9003-447e-a27b-fc74cab23454)
 
-![image](https://github.com/user-attachments/assets/04954db9-e94a-4f9d-8eac-46d7ff7a4c33)
+![image](https://github.com/user-attachments/assets/1feec621-f8bf-4b2a-ae73-afcb1fb1deba)
+
+![image](https://github.com/user-attachments/assets/c64b9a08-c99a-4d3a-ae8b-5f834623915b)
 
 > When **Fallback** is enabled, it will use the backup server `Lucida.su`
 

SpotiFLAC.py

@@ -10,14 +10,14 @@ from PyQt6.QtWidgets import (
     QApplication, QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLineEdit,
     QLabel, QFileDialog, QListWidget, QTextEdit, QTabWidget, QButtonGroup, QRadioButton,
     QAbstractItemView, QSpacerItem, QSizePolicy, QProgressBar, QCheckBox, QDialog,
-    QDialogButtonBox, QComboBox, QStyledItemDelegate, QStyle
+    QDialogButtonBox, QComboBox, QStyledItemDelegate
 )
 from PyQt6.QtCore import Qt, QThread, pyqtSignal, QUrl, QTimer, QTime, QSettings, QSize
-from PyQt6.QtGui import QIcon, QTextCursor, QDesktopServices, QPixmap, QBrush, QPalette
+from PyQt6.QtGui import QIcon, QTextCursor, QDesktopServices, QPixmap, QBrush
 from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
 
 from getMetadata import get_filtered_data, parse_uri, SpotifyInvalidUrlException
-from getTracks import TrackDownloader
+from getTracks import LucidaDownloader, SquidWTFDownloader, TidalDownloader 
 
 @dataclass
 class Track:
@@ -28,6 +28,7 @@ class Track:
     track_number: int
     duration_ms: int
     id: str
+    isrc: str = ""
 
 class MetadataFetchWorker(QThread):
     finished = pyqtSignal(dict)
@@ -55,7 +56,7 @@ class DownloadWorker(QThread):
     
     def __init__(self, tracks, outpath, is_single_track=False, is_album=False, is_playlist=False, 
                  album_or_playlist_name='', filename_format='title_artist', use_track_numbers=True,
-                 use_album_subfolders=False, use_fallback=False, service="amazon"):
+                 use_album_subfolders=False, service="amazon", timeout=30, qobuz_region="us"):
         super().__init__()
         self.tracks = tracks
         self.outpath = outpath
@@ -66,8 +67,9 @@ class DownloadWorker(QThread):
         self.filename_format = filename_format
         self.use_track_numbers = use_track_numbers
         self.use_album_subfolders = use_album_subfolders
-        self.use_fallback = use_fallback
         self.service = service
+        self.timeout = timeout
+        self.qobuz_region = qobuz_region
         self.is_paused = False
         self.is_stopped = False
         self.failed_tracks = []
@@ -81,7 +83,12 @@ class DownloadWorker(QThread):
 
     def run(self):
         try:
-            downloader = TrackDownloader(self.use_fallback)
+            if self.service == "qobuz":
+                downloader = SquidWTFDownloader(self.qobuz_region, self.timeout)
+            elif self.service == "tidal_api": 
+                downloader = TidalDownloader(timeout=self.timeout)
+            else:
+                downloader = LucidaDownloader(timeout=self.timeout)
             
             def progress_update(current, total):
                 if total > 0:
@@ -109,9 +116,6 @@ class DownloadWorker(QThread):
                                 int((i) / total_tracks * 100))
                 
                 try:
-                    track_id = track.id
-                    self.progress.emit(f"Getting track info for ID: {track_id} from {self.service}", 0)
-                    
                     if self.is_playlist and self.use_album_subfolders:
                         album_folder = re.sub(r'[<>:"/\\|?*]', '_', track.album)
                         track_outpath = os.path.join(self.outpath, album_folder)
@@ -119,21 +123,6 @@ class DownloadWorker(QThread):
                     else:
                         track_outpath = self.outpath
                     
-                    import asyncio
-                    metadata = asyncio.run(downloader.get_track_info(track_id, self.service))
-                    
-                    self.progress.emit(f"Track info received, starting download process", 0)
-                    
-                    is_paused_callback = lambda: self.is_paused
-                    is_stopped_callback = lambda: self.is_stopped
-                    
-                    downloaded_file = downloader.download(
-                        metadata, 
-                        track_outpath,
-                        is_paused_callback=is_paused_callback,
-                        is_stopped_callback=is_stopped_callback
-                    )
-                    
                     if (self.is_album or (self.is_playlist and self.use_album_subfolders)) and self.use_track_numbers:
                         new_filename = f"{track.track_number:02d} - {self.get_formatted_filename(track)}"
                     else:
@@ -142,6 +131,111 @@ class DownloadWorker(QThread):
                     new_filename = re.sub(r'[<>:"/\\|?*]', '_', new_filename)
                     new_filepath = os.path.join(track_outpath, new_filename)
                     
+                    if os.path.exists(new_filepath) and os.path.getsize(new_filepath) > 0:
+                        self.progress.emit(f"File already exists: {new_filename}. Skipping download.", 0)
+                        self.progress.emit(f"Skipped: {track.title} - {track.artists}", 
+                                    int((i + 1) / total_tracks * 100))
+                        continue
+                    
+                    if self.service == "qobuz":
+                        if not track.isrc:
+                            self.progress.emit(f"No ISRC found for track: {track.title}. Skipping.", 0)
+                            self.failed_tracks.append((track.title, track.artists, "No ISRC available"))
+                            continue
+                        
+                        self.progress.emit(f"Getting track from Qobuz with ISRC: {track.isrc}", 0)
+                        
+                        is_paused_callback = lambda: self.is_paused
+                        is_stopped_callback = lambda: self.is_stopped
+                        
+                        downloaded_file = downloader.download(
+                            track.isrc, 
+                            track_outpath,
+                            is_paused_callback=is_paused_callback,
+                            is_stopped_callback=is_stopped_callback
+                        )
+                    elif self.service == "tidal_api": 
+                        if not track.isrc:
+                            self.progress.emit(f"No ISRC found for track: {track.title}. Skipping.", 0)
+                            self.failed_tracks.append((track.title, track.artists, "No ISRC available"))
+                            continue
+                        
+                        self.progress.emit(f"Searching and downloading from Tidal (API) for ISRC: {track.isrc} - {track.title} - {track.artists}", 0)
+                        
+                        import asyncio 
+                        
+                        is_paused_callback = lambda: self.is_paused
+                        is_stopped_callback = lambda: self.is_stopped
+                        
+                        try:
+                            loop = asyncio.get_event_loop()
+                            if loop.is_closed():
+                                loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(loop)
+                        except RuntimeError:
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(loop)
+
+                        download_result_details = loop.run_until_complete(downloader.download(
+                            query=f"{track.title} {track.artists}", 
+                            isrc=track.isrc,
+                            output_dir=track_outpath,
+                            quality="LOSSLESS", 
+                            embed_metadata=True, 
+                            is_paused_callback=is_paused_callback,
+                            is_stopped_callback=is_stopped_callback
+                        ))
+                        
+                        if isinstance(download_result_details, str) and os.path.exists(download_result_details): 
+                            downloaded_file = download_result_details
+                        elif isinstance(download_result_details, dict) and download_result_details.get("success") == False and download_result_details.get("error") == "Download stopped by user":
+                            self.progress.emit(f"Download stopped by user for: {track.title}",0)
+                            return 
+                        elif isinstance(download_result_details, dict) and download_result_details.get("success") == False:
+                            raise Exception(download_result_details.get("error", "Tidal API download failed"))                        
+                        elif isinstance(download_result_details, dict) and (download_result_details.get("status") == "all_skipped" or download_result_details.get("status") == "skipped_exists"):
+                            self.progress.emit(f"File already exists or skipped: {new_filename}",0)
+                            downloaded_file = new_filepath
+                        else: 
+                            downloaded_file = None 
+                            raise Exception(f"Tidal API download failed or returned unexpected result: {download_result_details}")                    
+                    else: 
+                        track_id = track.id
+                        self.progress.emit(f"Getting track info for ID: {track_id} from {self.service}", 0)
+                        
+                        import asyncio
+                        
+                        try:
+                            loop = asyncio.get_event_loop()
+                            if loop.is_closed():
+                                loop = asyncio.new_event_loop()
+                                asyncio.set_event_loop(loop)
+                        except RuntimeError:
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(loop)
+                        
+                        metadata = loop.run_until_complete(downloader.get_track_info(track_id, self.service))
+                        self.progress.emit(f"Track info received, starting download process", 0)
+                        
+                        is_paused_callback = lambda: self.is_paused
+                        is_stopped_callback = lambda: self.is_stopped
+                        
+                        downloaded_file = downloader.download(
+                            metadata, 
+                            track_outpath,
+                            is_paused_callback=is_paused_callback,
+                            is_stopped_callback=is_stopped_callback
+                        )
+                    
+                    if self.is_stopped: 
+                        return
+
+                    if downloaded_file == new_filepath: 
+                        self.progress.emit(f"File already exists: {new_filename}", 0)
+                        self.progress.emit(f"Skipped: {track.title} - {track.artists}", 
+                                    int((i + 1) / total_tracks * 100))
+                        continue
+                    
                     if os.path.exists(downloaded_file) and downloaded_file != new_filepath:
                         if os.path.exists(new_filepath):
                             os.remove(new_filepath)
@@ -219,21 +313,48 @@ class ServiceStatusChecker(QThread):
     def run(self):
         try:
             response = requests.get("https://lucida.to/api/stats", timeout=5)
+            services_status = {}
             if response.status_code == 200:
                 data = response.json()
-                services_status = {}
+                current_services = data.get('downloads', {}).get('current', {}).get('services', {})
-                
-                current_services = data.get('all', {}).get('downloads', {}).get('current', {}).get('services', {})
-                
                 services_status['amazon'] = current_services.get('amazon', 0) > 0
                 services_status['tidal'] = current_services.get('tidal', 0) > 0
                 services_status['deezer'] = current_services.get('deezer', 0) > 0
-                
-                self.status_updated.emit(services_status)
             else:
-                self.error.emit(f"Server returned status code: {response.status_code}")
+                self.error.emit(f"Lucida API error: {response.status_code}")
+            
+            self.status_updated.emit(services_status) 
         except Exception as e:
-            self.error.emit(f"Error checking service status: {str(e)}")
+            self.error.emit(f"Error checking Lucida service status: {str(e)}")
+
+class TidalStatusChecker(QThread):
+    status_updated = pyqtSignal(bool)
+    error = pyqtSignal(str)
+
+    def run(self):
+        try:
+            response = requests.get("https://hifi.401658.xyz", timeout=5)
+            is_online = response.status_code == 200 or response.status_code == 429
+            self.status_updated.emit(is_online)
+        except Exception as e:
+            self.error.emit(f"Error checking Tidal (API) status: {str(e)}")
+            self.status_updated.emit(False)
+
+class QobuzStatusChecker(QThread):
+    status_updated = pyqtSignal(bool)
+    error = pyqtSignal(str)
+    
+    def __init__(self, region="us"):
+        super().__init__()
+        self.region = region
+    
+    def run(self):
+        try:
+            response = requests.get(f"https://{self.region}.qobuz.squid.wtf", timeout=5)
+            self.status_updated.emit(response.status_code == 200)
+        except Exception as e:
+            self.error.emit(f"Error checking Qobuz status: {str(e)}")
+            self.status_updated.emit(False)
 
 class StatusIndicatorDelegate(QStyledItemDelegate):
     def paint(self, painter, option, index):
@@ -242,11 +363,6 @@ class StatusIndicatorDelegate(QStyledItemDelegate):
         
         super().paint(painter, option, index)
         
-        if option.state & QStyle.StateFlag.State_Selected:
-            text_color = option.palette.color(QPalette.ColorGroup.Active, QPalette.ColorRole.HighlightedText)
-        else:
-            text_color = option.palette.color(QPalette.ColorGroup.Active, QPalette.ColorRole.Text)
-        
         indicator_color = Qt.GlobalColor.green if is_online else Qt.GlobalColor.red
         
         circle_size = 6
@@ -271,20 +387,31 @@ class ServiceComboBox(QComboBox):
         
         self.status_checker = ServiceStatusChecker()
         self.status_checker.status_updated.connect(self.update_service_status)
-        self.status_checker.error.connect(lambda e: print(f"Status check error: {e}"))
+        self.status_checker.error.connect(lambda e: print(f"General status check error: {e}"))
         self.status_checker.start()
         
         self.status_timer = QTimer(self)
         self.status_timer.timeout.connect(self.refresh_status)
-        self.status_timer.start(5000)
+        self.status_timer.start(5000) 
+
+        self.tidal_api_status_checker = TidalStatusChecker() 
+        self.tidal_api_status_checker.status_updated.connect(self.update_tidal_api_service_status) 
+        self.tidal_api_status_checker.error.connect(lambda e: print(f"Tidal (API) status check error: {e}")) 
+        self.tidal_api_status_checker.start()
+
+        self.tidal_api_status_timer = QTimer(self) 
+        self.tidal_api_status_timer.timeout.connect(self.refresh_tidal_api_status) 
+        self.tidal_api_status_timer.start(6000) 
         
     def setup_items(self):
         current_dir = os.path.dirname(os.path.abspath(__file__))
         
         self.services = [
-            {'id': 'tidal', 'name': 'Tidal', 'icon': 'tidal.png', 'online': False},
+            {'id': 'tidal', 'name': 'Tidal (Lucida)', 'icon': 'tidal.png', 'online': False},
-            {'id': 'amazon', 'name': 'Amazon Music', 'icon': 'amazon.png', 'online': False},
+            {'id': 'amazon', 'name': 'Amazon (Lucida)', 'icon': 'amazon.png', 'online': False},
-            {'id': 'deezer', 'name': 'Deezer', 'icon': 'deezer.png', 'online': False}
+            {'id': 'deezer', 'name': 'Deezer (Lucida)', 'icon': 'deezer.png', 'online': False},
+            {'id': 'qobuz', 'name': 'Qobuz (SquidWTF)', 'icon': 'qobuz.png', 'online': False},
+            {'id': 'tidal_api', 'name': 'Tidal (API)', 'icon': 'tidal.png', 'online': False} 
         ]
         
         for service in self.services:
@@ -305,12 +432,12 @@ class ServiceComboBox(QComboBox):
         pixmap.save(path)
     
     def update_service_status(self, status_dict):
-        self.services_status = status_dict
+        self.services_status.update(status_dict) 
         
         for i in range(self.count()):
             service_id = self.itemData(i, Qt.ItemDataRole.UserRole + 1)
             
-            if service_id in self.services_status:
+            if service_id in self.services_status: 
                 service_data = self.itemData(i, Qt.ItemDataRole.UserRole)
                 if isinstance(service_data, dict):
                     service_data['online'] = self.services_status[service_id]
@@ -321,8 +448,110 @@ class ServiceComboBox(QComboBox):
     def refresh_status(self):
         self.status_checker = ServiceStatusChecker()
         self.status_checker.status_updated.connect(self.update_service_status)
-        self.status_checker.error.connect(lambda e: print(f"Status check error: {e}"))
+        self.status_checker.error.connect(lambda e: print(f"General status check error: {e}"))
         self.status_checker.start()
+
+    def update_tidal_api_service_status(self, is_online): 
+        for i in range(self.count()):
+            service_id = self.itemData(i, Qt.ItemDataRole.UserRole + 1)
+            if service_id == 'tidal_api': 
+                service_data = self.itemData(i, Qt.ItemDataRole.UserRole)
+                if isinstance(service_data, dict):
+                    service_data['online'] = is_online
+                    self.setItemData(i, service_data, Qt.ItemDataRole.UserRole)
+                break 
+        self.update()
+
+    def refresh_tidal_api_status(self): 
+        self.tidal_api_status_checker = TidalStatusChecker() 
+        self.tidal_api_status_checker.status_updated.connect(self.update_tidal_api_service_status) 
+        self.tidal_api_status_checker.error.connect(lambda e: print(f"Tidal (API) status check error: {e}")) 
+        self.tidal_api_status_checker.start()
+        
+    def currentData(self, role=Qt.ItemDataRole.UserRole + 1):
+        return super().currentData(role)
+
+    def update_qobuz_status(self, region_id, is_online):
+        for i in range(self.count()):
+            service_id = self.itemData(i, Qt.ItemDataRole.UserRole + 1)
+            
+            if service_id == 'qobuz':
+                service_data = self.itemData(i, Qt.ItemDataRole.UserRole)
+                if isinstance(service_data, dict):
+                    if is_online or service_data.get('online', False):
+                        service_data['online'] = True
+                        self.setItemData(i, service_data, Qt.ItemDataRole.UserRole)
+                break
+        
+        self.update()
+
+class QobuzRegionComboBox(QComboBox):
+    status_updated = pyqtSignal(str, bool)
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setIconSize(QSize(16, 16))
+        
+        self.setItemDelegate(StatusIndicatorDelegate())
+        
+        self.setup_items()
+        
+        self.status_checkers = {}
+        self.check_status()
+        
+        self.status_timer = QTimer(self)
+        self.status_timer.timeout.connect(self.check_status)
+        self.status_timer.start(10000)
+        
+    def setup_items(self):
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        self.regions = [
+            {'id': 'eu', 'name': 'Europe', 'icon': 'eu.svg', 'online': False},
+            {'id': 'us', 'name': 'North America', 'icon': 'us.svg', 'online': False}
+        ]
+        
+        for region in self.regions:
+            icon_path = os.path.join(current_dir, region['icon'])
+            if not os.path.exists(icon_path):
+                self.create_placeholder_icon(icon_path)
+            
+            icon = QIcon(icon_path)
+            
+            self.addItem(icon, region['name'])
+            item_index = self.count() - 1
+            self.setItemData(item_index, region['id'], Qt.ItemDataRole.UserRole + 1)
+            self.setItemData(item_index, region, Qt.ItemDataRole.UserRole)
+    
+    def create_placeholder_icon(self, path):
+        pixmap = QPixmap(16, 16)
+        pixmap.fill(Qt.GlobalColor.transparent)
+        pixmap.save(path)
+    
+    def update_region_status(self, region_id, is_online):
+        for i in range(self.count()):
+            current_region_id = self.itemData(i, Qt.ItemDataRole.UserRole + 1)
+            
+            if current_region_id == region_id:
+                region_data = self.itemData(i, Qt.ItemDataRole.UserRole)
+                if isinstance(region_data, dict):
+                    region_data['online'] = is_online
+                    self.setItemData(i, region_data, Qt.ItemDataRole.UserRole)
+                break
+        
+        self.update()
+    
+    def check_status(self):
+        for region in self.regions:
+            region_id = region['id']
+            checker = QobuzStatusChecker(region_id)
+            checker.status_updated.connect(lambda status, rid=region_id: self.handle_status_update(rid, status))
+            checker.start()
+            self.status_checkers[region_id] = checker
+    
+    def handle_status_update(self, region_id, is_online):
+        self.update_region_status(region_id, is_online)
+        self.status_updated.emit(region_id, is_online)
         
     def currentData(self, role=Qt.ItemDataRole.UserRole + 1):
         return super().currentData(role)
@@ -330,7 +559,7 @@ class ServiceComboBox(QComboBox):
 class SpotiFLACGUI(QWidget):
     def __init__(self):
         super().__init__()
-        self.current_version = "2.4"
+        self.current_version = "3.4"
         self.tracks = []
         self.reset_state()
         
@@ -341,8 +570,9 @@ class SpotiFLACGUI(QWidget):
         self.filename_format = self.settings.value('filename_format', 'title_artist')
         self.use_track_numbers = self.settings.value('use_track_numbers', False, type=bool)
         self.use_album_subfolders = self.settings.value('use_album_subfolders', False, type=bool)
-        self.use_fallback = self.settings.value('use_fallback', False, type=bool)
         self.service = self.settings.value('service', 'amazon')
+        self.qobuz_region = self.settings.value('qobuz_region', 'us')
+        self.timeout_value = self.settings.value('timeout_value', 30, type=int)
         self.check_for_updates = self.settings.value('check_for_updates', True, type=bool)
         
         self.elapsed_time = QTime(0, 0, 0)
@@ -586,7 +816,7 @@ class SpotiFLACGUI(QWidget):
         output_layout.setSpacing(5)
         
         output_label = QLabel('Output Directory')
-        output_label.setStyleSheet("font-weight: bold; color: palette(text);")
+        output_label.setStyleSheet("font-weight: bold;")
         output_layout.addWidget(output_label)
         
         output_dir_layout = QHBoxLayout()
@@ -600,6 +830,7 @@ class SpotiFLACGUI(QWidget):
         
         output_dir_layout.addWidget(self.output_dir)
         output_dir_layout.addWidget(self.output_browse)
+        
         output_layout.addLayout(output_dir_layout)
         
         settings_layout.addWidget(output_group)
@@ -609,21 +840,18 @@ class SpotiFLACGUI(QWidget):
         file_layout.setSpacing(5)
         
         file_label = QLabel('File Settings')
-        file_label.setStyleSheet("font-weight: bold; color: palette(text);")
+        file_label.setStyleSheet("font-weight: bold;")
         file_layout.addWidget(file_label)
         
         format_layout = QHBoxLayout()
         format_label = QLabel('Filename Format:')
-        format_label.setStyleSheet("color: palette(text);")
         
         self.format_group = QButtonGroup(self)
         self.title_artist_radio = QRadioButton('Title - Artist')
-        self.title_artist_radio.setStyleSheet("color: palette(text);")
         self.title_artist_radio.setCursor(Qt.CursorShape.PointingHandCursor)
         self.title_artist_radio.toggled.connect(self.save_filename_format)
         
         self.artist_title_radio = QRadioButton('Artist - Title')
-        self.artist_title_radio.setStyleSheet("color: palette(text);")
         self.artist_title_radio.setCursor(Qt.CursorShape.PointingHandCursor)
         self.artist_title_radio.toggled.connect(self.save_filename_format)
         
@@ -644,14 +872,12 @@ class SpotiFLACGUI(QWidget):
         checkbox_layout = QHBoxLayout()
         
         self.track_number_checkbox = QCheckBox('Add Track Numbers to Album Files')
-        self.track_number_checkbox.setStyleSheet("color: palette(text);")
         self.track_number_checkbox.setCursor(Qt.CursorShape.PointingHandCursor)
         self.track_number_checkbox.setChecked(self.use_track_numbers)
         self.track_number_checkbox.toggled.connect(self.save_track_numbering)
         checkbox_layout.addWidget(self.track_number_checkbox)
         
         self.album_subfolder_checkbox = QCheckBox('Create Album Subfolders for Playlist Downloads')
-        self.album_subfolder_checkbox.setStyleSheet("color: palette(text);")
         self.album_subfolder_checkbox.setCursor(Qt.CursorShape.PointingHandCursor)
         self.album_subfolder_checkbox.setChecked(self.use_album_subfolders)
         self.album_subfolder_checkbox.toggled.connect(self.save_album_subfolder_setting)
@@ -666,39 +892,61 @@ class SpotiFLACGUI(QWidget):
         auth_layout = QVBoxLayout(auth_group)
         auth_layout.setSpacing(5)
         
-        auth_label = QLabel('Lucida')
+        auth_label = QLabel('Service Settings')
-        auth_label.setStyleSheet("font-weight: bold; color: palette(text);")
+        auth_label.setStyleSheet("font-weight: bold;")
         auth_layout.addWidget(auth_label)
 
         service_fallback_layout = QHBoxLayout()
 
         service_label = QLabel('Service:')
-        service_label.setStyleSheet("color: palette(text);")
         
         self.service_dropdown = ServiceComboBox()
-        self.service_dropdown.currentIndexChanged.connect(self.save_service_setting)
+        self.service_dropdown.currentIndexChanged.connect(self.on_service_changed)
         
         service_fallback_layout.addWidget(service_label)
         service_fallback_layout.addWidget(self.service_dropdown)
         
-        service_fallback_layout.addSpacing(20)
+        service_fallback_layout.addSpacing(10)
+
+        timeout_label = QLabel('Timeout:')
+        self.timeout_input = QLineEdit()
+        self.timeout_input.setText(str(self.timeout_value))
+        self.timeout_input.setFixedWidth(35)
+        self.timeout_input.textChanged.connect(self.save_timeout_setting)
+        service_fallback_layout.addWidget(timeout_label)
+        service_fallback_layout.addWidget(self.timeout_input)
         
-        self.fallback_checkbox = QCheckBox('Fallback')
+        region_label = QLabel('Region:')
-        self.fallback_checkbox.setStyleSheet("color: palette(text);")
+        self.qobuz_region_dropdown = QobuzRegionComboBox()
-        self.fallback_checkbox.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.qobuz_region_dropdown.currentIndexChanged.connect(self.save_qobuz_region_setting)
-        self.fallback_checkbox.setChecked(self.use_fallback)
+        service_fallback_layout.addWidget(region_label)
-        self.fallback_checkbox.toggled.connect(self.save_fallback_setting)
+        service_fallback_layout.addWidget(self.qobuz_region_dropdown)
-        service_fallback_layout.addWidget(self.fallback_checkbox)
+        
+        region_label.hide()
+        self.qobuz_region_dropdown.hide()
         
         service_fallback_layout.addStretch()
         auth_layout.addLayout(service_fallback_layout)
         
         settings_layout.addWidget(auth_group)
-
         settings_layout.addStretch()
         settings_tab.setLayout(settings_layout)
         self.tab_widget.addTab(settings_tab, "Settings")
         
+        for i in range(self.service_dropdown.count()):
+            if self.service_dropdown.itemData(i, Qt.ItemDataRole.UserRole + 1) == self.service:
+                self.service_dropdown.setCurrentIndex(i)
+                break
+                
+        for i in range(self.qobuz_region_dropdown.count()):
+            if self.qobuz_region_dropdown.itemData(i, Qt.ItemDataRole.UserRole + 1) == self.qobuz_region:
+                self.qobuz_region_dropdown.setCurrentIndex(i)
+                break
+        
+        self.qobuz_region_dropdown.status_updated.connect(
+            lambda region_id, is_online: self.service_dropdown.update_qobuz_status(region_id, is_online)
+        )
+        
     def setup_about_tab(self):
         about_tab = QWidget()
         about_layout = QVBoxLayout()
@@ -708,7 +956,7 @@ class SpotiFLACGUI(QWidget):
         sections = [
             ("Check for Updates", "https://github.com/afkarxyz/SpotiFLAC/releases"),
             ("Report an Issue", "https://github.com/afkarxyz/SpotiFLAC/issues"),
-            ("Lucida Site", "https://lucida.to/stats")
+            ("Lucida Status", "https://status.lucida.to")
         ]
 
         for title, url in sections:
@@ -749,13 +997,57 @@ class SpotiFLACGUI(QWidget):
                 spacer = QSpacerItem(20, 6, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
                 about_layout.addItem(spacer)
 
-        footer_label = QLabel("v2.4 | April 2025")
+        footer_label = QLabel("v3.4 | June 2025")
-        footer_label.setStyleSheet("font-size: 12px; color: palette(text); margin-top: 10px;")
+        footer_label.setStyleSheet("font-size: 12px; margin-top: 10px;")
         about_layout.addWidget(footer_label, alignment=Qt.AlignmentFlag.AlignCenter)
 
         about_tab.setLayout(about_layout)
         self.tab_widget.addTab(about_tab, "About")
 
+    def on_service_changed(self, index):
+        service = self.service_dropdown.currentData()
+        self.service = service
+        self.settings.setValue('service', service)
+        self.settings.sync()
+        
+        timeout_label = None
+        for widget in self.timeout_input.parentWidget().children():
+            if isinstance(widget, QLabel) and widget.text() == "Timeout:":
+                timeout_label = widget
+                break
+        
+        region_label = None
+        for widget in self.qobuz_region_dropdown.parentWidget().children():
+            if isinstance(widget, QLabel) and widget.text() == "Region:":
+                region_label = widget
+                break
+
+        if service == "qobuz":
+            self.timeout_input.hide()
+            if timeout_label:
+                timeout_label.hide()
+            
+            if region_label:
+                region_label.show()
+            self.qobuz_region_dropdown.show()
+        elif service == "tidal_api": 
+            self.timeout_input.hide()
+            if timeout_label:
+                timeout_label.hide()
+            if region_label:
+                region_label.hide()
+            self.qobuz_region_dropdown.hide()
+        else: 
+            self.timeout_input.show()
+            if timeout_label:
+                timeout_label.show()
+            
+            if region_label:
+                region_label.hide()
+            self.qobuz_region_dropdown.hide()
+            
+        self.log_output.append(f"Service changed to: {self.service_dropdown.currentText()}")
+
     def save_url(self):
         self.settings.setValue('spotify_url', self.spotify_url.text().strip())
         self.settings.sync()
@@ -775,18 +1067,27 @@ class SpotiFLACGUI(QWidget):
         self.settings.setValue('use_album_subfolders', self.use_album_subfolders)
         self.settings.sync()
     
-    def save_fallback_setting(self):
+    def save_timeout_setting(self):
-        self.use_fallback = self.fallback_checkbox.isChecked()
+        try:
-        self.settings.setValue('use_fallback', self.use_fallback)
+            timeout = int(self.timeout_input.text())
-        self.settings.sync()
+            if timeout > 0:
-        self.log_output.append("Fallback setting saved successfully!")
+                self.timeout_value = timeout
+                self.settings.setValue('timeout_value', self.timeout_value)
+                self.settings.sync()
+                self.log_output.append(f"Timeout setting saved: {self.timeout_value} seconds")
+            else:
+                self.timeout_input.setText(str(self.timeout_value))
+                self.log_output.append("Timeout must be a positive number")
+        except ValueError:
+            self.timeout_input.setText(str(self.timeout_value))
+            self.log_output.append("Timeout must be a valid number")
     
-    def save_service_setting(self):
+    def save_qobuz_region_setting(self):
-        service = self.service_dropdown.currentData()
+        region = self.qobuz_region_dropdown.currentData()
-        self.service = service
+        self.qobuz_region = region
-        self.settings.setValue('service', service)
+        self.settings.setValue('qobuz_region', region)
         self.settings.sync()
-        self.log_output.append(f"Service setting saved: {self.service_dropdown.currentText()}")
+        self.log_output.append(f"Qobuz region setting saved: {self.qobuz_region_dropdown.currentText()}")
     
     def save_settings(self):
         self.settings.setValue('output_path', self.output_dir.text().strip())
@@ -848,7 +1149,8 @@ class SpotiFLACGUI(QWidget):
             album=track_data["album_name"],
             track_number=1,
             duration_ms=track_data.get("duration_ms", 0),
-            id=track_id
+            id=track_id,
+            isrc=track_data.get("isrc", "")
         )]
         self.is_single_track = True
         self.is_album = self.is_playlist = False
@@ -877,7 +1179,8 @@ class SpotiFLACGUI(QWidget):
                 album=self.album_or_playlist_name,
                 track_number=track["track_number"],
                 duration_ms=track.get("duration_ms", 0),
-                id=track_id
+                id=track_id,
+                isrc=track.get("isrc", "")
             ))
             
         self.is_album = True
@@ -906,7 +1209,8 @@ class SpotiFLACGUI(QWidget):
                 album=track["album_name"],
                 track_number=len(self.tracks) + 1,
                 duration_ms=track.get("duration_ms", 0),
-                id=track_id
+                id=track_id,
+                isrc=track.get("isrc", "")
             ))
             
         self.is_playlist = True
@@ -950,10 +1254,21 @@ class SpotiFLACGUI(QWidget):
             self.followers_label.hide()
         
         if metadata.get('releaseDate'):
-            release_date = datetime.strptime(metadata['releaseDate'], "%Y-%m-%d")
+            try:
-            formatted_date = release_date.strftime("%d-%m-%Y")
+                release_date = metadata['releaseDate']
-            self.release_date_label.setText(f"<b>Released</b> {formatted_date}")
+                if len(release_date) == 4:
-            self.release_date_label.show()
+                    date_obj = datetime.strptime(release_date, "%Y")
+                elif len(release_date) == 7:
+                    date_obj = datetime.strptime(release_date, "%Y-%m")
+                else:
+                    date_obj = datetime.strptime(release_date, "%Y-%m-%d")
+                
+                formatted_date = date_obj.strftime("%d-%m-%Y")
+                self.release_date_label.setText(f"<b>Released</b> {formatted_date}")
+                self.release_date_label.show()
+            except ValueError:
+                self.release_date_label.setText(f"<b>Released</b> {metadata['releaseDate']}")
+                self.release_date_label.show()
         else:
             self.release_date_label.hide()
         
@@ -1033,7 +1348,8 @@ class SpotiFLACGUI(QWidget):
 
     def download_tracks(self, indices):
         self.log_output.clear()
-        outpath = self.output_dir.text()
+        raw_outpath = self.output_dir.text().strip()
+        outpath = os.path.normpath(raw_outpath)
         if not os.path.exists(outpath):
             self.log_output.append('Warning: Invalid output directory.')
             return
@@ -1041,7 +1357,8 @@ class SpotiFLACGUI(QWidget):
         tracks_to_download = self.tracks if self.is_single_track else [self.tracks[i] for i in indices]
 
         if self.is_album or self.is_playlist:
-            folder_name = re.sub(r'[<>:"/\\|?*]', '_', self.album_or_playlist_name)
+            name = self.album_or_playlist_name.strip()
+            folder_name = re.sub(r'[<>:"/\\|?*]', '_', name)
             outpath = os.path.join(outpath, folder_name)
             os.makedirs(outpath, exist_ok=True)
 
@@ -1052,6 +1369,7 @@ class SpotiFLACGUI(QWidget):
 
     def start_download_worker(self, tracks_to_download, outpath):
         service = self.service_dropdown.currentData()
+        qobuz_region = self.qobuz_region_dropdown.currentData() if service == "qobuz" else "us"
     
         self.worker = DownloadWorker(
             tracks_to_download, 
@@ -1063,8 +1381,9 @@ class SpotiFLACGUI(QWidget):
             self.filename_format,
             self.use_track_numbers,
             self.use_album_subfolders,
-            self.use_fallback,
+            service,
-            service
+            self.timeout_value,
+            qobuz_region
         )
         self.worker.finished.connect(self.on_download_finished)
         self.worker.progress.connect(self.update_progress)
@@ -1104,7 +1423,7 @@ class SpotiFLACGUI(QWidget):
         else:
             self.log_output.append(message)
         
-        if percentage > 0:
+        if percentage > 0 and not "Download progress:" in message:
             self.progress_bar.setValue(percentage)
 
     def stop_download(self):
@@ -1179,6 +1498,16 @@ class SpotiFLACGUI(QWidget):
         self.time_label.hide()
 
 if __name__ == '__main__':
+    try:
+        if sys.platform == "win32":
+            import os
+            os.system("chcp 65001 > nul")
+            import io
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+    except Exception as e:
+        print(f"Warning: Could not set UTF-8 encoding: {e}")
+        
     app = QApplication(sys.argv)
     ex = SpotiFLACGUI()
     ex.show()

getMetadata.py

@@ -32,7 +32,7 @@ def generate_totp(
         counter * 30_000,
     )
 
-token_url = 'https://open.spotify.com/get_access_token'
+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/{}'
@@ -319,6 +319,8 @@ def format_track_data(track_data):
     
     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),
@@ -328,7 +330,8 @@ def format_track_data(track_data):
             "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', '')
+            "external_urls": track_data.get('external_urls', {}).get('spotify', ''),
+            "isrc": isrc  
         }
     }
 
@@ -344,6 +347,20 @@ def format_album_data(album_data):
         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),
@@ -353,7 +370,8 @@ def format_album_data(album_data):
             "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', '')
+            "external_urls": track.get('external_urls', {}).get('spotify', ''),
+            "isrc": track_isrc  
         })
     
     album_info = {
@@ -389,6 +407,8 @@ def format_playlist_data(playlist_data):
         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', ''),
@@ -397,7 +417,8 @@ def format_playlist_data(playlist_data):
             "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', '')
+            "external_urls": track.get('external_urls', {}).get('spotify', ''),
+            "isrc": track_isrc  
         })
     
     playlist_info = {
@@ -443,9 +464,9 @@ def get_filtered_data(spotify_url, batch=False, delay=1.0):
     return {"error": "Failed to get raw data"}
 
 if __name__ == '__main__':
-    playlist = "https://open.spotify.com/playlist/5Qvz8wZIRYbEUUFoPueKI5"
+    playlist = "https://open.spotify.com/playlist/37i9dQZEVXbNG2KDcFcKOF"
-    album = "https://open.spotify.com/album/7kFyd5oyJdVX2pIi6P4iHE"
+    album = "https://open.spotify.com/album/6J84szYCnMfzEcvIcfWMFL"
-    song = "https://open.spotify.com/track/4wJ5Qq0jBN4ajy7ouZIV1c"
+    song = "https://open.spotify.com/track/7so0lgd0zP2Sbgs2d7a1SZ"
     
     filtered_playlist = get_filtered_data(playlist, batch=True, delay=0.1)
     print(json.dumps(filtered_playlist, indent=2))

version.json

@@ -1,3 +1,3 @@
 {
-  "version": "2.3"
+  "version": "3.3"
 }