finde alle fehler in diesem skript: import sys import os import tempfile import re…
- User
finde alle fehler in diesem 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 QEvent from bs4 import BeautifulSoup from configparser import ConfigParser 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.QtCore import Qt, QThread, pyqtSignal, QUrl 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, error
Prüfe, ob librosa installiert ist
try: import librosa LIBROSA_AVAILABLE = True except ImportError: LIBROSA_AVAILABLE = False
Logging konfigurieren
logging.basicConfig( filename='music_extractor.log', level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s' )
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)
class QTextEditLogEvent(QEvent): def init(self, message): super().init(QEvent.User) self.message = message
Custom Logger Handler für QTextEdit
class QTextEditLogger(logging.Handler): def init(self, text_edit_widget): super().init() self.widget = text_edit_widget
def emit(self, record): msg = self.format(record) QApplication.instance().postEvent(self.widget, QTextEditLogEvent(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 = [] 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 not audio_file: 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 progress = int((idx / total_inputs) * 100) self.progress.emit(progress) # 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(audio_file, tracklist) else: self.log.emit("Keine Trackliste gefunden. Verwende akustische Analyse.") # Verwende akustische Analyse zur Segmentierung segments = self.segment_audio_by_acoustic_analysis(audio_file) 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) all_extracted_tracks.extend(extracted_tracks) self.log.emit(f"Verarbeitung von {input_value} abgeschlossen.") # Beende den Prozess und gebe auch das vollständige Audio aus if audio_file: full_audio = AudioSegment.from_mp3(audio_file) else: full_audio = None 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 = os.path.join(temp_dir, f"{video_title}.{ext}") # 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_file, tracklist): """ Segmentiert das Audio basierend auf der extrahierten Trackliste. """ try: audio = AudioSegment.from_mp3(audio_file) 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_file): """ 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 y, sr = librosa.load(audio_file, sr=None) tempo, beat_frames = librosa.beat.beat_track(y=y, 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(y) / sr * 1000] audio = AudioSegment.from_mp3(audio_file) for idx, (start_ms, end_ms) in enumerate(zip(start_times, end_times)): start_ms = int(start_ms) end_ms = int(end_ms) 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): """ 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") # Identifiziere den Track track_info = self.identify_track_by_spectral_and_text(data['file_path']) if track_info: data['title'] = track_info['title'] data['artist'] = track_info['artist'] # Versuche, Metadaten automatisch zu finden metadata = self.fetch_metadata(title) 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': os.path.join(temp_dir, f"segment_{idx + 1}.mp3"), 'cover_path': cover_path, 'start_ms': start_ms, 'end_ms': end_ms } segment.export(track_info['file_path'], format='mp3') extracted_tracks.append(track_info) progress = int((idx / total_segments) * 100) self.progress.emit(progress) self.log.emit(f"Segment {idx + 1}/{total_segments} verarbeitet.") return extracted_tracks def fetch_metadata(self, track_title): """ Sucht nach Metadaten zu einem gegebenen Titel mittels der MusicBrainz API. """ try: query = requests.utils.quote(track_title) url = f"https://musicbrainz.org/ws/2/recording/?query={query}&fmt=json&limit=1" response = requests.get(url) 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: passWidget 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 # Zeichne die Waveform 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 = h_center - amplitude[x] x2 = x + 1 y2 = h_center - amplitude[x+1] painter.drawLine(x1, y1, x2, y2) # Zeichne die 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 = 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
# Terminalartiger Anzeigebereich für Logs self.log_display = QTextEdit() self.log_display.setReadOnly(True) self.log_display.setObjectName("LogDisplay") self.init_ui() self.logger = logging.getLogger(__name__) self.logger.setLevel(logging.INFO) text_edit_handler = QTextEditLogger(self.log_display) 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() # Füge das log_display zum Hauptlayout hinzu main_layout.addWidget(self.log_display) self.statusBar().showMessage('Bereit') def event(self, event): if isinstance(event, QTextEditLogEvent): self.log_display.append(event.message) return True return super().event(event) 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 = QWidget() self.setCentralWidget(central_widget) main_layout = QVBoxLayout(central_widget) # 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 main_layout.addWidget(self.log_display) # 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: self.input_field.append(url.toLocalFile()) 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: audio = ID3(file_path) except error.ID3NoHeaderError: audio = ID3() audio.add(TIT2(encoding=3, text=track['title'])) audio.add(TPE1(encoding=3, text=track['artist'])) audio.add(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.add(APIC( encoding=3, mime='image/jpeg', type=3, desc='Cover', data=cover_file.read() )) audio.save(file_path) 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()
def identify_track_by_spectral_and_text(self, audio_file_path): try: if not LIBROSA_AVAILABLE: self.logger.warning("Librosa nicht verfügbar. Spektralanalyse wird übersprungen.") return None
y, sr_audio = librosa.load(audio_file_path, duration=30) mid_point = len(y) // 2 sample = y[mid_point - sr_audio*7:mid_point + sr_audio*8] mfcc = librosa.feature.mfcc(y=sample, sr=sr_audio, n_mfcc=13) chroma = librosa.feature.chroma_stft(y=sample, sr=sr_audio) tempo, _ = librosa.beat.beat_track(y=sample, sr=sr_audio) spectral_features = np.concatenate([ np.mean(mfcc, axis=1), np.mean(chroma, axis=1), [tempo] ]) recognizer = sr.Recognizer() audio_segment = AudioSegment.from_file(audio_file_path)[mid_point-5000:mid_point+5000] with sr.AudioFile(audio_segment.export(format="wav")) as source: audio = recognizer.record(source) try: text = recognizer.recognize_google(audio, language="de-DE") except sr.UnknownValueError: text = "" search_query = f"{text} {' '.join(map(str, spectral_features))}" return self.search_track_online(search_query) except Exception as e: self.logger.error(f"Fehler bei der Spektral- und Textanalyse: {str(e)}") return Nonedef search_track_online(self, query): if not self.check_internet_connection(): self.logger.warning("Keine Internetverbindung verfügbar. Online-Suche übersprungen.") return None
search_url = f"https://search.azlyrics.com/search.php?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() soup = BeautifulSoup(response.text, 'html.parser') results = soup.find_all('td', class_='text-left visitedlyr') if results: first_result = results[0] artist = first_result.find('b').text.strip() title = first_result.find('span').text.strip() return {'artist': artist, 'title': title} else: return None except Exception as e: self.logger.error(f"Fehler bei der Online-Suche: {str(e)}") return Nonedef identify_track_by_spectral_and_text(self, audio_file_path): try: # Spektrale Analyse y, sr_audio = librosa.load(audio_file_path, duration=30) mid_point = len(y) // 2 sample = y[mid_point - sr_audio7:mid_point + sr_audio8]
mfcc = librosa.feature.mfcc(y=sample, sr=sr_audio, n_mfcc=13) chroma = librosa.feature.chroma_stft(y=sample, sr=sr_audio) tempo, _ = librosa.beat.beat_track(y=sample, sr=sr_audio) 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)[mid_point-5000:mid_point+5000] with sr.AudioFile(audio_segment.export(format="wav")) 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.logger.error(f"Fehler bei der Spektral- und Textanalyse: {str(e)}") return Nonedef search_track_online(self, query): search_url = f"https://search.azlyrics.com/search.php?q={urllib.parse.quote(query)}" headers = {'User-Agent': 'Mozilla/5.0'}
try: response = requests.get(search_url, headers=headers) response.raise_for_status() soup = BeautifulSoup(response.text, 'html.parser') results = soup.find_all('td', class_='text-left visitedlyr') if results: first_result = results[0] artist = first_result.find('b').text.strip() title = first_result.find('span').text.strip() return {'artist': artist, 'title': title} else: return None except Exception as e: self.logger.error(f"Fehler bei der Online-Suche: {str(e)}") return None - Assistant
Das angegebene Skript enthält mehrere Fehler, die sowohl syntaktischer als auch logischer Natur sind. Im Folgenden werden alle identifizierten Fehler aufgeführt und erläutert:
-
Doppelte Definition der Funktion
identify_track_by_spectral_and_textAm Ende des Skripts wird die Funktion
identify_track_by_spectral_and_textzweimal definiert:def identify_track_by_spectral_and_text(self, audio_file_path): # Inhalt der FunktionDie doppelte Definition führt dazu, dass die erste Definition überschrieben wird. Dies kann zu unvorhersehbarem Verhalten führen und sollte korrigiert werden, indem eine der beiden Definitionen entfernt wird.
-
Falsche Platzierung und Indentierung der Funktionen
Die Funktionen
identify_track_by_spectral_and_textundsearch_track_onlinesind außerhalb jeder Klasse definiert, verwenden jedochself, was bedeutet, dass sie Methoden einer Klasse sein sollten. Da sie derzeit außerhalb der KlasseExtractionThreaddefiniert sind, kommt es zu Fehlern, wennselfverwendet wird.Fehlerhafte Verwendung von
selfaußerhalb einer Klasse:def identify_track_by_spectral_and_text(self, audio_file_path): # ... self.logger.warning("Librosa nicht verfügbar. Spektralanalyse wird übersprungen.")Hier ist
selfnicht definiert, da die Funktion keine Methode einer Klasse, sondern eine freie Funktion ist. Um dies zu korrigieren, müssen diese Funktionen als Methoden der KlasseExtractionThreaddefiniert werden oder dasselfmuss entfernt werden. -
Aufruf einer nicht existierenden Methode
In der Methode
process_segmentsder KlasseExtractionThreadwird versucht, die Methodeidentify_track_by_spectral_and_textaufzurufen:track_info = self.identify_track_by_spectral_and_text(data['file_path'])Da
identify_track_by_spectral_and_textnicht als Methode der KlasseExtractionThreaddefiniert ist, führt dies zu einem Attributfehler. Um dies zu beheben, muss die Methode innerhalb der Klasse definiert werden. -
Fehlendes 'file_path' in Segmentdaten
In der Methode
process_segmentswird aufdata['file_path']zugegriffen:track_info = self.identify_track_by_spectral_and_text(data['file_path'])Allerdings wird
file_pathin den Segmentdaten nicht gesetzt. In der Methodesegment_audio_by_tracklist(und eventuell insegment_audio_by_acoustic_analysis) sollten Sie sicherstellen, dassfile_pathfür jedes Segment korrekt gesetzt wird. Möglicherweise sollte das Segment zwischenzeitlich als temporäre Datei gespeichert werden, um einen Pfad angeben zu können. -
Einheiteninkonsistenzen zwischen Sample-Indizes und Millisekunden
In der Funktion
identify_track_by_spectral_and_textgibt es eine Inkonsistenz zwischen den Einheiten vonmid_pointin Samples und der Verwendung inAudioSegment, die Zeit in Millisekunden erwartet:y, sr_audio = librosa.load(audio_file_path, duration=30) mid_point = len(y) // 2 # ... audio_segment = AudioSegment.from_file(audio_file_path)[mid_point-5000:mid_point+5000]Hier ist
mid_pointin Samples, aber beim Slicen vonAudioSegmentwerden Millisekunden verwendet. Dies führt zu falschen Segmenten oder Indexfehlern. Um dies zu korrigieren, mussmid_pointin Millisekunden umgerechnet werden:duration_ms = self.audio_data.duration_seconds * 1000 mid_point_ms = duration_ms / 2 audio_segment = AudioSegment.from_file(audio_file_path)[mid_point_ms - 5000:mid_point_ms + 5000] -
Falsche Verwendung von Variablennamen
In der Funktion
identify_track_by_spectral_and_textwirdsr_audioverwendet, obwohl die Variable auslibrosa.loadsrheißt:y, sr_audio = librosa.load(audio_file_path, duration=30) # ... sample = y[mid_point - sr_audio*7:mid_point + sr_audio*8]Dies sollte konsistent sein:
y, sr = librosa.load(audio_file_path, duration=30) # ... sample = y[mid_point - sr*7:mid_point + sr*8] -
Fehler bei der Verwendung von
AudioSegmentmitspeech_recognitionIn der Funktion
identify_track_by_spectral_and_textwird versucht,AudioSegmentdirekt ansr.AudioFilezu übergeben:with sr.AudioFile(audio_segment.export(format="wav")) as source: audio = recognizer.record(source)Hier gibt es zwei Probleme:
audio_segment.exportohne Dateipfad exportiert die Audiodaten als Bytes-Objekt, nicht als Datei.sr.AudioFileerwartet einen Dateipfad oder eine Datei.
Um dies zu beheben, sollte man ein
BytesIO-Objekt verwenden:from io import BytesIO audio_bytes = BytesIO() audio_segment.export(audio_bytes, format="wav") audio_bytes.seek(0) with sr.AudioFile(audio_bytes) as source: audio = recognizer.record(source) -
Überprüfung der Internetverbindung innerhalb von
search_track_onlineIn der Funktion
search_track_onlinewirdself.check_internet_connection()aufgerufen, obwohlselfnicht definiert ist:if not self.check_internet_connection(): self.logger.warning("Keine Internetverbindung verfügbar. Online-Suche übersprungen.") return NoneDa
search_track_onlinekeine Methode einer Klasse ist, sollteselfentfernt und die Funktion entsprechend angepasst werden. Alternativ kannsearch_track_onlineals Methode der KlasseExtractionThreaddefiniert werden. -
Fehlerhafte Verwendung von
self.loggerin freien FunktionenIn den Funktionen
identify_track_by_spectral_and_textundsearch_track_onlinewirdself.loggerverwendet, obwohlselfnicht definiert ist. Dies führt zu Fehlern. Um dies zu korrigieren, müssen Sie entwederself.loggerdurch einen globalen Logger ersetzen oder die Funktionen als Methoden einer Klasse definieren.Beispiel für die Verwendung eines globalen Loggers:
logger = logging.getLogger(__name__) def identify_track_by_spectral_and_text(audio_file_path): # ... logger.warning("Librosa nicht verfügbar. Spektralanalyse wird übersprungen.") -
Unnötige und verwirrende Kommentare
Im gesamten Skript sind Kommentare enthalten, die an manchen Stellen redundant oder irreführend sind. Zum Beispiel der Kommentar "Versuche, die Trackliste aus der Videobeschreibung zu extrahieren" in der Methode
run, obwohl diese Aufgabe später im Code erledigt wird. Es ist wichtig, Kommentare aktuell und relevant zu halten. -
Überflüssige oder fehlende Fehlerbehandlung
In mehreren Methoden fehlt eine angemessene Fehlerbehandlung. Beispielsweise sollte in der Methode
download_and_extract_audioüberprüft werden, ob der Download erfolgreich war, bevor versucht wird, die Datei zu konvertieren oder zu öffnen. Ebenso sollten mögliche Ausnahmen, die beim Zugriff auf externe APIs auftreten können, abgefangen und behandelt werden. -
Nicht verwendete oder falsch initialisierte Variablen
In der Methode
extraction_finishedder KlasseMusicExtractorAppwird aufself.full_audiozugegriffen, ohne sicherzustellen, dass sie tatsächlich ein gültiges Audioobjekt enthält. Es wäre sinnvoll, eine Prüfung einzufügen, um sicherzustellen, dassself.full_audionichtNoneist, bevor versucht wird, es zu verwenden. -
Fehlerhafte Verwendung von PyQt-Signalen
In der Klasse
ExtractionThreadwerden Signale definiert, aber es ist nicht ersichtlich, dass sie korrekt emittiert oder verbunden werden. Zudem könnte es zu Problemen führen, wenn Signale mit komplexen Daten (wie Listen oder Objekten) verwendet werden, ohne die passenden Typen anzugeben. PyQt erwartet oft, dass die Signale mit den richtigen Typen definiert sind. -
Fehlende Rückgabe in bestimmten Kontrollflusswegen
In einigen Methoden gibt es Kontrollflusswege, bei denen keine Rückgabe erfolgt, obwohl eine Rückgabe erwartet wird. Beispielsweise in
segment_audio_by_tracklistundsegment_audio_by_acoustic_analysissollte sichergestellt werden, dass immer eine Liste von Segmenten oderNonezurückgegeben wird. -
Unvollständige Implementierung von Funktionen
Einige Funktionen scheinen unvollständig zu sein oder wichtige Teile zu fehlen. Zum Beispiel ruft die Methode
fetch_cover_urldie Cover-URL ab, aber es wird nicht überprüft, ob die Antwort tatsächlich das erwartete Format hat. -
Fehler bei der Verwendung von Mutagen zur Metadatenbearbeitung
In der Methode
add_metadatawirdID3ausmutagen.id3verwendet. Wenn die Datei noch keine ID3-Tags hat, wirftID3eineID3NoHeaderError. Dieser wird abgefangen, aber dann wirdaudio = ID3()erstellt, ohne die Datei zu referenzieren. Um Metadaten zu einer Datei hinzuzufügen, sollteEasyID3verwendet werden oderID3sollte korrekt initialisiert werden:from mutagen.easyid3 import EasyID3 def add_metadata(self, file_path, track): try: audio = EasyID3(file_path) except Exception: audio = EasyID3() audio['title'] = track['title'] audio['artist'] = track['artist'] audio['album'] = track['album'] audio.save(file_path) -
Fehler beim Umgang mit Unicode und Zeichenkodierungen
Bei der Verarbeitung von Texten aus dem Internet (z.B. von Webseiten oder APIs) können Zeichen auftauchen, die spezielle Behandlung erfordern. Es sollte sichergestellt werden, dass alle Texte korrekt kodiert und dekodiert werden, um Fehler oder Abstürze zu vermeiden.
-
Fehlerhafte Implementierung der Drag-and-Drop-Funktionalität
In den Methoden
drag_enter_eventunddrop_eventwird aufevent.mimeData().hasUrls()undevent.mimeData().hasText()geprüft, aber es könnte zu Problemen kommen, wenn andere Datentypen fallen gelassen werden. Es wäre sinnvoll, eine robustere Prüfung und Fehlerbehandlung zu implementieren. -
Veraltete oder unsichere Bibliotheken
Die Bibliothek
youtube_dlist inzwischen veraltet und sollte durchyt-dlpersetzt werden, wie es bereits imtry-except-Block vorgesehen ist. Allerdings kann es zu Problemen kommen, wennyoutube_dlnicht installiert ist. Es ist besser, direktyt-dlpzu verwenden und sicherzustellen, dass die Abhängigkeiten korrekt installiert sind. -
Fehlende Überprüfung von Benutzer-Eingaben
In der Methode
start_extractionwird die Benutzereingabe aus dem Textfeld direkt verwendet, ohne auf gefährliche Inhalte oder ungültige Daten zu prüfen. Es sollte sichergestellt werden, dass die Eingaben gültig sind und keine potenziellen Sicherheitsrisiken darstellen. -
Fehler in der Berechnung des Fortschritts
In der Methode
runder KlasseExtractionThreadwird der Fortschritt wie folgt berechnet:progress = int((idx / total_inputs) * 100) self.progress.emit(progress)Dies führt dazu, dass der Fortschritt nicht vollständig dargestellt wird, insbesondere wenn mehrere Schritte innerhalb einer Eingabe ausgeführt werden. Eine genauere Fortschrittsberechnung würde alle Schritte berücksichtigen und den Benutzer besser über den aktuellen Status informieren.
-
Fehlerhafte Verwendung von Threads mit PyQt
Obwohl
QThreadverwendet wird, könnte es zu Problemen kommen, wenn nicht sichergestellt wird, dass alle GUI-Operationen im Hauptthread ausgeführt werden. Funktionen, die die GUI beeinflussen, sollten über Signale kommunizieren, um Threading-Probleme zu vermeiden.
Zusammenfassung der Korrekturen:
- Entfernen Sie eine der doppelten Definitionen von
identify_track_by_spectral_and_text. - Verschieben Sie die Funktionen
identify_track_by_spectral_and_textundsearch_track_onlinein die KlasseExtractionThreadund passen Sie die Verwendung vonselfentsprechend an. - Korrigieren Sie die Einheiteninkonsistenzen zwischen Samples und Millisekunden.
- Stellen Sie sicher, dass alle benötigten Variablen korrekt initialisiert und verwendet werden (z.B.
srvs.sr_audio). - Beheben Sie alle Stellen, an denen
selffälschlicherweise in freien Funktionen verwendet wird. - Verbessern Sie die Fehlerbehandlung und die Überprüfung von Eingabedaten.
- Aktualisieren Sie die Verwendung von Bibliotheken und stellen Sie sicher, dass alle Abhängigkeiten korrekt installiert sind.
- Überarbeiten Sie die Fortschrittsanzeige, um eine genauere Rückmeldung zu geben.
- Stellen Sie sicher, dass alle GUI-Operationen im Hauptthread ausgeführt werden, um Threading-Probleme zu vermeiden.
Durch diese Korrekturen sollte das Skript fehlerfrei funktionieren und die gewünschte Funktionalität bereitstellen.
-