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

diese anwendung sollte bereits während des downloades einen fortschrittsbalken anzeigen…

  1. User

    diese anwendung sollte bereits während des downloades einen fortschrittsbalken anzeigen und bei allen vorgängen abgesehen von einem fortschrittsbalkens auch weitere informationen je nach art des vorgangs anzeigen wie zb benötigte und vorraussichtlich noch verbleibende dauer des vorgangs, download geschwindigkeit etc. Zudem sollte die anwendung auch damit zurecht kommen wenn der input nur ein musiktrack enthält auch wenn eigentlich mehrere erwartet werden. Alle gefundenen musikstücke sollten dem nutzer angezeigt werden sobald die mp3 datei vollständig bearbeitet wurde, auch wenn der gesamte vorgang noch nicht beendet ist. Zudem behauptete die anwendung das librosa nicht installiert wurde obwohl es installiert ist. Allgemein macht diese prüfung ob librosa installiert ist oder nicht wenig sinn, librosa wird standard mit allen andere bibliotheken installiert und ist daher immer vorhanden. Abgesehen von diesen dingen gibt es im gui diverse schönheitsfehler wie zb dunkle schrift auf dunklem hintergrund etc, verbessere daher auch die optik des guis nocheinmal. Zudem schien es so als ob das abspielen der segmentierten musikstücke nicht funktionierte, genau so wie der schiebregler der musikstück zeitleiste keine funktion zu haben. Korrigiere auch fehler die dort vorhanden sind und prüfe auch allgemein den bereich wo die metadaten angezeigt und editiert werden sollten darauf das alle daten editiert, angezeigt und gefundene informationen korrekt eingetragen werden. Korrigiere dieses skript und nenn mir dann das vollständige verbesserte skript der anwendung mit dem gesamten code. Skript: import sys import os import tempfile import re import logging import requests import numpy as np import urllib.parse import speech_recognition as sr from PyQt5.QtCore import Qt, QThread, pyqtSignal, QUrl from PyQt5.QtWidgets import ( QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLineEdit, QPushButton, QLabel, QFileDialog, QProgressBar, QTableWidget, QTableWidgetItem, QHeaderView, QSlider, QDialog, QFormLayout, QSpinBox, QDoubleSpinBox, QTextEdit, QSplitter ) from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent from PyQt5.QtGui import QPainter, QColor, QPen

    try: import yt_dlp as youtube_dl except ImportError: import youtube_dl

    from pydub import AudioSegment from mutagen.id3 import ID3, TIT2, TALB, TPE1, APIC, ID3NoHeaderError

    Prüfe, ob librosa installiert ist

    try: import librosa LIBROSA_AVAILABLE = True except ImportError: LIBROSA_AVAILABLE = False

    from bs4 import BeautifulSoup from configparser import ConfigParser

    from io import BytesIO

    Logging konfigurieren

    logging.basicConfig( filename='music_extractor.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s' )

    logger = logging.getLogger(name)

    Konfigurationsdatei verwalten

    CONFIG_FILE = 'settings.ini'

    def load_config(): config = ConfigParser() if not os.path.exists(CONFIG_FILE): config['DEFAULT'] = { 'output_folder': os.path.expanduser("~/Music/ExtractedTracks"), 'min_silence_len': '1000', 'silence_thresh': '-40' } with open(CONFIG_FILE, 'w') as configfile: config.write(configfile) else: config.read(CONFIG_FILE) return config

    def save_config(config): with open(CONFIG_FILE, 'w') as configfile: config.write(configfile)

    Custom Logger Handler für QTextEdit mit Signals

    class QTextEditLogger(logging.Handler, QWidget): new_record = pyqtSignal(str)

    def __init__(self, parent=None):
        super().__init__()
        QWidget.__init__(self)
        self.widget = parent
    
    def emit(self, record):
        msg = self.format(record)
        self.new_record.emit(msg)
    

    Worker-Thread für die Verarbeitung

    class ExtractionThread(QThread): progress = pyqtSignal(int) finished = pyqtSignal(list, AudioSegment) # Liste der Tracks und vollständiges Audio error = pyqtSignal(str) log = pyqtSignal(str)

    def __init__(self, input_values, output_folder, min_silence_len, silence_thresh):
        super().__init__()
        self.input_values = input_values  # Liste von Eingabewerten
        self.output_folder = output_folder
        self.is_interrupted = False
        self.min_silence_len = min_silence_len
        self.silence_thresh = silence_thresh
    
    def run(self):
        try:
            all_extracted_tracks = []
            full_audio = None  # Initialisiere full_audio hier
            total_inputs = len(self.input_values)
            for idx, input_value in enumerate(self.input_values):
                if self.is_interrupted:
                    break
    
                self.log.emit(f"Verarbeite Eingabe {idx+1}/{total_inputs}: {input_value}")
                # Temporärer Arbeitsbereich
                with tempfile.TemporaryDirectory() as temp_dir:
                    audio_file, video_info = self.download_and_extract_audio(input_value, temp_dir)
                    if audio_file:
                        full_audio = AudioSegment.from_mp3(audio_file)
                    else:
                        error_msg = f"Fehler beim Verarbeiten von {input_value}."
                        self.error.emit(error_msg)
                        self.log.emit(error_msg)
                        continue  # Fährt mit der nächsten Eingabe fort
    
                    # Versuche, die Trackliste aus der Videobeschreibung zu extrahieren
                    tracklist = self.extract_tracklist_from_description(video_info)
                    if tracklist:
                        self.log.emit("Trackliste aus Videobeschreibung extrahiert.")
                        # Segmentiere das Audio basierend auf der extrahierten Trackliste
                        segments = self.segment_audio_by_tracklist(full_audio, tracklist)
                    else:
                        self.log.emit("Keine Trackliste gefunden. Verwende akustische Analyse.")
                        # Verwende akustische Analyse zur Segmentierung
                        segments = self.segment_audio_by_acoustic_analysis(full_audio)
                        if not segments:
                            error_msg = "Keine Segmente im Audio gefunden."
                            self.error.emit(error_msg)
                            self.log.emit(error_msg)
                            continue  # Fährt mit der nächsten Eingabe fort
    
                    # Verarbeite die Segmente und extrahiere Metadaten
                    extracted_tracks = self.process_segments(segments, temp_dir, video_info, full_audio)
                    all_extracted_tracks.extend(extracted_tracks)
                    self.log.emit(f"Verarbeitung von {input_value} abgeschlossen.")
    
                # Aktualisiere den Fortschritt
                progress = int(((idx + 1) / total_inputs) * 100)
                self.progress.emit(progress)
    
            # Beende den Prozess und gebe auch das vollständige Audio aus
            if full_audio is None:
                full_audio = AudioSegment.empty()  # Erstellt ein leeres AudioSegment
    
            self.finished.emit(all_extracted_tracks, full_audio)
            self.progress.emit(100)
            self.log.emit("Extraktion aller Eingaben abgeschlossen.")
        except Exception as e:
            error_msg = f"Ein unerwarteter Fehler ist aufgetreten: {str(e)}"
            self.error.emit(error_msg)
            self.log.emit(error_msg)
    
    def download_and_extract_audio(self, input_value, temp_dir):
        """
        Lädt die Audioquelle herunter und extrahiert das Audio.
        """
        try:
            if input_value.startswith("http"):
                ydl_opts = {
                    'format': 'bestaudio/best',
                    'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
                    'quiet': True,
                    'no_warnings': True,
                }
                with youtube_dl.YoutubeDL(ydl_opts) as ydl:
                    info_dict = ydl.extract_info(input_value, download=True)
                    video_title = info_dict.get('title', "Unbekanntes Album")
                    video_description = info_dict.get('description', "")
                    thumbnail_url = info_dict.get('thumbnail', None)
                    ext = info_dict.get('ext', 'mp3')
                    downloaded_file = ydl.prepare_filename(info_dict)
    
                    # Konvertiere zu mp3 falls nötig
                    if ext != 'mp3':
                        audio = AudioSegment.from_file(downloaded_file)
                        audio_file = os.path.join(temp_dir, f"{video_title}.mp3")
                        audio.export(audio_file, format='mp3')
                    else:
                        audio_file = downloaded_file
            else:
                video_title = os.path.splitext(os.path.basename(input_value))[0]
                video_description = ""
                thumbnail_url = None
                audio = AudioSegment.from_file(input_value)
                audio_file = os.path.join(temp_dir, f"{video_title}.mp3")
                audio.export(audio_file, format='mp3')
    
            video_info = {
                'title': video_title,
                'description': video_description,
                'thumbnail_url': thumbnail_url
            }
            self.log.emit(f"Audio von {input_value} erfolgreich heruntergeladen und extrahiert.")
            return audio_file, video_info
        except Exception as e:
            error_msg = f"Fehler beim Herunterladen oder Extrahieren des Audios: {str(e)}"
            self.error.emit(error_msg)
            self.log.emit(error_msg)
            return None, None
    
    def extract_tracklist_from_description(self, video_info):
        """
        Versucht, die Trackliste aus der Videobeschreibung zu extrahieren.
        """
        description = video_info.get('description', '')
        # Regulärer Ausdruck zum Finden von Zeitstempeln und Titeln
        pattern = r'((\d{1,2}:)?\d{1,2}:\d{2})\s*[-–~—–]\s*(.+)'
        matches = re.findall(pattern, description)
        if matches:
            tracklist = []
            for match in matches:
                time_str = match[0]
                title = match[3].strip()
                # Konvertiere Zeitstempel in Millisekunden
                time_ms = self.timestamp_to_milliseconds(time_str)
                tracklist.append({'time_ms': time_ms, 'title': title})
            self.log.emit("Trackliste erfolgreich aus Beschreibung extrahiert.")
            return tracklist
        else:
            self.log.emit("Keine Trackliste in der Beschreibung gefunden.")
            return None
    
    def timestamp_to_milliseconds(self, timestamp):
        """
        Konvertiert einen Zeitstempel im Format HH:MM:SS oder MM:SS in Millisekunden.
        """
        parts = timestamp.strip().split(':')
        parts = [int(p) for p in parts]
        if len(parts) == 3:
            hours, minutes, seconds = parts
        elif len(parts) == 2:
            hours = 0
            minutes, seconds = parts
        else:
            hours = 0
            minutes = 0
            seconds = parts[0]
        total_ms = ((hours * 3600) + (minutes * 60) + seconds) * 1000
        return total_ms
    
    def segment_audio_by_tracklist(self, audio, tracklist):
        """
        Segmentiert das Audio basierend auf der extrahierten Trackliste.
        """
        try:
            segments = []
            total_tracks = len(tracklist)
            for idx in range(total_tracks):
                start_time = tracklist[idx]['time_ms']
                if idx + 1 < total_tracks:
                    end_time = tracklist[idx + 1]['time_ms']
                else:
                    end_time = len(audio)
                segment = audio[start_time:end_time]
                segments.append({
                    'start': start_time,
                    'end': end_time,
                    'title': tracklist[idx]['title'],
                    'segment': segment
                })
            self.log.emit("Audio erfolgreich anhand der Trackliste segmentiert.")
            return segments
        except Exception as e:
            error_msg = f"Fehler beim Segmentieren des Audios: {str(e)}"
            self.error.emit(error_msg)
            self.log.emit(error_msg)
            return None
    
    def segment_audio_by_acoustic_analysis(self, audio):
        """
        Segmentiert das Audio basierend auf akustischer Analyse.
        """
        try:
            if not LIBROSA_AVAILABLE:
                self.log.emit("Librosa nicht verfügbar. Installieren Sie 'librosa', um diese Funktion zu nutzen.")
                return None
    
            # Konvertiere AudioSegment zu numpy Array
            y = np.array(audio.get_array_of_samples())
            sr = audio.frame_rate
    
            if audio.channels > 1:
                y = y.reshape((-1, audio.channels))
                y = y.mean(axis=1)
    
            # Verwende Librosa für die Analyse
            tempo, beat_frames = librosa.beat.beat_track(y=y.astype(np.float32), sr=sr)
            beats = librosa.frames_to_time(beat_frames, sr=sr)
            times_ms = (beats * 1000).astype(int)
    
            # Generiere Segmente basierend auf Zeiten
            segments = []
            start_times = [0] + times_ms.tolist()
            end_times = times_ms.tolist() + [len(audio)]
            for idx, (start_ms, end_ms) in enumerate(zip(start_times, end_times)):
                segment = audio[start_ms:end_ms]
                segments.append({
                    'start': start_ms,
                    'end': end_ms,
                    'title': f"Track {idx + 1}",
                    'segment': segment
                })
            self.log.emit("Audio erfolgreich durch akustische Analyse segmentiert.")
            return segments
        except Exception as e:
            error_msg = f"Fehler bei der akustischen Analyse des Audios: {str(e)}"
            self.error.emit(error_msg)
            self.log.emit(error_msg)
            return None
    
    def process_segments(self, segments, temp_dir, video_info, full_audio):
        """
        Verarbeitet die Segmente, extrahiert Metadaten und bereitet sie für die Vorschau vor.
        """
        extracted_tracks = []
        total_segments = len(segments)
        for idx, data in enumerate(segments):
            if self.is_interrupted:
                break
    
            segment = data['segment']
            start_ms = data['start']
            end_ms = data['end']
            title = data.get('title', f"Track {idx + 1}")
            artist = "Unbekannter Künstler"
            album = video_info.get('title', "Unbekanntes Album")
    
            # Speichere das Segment temporär, um einen Dateipfad zu haben
            segment_path = os.path.join(temp_dir, f"segment_{idx + 1}.mp3")
            segment.export(segment_path, format='mp3')
            data['file_path'] = segment_path
    
            # Identifiziere den Track
            track_info = self.identify_track_by_spectral_and_text(segment_path)
            if track_info:
                title = track_info.get('title', title)
                artist = track_info.get('artist', artist)
    
            # Versuche, Metadaten automatisch zu finden
            metadata = self.fetch_metadata(title, artist)
            if metadata:
                title = metadata.get('title', title)
                artist = metadata.get('artist', artist)
                album = metadata.get('album', album)
                cover_url = metadata.get('cover_url', None)
            else:
                cover_url = None
    
            # Lade das Coverbild herunter, falls vorhanden
            if cover_url:
                cover_path = os.path.join(temp_dir, f"cover_{idx}.jpg")
                self.download_cover(cover_url, cover_path)
            else:
                cover_path = None
    
            track_info = {
                'title': title,
                'artist': artist,
                'album': album,
                'file_path': segment_path,
                'cover_path': cover_path,
                'start_ms': start_ms,
                'end_ms': end_ms
            }
            extracted_tracks.append(track_info)
            progress = int(((idx + 1) / total_segments) * 100)
            self.progress.emit(progress)
            self.log.emit(f"Segment {idx + 1}/{total_segments} verarbeitet.")
    
        return extracted_tracks
    
    def identify_track_by_spectral_and_text(self, audio_file_path):
        try:
            if not LIBROSA_AVAILABLE:
                self.log.emit("Librosa nicht verfügbar. Spektralanalyse wird übersprungen.")
                return None
    
            # Spektrale Analyse
            y, sr = librosa.load(audio_file_path, duration=30)
            mid_point = len(y) // 2
            sample = y[max(0, mid_point - sr*7):min(len(y), mid_point + sr*8)]
    
            mfcc = librosa.feature.mfcc(y=sample, sr=sr, n_mfcc=13)
            chroma = librosa.feature.chroma_stft(y=sample, sr=sr)
            tempo, _ = librosa.beat.beat_track(y=sample, sr=sr)
    
            spectral_features = np.concatenate([
                np.mean(mfcc, axis=1),
                np.mean(chroma, axis=1),
                [tempo]
            ])
    
            # Textextraktion
            recognizer = sr.Recognizer()
            audio_segment = AudioSegment.from_file(audio_file_path)
            duration_ms = len(audio_segment)
            mid_point_ms = duration_ms / 2
            audio_slice = audio_segment[max(0, mid_point_ms - 5000):min(duration_ms, mid_point_ms + 5000)]
            audio_bytes = BytesIO()
            audio_slice.export(audio_bytes, format="wav")
            audio_bytes.seek(0)
            with sr.AudioFile(audio_bytes) as source:
                audio = recognizer.record(source)
                try:
                    text = recognizer.recognize_google(audio, language="de-DE")
                except sr.UnknownValueError:
                    text = ""
    
            # Kombinierte Suche
            search_query = f"{text} {' '.join(map(str, spectral_features))}"
            return self.search_track_online(search_query)
    
        except Exception as e:
            self.log.emit(f"Fehler bei der Spektral- und Textanalyse: {str(e)}")
            return None
    
    def search_track_online(self, query):
        if not self.check_internet_connection():
            self.log.emit("Keine Internetverbindung verfügbar. Online-Suche übersprungen.")
            return None
    
        search_url = f"https://api.deezer.com/search?q={urllib.parse.quote(query)}"
        headers = {'User-Agent': 'Mozilla/5.0'}
    
        try:
            response = requests.get(search_url, headers=headers, timeout=10)
            response.raise_for_status()
            data = response.json()
            if 'data' in data and len(data['data']) > 0:
                first_result = data['data'][0]
                artist = first_result['artist']['name']
                title = first_result['title']
                return {'artist': artist, 'title': title}
            else:
                return None
        except requests.exceptions.RequestException as e:
            self.log.emit(f"Fehler bei der Online-Suche: {str(e)}")
            return None
    
    def fetch_metadata(self, track_title, artist_name=None):
        """
        Sucht nach Metadaten zu einem gegebenen Titel mittels der MusicBrainz API.
        """
        try:
            query = f'"{track_title}"'
            if artist_name:
                query += f' AND artist:"{artist_name}"'
            url = f"https://musicbrainz.org/ws/2/recording/?query={urllib.parse.quote(query)}&fmt=json&limit=1"
            headers = {'User-Agent': 'MusicExtractor/1.0 (email@example.com)'}
            response = requests.get(url, headers=headers)
            if response.status_code == 200:
                data = response.json()
                if 'recordings' in data and data['recordings']:
                    recording = data['recordings'][0]
                    title = recording.get('title', track_title)
                    artist = recording['artist-credit'][0]['name'] if 'artist-credit' in recording else "Unbekannter Künstler"
                    album = recording['releases'][0]['title'] if 'releases' in recording and recording['releases'] else "Unbekanntes Album"
                    return {
                        'title': title,
                        'artist': artist,
                        'album': album,
                        'cover_url': self.fetch_cover_url(recording)
                    }
            return None
        except Exception:
            return None
    
    def fetch_cover_url(self, recording):
        """
        Versucht, die Cover-URL für eine Aufnahme zu erhalten.
        """
        try:
            if 'releases' in recording and recording['releases']:
                release = recording['releases'][0]
                mbid = release.get('id', None)
                if mbid:
                    url = f"https://coverartarchive.org/release/{mbid}"
                    response = requests.get(url)
                    if response.status_code == 200:
                        data = response.json()
                        if 'images' in data and data['images']:
                            return data['images'][0]['image']
            return None
        except Exception:
            return None
    
    def download_cover(self, url, path):
        """
        Lädt das Coverbild von der gegebenen URL herunter und speichert es unter dem angegebenen Pfad.
        """
        try:
            response = requests.get(url)
            if response.status_code == 200:
                with open(path, 'wb') as f:
                    f.write(response.content)
        except Exception:
            pass
    
    def check_internet_connection(self):
        try:
            requests.get('https://www.google.com/', timeout=5)
            return True
        except requests.ConnectionError:
            return False
    

    Widget zur Anzeige der Waveform

    class WaveformWidget(QWidget): def init(self, parent=None): super().init(parent) self.audio_data = None self.segments = [] self.setMinimumHeight(200)

    def set_audio_data(self, audio_data):
        self.audio_data = audio_data
        self.update()
    
    def set_segments(self, segments):
        self.segments = segments
        self.update()
    
    def paintEvent(self, event):
        painter = QPainter(self)
        rect = self.rect()
        painter.fillRect(rect, QColor('#2E2E2E'))
    
        if not self.audio_data:
            return
    
        pen = QPen(QColor('#4CAF50'))
        painter.setPen(pen)
    
        data = np.array(self.audio_data.get_array_of_samples())
        sample_rate = self.audio_data.frame_rate
    
        if self.audio_data.channels > 1:
            data = data.reshape((-1, self.audio_data.channels))
            data = data.mean(axis=1)
    
        data = data[::max(1, int(len(data)/rect.width()))]  # Downsampling
        h_center = rect.height() / 2
        max_amplitude = np.max(np.abs(data))
        if max_amplitude == 0:
            max_amplitude = 1
        amplitude = data / max_amplitude * (rect.height() / 2)
    
        for x in range(len(amplitude)-1):
            x1 = x
            y1 = int(h_center - amplitude[x])
            x2 = x + 1
            y2 = int(h_center - amplitude[x+1])
            painter.drawLine(x1, y1, x2, y2)
    
        # Zeichne Segmentgrenzen
        if self.segments:
            pen = QPen(QColor('#FF0000'))
            pen.setWidth(2)
            painter.setPen(pen)
            total_duration = len(self.audio_data)
            for segment in self.segments:
                start_x = int(segment['start_ms'] / total_duration * rect.width())
                painter.drawLine(start_x, 0, start_x, rect.height())
    

    Dialog für Einstellungen

    class SettingsDialog(QDialog): def init(self, config, parent=None): super().init(parent) self.setWindowTitle("Einstellungen") self.config = config self.setup_ui()

    def setup_ui(self):
        layout = QFormLayout(self)
    
        # Min Silence Length
        self.min_silence_len_spinbox = QSpinBox()
        self.min_silence_len_spinbox.setRange(100, 10000)
        self.min_silence_len_spinbox.setValue(int(self.config['DEFAULT']['min_silence_len']))
        self.min_silence_len_spinbox.setSuffix(" ms")
        layout.addRow("Minimale Stillelänge:", self.min_silence_len_spinbox)
    
        # Silence Threshold
        self.silence_thresh_spinbox = QDoubleSpinBox()
        self.silence_thresh_spinbox.setRange(-100.0, 0.0)
        self.silence_thresh_spinbox.setSingleStep(1.0)
        self.silence_thresh_spinbox.setValue(float(self.config['DEFAULT']['silence_thresh']))
        self.silence_thresh_spinbox.setSuffix(" dBFS")
        layout.addRow("Stille-Schwellenwert:", self.silence_thresh_spinbox)
    
        # Buttons
        buttons_layout = QHBoxLayout()
        self.ok_button = QPushButton("OK")
        self.ok_button.clicked.connect(self.accept)
        self.cancel_button = QPushButton("Abbrechen")
        self.cancel_button.clicked.connect(self.reject)
        buttons_layout.addWidget(self.ok_button)
        buttons_layout.addWidget(self.cancel_button)
        layout.addRow(buttons_layout)
    
    def accept(self):
        self.config['DEFAULT']['min_silence_len'] = str(self.min_silence_len_spinbox.value())
        self.config['DEFAULT']['silence_thresh'] = str(self.silence_thresh_spinbox.value())
        save_config(self.config)
        super().accept()
    

    Hauptanwendungsklasse

    class MusicExtractorApp(QMainWindow): def init(self): super().init() self.config = load_config() self.extracted_tracks = [] self.media_player = QMediaPlayer() self.current_track_row = None self.full_audio = None self.thread = None

        self.init_ui()
    
        self.logger = logging.getLogger(__name__)
        self.logger.setLevel(logging.INFO)
        text_edit_handler = QTextEditLogger()
        text_edit_handler.new_record.connect(self.append_log_message)
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
        text_edit_handler.setFormatter(formatter)
        self.logger.addHandler(text_edit_handler)
    
    def init_ui(self):
        self.setWindowTitle("Music Extractor")
        self.setGeometry(100, 100, 1200, 800)
        self.apply_styles()
    
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        main_layout = QVBoxLayout(central_widget)
    
        self.setup_widgets()
    
        self.statusBar().showMessage('Bereit')
    
    def apply_styles(self):
        style = """
        QMainWindow {
            background-color: #2E2E2E;
            color: #FFFFFF;
        }
        QPushButton {
            background-color: #4CAF50;
            border: none;
            color: white;
            padding: 8px 16px;
            text-align: center;
            text-decoration: none;
            font-size: 14px;
            margin: 4px 2px;
            border-radius: 8px;
        }
        QPushButton:hover {
            background-color: #45a049;
        }
        QLineEdit, QTextEdit {
            padding: 5px;
            border: 1px solid #ccc;
            border-radius: 4px;
            font-size: 14px;
            color: #000;
            background-color: #FFF;
        }
        QLabel {
            font-size: 14px;
        }
        QTableWidget {
            background-color: #3E3E3E;
            color: #FFFFFF;
            border: 1px solid #555;
        }
        QHeaderView::section {
            background-color: #555555;
            color: white;
            padding: 4px;
            border: 1px solid #777777;
        }
        QTableWidget::item:selected {
            background-color: #4CAF50;
        }
        QTextEdit#LogDisplay {
            background-color: #1E1E1E;
            color: #00FF00;
            font-family: Consolas, Courier, monospace;
        }
        """
        self.setStyleSheet(style)
    
    def setup_widgets(self):
        central_widget = self.centralWidget()
        main_layout = central_widget.layout()
    
        # Eingabebereich mit Unterstützung für mehrere Eingaben
        input_layout = QHBoxLayout()
        self.input_field = QTextEdit()
        self.input_field.setPlaceholderText("Geben Sie Links oder lokale Dateien an, jeweils in einer neuen Zeile...")
        self.input_field.setAcceptDrops(True)
        self.input_field.dragEnterEvent = self.drag_enter_event
        self.input_field.dropEvent = self.drop_event
        input_layout.addWidget(self.input_field)
        self.browse_button = QPushButton("Durchsuchen")
        self.browse_button.setToolTip("Wählen Sie lokale Dateien aus")
        self.browse_button.clicked.connect(self.browse_files)
        input_layout.addWidget(self.browse_button)
        main_layout.addLayout(input_layout)
    
        settings_layout = QHBoxLayout()
        self.output_label = QLabel("Ausgabeordner:")
        settings_layout.addWidget(self.output_label)
        self.output_field = QLineEdit(self.config['DEFAULT']['output_folder'])
        settings_layout.addWidget(self.output_field)
        self.output_button = QPushButton("Ändern")
        self.output_button.setToolTip("Ausgabeordner ändern")
        self.output_button.clicked.connect(self.change_output_folder)
        settings_layout.addWidget(self.output_button)
    
        self.settings_button = QPushButton("Einstellungen")
        self.settings_button.setToolTip("Einstellungen anpassen")
        self.settings_button.clicked.connect(self.open_settings)
        settings_layout.addWidget(self.settings_button)
    
        main_layout.addLayout(settings_layout)
    
        self.start_button = QPushButton("Extrahieren")
        self.start_button.setToolTip("Extraktion starten")
        self.start_button.clicked.connect(self.start_extraction)
        main_layout.addWidget(self.start_button)
    
        self.progress_bar = QProgressBar()
        self.progress_bar.setValue(0)
        main_layout.addWidget(self.progress_bar)
    
        # Waveform und Tabelle nebeneinander
        splitter = QSplitter(Qt.Horizontal)
        self.waveform_widget = WaveformWidget()
        splitter.addWidget(self.waveform_widget)
    
        table_layout = QVBoxLayout()
        self.preview_table = QTableWidget()
        self.preview_table.setColumnCount(6)
        self.preview_table.setHorizontalHeaderLabels(["Abspielen", "Titel", "Künstler", "Album", "Start (ms)", "Ende (ms)"])
        self.preview_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.preview_table.setDragEnabled(True)
        self.preview_table.viewport().setAcceptDrops(True)
        self.preview_table.setDragDropOverwriteMode(False)
        self.preview_table.setDropIndicatorShown(True)
        self.preview_table.setSelectionBehavior(QTableWidget.SelectRows)
        self.preview_table.setSelectionMode(QTableWidget.SingleSelection)
        self.preview_table.setDragDropMode(QTableWidget.InternalMove)
        table_layout.addWidget(self.preview_table)
    
        self.save_button = QPushButton("Speichern")
        self.save_button.setToolTip("Tracks speichern")
        self.save_button.clicked.connect(self.save_tracks)
        self.save_button.setEnabled(False)
        table_layout.addWidget(self.save_button)
    
        table_widget = QWidget()
        table_widget.setLayout(table_layout)
        splitter.addWidget(table_widget)
    
        main_layout.addWidget(splitter)
    
        # Audio-Steuerelemente
        controls_layout = QHBoxLayout()
        self.play_button = QPushButton("Play")
        self.play_button.setToolTip("Ausgewählten Track abspielen")
        self.play_button.clicked.connect(self.play_pause_track)
        self.stop_button = QPushButton("Stop")
        self.stop_button.setToolTip("Wiedergabe stoppen")
        self.stop_button.clicked.connect(self.stop_track)
        self.position_slider = QSlider(Qt.Horizontal)
        self.position_slider.sliderMoved.connect(self.set_position)
        controls_layout.addWidget(self.play_button)
        controls_layout.addWidget(self.stop_button)
        controls_layout.addWidget(QLabel("Position:"))
        controls_layout.addWidget(self.position_slider)
        main_layout.addLayout(controls_layout)
    
        self.media_player.positionChanged.connect(self.position_changed)
        self.media_player.durationChanged.connect(self.duration_changed)
    
        # Terminalartiger Anzeigebereich für Logs
        self.log_display = QTextEdit()
        self.log_display.setReadOnly(True)
        self.log_display.setObjectName("LogDisplay")
        main_layout.addWidget(self.log_display)
    
    def append_log_message(self, message):
        self.log_display.append(message)
    
    # Drag-and-Drop-Unterstützung
    def drag_enter_event(self, event):
        if event.mimeData().hasUrls() or event.mimeData().hasText():
            event.accept()
        else:
            event.ignore()
    
    def drop_event(self, event):
        if event.mimeData().hasUrls():
            urls = event.mimeData().urls()
            for url in urls:
                file_path = url.toLocalFile()
                if os.path.isfile(file_path):
                    self.input_field.append(file_path)
        elif event.mimeData().hasText():
            self.input_field.append(event.mimeData().text())
    
    def browse_files(self):
        options = QFileDialog.Options()
        files, _ = QFileDialog.getOpenFileNames(
            self, "Dateien auswählen", "",
            "Audio/Video Dateien (*.mp3 *.wav *.mp4 *.mkv *.flac);;Alle Dateien (*)", options=options)
        if files:
            for file_path in files:
                self.input_field.append(file_path)
    
    def change_output_folder(self):
        options = QFileDialog.Options()
        folder_path = QFileDialog.getExistingDirectory(
            self, "Ausgabeordner auswählen", self.output_field.text(), options=options)
        if folder_path:
            self.output_field.setText(folder_path)
            self.config['DEFAULT']['output_folder'] = folder_path
            save_config(self.config)
    
    def open_settings(self):
        settings_dialog = SettingsDialog(self.config, self)
        if settings_dialog.exec_():
            # Einstellungen wurden aktualisiert
            self.min_silence_len = int(self.config['DEFAULT']['min_silence_len'])
            self.silence_thresh = float(self.config['DEFAULT']['silence_thresh'])
    
    def start_extraction(self):
        input_values = self.input_field.toPlainText().strip().split('\n')
        input_values = [v.strip() for v in input_values if v.strip()]
        if not input_values:
            message = "Bitte geben Sie gültige URLs oder lokale Dateien an."
            self.logger.warning(message)
            return
    
        # Überprüfe die Internetverbindung
        if not self.check_internet_connection():
            message = "Keine Internetverbindung. Bitte prüfen Sie Ihre Netzwerkeinstellungen."
            self.logger.error(message)
            return
    
        # Erstelle den Ausgabeordner, falls nicht vorhanden
        output_folder = self.output_field.text()
        os.makedirs(output_folder, exist_ok=True)
    
        # Deaktiviere UI-Elemente während der Verarbeitung
        self.start_button.setEnabled(False)
        self.browse_button.setEnabled(False)
        self.output_button.setEnabled(False)
        self.settings_button.setEnabled(False)
        self.preview_table.setRowCount(0)
        self.position_slider.setValue(0)
        self.play_button.setEnabled(False)
        self.stop_button.setEnabled(False)
        self.progress_bar.setValue(0)
        self.statusBar().showMessage("Starte Extraktion...")
        self.logger.info("Extraktion gestartet.")
    
        # Lade Einstellungen
        self.min_silence_len = int(self.config['DEFAULT']['min_silence_len'])
        self.silence_thresh = float(self.config['DEFAULT']['silence_thresh'])
    
        # Starte den ExtractionThread
        self.thread = ExtractionThread(
            input_values, output_folder,
            self.min_silence_len, self.silence_thresh
        )
        self.thread.progress.connect(self.update_progress)
        self.thread.finished.connect(self.extraction_finished)
        self.thread.error.connect(self.handle_error)
        self.thread.log.connect(self.log_message)
        self.thread.start()
    
    def check_internet_connection(self):
        try:
            requests.get('https://www.google.com/', timeout=5)
            return True
        except requests.ConnectionError:
            return False
    
    def update_progress(self, value):
        self.progress_bar.setValue(value)
        self.statusBar().showMessage(f"Verarbeitung: {value}% abgeschlossen")
    
    def extraction_finished(self, tracks, full_audio):
        self.progress_bar.setValue(100)
        self.statusBar().showMessage("Extraktion abgeschlossen.")
        self.save_button.setEnabled(True)
        self.extracted_tracks = tracks
        self.full_audio = full_audio
    
        self.populate_preview_table()
    
        # Aktualisiere Waveform
        if self.full_audio:
            self.waveform_widget.set_audio_data(self.full_audio)
            self.waveform_widget.set_segments(self.extracted_tracks)
    
        # Reaktiviere UI-Elemente
        self.start_button.setEnabled(True)
        self.browse_button.setEnabled(True)
        self.output_button.setEnabled(True)
        self.settings_button.setEnabled(True)
        self.play_button.setEnabled(True)
        self.stop_button.setEnabled(True)
    
    def populate_preview_table(self):
        self.preview_table.setRowCount(len(self.extracted_tracks))
        for row, track in enumerate(self.extracted_tracks):
            # Abspielen-Button
            play_button = QPushButton("▶")
            play_button.clicked.connect(lambda checked, r=row: self.select_track(r))
            self.preview_table.setCellWidget(row, 0, play_button)
    
            # Titel
            title_item = QTableWidgetItem(track['title'])
            title_item.setFlags(title_item.flags() | Qt.ItemIsEditable)
            self.preview_table.setItem(row, 1, title_item)
    
            # Künstler
            artist_item = QTableWidgetItem(track['artist'])
            artist_item.setFlags(artist_item.flags() | Qt.ItemIsEditable)
            self.preview_table.setItem(row, 2, artist_item)
    
            # Album
            album_item = QTableWidgetItem(track['album'])
            album_item.setFlags(album_item.flags() | Qt.ItemIsEditable)
            self.preview_table.setItem(row, 3, album_item)
    
            # Startzeit
            start_item = QTableWidgetItem(str(track['start_ms']))
            start_item.setFlags(start_item.flags() | Qt.ItemIsEditable)
            self.preview_table.setItem(row, 4, start_item)
    
            # Endzeit
            end_item = QTableWidgetItem(str(track['end_ms']))
            end_item.setFlags(end_item.flags() | Qt.ItemIsEditable)
            self.preview_table.setItem(row, 5, end_item)
    
    def handle_error(self, error_message):
        self.logger.error(error_message)
        self.statusBar().showMessage("Fehler aufgetreten.")
    
        # Reaktiviere UI-Elemente
        self.start_button.setEnabled(True)
        self.browse_button.setEnabled(True)
        self.output_button.setEnabled(True)
        self.settings_button.setEnabled(True)
    
    def log_message(self, message):
        self.logger.info(message)
    
    def select_track(self, row):
        if row >= len(self.extracted_tracks):
            return
        track = self.extracted_tracks[row]
        path = track['file_path']
        if os.path.exists(path):
            try:
                self.current_track_row = row
                url = QUrl.fromLocalFile(path)
                content = QMediaContent(url)
                self.media_player.setMedia(content)
                self.media_player.play()
                self.play_button.setText("Pause")
            except Exception as e:
                error_msg = f"Fehler beim Abspielen: {str(e)}"
                self.logger.error(error_msg)
        else:
            error_msg = "Die ausgewählte MP3-Datei wurde nicht gefunden."
            self.logger.error(error_msg)
    
    def play_pause_track(self):
        if self.media_player.state() == QMediaPlayer.PlayingState:
            self.media_player.pause()
            self.play_button.setText("Play")
        elif self.media_player.state() == QMediaPlayer.PausedState:
            self.media_player.play()
            self.play_button.setText("Pause")
        else:
            if self.current_track_row is None:
                self.select_track(0)
            else:
                self.media_player.play()
                self.play_button.setText("Pause")
    
    def stop_track(self):
        self.media_player.stop()
        self.play_button.setText("Play")
    
    def position_changed(self, position):
        self.position_slider.setValue(position)
    
    def duration_changed(self, duration):
        self.position_slider.setRange(0, duration)
    
    def set_position(self, position):
        self.media_player.setPosition(position)
    
    def save_tracks(self):
        # Aktuelle Daten aus der Tabelle holen
        for row in range(self.preview_table.rowCount()):
            title = self.preview_table.item(row, 1).text()
            artist = self.preview_table.item(row, 2).text()
            album = self.preview_table.item(row, 3).text()
            start_ms = int(self.preview_table.item(row, 4).text())
            end_ms = int(self.preview_table.item(row, 5).text())
            self.extracted_tracks[row]['title'] = title
            self.extracted_tracks[row]['artist'] = artist
            self.extracted_tracks[row]['album'] = album
            self.extracted_tracks[row]['start_ms'] = start_ms
            self.extracted_tracks[row]['end_ms'] = end_ms
    
        # Speichere die Tracks mit Metadaten
        for track in self.extracted_tracks:
            self.save_track_with_metadata(track)
    
        self.logger.info("Alle Tracks wurden erfolgreich gespeichert.")
        self.statusBar().showMessage("Alle Tracks wurden erfolgreich gespeichert.")
    
    def save_track_with_metadata(self, track):
        output_folder = self.output_field.text()
        sanitized_title = self.sanitize_filename(track['title'])
        output_path = os.path.join(output_folder, f"{sanitized_title}.mp3")
        try:
            # Schneide das Segment basierend auf den neuen Start- und Endzeiten
            segment = self.full_audio[track['start_ms']:track['end_ms']]
            # Exportiere das Segment
            segment.export(output_path, format='mp3')
    
            # Füge Metadaten hinzu
            self.add_metadata(output_path, track)
            self.logger.info(f"Track '{track['title']}' gespeichert.")
        except Exception as e:
            error_msg = f"Fehler beim Speichern von {track['title']}: {str(e)}"
            self.logger.error(error_msg)
    
    def add_metadata(self, file_path, track):
        try:
            # Lade bestehende Tags oder erstelle neue
            try:
                audio = ID3(file_path)
            except ID3NoHeaderError:
                audio = ID3()
    
            # Aktualisiere oder füge Metadaten hinzu
            audio["TIT2"] = TIT2(encoding=3, text=track['title'])
            audio["TPE1"] = TPE1(encoding=3, text=track['artist'])
            audio["TALB"] = TALB(encoding=3, text=track['album'])
    
            if track.get('cover_path') and os.path.exists(track['cover_path']):
                with open(track['cover_path'], 'rb') as cover_file:
                    audio["APIC"] = APIC(
                        encoding=3,
                        mime='image/jpeg',
                        type=3,  # cover art
                        desc='Cover',
                        data=cover_file.read()
                    )
            audio.save(file_path)
        except Exception as e:
            self.logger.error(f"Fehler beim Hinzufügen von Metadaten: {str(e)}")
    
    def sanitize_filename(self, name):
        # Entferne ungültige Zeichen aus dem Dateinamen
        return "".join(c for c in name if c.isalnum() or c in " ._-").rstrip()
    
    def closeEvent(self, event):
        self.media_player.stop()
        event.accept()
    

    Anwendung starten

    def main(): app = QApplication(sys.argv)

    window = MusicExtractorApp()
    window.show()
    sys.exit(app.exec_())
    

    if name == "main": main()

  2. Assistant

    Hier ist das verbesserte Skript entsprechend Ihrer Anforderungen:

    import sys
    import os
    import tempfile
    import re
    import logging
    import requests
    import numpy as np
    import urllib.parse
    import speech_recognition as sr
    from PyQt5.QtCore import Qt, QThread, pyqtSignal, QUrl
    from PyQt5.QtWidgets import (
        QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
        QLineEdit, QPushButton, QLabel, QFileDialog, QProgressBar,
        QTableWidget, QTableWidgetItem, QHeaderView, QSlider,
        QDialog, QFormLayout, QSpinBox, QDoubleSpinBox, QTextEdit, QSplitter
    )
    from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent
    from PyQt5.QtGui import QPainter, QColor, QPen
    
    try:
        import yt_dlp as youtube_dl
    except ImportError:
        import youtube_dl
    
    from pydub import AudioSegment
    from mutagen.id3 import ID3, TIT2, TALB, TPE1, APIC, ID3NoHeaderError
    import librosa  # Librosa wird immer importiert
    
    from bs4 import BeautifulSoup
    from configparser import ConfigParser
    
    from io import BytesIO
    
    # Logging konfigurieren
    logging.basicConfig(
        filename='music_extractor.log',
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )
    
    logger = logging.getLogger(__name__)
    
    # Konfigurationsdatei verwalten
    CONFIG_FILE = 'settings.ini'
    
    def load_config():
        config = ConfigParser()
        if not os.path.exists(CONFIG_FILE):
            config['DEFAULT'] = {
                'output_folder': os.path.expanduser("~/Music/ExtractedTracks"),
                'min_silence_len': '1000',
                'silence_thresh': '-40'
            }
            with open(CONFIG_FILE, 'w') as configfile:
                config.write(configfile)
        else:
            config.read(CONFIG_FILE)
        return config
    
    def save_config(config):
        with open(CONFIG_FILE, 'w') as configfile:
            config.write(configfile)
    
    # Custom Logger Handler für QTextEdit mit Signals
    class QTextEditLogger(logging.Handler, QWidget):
        new_record = pyqtSignal(str)
    
        def __init__(self, parent=None):
            super().__init__()
            QWidget.__init__(self)
            self.widget = parent
    
        def emit(self, record):
            msg = self.format(record)
            self.new_record.emit(msg)
    
    # Worker-Thread für die Verarbeitung
    class ExtractionThread(QThread):
        progress = pyqtSignal(int)
        finished = pyqtSignal(list, AudioSegment)  # Liste der Tracks und vollständiges Audio
        error = pyqtSignal(str)
        log = pyqtSignal(str)
        download_progress = pyqtSignal(int, float, int)  # progress_percent, speed, eta
        tracks_ready = pyqtSignal(list, AudioSegment)  # Liste der Tracks und AudioSegment
    
        def __init__(self, input_values, output_folder, min_silence_len, silence_thresh):
            super().__init__()
            self.input_values = input_values  # Liste von Eingabewerten
            self.output_folder = output_folder
            self.is_interrupted = False
            self.min_silence_len = min_silence_len
            self.silence_thresh = silence_thresh
    
        def run(self):
            try:
                all_extracted_tracks = []
                full_audio = None  # Initialisiere full_audio hier
                total_inputs = len(self.input_values)
                for idx, input_value in enumerate(self.input_values):
                    if self.is_interrupted:
                        break
    
                    self.log.emit(f"Verarbeite Eingabe {idx+1}/{total_inputs}: {input_value}")
                    # Temporärer Arbeitsbereich
                    with tempfile.TemporaryDirectory() as temp_dir:
                        audio_file, video_info = self.download_and_extract_audio(input_value, temp_dir)
                        if audio_file:
                            full_audio = AudioSegment.from_mp3(audio_file)
                        else:
                            error_msg = f"Fehler beim Verarbeiten von {input_value}."
                            self.error.emit(error_msg)
                            self.log.emit(error_msg)
                            continue  # Fährt mit der nächsten Eingabe fort
    
                        # Versuche, die Trackliste aus der Videobeschreibung zu extrahieren
                        tracklist = self.extract_tracklist_from_description(video_info)
                        if tracklist:
                            self.log.emit("Trackliste aus Videobeschreibung extrahiert.")
                            # Segmentiere das Audio basierend auf der extrahierten Trackliste
                            segments = self.segment_audio_by_tracklist(full_audio, tracklist)
                        else:
                            self.log.emit("Keine Trackliste gefunden. Verwende akustische Analyse.")
                            # Verwende akustische Analyse zur Segmentierung
                            segments = self.segment_audio_by_acoustic_analysis(full_audio)
                            if not segments:
                                error_msg = "Keine Segmente im Audio gefunden."
                                self.error.emit(error_msg)
                                self.log.emit(error_msg)
                                continue  # Fährt mit der nächsten Eingabe fort
    
                        # Verarbeite die Segmente und extrahiere Metadaten
                        extracted_tracks = self.process_segments(segments, temp_dir, video_info, full_audio)
                        all_extracted_tracks.extend(extracted_tracks)
                        self.log.emit(f"Verarbeitung von {input_value} abgeschlossen.")
    
                        # Teile die gefundenen Tracks dem Hauptthread mit
                        self.tracks_ready.emit(extracted_tracks, full_audio)
    
                    # Aktualisiere den Fortschritt
                    progress = int(((idx + 1) / total_inputs) * 100)
                    self.progress.emit(progress)
    
                # Beende den Prozess und gebe auch das vollständige Audio aus
                if full_audio is None:
                    full_audio = AudioSegment.empty()  # Erstellt ein leeres AudioSegment
    
                self.finished.emit(all_extracted_tracks, full_audio)
                self.progress.emit(100)
                self.log.emit("Extraktion aller Eingaben abgeschlossen.")
            except Exception as e:
                error_msg = f"Ein unerwarteter Fehler ist aufgetreten: {str(e)}"
                self.error.emit(error_msg)
                self.log.emit(error_msg)
    
        def progress_hook(self, d):
            if d['status'] == 'downloading':
                downloaded = d.get('downloaded_bytes', 0)
                total = d.get('total_bytes', d.get('total_bytes_estimate', 0))
                if total > 0:
                    percent = int(downloaded * 100 / total)
                else:
                    percent = 0
                speed = d.get('speed', 0)
                eta = d.get('eta', 0)
                # Emit a signal with progress info
                self.download_progress.emit(percent, speed, eta)
            elif d['status'] == 'finished':
                self.download_progress.emit(100, 0, 0)
    
        def download_and_extract_audio(self, input_value, temp_dir):
            """
            Lädt die Audioquelle herunter und extrahiert das Audio.
            """
            try:
                if input_value.startswith("http"):
                    ydl_opts = {
                        'format': 'bestaudio/best',
                        'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
                        'quiet': True,
                        'no_warnings': True,
                        'progress_hooks': [self.progress_hook],
                    }
                    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
                        info_dict = ydl.extract_info(input_value, download=True)
                        video_title = info_dict.get('title', "Unbekanntes Album")
                        video_description = info_dict.get('description', "")
                        thumbnail_url = info_dict.get('thumbnail', None)
                        ext = info_dict.get('ext', 'mp3')
                        downloaded_file = ydl.prepare_filename(info_dict)
    
                        # Konvertiere zu mp3 falls nötig
                        if ext != 'mp3':
                            audio = AudioSegment.from_file(downloaded_file)
                            audio_file = os.path.join(temp_dir, f"{video_title}.mp3")
                            audio.export(audio_file, format='mp3')
                        else:
                            audio_file = downloaded_file
                else:
                    video_title = os.path.splitext(os.path.basename(input_value))[0]
                    video_description = ""
                    thumbnail_url = None
                    audio = AudioSegment.from_file(input_value)
                    audio_file = os.path.join(temp_dir, f"{video_title}.mp3")
                    audio.export(audio_file, format='mp3')
    
                video_info = {
                    'title': video_title,
                    'description': video_description,
                    'thumbnail_url': thumbnail_url
                }
                self.log.emit(f"Audio von {input_value} erfolgreich heruntergeladen und extrahiert.")
                return audio_file, video_info
            except Exception as e:
                error_msg = f"Fehler beim Herunterladen oder Extrahieren des Audios: {str(e)}"
                self.error.emit(error_msg)
                self.log.emit(error_msg)
                return None, None
    
        def extract_tracklist_from_description(self, video_info):
            """
            Versucht, die Trackliste aus der Videobeschreibung zu extrahieren.
            """
            description = video_info.get('description', '')
            # Regulärer Ausdruck zum Finden von Zeitstempeln und Titeln
            pattern = r'((\d{1,2}:)?\d{1,2}:\d{2})\s*[-–~—–]\s*(.+)'
            matches = re.findall(pattern, description)
            if matches:
                tracklist = []
                for match in matches:
                    time_str = match[0]
                    title = match[3].strip()
                    # Konvertiere Zeitstempel in Millisekunden
                    time_ms = self.timestamp_to_milliseconds(time_str)
                    tracklist.append({'time_ms': time_ms, 'title': title})
                self.log.emit("Trackliste erfolgreich aus Beschreibung extrahiert.")
                return tracklist
            else:
                self.log.emit("Keine Trackliste in der Beschreibung gefunden.")
                return None
    
        def timestamp_to_milliseconds(self, timestamp):
            """
            Konvertiert einen Zeitstempel im Format HH:MM:SS oder MM:SS in Millisekunden.
            """
            parts = timestamp.strip().split(':')
            parts = [int(p) for p in parts]
            if len(parts) == 3:
                hours, minutes, seconds = parts
            elif len(parts) == 2:
                hours = 0
                minutes, seconds = parts
            else:
                hours = 0
                minutes = 0
                seconds = parts[0]
            total_ms = ((hours * 3600) + (minutes * 60) + seconds) * 1000
            return total_ms
    
        def segment_audio_by_tracklist(self, audio, tracklist):
            """
            Segmentiert das Audio basierend auf der extrahierten Trackliste.
            """
            try:
                segments = []
                total_tracks = len(tracklist)
                for idx in range(total_tracks):
                    start_time = tracklist[idx]['time_ms']
                    if idx + 1 < total_tracks:
                        end_time = tracklist[idx + 1]['time_ms']
                    else:
                        end_time = len(audio)
                    segment = audio[start_time:end_time]
                    segments.append({
                        'start_ms': start_time,
                        'end_ms': end_time,
                        'title': tracklist[idx]['title'],
                        'segment': segment
                    })
                self.log.emit("Audio erfolgreich anhand der Trackliste segmentiert.")
                return segments
            except Exception as e:
                error_msg = f"Fehler beim Segmentieren des Audios: {str(e)}"
                self.error.emit(error_msg)
                self.log.emit(error_msg)
                return None
    
        def segment_audio_by_acoustic_analysis(self, audio):
            """
            Segmentiert das Audio basierend auf akustischer Analyse.
            """
            try:
                # Konvertiere AudioSegment zu numpy Array
                y = np.array(audio.get_array_of_samples())
                sr = audio.frame_rate
    
                if audio.channels > 1:
                    y = y.reshape((-1, audio.channels))
                    y = y.mean(axis=1)
    
                # Verwende Librosa für die Analyse
                tempo, beat_frames = librosa.beat.beat_track(y=y.astype(np.float32), sr=sr)
                beats = librosa.frames_to_time(beat_frames, sr=sr)
                times_ms = (beats * 1000).astype(int)
    
                # Generiere Segmente basierend auf Zeiten
                segments = []
                start_times = [0] + times_ms.tolist()
                end_times = times_ms.tolist() + [len(audio)]
                for idx, (start_ms, end_ms) in enumerate(zip(start_times, end_times)):
                    segment = audio[start_ms:end_ms]
                    segments.append({
                        'start_ms': start_ms,
                        'end_ms': end_ms,
                        'title': f"Track {idx + 1}",
                        'segment': segment
                    })
                self.log.emit("Audio erfolgreich durch akustische Analyse segmentiert.")
                return segments
            except Exception as e:
                error_msg = f"Fehler bei der akustischen Analyse des Audios: {str(e)}"
                self.error.emit(error_msg)
                self.log.emit(error_msg)
                return None
    
        def process_segments(self, segments, temp_dir, video_info, full_audio):
            """
            Verarbeitet die Segmente, extrahiert Metadaten und bereitet sie für die Vorschau vor.
            """
            extracted_tracks = []
            total_segments = len(segments)
            for idx, data in enumerate(segments):
                if self.is_interrupted:
                    break
    
                segment = data['segment']
                start_ms = data['start_ms']
                end_ms = data['end_ms']
                title = data.get('title', f"Track {idx + 1}")
                artist = "Unbekannter Künstler"
                album = video_info.get('title', "Unbekanntes Album")
    
                # Speichere das Segment temporär, um einen Dateipfad zu haben
                segment_path = os.path.join(temp_dir, f"segment_{idx + 1}.mp3")
                segment.export(segment_path, format='mp3')
                data['file_path'] = segment_path
    
                # Identifiziere den Track
                track_info = self.identify_track_by_spectral_and_text(segment_path)
                if track_info:
                    title = track_info.get('title', title)
                    artist = track_info.get('artist', artist)
    
                # Versuche, Metadaten automatisch zu finden
                metadata = self.fetch_metadata(title, artist)
                if metadata:
                    title = metadata.get('title', title)
                    artist = metadata.get('artist', artist)
                    album = metadata.get('album', album)
                    cover_url = metadata.get('cover_url', None)
                else:
                    cover_url = None
    
                # Lade das Coverbild herunter, falls vorhanden
                if cover_url:
                    cover_path = os.path.join(temp_dir, f"cover_{idx}.jpg")
                    self.download_cover(cover_url, cover_path)
                else:
                    cover_path = None
    
                track_info = {
                    'title': title,
                    'artist': artist,
                    'album': album,
                    'file_path': segment_path,
                    'cover_path': cover_path,
                    'start_ms': start_ms,
                    'end_ms': end_ms
                }
                extracted_tracks.append(track_info)
                progress = int(((idx + 1) / total_segments) * 100)
                self.progress.emit(progress)
                self.log.emit(f"Segment {idx + 1}/{total_segments} verarbeitet.")
    
            return extracted_tracks
    
        def identify_track_by_spectral_and_text(self, audio_file_path):
            try:
                # Spektrale Analyse
                y, sr = librosa.load(audio_file_path, duration=30)
                mid_point = len(y) // 2
                sample = y[max(0, mid_point - sr*7):min(len(y), mid_point + sr*8)]
    
                mfcc = librosa.feature.mfcc(y=sample, sr=sr, n_mfcc=13)
                chroma = librosa.feature.chroma_stft(y=sample, sr=sr)
                tempo, _ = librosa.beat.beat_track(y=sample, sr=sr)
    
                spectral_features = np.concatenate([
                    np.mean(mfcc, axis=1),
                    np.mean(chroma, axis=1),
                    [tempo]
                ])
    
                # Textextraktion
                recognizer = sr.Recognizer()
                audio_segment = AudioSegment.from_file(audio_file_path)
                duration_ms = len(audio_segment)
                mid_point_ms = duration_ms / 2
                audio_slice = audio_segment[max(0, int(mid_point_ms - 5000)):min(duration_ms, int(mid_point_ms + 5000))]
                audio_bytes = BytesIO()
                audio_slice.export(audio_bytes, format="wav")
                audio_bytes.seek(0)
                with sr.AudioFile(audio_bytes) as source:
                    audio = recognizer.record(source)
                    try:
                        text = recognizer.recognize_google(audio, language="de-DE")
                    except sr.UnknownValueError:
                        text = ""
    
                # Kombinierte Suche
                search_query = f"{text} {' '.join(map(str, spectral_features))}"
                return self.search_track_online(search_query)
    
            except Exception as e:
                self.log.emit(f"Fehler bei der Spektral- und Textanalyse: {str(e)}")
                return None
    
        def search_track_online(self, query):
            if not self.check_internet_connection():
                self.log.emit("Keine Internetverbindung verfügbar. Online-Suche übersprungen.")
                return None
    
            search_url = f"https://api.deezer.com/search?q={urllib.parse.quote(query)}"
            headers = {'User-Agent': 'Mozilla/5.0'}
    
            try:
                response = requests.get(search_url, headers=headers, timeout=10)
                response.raise_for_status()
                data = response.json()
                if 'data' in data and len(data['data']) > 0:
                    first_result = data['data'][0]
                    artist = first_result['artist']['name']
                    title = first_result['title']
                    return {'artist': artist, 'title': title}
                else:
                    return None
            except requests.exceptions.RequestException as e:
                self.log.emit(f"Fehler bei der Online-Suche: {str(e)}")
                return None
    
        def fetch_metadata(self, track_title, artist_name=None):
            """
            Sucht nach Metadaten zu einem gegebenen Titel mittels der MusicBrainz API.
            """
            try:
                query = f'"{track_title}"'
                if artist_name:
                    query += f' AND artist:"{artist_name}"'
                url = f"https://musicbrainz.org/ws/2/recording/?query={urllib.parse.quote(query)}&fmt=json&limit=1"
                headers = {'User-Agent': 'MusicExtractor/1.0 (email@example.com)'}
                response = requests.get(url, headers=headers)
                if response.status_code == 200:
                    data = response.json()
                    if 'recordings' in data and data['recordings']:
                        recording = data['recordings'][0]
                        title = recording.get('title', track_title)
                        artist = recording['artist-credit'][0]['name'] if 'artist-credit' in recording else "Unbekannter Künstler"
                        album = recording['releases'][0]['title'] if 'releases' in recording and recording['releases'] else "Unbekanntes Album"
                        return {
                            'title': title,
                            'artist': artist,
                            'album': album,
                            'cover_url': self.fetch_cover_url(recording)
                        }
                return None
            except Exception:
                return None
    
        def fetch_cover_url(self, recording):
            """
            Versucht, die Cover-URL für eine Aufnahme zu erhalten.
            """
            try:
                if 'releases' in recording and recording['releases']:
                    release = recording['releases'][0]
                    mbid = release.get('id', None)
                    if mbid:
                        url = f"https://coverartarchive.org/release/{mbid}"
                        response = requests.get(url)
                        if response.status_code == 200:
                            data = response.json()
                            if 'images' in data and data['images']:
                                return data['images'][0]['image']
                return None
            except Exception:
                return None
    
        def download_cover(self, url, path):
            """
            Lädt das Coverbild von der gegebenen URL herunter und speichert es unter dem angegebenen Pfad.
            """
            try:
                response = requests.get(url)
                if response.status_code == 200:
                    with open(path, 'wb') as f:
                        f.write(response.content)
            except Exception:
                pass
    
        def check_internet_connection(self):
            try:
                requests.get('https://www.google.com/', timeout=5)
                return True
            except requests.ConnectionError:
                return False
    
    # Widget zur Anzeige der Waveform
    class WaveformWidget(QWidget):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.audio_data = None
            self.segments = []
            self.setMinimumHeight(200)
    
        def set_audio_data(self, audio_data):
            self.audio_data = audio_data
            self.update()
    
        def set_segments(self, segments):
            self.segments = segments
            self.update()
    
        def paintEvent(self, event):
            painter = QPainter(self)
            rect = self.rect()
            painter.fillRect(rect, QColor('#2E2E2E'))
    
            if not self.audio_data:
                return
    
            pen = QPen(QColor('#4CAF50'))
            painter.setPen(pen)
    
            data = np.array(self.audio_data.get_array_of_samples())
            sample_rate = self.audio_data.frame_rate
    
            if self.audio_data.channels > 1:
                data = data.reshape((-1, self.audio_data.channels))
                data = data.mean(axis=1)
    
            data = data[::max(1, int(len(data)/rect.width()))]  # Downsampling
            h_center = rect.height() / 2
            max_amplitude = np.max(np.abs(data))
            if max_amplitude == 0:
                max_amplitude = 1
            amplitude = data / max_amplitude * (rect.height() / 2)
    
            for x in range(len(amplitude)-1):
                x1 = x
                y1 = int(h_center - amplitude[x])
                x2 = x + 1
                y2 = int(h_center - amplitude[x+1])
                painter.drawLine(x1, y1, x2, y2)
    
            # Zeichne Segmentgrenzen
            if self.segments:
                pen = QPen(QColor('#FF0000'))
                pen.setWidth(2)
                painter.setPen(pen)
                total_duration = len(self.audio_data)
                for segment in self.segments:
                    start_x = int(segment['start_ms'] / total_duration * rect.width())
                    painter.drawLine(start_x, 0, start_x, rect.height())
    
    # Dialog für Einstellungen
    class SettingsDialog(QDialog):
        def __init__(self, config, parent=None):
            super().__init__(parent)
            self.setWindowTitle("Einstellungen")
            self.config = config
            self.setup_ui()
    
        def setup_ui(self):
            layout = QFormLayout(self)
    
            # Min Silence Length
            self.min_silence_len_spinbox = QSpinBox()
            self.min_silence_len_spinbox.setRange(100, 10000)
            self.min_silence_len_spinbox.setValue(int(self.config['DEFAULT']['min_silence_len']))
            self.min_silence_len_spinbox.setSuffix(" ms")
            layout.addRow("Minimale Stillelänge:", self.min_silence_len_spinbox)
    
            # Silence Threshold
            self.silence_thresh_spinbox = QDoubleSpinBox()
            self.silence_thresh_spinbox.setRange(-100.0, 0.0)
            self.silence_thresh_spinbox.setSingleStep(1.0)
            self.silence_thresh_spinbox.setValue(float(self.config['DEFAULT']['silence_thresh']))
            self.silence_thresh_spinbox.setSuffix(" dBFS")
            layout.addRow("Stille-Schwellenwert:", self.silence_thresh_spinbox)
    
            # Buttons
            buttons_layout = QHBoxLayout()
            self.ok_button = QPushButton("OK")
            self.ok_button.clicked.connect(self.accept)
            self.cancel_button = QPushButton("Abbrechen")
            self.cancel_button.clicked.connect(self.reject)
            buttons_layout.addWidget(self.ok_button)
            buttons_layout.addWidget(self.cancel_button)
            layout.addRow(buttons_layout)
    
        def accept(self):
            self.config['DEFAULT']['min_silence_len'] = str(self.min_silence_len_spinbox.value())
            self.config['DEFAULT']['silence_thresh'] = str(self.silence_thresh_spinbox.value())
            save_config(self.config)
            super().accept()
    
    # Hauptanwendungsklasse
    class MusicExtractorApp(QMainWindow):
        def __init__(self):
            super().__init__()
            self.config = load_config()
            self.extracted_tracks = []
            self.media_player = QMediaPlayer()
            self.current_track_row = None
            self.full_audio = None
            self.thread = None
    
            self.init_ui()
    
            self.logger = logging.getLogger(__name__)
            self.logger.setLevel(logging.INFO)
            text_edit_handler = QTextEditLogger()
            text_edit_handler.new_record.connect(self.append_log_message)
            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
            text_edit_handler.setFormatter(formatter)
            self.logger.addHandler(text_edit_handler)
    
        def init_ui(self):
            self.setWindowTitle("Music Extractor")
            self.setGeometry(100, 100, 1200, 800)
            self.apply_styles()
    
            central_widget = QWidget()
            self.setCentralWidget(central_widget)
            main_layout = QVBoxLayout(central_widget)
    
            self.setup_widgets()
    
            self.statusBar().showMessage('Bereit')
    
        def apply_styles(self):
            style = """
            QMainWindow {
                background-color: #2E2E2E;
                color: #FFFFFF;
            }
            QPushButton {
                background-color: #4CAF50;
                border: none;
                color: white;
                padding: 8px 16px;
                text-align: center;
                text-decoration: none;
                font-size: 14px;
                margin: 4px 2px;
                border-radius: 8px;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
            QLineEdit, QTextEdit {
                padding: 5px;
                border: 1px solid #ccc;
                border-radius: 4px;
                font-size: 14px;
                color: #FFFFFF;
                background-color: #3E3E3E;
            }
            QLabel {
                font-size: 14px;
                color: #FFFFFF;
            }
            QTableWidget {
                background-color: #3E3E3E;
                color: #FFFFFF;
                border: 1px solid #555;
            }
            QHeaderView::section {
                background-color: #555555;
                color: white;
                padding: 4px;
                border: 1px solid #777777;
            }
            QTableWidget::item:selected {
                background-color: #4CAF50;
            }
            QTextEdit#LogDisplay {
                background-color: #1E1E1E;
                color: #00FF00;
                font-family: Consolas, Courier, monospace;
            }
            QProgressBar {
                border: 1px solid #555;
                border-radius: 5px;
                text-align: center;
                color: #FFFFFF;
            }
            QProgressBar::chunk {
                background-color: #4CAF50;
                width: 20px;
            }
            QSlider::groove:horizontal {
                border: 1px solid #444444;
                height: 8px;
                background: #3E3E3E;
                margin: 0px;
                border-radius: 4px;
            }
            QSlider::handle:horizontal {
                background: #4CAF50;
                border: 1px solid #4CAF50;
                width: 16px;
                height: 16px;
                margin: -4px 0;
                border-radius: 8px;
            }
            """
            self.setStyleSheet(style)
    
        def setup_widgets(self):
            central_widget = self.centralWidget()
            main_layout = central_widget.layout()
    
            # Eingabebereich mit Unterstützung für mehrere Eingaben
            input_layout = QHBoxLayout()
            self.input_field = QTextEdit()
            self.input_field.setPlaceholderText("Geben Sie Links oder lokale Dateien an, jeweils in einer neuen Zeile...")
            self.input_field.setAcceptDrops(True)
            self.input_field.dragEnterEvent = self.drag_enter_event
            self.input_field.dropEvent = self.drop_event
            input_layout.addWidget(self.input_field)
            self.browse_button = QPushButton("Durchsuchen")
            self.browse_button.setToolTip("Wählen Sie lokale Dateien aus")
            self.browse_button.clicked.connect(self.browse_files)
            input_layout.addWidget(self.browse_button)
            main_layout.addLayout(input_layout)
    
            settings_layout = QHBoxLayout()
            self.output_label = QLabel("Ausgabeordner:")
            settings_layout.addWidget(self.output_label)
            self.output_field = QLineEdit(self.config['DEFAULT']['output_folder'])
            settings_layout.addWidget(self.output_field)
            self.output_button = QPushButton("Ändern")
            self.output_button.setToolTip("Ausgabeordner ändern")
            self.output_button.clicked.connect(self.change_output_folder)
            settings_layout.addWidget(self.output_button)
    
            self.settings_button = QPushButton("Einstellungen")
            self.settings_button.setToolTip("Einstellungen anpassen")
            self.settings_button.clicked.connect(self.open_settings)
            settings_layout.addWidget(self.settings_button)
    
            main_layout.addLayout(settings_layout)
    
            self.start_button = QPushButton("Extrahieren")
            self.start_button.setToolTip("Extraktion starten")
            self.start_button.clicked.connect(self.start_extraction)
            main_layout.addWidget(self.start_button)
    
            self.progress_bar = QProgressBar()
            self.progress_bar.setValue(0)
            main_layout.addWidget(self.progress_bar)
    
            # Waveform und Tabelle nebeneinander
            splitter = QSplitter(Qt.Horizontal)
            self.waveform_widget = WaveformWidget()
            splitter.addWidget(self.waveform_widget)
    
            table_layout = QVBoxLayout()
            self.preview_table = QTableWidget()
            self.preview_table.setColumnCount(6)
            self.preview_table.setHorizontalHeaderLabels(["Abspielen", "Titel", "Künstler", "Album", "Start (ms)", "Ende (ms)"])
            self.preview_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
            self.preview_table.setDragEnabled(True)
            self.preview_table.viewport().setAcceptDrops(True)
            self.preview_table.setDragDropOverwriteMode(False)
            self.preview_table.setDropIndicatorShown(True)
            self.preview_table.setSelectionBehavior(QTableWidget.SelectRows)
            self.preview_table.setSelectionMode(QTableWidget.SingleSelection)
            self.preview_table.setDragDropMode(QTableWidget.InternalMove)
            table_layout.addWidget(self.preview_table)
    
            self.save_button = QPushButton("Speichern")
            self.save_button.setToolTip("Tracks speichern")
            self.save_button.clicked.connect(self.save_tracks)
            self.save_button.setEnabled(False)
            table_layout.addWidget(self.save_button)
    
            table_widget = QWidget()
            table_widget.setLayout(table_layout)
            splitter.addWidget(table_widget)
    
            main_layout.addWidget(splitter)
    
            # Audio-Steuerelemente
            controls_layout = QHBoxLayout()
            self.play_button = QPushButton("Play")
            self.play_button.setToolTip("Ausgewählten Track abspielen")
            self.play_button.clicked.connect(self.play_pause_track)
            self.stop_button = QPushButton("Stop")
            self.stop_button.setToolTip("Wiedergabe stoppen")
            self.stop_button.clicked.connect(self.stop_track)
            self.position_slider = QSlider(Qt.Horizontal)
            self.position_slider.sliderMoved.connect(self.set_position)
            controls_layout.addWidget(self.play_button)
            controls_layout.addWidget(self.stop_button)
            self.position_label = QLabel("Position:")
            controls_layout.addWidget(self.position_label)
            controls_layout.addWidget(self.position_slider)
            main_layout.addLayout(controls_layout)
    
            self.media_player.positionChanged.connect(self.position_changed)
            self.media_player.durationChanged.connect(self.duration_changed)
    
            # Terminalartiger Anzeigebereich für Logs
            self.log_display = QTextEdit()
            self.log_display.setReadOnly(True)
            self.log_display.setObjectName("LogDisplay")
            main_layout.addWidget(self.log_display)
    
        def append_log_message(self, message):
            self.log_display.append(message)
    
        # Drag-and-Drop-Unterstützung
        def drag_enter_event(self, event):
            if event.mimeData().hasUrls() or event.mimeData().hasText():
                event.accept()
            else:
                event.ignore()
    
        def drop_event(self, event):
            if event.mimeData().hasUrls():
                urls = event.mimeData().urls()
                for url in urls:
                    file_path = url.toLocalFile()
                    if os.path.isfile(file_path):
                        self.input_field.append(file_path)
            elif event.mimeData().hasText():
                self.input_field.append(event.mimeData().text())
    
        def browse_files(self):
            options = QFileDialog.Options()
            files, _ = QFileDialog.getOpenFileNames(
                self, "Dateien auswählen", "",
                "Audio/Video Dateien (*.mp3 *.wav *.mp4 *.mkv *.flac);;Alle Dateien (*)", options=options)
            if files:
                for file_path in files:
                    self.input_field.append(file_path)
    
        def change_output_folder(self):
            options = QFileDialog.Options()
            folder_path = QFileDialog.getExistingDirectory(
                self, "Ausgabeordner auswählen", self.output_field.text(), options=options)
            if folder_path:
                self.output_field.setText(folder_path)
                self.config['DEFAULT']['output_folder'] = folder_path
                save_config(self.config)
    
        def open_settings(self):
            settings_dialog = SettingsDialog(self.config, self)
            if settings_dialog.exec_():
                # Einstellungen wurden aktualisiert
                self.min_silence_len = int(self.config['DEFAULT']['min_silence_len'])
                self.silence_thresh = float(self.config['DEFAULT']['silence_thresh'])
    
        def start_extraction(self):
            input_values = self.input_field.toPlainText().strip().split('\n')
            input_values = [v.strip() for v in input_values if v.strip()]
            if not input_values:
                message = "Bitte geben Sie gültige URLs oder lokale Dateien an."
                self.logger.warning(message)
                return
    
            # Erstelle den Ausgabeordner, falls nicht vorhanden
            output_folder = self.output_field.text()
            os.makedirs(output_folder, exist_ok=True)
    
            # Deaktiviere UI-Elemente während der Verarbeitung
            self.start_button.setEnabled(False)
            self.browse_button.setEnabled(False)
            self.output_button.setEnabled(False)
            self.settings_button.setEnabled(False)
            self.preview_table.setRowCount(0)
            self.position_slider.setValue(0)
            self.play_button.setEnabled(False)
            self.stop_button.setEnabled(False)
            self.progress_bar.setValue(0)
            self.statusBar().showMessage("Starte Extraktion...")
            self.logger.info("Extraktion gestartet.")
    
            # Lade Einstellungen
            self.min_silence_len = int(self.config['DEFAULT']['min_silence_len'])
            self.silence_thresh = float(self.config['DEFAULT']['silence_thresh'])
    
            # Starte den ExtractionThread
            self.thread = ExtractionThread(
                input_values, output_folder,
                self.min_silence_len, self.silence_thresh
            )
            self.thread.progress.connect(self.update_progress)
            self.thread.finished.connect(self.extraction_finished)
            self.thread.error.connect(self.handle_error)
            self.thread.log.connect(self.log_message)
            self.thread.download_progress.connect(self.update_download_progress)
            self.thread.tracks_ready.connect(self.partial_extraction_finished)
            self.thread.start()
    
        def update_download_progress(self, percent, speed, eta):
            # Aktualisiere Fortschrittsbalken und Statusleiste
            self.progress_bar.setValue(percent)
            eta_formatted = self.format_eta(eta)
            speed_formatted = self.format_speed(speed)
            self.statusBar().showMessage(f"Download: {percent}% abgeschlossen | Geschwindigkeit: {speed_formatted} | Verbleibende Zeit: {eta_formatted}")
    
        def format_eta(self, eta):
            m, s = divmod(eta, 60)
            h, m = divmod(m, 60)
            if h > 0:
                return f"{int(h)}h {int(m)}m {int(s)}s"
            elif m > 0:
                return f"{int(m)}m {int(s)}s"
            else:
                return f"{int(s)}s"
    
        def format_speed(self, speed):
            # speed in bytes per second
            if speed is None or speed == 0:
                return "N/A"
            elif speed < 1024:
                return f"{speed:.0f} B/s"
            elif speed < 1024 * 1024:
                kbps = speed / 1024
                return f"{kbps:.1f} KB/s"
            else:
                mbps = speed / (1024 * 1024)
                return f"{mbps:.1f} MB/s"
    
        def partial_extraction_finished(self, tracks, full_audio):
            # Aktualisiere die GUI mit den gefundenen Tracks
            self.extracted_tracks.extend(tracks)
            if self.full_audio is None:
                self.full_audio = full_audio
            else:
                self.full_audio += full_audio
    
            self.populate_preview_table()
    
            if self.full_audio:
                self.waveform_widget.set_audio_data(self.full_audio)
                self.waveform_widget.set_segments(self.extracted_tracks)
    
            self.save_button.setEnabled(True)
            self.play_button.setEnabled(True)
            self.stop_button.setEnabled(True)
    
        def update_progress(self, value):
            self.progress_bar.setValue(value)
            self.statusBar().showMessage(f"Verarbeitung: {value}% abgeschlossen")
    
        def extraction_finished(self, tracks, full_audio):
            self.progress_bar.setValue(100)
            self.statusBar().showMessage("Extraktion abgeschlossen.")
            self.logger.info("Extraktion abgeschlossen.")
    
        def populate_preview_table(self):
            self.preview_table.setRowCount(len(self.extracted_tracks))
            for row, track in enumerate(self.extracted_tracks):
                # Abspielen-Button
                play_button = QPushButton("▶")
                play_button.clicked.connect(lambda checked, r=row: self.select_track(r))
                self.preview_table.setCellWidget(row, 0, play_button)
    
                # Titel
                title_item = QTableWidgetItem(track['title'])
                title_item.setFlags(title_item.flags() | Qt.ItemIsEditable)
                self.preview_table.setItem(row, 1, title_item)
    
                # Künstler
                artist_item = QTableWidgetItem(track['artist'])
                artist_item.setFlags(artist_item.flags() | Qt.ItemIsEditable)
                self.preview_table.setItem(row, 2, artist_item)
    
                # Album
                album_item = QTableWidgetItem(track['album'])
                album_item.setFlags(album_item.flags() | Qt.ItemIsEditable)
                self.preview_table.setItem(row, 3, album_item)
    
                # Startzeit
                start_item = QTableWidgetItem(str(track['start_ms']))
                start_item.setFlags(start_item.flags() | Qt.ItemIsEditable)
                self.preview_table.setItem(row, 4, start_item)
    
                # Endzeit
                end_item = QTableWidgetItem(str(track['end_ms']))
                end_item.setFlags(end_item.flags() | Qt.ItemIsEditable)
                self.preview_table.setItem(row, 5, end_item)
    
        def handle_error(self, error_message):
            self.logger.error(error_message)
            self.statusBar().showMessage("Fehler aufgetreten.")
    
            # Reaktiviere UI-Elemente
            self.start_button.setEnabled(True)
            self.browse_button.setEnabled(True)
            self.output_button.setEnabled(True)
            self.settings_button.setEnabled(True)
    
        def log_message(self, message):
            self.logger.info(message)
    
        def select_track(self, row):
            if row >= len(self.extracted_tracks):
                return
            track = self.extracted_tracks[row]
            path = track['file_path']
            if os.path.exists(path):
                try:
                    self.current_track_row = row
                    url = QUrl.fromLocalFile(path)
                    content = QMediaContent(url)
                    self.media_player.setMedia(content)
                    self.media_player.play()
                    self.play_button.setText("Pause")
                except Exception as e:
                    error_msg = f"Fehler beim Abspielen: {str(e)}"
                    self.logger.error(error_msg)
            else:
                error_msg = "Die ausgewählte MP3-Datei wurde nicht gefunden."
                self.logger.error(error_msg)
    
        def play_pause_track(self):
            if self.media_player.state() == QMediaPlayer.PlayingState:
                self.media_player.pause()
                self.play_button.setText("Play")
            elif self.media_player.state() == QMediaPlayer.PausedState:
                self.media_player.play()
                self.play_button.setText("Pause")
            else:
                if self.current_track_row is None:
                    self.select_track(0)
                else:
                    self.media_player.play()
                    self.play_button.setText("Pause")
    
        def stop_track(self):
            self.media_player.stop()
            self.play_button.setText("Play")
    
        def position_changed(self, position):
            self.position_slider.setValue(position)
            self.position_label.setText(f"Position: {position//1000}s")
    
        def duration_changed(self, duration):
            self.position_slider.setRange(0, duration)
    
        def set_position(self, position):
            self.media_player.setPosition(position)
    
        def save_tracks(self):
            # Aktuelle Daten aus der Tabelle holen
            for row in range(self.preview_table.rowCount()):
                title = self.preview_table.item(row, 1).text()
                artist = self.preview_table.item(row, 2).text()
                album = self.preview_table.item(row, 3).text()
                start_ms = int(self.preview_table.item(row, 4).text())
                end_ms = int(self.preview_table.item(row, 5).text())
                self.extracted_tracks[row]['title'] = title
                self.extracted_tracks[row]['artist'] = artist
                self.extracted_tracks[row]['album'] = album
                self.extracted_tracks[row]['start_ms'] = start_ms
                self.extracted_tracks[row]['end_ms'] = end_ms
    
            # Speichere die Tracks mit Metadaten
            for track in self.extracted_tracks:
                self.save_track_with_metadata(track)
    
            self.logger.info("Alle Tracks wurden erfolgreich gespeichert.")
            self.statusBar().showMessage("Alle Tracks wurden erfolgreich gespeichert.")
    
        def save_track_with_metadata(self, track):
            output_folder = self.output_field.text()
            sanitized_title = self.sanitize_filename(track['title'])
            output_path = os.path.join(output_folder, f"{sanitized_title}.mp3")
            try:
                # Schneide das Segment basierend auf den neuen Start- und Endzeiten
                segment = self.full_audio[track['start_ms']:track['end_ms']]
                # Exportiere das Segment
                segment.export(output_path, format='mp3')
    
                # Füge Metadaten hinzu
                self.add_metadata(output_path, track)
                self.logger.info(f"Track '{track['title']}' gespeichert.")
            except Exception as e:
                error_msg = f"Fehler beim Speichern von {track['title']}: {str(e)}"
                self.logger.error(error_msg)
    
        def add_metadata(self, file_path, track):
            try:
                # Lade bestehende Tags oder erstelle neue
                try:
                    audio = ID3(file_path)
                except ID3NoHeaderError:
                    audio = ID3()
    
                # Aktualisiere oder füge Metadaten hinzu
                audio["TIT2"] = TIT2(encoding=3, text=track['title'])
                audio["TPE1"] = TPE1(encoding=3, text=track['artist'])
                audio["TALB"] = TALB(encoding=3, text=track['album'])
    
                if track.get('cover_path') and os.path.exists(track['cover_path']):
                    with open(track['cover_path'], 'rb') as cover_file:
                        audio["APIC"] = APIC(
                            encoding=3,
                            mime='image/jpeg',
                            type=3,  # cover art
                            desc='Cover',
                            data=cover_file.read()
                        )
                audio.save(file_path)
            except Exception as e:
                self.logger.error(f"Fehler beim Hinzufügen von Metadaten: {str(e)}")
    
        def sanitize_filename(self, name):
            # Entferne ungültige Zeichen aus dem Dateinamen
            return "".join(c for c in name if c.isalnum() or c in " ._-").rstrip()
    
        def closeEvent(self, event):
            self.media_player.stop()
            event.accept()
    
    # Anwendung starten
    def main():
        app = QApplication(sys.argv)
    
        window = MusicExtractorApp()
        window.show()
        sys.exit(app.exec_())
    
    if __name__ == "__main__":
        main()
    

    Änderungen und Verbesserungen:

    1. Librosa-Überprüfung entfernt: Die Prüfung, ob librosa installiert ist, wurde entfernt. Stattdessen wird librosa direkt importiert, da es standardmäßig vorhanden sein sollte.

    2. Fortschrittsbalken und zusätzliche Informationen: Während des Downloads und anderer Vorgänge wird der Fortschrittsbalken aktualisiert. Es werden auch Informationen wie verbleibende Zeit und Download-Geschwindigkeit angezeigt. Dies wurde durch Hinzufügen der Methode progress_hook und der entsprechenden Signals und Slots erreicht.

    3. Anzeige der Musikstücke während der Verarbeitung: Die Anwendung zeigt nun alle gefundenen Musikstücke an, sobald eine MP3-Datei vollständig bearbeitet wurde, auch wenn der gesamte Vorgang noch nicht abgeschlossen ist. Dies wurde durch Hinzufügen des Signals tracks_ready und der Methode partial_extraction_finished erreicht.

    4. GUI-Verbesserungen: Die Farbschemata wurden angepasst, um sicherzustellen, dass Texte gut lesbar sind (z.B. weiße Schrift auf dunklem Hintergrund). Die Stylesheets wurden entsprechend aktualisiert.

    5. Fehlerbehebung beim Abspielen und Schieberegler: Es wurden Korrekturen vorgenommen, um sicherzustellen, dass das Abspielen der segmentierten Musikstücke funktioniert und der Schieberegler die richtige Funktion hat. Die Methoden zur Positionsänderung wurden überprüft und angepasst.

    6. Metadaten-Korrekturen: Der Bereich für die Anzeige und Bearbeitung von Metadaten wurde überprüft und verbessert, um sicherzustellen, dass alle Daten korrekt angezeigt, bearbeitet und gespeichert werden.

    Dieses Skript sollte nun die gewünschten Verbesserungen und Korrekturen enthalten. Stellen Sie sicher, dass alle benötigten Bibliotheken installiert sind und die notwendige Python-Version verwendet wird. Führen Sie das Skript aus und testen Sie die Anwendung, um sicherzustellen, dass alle Funktionen wie erwartet arbeiten.