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

überprüfe das skript und behebe sorgfälltig alle fehler und probleme. Zum beispiel…

  1. User

    überprüfe das skript und behebe sorgfälltig alle fehler und probleme. Zum beispiel diesen der im terminal gezeigt wurde: (venv) D:_Projekte_MyCodes\GitHub\Speech2Speech>d:/_Projekte/_MyCodes/GitHub/Speech2Speech/venv/Scripts/python.exe d:/_Projekte/_MyCodes/GitHub/Speech2Speech/Speech2Speech.py QWidget: Must construct a QApplication before a QWidget Nachdem alle fehler behoben wurden und sichergestellt wurde das die anwendung vollständig problemlos ausführbar ist nennst du mir das vollständige korrigierte skript der anwendung mit dem gesamten code ohne fehlende zeilen. (venv) D:_Projekte_MyCodes\GitHub\Speech2Speech>

    import sys import os import threading import tempfile import wave import json import shutil import queue import logging import configparser import mimetypes from pathlib import Path import zipfile import subprocess

    import requests from PyQt5 import QtWidgets, QtCore, QtGui from PyQt5.QtWidgets import (QApplication, QMainWindow, QFileDialog, QMessageBox, QProgressBar, QListWidgetItem) from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal Prüfen und Installieren fehlender Python-Pakete

    required_packages = [ 'TTS', 'vosk', 'simpleaudio', 'moviepy', 'pydub', 'librosa', 'soundfile', 'deep_translator', 'requests' ]

    missing_packages = [] for package in required_packages: try: import(package) except ImportError: missing_packages.append(package)

    if missing_packages: try: subprocess.check_call([sys.executable, '-m', 'pip', 'install', *missing_packages]) print(f"Folgende Pakete wurden installiert: {', '.join(missing_packages)}") except Exception as e: print(f"Fehler bei der automatischen Installation der Pakete: {e}") sys.exit(1) Erneutes Importieren der Pakete nach Installation

    from TTS.api import TTS from vosk import Model as ASRModel, KaldiRecognizer import simpleaudio as sa from moviepy.editor import VideoFileClip, AudioFileClip from pydub import AudioSegment import librosa import soundfile as sf from deep_translator import GoogleTranslator Überprüfen, ob espeak-ng installiert ist

    def check_espeak(): try: if sys.platform.startswith('win'): subprocess.check_output(['where', 'espeak-ng'], stderr=subprocess.STDOUT) else: subprocess.check_output(['which', 'espeak-ng'], stderr=subprocess.STDOUT) return True except subprocess.CalledProcessError: return False

    if not check_espeak(): QMessageBox.critical(None, "Fehlende Abhängigkeit", "Die Anwendung benötigt 'espeak-ng', um korrekt zu funktionieren.\n" "Bitte installieren Sie 'espeak-ng' manuell auf Ihrem System.") sys.exit(1) Setup logging

    logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') Constants for directories

    MODELS_DIR = Path("models") SAVED_VOICES_DIR = Path("saved_voices")

    class Speech2SpeechApp(QMainWindow): log_signal = pyqtSignal(str) progress_signal = pyqtSignal(int) enable_buttons_signal = pyqtSignal(bool)

    def init(self): super().init()

    self.setWindowTitle("Speech2Speech Anwendung")
    self.setGeometry(100, 100, 1200, 800)
    
    # Initialize variables
    self.speaker_embeddings = {}
    self.current_embedding = None
    self.synthesized_audio_path = None
    self.current_language = "Deutsch"
    self.asr_models = {}
    self.tts_models = {}
    self.language_models = {
        "Deutsch": {
            "tts_model_name": "tts_models/de/thorsten/tacotron2-DCA",
            "asr_model_path": MODELS_DIR / "vosk-model-small-de-0.15",
            "asr_model_url": "https://alphacephei.com/vosk/models/vosk-model-small-de-0.15.zip",
            "language_code": "de",
        },
        "Englisch": {
            "tts_model_name": "tts_models/en/ljspeech/tacotron2-DDC",
            "asr_model_path": MODELS_DIR / "vosk-model-small-en-us-0.15",
            "asr_model_url": "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip",
            "language_code": "en",
        }
        # Weitere Sprachen können hier hinzugefügt werden
    }
    
    self.file_to_process = None  # Initialisierung der Datei-Variable
    
    # Einstellungen laden
    self.config_parser = configparser.ConfigParser()
    self.config_file = 'settings.ini'
    if os.path.exists(self.config_file):
        self.config_parser.read(self.config_file)
        self.first_run = self.config_parser.getboolean('General', 'first_run', fallback=True)
    else:
        self.first_run = True
    
    self.queue = queue.Queue()
    self.progress_bars = []
    self.progress_bar_colors = ['#6699CC', '#66CC99', '#CC6699', '#FFCC66', '#66FFCC']
    
    # Signale verbinden
    self.log_signal.connect(self.update_log)
    self.progress_signal.connect(self.update_progress)
    self.enable_buttons_signal.connect(self.set_buttons_enabled)
    
    self.init_ui()
    self.load_saved_voices()
    self.ensure_models()
    

    def init_ui(self): # Erstellen des Haupt-Widgets self.central_widget = QtWidgets.QWidget() self.setCentralWidget(self.central_widget)

    # Hauptlayout
    self.main_layout = QtWidgets.QVBoxLayout(self.central_widget)
    
    # Menüleiste erstellen
    self.create_menu()
    
    # Tabs erstellen
    self.create_tabs()
    
    # Statusleiste erstellen
    self.create_status_bar()
    

    def create_menu(self): # Menüleiste self.menu_bar = self.menuBar()

    # Datei-Menü
    self.file_menu = self.menu_bar.addMenu("Datei")
    self.open_file_action = QtWidgets.QAction("Datei öffnen", self)
    self.open_file_action.triggered.connect(self.select_audio_video_file)
    self.file_menu.addAction(self.open_file_action)
    
    self.exit_action = QtWidgets.QAction("Beenden", self)
    self.exit_action.triggered.connect(self.close)
    self.file_menu.addAction(self.exit_action)
    
    # Einstellungen-Menü
    self.settings_menu = self.menu_bar.addMenu("Einstellungen")
    self.change_language_action = QtWidgets.QAction("Sprache ändern", self)
    self.change_language_action.triggered.connect(self.change_language)
    self.settings_menu.addAction(self.change_language_action)
    
    self.download_models_action = QtWidgets.QAction("Modelle herunterladen", self)
    self.download_models_action.triggered.connect(self.show_download_models_popup)
    self.settings_menu.addAction(self.download_models_action)
    
    # Hilfe-Menü
    self.help_menu = self.menu_bar.addMenu("Hilfe")
    self.about_action = QtWidgets.QAction("Über", self)
    self.about_action.triggered.connect(self.show_about)
    self.help_menu.addAction(self.about_action)
    

    def create_tabs(self): # Tabs erstellen self.tabs = QtWidgets.QTabWidget() self.main_layout.addWidget(self.tabs)

    # Tab 1: Stimmenverwaltung
    self.tab_voices = QtWidgets.QWidget()
    self.tabs.addTab(self.tab_voices, "Stimmenverwaltung")
    self.create_voice_tab()
    
    # Tab 2: Text Synthese
    self.tab_synthesize = QtWidgets.QWidget()
    self.tabs.addTab(self.tab_synthesize, "Text Synthese")
    self.create_synthesize_tab()
    
    # Tab 3: Stimmtausch
    self.tab_replace = QtWidgets.QWidget()
    self.tabs.addTab(self.tab_replace, "Stimmtausch")
    self.create_replace_tab()
    
    # Tab 4: Einstellungen
    self.tab_settings = QtWidgets.QWidget()
    self.tabs.addTab(self.tab_settings, "Einstellungen")
    self.create_settings_tab()
    
    # Tab 5: Vorschau
    self.tab_preview = QtWidgets.QWidget()
    self.tabs.addTab(self.tab_preview, "Vorschau")
    self.create_preview_tab()
    

    def create_voice_tab(self): layout = QtWidgets.QVBoxLayout(self.tab_voices)

    # Stimmenliste
    self.voice_list = QtWidgets.QListWidget()
    self.voice_list.itemClicked.connect(self.voice_selected)
    layout.addWidget(self.voice_list)
    
    # Buttons
    button_layout = QtWidgets.QHBoxLayout()
    layout.addLayout(button_layout)
    
    self.load_voice_button = QtWidgets.QPushButton("Stimme laden")
    self.load_voice_button.clicked.connect(self.load_voice)
    button_layout.addWidget(self.load_voice_button)
    
    self.delete_voice_button = QtWidgets.QPushButton("Stimme löschen")
    self.delete_voice_button.clicked.connect(self.delete_voice)
    button_layout.addWidget(self.delete_voice_button)
    
    self.train_voice_button = QtWidgets.QPushButton("Neue Stimme trainieren")
    self.train_voice_button.clicked.connect(self.train_new_voice)
    button_layout.addWidget(self.train_voice_button)
    

    def create_synthesize_tab(self): layout = QtWidgets.QVBoxLayout(self.tab_synthesize)

    # Texteingabe
    self.text_input = QtWidgets.QTextEdit()
    layout.addWidget(self.text_input)
    
    # Beispieltexte
    example_layout = QtWidgets.QHBoxLayout()
    layout.addLayout(example_layout)
    self.example1_button = QtWidgets.QPushButton("Beispiel 1")
    self.example1_button.clicked.connect(lambda: self.insert_example_text(1))
    example_layout.addWidget(self.example1_button)
    
    self.example2_button = QtWidgets.QPushButton("Beispiel 2")
    self.example2_button.clicked.connect(lambda: self.insert_example_text(2))
    example_layout.addWidget(self.example2_button)
    
    # Einstellungen
    settings_layout = QtWidgets.QFormLayout()
    layout.addLayout(settings_layout)
    
    self.rate_slider = QtWidgets.QSlider(Qt.Horizontal)
    self.rate_slider.setMinimum(50)
    self.rate_slider.setMaximum(200)
    self.rate_slider.setValue(100)
    self.rate_slider.setTickInterval(10)
    self.rate_slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
    settings_layout.addRow("Sprechgeschwindigkeit:", self.rate_slider)
    
    self.pitch_slider = QtWidgets.QSlider(Qt.Horizontal)
    self.pitch_slider.setMinimum(50)
    self.pitch_slider.setMaximum(200)
    self.pitch_slider.setValue(100)
    self.pitch_slider.setTickInterval(10)
    self.pitch_slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
    settings_layout.addRow("Tonhöhe:", self.pitch_slider)
    
    # Synthese-Button
    self.synthesize_button = QtWidgets.QPushButton("Text synthetisieren")
    self.synthesize_button.clicked.connect(self.synthesize_voice)
    layout.addWidget(self.synthesize_button)
    

    def create_replace_tab(self): layout = QtWidgets.QVBoxLayout(self.tab_replace)

    # Datei auswählen
    self.select_file_button = QtWidgets.QPushButton("Audio-/Videodatei auswählen")
    self.select_file_button.clicked.connect(self.select_audio_video_file)
    layout.addWidget(self.select_file_button)
    
    # Übersetzungsoption
    self.translate_checkbox = QtWidgets.QCheckBox("Englische Sprache ins Deutsche übersetzen")
    layout.addWidget(self.translate_checkbox)
    
    # Stimme ersetzen Button
    self.replace_voice_button = QtWidgets.QPushButton("Stimme in Datei ersetzen")
    self.replace_voice_button.clicked.connect(self.replace_voice_in_file)
    layout.addWidget(self.replace_voice_button)
    

    def create_settings_tab(self): layout = QtWidgets.QFormLayout(self.tab_settings)

    # Spracheinstellungen
    self.language_combo = QtWidgets.QComboBox()
    self.language_combo.addItems(self.language_models.keys())
    self.language_combo.setCurrentText(self.current_language)
    self.language_combo.currentTextChanged.connect(self.change_language)
    layout.addRow("Sprache:", self.language_combo)
    
    # Audioformat-Einstellungen
    self.audio_format_combo = QtWidgets.QComboBox()
    self.audio_format_combo.addItems(["wav", "mp3"])
    layout.addRow("Audioformat:", self.audio_format_combo)
    

    def create_preview_tab(self): layout = QtWidgets.QVBoxLayout(self.tab_preview)

    # Audiodatei auswählen
    self.select_preview_button = QtWidgets.QPushButton("Audiodatei zur Vorschau auswählen")
    self.select_preview_button.clicked.connect(self.select_preview_file)
    layout.addWidget(self.select_preview_button)
    
    # Wiedergabe-Steuerung
    control_layout = QtWidgets.QHBoxLayout()
    layout.addLayout(control_layout)
    self.play_preview_button = QtWidgets.QPushButton("Abspielen")
    self.play_preview_button.clicked.connect(self.play_preview)
    control_layout.addWidget(self.play_preview_button)
    
    self.stop_preview_button = QtWidgets.QPushButton("Stoppen")
    self.stop_preview_button.clicked.connect(self.stop_preview)
    control_layout.addWidget(self.stop_preview_button)
    

    def create_status_bar(self): # Statusleiste self.status_bar = self.statusBar()

    # Fortschrittsbalken
    self.progress_bar = QProgressBar()
    self.progress_bar.setVisible(False)
    self.status_bar.addPermanentWidget(self.progress_bar)
    
    # Nachrichtenbereich
    self.message_label = QtWidgets.QLabel()
    self.status_bar.addWidget(self.message_label)
    

    @pyqtSlot() def show_about(self): QMessageBox.information(self, "Über", "Speech2Speech Anwendung\nVersion 1.0\nEntwickelt von Ihrem Namen")

    def load_saved_voices(self): SAVED_VOICES_DIR.mkdir(exist_ok=True) self.voice_list.clear() for voice_file in SAVED_VOICES_DIR.glob("*.wav"): voice_name = voice_file.stem item = QListWidgetItem(voice_name) self.voice_list.addItem(item) self.speaker_embeddings[voice_name] = str(voice_file)

    @pyqtSlot() def voice_selected(self): selected_item = self.voice_list.currentItem() if selected_item: self.current_embedding = self.speaker_embeddings[selected_item.text()] self.log_message(f"Stimme '{selected_item.text()}' wurde ausgewählt.")

    @pyqtSlot() def load_voice(self): selected_item = self.voice_list.currentItem() if selected_item: self.current_embedding = self.speaker_embeddings[selected_item.text()] self.log_message(f"Stimme '{selected_item.text()}' wurde geladen.") else: self.log_message("Keine Stimme ausgewählt.")

    @pyqtSlot() def delete_voice(self): selected_item = self.voice_list.currentItem() if selected_item: voice_name = selected_item.text() reply = QMessageBox.question(self, 'Bestätigung', f"Möchten Sie die Stimme '{voice_name}' wirklich löschen?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.Yes: try: os.remove(self.speaker_embeddings[voice_name]) del self.speaker_embeddings[voice_name] self.voice_list.takeItem(self.voice_list.row(selected_item)) self.log_message(f"Stimme '{voice_name}' wurde gelöscht.") except Exception as e: logging.error(f"Fehler beim Löschen der Stimme '{voice_name}': {e}") self.log_message(f"Fehler beim Löschen der Stimme '{voice_name}': {e}") else: self.log_message("Keine Stimme ausgewählt.")

    @pyqtSlot() def train_new_voice(self): file_dialog = QFileDialog(self) file_dialog.setFileMode(QFileDialog.ExistingFiles) file_dialog.setNameFilters(["Audio Dateien (*.wav *.mp3 *.flac *.ogg *.opus)"]) if file_dialog.exec_(): file_paths = file_dialog.selectedFiles() voice_name, ok = QtWidgets.QInputDialog.getText(self, "Stimmenname", "Geben Sie einen Namen für die neue Stimme ein:") if ok and voice_name: if voice_name in self.speaker_embeddings: QMessageBox.warning(self, "Warnung", f"Stimme '{voice_name}' existiert bereits.") return threading.Thread(target=self.train_voice_thread, args=(file_paths, voice_name), daemon=True).start() else: self.log_message("Kein Stimmenname eingegeben.")

    def train_voice_thread(self, file_paths, voice_name): self.progress_signal.emit(0) self.enable_buttons_signal.emit(False) preprocessed_files = [] try: total_files = len(file_paths) for idx, file_path in enumerate(file_paths, 1): preprocessed_path = self.preprocess_audio(file_path) if preprocessed_path: preprocessed_files.append(preprocessed_path) else: self.log_message(f"Überspringe Datei {file_path} aufgrund von Vorverarbeitungsfehlern.") progress = int((idx / (total_files * 2)) * 100) self.progress_signal.emit(progress)

        if not preprocessed_files:
            self.log_message("Keine gültigen Audiodateien für das Training vorhanden.")
            return
    
        # Kombiniere vorverarbeitete Dateien in eine Datei
        combined_audio = AudioSegment.empty()
        for preprocessed_file in preprocessed_files:
            audio_segment = AudioSegment.from_file(preprocessed_file)
            combined_audio += audio_segment
    
        # Speichere kombiniertes Audio
        save_path = SAVED_VOICES_DIR / f"{voice_name}.wav"
        combined_audio.export(str(save_path), format="wav")
        self.speaker_embeddings[voice_name] = str(save_path)
        self.log_signal.emit(f"Stimme '{voice_name}' wurde erfolgreich erstellt.")
        self.progress_signal.emit(100)
        self.enable_buttons_signal.emit(True)
        self.load_saved_voices()
    except Exception as e:
        logging.error(f"Fehler beim Training der Stimme: {e}")
        self.log_message(f"Fehler beim Training der Stimme: {e}")
    finally:
        # Temporäre Dateien löschen
        for preprocessed_file in preprocessed_files:
            try:
                os.remove(preprocessed_file)
            except Exception as e:
                logging.error(f"Fehler beim Löschen der temporären Datei '{preprocessed_file}': {e}")
        self.enable_buttons_signal.emit(True)
        self.progress_signal.emit(0)
    

    def preprocess_audio(self, file_path): temp_audio_path = None # Initialisieren try: self.log_message(f"Vorverarbeitung der Audiodatei: {file_path}") mime_type, _ = mimetypes.guess_type(file_path) if mime_type and mime_type.startswith('video'): self.log_message("Video-Datei erkannt, extrahiere Audio...") # Extrahieren des Audio-Teils aus der Video-Datei with VideoFileClip(file_path) as video: audio = video.audio temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav") os.close(temp_audio_fd) audio.write_audiofile(temp_audio_path, logger=None) file_path = temp_audio_path

        # Konvertieren und Laden der Audiodatei
        sound = AudioSegment.from_file(file_path)
        sound = sound.set_frame_rate(22050).set_channels(1)
        temp_processed_fd, preprocessed_path = tempfile.mkstemp(suffix=".wav")
        os.close(temp_processed_fd)
        sound.export(preprocessed_path, format="wav")
        y, sr = librosa.load(preprocessed_path, sr=22050, mono=True)
    
        # Überprüfen der Länge
        if len(y) < sr * 1:  # Mindestens 1 Sekunde
            self.log_message(f"Audiodatei '{file_path}' ist zu kurz. Mindestens 1 Sekunde erforderlich.")
            os.remove(preprocessed_path)
            return None
    
        # Normalisierung
        y = librosa.util.normalize(y)
    
        # Speichern der normalisierten Audiodaten
        sf.write(preprocessed_path, y, sr)
        self.log_message(f"Vorverarbeitung der Audiodatei '{file_path}' abgeschlossen.")
        return preprocessed_path
    except Exception as e:
        logging.error(f"Fehler bei der Vorverarbeitung der Audiodatei '{file_path}': {e}")
        self.log_message(f"Fehler bei der Vorverarbeitung der Audiodatei '{file_path}': {e}")
        return None
    finally:
        # Temporäre Dateien löschen
        if temp_audio_path and os.path.exists(temp_audio_path):
            try:
                os.remove(temp_audio_path)
            except Exception as e:
                logging.error(f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}")
    

    @pyqtSlot() def insert_example_text(self, example_number): examples = { 1: "Dies ist ein Beispieltext für die Sprachsynthese.", 2: "Willkommen bei der verbesserten Speech2Speech Anwendung!" } self.text_input.setPlainText(examples.get(example_number, ""))

    @pyqtSlot() def synthesize_voice(self): selected_item = self.voice_list.currentItem() if not selected_item: QMessageBox.warning(self, "Warnung", "Bitte wählen Sie eine Stimme aus.") return

    if self.current_embedding is None:
        QMessageBox.warning(self, "Warnung", "Keine gültige Stimme geladen.")
        return
    
    text_to_speak = self.text_input.toPlainText().strip()
    if not text_to_speak:
        QMessageBox.warning(self, "Warnung", "Bitte geben Sie einen Text ein.")
        return
    
    threading.Thread(target=self.synthesize_voice_thread, args=(text_to_speak,), daemon=True).start()
    

    def synthesize_voice_thread(self, text_to_speak): self.progress_signal.emit(0) self.enable_buttons_signal.emit(False)

    tts_model = self.tts_models.get(self.current_language)
    if not tts_model:
        # TTS-Modell nicht vorhanden, Vorschlag zum Herunterladen
        self.enable_buttons_signal.emit(True)
        self.progress_signal.emit(0)
        self.log_message(f"TTS-Modell für {self.current_language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'.")
        return
    
    try:
        language_code = self.language_models[self.current_language]["language_code"]
    
        # TTS-Einstellungen berücksichtigen
        rate = self.rate_slider.value() / 100
        pitch = self.pitch_slider.value() / 100
    
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
            tts_model.tts_to_file(
                text=text_to_speak,
                speaker_wav=self.current_embedding,
                language=language_code,
                file_path=f.name
            )
            synthesized_audio = AudioSegment.from_file(f.name)
            # Geschwindigkeit und Tonhöhe anpassen
            # Zuerst die Tonhöhe anpassen
            octaves = pitch - 1.0  # Berechnung der Oktavenänderung
            new_sample_rate = int(synthesized_audio.frame_rate * (2.0 ** octaves))
            synthesized_audio = synthesized_audio._spawn(synthesized_audio.raw_data, overrides={
                "frame_rate": new_sample_rate
            })
            # Dann die Geschwindigkeit anpassen
            synthesized_audio = synthesized_audio.speedup(playback_speed=rate)
            # Speichern der angepassten Audiodatei
            synthesized_audio = synthesized_audio.set_frame_rate(22050)
            synthesized_audio.export(f.name, format=self.audio_format_combo.currentText())
            self.synthesized_audio_path = f.name
    
        self.log_message("Synthese abgeschlossen.")
        self.progress_signal.emit(100)
        self.update_preview(self.synthesized_audio_path)
        self.play_synthesized_audio()
    except Exception as e:
        logging.error(f"Fehler bei der Sprachsynthese: {e}")
        self.log_message(f"Fehler bei der Sprachsynthese: {e}")
        QtWidgets.QMessageBox.warning(self, "Fehler", f"Fehler bei der Sprachsynthese:\n{e}")
    finally:
        self.enable_buttons_signal.emit(True)
        self.progress_signal.emit(0)
    

    def play_synthesized_audio(self): try: wave_obj = sa.WaveObject.from_wave_file(self.synthesized_audio_path) play_obj = wave_obj.play() play_obj.wait_done() self.log_message("Synthese abgeschlossen und abgespielt.") except Exception as e: logging.error(f"Fehler beim Abspielen der synthetisierten Audiodatei: {e}") self.log_message(f"Fehler beim Abspielen der synthetisierten Audiodatei: {e}")

    def update_preview(self, audio_path): self.preview_audio_path = audio_path self.log_message(f"Vorschau-Audiodatei aktualisiert: {audio_path}")

    @pyqtSlot() def select_preview_file(self): file_dialog = QFileDialog(self) file_dialog.setNameFilters(["Audio Dateien (*.wav *.mp3 *.flac *.ogg *.opus)"]) if file_dialog.exec_(): file_path = file_dialog.selectedFiles()[0] self.preview_audio_path = file_path self.log_message(f"Vorschau-Datei ausgewählt: {os.path.basename(file_path)}")

    @pyqtSlot() def play_preview(self): if not hasattr(self, 'preview_audio_path') or not self.preview_audio_path: QMessageBox.warning(self, "Warnung", "Keine Datei zur Vorschau ausgewählt.") return threading.Thread(target=self.play_preview_thread, daemon=True).start()

    def play_preview_thread(self): try: # Ensure the file is in WAV format if not self.preview_audio_path.lower().endswith('.wav'): self.log_message("Konvertiere Datei zur Vorschau in WAV-Format...") audio = AudioSegment.from_file(self.preview_audio_path) temp_preview_fd, temp_preview_path = tempfile.mkstemp(suffix=".wav") os.close(temp_preview_fd) audio.export(temp_preview_path, format="wav") self.preview_audio_path = temp_preview_path # Update to the temp WAV file

        wave_obj = sa.WaveObject.from_wave_file(self.preview_audio_path)
        self.preview_play_obj = wave_obj.play()
        self.preview_play_obj.wait_done()
        self.log_message("Vorschau abgespielt.")
    
        # Temporäre Datei löschen
        if self.preview_audio_path.endswith('.wav') and os.path.exists(self.preview_audio_path):
            os.remove(self.preview_audio_path)
            self.preview_audio_path = None
    except Exception as e:
        logging.error(f"Fehler beim Abspielen der Vorschau: {e}")
        self.log_message(f"Fehler beim Abspielen der Vorschau: {e}")
        QtWidgets.QMessageBox.warning(self, "Fehler", f"Fehler beim Abspielen der Vorschau:\n{e}")
    

    @pyqtSlot() def stop_preview(self): if hasattr(self, 'preview_play_obj'): self.preview_play_obj.stop() self.log_message("Vorschau-Wiedergabe gestoppt.") else: self.log_message("Keine laufende Vorschau-Wiedergabe.")

    @pyqtSlot() def select_audio_video_file(self): file_dialog = QFileDialog(self) file_dialog.setNameFilters([ "Audio Dateien (*.wav *.mp3 *.flac *.ogg .opus)", "Video Dateien (.mp4 *.avi *.mov .mkv)", "Alle Dateien ()" ]) if file_dialog.exec_(): self.file_to_process = file_dialog.selectedFiles()[0] self.log_message(f"Datei ausgewählt: {os.path.basename(self.file_to_process)}")

    @pyqtSlot() def replace_voice_in_file(self): if not self.file_to_process: QMessageBox.warning(self, "Warnung", "Bitte wählen Sie zuerst eine Datei aus.") return

    selected_item = self.voice_list.currentItem()
    if not selected_item:
        QMessageBox.warning(self, "Warnung", "Bitte wählen Sie eine Stimme aus.")
        return
    
    if self.current_embedding is None:
        QMessageBox.warning(self, "Warnung", "Keine gültige Stimme geladen.")
        return
    
    threading.Thread(target=self.replace_voice_thread, daemon=True).start()
    

    def replace_voice_thread(self): self.progress_signal.emit(0) self.enable_buttons_signal.emit(False)

    temp_files = []
    try:
        total_steps = 8
        current_step = 0
    
        # Audio extrahieren (falls Video)
        mime_type, _ = mimetypes.guess_type(self.file_to_process)
        if mime_type and mime_type.startswith('video'):
            self.log_message("Video-Datei erkannt, extrahiere Audio...")
            with VideoFileClip(self.file_to_process) as video:
                audio = video.audio
                temp_audio_fd, audio_path = tempfile.mkstemp(suffix=".wav")
                os.close(temp_audio_fd)
                audio.write_audiofile(audio_path, logger=None)
                temp_files.append(audio_path)
                is_video = True
        else:
            audio_path = self.file_to_process
            is_video = False
    
        current_step += 1
        self.progress_signal.emit(int((current_step / total_steps) * 100))
    
        # Spracherkennung (ASR)
        self.log_message("Spracherkennung läuft...")
        language = self.detect_language(audio_path)
    
        asr_model = self.asr_models.get(language)
        tts_model = self.tts_models.get(language)
    
        if not asr_model:
            self.enable_buttons_signal.emit(True)
            self.progress_signal.emit(0)
            self.log_message(f"ASR-Modell für {language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'.")
            return
    
        if not tts_model:
            self.enable_buttons_signal.emit(True)
            self.progress_signal.emit(0)
            self.log_message(f"TTS-Modell für {language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'.")
            return
    
        language_code = self.language_models[language]["language_code"]
    
        segments = self.transcribe_audio(audio_path, asr_model)
        if not segments:
            raise Exception("Keine Sprache im Audio erkannt.")
    
        current_step += 1
        self.progress_signal.emit(int((current_step / total_steps) * 100))
    
        # Übersetzung ins Deutsche (falls ausgewählt)
        if self.translate_checkbox.isChecked() and language == "Englisch":
            self.log_message("Übersetzung läuft...")
            try:
                # Text sammeln
                text = ' '.join([seg['word'] for seg in segments])
                translated_text = GoogleTranslator(source='en', target='de').translate(text)
                translated_words = translated_text.split()
                # Übersetzte Wörter den Segmenten zuweisen
                for idx, seg in enumerate(segments):
                    if idx < len(translated_words):
                        seg['word'] = translated_words[idx]
            except Exception as e:
                self.log_message(f"Fehler bei der Übersetzung: {e}")
    
        current_step += 1
        self.progress_signal.emit(int((current_step / total_steps) * 100))
    
        # Generiere synthetisierte Audios für jedes Segment
        self.log_message("Synthese der neuen Stimme läuft...")
        synthesized_segments = []
        for idx, segment in enumerate(segments):
            text = segment['word']
            if not text.strip():
                continue
            try:
                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
                    tts_model.tts_to_file(
                        text=text,
                        speaker_wav=self.current_embedding,
                        language=language_code,
                        file_path=f.name
                    )
                    synthesized_segments.append({'audio_path': f.name, 'start': segment['start'], 'end': segment['end']})
                    temp_files.append(f.name)
            except Exception as e:
                self.log_message(f"Fehler bei der Synthese von '{text}': {e}")
                silence_duration = max(int((segment['end'] - segment['start']) * 1000), 100)
                silence = AudioSegment.silent(duration=silence_duration)
                temp_silence_fd, temp_silence_path = tempfile.mkstemp(suffix=".wav")
                os.close(temp_silence_fd)
                silence.export(temp_silence_path, format="wav")
                synthesized_segments.append({'audio_path': temp_silence_path, 'start': segment['start'], 'end': segment['end']})
                temp_files.append(temp_silence_path)
            # Fortschritt aktualisieren
            progress = int(((current_step + (idx / len(segments))) / total_steps) * 100)
            self.progress_signal.emit(progress)
    
        current_step += 1
        self.progress_signal.emit(int((current_step / total_steps) * 100))
    
        # Zusammensetzen der Audios
        self.log_message("Zusammenfügen der Audiodateien...")
        total_duration_ms = int(segments[-1]['end'] * 1000)
        combined = AudioSegment.silent(duration=total_duration_ms)
        for segment in synthesized_segments:
            audio = AudioSegment.from_file(segment['audio_path'])
            start_ms = int(segment['start'] * 1000)
            combined = combined.overlay(audio, position=start_ms)
        output_audio_fd, output_audio_path = tempfile.mkstemp(suffix=".wav")
        os.close(output_audio_fd)
        combined.export(output_audio_path, format="wav")
        temp_files.append(output_audio_path)
    
        current_step += 1
        self.progress_signal.emit(int((current_step / total_steps) * 100))
    
        if is_video:
            self.log_message("Erstelle neues Video mit ersetzter Audiospur...")
            save_path, _ = QFileDialog.getSaveFileName(self, "Speichern Sie die neue Videodatei",
                                                       filter="MP4 Dateien (*.mp4)")
            if save_path:
                with VideoFileClip(self.file_to_process) as video:
                    new_video = video.set_audio(AudioFileClip(output_audio_path))
                    new_video.write_videofile(save_path, logger=None)
                self.log_message(f"Neues Video gespeichert unter: {save_path}")
        else:
            self.log_message("Speichere die neue Audiodatei...")
            save_path, _ = QFileDialog.getSaveFileName(self, "Speichern Sie die neue Audiodatei",
                                                       filter="WAV Dateien (*.wav)")
            if save_path:
                shutil.move(output_audio_path, save_path)
                temp_files.remove(output_audio_path)
                self.log_message(f"Neue Audiodatei gespeichert unter: {save_path}")
    
        self.log_message("Stimmtausch abgeschlossen.")
        self.progress_signal.emit(100)
    except Exception as e:
        logging.error(f"Fehler beim Stimmtausch: {e}")
        self.log_message(f"Fehler beim Stimmtausch: {e}")
        QtWidgets.QMessageBox.warning(self, "Fehler", f"Es ist ein Fehler aufgetreten:\n{str(e)}")
    finally:
        for temp_file in temp_files:
            if os.path.exists(temp_file):
                try:
                    os.remove(temp_file)
                except Exception as e:
                    logging.error(f"Fehler beim Löschen der temporären Datei '{temp_file}': {e}")
        self.enable_buttons_signal.emit(True)
        self.progress_signal.emit(0)
    

    @pyqtSlot(bool) def set_buttons_enabled(self, enabled): self.load_voice_button.setEnabled(enabled) self.delete_voice_button.setEnabled(enabled) self.train_voice_button.setEnabled(enabled) self.synthesize_button.setEnabled(enabled) self.select_preview_button.setEnabled(enabled) self.play_preview_button.setEnabled(enabled) self.stop_preview_button.setEnabled(enabled) self.select_file_button.setEnabled(enabled) self.replace_voice_button.setEnabled(enabled)

    def disable_all_buttons(self): self.enable_buttons_signal.emit(False)

    def enable_all_buttons(self): self.enable_buttons_signal.emit(True)

    @pyqtSlot(int) def update_progress(self, value): self.progress_bar.setVisible(value != 0) self.progress_bar.setValue(value)

    def log_message(self, message): self.log_signal.emit(message)

    @pyqtSlot(str) def update_log(self, message): self.message_label.setText(message) logging.debug(message) print(message)

    def ensure_models(self): if self.first_run: self.show_first_run_popup() else: threading.Thread(target=self.load_tts_models, daemon=True).start() threading.Thread(target=self.load_asr_models, daemon=True).start()

    def show_first_run_popup(self): # Implementierung des Popups für den ersten Start self.download_models_dialog = DownloadModelsDialog(self, self.language_models) self.download_models_dialog.exec_() self.first_run = False if 'General' not in self.config_parser: self.config_parser.add_section('General') self.config_parser.set('General', 'first_run', 'False') with open(self.config_file, 'w') as configfile: self.config_parser.write(configfile) threading.Thread(target=self.load_models_after_first_run, daemon=True).start()

    def load_models_after_first_run(self): selected_models = self.download_models_dialog.get_selected_models() for key in selected_models: kind, lang = key.split('_') if kind == 'tts': self.load_tts_model(lang) elif kind == 'asr': self.load_asr_model(lang)

    def show_download_models_popup(self): # Implementierung eines Dialogs zum Herunterladen von Modellen self.download_models_dialog = DownloadModelsDialog(self, self.language_models) self.download_models_dialog.exec_() selected_models = self.download_models_dialog.get_selected_models() for key in selected_models: kind, lang = key.split('_') if kind == 'tts': threading.Thread(target=self.load_tts_model, args=(lang,), daemon=True).start() elif kind == 'asr': threading.Thread(target=self.load_asr_model, args=(lang,), daemon=True).start()

    def load_tts_models(self): for language in self.language_models: threading.Thread(target=self.load_tts_model, args=(language,), daemon=True).start()

    def load_tts_model(self, language): self.log_message(f"Lade TTS-Modell für {language}...") try: paths = self.language_models[language] tts_model_name = paths["tts_model_name"] if tts_model_name: self.tts_models[language] = TTS(tts_model_name) self.log_message(f"TTS-Modell für {language} geladen.") else: self.log_message(f"Kein TTS-Modellname für {language} definiert.") except Exception as e: logging.error(f"Fehler beim Laden des TTS-Modells für {language}: {e}") self.log_message(f"Fehler beim Laden des TTS-Modells für {language}: {e}")

    def load_asr_models(self): for language in self.language_models: threading.Thread(target=self.load_asr_model, args=(language,), daemon=True).start()

    def load_asr_model(self, language): paths = self.language_models[language] asr_model_path = paths["asr_model_path"] if not asr_model_path.exists(): self.download_asr_model(language) else: self.log_message(f"ASR-Modell für {language} ist bereits vorhanden.") try: self.asr_models[language] = ASRModel(str(asr_model_path)) self.log_message(f"ASR-Modell für {language} geladen.") except Exception as e: logging.error(f"Fehler beim Laden des ASR-Modells für {language}: {e}") self.log_message(f"Fehler beim Laden des ASR-Modells für {language}: {e}") self.log_message(f"ASR-Modell für {language} ist bereit.")

    def download_asr_model(self, language): self.log_message(f"ASR-Modell für {language} wird heruntergeladen...") try: url = self.language_models[language]["asr_model_url"] model_zip_path = MODELS_DIR / f"asr_model_{language}.zip" MODELS_DIR.mkdir(parents=True, exist_ok=True) self.download_file(url, model_zip_path) # Entpacken des Modells with zipfile.ZipFile(model_zip_path, 'r') as zip_ref: zip_ref.extractall(MODELS_DIR) os.remove(model_zip_path) asr_model_path = self.language_models[language]["asr_model_path"] if asr_model_path.exists(): self.asr_models[language] = ASRModel(str(asr_model_path)) self.log_message(f"ASR-Modell für {language} erfolgreich heruntergeladen und eingerichtet.") else: raise Exception(f"ASR-Modellpfad {asr_model_path} existiert nach dem Entpacken nicht.") except Exception as e: logging.error(f"Fehler beim Herunterladen des ASR-Modells für {language}: {e}") self.log_message(f"Fehler beim Herunterladen des ASR-Modells für {language}: {e}")

    def download_file(self, url, dest_path): try: self.progress_signal.emit(0) with requests.get(url, stream=True) as response: response.raise_for_status() total_size = int(response.headers.get('content-length', 0)) block_size = 1024 * 1024 # 1MB wrote = 0 with open(dest_path, 'wb') as f: for data in response.iter_content(block_size): wrote += len(data) f.write(data) if total_size > 0: progress = int((wrote / total_size) * 100) self.progress_signal.emit(progress)

        if total_size != 0 and wrote != total_size:
            self.log_message(f"Fehler beim Herunterladen von {url}: Größe stimmt nicht überein.")
            raise Exception("Download unvollständig")
        self.progress_signal.emit(100)
    except requests.exceptions.RequestException as e:
        logging.error(f"Fehler beim Herunterladen der Datei {url}: {e}")
        self.log_message(f"Fehler beim Herunterladen der Datei {url}: {e}")
        raise
    finally:
        self.progress_signal.emit(0)
    

    @pyqtSlot() def change_language(self): self.current_language = self.language_combo.currentText() self.log_message(f"Sprache gewechselt zu {self.current_language}") # Lade Modelle für die ausgewählte Sprache, falls noch nicht geladen if self.current_language not in self.tts_models: threading.Thread(target=self.load_tts_model, args=(self.current_language,), daemon=True).start() if self.current_language not in self.asr_models: threading.Thread(target=self.load_asr_model, args=(self.current_language,), daemon=True).start()

    def detect_language(self, audio_path): temp_audio_path = audio_path try: self.log_message("Erkenne Sprache der Audiodatei...") # Ensure the file is in WAV format with appropriate parameters with wave.open(audio_path, "rb") as wf: sample_width = wf.getsampwidth() num_channels = wf.getnchannels() sample_rate = wf.getframerate() if sample_width != 2 or num_channels != 1: self.log_message("Konvertiere Audiodatei in Mono und 16-Bit PCM WAV...") sound = AudioSegment.from_file(audio_path) sound = sound.set_channels(1).set_sample_width(2).set_frame_rate(16000) temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav") os.close(temp_audio_fd) sound.export(temp_audio_path, format="wav")

        with wave.open(temp_audio_path, "rb") as wf_processed:
            frames = wf_processed.getnframes()
            rate = wf_processed.getframerate()
            data = wf_processed.readframes(frames)
    
        # Initialize recognizers
        rec_de = KaldiRecognizer(self.asr_models["Deutsch"], rate)
        rec_en = KaldiRecognizer(self.asr_models["Englisch"], rate)
    
        rec_de.SetWords(True)
        rec_en.SetWords(True)
    
        rec_de.AcceptWaveform(data)
        result_de = json.loads(rec_de.Result())
    
        rec_en.AcceptWaveform(data)
        result_en = json.loads(rec_en.Result())
    
        score_de = len(result_de.get('text', '').split())
        score_en = len(result_en.get('text', '').split())
    
        # Sprache mit dem höheren Score auswählen
        if score_de > score_en:
            self.log_message("Sprache Deutsch erkannt.")
            return "Deutsch"
        elif score_en > score_de:
            self.log_message("Sprache Englisch erkannt.")
            return "Englisch"
        else:
            self.log_message("Sprache konnte nicht eindeutig erkannt werden, verwende Standardsprache.")
            return self.current_language
    except Exception as e:
        logging.error(f"Fehler bei der Sprachenerkennung: {e}")
        self.log_message(f"Fehler bei der Sprachenerkennung: {e}")
        return self.current_language
    finally:
        # Temporäre Dateien löschen
        if temp_audio_path != audio_path and os.path.exists(temp_audio_path):
            try:
                os.remove(temp_audio_path)
            except Exception as e:
                logging.error(f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}")
    

    def transcribe_audio(self, audio_path, asr_model): try: temp_audio_path = audio_path # Sicherstellen, dass die Audiodatei im richtigen Format vorliegt with wave.open(audio_path, "rb") as wf: sample_width = wf.getsampwidth() num_channels = wf.getnchannels() sample_rate = wf.getframerate() if sample_width != 2 or num_channels != 1 or sample_rate != 16000: self.log_message("Konvertiere Audiodatei für die Transkription...") sound = AudioSegment.from_file(audio_path) sound = sound.set_channels(1).set_sample_width(2).set_frame_rate(16000) temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav") os.close(temp_audio_fd) sound.export(temp_audio_path, format="wav")

        with wave.open(temp_audio_path, "rb") as wf:
            rec = KaldiRecognizer(asr_model, wf.getframerate())
            rec.SetWords(True)
            results = []
            while True:
                data = wf.readframes(4000)
                if len(data) == 0:
                    break
                if rec.AcceptWaveform(data):
                    part_result = json.loads(rec.Result())
                    if 'result' in part_result:
                        results.extend(part_result['result'])
            final_result = json.loads(rec.FinalResult())
            if 'result' in final_result:
                results.extend(final_result['result'])
    
        # Segmente extrahieren
        segments = []
        for word_info in results:
            word = word_info['word']
            start = word_info['start']
            end = word_info['end']
            segments.append({'word': word, 'start': start, 'end': end})
    
        return segments
    except Exception as e:
        logging.error(f"Fehler bei der Transkription: {e}")
        self.log_message(f"Fehler bei der Transkription: {e}")
        return []
    finally:
        # Temporäre Datei löschen
        if temp_audio_path != audio_path and os.path.exists(temp_audio_path):
            try:
                os.remove(temp_audio_path)
            except Exception as e:
                logging.error(f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}")
    

    class DownloadModelsDialog(QtWidgets.QDialog): def init(self, parent, language_models): super().init(parent) self.setWindowTitle("Modelle auswählen") self.language_models = language_models self.selected_models = []

    self.init_ui()
    

    def init_ui(self): layout = QtWidgets.QVBoxLayout(self)

    label = QtWidgets.QLabel("Wählen Sie die Modelle aus, die Sie herunterladen möchten:")
    layout.addWidget(label)
    
    self.model_list = QtWidgets.QListWidget()
    self.model_list.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
    layout.addWidget(self.model_list)
    
    # Modelle hinzufügen
    for language in self.language_models:
        tts_item = QListWidgetItem(f"TTS Modell für {language}")
        tts_item.setData(Qt.UserRole, f"tts_{language}")
        self.model_list.addItem(tts_item)
    
        asr_item = QListWidgetItem(f"ASR Modell für {language}")
        asr_item.setData(Qt.UserRole, f"asr_{language}")
        self.model_list.addItem(asr_item)
    
    # Standardmäßig alle Modelle auswählen
    self.model_list.selectAll()
    
    # Buttons
    button_layout = QtWidgets.QHBoxLayout()
    layout.addLayout(button_layout)
    
    ok_button = QtWidgets.QPushButton("OK")
    ok_button.clicked.connect(self.accept)
    button_layout.addWidget(ok_button)
    
    cancel_button = QtWidgets.QPushButton("Abbrechen")
    cancel_button.clicked.connect(self.reject)
    button_layout.addWidget(cancel_button)
    

    def get_selected_models(self): selected_items = self.model_list.selectedItems() return [item.data(Qt.UserRole) for item in selected_items]

    if name == "main": try: app = QApplication(sys.argv) window = Speech2SpeechApp() window.show() sys.exit(app.exec_()) except Exception as e: logging.error(f"Fehler beim Starten der Anwendung: {e}") QMessageBox.critical(None, "Fehler", f"Fehler beim Starten der Anwendung:\n{e}")

  2. Assistant

    Der Fehler QWidget: Must construct a QApplication before a QWidget tritt auf, weil irgendwo im Code ein QWidget oder eine abgeleitete Klasse erstellt wird, bevor die QApplication-Instanz initialisiert wurde. In Ihrem ursprünglichen Skript wird die Überprüfung von espeak-ng mittels QMessageBox durchgeführt, bevor die QApplication erstellt wurde. Dies verursacht den genannten Fehler.

    Um alle Fehler und Probleme zu beheben, habe ich das Skript sorgfältig durchgesehen und folgende Korrekturen vorgenommen:

    1. Package-Installation: Verwendung von importlib zum dynamischen Importieren von Paketen und korrekte Installation fehlender Pakete.
    2. Reihenfolge der Initialisierung: Sicherstellung, dass die QApplication vor der Verwendung von QMessageBox oder anderen QWidget-basierten Klassen erstellt wird.
    3. Syntax- und Einrückungsfehler: Behebung von Syntaxfehlern wie def init zu def __init__ in Klassen und korrekte Einrückung aller Codeblöcke.
    4. Main-Block: Korrektur des if name == "main": Blocks zu if __name__ == "__main__":.
    5. Weitere Korrekturen: Sicherstellung, dass alle temporären Dateien ordnungsgemäß behandelt werden und dass alle Signal-Slots korrekt verbunden sind.

    Hier ist das vollständig korrigierte Skript:

    import sys
    import os
    import threading
    import tempfile
    import wave
    import json
    import shutil
    import queue
    import logging
    import configparser
    import mimetypes
    from pathlib import Path
    import zipfile
    import subprocess
    
    import importlib
    import requests
    from PyQt5 import QtWidgets, QtCore, QtGui
    from PyQt5.QtWidgets import (
        QApplication,
        QMainWindow,
        QFileDialog,
        QMessageBox,
        QProgressBar,
        QListWidgetItem,
    )
    from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
    
    # Prüfen und Installieren fehlender Python-Pakete
    required_packages = [
        "TTS",
        "vosk",
        "simpleaudio",
        "moviepy",
        "pydub",
        "librosa",
        "soundfile",
        "deep_translator",
        "requests",
    ]
    
    missing_packages = []
    for package in required_packages:
        try:
            importlib.import_module(package)
        except ImportError:
            missing_packages.append(package)
    
    if missing_packages:
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", *missing_packages])
            print(f"Folgende Pakete wurden installiert: {', '.join(missing_packages)}")
        except Exception as e:
            print(f"Fehler bei der automatischen Installation der Pakete: {e}")
            sys.exit(1)
    
    # Erneutes Importieren der Pakete nach Installation
    from TTS.api import TTS
    from vosk import Model as ASRModel, KaldiRecognizer
    import simpleaudio as sa
    from moviepy.editor import VideoFileClip, AudioFileClip
    from pydub import AudioSegment
    import librosa
    import soundfile as sf
    from deep_translator import GoogleTranslator
    
    # Setup logging
    logging.basicConfig(
        level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s"
    )
    
    # Constants for directories
    MODELS_DIR = Path("models")
    SAVED_VOICES_DIR = Path("saved_voices")
    
    
    class Speech2SpeechApp(QMainWindow):
        log_signal = pyqtSignal(str)
        progress_signal = pyqtSignal(int)
        enable_buttons_signal = pyqtSignal(bool)
    
        def __init__(self):
            super().__init__()
    
            self.setWindowTitle("Speech2Speech Anwendung")
            self.setGeometry(100, 100, 1200, 800)
    
            # Initialize variables
            self.speaker_embeddings = {}
            self.current_embedding = None
            self.synthesized_audio_path = None
            self.current_language = "Deutsch"
            self.asr_models = {}
            self.tts_models = {}
            self.language_models = {
                "Deutsch": {
                    "tts_model_name": "tts_models/de/thorsten/tacotron2-DCA",
                    "asr_model_path": MODELS_DIR / "vosk-model-small-de-0.15",
                    "asr_model_url": "https://alphacephei.com/vosk/models/vosk-model-small-de-0.15.zip",
                    "language_code": "de",
                },
                "Englisch": {
                    "tts_model_name": "tts_models/en/ljspeech/tacotron2-DDC",
                    "asr_model_path": MODELS_DIR / "vosk-model-small-en-us-0.15",
                    "asr_model_url": "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip",
                    "language_code": "en",
                },
                # Weitere Sprachen können hier hinzugefügt werden
            }
    
            self.file_to_process = None  # Initialisierung der Datei-Variable
    
            # Einstellungen laden
            self.config_parser = configparser.ConfigParser()
            self.config_file = "settings.ini"
            if os.path.exists(self.config_file):
                self.config_parser.read(self.config_file)
                self.first_run = self.config_parser.getboolean(
                    "General", "first_run", fallback=True
                )
            else:
                self.first_run = True
    
            self.queue = queue.Queue()
            self.progress_bars = []
            self.progress_bar_colors = [
                "#6699CC",
                "#66CC99",
                "#CC6699",
                "#FFCC66",
                "#66FFCC",
            ]
    
            # Signale verbinden
            self.log_signal.connect(self.update_log)
            self.progress_signal.connect(self.update_progress)
            self.enable_buttons_signal.connect(self.set_buttons_enabled)
    
            self.init_ui()
            self.load_saved_voices()
            self.ensure_models()
    
        def init_ui(self):
            # Erstellen des Haupt-Widgets
            self.central_widget = QtWidgets.QWidget()
            self.setCentralWidget(self.central_widget)
    
            # Hauptlayout
            self.main_layout = QtWidgets.QVBoxLayout(self.central_widget)
    
            # Menüleiste erstellen
            self.create_menu()
    
            # Tabs erstellen
            self.create_tabs()
    
            # Statusleiste erstellen
            self.create_status_bar()
    
        def create_menu(self):
            # Menüleiste
            self.menu_bar = self.menuBar()
    
            # Datei-Menü
            self.file_menu = self.menu_bar.addMenu("Datei")
            self.open_file_action = QtWidgets.QAction("Datei öffnen", self)
            self.open_file_action.triggered.connect(self.select_audio_video_file)
            self.file_menu.addAction(self.open_file_action)
    
            self.exit_action = QtWidgets.QAction("Beenden", self)
            self.exit_action.triggered.connect(self.close)
            self.file_menu.addAction(self.exit_action)
    
            # Einstellungen-Menü
            self.settings_menu = self.menu_bar.addMenu("Einstellungen")
            self.change_language_action = QtWidgets.QAction("Sprache ändern", self)
            self.change_language_action.triggered.connect(self.change_language)
            self.settings_menu.addAction(self.change_language_action)
    
            self.download_models_action = QtWidgets.QAction("Modelle herunterladen", self)
            self.download_models_action.triggered.connect(
                self.show_download_models_popup
            )
            self.settings_menu.addAction(self.download_models_action)
    
            # Hilfe-Menü
            self.help_menu = self.menu_bar.addMenu("Hilfe")
            self.about_action = QtWidgets.QAction("Über", self)
            self.about_action.triggered.connect(self.show_about)
            self.help_menu.addAction(self.about_action)
    
        def create_tabs(self):
            # Tabs erstellen
            self.tabs = QtWidgets.QTabWidget()
            self.main_layout.addWidget(self.tabs)
    
            # Tab 1: Stimmenverwaltung
            self.tab_voices = QtWidgets.QWidget()
            self.tabs.addTab(self.tab_voices, "Stimmenverwaltung")
            self.create_voice_tab()
    
            # Tab 2: Text Synthese
            self.tab_synthesize = QtWidgets.QWidget()
            self.tabs.addTab(self.tab_synthesize, "Text Synthese")
            self.create_synthesize_tab()
    
            # Tab 3: Stimmtausch
            self.tab_replace = QtWidgets.QWidget()
            self.tabs.addTab(self.tab_replace, "Stimmtausch")
            self.create_replace_tab()
    
            # Tab 4: Einstellungen
            self.tab_settings = QtWidgets.QWidget()
            self.tabs.addTab(self.tab_settings, "Einstellungen")
            self.create_settings_tab()
    
            # Tab 5: Vorschau
            self.tab_preview = QtWidgets.QWidget()
            self.tabs.addTab(self.tab_preview, "Vorschau")
            self.create_preview_tab()
    
        def create_voice_tab(self):
            layout = QtWidgets.QVBoxLayout(self.tab_voices)
    
            # Stimmenliste
            self.voice_list = QtWidgets.QListWidget()
            self.voice_list.itemClicked.connect(self.voice_selected)
            layout.addWidget(self.voice_list)
    
            # Buttons
            button_layout = QtWidgets.QHBoxLayout()
            layout.addLayout(button_layout)
    
            self.load_voice_button = QtWidgets.QPushButton("Stimme laden")
            self.load_voice_button.clicked.connect(self.load_voice)
            button_layout.addWidget(self.load_voice_button)
    
            self.delete_voice_button = QtWidgets.QPushButton("Stimme löschen")
            self.delete_voice_button.clicked.connect(self.delete_voice)
            button_layout.addWidget(self.delete_voice_button)
    
            self.train_voice_button = QtWidgets.QPushButton("Neue Stimme trainieren")
            self.train_voice_button.clicked.connect(self.train_new_voice)
            button_layout.addWidget(self.train_voice_button)
    
        def create_synthesize_tab(self):
            layout = QtWidgets.QVBoxLayout(self.tab_synthesize)
    
            # Texteingabe
            self.text_input = QtWidgets.QTextEdit()
            layout.addWidget(self.text_input)
    
            # Beispieltexte
            example_layout = QtWidgets.QHBoxLayout()
            layout.addLayout(example_layout)
            self.example1_button = QtWidgets.QPushButton("Beispiel 1")
            self.example1_button.clicked.connect(lambda: self.insert_example_text(1))
            example_layout.addWidget(self.example1_button)
    
            self.example2_button = QtWidgets.QPushButton("Beispiel 2")
            self.example2_button.clicked.connect(lambda: self.insert_example_text(2))
            example_layout.addWidget(self.example2_button)
    
            # Einstellungen
            settings_layout = QtWidgets.QFormLayout()
            layout.addLayout(settings_layout)
    
            self.rate_slider = QtWidgets.QSlider(Qt.Horizontal)
            self.rate_slider.setMinimum(50)
            self.rate_slider.setMaximum(200)
            self.rate_slider.setValue(100)
            self.rate_slider.setTickInterval(10)
            self.rate_slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
            settings_layout.addRow("Sprechgeschwindigkeit:", self.rate_slider)
    
            self.pitch_slider = QtWidgets.QSlider(Qt.Horizontal)
            self.pitch_slider.setMinimum(50)
            self.pitch_slider.setMaximum(200)
            self.pitch_slider.setValue(100)
            self.pitch_slider.setTickInterval(10)
            self.pitch_slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
            settings_layout.addRow("Tonhöhe:", self.pitch_slider)
    
            # Synthese-Button
            self.synthesize_button = QtWidgets.QPushButton("Text synthetisieren")
            self.synthesize_button.clicked.connect(self.synthesize_voice)
            layout.addWidget(self.synthesize_button)
    
        def create_replace_tab(self):
            layout = QtWidgets.QVBoxLayout(self.tab_replace)
    
            # Datei auswählen
            self.select_file_button = QtWidgets.QPushButton(
                "Audio-/Videodatei auswählen"
            )
            self.select_file_button.clicked.connect(self.select_audio_video_file)
            layout.addWidget(self.select_file_button)
    
            # Übersetzungsoption
            self.translate_checkbox = QtWidgets.QCheckBox(
                "Englische Sprache ins Deutsche übersetzen"
            )
            layout.addWidget(self.translate_checkbox)
    
            # Stimme ersetzen Button
            self.replace_voice_button = QtWidgets.QPushButton("Stimme in Datei ersetzen")
            self.replace_voice_button.clicked.connect(self.replace_voice_in_file)
            layout.addWidget(self.replace_voice_button)
    
        def create_settings_tab(self):
            layout = QtWidgets.QFormLayout(self.tab_settings)
    
            # Spracheinstellungen
            self.language_combo = QtWidgets.QComboBox()
            self.language_combo.addItems(self.language_models.keys())
            self.language_combo.setCurrentText(self.current_language)
            self.language_combo.currentTextChanged.connect(self.change_language)
            layout.addRow("Sprache:", self.language_combo)
    
            # Audioformat-Einstellungen
            self.audio_format_combo = QtWidgets.QComboBox()
            self.audio_format_combo.addItems(["wav", "mp3"])
            layout.addRow("Audioformat:", self.audio_format_combo)
    
        def create_preview_tab(self):
            layout = QtWidgets.QVBoxLayout(self.tab_preview)
    
            # Audiodatei auswählen
            self.select_preview_button = QtWidgets.QPushButton(
                "Audiodatei zur Vorschau auswählen"
            )
            self.select_preview_button.clicked.connect(self.select_preview_file)
            layout.addWidget(self.select_preview_button)
    
            # Wiedergabe-Steuerung
            control_layout = QtWidgets.QHBoxLayout()
            layout.addLayout(control_layout)
            self.play_preview_button = QtWidgets.QPushButton("Abspielen")
            self.play_preview_button.clicked.connect(self.play_preview)
            control_layout.addWidget(self.play_preview_button)
    
            self.stop_preview_button = QtWidgets.QPushButton("Stoppen")
            self.stop_preview_button.clicked.connect(self.stop_preview)
            control_layout.addWidget(self.stop_preview_button)
    
        def create_status_bar(self):
            # Statusleiste
            self.status_bar = self.statusBar()
    
            # Fortschrittsbalken
            self.progress_bar = QProgressBar()
            self.progress_bar.setVisible(False)
            self.status_bar.addPermanentWidget(self.progress_bar)
    
            # Nachrichtenbereich
            self.message_label = QtWidgets.QLabel()
            self.status_bar.addWidget(self.message_label)
    
        @pyqtSlot()
        def show_about(self):
            QMessageBox.information(
                self,
                "Über",
                "Speech2Speech Anwendung\nVersion 1.0\nEntwickelt von Ihrem Namen",
            )
    
        def load_saved_voices(self):
            SAVED_VOICES_DIR.mkdir(exist_ok=True)
            self.voice_list.clear()
            for voice_file in SAVED_VOICES_DIR.glob("*.wav"):
                voice_name = voice_file.stem
                item = QListWidgetItem(voice_name)
                self.voice_list.addItem(item)
                self.speaker_embeddings[voice_name] = str(voice_file)
    
        @pyqtSlot()
        def voice_selected(self):
            selected_item = self.voice_list.currentItem()
            if selected_item:
                self.current_embedding = self.speaker_embeddings[selected_item.text()]
                self.log_message(f"Stimme '{selected_item.text()}' wurde ausgewählt.")
    
        @pyqtSlot()
        def load_voice(self):
            selected_item = self.voice_list.currentItem()
            if selected_item:
                self.current_embedding = self.speaker_embeddings[selected_item.text()]
                self.log_message(f"Stimme '{selected_item.text()}' wurde geladen.")
            else:
                self.log_message("Keine Stimme ausgewählt.")
    
        @pyqtSlot()
        def delete_voice(self):
            selected_item = self.voice_list.currentItem()
            if selected_item:
                voice_name = selected_item.text()
                reply = QMessageBox.question(
                    self,
                    "Bestätigung",
                    f"Möchten Sie die Stimme '{voice_name}' wirklich löschen?",
                    QMessageBox.Yes | QMessageBox.No,
                    QMessageBox.No,
                )
                if reply == QMessageBox.Yes:
                    try:
                        os.remove(self.speaker_embeddings[voice_name])
                        del self.speaker_embeddings[voice_name]
                        self.voice_list.takeItem(self.voice_list.row(selected_item))
                        self.log_message(f"Stimme '{voice_name}' wurde gelöscht.")
                    except Exception as e:
                        logging.error(
                            f"Fehler beim Löschen der Stimme '{voice_name}': {e}"
                        )
                        self.log_message(
                            f"Fehler beim Löschen der Stimme '{voice_name}': {e}"
                        )
            else:
                self.log_message("Keine Stimme ausgewählt.")
    
        @pyqtSlot()
        def train_new_voice(self):
            file_dialog = QFileDialog(self)
            file_dialog.setFileMode(QFileDialog.ExistingFiles)
            file_dialog.setNameFilters(
                ["Audio Dateien (*.wav *.mp3 *.flac *.ogg *.opus)"]
            )
            if file_dialog.exec_():
                file_paths = file_dialog.selectedFiles()
                voice_name, ok = QtWidgets.QInputDialog.getText(
                    self,
                    "Stimmenname",
                    "Geben Sie einen Namen für die neue Stimme ein:",
                )
                if ok and voice_name:
                    if voice_name in self.speaker_embeddings:
                        QMessageBox.warning(
                            self, "Warnung", f"Stimme '{voice_name}' existiert bereits."
                        )
                        return
                    threading.Thread(
                        target=self.train_voice_thread, args=(file_paths, voice_name), daemon=True
                    ).start()
                else:
                    self.log_message("Kein Stimmenname eingegeben.")
    
        def train_voice_thread(self, file_paths, voice_name):
            self.progress_signal.emit(0)
            self.enable_buttons_signal.emit(False)
            preprocessed_files = []
            try:
                total_files = len(file_paths)
                for idx, file_path in enumerate(file_paths, 1):
                    preprocessed_path = self.preprocess_audio(file_path)
                    if preprocessed_path:
                        preprocessed_files.append(preprocessed_path)
                    else:
                        self.log_message(
                            f"Überspringe Datei {file_path} aufgrund von Vorverarbeitungsfehlern."
                        )
                    progress = int((idx / (total_files * 2)) * 100)
                    self.progress_signal.emit(progress)
    
                if not preprocessed_files:
                    self.log_message("Keine gültigen Audiodateien für das Training vorhanden.")
                    return
    
                # Kombiniere vorverarbeitete Dateien in eine Datei
                combined_audio = AudioSegment.empty()
                for preprocessed_file in preprocessed_files:
                    audio_segment = AudioSegment.from_file(preprocessed_file)
                    combined_audio += audio_segment
    
                # Speichere kombiniertes Audio
                save_path = SAVED_VOICES_DIR / f"{voice_name}.wav"
                combined_audio.export(str(save_path), format="wav")
                self.speaker_embeddings[voice_name] = str(save_path)
                self.log_signal.emit(f"Stimme '{voice_name}' wurde erfolgreich erstellt.")
                self.progress_signal.emit(100)
                self.enable_buttons_signal.emit(True)
                self.load_saved_voices()
            except Exception as e:
                logging.error(f"Fehler beim Training der Stimme: {e}")
                self.log_message(f"Fehler beim Training der Stimme: {e}")
            finally:
                # Temporäre Dateien löschen
                for preprocessed_file in preprocessed_files:
                    try:
                        os.remove(preprocessed_file)
                    except Exception as e:
                        logging.error(
                            f"Fehler beim Löschen der temporären Datei '{preprocessed_file}': {e}"
                        )
                self.enable_buttons_signal.emit(True)
                self.progress_signal.emit(0)
    
        def preprocess_audio(self, file_path):
            temp_audio_path = None  # Initialisieren
            try:
                self.log_message(f"Vorverarbeitung der Audiodatei: {file_path}")
                mime_type, _ = mimetypes.guess_type(file_path)
                if mime_type and mime_type.startswith("video"):
                    self.log_message("Video-Datei erkannt, extrahiere Audio...")
                    # Extrahieren des Audio-Teils aus der Video-Datei
                    with VideoFileClip(file_path) as video:
                        audio = video.audio
                        temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav")
                        os.close(temp_audio_fd)
                        audio.write_audiofile(temp_audio_path, logger=None)
                    file_path = temp_audio_path
    
                # Konvertieren und Laden der Audiodatei
                sound = AudioSegment.from_file(file_path)
                sound = sound.set_frame_rate(22050).set_channels(1)
                temp_processed_fd, preprocessed_path = tempfile.mkstemp(suffix=".wav")
                os.close(temp_processed_fd)
                sound.export(preprocessed_path, format="wav")
                y, sr = librosa.load(preprocessed_path, sr=22050, mono=True)
    
                # Überprüfen der Länge
                if len(y) < sr * 1:  # Mindestens 1 Sekunde
                    self.log_message(
                        f"Audiodatei '{file_path}' ist zu kurz. Mindestens 1 Sekunde erforderlich."
                    )
                    os.remove(preprocessed_path)
                    return None
    
                # Normalisierung
                y = librosa.util.normalize(y)
    
                # Speichern der normalisierten Audiodaten
                sf.write(preprocessed_path, y, sr)
                self.log_message(f"Vorverarbeitung der Audiodatei '{file_path}' abgeschlossen.")
                return preprocessed_path
            except Exception as e:
                logging.error(
                    f"Fehler bei der Vorverarbeitung der Audiodatei '{file_path}': {e}"
                )
                self.log_message(
                    f"Fehler bei der Vorverarbeitung der Audiodatei '{file_path}': {e}"
                )
                return None
            finally:
                # Temporäre Dateien löschen
                if temp_audio_path and os.path.exists(temp_audio_path):
                    try:
                        os.remove(temp_audio_path)
                    except Exception as e:
                        logging.error(
                            f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}"
                        )
    
        @pyqtSlot()
        def insert_example_text(self, example_number):
            examples = {
                1: "Dies ist ein Beispieltext für die Sprachsynthese.",
                2: "Willkommen bei der verbesserten Speech2Speech Anwendung!",
            }
            self.text_input.setPlainText(examples.get(example_number, ""))
    
        @pyqtSlot()
        def synthesize_voice(self):
            selected_item = self.voice_list.currentItem()
            if not selected_item:
                QMessageBox.warning(self, "Warnung", "Bitte wählen Sie eine Stimme aus.")
                return
    
            if self.current_embedding is None:
                QMessageBox.warning(self, "Warnung", "Keine gültige Stimme geladen.")
                return
    
            text_to_speak = self.text_input.toPlainText().strip()
            if not text_to_speak:
                QMessageBox.warning(self, "Warnung", "Bitte geben Sie einen Text ein.")
                return
    
            threading.Thread(
                target=self.synthesize_voice_thread, args=(text_to_speak,), daemon=True
            ).start()
    
        def synthesize_voice_thread(self, text_to_speak):
            self.progress_signal.emit(0)
            self.enable_buttons_signal.emit(False)
    
            tts_model = self.tts_models.get(self.current_language)
            if not tts_model:
                # TTS-Modell nicht vorhanden, Vorschlag zum Herunterladen
                self.enable_buttons_signal.emit(True)
                self.progress_signal.emit(0)
                self.log_message(
                    f"TTS-Modell für {self.current_language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'."
                )
                return
    
            try:
                language_code = self.language_models[self.current_language]["language_code"]
    
                # TTS-Einstellungen berücksichtigen
                rate = self.rate_slider.value() / 100
                pitch = self.pitch_slider.value() / 100
    
                with tempfile.NamedTemporaryFile(
                    suffix=".wav", delete=False
                ) as f:
                    tts_model.tts_to_file(
                        text=text_to_speak,
                        speaker_wav=self.current_embedding,
                        language=language_code,
                        file_path=f.name,
                    )
                    synthesized_audio = AudioSegment.from_file(f.name)
                    # Geschwindigkeit und Tonhöhe anpassen
                    # Zuerst die Tonhöhe anpassen
                    octaves = pitch - 1.0  # Berechnung der Oktavenänderung
                    new_sample_rate = int(synthesized_audio.frame_rate * (2.0 ** octaves))
                    synthesized_audio = synthesized_audio._spawn(
                        synthesized_audio.raw_data, overrides={"frame_rate": new_sample_rate}
                    )
                    # Dann die Geschwindigkeit anpassen
                    synthesized_audio = synthesized_audio.speedup(playback_speed=rate)
                    # Speichern der angepassten Audiodatei
                    synthesized_audio = synthesized_audio.set_frame_rate(22050)
                    synthesized_audio.export(f.name, format=self.audio_format_combo.currentText())
                    self.synthesized_audio_path = f.name
    
                self.log_message("Synthese abgeschlossen.")
                self.progress_signal.emit(100)
                self.update_preview(self.synthesized_audio_path)
                self.play_synthesized_audio()
            except Exception as e:
                logging.error(f"Fehler bei der Sprachsynthese: {e}")
                self.log_message(f"Fehler bei der Sprachsynthese: {e}")
                QtWidgets.QMessageBox.warning(
                    self, "Fehler", f"Fehler bei der Sprachsynthese:\n{e}"
                )
            finally:
                self.enable_buttons_signal.emit(True)
                self.progress_signal.emit(0)
    
        def play_synthesized_audio(self):
            try:
                wave_obj = sa.WaveObject.from_wave_file(self.synthesized_audio_path)
                play_obj = wave_obj.play()
                play_obj.wait_done()
                self.log_message("Synthese abgeschlossen und abgespielt.")
            except Exception as e:
                logging.error(
                    f"Fehler beim Abspielen der synthetisierten Audiodatei: {e}"
                )
                self.log_message(
                    f"Fehler beim Abspielen der synthetisierten Audiodatei: {e}"
                )
    
        def update_preview(self, audio_path):
            self.preview_audio_path = audio_path
            self.log_message(f"Vorschau-Audiodatei aktualisiert: {audio_path}")
    
        @pyqtSlot()
        def select_preview_file(self):
            file_dialog = QFileDialog(self)
            file_dialog.setNameFilters(
                ["Audio Dateien (*.wav *.mp3 *.flac *.ogg *.opus)"]
            )
            if file_dialog.exec_():
                file_path = file_dialog.selectedFiles()[0]
                self.preview_audio_path = file_path
                self.log_message(f"Vorschau-Datei ausgewählt: {os.path.basename(file_path)}")
    
        @pyqtSlot()
        def play_preview(self):
            if not hasattr(self, "preview_audio_path") or not self.preview_audio_path:
                QMessageBox.warning(self, "Warnung", "Keine Datei zur Vorschau ausgewählt.")
                return
            threading.Thread(target=self.play_preview_thread, daemon=True).start()
    
        def play_preview_thread(self):
            try:
                # Ensure the file is in WAV format
                if not self.preview_audio_path.lower().endswith(".wav"):
                    self.log_message("Konvertiere Datei zur Vorschau in WAV-Format...")
                    audio = AudioSegment.from_file(self.preview_audio_path)
                    temp_preview_fd, temp_preview_path = tempfile.mkstemp(suffix=".wav")
                    os.close(temp_preview_fd)
                    audio.export(temp_preview_path, format="wav")
                    self.preview_audio_path = temp_preview_path  # Update to the temp WAV file
    
                wave_obj = sa.WaveObject.from_wave_file(self.preview_audio_path)
                self.preview_play_obj = wave_obj.play()
                self.preview_play_obj.wait_done()
                self.log_message("Vorschau abgespielt.")
    
                # Temporäre Datei löschen
                if self.preview_audio_path.endswith(".wav") and os.path.exists(
                    self.preview_audio_path
                ):
                    os.remove(self.preview_audio_path)
                    self.preview_audio_path = None
            except Exception as e:
                logging.error(f"Fehler beim Abspielen der Vorschau: {e}")
                self.log_message(f"Fehler beim Abspielen der Vorschau: {e}")
                QtWidgets.QMessageBox.warning(
                    self, "Fehler", f"Fehler beim Abspielen der Vorschau:\n{e}"
                )
    
        @pyqtSlot()
        def stop_preview(self):
            if hasattr(self, "preview_play_obj"):
                self.preview_play_obj.stop()
                self.log_message("Vorschau-Wiedergabe gestoppt.")
            else:
                self.log_message("Keine laufende Vorschau-Wiedergabe.")
    
        @pyqtSlot()
        def select_audio_video_file(self):
            file_dialog = QFileDialog(self)
            file_dialog.setNameFilters(
                [
                    "Audio Dateien (*.wav *.mp3 *.flac *.ogg *.opus)",
                    "Video Dateien (*.mp4 *.avi *.mov *.mkv)",
                    "Alle Dateien (*)",
                ]
            )
            if file_dialog.exec_():
                self.file_to_process = file_dialog.selectedFiles()[0]
                self.log_message(f"Datei ausgewählt: {os.path.basename(self.file_to_process)}")
    
        @pyqtSlot()
        def replace_voice_in_file(self):
            if not self.file_to_process:
                QMessageBox.warning(self, "Warnung", "Bitte wählen Sie zuerst eine Datei aus.")
                return
    
            selected_item = self.voice_list.currentItem()
            if not selected_item:
                QMessageBox.warning(self, "Warnung", "Bitte wählen Sie eine Stimme aus.")
                return
    
            if self.current_embedding is None:
                QMessageBox.warning(self, "Warnung", "Keine gültige Stimme geladen.")
                return
    
            threading.Thread(target=self.replace_voice_thread, daemon=True).start()
    
        def replace_voice_thread(self):
            self.progress_signal.emit(0)
            self.enable_buttons_signal.emit(False)
    
            temp_files = []
            try:
                total_steps = 8
                current_step = 0
    
                # Audio extrahieren (falls Video)
                mime_type, _ = mimetypes.guess_type(self.file_to_process)
                if mime_type and mime_type.startswith("video"):
                    self.log_message("Video-Datei erkannt, extrahiere Audio...")
                    with VideoFileClip(self.file_to_process) as video:
                        audio = video.audio
                        temp_audio_fd, audio_path = tempfile.mkstemp(suffix=".wav")
                        os.close(temp_audio_fd)
                        audio.write_audiofile(audio_path, logger=None)
                        temp_files.append(audio_path)
                        is_video = True
                else:
                    audio_path = self.file_to_process
                    is_video = False
    
                current_step += 1
                self.progress_signal.emit(int((current_step / total_steps) * 100))
    
                # Spracherkennung (ASR)
                self.log_message("Spracherkennung läuft...")
                language = self.detect_language(audio_path)
    
                asr_model = self.asr_models.get(language)
                tts_model = self.tts_models.get(language)
    
                if not asr_model:
                    self.enable_buttons_signal.emit(True)
                    self.progress_signal.emit(0)
                    self.log_message(
                        f"ASR-Modell für {language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'."
                    )
                    return
    
                if not tts_model:
                    self.enable_buttons_signal.emit(True)
                    self.progress_signal.emit(0)
                    self.log_message(
                        f"TTS-Modell für {language} ist nicht geladen. Bitte laden Sie es über 'Einstellungen > Modelle herunterladen'."
                    )
                    return
    
                language_code = self.language_models[language]["language_code"]
    
                segments = self.transcribe_audio(audio_path, asr_model)
                if not segments:
                    raise Exception("Keine Sprache im Audio erkannt.")
    
                current_step += 1
                self.progress_signal.emit(int((current_step / total_steps) * 100))
    
                # Übersetzung ins Deutsche (falls ausgewählt)
                if self.translate_checkbox.isChecked() and language == "Englisch":
                    self.log_message("Übersetzung läuft...")
                    try:
                        # Text sammeln
                        text = " ".join([seg["word"] for seg in segments])
                        translated_text = GoogleTranslator(source="en", target="de").translate(
                            text
                        )
                        translated_words = translated_text.split()
                        # Übersetzte Wörter den Segmenten zuweisen
                        for idx, seg in enumerate(segments):
                            if idx < len(translated_words):
                                seg["word"] = translated_words[idx]
                    except Exception as e:
                        self.log_message(f"Fehler bei der Übersetzung: {e}")
    
                current_step += 1
                self.progress_signal.emit(int((current_step / total_steps) * 100))
    
                # Generiere synthetisierte Audios für jedes Segment
                self.log_message("Synthese der neuen Stimme läuft...")
                synthesized_segments = []
                for idx, segment in enumerate(segments):
                    text = segment["word"]
                    if not text.strip():
                        continue
                    try:
                        with tempfile.NamedTemporaryFile(
                            suffix=".wav", delete=False
                        ) as f:
                            tts_model.tts_to_file(
                                text=text,
                                speaker_wav=self.current_embedding,
                                language=language_code,
                                file_path=f.name,
                            )
                            synthesized_segments.append(
                                {
                                    "audio_path": f.name,
                                    "start": segment["start"],
                                    "end": segment["end"],
                                }
                            )
                            temp_files.append(f.name)
                    except Exception as e:
                        self.log_message(f"Fehler bei der Synthese von '{text}': {e}")
                        silence_duration = max(
                            int((segment["end"] - segment["start"]) * 1000), 100
                        )
                        silence = AudioSegment.silent(duration=silence_duration)
                        temp_silence_fd, temp_silence_path = tempfile.mkstemp(
                            suffix=".wav"
                        )
                        os.close(temp_silence_fd)
                        silence.export(temp_silence_path, format="wav")
                        synthesized_segments.append(
                            {
                                "audio_path": temp_silence_path,
                                "start": segment["start"],
                                "end": segment["end"],
                            }
                        )
                        temp_files.append(temp_silence_path)
                    # Fortschritt aktualisieren
                    progress = int(
                        ((current_step + (idx / len(segments))) / total_steps) * 100
                    )
                    self.progress_signal.emit(progress)
    
                current_step += 1
                self.progress_signal.emit(int((current_step / total_steps) * 100))
    
                # Zusammensetzen der Audios
                self.log_message("Zusammenfügen der Audiodateien...")
                total_duration_ms = int(segments[-1]["end"] * 1000)
                combined = AudioSegment.silent(duration=total_duration_ms)
                for segment in synthesized_segments:
                    audio = AudioSegment.from_file(segment["audio_path"])
                    start_ms = int(segment["start"] * 1000)
                    combined = combined.overlay(audio, position=start_ms)
                output_audio_fd, output_audio_path = tempfile.mkstemp(suffix=".wav")
                os.close(output_audio_fd)
                combined.export(output_audio_path, format="wav")
                temp_files.append(output_audio_path)
    
                current_step += 1
                self.progress_signal.emit(int((current_step / total_steps) * 100))
    
                if is_video:
                    self.log_message("Erstelle neues Video mit ersetzter Audiospur...")
                    save_path, _ = QFileDialog.getSaveFileName(
                        self, "Speichern Sie die neue Videodatei", filter="MP4 Dateien (*.mp4)"
                    )
                    if save_path:
                        with VideoFileClip(self.file_to_process) as video:
                            new_video = video.set_audio(AudioFileClip(output_audio_path))
                            new_video.write_videofile(save_path, logger=None)
                        self.log_message(f"Neues Video gespeichert unter: {save_path}")
                else:
                    self.log_message("Speichere die neue Audiodatei...")
                    save_path, _ = QFileDialog.getSaveFileName(
                        self, "Speichern Sie die neue Audiodatei", filter="WAV Dateien (*.wav)"
                    )
                    if save_path:
                        shutil.move(output_audio_path, save_path)
                        temp_files.remove(output_audio_path)
                        self.log_message(f"Neue Audiodatei gespeichert unter: {save_path}")
    
                self.log_message("Stimmtausch abgeschlossen.")
                self.progress_signal.emit(100)
            except Exception as e:
                logging.error(f"Fehler beim Stimmtausch: {e}")
                self.log_message(f"Fehler beim Stimmtausch: {e}")
                QtWidgets.QMessageBox.warning(
                    self, "Fehler", f"Es ist ein Fehler aufgetreten:\n{str(e)}"
                )
            finally:
                for temp_file in temp_files:
                    if os.path.exists(temp_file):
                        try:
                            os.remove(temp_file)
                        except Exception as e:
                            logging.error(
                                f"Fehler beim Löschen der temporären Datei '{temp_file}': {e}"
                            )
                self.enable_buttons_signal.emit(True)
                self.progress_signal.emit(0)
    
        @pyqtSlot(bool)
        def set_buttons_enabled(self, enabled):
            self.load_voice_button.setEnabled(enabled)
            self.delete_voice_button.setEnabled(enabled)
            self.train_voice_button.setEnabled(enabled)
            self.synthesize_button.setEnabled(enabled)
            self.select_preview_button.setEnabled(enabled)
            self.play_preview_button.setEnabled(enabled)
            self.stop_preview_button.setEnabled(enabled)
            self.select_file_button.setEnabled(enabled)
            self.replace_voice_button.setEnabled(enabled)
    
        def disable_all_buttons(self):
            self.enable_buttons_signal.emit(False)
    
        def enable_all_buttons(self):
            self.enable_buttons_signal.emit(True)
    
        @pyqtSlot(int)
        def update_progress(self, value):
            self.progress_bar.setVisible(value != 0)
            self.progress_bar.setValue(value)
    
        def log_message(self, message):
            self.log_signal.emit(message)
    
        @pyqtSlot(str)
        def update_log(self, message):
            self.message_label.setText(message)
            logging.debug(message)
            print(message)
    
        def ensure_models(self):
            if self.first_run:
                self.show_first_run_popup()
            else:
                threading.Thread(target=self.load_tts_models, daemon=True).start()
                threading.Thread(target=self.load_asr_models, daemon=True).start()
    
        def show_first_run_popup(self):
            # Implementierung des Popups für den ersten Start
            self.download_models_dialog = DownloadModelsDialog(
                self, self.language_models
            )
            if self.download_models_dialog.exec_():
                self.first_run = False
                if "General" not in self.config_parser:
                    self.config_parser.add_section("General")
                self.config_parser.set("General", "first_run", "False")
                with open(self.config_file, "w") as configfile:
                    self.config_parser.write(configfile)
                threading.Thread(
                    target=self.load_models_after_first_run, daemon=True
                ).start()
    
        def load_models_after_first_run(self):
            selected_models = self.download_models_dialog.get_selected_models()
            for key in selected_models:
                kind, lang = key.split("_", 1)
                if kind == "tts":
                    self.load_tts_model(lang)
                elif kind == "asr":
                    self.load_asr_model(lang)
    
        def show_download_models_popup(self):
            # Implementierung eines Dialogs zum Herunterladen von Modellen
            self.download_models_dialog = DownloadModelsDialog(
                self, self.language_models
            )
            if self.download_models_dialog.exec_():
                selected_models = self.download_models_dialog.get_selected_models()
                for key in selected_models:
                    kind, lang = key.split("_", 1)
                    if kind == "tts":
                        threading.Thread(
                            target=self.load_tts_model, args=(lang,), daemon=True
                        ).start()
                    elif kind == "asr":
                        threading.Thread(
                            target=self.load_asr_model, args=(lang,), daemon=True
                        ).start()
    
        def load_tts_models(self):
            for language in self.language_models:
                threading.Thread(target=self.load_tts_model, args=(language,), daemon=True).start()
    
        def load_tts_model(self, language):
            self.log_message(f"Lade TTS-Modell für {language}...")
            try:
                paths = self.language_models[language]
                tts_model_name = paths["tts_model_name"]
                if tts_model_name:
                    self.tts_models[language] = TTS(tts_model_name)
                    self.log_message(f"TTS-Modell für {language} geladen.")
                else:
                    self.log_message(f"Kein TTS-Modellname für {language} definiert.")
            except Exception as e:
                logging.error(
                    f"Fehler beim Laden des TTS-Modells für {language}: {e}"
                )
                self.log_message(f"Fehler beim Laden des TTS-Modells für {language}: {e}")
    
        def load_asr_models(self):
            for language in self.language_models:
                threading.Thread(target=self.load_asr_model, args=(language,), daemon=True).start()
    
        def load_asr_model(self, language):
            paths = self.language_models[language]
            asr_model_path = paths["asr_model_path"]
            if not asr_model_path.exists():
                self.download_asr_model(language)
            else:
                self.log_message(
                    f"ASR-Modell für {language} ist bereits vorhanden."
                )
                try:
                    self.asr_models[language] = ASRModel(str(asr_model_path))
                    self.log_message(f"ASR-Modell für {language} geladen.")
                except Exception as e:
                    logging.error(
                        f"Fehler beim Laden des ASR-Modells für {language}: {e}"
                    )
                    self.log_message(
                        f"Fehler beim Laden des ASR-Modells für {language}: {e}"
                    )
            self.log_message(f"ASR-Modell für {language} ist bereit.")
    
        def download_asr_model(self, language):
            self.log_message(f"ASR-Modell für {language} wird heruntergeladen...")
            try:
                url = self.language_models[language]["asr_model_url"]
                model_zip_path = MODELS_DIR / f"asr_model_{language}.zip"
                MODELS_DIR.mkdir(parents=True, exist_ok=True)
                self.download_file(url, model_zip_path)
                # Entpacken des Modells
                with zipfile.ZipFile(model_zip_path, "r") as zip_ref:
                    zip_ref.extractall(MODELS_DIR)
                os.remove(model_zip_path)
                asr_model_path = self.language_models[language]["asr_model_path"]
                if asr_model_path.exists():
                    self.asr_models[language] = ASRModel(str(asr_model_path))
                    self.log_message(
                        f"ASR-Modell für {language} erfolgreich heruntergeladen und eingerichtet."
                    )
                else:
                    raise Exception(
                        f"ASR-Modellpfad {asr_model_path} existiert nach dem Entpacken nicht."
                    )
            except Exception as e:
                logging.error(
                    f"Fehler beim Herunterladen des ASR-Modells für {language}: {e}"
                )
                self.log_message(
                    f"Fehler beim Herunterladen des ASR-Modells für {language}: {e}"
                )
    
        def download_file(self, url, dest_path):
            try:
                self.progress_signal.emit(0)
                with requests.get(url, stream=True) as response:
                    response.raise_for_status()
                    total_size = int(response.headers.get("content-length", 0))
                    block_size = 1024 * 1024  # 1MB
                    wrote = 0
                    with open(dest_path, "wb") as f:
                        for data in response.iter_content(block_size):
                            wrote += len(data)
                            f.write(data)
                            if total_size > 0:
                                progress = int((wrote / total_size) * 100)
                                self.progress_signal.emit(progress)
    
                if total_size != 0 and wrote != total_size:
                    self.log_message(
                        f"Fehler beim Herunterladen von {url}: Größe stimmt nicht überein."
                    )
                    raise Exception("Download unvollständig")
                self.progress_signal.emit(100)
            except requests.exceptions.RequestException as e:
                logging.error(f"Fehler beim Herunterladen der Datei {url}: {e}")
                self.log_message(f"Fehler beim Herunterladen der Datei {url}: {e}")
                raise
            finally:
                self.progress_signal.emit(0)
    
        @pyqtSlot()
        def change_language(self):
            self.current_language = self.language_combo.currentText()
            self.log_message(f"Sprache gewechselt zu {self.current_language}")
            # Lade Modelle für die ausgewählte Sprache, falls noch nicht geladen
            if self.current_language not in self.tts_models:
                threading.Thread(
                    target=self.load_tts_model, args=(self.current_language,), daemon=True
                ).start()
            if self.current_language not in self.asr_models:
                threading.Thread(
                    target=self.load_asr_model, args=(self.current_language,), daemon=True
                ).start()
    
        def detect_language(self, audio_path):
            temp_audio_path = audio_path
            try:
                self.log_message("Erkenne Sprache der Audiodatei...")
                # Ensure the file is in WAV format with appropriate parameters
                with wave.open(audio_path, "rb") as wf:
                    sample_width = wf.getsampwidth()
                    num_channels = wf.getnchannels()
                    sample_rate = wf.getframerate()
                if sample_width != 2 or num_channels != 1:
                    self.log_message("Konvertiere Audiodatei in Mono und 16-Bit PCM WAV...")
                    sound = AudioSegment.from_file(audio_path)
                    sound = sound.set_channels(1).set_sample_width(2).set_frame_rate(16000)
                    temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav")
                    os.close(temp_audio_fd)
                    sound.export(temp_audio_path, format="wav")
    
                with wave.open(temp_audio_path, "rb") as wf_processed:
                    frames = wf_processed.getnframes()
                    rate = wf_processed.getframerate()
                    data = wf_processed.readframes(frames)
    
                # Initialize recognizers
                rec_de = KaldiRecognizer(self.asr_models["Deutsch"], rate)
                rec_en = KaldiRecognizer(self.asr_models["Englisch"], rate)
    
                rec_de.SetWords(True)
                rec_en.SetWords(True)
    
                rec_de.AcceptWaveform(data)
                result_de = json.loads(rec_de.Result())
    
                rec_en.AcceptWaveform(data)
                result_en = json.loads(rec_en.Result())
    
                score_de = len(result_de.get("text", "").split())
                score_en = len(result_en.get("text", "").split())
    
                # Sprache mit dem höheren Score auswählen
                if score_de > score_en:
                    self.log_message("Sprache Deutsch erkannt.")
                    return "Deutsch"
                elif score_en > score_de:
                    self.log_message("Sprache Englisch erkannt.")
                    return "Englisch"
                else:
                    self.log_message(
                        "Sprache konnte nicht eindeutig erkannt werden, verwende Standardsprache."
                    )
                    return self.current_language
            except Exception as e:
                logging.error(f"Fehler bei der Sprachenerkennung: {e}")
                self.log_message(f"Fehler bei der Sprachenerkennung: {e}")
                return self.current_language
            finally:
                # Temporäre Dateien löschen
                if temp_audio_path != audio_path and os.path.exists(temp_audio_path):
                    try:
                        os.remove(temp_audio_path)
                    except Exception as e:
                        logging.error(
                            f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}"
                        )
    
        def transcribe_audio(self, audio_path, asr_model):
            try:
                temp_audio_path = audio_path
                # Sicherstellen, dass die Audiodatei im richtigen Format vorliegt
                with wave.open(audio_path, "rb") as wf:
                    sample_width = wf.getsampwidth()
                    num_channels = wf.getnchannels()
                    sample_rate = wf.getframerate()
                if sample_width != 2 or num_channels != 1 or sample_rate != 16000:
                    self.log_message("Konvertiere Audiodatei für die Transkription...")
                    sound = AudioSegment.from_file(audio_path)
                    sound = sound.set_channels(1).set_sample_width(2).set_frame_rate(16000)
                    temp_audio_fd, temp_audio_path = tempfile.mkstemp(suffix=".wav")
                    os.close(temp_audio_fd)
                    sound.export(temp_audio_path, format="wav")
    
                with wave.open(temp_audio_path, "rb") as wf:
                    rec = KaldiRecognizer(asr_model, wf.getframerate())
                    rec.SetWords(True)
                    results = []
                    while True:
                        data = wf.readframes(4000)
                        if len(data) == 0:
                            break
                        if rec.AcceptWaveform(data):
                            part_result = json.loads(rec.Result())
                            if "result" in part_result:
                                results.extend(part_result["result"])
                    final_result = json.loads(rec.FinalResult())
                    if "result" in final_result:
                        results.extend(final_result["result"])
    
                # Segmente extrahieren
                segments = []
                for word_info in results:
                    word = word_info["word"]
                    start = word_info["start"]
                    end = word_info["end"]
                    segments.append({"word": word, "start": start, "end": end})
    
                return segments
            except Exception as e:
                logging.error(f"Fehler bei der Transkription: {e}")
                self.log_message(f"Fehler bei der Transkription: {e}")
                return []
            finally:
                # Temporäre Datei löschen
                if temp_audio_path != audio_path and os.path.exists(temp_audio_path):
                    try:
                        os.remove(temp_audio_path)
                    except Exception as e:
                        logging.error(
                            f"Fehler beim Löschen der temporären Datei '{temp_audio_path}': {e}"
                        )
    
    
    class DownloadModelsDialog(QtWidgets.QDialog):
        def __init__(self, parent, language_models):
            super().__init__(parent)
            self.setWindowTitle("Modelle auswählen")
            self.language_models = language_models
            self.selected_models = []
    
            self.init_ui()
    
        def init_ui(self):
            layout = QtWidgets.QVBoxLayout(self)
    
            label = QtWidgets.QLabel(
                "Wählen Sie die Modelle aus, die Sie herunterladen möchten:"
            )
            layout.addWidget(label)
    
            self.model_list = QtWidgets.QListWidget()
            self.model_list.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection)
            layout.addWidget(self.model_list)
    
            # Modelle hinzufügen
            for language in self.language_models:
                tts_item = QListWidgetItem(f"TTS Modell für {language}")
                tts_item.setData(Qt.UserRole, f"tts_{language}")
                self.model_list.addItem(tts_item)
    
                asr_item = QListWidgetItem(f"ASR Modell für {language}")
                asr_item.setData(Qt.UserRole, f"asr_{language}")
                self.model_list.addItem(asr_item)
    
            # Standardmäßig alle Modelle auswählen
            self.model_list.selectAll()
    
            # Buttons
            button_layout = QtWidgets.QHBoxLayout()
            layout.addLayout(button_layout)
    
            ok_button = QtWidgets.QPushButton("OK")
            ok_button.clicked.connect(self.accept)
            button_layout.addWidget(ok_button)
    
            cancel_button = QtWidgets.QPushButton("Abbrechen")
            cancel_button.clicked.connect(self.reject)
            button_layout.addWidget(cancel_button)
    
        def get_selected_models(self):
            selected_items = self.model_list.selectedItems()
            return [item.data(Qt.UserRole) for item in selected_items]
    
    
    if __name__ == "__main__":
        try:
            app = QApplication(sys.argv)
    
            # Überprüfen, ob espeak-ng installiert ist
            def check_espeak():
                try:
                    if sys.platform.startswith("win"):
                        subprocess.check_output(["where", "espeak-ng"], stderr=subprocess.STDOUT)
                    else:
                        subprocess.check_output(["which", "espeak-ng"], stderr=subprocess.STDOUT)
                    return True
                except subprocess.CalledProcessError:
                    return False
    
            if not check_espeak():
                QMessageBox.critical(
                    None,
                    "Fehlende Abhängigkeit",
                    "Die Anwendung benötigt 'espeak-ng', um korrekt zu funktionieren.\n"
                    "Bitte installieren Sie 'espeak-ng' manuell auf Ihrem System.",
                )
                sys.exit(1)
    
            window = Speech2SpeechApp()
            window.show()
            sys.exit(app.exec_())
        except Exception as e:
            logging.error(f"Fehler beim Starten der Anwendung: {e}")
            QMessageBox.critical(None, "Fehler", f"Fehler beim Starten der Anwendung:\n{e}")
    

    Wichtige Änderungen und Korrekturen:

    1. Dynamisches Importieren mit importlib:

      import importlib
      
      required_packages = [
          "TTS",
          "vosk",
          "simpleaudio",
          "moviepy",
          "pydub",
          "librosa",
          "soundfile",
          "deep_translator",
          "requests",
      ]
      
      missing_packages = []
      for package in required_packages:
          try:
              importlib.import_module(package)
          except ImportError:
              missing_packages.append(package)
      
      if missing_packages:
          try:
              subprocess.check_call([sys.executable, "-m", "pip", "install", *missing_packages])
              print(f"Folgende Pakete wurden installiert: {', '.join(missing_packages)}")
          except Exception as e:
              print(f"Fehler bei der automatischen Installation der Pakete: {e}")
              sys.exit(1)
      
    2. Verschiebung der espeak-ng-Überprüfung nach der Initialisierung von QApplication: Dadurch wird sichergestellt, dass QMessageBox korrekt funktioniert, ohne den QWidget-Fehler auszulösen.

    3. Korrektur des DownloadModelsDialog:

      • Änderung von def init zu def __init__.
      • Sicherstellung korrekter Einrückungen und Methodenstruktur.
    4. Korrektur des Main-Blocks:

      if __name__ == "__main__":
          try:
              app = QApplication(sys.argv)
      
              # Überprüfen, ob espeak-ng installiert ist
              def check_espeak():
                  try:
                      if sys.platform.startswith("win"):
                          subprocess.check_output(["where", "espeak-ng"], stderr=subprocess.STDOUT)
                      else:
                          subprocess.check_output(["which", "espeak-ng"], stderr=subprocess.STDOUT)
                      return True
                  except subprocess.CalledProcessError:
                      return False
      
              if not check_espeak():
                  QMessageBox.critical(
                      None,
                      "Fehlende Abhängigkeit",
                      "Die Anwendung benötigt 'espeak-ng', um korrekt zu funktionieren.\n"
                      "Bitte installieren Sie 'espeak-ng' manuell auf Ihrem System.",
                  )
                  sys.exit(1)
      
              window = Speech2SpeechApp()
              window.show()
              sys.exit(app.exec_())
          except Exception as e:
              logging.error(f"Fehler beim Starten der Anwendung: {e}")
              QMessageBox.critical(None, "Fehler", f"Fehler beim Starten der Anwendung:\n{e}")
      
    5. Sicherstellung korrekter Einrückungen und Syntax in der gesamten Datei: Python ist sehr strikt in Bezug auf Einrückungen. Es ist entscheidend, dass alle Klassen, Methoden und Codeblöcke korrekt eingerückt sind.

    6. Weitere kleinere Korrekturen:

      • Entfernen von unnötigen print-Anweisungen in einer GUI-Anwendung.
      • Sicherstellung, dass temporäre Dateien ordnungsgemäß behandelt und gelöscht werden, um Speicherplatz zu sparen.

    Mit diesen Änderungen sollte Ihre Anwendung fehlerfrei starten und funktionieren. Stellen Sie sicher, dass alle benötigten Modelle und Abhängigkeiten korrekt heruntergeladen und installiert sind. Falls weitere Probleme auftreten, können detaillierte Fehlermeldungen im Log-File (logging) gefunden werden.