Update v1.4

LucidaDownloader.py

@@ -5,13 +5,15 @@ import asyncio
 from GetMetadata import main as get_metadata
 
 class TrackDownloader:
-    def __init__(self):
+    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
@@ -66,7 +68,7 @@ class TrackDownloader:
             "url": track_url
         }
 
-        response = self.client.post("https://lucida.to/api/load?url=/api/fetch/stream/v2", 
+        response = self.client.post(f"https://{self.base_domain}/api/load?url=/api/fetch/stream/v2", 
                                     json=initial_request, 
                                     headers=self.headers)
         
@@ -84,7 +86,7 @@ class TrackDownloader:
 
         file_name = self.generate_filename(metadata)
 
-        completion_url = f"https://{server}.lucida.to/api/fetch/request/{handoff}"
+        completion_url = f"https://{server}.{self.base_domain}/api/fetch/request/{handoff}"
 
         print("Waiting for track processing to complete")
         while True:
@@ -95,7 +97,7 @@ class TrackDownloader:
                 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"
+        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)

README.md

@@ -1,17 +1,25 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotifyFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotifyFLAC/releases)
 
-**Spotify FLAC** allows you to download Spotify tracks in true FLAC format using services like Tidal, Qobuz, and Amazon Music with the help of Lucida.
+![spotifyflac](https://github.com/user-attachments/assets/a11fde95-e756-4592-982f-b567d4a85f3c)
+
+**Spotify FLAC** allows you to download Spotify tracks in true FLAC format through services like Tidal, Amazon Music, Qobuz, and Deezer with the help of Lucida.
 
 > [!NOTE]  
 > Requires **Google Chrome**
 
-#### [Download](https://github.com/afkarxyz/SpotifyFLAC/releases/download/v1.2/SpotifyFLAC.exe) Spotify FLAC
+> [!WARNING] 
+Sometimes, the **download speed** from Lucida can be fast or slow; it varies unpredictably.
+
+#### [Download](https://github.com/afkarxyz/SpotifyFLAC/releases/download/v1.4/SpotifyFLAC.exe) Spotify FLAC
 
 ## Screenshots
 
-![image](https://github.com/user-attachments/assets/abcb01f3-ff3e-4496-afec-df720553a189)
+![image](https://github.com/user-attachments/assets/c2057543-7f15-470e-beeb-2451a3764d15)
 
-> When **Headless** is enabled, the browser runs in the background without a graphical interface, improving performance and allowing seamless automation.
+> - When **Headless** is enabled, the browser runs in the background without a graphical interface, improving performance and allowing seamless automation.
+> - 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` and `Deezer` occasionally experience issues.
 
 ![image](https://github.com/user-attachments/assets/75a61cef-05a8-4f2c-b40b-ba5d49885ffe)
 

SpotifyFLAC.py

@@ -29,11 +29,12 @@ class MetadataFetcher(QThread):
     finished = pyqtSignal(dict)
     error = pyqtSignal(str)
     
-    def __init__(self, url, headless=True, service="tidal"):
+    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):
@@ -45,9 +46,11 @@ class MetadataFetcher(QThread):
         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://lucida.to/?url=https%3A%2F%2Fopen.spotify.com%2Ftrack%2F{track_id}&country=auto&to={self.service}"
+                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)
@@ -88,20 +91,33 @@ class DownloaderWorker(QThread):
     finished = pyqtSignal(str)
     error = pyqtSignal(str)
     
-    def __init__(self, metadata, output_dir, filename_format='title_artist'):
+    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.downloader = TrackDownloader()
+        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):
-        return f"{size_bytes / (1024 * 1024):.2f}MB"
+        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):
-        return f"{speed_bytes * 8 / (1024 * 1024):.2f}Mbps"
+        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()
@@ -146,7 +162,8 @@ class ServiceComboBox(QComboBox):
         services = [
             {'id': 'tidal', 'name': 'Tidal', 'icon': 'tidal.png'},
             {'id': 'amazon', 'name': 'Amazon Music', 'icon': 'amazon.png'},
-            {'id': 'qobuz', 'name': 'Qobuz', 'icon': 'qobuz.png'}
+            {'id': 'qobuz', 'name': 'Qobuz', 'icon': 'qobuz.png'},
+            {'id': 'deezer', 'name': 'Deezer', 'icon': 'deezer.png'}
         ]
         
         for service in services:
@@ -187,11 +204,13 @@ class SpotifyFlacGUI(QMainWindow):
         
     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:
@@ -205,6 +224,8 @@ class SpotifyFlacGUI(QMainWindow):
     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(
@@ -254,18 +275,23 @@ class SpotifyFlacGUI(QMainWindow):
         settings_group = QGroupBox("Settings")
         settings_layout = QHBoxLayout(settings_group)
         settings_layout.setContentsMargins(10, 0, 10, 10)
-        settings_layout.setSpacing(15)
+        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(15)
+        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)
@@ -286,8 +312,8 @@ class SpotifyFlacGUI(QMainWindow):
         format_layout.setSpacing(10)
         
         format_label = QLabel("Filename:")
-        self.format_title_artist = QRadioButton("Title - Artist")
+        self.format_title_artist = QRadioButton("Title")
-        self.format_artist_title = QRadioButton("Artist - 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)
@@ -374,9 +400,37 @@ class SpotifyFlacGUI(QMainWindow):
         self.progress_bar.hide()
         self.main_layout.addWidget(self.progress_bar)
 
+        bottom_layout = QHBoxLayout()
+        
         self.status_label = QLabel("")
-        self.main_layout.addWidget(self.status_label)
+        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)
@@ -406,8 +460,9 @@ class SpotifyFlacGUI(QMainWindow):
         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)
+        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()
@@ -424,6 +479,7 @@ class SpotifyFlacGUI(QMainWindow):
         self.track_widget.show()
         self.download_button.show()
         self.cancel_button.show()
+        self.update_button.hide()
         self.status_label.clear()
         self.adjustWindowHeight()
 
@@ -464,6 +520,7 @@ class SpotifyFlacGUI(QMainWindow):
         self.status_label.clear()
         self.metadata = None
         self.fetch_button.setEnabled(True)
+        self.update_button.show()
         self.setFixedHeight(180)
 
     def button_clicked(self):
@@ -484,6 +541,7 @@ class SpotifyFlacGUI(QMainWindow):
         self.track_widget.hide()
         self.input_widget.show()
         self.metadata = None
+        self.update_button.show()
         self.setFixedHeight(180)
 
     def start_download(self):
@@ -502,10 +560,13 @@ class SpotifyFlacGUI(QMainWindow):
         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
+            filename_format=format_type,
+            use_fallback=fallback
         )
         
         self.worker.progress.connect(self.update_progress)