Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

bei diesem skript erhalte ich Unknown property transition und Unknown property transform…

  1. User

    bei diesem skript erhalte ich Unknown property transition und Unknown property transform meldungen. Es sollte eher QPropertyAnimation und QGraphicsEffect verwendet werden. Verbessere das gui ansonsten nochmal mehr und sorge für ein sinnvolles und flexible angepasstes layout mit deutlicherer darstellung der relevanteren elemente wie zb dem fortschrittsbalken des gesamten prozesses, bessere effekte und animation und farben, bessere ergebnis presentation der musikstücke und der abspielfunktion und füge lautstärke regelung hinzu und eine visualisierung der audiospur im hintergrund. Nenne mir anschließend das vollständige verbesserte skript mit dem gesamten code der anwendung.

    import os import sys import logging import traceback import warnings import re import configparser from datetime import datetime from typing import List, Tuple, Optional import time import tempfile import threading from functools import partial import urllib3

    from PyQt5.QtWidgets import ( QApplication, QMainWindow, QPushButton, QVBoxLayout, QHBoxLayout, QLineEdit, QFileDialog, QLabel, QWidget, QProgressBar, QTableWidget, QTableWidgetItem, QHeaderView, QCheckBox, QTextEdit, QMessageBox, QSlider, QSpinBox, QFormLayout, QDialog, QAction, QGroupBox, QComboBox, QStatusBar, QMenuBar ) from PyQt5.QtCore import ( Qt, QTimer, QObject, pyqtSignal, QThreadPool, QRunnable, QIODevice, QBuffer, QUrl, QThread, QMetaObject, Q_ARG, QSize ) from PyQt5.QtGui import QIcon, QPixmap, QTextCursor, QColor, QPalette from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent

    from pydub import AudioSegment from pydub.silence import split_on_silence

    import requests from mutagen.id3 import ID3, TIT2, TPE1, TALB, APIC, error from mutagen.mp3 import MP3

    from yt_dlp import YoutubeDL

    from bs4 import BeautifulSoup

    import musicbrainzngs musicbrainzngs.set_useragent("MusicIdentifierApp", "1.0", "your-email@example.com") MUSICBRAINZ_AVAILABLE = True

    Unterdrücke Deprecation-Warnings von PyQt5

    warnings.filterwarnings('ignore', category=DeprecationWarning)

    class MetadataFetcher(QObject): result_ready = pyqtSignal(int, str, str, str, object) progress = pyqtSignal(int)

    def __init__(self, index: int, title: str, total: int, cache: dict):
        super().__init__()
        self.index = index
        self.title = title
        self.total = total
        self.cache = cache
    
    def run(self):
        try:
            logging.info(f"Starte Metadatenabfrage für Index {self.index}: '{self.title}'")
            if self.title in self.cache:
                result = self.cache[self.title]
                logging.info(f"Metadaten aus Cache für Index {self.index}: {result}")
            else:
                result = self.get_cover_and_metadata(self.title)
                self.cache[self.title] = result
                logging.info(f"Metadaten abgefragt und im Cache gespeichert für Index {self.index}: {result}")
            self.result_ready.emit(self.index, *result)
        except Exception as e:
            logging.error(f"Fehler beim Abrufen der Metadaten für Index {self.index}: {str(e)}")
            self.result_ready.emit(self.index, '', '', self.title, None)
        finally:
            progress_value = int(((self.index + 1) / self.total) * 100)
            self.progress.emit(progress_value)
    
    def get_cover_and_metadata(self, title: str) -> Tuple[Optional[bytes], str, str, str]:
        cover_data, artist, album, track_title, lyrics = self.search_musicbrainz(title)
        if not all([artist, album, track_title]):
            cover_data, artist, album, track_title = self.search_azlyrics(title, lyrics)
        return cover_data, artist, album, track_title
    
    def search_musicbrainz(self, query: str) -> Tuple[Optional[bytes], str, str, str, Optional[str]]:
        if not MUSICBRAINZ_AVAILABLE:
            return None, '', '', '', None
        try:
            result = musicbrainzngs.search_recordings(query=query, limit=1, strict=False)
            if result['recording-list']:
                recording = result['recording-list'][0]
                artist = recording['artist-credit'][0]['name']
                track_title = recording['title']
                album = recording['release-list'][0]['title'] if recording.get('release-list') else ''
                release_id = recording['release-list'][0]['id'] if recording.get('release-list') else ''
                cover_data = self.get_cover_from_coverartarchive(release_id) if release_id else None
    
                # Extrahiere Lyrics, falls verfügbar
                lyrics = self.fetch_lyrics(track_title, artist)
    
                logging.debug(f"MusicBrainz gefunden: Artist='{artist}', Album='{album}', Titel='{track_title}'")
                return cover_data, artist, album, track_title, lyrics
        except Exception as e:
            logging.error(f"Fehler bei der MusicBrainz-Abfrage: {e}")
        return None, '', '', '', None
    
    def search_azlyrics(self, query: str, lyrics: Optional[str]) -> Tuple[Optional[bytes], str, str, str]:
        try:
            search_url = f"https://search.azlyrics.com/search.php?q={requests.utils.quote(query)}"
            response = requests.get(search_url, timeout=10)
            soup = BeautifulSoup(response.text, 'html.parser')
            result = soup.find('td', class_='text-left visitedlyr')
            if result:
                link = result.find('a')['href']
                artist, title = self.extract_artist_title(link)
                logging.debug(f"AZLyrics gefunden: Artist='{artist}', Titel='{title}'")
    
                # Optional: Extrahiere Lyrics von der Lyrics-Seite
                lyrics = self.fetch_lyrics(title, artist, link)
                if lyrics:
                    logging.debug(f"Lyrics extrahiert für '{title}': {lyrics[:100]}...")  # Loggt die ersten 100 Zeichen der Lyrics
    
                return None, artist, '', title
        except Exception as e:
            logging.error(f"Fehler bei der AZLyrics-Abfrage: {e}")
        return None, '', '', ''
    
    def extract_artist_title(self, url: str) -> Tuple[str, str]:
        parts = url.split('/')
        artist = parts[-2].replace('+', ' ').strip()
        title = parts[-1].split('.')[0].replace('+', ' ').strip()
        return artist, title
    
    def get_cover_from_coverartarchive(self, release_id: str) -> Optional[bytes]:
        url = f"https://coverartarchive.org/release/{release_id}/front"
        try:
            response = requests.get(url, verify=False, timeout=10)
            if response.status_code == 200 and response.headers['Content-Type'].startswith('image'):
                logging.debug(f"Cover gefunden für Release ID {release_id}")
                return response.content
        except Exception as e:
            logging.error(f"Fehler beim Abrufen des Covers von Cover Art Archive: {e}")
        return None
    
    def fetch_lyrics(self, title: str, artist: str, url: Optional[str] = None) -> Optional[str]:
        """Extrahiere Lyrics entweder von einer gegebenen URL oder durch Suche."""
        try:
            if not url:
                # Suche nach der Lyrics-Seite
                search_query = f"{artist} {title} lyrics"
                search_url = f"https://www.azlyrics.com/lyrics/{artist.replace(' ', '').lower()}/{title.replace(' ', '').lower()}.html"
            else:
                search_url = url
    
            response = requests.get(search_url, timeout=10)
            soup = BeautifulSoup(response.text, 'html.parser')
            # Lyrics befinden sich in einem div ohne Klassenname, zwischen Kommentaren
            lyrics_div = soup.find('div', attrs={'class': None, 'id': None})
            if lyrics_div:
                lyrics = lyrics_div.get_text(separator='\n').strip()
                return lyrics
        except Exception as e:
            logging.error(f"Fehler beim Abrufen der Lyrics: {e}")
        return None
    

    class MetadataFetcherTask(QRunnable): def init(self, fetcher: MetadataFetcher): super().init() self.fetcher = fetcher

    def run(self):
        self.fetcher.run()
    

    class SaveWorker(QObject): """Arbeiterklasse für den Speichervorgang.""" progress = pyqtSignal(int) finished = pyqtSignal()

    def __init__(self, tracks_to_save: dict, app_reference):
        super().__init__()
        self.tracks_to_save = tracks_to_save
        self.app_reference = app_reference
    
    def run(self):
        total = len(self.tracks_to_save)
        for i, index in enumerate(self.tracks_to_save):
            self.tracks_to_save[index]['save_function']()
            progress = int((i + 1) / total * 100)
            self.progress.emit(progress)
        self.finished.emit()
    

    class QTextEditLogger(logging.Handler): """Logging Handler, der Logs in ein QTextEdit schreibt."""

    def __init__(self, text_edit):
        super().__init__()
        self.widget = text_edit
    
    def emit(self, record):
        msg = self.format(record)
        # Sicherstellen, dass das Hinzufügen von Text im Hauptthread erfolgt
        if threading.current_thread() is threading.main_thread():
            self.widget.append(msg)
            self.widget.moveCursor(QTextCursor.End)
        else:
            QMetaObject.invokeMethod(
                self.widget,
                "append",
                Qt.QueuedConnection,
                Q_ARG(str, msg)
            )
            QMetaObject.invokeMethod(
                self.widget,
                "moveCursor",
                Qt.QueuedConnection,
                Q_ARG(QTextCursor.MoveOperation, QTextCursor.End)
            )
    

    class TimestampsDialog(QDialog): """Dialog zur manuellen Eingabe von Zeitstempeln."""

    def __init__(self, parent=None):
        super().__init__(parent)
        self.parent_app = parent
        self.setWindowTitle("Zeitstempel eingeben")
        self.setMinimumSize(400, 300)
        self.layout = QVBoxLayout()
        self.text_edit = QTextEdit()
        self.text_edit.setPlaceholderText(
            "Geben Sie hier die Zeitstempel und Titel ein.\nZum Beispiel:\n00:00 Titel 1\n03:45 Titel 2\n..."
        )
        self.layout.addWidget(self.text_edit)
        button_layout = QHBoxLayout()
        ok_button = QPushButton("OK")
        ok_button.clicked.connect(self.accept)
        cancel_button = QPushButton("Abbrechen")
        cancel_button.clicked.connect(self.reject)
        button_layout.addStretch()
        button_layout.addWidget(ok_button)
        button_layout.addWidget(cancel_button)
        self.layout.addLayout(button_layout)
        self.setLayout(self.layout)
    
    def get_timestamps(self):
        timestamps = []
        raw_text = self.text_edit.toPlainText()
        for line in raw_text.split('\n'):
            parts = line.strip().split(None, 1)
            if len(parts) == 2:
                time_str, title = parts
                total_seconds = self.convert_time_to_seconds(time_str)
                if total_seconds is not None:
                    timestamps.append((total_seconds, title))
        return sorted(timestamps, key=lambda x: x[0])
    
    def convert_time_to_seconds(self, time_str: str) -> Optional[int]:
        try:
            if ':' in time_str:
                parts = [int(p) for p in time_str.split(':')]
                if len(parts) == 3:
                    hours, minutes, seconds = parts
                elif len(parts) == 2:
                    hours = 0
                    minutes, seconds = parts
                else:
                    return None
                return hours * 3600 + minutes * 60 + seconds
            elif '.' in time_str:
                parts = [int(p) for p in time_str.split('.')]
                if len(parts) == 3:
                    hours, minutes, seconds = parts
                elif len(parts) == 2:
                    hours = 0
                    minutes, seconds = parts
                else:
                    return None
                return hours * 3600 + minutes * 60 + seconds
            else:
                return int(time_str)
        except ValueError:
            return None
    

    class SettingsDialog(QDialog): """Dialog zur Anzeige und Änderung der Anwendungseinstellungen."""

    def __init__(self, parent=None, settings=None):
        super().__init__(parent)
        self.setWindowTitle("Einstellungen")
        self.setMinimumSize(400, 300)
        self.settings = settings or {}
        self.layout = QVBoxLayout()
    
        form_layout = QFormLayout()
    
        self.min_silence_len_spinbox = QSpinBox()
        self.min_silence_len_spinbox.setRange(500, 10000)
        self.min_silence_len_spinbox.setValue(self.settings.get('min_silence_len', 2000))
        self.min_silence_len_spinbox.setToolTip(
            "Minimale Länge der Stille (in Millisekunden), um als Trennung zwischen Tracks zu gelten."
        )
        form_layout.addRow("Minimale Stillelänge (ms):", self.min_silence_len_spinbox)
    
        self.silence_thresh_spinbox = QSpinBox()
        self.silence_thresh_spinbox.setRange(-60, 0)
        self.silence_thresh_spinbox.setValue(self.settings.get('silence_thresh_adjust', -16))
        self.silence_thresh_spinbox.setToolTip(
            "Schwellenwert (in dBFS), unterhalb dessen Audio als Stille betrachtet wird."
        )
        form_layout.addRow("Stille-Schwellenwert (dBFS):", self.silence_thresh_spinbox)
    
        self.keep_silence_spinbox = QSpinBox()
        self.keep_silence_spinbox.setRange(0, 5000)
        self.keep_silence_spinbox.setValue(self.settings.get('keep_silence', 500))
        self.keep_silence_spinbox.setToolTip(
            "Länge der Stille (in Millisekunden), die am Anfang und Ende jedes Segments beibehalten wird."
        )
        form_layout.addRow("Stille beibehalten (ms):", self.keep_silence_spinbox)
    
        self.min_segment_length_spinbox = QSpinBox()
        self.min_segment_length_spinbox.setRange(5000, 300000)
        self.min_segment_length_spinbox.setValue(self.settings.get('min_segment_length', 10000))
        self.min_segment_length_spinbox.setToolTip(
            "Minimale Länge eines Segments (in Millisekunden), um als gültiger Track betrachtet zu werden."
        )
        form_layout.addRow("Minimale Segmentlänge (ms):", self.min_segment_length_spinbox)
    
        self.default_save_checkbox = QCheckBox()
        default_save = self.settings.get('default_save_all', True)
        self.default_save_checkbox.setChecked(default_save)
        self.default_save_checkbox.setToolTip("Legt fest, ob alle Tracks standardmäßig zum Speichern ausgewählt sind.")
        form_layout.addRow("Alle Tracks standardmäßig auswählen:", self.default_save_checkbox)
    
        # Themenauswahl
        self.theme_combo = QComboBox()
        self.theme_combo.addItems(["Dunkel", "Hell", "System"])
        current_theme = self.settings.get('theme', 'Dunkel')
        index = self.theme_combo.findText(current_theme)
        if index != -1:
            self.theme_combo.setCurrentIndex(index)
        self.theme_combo.setToolTip("Wählen Sie das Farbschema der Anwendung.")
        form_layout.addRow("Thema:", self.theme_combo)
    
        self.layout.addLayout(form_layout)
    
        # Animation für Buttons
        button_layout = QHBoxLayout()
        apply_button = QPushButton("Übernehmen")
        apply_button.clicked.connect(self.accept)
        apply_button.setStyleSheet("""
            QPushButton {
                background-color: #4CAF50;
                color: white;
                font-size: 14px;
                padding: 10px;
                border-radius: 5px;
                transition: background-color 0.3s;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
        """)
        cancel_button = QPushButton("Abbrechen")
        cancel_button.clicked.connect(self.reject)
        cancel_button.setStyleSheet("""
            QPushButton {
                background-color: #f44336;
                color: white;
                font-size: 14px;
                padding: 10px;
                border-radius: 5px;
                transition: background-color 0.3s;
            }
            QPushButton:hover {
                background-color: #da190b;
            }
        """)
        button_layout.addStretch()
        button_layout.addWidget(apply_button)
        button_layout.addWidget(cancel_button)
        self.layout.addLayout(button_layout)
        self.setLayout(self.layout)
    
    def get_settings(self):
        return {
            'min_silence_len': self.min_silence_len_spinbox.value(),
            'silence_thresh_adjust': self.silence_thresh_spinbox.value(),
            'keep_silence': self.keep_silence_spinbox.value(),
            'min_segment_length': self.min_segment_length_spinbox.value(),
            'default_save_all': self.default_save_checkbox.isChecked(),
            'theme': self.theme_combo.currentText()
        }
    

    class MusicIdentifierApp(QMainWindow): """Hauptanwendungsklasse für den Musik-Identifikator."""

    def __init__(self):
        super().__init__()
        self.setWindowTitle("Music Identifier")
        self.resize(1200, 700)  # Erweiterte Größe für bessere Übersicht
        self.setWindowIcon(QIcon.fromTheme("audio-x-generic") if not QIcon.fromTheme("audio-x-generic").isNull() else QIcon("icon.png"))
    
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler("application.log", encoding='utf-8'),
                logging.StreamHandler(sys.stdout)
            ]
        )
    
        self.config = configparser.ConfigParser()
        self.load_settings()
    
        # Ausgabeordner
        self.output_dir = self.config.get('SETTINGS', 'output_dir', fallback=os.getcwd())
    
        self.cache = {}  # Cache für Metadaten
    
        self.init_ui()
    
        self.segments = []
        self.segments_info = []
        self.total_segments = 0
        self.fetchers = {}
        self.thread_pool = QThreadPool()
        self.players = {}  # Dictionary zur Speicherung von MediaPlayer-Instanzen
        self.is_processing = False  # Flag zur Indikation laufender Prozesse
    
        self.disable_ssl_warnings()
    
    def init_ui(self):
        """Initialisiert die Benutzeroberfläche."""
        self.apply_theme()
    
        central_widget = QWidget()
        main_layout = QVBoxLayout(central_widget)
        main_layout.setSpacing(10)
        main_layout.setContentsMargins(10, 10, 10, 10)
    
        # Menüleiste
        self.create_menubar()
        main_layout.addWidget(self.menuBar())
    
        # Eingabe-Layout
        input_group = self.create_input_group()
        main_layout.addWidget(input_group)
    
        # Start-Button mit Animation
        self.start_btn = QPushButton("Start")
        self.start_btn.clicked.connect(self.handle_start)
        self.start_btn.setToolTip("Starten Sie die Verarbeitung des eingegebenen Links oder der ausgewählten Datei.")
        self.start_btn.setFixedHeight(50)
        self.start_btn.setIcon(QIcon.fromTheme("media-playback-start") if not QIcon.fromTheme("media-playback-start").isNull() else QIcon("play.png"))
        self.start_btn.setStyleSheet("""
            QPushButton {
                background-color: #05B8CC;
                color: white;
                font-size: 16px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #028090;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #026972;
                transform: scale(0.95);
            }
        """)
        main_layout.addWidget(self.start_btn)
    
        # Segmentierungsoptionen
        segmentation_options_layout = QHBoxLayout()
        self.manual_timestamps_btn = QPushButton("Manuelle Zeitstempel eingeben")
        self.manual_timestamps_btn.clicked.connect(self.open_timestamps_dialog)
        self.manual_timestamps_btn.setToolTip("Öffnen Sie einen Dialog, um manuell Zeitstempel und Titel einzugeben.")
        self.manual_timestamps_btn.setStyleSheet("""
            QPushButton {
                background-color: #FFC107;
                color: white;
                font-size: 14px;
                padding: 10px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #FFA000;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #FF8F00;
                transform: scale(0.95);
            }
        """)
        segmentation_options_layout.addWidget(self.manual_timestamps_btn)
    
        main_layout.addLayout(segmentation_options_layout)
    
        # Fortschrittsanzeigen
        progress_group = self.create_progress_group()
        main_layout.addWidget(progress_group)
    
        # Informationen
        info_group = self.create_info_group()
        main_layout.addWidget(info_group)
    
        # Musiktabelle
        table_group = self.create_table_group()
        main_layout.addWidget(table_group)
    
        # Speichern-Button und Fortschrittsbalken
        save_layout = QHBoxLayout()
        self.save_all_btn = QPushButton("Ausgewählte Tracks speichern")
        self.save_all_btn.clicked.connect(self.save_selected_tracks)
        self.save_all_btn.setStyleSheet("""
            QPushButton {
                background-color: #4CAF50;
                color: white;
                font-size: 14px;
                padding: 10px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #388E3C;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #2E7D32;
                transform: scale(0.95);
            }
        """)
        self.save_all_btn.setToolTip("Speichern Sie alle ausgewählten Tracks im Ausgabeordner.")
        save_icon = QIcon.fromTheme("document-save") if not QIcon.fromTheme("document-save").isNull() else QIcon("save.png")
        self.save_all_btn.setIcon(save_icon)
        save_layout.addWidget(self.save_all_btn)
    
        self.save_progress_bar = QProgressBar()
        self.save_progress_bar.setValue(0)
        self.save_progress_bar.setFormat("Speichern: %p%")
        self.save_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #4CAF50;
                width: 20px;
            }
        """)
        self.save_progress_bar.hide()
        save_layout.addWidget(self.save_progress_bar)
        main_layout.addLayout(save_layout)
    
        # Konsolenansicht für Logs mit modernem Look
        log_group = self.create_log_group()
        main_layout.addWidget(log_group)
    
        # Ausgabeordner
        output_group = self.create_output_group()
        main_layout.addWidget(output_group)
    
        self.setCentralWidget(central_widget)
    
        # Statusleiste
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
    
        # Timer für verstrichene Zeit
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.update_elapsed_time)
        self.start_time = None
    
    def create_menubar(self):
        """Erstellt die Menüleiste."""
        menubar = self.menuBar()
    
        # Datei-Menü
        file_menu = menubar.addMenu('Datei')
    
        open_file_action = QAction('Datei öffnen', self)
        open_file_action.setShortcut('Ctrl+O')
        open_file_action.triggered.connect(self.open_file_dialog)
        file_menu.addAction(open_file_action)
    
        save_all_action = QAction('Alle speichern', self)
        save_all_action.setShortcut('Ctrl+S')
        save_all_action.triggered.connect(self.save_selected_tracks)
        file_menu.addAction(save_all_action)
    
        file_menu.addSeparator()
    
        exit_action = QAction('Beenden', self)
        exit_action.setShortcut('Ctrl+Q')
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
    
        # Einstellungen-Menü
        settings_menu = menubar.addMenu('Einstellungen')
    
        preferences_action = QAction('Einstellungen', self)
        preferences_action.setShortcut('Ctrl+,')
        preferences_action.triggered.connect(self.open_settings_dialog)
        settings_menu.addAction(preferences_action)
    
        # Hilfe-Menü
        help_menu = menubar.addMenu('Hilfe')
    
        about_action = QAction('Über', self)
        about_action.triggered.connect(self.show_about_dialog)
        help_menu.addAction(about_action)
    
    def create_input_group(self):
        """Erstellt das Eingabe-Layout für die Audioquelle."""
        input_group = QGroupBox("Audioquelle")
        layout = QHBoxLayout()
        layout.setSpacing(10)
    
        self.url_input = QLineEdit()
        self.url_input.setPlaceholderText("Geben Sie eine URL ein oder wählen Sie eine lokale Datei aus")
        self.url_input.setToolTip("Geben Sie eine URL (z.B. YouTube-Link) oder den Pfad zu einer lokalen Datei ein.")
        self.url_input.setStyleSheet("font-size: 14px; padding: 10px;")
        self.url_input.setMinimumHeight(40)
        self.url_input.setAcceptDrops(True)
        self.url_input.installEventFilter(self)
    
        self.select_file_btn = QPushButton("Datei auswählen")
        self.select_file_btn.clicked.connect(self.open_file_dialog)
        self.select_file_btn.setStyleSheet("""
            QPushButton {
                background-color: #2196F3;
                color: white;
                font-size: 14px;
                padding: 10px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #1976D2;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #1565C0;
                transform: scale(0.95);
            }
        """)
        self.select_file_btn.setToolTip("Öffnen Sie einen Dialog, um eine lokale Audio-/Videodatei auszuwählen.")
        self.select_file_btn.setMinimumHeight(40)
    
        layout.addWidget(self.url_input)
        layout.addWidget(self.select_file_btn)
        input_group.setLayout(layout)
        return input_group
    
    def create_progress_group(self):
        """Erstellt die Fortschrittsanzeigen."""
        progress_group = QGroupBox("Fortschritt")
        progress_layout = QVBoxLayout()
        progress_layout.setSpacing(10)
    
        self.current_action_label = QLabel("Bereit")
        self.current_action_label.setStyleSheet("font-size: 14px; padding: 5px; font-weight: bold;")
    
        self.overall_progress_bar = QProgressBar()
        self.overall_progress_bar.setValue(0)
        self.overall_progress_bar.setFormat("Gesamtfortschritt: %p%")
        self.overall_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #05B8CC;
                width: 20px;
            }
        """)
    
        self.download_progress_bar = QProgressBar()
        self.download_progress_bar.setValue(0)
        self.download_progress_bar.setFormat("Download: %p%")
        self.download_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #FFA726;
                width: 20px;
            }
        """)
        self.download_progress_bar.hide()
    
        self.extraction_progress_bar = QProgressBar()
        self.extraction_progress_bar.setValue(0)
        self.extraction_progress_bar.setFormat("Extraktion: %p%")
        self.extraction_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #66BB6A;
                width: 20px;
            }
        """)
        self.extraction_progress_bar.hide()
    
        self.segmentation_progress_bar = QProgressBar()
        self.segmentation_progress_bar.setValue(0)
        self.segmentation_progress_bar.setFormat("Segmentierung: %p%")
        self.segmentation_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #AB47BC;
                width: 20px;
            }
        """)
        self.segmentation_progress_bar.hide()
    
        self.metadata_progress_bar = QProgressBar()
        self.metadata_progress_bar.setValue(0)
        self.metadata_progress_bar.setFormat("Metadaten: %p%")
        self.metadata_progress_bar.setStyleSheet("""
            QProgressBar {
                border: 2px solid grey;
                border-radius: 5px;
                text-align: center;
            }
            QProgressBar::chunk {
                background-color: #FF7043;
                width: 20px;
            }
        """)
        self.metadata_progress_bar.hide()
    
        progress_layout.addWidget(self.current_action_label)
        progress_layout.addWidget(self.overall_progress_bar)
        progress_layout.addWidget(self.download_progress_bar)
        progress_layout.addWidget(self.extraction_progress_bar)
        progress_layout.addWidget(self.segmentation_progress_bar)
        progress_layout.addWidget(self.metadata_progress_bar)
        progress_group.setLayout(progress_layout)
        return progress_group
    
    def create_info_group(self):
        """Erstellt das Informations-Layout."""
        info_group = QGroupBox("Informationen")
        info_layout = QHBoxLayout()
        info_layout.setSpacing(20)
    
        self.elapsed_time_label = QLabel("Verstrichene Zeit: 0s")
        self.elapsed_time_label.setStyleSheet("font-size: 14px;")
    
        self.segment_count_label = QLabel("Verarbeitete Segmente: 0")
        self.segment_count_label.setStyleSheet("font-size: 14px;")
    
        info_layout.addWidget(self.elapsed_time_label)
        info_layout.addWidget(self.segment_count_label)
        info_group.setLayout(info_layout)
        return info_group
    
    def create_table_group(self):
        """Erstellt die Musiktabelle."""
        table_group = QGroupBox("Erkannte Musikstücke")
        table_layout = QVBoxLayout()
    
        self.music_table = QTableWidget()
        self.music_table.setMinimumHeight(300)
        self.music_table.setStyleSheet("font-size: 14px;")
        self.music_table.setColumnCount(7)
        self.music_table.setHorizontalHeaderLabels(['Album', 'Künstler', 'Titel', 'Cover', 'Wiedergabe', 'Speichern', ''])
        self.music_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.music_table.verticalHeader().setVisible(False)
        self.music_table.setSelectionBehavior(QTableWidget.SelectRows)
        self.music_table.setEditTriggers(QTableWidget.NoEditTriggers)
        self.music_table.setAlternatingRowColors(True)
        self.music_table.setStyleSheet("""
            QTableWidget {
                border: 1px solid gray;
            }
            QTableWidget::item:selected {
                background-color: #90CAF9;
            }
        """)
    
        table_layout.addWidget(self.music_table)
        table_group.setLayout(table_layout)
        return table_group
    
    def create_log_group(self):
        """Erstellt die Log-Konsolenansicht."""
        log_group = QGroupBox("Protokoll")
        log_layout = QVBoxLayout()
    
        self.log_console = QTextEdit()
        self.log_console.setReadOnly(True)
        self.log_console.setStyleSheet("""
            QTextEdit {
                background-color: #1E1E1E;
                color: #D4D4D4;
                font-family: Consolas, monospace;
                font-size: 12px;
            }
        """)
        self.log_console.setMinimumHeight(150)
    
        log_handler = QTextEditLogger(self.log_console)
        log_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
        logging.getLogger().addHandler(log_handler)
    
        log_layout.addWidget(self.log_console)
        log_group.setLayout(log_layout)
        return log_group
    
    def create_output_group(self):
        """Erstellt das Ausgabeordner-Layout."""
        output_group = QGroupBox("Ausgabe")
        output_layout = QHBoxLayout()
    
        self.output_dir_label = QLabel(f"Ausgabeordner: {self.output_dir}")
        self.output_dir_label.setStyleSheet("font-size: 14px;")
    
        self.output_dir_btn = QPushButton("Ausgabeordner wählen")
        self.output_dir_btn.clicked.connect(self.choose_output_directory)
        self.output_dir_btn.setToolTip("Wählen Sie den Ordner aus, in dem die verarbeiteten Tracks gespeichert werden sollen.")
        self.output_dir_btn.setStyleSheet("""
            QPushButton {
                background-color: #FF9800;
                color: white;
                font-size: 14px;
                padding: 5px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #F57C00;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #EF6C00;
                transform: scale(0.95);
            }
        """)
    
        output_layout.addWidget(self.output_dir_label)
        output_layout.addWidget(self.output_dir_btn)
        output_group.setLayout(output_layout)
        return output_group
    
    def disable_ssl_warnings(self):
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    
    def open_file_dialog(self):
        file_path, _ = QFileDialog.getOpenFileName(self, "Audio-/Videodatei auswählen", "", "Audio/Videos (*.mp3 *.wav *.ogg *.flac *.mp4 *.mkv);;Alle Dateien (*)")
        if file_path:
            self.url_input.setText(file_path)
            logging.info(f"Ausgewählte Datei: {file_path}")
            self.status_bar.showMessage(f"Ausgewählte Datei: {file_path}")
    
    def open_settings_dialog(self):
        """Öffnet den Einstellungsdialog."""
        dialog = SettingsDialog(self, self.settings)
        if dialog.exec_():
            new_settings = dialog.get_settings()
            theme_changed = new_settings.get('theme') != self.settings.get('theme')
            self.settings.update(new_settings)
            self.save_settings()
            logging.info("Einstellungen aktualisiert.")
            if theme_changed:
                self.apply_theme()
                logging.info("Thema geändert.")
            self.status_bar.showMessage("Einstellungen aktualisiert.")
    
    def show_about_dialog(self):
        """Zeigt den 'Über'-Dialog an."""
        QMessageBox.about(
            self,
            "Über Music Identifier",
            "<h2>Music Identifier</h2>"
            "<p>Version 1.0</p>"
            "<p>Entwickelt von Ihrem Namen</p>"
            "<p>Dieses Tool identifiziert und segmentiert Musikstücke aus Audioquellen.</p>"
            "<p>© 2023 Ihr Unternehmen</p>"
        )
    
    def handle_start(self):
        """Startet den Verarbeitungsprozess."""
        if self.is_processing:
            QMessageBox.warning(self, "Verarbeitung läuft", "Es läuft bereits ein Verarbeitungsprozess.")
            return
    
        url_or_path = self.url_input.text().strip()
        if not url_or_path:
            logging.warning("Keine URL oder Datei eingegeben.")
            self.current_action_label.setText("Fehler: Keine URL oder Datei eingegeben.")
            self.status_bar.showMessage("Fehler: Keine URL oder Datei eingegeben.")
            return
    
        self.is_processing = True
        self.disable_ui_elements()
        self.music_table.setRowCount(0)
        self.log_console.clear()
        self.current_action_label.setText("Start...")
        self.status_bar.showMessage("Start der Verarbeitung.")
        self.start_time = datetime.now()
        self.timer.start(1000)
    
        # Fortschrittsanzeigen zurücksetzen
        self.reset_progress_bars()
        self.download_progress_bar.show()
        self.extraction_progress_bar.show()
        self.segmentation_progress_bar.show()
        self.metadata_progress_bar.show()
    
        self.worker = Worker(url_or_path, self.settings)
        self.worker_thread = QThread()
        self.worker.moveToThread(self.worker_thread)
        self.worker_thread.started.connect(self.worker.run)
        self.worker.finished.connect(self.worker_thread.quit)
        self.worker.finished.connect(self.worker.deleteLater)
        self.worker_thread.finished.connect(self.worker_thread.deleteLater)
        self.worker.progress.connect(self.update_overall_progress)
        self.worker.download_progress.connect(self.update_download_progress)
        self.worker.extraction_progress.connect(self.update_extraction_progress)
        self.worker.segmentation_progress.connect(self.update_segmentation_progress)
        self.worker.overall_progress.connect(self.update_overall_progress_bar)
        self.worker.error.connect(self.display_error)
        self.worker.segments_ready.connect(self.handle_segments_ready)
        self.worker.finished.connect(self.on_worker_finished)
        self.worker_thread.start()
    
    def disable_ui_elements(self):
        """Deaktiviert UI-Elemente während der Verarbeitung."""
        self.start_btn.setEnabled(False)
        self.url_input.setEnabled(False)
        self.select_file_btn.setEnabled(False)
        self.output_dir_btn.setEnabled(False)
        self.manual_timestamps_btn.setEnabled(False)
    
    def enable_ui_elements(self):
        """Aktiviert UI-Elemente nach der Verarbeitung."""
        self.start_btn.setEnabled(True)
        self.url_input.setEnabled(True)
        self.select_file_btn.setEnabled(True)
        self.output_dir_btn.setEnabled(True)
        self.manual_timestamps_btn.setEnabled(True)
    
    def update_overall_progress(self, value: int, message: str):
        """Aktualisiert die Statusnachricht."""
        self.current_action_label.setText(message)
        self.overall_progress_bar.setValue(value)
        self.status_bar.showMessage(message)
        QApplication.processEvents()
    
    def update_overall_progress_bar(self, value: int):
        """Aktualisiert die Gesamtfortschrittsleiste."""
        self.overall_progress_bar.setValue(value)
        QApplication.processEvents()
    
    def update_download_progress(self, value: int):
        """Aktualisiert den Download-Fortschrittsbalken."""
        self.download_progress_bar.setValue(value)
        QApplication.processEvents()
    
    def update_extraction_progress(self, value: int):
        """Aktualisiert den Extraktions-Fortschrittsbalken."""
        self.extraction_progress_bar.setValue(value)
        QApplication.processEvents()
    
    def update_segmentation_progress(self, value: int):
        """Aktualisiert den Segmentierungs-Fortschrittsbalken."""
        self.segmentation_progress_bar.setValue(value)
        QApplication.processEvents()
    
    def display_error(self, message: str):
        """Zeigt eine Fehlermeldung an."""
        logging.error(message)
        QMessageBox.critical(self, "Fehler", message)
        self.current_action_label.setText("Fehler aufgetreten.")
        self.status_bar.showMessage("Fehler aufgetreten.")
        self.timer.stop()
        self.is_processing = False
        self.enable_ui_elements()
        self.reset_progress_bars()
    
    def handle_segments_ready(self, segments_info: List[dict], segments: List[AudioSegment]):
        """Verarbeitet die bereitgestellten Segmente."""
        self.segments_info = segments_info
        self.segments = segments
        self.total_segments = len(segments)
        self.populate_music_table(segments_info)
        self.timer.stop()
        self.overall_progress_bar.setValue(100)
        self.current_action_label.setText("Alle Segmente verarbeitet.")
        self.status_bar.showMessage("Alle Segmente verarbeitet.")
        logging.info("Segmente bereit zur Anzeige.")
    
    def populate_music_table(self, segments_info: List[dict]):
        """Füllt die Musiktabelle mit den Segmentinformationen."""
        self.music_table.setRowCount(len(segments_info))
        self.fetchers = {}
        self.players = {}
        self.metadata_progress_bar.setValue(0)
        default_save_all = self.settings.get('default_save_all', True)
        total_segments = len(segments_info)
    
        for index, info in enumerate(segments_info):
            self.add_music_table_row(index, info, default_save_all)
            self.create_media_player(index)
            self.start_metadata_fetcher(index, info.get('title', f'Track {index + 1}'), total_segments)
    
        self.current_action_label.setText("Metadaten werden abgerufen.")
        self.status_bar.showMessage("Metadaten werden abgerufen.")
    
    def add_music_table_row(self, index: int, info: dict, default_save: bool):
        """Fügt eine einzelne Zeile zur Musiktabelle hinzu."""
        album = info.get('album', '')
        artist = info.get('artist', '')
        title = info.get('title', 'Unbekannt')
    
        album_item = QTableWidgetItem(album)
        album_item.setFlags(album_item.flags() | Qt.ItemIsEditable)
        artist_item = QTableWidgetItem(artist)
        artist_item.setFlags(artist_item.flags() | Qt.ItemIsEditable)
        title_item = QTableWidgetItem(title)
        title_item.setFlags(title_item.flags() | Qt.ItemIsEditable)
    
        cover_label = QLabel()
        cover_label.setAlignment(Qt.AlignCenter)
        cover_label.setFixedSize(80, 80)
        cover_label.setStyleSheet("margin: 5px;")
        default_pixmap = QPixmap("default_cover.png") if os.path.exists("default_cover.png") else QPixmap()
        if default_pixmap and not default_pixmap.isNull():
            default_pixmap = default_pixmap.scaled(80, 80, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            cover_label.setPixmap(default_pixmap)
    
        # Wiedergabesteuerung
        play_button = QPushButton()
        play_icon = QIcon.fromTheme("media-playback-start") if not QIcon.fromTheme("media-playback-start").isNull() else QIcon("play.png")
        play_button.setIcon(play_icon)
        play_button.setIconSize(QSize(24,24))
        play_button.clicked.connect(partial(self.play_pause_audio, index))
        play_button.setEnabled(True)
    
        progress_slider = QSlider(Qt.Horizontal)
        progress_slider.setRange(0, 100)
        progress_slider.sliderMoved.connect(partial(self.seek_audio, index))
        progress_slider.setEnabled(False)
    
        # Speichern
        save_checkbox = QCheckBox()
        save_checkbox.setChecked(default_save)
        save_button = QPushButton("Speichern")
        save_button.clicked.connect(partial(self.save_track, index))
        save_button.setEnabled(True)
        save_button.setStyleSheet("""
            QPushButton {
                background-color: #F44336;
                color: white;
                font-size: 12px;
                padding: 5px;
                border-radius: 5px;
                transition: background-color 0.3s, transform 0.3s;
            }
            QPushButton:hover {
                background-color: #D32F2F;
                transform: scale(1.05);
            }
            QPushButton:pressed {
                background-color: #C62828;
                transform: scale(0.95);
            }
        """)
    
        self.music_table.setItem(index, 0, album_item)
        self.music_table.setItem(index, 1, artist_item)
        self.music_table.setItem(index, 2, title_item)
        self.music_table.setCellWidget(index, 3, cover_label)
    
        # Wiedergabe-Widgets
        playback_layout = QHBoxLayout()
        playback_layout.setContentsMargins(0, 0, 0, 0)
        playback_layout.setSpacing(5)
        playback_layout.addWidget(play_button)
        playback_layout.addWidget(progress_slider)
        playback_widget = QWidget()
        playback_widget.setLayout(playback_layout)
        self.music_table.setCellWidget(index, 4, playback_widget)
    
        self.music_table.setCellWidget(index, 5, save_checkbox)
        self.music_table.setCellWidget(index, 6, save_button)
    
    def create_media_player(self, index: int):
        """Erstellt einen MediaPlayer für den angegebenen Index."""
        player = QMediaPlayer()
        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
        self.segments[index].export(temp_file.name, format="mp3", bitrate="320k")
        url = QUrl.fromLocalFile(temp_file.name)
        player.setMedia(QMediaContent(url))
    
        # Aktualisieren des Sliders während der Wiedergabe
        player.positionChanged.connect(partial(self.update_slider_position, index))
        player.durationChanged.connect(partial(self.update_slider_duration, index))
        player.mediaStatusChanged.connect(partial(self.handle_media_status, index))
        player.error.connect(partial(self.handle_player_error, index))
    
        self.players[index] = {
            'player': player,
            'temp_file': temp_file.name,
            'slider': self.music_table.cellWidget(index, 4).findChild(QSlider)
        }
    
    def handle_player_error(self, index: int, error: QMediaPlayer.Error):
        """Behandelt Fehler des MediaPlayers."""
        if error != QMediaPlayer.NoError:
            error_message = self.players[index]['player'].errorString()
            logging.error(f"Fehler beim Abspielen von Track {index + 1}: {error_message}")
            QMessageBox.critical(self, "Wiedergabefehler", f"Fehler beim Abspielen von Track {index + 1}: {error_message}")
    
    def start_metadata_fetcher(self, index: int, title: str, total_tracks: int):
        """Startet einen Thread zur Metadatenabfrage."""
        fetcher = MetadataFetcher(index, title, total_tracks, self.cache)
        fetcher.result_ready.connect(self.update_metadata)
        fetcher.progress.connect(self.update_metadata_progress)
        task = MetadataFetcherTask(fetcher)
        self.thread_pool.start(task)
        self.fetchers[index] = fetcher
    
    def update_metadata_progress(self, value: int):
        """Aktualisiert den Fortschritt der Metadatenabfrage."""
        self.metadata_progress_bar.setValue(value)
        QApplication.processEvents()
    
    def update_metadata(self, index: int, artist: str, album: str, title: str, cover_data: Optional[bytes]):
        """Aktualisiert die Metadaten in der Tabelle."""
        self.music_table.item(index, 0).setText(album)
        self.music_table.item(index, 1).setText(artist)
        self.music_table.item(index, 2).setText(title)
        cover_label = self.music_table.cellWidget(index, 3)
        if cover_data and cover_label:
            pixmap = QPixmap()
            pixmap.loadFromData(cover_data)
            pixmap = pixmap.scaled(80, 80, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            cover_label.setPixmap(pixmap)
            logging.info(f"Cover aktualisiert für Track {index + 1}")
    
        processed = sum(1 for i in range(self.music_table.rowCount())
                        if self.music_table.item(i, 1).text())
        self.segment_count_label.setText(f"Verarbeitete Segmente: {processed}/{self.total_segments}")
        logging.info(f"Verarbeitete Segmente: {processed}/{self.total_segments}")
    
        if processed == self.total_segments:
            self.current_action_label.setText("Alle Segmente verarbeitet.")
            self.status_bar.showMessage("Alle Segmente verarbeitet.")
            logging.info("Alle Segmente verarbeitet.")
    
        if index in self.fetchers:
            del self.fetchers[index]
    
    def save_selected_tracks(self):
        """Speichert die ausgewählten Tracks."""
        tracks_to_save = {}
        for index in range(self.music_table.rowCount()):
            save_item = self.music_table.cellWidget(index, 5)
            if isinstance(save_item, QCheckBox) and save_item.isChecked():
                tracks_to_save[index] = {
                    'save_function': partial(self.save_segment_as_mp3_wrapper, index)
                }
        if tracks_to_save:
            self.save_progress_bar.show()
            self.save_progress_bar.setValue(0)
            self.save_worker = SaveWorker(tracks_to_save, self)
            self.save_thread = QThread()
            self.save_worker.moveToThread(self.save_thread)
            self.save_thread.started.connect(self.save_worker.run)
            self.save_worker.progress.connect(self.update_save_progress)
            self.save_worker.finished.connect(self.on_save_finished)
            self.save_worker.finished.connect(self.save_thread.quit)
            self.save_worker.finished.connect(self.save_worker.deleteLater)
            self.save_thread.finished.connect(self.save_thread.deleteLater)
            self.save_thread.start()
            logging.info("Speichervorgang gestartet.")
            self.status_bar.showMessage("Speichervorgang gestartet.")
        else:
            logging.info("Keine Tracks zum Speichern ausgewählt.")
            QMessageBox.information(self, "Keine Auswahl", "Es wurden keine Tracks zum Speichern ausgewählt.")
            self.status_bar.showMessage("Keine Tracks zum Speichern ausgewählt.")
    
    def update_save_progress(self, value: int):
        self.save_progress_bar.setValue(value)
        self.current_action_label.setText(f"Speicherfortschritt: {value}%")
        self.status_bar.showMessage(f"Speicherfortschritt: {value}%")
        QApplication.processEvents()
    
    def on_save_finished(self):
        self.save_progress_bar.hide()
        self.current_action_label.setText("Speichern abgeschlossen.")
        self.status_bar.showMessage("Speichern abgeschlossen.")
        logging.info("Speichern abgeschlossen.")
    
    def save_track(self, index: int):
        """Speichert einen einzelnen Track."""
        self.save_segment_as_mp3_wrapper(index)
        logging.info(f"Segment {index + 1} wurde gespeichert.")
        self.status_bar.showMessage(f"Segment {index + 1} wurde gespeichert.")
    
    def save_segment_as_mp3_wrapper(self, index: int):
        """Wrapper-Method zur Speicherung eines Segments."""
        album = self.music_table.item(index, 0).text()
        artist = self.music_table.item(index, 1).text()
        title = self.music_table.item(index, 2).text()
        cover_label = self.music_table.cellWidget(index, 3)
        cover_data = None
        if cover_label and isinstance(cover_label, QLabel) and cover_label.pixmap():
            pixmap = cover_label.pixmap()
            buffer = QBuffer()
            buffer.open(QIODevice.WriteOnly)
            pixmap.save(buffer, 'JPEG')
            cover_data = buffer.data().data()
        self.save_segment_as_mp3(index, title, artist, album, cover_data)
    
    def save_segment_as_mp3(self, index: int, title: str, artist: str, album: str, cover_data: Optional[bytes]):
        """Speichert ein Audiosegment als MP3-Datei mit Metadaten."""
        try:
            segment = self.segments[index]
            sanitized_title = ''.join(c for c in title if c not in r'<>:"/\|?*').strip()
            sanitized_artist = ''.join(c for c in artist if c not in r'<>:"/\|?*').strip()
            sanitized_album = ''.join(c for c in album if c not in r'<>:"/\|?*').strip()
            if sanitized_artist and sanitized_title:
                base_filename = f"{sanitized_artist} - {sanitized_title}.mp3"
            else:
                base_filename = f"Track_{index + 1}.mp3"
            filename = os.path.join(self.output_dir, base_filename)
    
            if os.path.exists(filename):
                count = 1
                while True:
                    new_filename = os.path.join(self.output_dir, f"{os.path.splitext(base_filename)[0]} ({count}).mp3")
                    if not os.path.exists(new_filename):
                        filename = new_filename
                        break
                    count += 1
    
            # Exportiere das Audiosegment
            segment.export(filename, format="mp3", bitrate="320k", codec="libmp3lame", parameters=["-q:a", "0"])
    
            # Setze Metadaten
            audiofile = MP3(filename, ID3=ID3)
            try:
                audiofile.add_tags()
            except error:
                pass
            audiofile.tags["TIT2"] = TIT2(encoding=3, text=title)
            audiofile.tags["TPE1"] = TPE1(encoding=3, text=artist)
            audiofile.tags["TALB"] = TALB(encoding=3, text=album)
            if cover_data:
                audiofile.tags["APIC"] = APIC(
                    encoding=3,
                    mime='image/jpeg',
                    type=3,
                    desc='Cover',
                    data=cover_data
                )
            audiofile.save()
            logging.info(f"Segment {index + 1}: '{title}' wurde als '{filename}' gespeichert.")
            self.status_bar.showMessage(f"Segment {index + 1}: '{title}' wurde gespeichert.")
        except Exception as e:
            logging.error(f"Fehler beim Speichern von Segment {index + 1}: {e}")
            QMessageBox.critical(self, "Speicherfehler", f"Fehler beim Speichern von Segment {index + 1}: {e}")
            self.status_bar.showMessage(f"Fehler beim Speichern von Segment {index + 1}.")
    
    def choose_output_directory(self):
        """Öffnet einen Dialog zur Auswahl des Ausgabeordners."""
        directory = QFileDialog.getExistingDirectory(self, "Ausgabeordner auswählen", self.output_dir)
        if directory:
            self.output_dir = directory
            self.output_dir_label.setText(f"Ausgabeordner: {self.output_dir}")
            self.save_settings()
            logging.info(f"Ausgabeordner geändert zu: {self.output_dir}")
            self.status_bar.showMessage(f"Ausgabeordner geändert zu: {self.output_dir}")
    
    def load_settings(self):
        """Lädt die Anwendungseinstellungen."""
        self.config.read('settings.ini')
        if 'SETTINGS' not in self.config:
            self.config['SETTINGS'] = {}
    
        # Einstellungen für die Segmentierung
        self.settings = {
            'min_silence_len': self.config.getint('SETTINGS', 'min_silence_len', fallback=2000),
            'silence_thresh_adjust': self.config.getint('SETTINGS', 'silence_thresh_adjust', fallback=-16),
            'keep_silence': self.config.getint('SETTINGS', 'keep_silence', fallback=500),
            'min_segment_length': self.config.getint('SETTINGS', 'min_segment_length', fallback=10000),
            'default_save_all': self.config.getboolean('SETTINGS', 'default_save_all', fallback=True),
            'theme': self.config.get('SETTINGS', 'theme', fallback='Dunkel'),
            'output_dir': self.config.get('SETTINGS', 'output_dir', fallback=os.getcwd())
        }
    
    def save_settings(self):
        """Speichert die Anwendungseinstellungen."""
        if 'SETTINGS' not in self.config:
            self.config['SETTINGS'] = {}
        self.config['SETTINGS']['output_dir'] = self.output_dir
        self.config['SETTINGS']['min_silence_len'] = str(self.settings['min_silence_len'])
        self.config['SETTINGS']['silence_thresh_adjust'] = str(self.settings['silence_thresh_adjust'])
        self.config['SETTINGS']['keep_silence'] = str(self.settings['keep_silence'])
        self.config['SETTINGS']['min_segment_length'] = str(self.settings['min_segment_length'])
        self.config['SETTINGS']['default_save_all'] = str(self.settings['default_save_all'])
        self.config['SETTINGS']['theme'] = self.settings['theme']
        with open('settings.ini', 'w', encoding='utf-8') as configfile:
            self.config.write(configfile)
    
    def reset_progress_bars(self):
        """Setzt alle Fortschrittsbalken zurück."""
        self.overall_progress_bar.setValue(0)
        self.download_progress_bar.setValue(0)
        self.extraction_progress_bar.setValue(0)
        self.segmentation_progress_bar.setValue(0)
        self.metadata_progress_bar.setValue(0)
    
    def update_elapsed_time(self):
        """Aktualisiert die Anzeige der verstrichenen Zeit."""
        if self.start_time:
            elapsed_time = (datetime.now() - self.start_time).seconds
            self.elapsed_time_label.setText(f"Verstrichene Zeit: {elapsed_time}s")
    
    def on_worker_finished(self):
        """Wird aufgerufen, wenn der Worker-Thread beendet ist."""
        self.is_processing = False
        self.enable_ui_elements()
        self.update_overall_progress(100, "Verarbeitung abgeschlossen")
        self.status_bar.showMessage("Verarbeitung abgeschlossen.")
        logging.info("Verarbeitung abgeschlossen.")
    
    def open_timestamps_dialog(self):
        """Öffnet den Dialog zur manuellen Eingabe von Zeitstempeln."""
        dialog = TimestampsDialog(self)
        if dialog.exec_():
            manual_timestamps = dialog.get_timestamps()
            if manual_timestamps:
                self.worker.manual_timestamps = manual_timestamps
                self.worker.segment_using_timestamps(manual_timestamps)
                logging.info(f"Manuell eingegebene Zeitstempel: {manual_timestamps}")
                self.status_bar.showMessage("Manuelle Zeitstempel eingegeben.")
            else:
                logging.warning("Keine gültigen manuell eingegebenen Zeitstempel.")
                QMessageBox.warning(self, "Ungültige Eingabe", "Keine gültigen Zeitstempel eingegeben.")
    
    def eventFilter(self, source, event):
        """Filter für Drag-and-Drop in das URL-Eingabefeld."""
        if source == self.url_input:
            if event.type() == event.DragEnter:
                if event.mimeData().hasUrls():
                    event.acceptProposedAction()
                    return True
            elif event.type() == event.Drop:
                if event.mimeData().hasUrls():
                    urls = event.mimeData().urls()
                    if urls:
                        file_path = urls[0].toLocalFile()
                        if os.path.exists(file_path):
                            self.url_input.setText(file_path)
                            logging.info(f"Per Drag-and-Drop ausgewählte Datei: {file_path}")
                            self.status_bar.showMessage(f"Per Drag-and-Drop ausgewählte Datei: {file_path}")
                            return True
        return super().eventFilter(source, event)
    
    def apply_theme(self):
        """Setzt das Farbschema gemäß den Einstellungen."""
        theme = self.settings.get('theme', 'Dunkel')
        if theme == 'Hell' or theme == 'System':
            QApplication.setPalette(QApplication.style().standardPalette())
        else:  # Dunkel
            dark_palette = QPalette()
            dark_color = QColor(45, 45, 45)
            disabled_color = QColor(127, 127, 127)
    
            dark_palette.setColor(QPalette.Window, dark_color)
            dark_palette.setColor(QPalette.WindowText, Qt.white)
            dark_palette.setColor(QPalette.Base, QColor(30, 30, 30))
            dark_palette.setColor(QPalette.AlternateBase, dark_color)
            dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
            dark_palette.setColor(QPalette.ToolTipText, Qt.white)
            dark_palette.setColor(QPalette.Text, Qt.white)
            dark_palette.setColor(QPalette.Disabled, QPalette.Text, disabled_color)
            dark_palette.setColor(QPalette.Button, dark_color)
            dark_palette.setColor(QPalette.ButtonText, Qt.white)
            dark_palette.setColor(QPalette.Disabled, QPalette.ButtonText, disabled_color)
            dark_palette.setColor(QPalette.BrightText, Qt.red)
            dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
            dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
            dark_palette.setColor(QPalette.HighlightedText, Qt.black)
    
            QApplication.setPalette(dark_palette)
            QApplication.setStyle("Fusion")
    

    class Worker(QObject): """ Arbeiterklasse für die Verarbeitung von Audio, einschließlich Download, Extraktion, Segmentierung und Identifizierung. """ segmentation_finished = pyqtSignal() finished = pyqtSignal() progress = pyqtSignal(int, str) error = pyqtSignal(str) segments_ready = pyqtSignal(list, list) download_progress = pyqtSignal(int) extraction_progress = pyqtSignal(int) segmentation_progress = pyqtSignal(int) overall_progress = pyqtSignal(int)

    def __init__(self, url_or_path: str, settings: dict):
        super().__init__()
        self.url_or_path = url_or_path
        self.settings = settings
        self.segments: List[AudioSegment] = []
        self.segments_info: List[dict] = []
        self.video_description = ''
        self.audio: Optional[AudioSegment] = None
        self.manual_timestamps = []
        self.total_steps = 3  # Download, Extraktion, Segmentierung
    
    def run(self):
        """Startet den Verarbeitungsprozess."""
        try:
            self.progress.emit(0, "Audio wird vorbereitet...")
            self.overall_progress.emit(0)
            step = 0
            if self.url_or_path.lower().startswith('http'):
                success = self.download_audio(self.url_or_path)
                if not success:
                    self.error.emit("Download fehlgeschlagen.")
                    return
                step += 1
                self.overall_progress.emit(int((step / self.total_steps) * 100))
            else:
                self.process_local_file(self.url_or_path)
                step += 1
                self.overall_progress.emit(int((step / self.total_steps) * 100))
            self.segment_and_identify()
            step += 1
            self.overall_progress.emit(int((step / self.total_steps) * 100))
            self.finished.emit()
        except Exception as e:
            error_message = f"Ein Fehler ist aufgetreten: {str(e)}"
            logging.error(error_message)
            logging.error(traceback.format_exc())
            self.error.emit(error_message)
            self.finished.emit()
    
    def download_audio(self, url: str) -> bool:
        """Lädt das Audio von der gegebenen URL herunter."""
        self.progress.emit(10, "Audio wird heruntergeladen...")
        self.download_progress.emit(0)
        success = False
        try:
            with tempfile.TemporaryDirectory() as temp_dir:
                output_template = os.path.join(temp_dir, 'downloaded_audio.%(ext)s')
                ydl_opts = {
                    'format': 'bestaudio/best',
                    'outtmpl': output_template,
                    'quiet': True,
                    'no_warnings': True,
                    'ignoreerrors': False,
                    'nocheckcertificate': True,
                    'socket_timeout': 60,  # Erhöhtes Timeout
                    'retries': 3,  # Retry-Logik
                    'postprocessors': [{
                        'key': 'FFmpegExtractAudio',
                        'preferredcodec': 'mp3',
                        'preferredquality': '320',
                    }],
                    'progress_hooks': [self.ydl_hook],
                }
                with YoutubeDL(ydl_opts) as ydl:
                    info_dict = ydl.extract_info(url, download=True)
                    if info_dict is not None:
                        self.video_description = info_dict.get('description', '')
                        filename = ydl.prepare_filename(info_dict)
                        filename = os.path.splitext(filename)[0] + '.mp3'
                        if os.path.exists(filename):
                            self.extract_audio(filename)
                            success = True
                            logging.info("Download mit yt_dlp erfolgreich.")
                        else:
                            logging.warning("Heruntergeladene Datei nicht gefunden.")
                            self.error.emit("Heruntergeladene Datei nicht gefunden.")
                    else:
                        logging.warning("Download mit yt_dlp fehlgeschlagen.")
                        self.error.emit("Download fehlgeschlagen.")
        except Exception as e_yt_dlp:
            logging.error(f"Download mit yt_dlp fehlgeschlagen: {e_yt_dlp}")
            self.error.emit(f"Download fehlgeschlagen: {e_yt_dlp}")
        finally:
            if success:
                self.progress.emit(30, "Download abgeschlossen.")
                self.download_progress.emit(100)
        return success
    
    def ydl_hook(self, d):
        if d['status'] == 'downloading':
            if d.get('total_bytes'):
                percentage = d.get('downloaded_bytes', 0) / d.get('total_bytes', 1) * 100
            elif d.get('total_bytes_estimate'):
                percentage = d.get('downloaded_bytes', 0) / d.get('total_bytes_estimate', 1) * 100
            else:
                percentage = 0
            self.download_progress.emit(int(percentage))
        elif d['status'] == 'finished':
            self.download_progress.emit(100)
    
    def process_local_file(self, file_path: str):
        """Verarbeitet eine lokale Datei."""
        self.progress.emit(10, "Lokale Datei wird verarbeitet...")
        self.extract_metadata_from_file(file_path)
        self.extract_audio(file_path)
    
    def extract_audio(self, file_path: str):
        """Extrahiert das Audio aus der gegebenen Datei."""
        try:
            if not os.path.exists(file_path):
                raise Exception(f"Audiodatei nicht gefunden: {file_path}")
            self.progress.emit(35, "Audio wird extrahiert...")
            self.extraction_progress.emit(0)
    
            self.audio = AudioSegment.from_file(file_path)
            logging.info(f"Audio extrahiert in {(time.time())} Sekunden.")
            self.extraction_progress.emit(100)
            self.progress.emit(40, "Audio erfolgreich extrahiert.")
        except Exception as e:
            raise Exception(f"Fehler beim Extrahieren des Audios: {str(e)}")
    
    def extract_metadata_from_file(self, file_path: str):
        """Extrahiert Metadaten aus der lokalen Datei."""
        try:
            if file_path.lower().endswith(('.mp3', '.wav', '.flac', '.ogg')):
                audio = MP3(file_path)
                title = audio.tags.get("TIT2", "").text[0] if audio.tags.get("TIT2") else ''
                artist = audio.tags.get("TPE1", "").text[0] if audio.tags.get("TPE1") else ''
                self.video_description = f"{title} {artist}"
                logging.info("Metadaten aus lokaler Datei extrahiert.")
        except (AttributeError, error) as e:
            logging.warning(f"Keine Metadaten aus lokaler Datei extrahiert: {e}")
    
    def segment_and_identify(self):
        """Segmentiert das Audio und identifiziert die einzelnen Tracks."""
        self.progress.emit(45, "Audio wird segmentiert...")
        self.segmentation_progress.emit(0)
        timestamps = self.parse_timestamps(self.video_description)
        if timestamps:
            logging.info("Zeitstempel aus Videobeschreibung werden für die Segmentierung verwendet.")
            self.segment_using_timestamps(timestamps)
        else:
            logging.info("Keine Zeitstempel gefunden.")
            if self.manual_timestamps:
                logging.info("Verwende manuell eingegebene Zeitstempel.")
                self.segment_using_timestamps(self.manual_timestamps)
            else:
                logging.info("Versuche Stilleerkennung.")
                self.segment_using_silence_detection()
                if not self.segments:
                    logging.info("Stilleerkennung fehlgeschlagen, versuche alternative Segmentierung.")
                    self.segment_using_fixed_length()
                    if not self.segments:
                        logging.warning("Alternative Segmentierung fehlgeschlagen, gesamtes Audio wird verwendet.")
                        self.segments.append(self.audio)
                        self.segments_info.append({'title': 'Gesamtes Audio'})
        self.segmentation_progress.emit(100)
        self.progress.emit(80, "Segmentierung abgeschlossen.")
        self.segments_ready.emit(self.segments_info, self.segments)
    
    def segment_using_timestamps(self, timestamps: List[Tuple[int, str]]):
        """Segmentiert das Audio basierend auf Zeitstempeln."""
        total = len(timestamps)
        for i, (start_time, title) in enumerate(timestamps):
            progress = int(((i + 1) / total) * 100)
            self.segmentation_progress.emit(progress)
            start_ms = int(start_time * 1000)
            end_ms = int(timestamps[i + 1][0] * 1000) if i + 1 < len(timestamps) else len(self.audio)
            if start_ms >= len(self.audio):
                logging.warning(f"Startzeit {start_time}s überschreitet die Audiodauer.")
                continue
            segment = self.audio[start_ms:end_ms]
            self.segments.append(segment)
            self.segments_info.append({'title': title})
            logging.info(f"Segment {i + 1}: '{title}' erstellt von {start_time}s bis {end_ms / 1000}s.")
    
    def segment_using_silence_detection(self):
        """Segmentiert das Audio durch Stilleerkennung."""
        if not self.audio:
            logging.error("Keine Audiodaten zum Segmentieren vorhanden.")
            return
    
        min_silence_len = self.settings.get('min_silence_len', 2000)
        silence_thresh_adjust = self.settings.get('silence_thresh_adjust', -16)
        silence_thresh = self.audio.dBFS + silence_thresh_adjust
        keep_silence = self.settings.get('keep_silence', 500)
        logging.info(f"Stilleerkennung mit min_silence_len={min_silence_len}, silence_thresh={silence_thresh} dBFS")
    
        chunks = split_on_silence(
            self.audio,
            min_silence_len=min_silence_len,
            silence_thresh=silence_thresh,
            keep_silence=keep_silence
        )
    
        min_segment_length = self.settings.get('min_segment_length', 10000)
        segments = [s for s in chunks if len(s) > min_segment_length]
    
        if segments:
            self.segments = segments
            self.segments_info = [{'title': f'Track {i + 1}'} for i in range(len(segments))]
            logging.info(f"{len(segments)} Segmente durch Stilleerkennung gefunden.")
        else:
            logging.warning("Keine Segmente mit Stilleerkennung gefunden.")
    
    def segment_using_fixed_length(self, segment_length_ms: int = 180000):
        """Segmentiert das Audio in feste Längen."""
        if not self.audio:
            logging.error("Keine Audiodaten zum Segmentieren vorhanden.")
            return
    
        self.segments = []
        self.segments_info = []
        total_length_ms = len(self.audio)
        num_segments = total_length_ms // segment_length_ms + 1
        for i, start_ms in enumerate(range(0, total_length_ms, segment_length_ms)):
            progress = int(((i + 1) / num_segments) * 100)
            self.segmentation_progress.emit(progress)
            end_ms = min(start_ms + segment_length_ms, total_length_ms)
            segment = self.audio[start_ms:end_ms]
            self.segments.append(segment)
            self.segments_info.append({'title': f'Track {len(self.segments)}'})
            logging.info(f"Segment {i + 1}: 'Track {len(self.segments)}' erstellt von {start_ms / 1000}s bis {end_ms / 1000}s.")
        logging.info(f"{len(self.segments)} Segmente durch feste Länge erzeugt.")
    
    def parse_timestamps(self, description: str) -> List[Tuple[int, str]]:
        """Parst Zeitstempel und Titel aus der Videobeschreibung."""
        timestamps = []
        lines = description.splitlines()
        for line in lines:
            line = line.strip()
            if not line:
                continue
            # Muster für verschiedene Zeitstempelformate
            patterns = [
                r'^(\d{1,2}:\d{2}:\d{2})\s*[-–—]\s*(.+)$',
                r'^(\d{1,2}:\d{2})\s*[-–—]\s*(.+)$',
                r'^(\d{1,2}\.\d{2}\.\d{2})\s*[-–—]?\s*(.+)$',
                r'^(\d{1,2}\.\d{2})\s*[-–—]?\s*(.+)$',
                r'^(\d+)\s*[-–—]?\s*(.+)$',
            ]
            matched = False
            for pattern in patterns:
                match = re.match(pattern, line)
                if match:
                    time_str = match.group(1)
                    title = match.group(2)
                    total_seconds = self.convert_time_to_seconds(time_str)
                    if total_seconds is not None:
                        timestamps.append((total_seconds, title.strip()))
                        logging.debug(f"Zeitstempel gefunden: {time_str} - {title.strip()}")
                    matched = True
                    break
            if not matched:
                logging.debug(f"Kein gültiger Zeitstempel in Zeile: {line}")
        timestamps.sort(key=lambda x: x[0])
        logging.info(f"{len(timestamps)} Zeitstempel aus der Beschreibung geparst.")
        return timestamps
    
    def convert_time_to_seconds(self, time_str: str) -> Optional[int]:
        try:
            time_str = time_str.strip()
            if ':' in time_str:
                parts = [int(p) for p in time_str.split(':')]
                if len(parts) == 3:
                    hours, minutes, seconds = parts
                elif len(parts) == 2:
                    hours = 0
                    minutes, seconds = parts
                else:
                    return None
                total_seconds = hours * 3600 + minutes * 60 + seconds
            elif '.' in time_str:
                parts = [int(p) for p in time_str.split('.')]
                if len(parts) == 3:
                    hours, minutes, seconds = parts
                elif len(parts) == 2:
                    hours = 0
                    minutes, seconds = parts
                else:
                    return None
                total_seconds = hours * 3600 + minutes * 60 + seconds
            else:
                total_seconds = int(time_str)
            return total_seconds
        except ValueError:
            return None
    

    Run the application

    if name == "main": app = QApplication(sys.argv) window = MusicIdentifierApp() window.show() sys.exit(app.exec_())

  2. Assistant

    Um die von Ihnen beschriebenen Probleme zu beheben und die Benutzeroberfläche Ihrer Anwendung zu verbessern, haben wir folgende Änderungen vorgenommen:

    1. Entfernung von CSS-Transitions und -Transforms: Da PyQt5 CSS-Transitions und -Transforms nicht vollständig unterstützt, wurden diese entfernt, um die Fehlermeldungen zu eliminieren.

    2. Implementierung von QPropertyAnimation: Anstelle von CSS-Animationen werden nun QPropertyAnimation und QGraphicsEffect verwendet, um animierte Effekte für Buttons zu realisieren. Dies umfasst Hover- und Klick-Effekte sowie grafische Verbesserungen wie Schatten.

    3. Verbesserung des Layouts: Das Layout wurde neu strukturiert, um eine flexiblere und benutzerfreundlichere Anordnung der Elemente zu gewährleisten. Der Gesamtfortschrittsbalken ist nun prominenter platziert, und relevante Elemente wie der Fortschrittsbalken und die Musiktabelle werden deutlicher hervorgehoben.

    4. Hinzufügen von Lautstärkeregelung: Jeder MediaPlayer besitzt nun einen separaten Lautstärkeregler, der die Lautstärke der jeweiligen Wiedergabe steuert.

    5. Implementierung der Audio-Wellenform-Visualisierung: Eine benutzerdefinierte Wellenform-Visualisierung wurde hinzugefügt, um eine visuelle Darstellung der Audiospur zu bieten.

    6. Weitere Verbesserungen: Zusätzliche grafische Effekte und optimierte Farbgebung sorgen für ein ästhetisch ansprechenderes Erscheinungsbild der Anwendung.

    Nachfolgend finden Sie das vollständige, verbesserte Skript.

    import os
    import sys
    import logging
    import traceback
    import warnings
    import re
    import configparser
    from datetime import datetime
    from typing import List, Tuple, Optional
    import time
    import tempfile
    import threading
    from functools import partial
    import urllib3
    
    from PyQt5.QtWidgets import (
        QApplication, QMainWindow, QPushButton, QVBoxLayout, QHBoxLayout,
        QLineEdit, QFileDialog, QLabel, QWidget, QProgressBar, QTableWidget,
        QTableWidgetItem, QHeaderView, QCheckBox, QTextEdit, QMessageBox, QSlider,
        QSpinBox, QFormLayout, QDialog, QAction, QGroupBox,
        QComboBox, QStatusBar, QMenuBar, QGraphicsDropShadowEffect, QSizePolicy
    )
    from PyQt5.QtCore import (
        Qt, QTimer, QObject, pyqtSignal, QThreadPool, QRunnable,
        QIODevice, QBuffer, QUrl, QThread, QMetaObject, Q_ARG, QSize, QRectF, QPointF
    )
    from PyQt5.QtGui import QIcon, QPixmap, QTextCursor, QColor, QPalette, QPainter, QPen
    from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
    
    from pydub import AudioSegment
    from pydub.silence import split_on_silence
    
    import requests
    from mutagen.id3 import ID3, TIT2, TPE1, TALB, APIC, error
    from mutagen.mp3 import MP3
    
    from yt_dlp import YoutubeDL
    
    from bs4 import BeautifulSoup
    
    import musicbrainzngs
    musicbrainzngs.set_useragent("MusicIdentifierApp", "1.0", "your-email@example.com")
    MUSICBRAINZ_AVAILABLE = True
    
    # Unterdrücke Deprecation-Warnings von PyQt5
    warnings.filterwarnings('ignore', category=DeprecationWarning)
    
    
    class MetadataFetcher(QObject):
        result_ready = pyqtSignal(int, str, str, str, object)
        progress = pyqtSignal(int)
    
        def __init__(self, index: int, title: str, total: int, cache: dict):
            super().__init__()
            self.index = index
            self.title = title
            self.total = total
            self.cache = cache
    
        def run(self):
            try:
                logging.info(f"Starte Metadatenabfrage für Index {self.index}: '{self.title}'")
                if self.title in self.cache:
                    result = self.cache[self.title]
                    logging.info(f"Metadaten aus Cache für Index {self.index}: {result}")
                else:
                    result = self.get_cover_and_metadata(self.title)
                    self.cache[self.title] = result
                    logging.info(f"Metadaten abgefragt und im Cache gespeichert für Index {self.index}: {result}")
                self.result_ready.emit(self.index, *result)
            except Exception as e:
                logging.error(f"Fehler beim Abrufen der Metadaten für Index {self.index}: {str(e)}")
                self.result_ready.emit(self.index, '', '', self.title, None)
            finally:
                progress_value = int(((self.index + 1) / self.total) * 100)
                self.progress.emit(progress_value)
    
        def get_cover_and_metadata(self, title: str) -> Tuple[Optional[bytes], str, str, str]:
            cover_data, artist, album, track_title, lyrics = self.search_musicbrainz(title)
            if not all([artist, album, track_title]):
                cover_data, artist, album, track_title = self.search_azlyrics(title, lyrics)
            return cover_data, artist, album, track_title
    
        def search_musicbrainz(self, query: str) -> Tuple[Optional[bytes], str, str, str, Optional[str]]:
            if not MUSICBRAINZ_AVAILABLE:
                return None, '', '', '', None
            try:
                result = musicbrainzngs.search_recordings(query=query, limit=1, strict=False)
                if result['recording-list']:
                    recording = result['recording-list'][0]
                    artist = recording['artist-credit'][0]['name']
                    track_title = recording['title']
                    album = recording['release-list'][0]['title'] if recording.get('release-list') else ''
                    release_id = recording['release-list'][0]['id'] if recording.get('release-list') else ''
                    cover_data = self.get_cover_from_coverartarchive(release_id) if release_id else None
    
                    # Extrahiere Lyrics, falls verfügbar
                    lyrics = self.fetch_lyrics(track_title, artist)
    
                    logging.debug(f"MusicBrainz gefunden: Artist='{artist}', Album='{album}', Titel='{track_title}'")
                    return cover_data, artist, album, track_title, lyrics
            except Exception as e:
                logging.error(f"Fehler bei der MusicBrainz-Abfrage: {e}")
            return None, '', '', '', None
    
        def search_azlyrics(self, query: str, lyrics: Optional[str]) -> Tuple[Optional[bytes], str, str, str]:
            try:
                search_url = f"https://search.azlyrics.com/search.php?q={requests.utils.quote(query)}"
                response = requests.get(search_url, timeout=10)
                soup = BeautifulSoup(response.text, 'html.parser')
                result = soup.find('td', class_='text-left visitedlyr')
                if result:
                    link = result.find('a')['href']
                    artist, title = self.extract_artist_title(link)
                    logging.debug(f"AZLyrics gefunden: Artist='{artist}', Titel='{title}'")
    
                    # Optional: Extrahiere Lyrics von der Lyrics-Seite
                    lyrics = self.fetch_lyrics(title, artist, link)
                    if lyrics:
                        logging.debug(f"Lyrics extrahiert für '{title}': {lyrics[:100]}...")  # Loggt die ersten 100 Zeichen der Lyrics
    
                    return None, artist, '', title
            except Exception as e:
                logging.error(f"Fehler bei der AZLyrics-Abfrage: {e}")
            return None, '', '', ''
    
        def extract_artist_title(self, url: str) -> Tuple[str, str]:
            parts = url.split('/')
            artist = parts[-2].replace('+', ' ').strip()
            title = parts[-1].split('.')[0].replace('+', ' ').strip()
            return artist, title
    
        def get_cover_from_coverartarchive(self, release_id: str) -> Optional[bytes]:
            url = f"https://coverartarchive.org/release/{release_id}/front"
            try:
                response = requests.get(url, verify=False, timeout=10)
                if response.status_code == 200 and response.headers['Content-Type'].startswith('image'):
                    logging.debug(f"Cover gefunden für Release ID {release_id}")
                    return response.content
            except Exception as e:
                logging.error(f"Fehler beim Abrufen des Covers von Cover Art Archive: {e}")
            return None
    
        def fetch_lyrics(self, title: str, artist: str, url: Optional[str] = None) -> Optional[str]:
            """Extrahiere Lyrics entweder von einer gegebenen URL oder durch Suche."""
            try:
                if not url:
                    # Suche nach der Lyrics-Seite
                    search_query = f"{artist} {title} lyrics"
                    search_url = f"https://www.azlyrics.com/lyrics/{artist.replace(' ', '').lower()}/{title.replace(' ', '').lower()}.html"
                else:
                    search_url = url
    
                response = requests.get(search_url, timeout=10)
                soup = BeautifulSoup(response.text, 'html.parser')
                # Lyrics befinden sich in einem div ohne Klassenname, zwischen Kommentaren
                lyrics_div = soup.find('div', attrs={'class': None, 'id': None})
                if lyrics_div:
                    lyrics = lyrics_div.get_text(separator='\n').strip()
                    return lyrics
            except Exception as e:
                logging.error(f"Fehler beim Abrufen der Lyrics: {e}")
            return None
    
    
    class MetadataFetcherTask(QRunnable):
        def __init__(self, fetcher: MetadataFetcher):
            super().__init__()
            self.fetcher = fetcher
    
        def run(self):
            self.fetcher.run()
    
    
    class SaveWorker(QObject):
        """Arbeiterklasse für den Speichervorgang."""
        progress = pyqtSignal(int)
        finished = pyqtSignal()
    
        def __init__(self, tracks_to_save: dict, app_reference):
            super().__init__()
            self.tracks_to_save = tracks_to_save
            self.app_reference = app_reference
    
        def run(self):
            total = len(self.tracks_to_save)
            for i, index in enumerate(self.tracks_to_save):
                self.tracks_to_save[index]['save_function']()
                progress = int((i + 1) / total * 100)
                self.progress.emit(progress)
            self.finished.emit()
    
    
    class QTextEditLogger(logging.Handler):
        """Logging Handler, der Logs in ein QTextEdit schreibt."""
    
        def __init__(self, text_edit):
            super().__init__()
            self.widget = text_edit
    
        def emit(self, record):
            msg = self.format(record)
            # Sicherstellen, dass das Hinzufügen von Text im Hauptthread erfolgt
            if threading.current_thread() is threading.main_thread():
                self.widget.append(msg)
                self.widget.moveCursor(QTextCursor.End)
            else:
                QMetaObject.invokeMethod(
                    self.widget,
                    "append",
                    Qt.QueuedConnection,
                    Q_ARG(str, msg)
                )
                QMetaObject.invokeMethod(
                    self.widget,
                    "moveCursor",
                    Qt.QueuedConnection,
                    Q_ARG(QTextCursor.MoveOperation, QTextCursor.End)
                )
    
    
    class TimestampsDialog(QDialog):
        """Dialog zur manuellen Eingabe von Zeitstempeln."""
    
        def __init__(self, parent=None):
            super().__init__(parent)
            self.parent_app = parent
            self.setWindowTitle("Zeitstempel eingeben")
            self.setMinimumSize(400, 300)
            self.layout = QVBoxLayout()
            self.text_edit = QTextEdit()
            self.text_edit.setPlaceholderText(
                "Geben Sie hier die Zeitstempel und Titel ein.\nZum Beispiel:\n00:00 Titel 1\n03:45 Titel 2\n..."
            )
            self.layout.addWidget(self.text_edit)
            button_layout = QHBoxLayout()
            ok_button = QPushButton("OK")
            ok_button.clicked.connect(self.accept)
            ok_button.setCursor(Qt.PointingHandCursor)
            cancel_button = QPushButton("Abbrechen")
            cancel_button.clicked.connect(self.reject)
            cancel_button.setCursor(Qt.PointingHandCursor)
            button_layout.addStretch()
            button_layout.addWidget(ok_button)
            button_layout.addWidget(cancel_button)
            self.layout.addLayout(button_layout)
            self.setLayout(self.layout)
    
        def get_timestamps(self):
            timestamps = []
            raw_text = self.text_edit.toPlainText()
            for line in raw_text.split('\n'):
                parts = line.strip().split(None, 1)
                if len(parts) == 2:
                    time_str, title = parts
                    total_seconds = self.convert_time_to_seconds(time_str)
                    if total_seconds is not None:
                        timestamps.append((total_seconds, title))
            return sorted(timestamps, key=lambda x: x[0])
    
        def convert_time_to_seconds(self, time_str: str) -> Optional[int]:
            try:
                if ':' in time_str:
                    parts = [int(p) for p in time_str.split(':')]
                    if len(parts) == 3:
                        hours, minutes, seconds = parts
                    elif len(parts) == 2:
                        hours = 0
                        minutes, seconds = parts
                    else:
                        return None
                    return hours * 3600 + minutes * 60 + seconds
                elif '.' in time_str:
                    parts = [int(p) for p in time_str.split('.')]
                    if len(parts) == 3:
                        hours, minutes, seconds = parts
                    elif len(parts) == 2:
                        hours = 0
                        minutes, seconds = parts
                    else:
                        return None
                    return hours * 3600 + minutes * 60 + seconds
                else:
                    return int(time_str)
            except ValueError:
                return None
    
    
    class SettingsDialog(QDialog):
        """Dialog zur Anzeige und Änderung der Anwendungseinstellungen."""
    
        def __init__(self, parent=None, settings=None):
            super().__init__(parent)
            self.setWindowTitle("Einstellungen")
            self.setMinimumSize(400, 300)
            self.settings = settings or {}
            self.layout = QVBoxLayout()
    
            form_layout = QFormLayout()
    
            self.min_silence_len_spinbox = QSpinBox()
            self.min_silence_len_spinbox.setRange(500, 10000)
            self.min_silence_len_spinbox.setValue(self.settings.get('min_silence_len', 2000))
            self.min_silence_len_spinbox.setToolTip(
                "Minimale Länge der Stille (in Millisekunden), um als Trennung zwischen Tracks zu gelten."
            )
            form_layout.addRow("Minimale Stillelänge (ms):", self.min_silence_len_spinbox)
    
            self.silence_thresh_spinbox = QSpinBox()
            self.silence_thresh_spinbox.setRange(-60, 0)
            self.silence_thresh_spinbox.setValue(self.settings.get('silence_thresh_adjust', -16))
            self.silence_thresh_spinbox.setToolTip(
                "Schwellenwert (in dBFS), unterhalb dessen Audio als Stille betrachtet wird."
            )
            form_layout.addRow("Stille-Schwellenwert (dBFS):", self.silence_thresh_spinbox)
    
            self.keep_silence_spinbox = QSpinBox()
            self.keep_silence_spinbox.setRange(0, 5000)
            self.keep_silence_spinbox.setValue(self.settings.get('keep_silence', 500))
            self.keep_silence_spinbox.setToolTip(
                "Länge der Stille (in Millisekunden), die am Anfang und Ende jedes Segments beibehalten wird."
            )
            form_layout.addRow("Stille beibehalten (ms):", self.keep_silence_spinbox)
    
            self.min_segment_length_spinbox = QSpinBox()
            self.min_segment_length_spinbox.setRange(5000, 300000)
            self.min_segment_length_spinbox.setValue(self.settings.get('min_segment_length', 10000))
            self.min_segment_length_spinbox.setToolTip(
                "Minimale Länge eines Segments (in Millisekunden), um als gültiger Track betrachtet zu werden."
            )
            form_layout.addRow("Minimale Segmentlänge (ms):", self.min_segment_length_spinbox)
    
            self.default_save_checkbox = QCheckBox()
            default_save = self.settings.get('default_save_all', True)
            self.default_save_checkbox.setChecked(default_save)
            self.default_save_checkbox.setToolTip("Legt fest, ob alle Tracks standardmäßig zum Speichern ausgewählt sind.")
            form_layout.addRow("Alle Tracks standardmäßig auswählen:", self.default_save_checkbox)
    
            # Themenauswahl
            self.theme_combo = QComboBox()
            self.theme_combo.addItems(["Dunkel", "Hell", "System"])
            current_theme = self.settings.get('theme', 'Dunkel')
            index = self.theme_combo.findText(current_theme)
            if index != -1:
                self.theme_combo.setCurrentIndex(index)
            self.theme_combo.setToolTip("Wählen Sie das Farbschema der Anwendung.")
            form_layout.addRow("Thema:", self.theme_combo)
    
            self.layout.addLayout(form_layout)
    
            # Animation für Buttons
            button_layout = QHBoxLayout()
            apply_button = QPushButton("Übernehmen")
            apply_button.clicked.connect(self.accept)
            apply_button.setCursor(Qt.PointingHandCursor)
            cancel_button = QPushButton("Abbrechen")
            cancel_button.clicked.connect(self.reject)
            cancel_button.setCursor(Qt.PointingHandCursor)
            button_layout.addStretch()
            button_layout.addWidget(apply_button)
            button_layout.addWidget(cancel_button)
            self.layout.addLayout(button_layout)
            self.setLayout(self.layout)
    
        def get_settings(self):
            return {
                'min_silence_len': self.min_silence_len_spinbox.value(),
                'silence_thresh_adjust': self.silence_thresh_spinbox.value(),
                'keep_silence': self.keep_silence_spinbox.value(),
                'min_segment_length': self.min_segment_length_spinbox.value(),
                'default_save_all': self.default_save_checkbox.isChecked(),
                'theme': self.theme_combo.currentText()
            }
    
    
    class WaveformWidget(QWidget):
        """Widget zur Darstellung der Audio-Wellenform."""
    
        def __init__(self, audio_segment: Optional[AudioSegment] = None, parent=None):
            super().__init__(parent)
            self.audio_segment = audio_segment
            self.setMinimumHeight(100)
            self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
            self.waveform = []
            if self.audio_segment:
                self.process_waveform()
    
        def set_audio(self, audio_segment: AudioSegment):
            self.audio_segment = audio_segment
            self.process_waveform()
            self.update()
    
        def process_waveform(self):
            """Verarbeitet das AudioSegment, um die Wellenformdaten zu generieren."""
            samples = self.audio_segment.get_array_of_samples()
            sample_count = len(samples)
            width = self.width()
            if width == 0:
                width = 800  # Fallback width
            step = max(1, sample_count // width)
            self.waveform = [max(samples[i:i + step]) for i in range(0, sample_count, step)]
    
        def resizeEvent(self, event):
            super().resizeEvent(event)
            if self.audio_segment:
                self.process_waveform()
    
        def paintEvent(self, event):
            super().paintEvent(event)
            if not self.waveform:
                return
            painter = QPainter(self)
            painter.fillRect(self.rect(), QColor(30, 30, 30))
    
            pen = QPen(QColor(0, 122, 204))
            pen.setWidth(1)
            painter.setPen(pen)
    
            mid_y = self.height() / 2
            scale = self.height() / (max(self.waveform) if self.waveform else 1)
    
            for x, sample in enumerate(self.waveform):
                y = sample * scale
                painter.drawLine(x, mid_y - y / 2, x, mid_y + y / 2)
    
    
    class AnimatedButton(QPushButton):
        """QPushButton mit Hover- und Klick-Animationen."""
    
        def __init__(self, text="", icon=None, parent=None):
            super().__init__(text, parent)
            if icon:
                self.setIcon(icon)
            self.setCursor(Qt.PointingHandCursor)
            self.setFlat(False)
            self.setStyleSheet("background-color: #2196F3; color: white; font-size: 14px; padding: 10px; border-radius: 5px;")
            self.shadow = QGraphicsDropShadowEffect(self)
            self.shadow.setBlurRadius(10)
            self.shadow.setColor(QColor(0, 0, 0, 160))
            self.shadow.setOffset(0, 3)
            self.setGraphicsEffect(self.shadow)
    
            self.anim = QPropertyAnimation(self, b"geometry")
            self.anim.setDuration(200)
    
        def enterEvent(self, event):
            """Starten der Hover-Animation."""
            geom = self.geometry()
            self.anim.stop()
            self.anim.setStartValue(geom)
            self.anim.setEndValue(QRectF(geom.x(), geom.y(), geom.width() * 1.05, geom.height() * 1.05).toRect())
            self.anim.start()
            super().enterEvent(event)
    
        def leaveEvent(self, event):
            """Rücksetzen der Hover-Animation."""
            geom = self.geometry()
            self.anim.stop()
            self.anim.setStartValue(geom)
            self.anim.setEndValue(QRectF(geom.x(), geom.y(), geom.width() / 1.05, geom.height() / 1.05).toRect())
            self.anim.start()
            super().leaveEvent(event)
    
        def mousePressEvent(self, event):
            """Starten der Klick-Animation."""
            geom = self.geometry()
            self.anim.stop()
            self.anim.setStartValue(geom)
            self.anim.setEndValue(QRectF(geom.x(), geom.y(), geom.width() * 0.95, geom.height() * 0.95).toRect())
            self.anim.start()
            super().mousePressEvent(event)
    
        def mouseReleaseEvent(self, event):
            """Zurücksetzen nach dem Klick."""
            geom = self.geometry()
            self.anim.stop()
            self.anim.setStartValue(geom)
            self.anim.setEndValue(QRectF(geom.x(), geom.y(), geom.width() / 0.95, geom.height() / 0.95).toRect())
            self.anim.start()
            super().mouseReleaseEvent(event)
    
    
    class MusicIdentifierApp(QMainWindow):
        """Hauptanwendungsklasse für den Musik-Identifikator."""
    
        def __init__(self):
            super().__init__()
            self.setWindowTitle("Music Identifier")
            self.resize(1400, 800)  # Erweiterte Größe für bessere Übersicht
            self.setWindowIcon(QIcon.fromTheme("audio-x-generic") if not QIcon.fromTheme("audio-x-generic").isNull() else QIcon("icon.png"))
    
            logging.basicConfig(
                level=logging.INFO,
                format='%(asctime)s - %(levelname)s - %(message)s',
                handlers=[
                    logging.FileHandler("application.log", encoding='utf-8'),
                    logging.StreamHandler(sys.stdout)
                ]
            )
    
            self.config = configparser.ConfigParser()
            self.load_settings()
    
            # Ausgabeordner
            self.output_dir = self.config.get('SETTINGS', 'output_dir', fallback=os.getcwd())
    
            self.cache = {}  # Cache für Metadaten
    
            self.init_ui()
    
            self.segments = []
            self.segments_info = []
            self.total_segments = 0
            self.fetchers = {}
            self.thread_pool = QThreadPool()
            self.players = {}  # Dictionary zur Speicherung von MediaPlayer-Instanzen
            self.is_processing = False  # Flag zur Indikation laufender Prozesse
    
            self.disable_ssl_warnings()
    
        def init_ui(self):
            """Initialisiert die Benutzeroberfläche."""
            self.apply_theme()
    
            central_widget = QWidget()
            main_layout = QVBoxLayout(central_widget)
            main_layout.setSpacing(10)
            main_layout.setContentsMargins(10, 10, 10, 10)
    
            # Menüleiste
            self.create_menubar()
            main_layout.addWidget(self.menuBar())
    
            # Waveform-Visualisierung
            self.waveform_widget = WaveformWidget(parent=self)
            main_layout.addWidget(self.waveform_widget)
    
            # Eingabe-Layout
            input_group = self.create_input_group()
            main_layout.addWidget(input_group)
    
            # Start-Button mit Animation
            self.start_btn = AnimatedButton("Start", QIcon.fromTheme("media-playback-start") if not QIcon.fromTheme("media-playback-start").isNull() else QIcon("play.png"))
            self.start_btn.clicked.connect(self.handle_start)
            self.start_btn.setToolTip("Starten Sie die Verarbeitung des eingegebenen Links oder der ausgewählten Datei.")
            self.start_btn.setFixedHeight(50)
            main_layout.addWidget(self.start_btn)
    
            # Segmentierungsoptionen
            segmentation_options_layout = QHBoxLayout()
            self.manual_timestamps_btn = AnimatedButton("Manuelle Zeitstempel eingeben", QIcon.fromTheme("edit") if not QIcon.fromTheme("edit").isNull() else QIcon("edit.png"))
            self.manual_timestamps_btn.clicked.connect(self.open_timestamps_dialog)
            self.manual_timestamps_btn.setToolTip("Öffnen Sie einen Dialog, um manuell Zeitstempel und Titel einzugeben.")
            segmentation_options_layout.addWidget(self.manual_timestamps_btn)
            segmentation_options_layout.addStretch()
    
            main_layout.addLayout(segmentation_options_layout)
    
            # Fortschrittsanzeigen
            progress_group = self.create_progress_group()
            main_layout.addWidget(progress_group)
    
            # Informationen
            info_group = self.create_info_group()
            main_layout.addWidget(info_group)
    
            # Musiktabelle
            table_group = self.create_table_group()
            main_layout.addWidget(table_group)
    
            # Speichern-Button und Fortschrittsbalken
            save_layout = QHBoxLayout()
            self.save_all_btn = AnimatedButton("Ausgewählte Tracks speichern", QIcon.fromTheme("document-save") if not QIcon.fromTheme("document-save").isNull() else QIcon("save.png"))
            self.save_all_btn.clicked.connect(self.save_selected_tracks)
            self.save_all_btn.setToolTip("Speichern Sie alle ausgewählten Tracks im Ausgabeordner.")
            save_layout.addWidget(self.save_all_btn)
    
            self.save_progress_bar = QProgressBar()
            self.save_progress_bar.setValue(0)
            self.save_progress_bar.setFormat("Speichern: %p%")
            self.save_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #4CAF50;
                    width: 20px;
                }
            """)
            self.save_progress_bar.hide()
            save_layout.addWidget(self.save_progress_bar)
            save_layout.addStretch()
            main_layout.addLayout(save_layout)
    
            # Konsolenansicht für Logs mit modernem Look
            log_group = self.create_log_group()
            main_layout.addWidget(log_group)
    
            # Ausgabeordner
            output_group = self.create_output_group()
            main_layout.addWidget(output_group)
    
            self.setCentralWidget(central_widget)
    
            # Statusleiste
            self.status_bar = QStatusBar()
            self.setStatusBar(self.status_bar)
    
            # Timer für verstrichene Zeit
            self.timer = QTimer(self)
            self.timer.timeout.connect(self.update_elapsed_time)
            self.start_time = None
    
        def create_menubar(self):
            """Erstellt die Menüleiste."""
            menubar = self.menuBar()
    
            # Datei-Menü
            file_menu = menubar.addMenu('Datei')
    
            open_file_action = QAction('Datei öffnen', self)
            open_file_action.setShortcut('Ctrl+O')
            open_file_action.triggered.connect(self.open_file_dialog)
            file_menu.addAction(open_file_action)
    
            save_all_action = QAction('Alle speichern', self)
            save_all_action.setShortcut('Ctrl+S')
            save_all_action.triggered.connect(self.save_selected_tracks)
            file_menu.addAction(save_all_action)
    
            file_menu.addSeparator()
    
            exit_action = QAction('Beenden', self)
            exit_action.setShortcut('Ctrl+Q')
            exit_action.triggered.connect(self.close)
            file_menu.addAction(exit_action)
    
            # Einstellungen-Menü
            settings_menu = menubar.addMenu('Einstellungen')
    
            preferences_action = QAction('Einstellungen', self)
            preferences_action.setShortcut('Ctrl+,')
            preferences_action.triggered.connect(self.open_settings_dialog)
            settings_menu.addAction(preferences_action)
    
            # Hilfe-Menü
            help_menu = menubar.addMenu('Hilfe')
    
            about_action = QAction('Über', self)
            about_action.triggered.connect(self.show_about_dialog)
            help_menu.addAction(about_action)
    
        def create_input_group(self):
            """Erstellt das Eingabe-Layout für die Audioquelle."""
            input_group = QGroupBox("Audioquelle")
            layout = QHBoxLayout()
            layout.setSpacing(10)
    
            self.url_input = QLineEdit()
            self.url_input.setPlaceholderText("Geben Sie eine URL ein oder wählen Sie eine lokale Datei aus")
            self.url_input.setToolTip("Geben Sie eine URL (z.B. YouTube-Link) oder den Pfad zu einer lokalen Datei ein.")
            self.url_input.setStyleSheet("font-size: 14px; padding: 10px;")
            self.url_input.setMinimumHeight(40)
            self.url_input.setAcceptDrops(True)
            self.url_input.installEventFilter(self)
    
            self.select_file_btn = AnimatedButton("Datei auswählen", QIcon.fromTheme("folder-open") if not QIcon.fromTheme("folder-open").isNull() else QIcon("folder.png"))
            self.select_file_btn.clicked.connect(self.open_file_dialog)
            self.select_file_btn.setToolTip("Öffnen Sie einen Dialog, um eine lokale Audio-/Videodatei auszuwählen.")
            self.select_file_btn.setMinimumHeight(40)
    
            layout.addWidget(self.url_input)
            layout.addWidget(self.select_file_btn)
            input_group.setLayout(layout)
            return input_group
    
        def create_progress_group(self):
            """Erstellt die Fortschrittsanzeigen."""
            progress_group = QGroupBox("Fortschritt")
            progress_layout = QVBoxLayout()
            progress_layout.setSpacing(10)
    
            self.current_action_label = QLabel("Bereit")
            self.current_action_label.setStyleSheet("font-size: 14px; padding: 5px; font-weight: bold;")
    
            self.overall_progress_bar = QProgressBar()
            self.overall_progress_bar.setValue(0)
            self.overall_progress_bar.setFormat("Gesamtfortschritt: %p%")
            self.overall_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #05B8CC;
                    width: 20px;
                }
            """)
    
            self.download_progress_bar = QProgressBar()
            self.download_progress_bar.setValue(0)
            self.download_progress_bar.setFormat("Download: %p%")
            self.download_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #FFA726;
                    width: 20px;
                }
            """)
            self.download_progress_bar.hide()
    
            self.extraction_progress_bar = QProgressBar()
            self.extraction_progress_bar.setValue(0)
            self.extraction_progress_bar.setFormat("Extraktion: %p%")
            self.extraction_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #66BB6A;
                    width: 20px;
                }
            """)
            self.extraction_progress_bar.hide()
    
            self.segmentation_progress_bar = QProgressBar()
            self.segmentation_progress_bar.setValue(0)
            self.segmentation_progress_bar.setFormat("Segmentierung: %p%")
            self.segmentation_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #AB47BC;
                    width: 20px;
                }
            """)
            self.segmentation_progress_bar.hide()
    
            self.metadata_progress_bar = QProgressBar()
            self.metadata_progress_bar.setValue(0)
            self.metadata_progress_bar.setFormat("Metadaten: %p%")
            self.metadata_progress_bar.setStyleSheet("""
                QProgressBar {
                    border: 2px solid grey;
                    border-radius: 5px;
                    text-align: center;
                }
                QProgressBar::chunk {
                    background-color: #FF7043;
                    width: 20px;
                }
            """)
            self.metadata_progress_bar.hide()
    
            progress_layout.addWidget(self.current_action_label)
            progress_layout.addWidget(self.overall_progress_bar)
            progress_layout.addWidget(self.download_progress_bar)
            progress_layout.addWidget(self.extraction_progress_bar)
            progress_layout.addWidget(self.segmentation_progress_bar)
            progress_layout.addWidget(self.metadata_progress_bar)
            progress_group.setLayout(progress_layout)
            return progress_group
    
        def create_info_group(self):
            """Erstellt das Informations-Layout."""
            info_group = QGroupBox("Informationen")
            info_layout = QHBoxLayout()
            info_layout.setSpacing(20)
    
            self.elapsed_time_label = QLabel("Verstrichene Zeit: 0s")
            self.elapsed_time_label.setStyleSheet("font-size: 14px;")
    
            self.segment_count_label = QLabel("Verarbeitete Segmente: 0")
            self.segment_count_label.setStyleSheet("font-size: 14px;")
    
            info_layout.addWidget(self.elapsed_time_label)
            info_layout.addWidget(self.segment_count_label)
            info_group.setLayout(info_layout)
            return info_group
    
        def create_table_group(self):
            """Erstellt die Musiktabelle."""
            table_group = QGroupBox("Erkannte Musikstücke")
            table_layout = QVBoxLayout()
    
            self.music_table = QTableWidget()
            self.music_table.setMinimumHeight(300)
            self.music_table.setStyleSheet("font-size: 14px;")
            self.music_table.setColumnCount(8)
            self.music_table.setHorizontalHeaderLabels(['Album', 'Künstler', 'Titel', 'Cover', 'Wiedergabe', 'Lautstärke', 'Speichern', ''])
            self.music_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
            self.music_table.verticalHeader().setVisible(False)
            self.music_table.setSelectionBehavior(QTableWidget.SelectRows)
            self.music_table.setEditTriggers(QTableWidget.NoEditTriggers)
            self.music_table.setAlternatingRowColors(True)
            self.music_table.setStyleSheet("""
                QTableWidget {
                    border: 1px solid gray;
                }
                QTableWidget::item:selected {
                    background-color: #90CAF9;
                }
            """)
    
            table_layout.addWidget(self.music_table)
            table_group.setLayout(table_layout)
            return table_group
    
        def create_log_group(self):
            """Erstellt die Log-Konsolenansicht."""
            log_group = QGroupBox("Protokoll")
            log_layout = QVBoxLayout()
    
            self.log_console = QTextEdit()
            self.log_console.setReadOnly(True)
            self.log_console.setStyleSheet("""
                QTextEdit {
                    background-color: #1E1E1E;
                    color: #D4D4D4;
                    font-family: Consolas, monospace;
                    font-size: 12px;
                }
            """)
            self.log_console.setMinimumHeight(150)
    
            log_handler = QTextEditLogger(self.log_console)
            log_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
            logging.getLogger().addHandler(log_handler)
    
            log_layout.addWidget(self.log_console)
            log_group.setLayout(log_layout)
            return log_group
    
        def create_output_group(self):
            """Erstellt das Ausgabeordner-Layout."""
            output_group = QGroupBox("Ausgabe")
            output_layout = QHBoxLayout()
    
            self.output_dir_label = QLabel(f"Ausgabeordner: {self.output_dir}")
            self.output_dir_label.setStyleSheet("font-size: 14px;")
    
            self.output_dir_btn = AnimatedButton("Ausgabeordner wählen", QIcon.fromTheme("folder") if not QIcon.fromTheme("folder").isNull() else QIcon("folder.png"))
            self.output_dir_btn.clicked.connect(self.choose_output_directory)
            self.output_dir_btn.setToolTip("Wählen Sie den Ordner aus, in dem die verarbeiteten Tracks gespeichert werden sollen.")
    
            output_layout.addWidget(self.output_dir_label)
            output_layout.addWidget(self.output_dir_btn)
            output_layout.addStretch()
            output_group.setLayout(output_layout)
            return output_group
    
        def disable_ssl_warnings(self):
            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
    
        def open_file_dialog(self):
            file_path, _ = QFileDialog.getOpenFileName(self, "Audio-/Videodatei auswählen", "", "Audio/Videos (*.mp3 *.wav *.ogg *.flac *.mp4 *.mkv);;Alle Dateien (*)")
            if file_path:
                self.url_input.setText(file_path)
                logging.info(f"Ausgewählte Datei: {file_path}")
                self.status_bar.showMessage(f"Ausgewählte Datei: {file_path}")
                # Aktualisiere die Waveform
                self.waveform_widget.set_audio(AudioSegment.from_file(file_path))
    
        def open_settings_dialog(self):
            """Öffnet den Einstellungsdialog."""
            dialog = SettingsDialog(self, self.settings)
            if dialog.exec_():
                new_settings = dialog.get_settings()
                theme_changed = new_settings.get('theme') != self.settings.get('theme')
                self.settings.update(new_settings)
                self.save_settings()
                logging.info("Einstellungen aktualisiert.")
                if theme_changed:
                    self.apply_theme()
                    logging.info("Thema geändert.")
                self.status_bar.showMessage("Einstellungen aktualisiert.")
    
        def show_about_dialog(self):
            """Zeigt den 'Über'-Dialog an."""
            QMessageBox.about(
                self,
                "Über Music Identifier",
                "<h2>Music Identifier</h2>"
                "<p>Version 1.0</p>"
                "<p>Entwickelt von Ihrem Namen</p>"
                "<p>Dieses Tool identifiziert und segmentiert Musikstücke aus Audioquellen.</p>"
                "<p>© 2023 Ihr Unternehmen</p>"
            )
    
        def handle_start(self):
            """Startet den Verarbeitungsprozess."""
            if self.is_processing:
                QMessageBox.warning(self, "Verarbeitung läuft", "Es läuft bereits ein Verarbeitungsprozess.")
                return
    
            url_or_path = self.url_input.text().strip()
            if not url_or_path:
                logging.warning("Keine URL oder Datei eingegeben.")
                self.current_action_label.setText("Fehler: Keine URL oder Datei eingegeben.")
                self.status_bar.showMessage("Fehler: Keine URL oder Datei eingegeben.")
                return
    
            self.is_processing = True
            self.disable_ui_elements()
            self.music_table.setRowCount(0)
            self.log_console.clear()
            self.current_action_label.setText("Start...")
            self.status_bar.showMessage("Start der Verarbeitung.")
            self.start_time = datetime.now()
            self.timer.start(1000)
    
            # Fortschrittsanzeigen zurücksetzen
            self.reset_progress_bars()
            self.download_progress_bar.show()
            self.extraction_progress_bar.show()
            self.segmentation_progress_bar.show()
            self.metadata_progress_bar.show()
    
            self.worker = Worker(url_or_path, self.settings)
            self.worker_thread = QThread()
            self.worker.moveToThread(self.worker_thread)
            self.worker_thread.started.connect(self.worker.run)
            self.worker.finished.connect(self.worker_thread.quit)
            self.worker.finished.connect(self.worker.deleteLater)
            self.worker_thread.finished.connect(self.worker_thread.deleteLater)
            self.worker.progress.connect(self.update_overall_progress)
            self.worker.download_progress.connect(self.update_download_progress)
            self.worker.extraction_progress.connect(self.update_extraction_progress)
            self.worker.segmentation_progress.connect(self.update_segmentation_progress)
            self.worker.overall_progress.connect(self.update_overall_progress_bar)
            self.worker.error.connect(self.display_error)
            self.worker.segments_ready.connect(self.handle_segments_ready)
            self.worker.finished.connect(self.on_worker_finished)
            self.worker_thread.start()
    
        def disable_ui_elements(self):
            """Deaktiviert UI-Elemente während der Verarbeitung."""
            self.start_btn.setEnabled(False)
            self.url_input.setEnabled(False)
            self.select_file_btn.setEnabled(False)
            self.output_dir_btn.setEnabled(False)
            self.manual_timestamps_btn.setEnabled(False)
    
        def enable_ui_elements(self):
            """Aktiviert UI-Elemente nach der Verarbeitung."""
            self.start_btn.setEnabled(True)
            self.url_input.setEnabled(True)
            self.select_file_btn.setEnabled(True)
            self.output_dir_btn.setEnabled(True)
            self.manual_timestamps_btn.setEnabled(True)
    
        def update_overall_progress(self, value: int, message: str):
            """Aktualisiert die Statusnachricht."""
            self.current_action_label.setText(message)
            self.overall_progress_bar.setValue(value)
            self.status_bar.showMessage(message)
            QApplication.processEvents()
    
        def update_overall_progress_bar(self, value: int):
            """Aktualisiert die Gesamtfortschrittsleiste."""
            self.overall_progress_bar.setValue(value)
            QApplication.processEvents()
    
        def update_download_progress(self, value: int):
            """Aktualisiert den Download-Fortschrittsbalken."""
            self.download_progress_bar.setValue(value)
            QApplication.processEvents()
    
        def update_extraction_progress(self, value: int):
            """Aktualisiert den Extraktions-Fortschrittsbalken."""
            self.extraction_progress_bar.setValue(value)
            QApplication.processEvents()
    
        def update_segmentation_progress(self, value: int):
            """Aktualisiert den Segmentierungs-Fortschrittsbalken."""
            self.segmentation_progress_bar.setValue(value)
            QApplication.processEvents()
    
        def display_error(self, message: str):
            """Zeigt eine Fehlermeldung an."""
            logging.error(message)
            QMessageBox.critical(self, "Fehler", message)
            self.current_action_label.setText("Fehler aufgetreten.")
            self.status_bar.showMessage("Fehler aufgetreten.")
            self.timer.stop()
            self.is_processing = False
            self.enable_ui_elements()
            self.reset_progress_bars()
    
        def handle_segments_ready(self, segments_info: List[dict], segments: List[AudioSegment]):
            """Verarbeitet die bereitgestellten Segmente."""
            self.segments_info = segments_info
            self.segments = segments
            self.total_segments = len(segments)
            self.populate_music_table(segments_info)
            self.timer.stop()
            self.overall_progress_bar.setValue(100)
            self.current_action_label.setText("Alle Segmente verarbeitet.")
            self.status_bar.showMessage("Alle Segmente verarbeitet.")
            logging.info("Segmente bereit zur Anzeige.")
    
        def populate_music_table(self, segments_info: List[dict]):
            """Füllt die Musiktabelle mit den Segmentinformationen."""
            self.music_table.setRowCount(len(segments_info))
            self.fetchers = {}
            self.players = {}
            self.metadata_progress_bar.setValue(0)
            default_save_all = self.settings.get('default_save_all', True)
            total_segments = len(segments_info)
    
            for index, info in enumerate(segments_info):
                self.add_music_table_row(index, info, default_save_all)
                self.create_media_player(index)
                self.start_metadata_fetcher(index, info.get('title', f'Track {index + 1}'), total_segments)
    
            self.current_action_label.setText("Metadaten werden abgerufen.")
            self.status_bar.showMessage("Metadaten werden abgerufen.")
    
        def add_music_table_row(self, index: int, info: dict, default_save: bool):
            """Fügt eine einzelne Zeile zur Musiktabelle hinzu."""
            album = info.get('album', '')
            artist = info.get('artist', '')
            title = info.get('title', 'Unbekannt')
    
            album_item = QTableWidgetItem(album)
            album_item.setFlags(album_item.flags() | Qt.ItemIsEditable)
            artist_item = QTableWidgetItem(artist)
            artist_item.setFlags(artist_item.flags() | Qt.ItemIsEditable)
            title_item = QTableWidgetItem(title)
            title_item.setFlags(title_item.flags() | Qt.ItemIsEditable)
    
            cover_label = QLabel()
            cover_label.setAlignment(Qt.AlignCenter)
            cover_label.setFixedSize(80, 80)
            cover_label.setStyleSheet("margin: 5px;")
            default_pixmap = QPixmap("default_cover.png") if os.path.exists("default_cover.png") else QPixmap()
            if default_pixmap and not default_pixmap.isNull():
                default_pixmap = default_pixmap.scaled(80, 80, Qt.KeepAspectRatio, Qt.SmoothTransformation)
                cover_label.setPixmap(default_pixmap)
    
            # Wiedergabesteuerung
            play_button = QPushButton()
            play_icon = QIcon.fromTheme("media-playback-start") if not QIcon.fromTheme("media-playback-start").isNull() else QIcon("play.png")
            play_button.setIcon(play_icon)
            play_button.setIconSize(QSize(24, 24))
            play_button.clicked.connect(partial(self.play_pause_audio, index))
            play_button.setEnabled(False)  # Enable after metadata is fetched
    
            # Lautstärkeregler
            volume_slider = QSlider(Qt.Horizontal)
            volume_slider.setRange(0, 100)
            volume_slider.setValue(50)
            volume_slider.setFixedWidth(100)
            volume_slider.setEnabled(False)  # Enable after playback is ready
            volume_slider.valueChanged.connect(partial(self.change_volume, index))
    
            # Speichern
            save_checkbox = QCheckBox()
            save_checkbox.setChecked(default_save)
            save_button = QPushButton("Speichern")
            save_button.clicked.connect(partial(self.save_track, index))
            save_button.setEnabled(True)
            save_button.setStyleSheet("""
                QPushButton {
                    background-color: #F44336;
                    color: white;
                    font-size: 12px;
                    padding: 5px;
                    border-radius: 5px;
                }
                QPushButton:hover {
                    background-color: #D32F2F;
                }
                QPushButton:pressed {
                    background-color: #C62828;
                }
            """)
    
            self.music_table.setItem(index, 0, album_item)
            self.music_table.setItem(index, 1, artist_item)
            self.music_table.setItem(index, 2, title_item)
            self.music_table.setCellWidget(index, 3, cover_label)
    
            # Wiedergabe-Widgets
            playback_layout = QHBoxLayout()
            playback_layout.setContentsMargins(0, 0, 0, 0)
            playback_layout.setSpacing(5)
            playback_layout.addWidget(play_button)
            playback_layout.addWidget(volume_slider)
            playback_widget = QWidget()
            playback_widget.setLayout(playback_layout)
            self.music_table.setCellWidget(index, 4, playback_widget)
    
            self.music_table.setCellWidget(index, 5, volume_slider)
            self.music_table.setCellWidget(index, 6, save_checkbox)
            self.music_table.setCellWidget(index, 7, save_button)
    
        def create_media_player(self, index: int):
            """Erstellt einen MediaPlayer für den angegebenen Index."""
            player = QMediaPlayer()
            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
            self.segments[index].export(temp_file.name, format="mp3", bitrate="320k")
            url = QUrl.fromLocalFile(temp_file.name)
            player.setMedia(QMediaContent(url))
    
            # Aktualisieren des Sliders während der Wiedergabe
            player.positionChanged.connect(partial(self.update_slider_position, index))
            player.durationChanged.connect(partial(self.update_slider_duration, index))
            player.mediaStatusChanged.connect(partial(self.handle_media_status, index))
            player.error.connect(partial(self.handle_player_error, index))
    
            self.players[index] = {
                'player': player,
                'temp_file': temp_file.name,
                'play_button': self.music_table.cellWidget(index, 4).findChild(QPushButton),
                'volume_slider': self.music_table.cellWidget(index, 5)
            }
    
        def handle_player_error(self, index: int, error: QMediaPlayer.Error):
            """Behandelt Fehler des MediaPlayers."""
            if error != QMediaPlayer.NoError:
                error_message = self.players[index]['player'].errorString()
                logging.error(f"Fehler beim Abspielen von Track {index + 1}: {error_message}")
                QMessageBox.critical(self, "Wiedergabefehler", f"Fehler beim Abspielen von Track {index + 1}: {error_message}")
    
        def start_metadata_fetcher(self, index: int, title: str, total_tracks: int):
            """Startet einen Thread zur Metadatenabfrage."""
            fetcher = MetadataFetcher(index, title, total_tracks, self.cache)
            fetcher.result_ready.connect(self.update_metadata)
            fetcher.progress.connect(self.update_metadata_progress)
            task = MetadataFetcherTask(fetcher)
            self.thread_pool.start(task)
            self.fetchers[index] = fetcher
    
        def update_metadata_progress(self, value: int):
            """Aktualisiert den Fortschritt der Metadatenabfrage."""
            self.metadata_progress_bar.setValue(value)
            QApplication.processEvents()
    
        def update_metadata(self, index: int, artist: str, album: str, title: str, cover_data: Optional[bytes]):
            """Aktualisiert die Metadaten in der Tabelle."""
            self.music_table.item(index, 0).setText(album)
            self.music_table.item(index, 1).setText(artist)
            self.music_table.item(index, 2).setText(title)
            cover_label = self.music_table.cellWidget(index, 3)
            if cover_data and cover_label:
                pixmap = QPixmap()
                pixmap.loadFromData(cover_data)
                pixmap = pixmap.scaled(80, 80, Qt.KeepAspectRatio, Qt.SmoothTransformation)
                cover_label.setPixmap(pixmap)
                logging.info(f"Cover aktualisiert für Track {index + 1}")
    
            processed = sum(1 for i in range(self.music_table.rowCount())
                            if self.music_table.item(i, 1).text())
            self.segment_count_label.setText(f"Verarbeitete Segmente: {processed}/{self.total_segments}")
            logging.info(f"Verarbeitete Segmente: {processed}/{self.total_segments}")
    
            if processed == self.total_segments:
                self.current_action_label.setText("Alle Segmente verarbeitet.")
                self.status_bar.showMessage("Alle Segmente verarbeitet.")
                logging.info("Alle Segmente verarbeitet.")
    
            # Enable the play button and volume slider now that metadata is fetched
            playback_widget = self.music_table.cellWidget(index, 4)
            if isinstance(playback_widget, QWidget):
                play_button = playback_widget.findChild(QPushButton)
                if play_button:
                    play_button.setEnabled(True)
            volume_slider = self.music_table.cellWidget(index, 5)
            if isinstance(volume_slider, QSlider):
                volume_slider.setEnabled(True)
    
            if index in self.fetchers:
                del self.fetchers[index]
    
        def save_selected_tracks(self):
            """Speichert die ausgewählten Tracks."""
            tracks_to_save = {}
            for index in range(self.music_table.rowCount()):
                save_item = self.music_table.cellWidget(index, 6)
                if isinstance(save_item, QCheckBox) and save_item.isChecked():
                    tracks_to_save[index] = {
                        'save_function': partial(self.save_segment_as_mp3_wrapper, index)
                    }
            if tracks_to_save:
                self.save_progress_bar.show()
                self.save_progress_bar.setValue(0)
                self.save_worker = SaveWorker(tracks_to_save, self)
                self.save_thread = QThread()
                self.save_worker.moveToThread(self.save_thread)
                self.save_thread.started.connect(self.save_worker.run)
                self.save_worker.progress.connect(self.update_save_progress)
                self.save_worker.finished.connect(self.on_save_finished)
                self.save_worker.finished.connect(self.save_thread.quit)
                self.save_worker.finished.connect(self.save_worker.deleteLater)
                self.save_thread.finished.connect(self.save_thread.deleteLater)
                self.save_thread.start()
                logging.info("Speichervorgang gestartet.")
                self.status_bar.showMessage("Speichervorgang gestartet.")
            else:
                logging.info("Keine Tracks zum Speichern ausgewählt.")
                QMessageBox.information(self, "Keine Auswahl", "Es wurden keine Tracks zum Speichern ausgewählt.")
                self.status_bar.showMessage("Keine Tracks zum Speichern ausgewählt.")
    
        def update_save_progress(self, value: int):
            self.save_progress_bar.setValue(value)
            self.current_action_label.setText(f"Speicherfortschritt: {value}%")
            self.status_bar.showMessage(f"Speicherfortschritt: {value}%")
            QApplication.processEvents()
    
        def on_save_finished(self):
            self.save_progress_bar.hide()
            self.current_action_label.setText("Speichern abgeschlossen.")
            self.status_bar.showMessage("Speichern abgeschlossen.")
            logging.info("Speichern abgeschlossen.")
    
        def save_track(self, index: int):
            """Speichert einen einzelnen Track."""
            self.save_segment_as_mp3_wrapper(index)
            logging.info(f"Segment {index + 1} wurde gespeichert.")
            self.status_bar.showMessage(f"Segment {index + 1} wurde gespeichert.")
    
        def save_segment_as_mp3_wrapper(self, index: int):
            """Wrapper-Method zur Speicherung eines Segments."""
            album = self.music_table.item(index, 0).text()
            artist = self.music_table.item(index, 1).text()
            title = self.music_table.item(index, 2).text()
            cover_label = self.music_table.cellWidget(index, 3)
            cover_data = None
            if cover_label and isinstance(cover_label, QLabel) and cover_label.pixmap():
                pixmap = cover_label.pixmap()
                buffer = QBuffer()
                buffer.open(QIODevice.WriteOnly)
                pixmap.save(buffer, 'JPEG')
                cover_data = buffer.data().data()
            self.save_segment_as_mp3(index, title, artist, album, cover_data)
    
        def save_segment_as_mp3(self, index: int, title: str, artist: str, album: str, cover_data: Optional[bytes]):
            """Speichert ein Audiosegment als MP3-Datei mit Metadaten."""
            try:
                segment = self.segments[index]
                sanitized_title = ''.join(c for c in title if c not in r'<>:"/\|?*').strip()
                sanitized_artist = ''.join(c for c in artist if c not in r'<>:"/\|?*').strip()
                sanitized_album = ''.join(c for c in album if c not in r'<>:"/\|?*').strip()
                if sanitized_artist and sanitized_title:
                    base_filename = f"{sanitized_artist} - {sanitized_title}.mp3"
                else:
                    base_filename = f"Track_{index + 1}.mp3"
                filename = os.path.join(self.output_dir, base_filename)
    
                if os.path.exists(filename):
                    count = 1
                    while True:
                        new_filename = os.path.join(self.output_dir, f"{os.path.splitext(base_filename)[0]} ({count}).mp3")
                        if not os.path.exists(new_filename):
                            filename = new_filename
                            break
                        count += 1
    
                # Exportiere das Audiosegment
                segment.export(filename, format="mp3", bitrate="320k", codec="libmp3lame", parameters=["-q:a", "0"])
    
                # Setze Metadaten
                audiofile = MP3(filename, ID3=ID3)
                try:
                    audiofile.add_tags()
                except error:
                    pass
                audiofile.tags["TIT2"] = TIT2(encoding=3, text=title)
                audiofile.tags["TPE1"] = TPE1(encoding=3, text=artist)
                audiofile.tags["TALB"] = TALB(encoding=3, text=album)
                if cover_data:
                    audiofile.tags["APIC"] = APIC(
                        encoding=3,
                        mime='image/jpeg',
                        type=3,
                        desc='Cover',
                        data=cover_data
                    )
                audiofile.save()
                logging.info(f"Segment {index + 1}: '{title}' wurde als '{filename}' gespeichert.")
                self.status_bar.showMessage(f"Segment {index + 1}: '{title}' wurde gespeichert.")
            except Exception as e:
                logging.error(f"Fehler beim Speichern von Segment {index + 1}: {e}")
                QMessageBox.critical(self, "Speicherfehler", f"Fehler beim Speichern von Segment {index + 1}: {e}")
                self.status_bar.showMessage(f"Fehler beim Speichern von Segment {index + 1}.")
    
        def choose_output_directory(self):
            """Öffnet einen Dialog zur Auswahl des Ausgabeordners."""
            directory = QFileDialog.getExistingDirectory(self, "Ausgabeordner auswählen", self.output_dir)
            if directory:
                self.output_dir = directory
                self.output_dir_label.setText(f"Ausgabeordner: {self.output_dir}")
                self.save_settings()
                logging.info(f"Ausgabeordner geändert zu: {self.output_dir}")
                self.status_bar.showMessage(f"Ausgabeordner geändert zu: {self.output_dir}")
    
        def load_settings(self):
            """Lädt die Anwendungseinstellungen."""
            self.config.read('settings.ini')
            if 'SETTINGS' not in self.config:
                self.config['SETTINGS'] = {}
    
            # Einstellungen für die Segmentierung
            self.settings = {
                'min_silence_len': self.config.getint('SETTINGS', 'min_silence_len', fallback=2000),
                'silence_thresh_adjust': self.config.getint('SETTINGS', 'silence_thresh_adjust', fallback=-16),
                'keep_silence': self.config.getint('SETTINGS', 'keep_silence', fallback=500),
                'min_segment_length': self.config.getint('SETTINGS', 'min_segment_length', fallback=10000),
                'default_save_all': self.config.getboolean('SETTINGS', 'default_save_all', fallback=True),
                'theme': self.config.get('SETTINGS', 'theme', fallback='Dunkel'),
                'output_dir': self.config.get('SETTINGS', 'output_dir', fallback=os.getcwd())
            }
    
        def save_settings(self):
            """Speichert die Anwendungseinstellungen."""
            if 'SETTINGS' not in self.config:
                self.config['SETTINGS'] = {}
            self.config['SETTINGS']['output_dir'] = self.output_dir
            self.config['SETTINGS']['min_silence_len'] = str(self.settings['min_silence_len'])
            self.config['SETTINGS']['silence_thresh_adjust'] = str(self.settings['silence_thresh_adjust'])
            self.config['SETTINGS']['keep_silence'] = str(self.settings['keep_silence'])
            self.config['SETTINGS']['min_segment_length'] = str(self.settings['min_segment_length'])
            self.config['SETTINGS']['default_save_all'] = str(self.settings['default_save_all'])
            self.config['SETTINGS']['theme'] = self.settings['theme']
            with open('settings.ini', 'w', encoding='utf-8') as configfile:
                self.config.write(configfile)
    
        def reset_progress_bars(self):
            """Setzt alle Fortschrittsbalken zurück."""
            self.overall_progress_bar.setValue(0)
            self.download_progress_bar.setValue(0)
            self.extraction_progress_bar.setValue(0)
            self.segmentation_progress_bar.setValue(0)
            self.metadata_progress_bar.setValue(0)
    
        def update_elapsed_time(self):
            """Aktualisiert die Anzeige der verstrichenen Zeit."""
            if self.start_time:
                elapsed_time = (datetime.now() - self.start_time).seconds
                self.elapsed_time_label.setText(f"Verstrichene Zeit: {elapsed_time}s")
    
        def on_worker_finished(self):
            """Wird aufgerufen, wenn der Worker-Thread beendet ist."""
            self.is_processing = False
            self.enable_ui_elements()
            self.update_overall_progress(100, "Verarbeitung abgeschlossen")
            self.status_bar.showMessage("Verarbeitung abgeschlossen.")
            logging.info("Verarbeitung abgeschlossen.")
    
        def open_timestamps_dialog(self):
            """Öffnet den Dialog zur manuellen Eingabe von Zeitstempeln."""
            dialog = TimestampsDialog(self)
            if dialog.exec_():
                manual_timestamps = dialog.get_timestamps()
                if manual_timestamps:
                    self.worker.manual_timestamps = manual_timestamps
                    self.worker.segment_using_timestamps(manual_timestamps)
                    logging.info(f"Manuell eingegebene Zeitstempel: {manual_timestamps}")
                    self.status_bar.showMessage("Manuelle Zeitstempel eingegeben.")
                else:
                    logging.warning("Keine gültigen manuell eingegebenen Zeitstempel.")
                    QMessageBox.warning(self, "Ungültige Eingabe", "Keine gültigen Zeitstempel eingegeben.")
    
        def eventFilter(self, source, event):
            """Filter für Drag-and-Drop in das URL-Eingabefeld."""
            if source == self.url_input:
                if event.type() == event.DragEnter:
                    if event.mimeData().hasUrls():
                        event.acceptProposedAction()
                        return True
                elif event.type() == event.Drop:
                    if event.mimeData().hasUrls():
                        urls = event.mimeData().urls()
                        if urls:
                            file_path = urls[0].toLocalFile()
                            if os.path.exists(file_path):
                                self.url_input.setText(file_path)
                                logging.info(f"Per Drag-and-Drop ausgewählte Datei: {file_path}")
                                self.status_bar.showMessage(f"Per Drag-and-Drop ausgewählte Datei: {file_path}")
                                # Aktualisiere die Waveform
                                self.waveform_widget.set_audio(AudioSegment.from_file(file_path))
                                return True
            return super().eventFilter(source, event)
    
        def apply_theme(self):
            """Setzt das Farbschema gemäß den Einstellungen."""
            theme = self.settings.get('theme', 'Dunkel')
            if theme == 'Hell' or theme == 'System':
                QApplication.setPalette(QApplication.style().standardPalette())
            else:  # Dunkel
                dark_palette = QPalette()
                dark_color = QColor(45, 45, 45)
                disabled_color = QColor(127, 127, 127)
    
                dark_palette.setColor(QPalette.Window, dark_color)
                dark_palette.setColor(QPalette.WindowText, Qt.white)
                dark_palette.setColor(QPalette.Base, QColor(30, 30, 30))
                dark_palette.setColor(QPalette.AlternateBase, dark_color)
                dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
                dark_palette.setColor(QPalette.ToolTipText, Qt.white)
                dark_palette.setColor(QPalette.Text, Qt.white)
                dark_palette.setColor(QPalette.Disabled, QPalette.Text, disabled_color)
                dark_palette.setColor(QPalette.Button, dark_color)
                dark_palette.setColor(QPalette.ButtonText, Qt.white)
                dark_palette.setColor(QPalette.Disabled, QPalette.ButtonText, disabled_color)
                dark_palette.setColor(QPalette.BrightText, Qt.red)
                dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
                dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
                dark_palette.setColor(QPalette.HighlightedText, Qt.black)
    
                QApplication.setPalette(dark_palette)
                QApplication.setStyle("Fusion")
    
    
    class Worker(QObject):
        """
        Arbeiterklasse für die Verarbeitung von Audio, einschließlich Download, Extraktion, Segmentierung und Identifizierung.
        """
        segmentation_finished = pyqtSignal()
        finished = pyqtSignal()
        progress = pyqtSignal(int, str)
        error = pyqtSignal(str)
        segments_ready = pyqtSignal(list, list)
        download_progress = pyqtSignal(int)
        extraction_progress = pyqtSignal(int)
        segmentation_progress = pyqtSignal(int)
        overall_progress = pyqtSignal(int)
    
        def __init__(self, url_or_path: str, settings: dict):
            super().__init__()
            self.url_or_path = url_or_path
            self.settings = settings
            self.segments: List[AudioSegment] = []
            self.segments_info: List[dict] = []
            self.video_description = ''
            self.audio: Optional[AudioSegment] = None
            self.manual_timestamps = []
            self.total_steps = 3  # Download, Extraktion, Segmentierung
    
        def run(self):
            """Startet den Verarbeitungsprozess."""
            try:
                self.progress.emit(0, "Audio wird vorbereitet...")
                self.overall_progress.emit(0)
                step = 0
                if self.url_or_path.lower().startswith('http'):
                    success = self.download_audio(self.url_or_path)
                    if not success:
                        self.error.emit("Download fehlgeschlagen.")
                        return
                    step += 1
                    self.overall_progress.emit(int((step / self.total_steps) * 100))
                else:
                    self.process_local_file(self.url_or_path)
                    step += 1
                    self.overall_progress.emit(int((step / self.total_steps) * 100))
                self.segment_and_identify()
                step += 1
                self.overall_progress.emit(int((step / self.total_steps) * 100))
                self.finished.emit()
            except Exception as e:
                error_message = f"Ein Fehler ist aufgetreten: {str(e)}"
                logging.error(error_message)
                logging.error(traceback.format_exc())
                self.error.emit(error_message)
                self.finished.emit()
    
        def download_audio(self, url: str) -> bool:
            """Lädt das Audio von der gegebenen URL herunter."""
            self.progress.emit(10, "Audio wird heruntergeladen...")
            self.download_progress.emit(0)
            success = False
            try:
                with tempfile.TemporaryDirectory() as temp_dir:
                    output_template = os.path.join(temp_dir, 'downloaded_audio.%(ext)s')
                    ydl_opts = {
                        'format': 'bestaudio/best',
                        'outtmpl': output_template,
                        'quiet': True,
                        'no_warnings': True,
                        'ignoreerrors': False,
                        'nocheckcertificate': True,
                        'socket_timeout': 60,  # Erhöhtes Timeout
                        'retries': 3,  # Retry-Logik
                        'postprocessors': [{
                            'key': 'FFmpegExtractAudio',
                            'preferredcodec': 'mp3',
                            'preferredquality': '320',
                        }],
                        'progress_hooks': [self.ydl_hook],
                    }
                    with YoutubeDL(ydl_opts) as ydl:
                        info_dict = ydl.extract_info(url, download=True)
                        if info_dict is not None:
                            self.video_description = info_dict.get('description', '')
                            filename = ydl.prepare_filename(info_dict)
                            filename = os.path.splitext(filename)[0] + '.mp3'
                            if os.path.exists(filename):
                                self.extract_audio(filename)
                                success = True
                                logging.info("Download mit yt_dlp erfolgreich.")
                            else:
                                logging.warning("Heruntergeladene Datei nicht gefunden.")
                                self.error.emit("Heruntergeladene Datei nicht gefunden.")
                        else:
                            logging.warning("Download mit yt_dlp fehlgeschlagen.")
                            self.error.emit("Download fehlgeschlagen.")
            except Exception as e_yt_dlp:
                logging.error(f"Download mit yt_dlp fehlgeschlagen: {e_yt_dlp}")
                self.error.emit(f"Download fehlgeschlagen: {e_yt_dlp}")
            finally:
                if success:
                    self.progress.emit(30, "Download abgeschlossen.")
                    self.download_progress.emit(100)
            return success
    
        def ydl_hook(self, d):
            if d['status'] == 'downloading':
                if d.get('total_bytes'):
                    percentage = d.get('downloaded_bytes', 0) / d.get('total_bytes', 1) * 100
                elif d.get('total_bytes_estimate'):
                    percentage = d.get('downloaded_bytes', 0) / d.get('total_bytes_estimate', 1) * 100
                else:
                    percentage = 0
                self.download_progress.emit(int(percentage))
            elif d['status'] == 'finished':
                self.download_progress.emit(100)
    
        def process_local_file(self, file_path: str):
            """Verarbeitet eine lokale Datei."""
            self.progress.emit(10, "Lokale Datei wird verarbeitet...")
            self.extract_metadata_from_file(file_path)
            self.extract_audio(file_path)
    
        def extract_audio(self, file_path: str):
            """Extrahiert das Audio aus der gegebenen Datei."""
            try:
                if not os.path.exists(file_path):
                    raise Exception(f"Audiodatei nicht gefunden: {file_path}")
                self.progress.emit(35, "Audio wird extrahiert...")
                self.extraction_progress.emit(0)
    
                self.audio = AudioSegment.from_file(file_path)
                self.extraction_progress.emit(100)
                self.progress.emit(40, "Audio erfolgreich extrahiert.")
                self.overall_progress.emit(int((1 / self.total_steps) * 100))
            except Exception as e:
                raise Exception(f"Fehler beim Extrahieren des Audios: {str(e)}")
    
        def extract_metadata_from_file(self, file_path: str):
            """Extrahiert Metadaten aus der lokalen Datei."""
            try:
                if file_path.lower().endswith(('.mp3', '.wav', '.flac', '.ogg')):
                    audio = MP3(file_path)
                    title = audio.tags.get("TIT2", "").text[0] if audio.tags.get("TIT2") else ''
                    artist = audio.tags.get("TPE1", "").text[0] if audio.tags.get("TPE1") else ''
                    self.video_description = f"{title} {artist}"
                    logging.info("Metadaten aus lokaler Datei extrahiert.")
            except (AttributeError, error) as e:
                logging.warning(f"Keine Metadaten aus lokaler Datei extrahiert: {e}")
    
        def segment_and_identify(self):
            """Segmentiert das Audio und identifiziert die einzelnen Tracks."""
            self.progress.emit(45, "Audio wird segmentiert...")
            self.segmentation_progress.emit(0)
            timestamps = self.parse_timestamps(self.video_description)
            if timestamps:
                logging.info("Zeitstempel aus Videobeschreibung werden für die Segmentierung verwendet.")
                self.segment_using_timestamps(timestamps)
            else:
                logging.info("Keine Zeitstempel gefunden.")
                if self.manual_timestamps:
                    logging.info("Verwende manuell eingegebene Zeitstempel.")
                    self.segment_using_timestamps(self.manual_timestamps)
                else:
                    logging.info("Versuche Stilleerkennung.")
                    self.segment_using_silence_detection()
                    if not self.segments:
                        logging.info("Stilleerkennung fehlgeschlagen, versuche alternative Segmentierung.")
                        self.segment_using_fixed_length()
                        if not self.segments:
                            logging.warning("Alternative Segmentierung fehlgeschlagen, gesamtes Audio wird verwendet.")
                            self.segments.append(self.audio)
                            self.segments_info.append({'title': 'Gesamtes Audio'})
            self.segmentation_progress.emit(100)
            self.progress.emit(80, "Segmentierung abgeschlossen.")
            self.segments_ready.emit(self.segments_info, self.segments)
    
        def segment_using_timestamps(self, timestamps: List[Tuple[int, str]]):
            """Segmentiert das Audio basierend auf Zeitstempeln."""
            total = len(timestamps)
            for i, (start_time, title) in enumerate(timestamps):
                progress = int(((i + 1) / total) * 100)
                self.segmentation_progress.emit(progress)
                start_ms = int(start_time * 1000)
                end_ms = int(timestamps[i + 1][0] * 1000) if i + 1 < len(timestamps) else len(self.audio)
                if start_ms >= len(self.audio):
                    logging.warning(f"Startzeit {start_time}s überschreitet die Audiodauer.")
                    continue
                segment = self.audio[start_ms:end_ms]
                self.segments.append(segment)
                self.segments_info.append({'title': title})
                logging.info(f"Segment {i + 1}: '{title}' erstellt von {start_time}s bis {end_ms / 1000}s.")
    
        def segment_using_silence_detection(self):
            """Segmentiert das Audio durch Stilleerkennung."""
            if not self.audio:
                logging.error("Keine Audiodaten zum Segmentieren vorhanden.")
                return
    
            min_silence_len = self.settings.get('min_silence_len', 2000)
            silence_thresh_adjust = self.settings.get('silence_thresh_adjust', -16)
            silence_thresh = self.audio.dBFS + silence_thresh_adjust
            keep_silence = self.settings.get('keep_silence', 500)
            logging.info(f"Stilleerkennung mit min_silence_len={min_silence_len}, silence_thresh={silence_thresh} dBFS")
    
            chunks = split_on_silence(
                self.audio,
                min_silence_len=min_silence_len,
                silence_thresh=silence_thresh,
                keep_silence=keep_silence
            )
    
            min_segment_length = self.settings.get('min_segment_length', 10000)
            segments = [s for s in chunks if len(s) > min_segment_length]
    
            if segments:
                self.segments = segments
                self.segments_info = [{'title': f'Track {i + 1}'} for i in range(len(segments))]
                logging.info(f"{len(segments)} Segmente durch Stilleerkennung gefunden.")
            else:
                logging.warning("Keine Segmente mit Stilleerkennung gefunden.")
    
        def segment_using_fixed_length(self, segment_length_ms: int = 180000):
            """Segmentiert das Audio in feste Längen."""
            if not self.audio:
                logging.error("Keine Audiodaten zum Segmentieren vorhanden.")
                return
    
            self.segments = []
            self.segments_info = []
            total_length_ms = len(self.audio)
            num_segments = total_length_ms // segment_length_ms + 1
            for i, start_ms in enumerate(range(0, total_length_ms, segment_length_ms)):
                progress = int(((i + 1) / num_segments) * 100)
                self.segmentation_progress.emit(progress)
                end_ms = min(start_ms + segment_length_ms, total_length_ms)
                segment = self.audio[start_ms:end_ms]
                self.segments.append(segment)
                self.segments_info.append({'title': f'Track {len(self.segments)}'})
                logging.info(f"Segment {i + 1}: 'Track {len(self.segments)}' erstellt von {start_ms / 1000}s bis {end_ms / 1000}s.")
            logging.info(f"{len(self.segments)} Segmente durch feste Länge erzeugt.")
    
        def parse_timestamps(self, description: str) -> List[Tuple[int, str]]:
            """Parst Zeitstempel und Titel aus der Videobeschreibung."""
            timestamps = []
            lines = description.splitlines()
            for line in lines:
                line = line.strip()
                if not line:
                    continue
                # Muster für verschiedene Zeitstempelformate
                patterns = [
                    r'^(\d{1,2}:\d{2}:\d{2})\s*[-–—]\s*(.+)$',
                    r'^(\d{1,2}:\d{2})\s*[-–—]\s*(.+)$',
                    r'^(\d{1,2}\.\d{2}\.\d{2})\s*[-–—]?\s*(.+)$',
                    r'^(\d{1,2}\.\d{2})\s*[-–—]?\s*(.+)$',
                    r'^(\d+)\s*[-–—]?\s*(.+)$',
                ]
                matched = False
                for pattern in patterns:
                    match = re.match(pattern, line)
                    if match:
                        time_str = match.group(1)
                        title = match.group(2)
                        total_seconds = self.convert_time_to_seconds(time_str)
                        if total_seconds is not None:
                            timestamps.append((total_seconds, title.strip()))
                            logging.debug(f"Zeitstempel gefunden: {time_str} - {title.strip()}")
                        matched = True
                        break
                if not matched:
                    logging.debug(f"Kein gültiger Zeitstempel in Zeile: {line}")
            timestamps.sort(key=lambda x: x[0])
            logging.info(f"{len(timestamps)} Zeitstempel aus der Beschreibung geparst.")
            return timestamps
    
        def convert_time_to_seconds(self, time_str: str) -> Optional[int]:
            try:
                time_str = time_str.strip()
                if ':' in time_str:
                    parts = [int(p) for p in time_str.split(':')]
                    if len(parts) == 3:
                        hours, minutes, seconds = parts
                    elif len(parts) == 2:
                        hours = 0
                        minutes, seconds = parts
                    else:
                        return None
                    total_seconds = hours * 3600 + minutes * 60 + seconds
                elif '.' in time_str:
                    parts = [int(p) for p in time_str.split('.')]
                    if len(parts) == 3:
                        hours, minutes, seconds = parts
                    elif len(parts) == 2:
                        hours = 0
                        minutes, seconds = parts
                    else:
                        return None
                    total_seconds = hours * 3600 + minutes * 60 + seconds
                else:
                    total_seconds = int(time_str)
                return total_seconds
            except ValueError:
                return None
    
    
    # Run the application
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        window = MusicIdentifierApp()
        window.show()
        sys.exit(app.exec_())
    

    Erläuterung der Änderungen

    1. Entfernung von CSS-Transitions und -Transforms:

      • Alle transition und transform CSS-Eigenschaften wurden aus den Stylesheets der Buttons entfernt, um die Fehlermeldungen zu beseitigen.
    2. Implementierung von QPropertyAnimation und QGraphicsEffect:

      • Eine neue Klasse AnimatedButton wurde eingeführt, die von QPushButton erbt. Diese Klasse implementiert Hover- und Klick-Animationen mithilfe von QPropertyAnimation.
      • Zusätzlich wurden QGraphicsDropShadowEffect-Effekte hinzugefügt, um den Buttons einen Schattenwurf für eine bessere visuelle Tiefe zu verleihen.
    3. Verbesserung des Layouts:

      • Die Anwendung verwendet jetzt eine flexiblere und klarere Layoutstruktur. Ein WaveformWidget wurde hinzugefügt, um die Audio-Wellenform im Hintergrund anzuzeigen.
      • Der Gesamtfortschrittsbalken (overall_progress_bar) wurde prominenter platziert, um den Fortschritt des gesamten Prozesses besser sichtbar zu machen.
    4. Lautstärkeregelung:

      • Jeder MediaPlayer besitzt nun einen eigenen Lautstärkeregler (volume_slider), der die Lautstärke der jeweiligen Wiedergabe steuert. Diese Slider sind standardmäßig deaktiviert und werden aktiviert, sobald die Metadaten abgerufen wurden.
    5. Audio-Wellenform-Visualisierung:

      • Eine neue Klasse WaveformWidget wurde erstellt, die die Audio-Wellenform darstellt. Diese Klasse verarbeitet das Audiosegment, extrahiert die Samples und zeichnet die Wellenform mit QPainter.
      • Das WaveformWidget wird oberhalb der Eingabefelder angezeigt und aktualisiert sich automatisch, wenn eine Datei ausgewählt wird.
    6. Weiterführende Verbesserungen:

      • Die Buttons und anderen interaktiven Elemente nutzen jetzt die AnimatedButton-Klasse, um ein ansprechenderes Benutzererlebnis zu bieten.
      • Die Musiktabelle umfasst jetzt eine zusätzliche Spalte für den Lautstärkeregler, was die Steuerung der Wiedergabe weiter verbessert.

    Diese Änderungen sorgen für eine robustere und benutzerfreundlichere Anwendung mit einer modernen und ansprechenden Benutzeroberfläche.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.