Raspberry Pi 5: Sprachübersetzer mit Schutz der Privatsphäre

#!/usr/bin/env python3
import argparse, logging, subprocess, sys
from pathlib import Path
import requests

BASE = Path.home() / "translator"
WORK = BASE / "work"
LOG = BASE / "log/translator.log"
WHISPER = Path.home() / "whisper.cpp/build/bin/whisper-cli"
WHISPER_MODEL = Path.home() / "whisper.cpp/models/ggml-base.bin"
OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
GEMMA_MODEL = "gemma3:1b"

# HIER DEINE AUDIO-GERÄTE EINTRAGEN:
MIC_DEVICE = "plughw:2,0"   
PLAYBACK_DEVICE = "default" 

VOICES = {
    "de": BASE / "voices/de/de_DE-thorsten-medium.onnx",
    "en": BASE / "voices/en/en_GB-alan-medium.onnx",
}

WORK.mkdir(parents=True, exist_ok=True)
LOG.parent.mkdir(parents=True, exist_ok=True)
logging.basicConfig(filename=LOG, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

def run(cmd, input_text=None):
    cmd=[str(x) for x in cmd]
    logging.info("CMD: %s", " ".join(cmd))
    r=subprocess.run(cmd,input=input_text,text=True,capture_output=True)
    if r.stdout: logging.info("STDOUT: %s",r.stdout.strip())
    if r.stderr: logging.info("STDERR: %s",r.stderr.strip())
    if r.returncode:
        raise RuntimeError(f"Befehl fehlgeschlagen ({r.returncode}): {' '.join(cmd)}\n{r.stderr.strip()}")
    return r

def record(seconds):
    wav=WORK/"input.wav"; wav.unlink(missing_ok=True)
    run(["arecord","-D",MIC_DEVICE,"-f","S16_LE","-r","16000","-c","1","-d",seconds,wav])
    if not wav.is_file() or wav.stat().st_size<1000: raise RuntimeError("Aufnahme fehlt oder ist zu klein")
    return wav

def transcribe(wav,lang):
    stem=WORK/"transcript"; txt=stem.with_suffix(".txt"); txt.unlink(missing_ok=True)
    run([WHISPER,"-m",WHISPER_MODEL,"-f",wav,"-l",lang,"-nt","-otxt","-of",stem])
    if not txt.is_file(): raise RuntimeError("Whisper erzeugte keine Textdatei")
    text=txt.read_text(encoding="utf-8",errors="replace").strip()
    if not text: raise RuntimeError("Whisper lieferte keinen Text")
    return text

def translate(text,target):
    language="Deutsch" if target=="de" else "Englisch"
    prompt=f"Übersetze exakt ins {language}. Gib ausschließlich die Übersetzung aus, ohne Erklärung, Anführungszeichen oder Präfix. Text: {text}"
    r=requests.post(OLLAMA_URL,json={"model":GEMMA_MODEL,"prompt":prompt,"stream":False,"options":{"temperature":0}},timeout=180)
    r.raise_for_status(); out=r.json()["response"].strip()
    if not out: raise RuntimeError("Gemma lieferte keine Übersetzung")
    return out

def speak(text,target):
    model=VOICES[target]; config=Path(str(model)+".json")
    if not model.is_file(): raise FileNotFoundError(f"TTS-Modell fehlt: {model}")
    if not config.is_file(): raise FileNotFoundError(f"TTS-Konfiguration fehlt: {config}")
    out=WORK/"translation.wav"; out.unlink(missing_ok=True)
    run([BASE/"venv/bin/piper","--model",model,"--output_file",out],text)
    run(["aplay","-D",PLAYBACK_DEVICE,out]); return out

def main():
    ap=argparse.ArgumentParser(); 
    ap.add_argument("--from",dest="source",choices=["de","en"],required=True)
    ap.add_argument("--to",dest="target",choices=["de","en"],required=True); 
    ap.add_argument("--seconds",type=int,default=7)
    a=ap.parse_args()
    if a.source==a.target: sys.exit("Quell- und Zielsprache müssen verschieden sein")
    try:
        print("Aufnahme startet ...")
        text=transcribe(record(a.seconds),a.source)
        print("Erkannt:",text)
        out=translate(text,a.target)
        print("Übersetzt:",out)
        speak(out,a.target)
    except Exception as e:
        logging.exception("Fehler")
        print(f"FEHLER: {e}",file=sys.stderr)
        sys.exit(1)

if __name__=="__main__": main()

#!/usr/bin/env python3
import argparse, logging, subprocess, sys
from pathlib import Path
import requests

BASE = Path.home() / "translator"
WORK = BASE / "work"
LOG = BASE / "log/translator.log"
WHISPER = Path.home() / "whisper.cpp/build/bin/whisper-cli"
WHISPER_MODEL = Path.home() / "whisper.cpp/models/ggml-base.bin"
OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
GEMMA_MODEL = "gemma3:1b"

# HIER DEINE AUDIO-GERÄTE EINTRAGEN:
MIC_DEVICE = "plughw:2,0"
PLAYBACK_DEVICE = "default"

# Absoluter Pfad zur Piper-Datei in der virtuellen Umgebung (Virtual Environment / venv)
PIPER = BASE / "venv/bin/piper"

# Stimmen für die verschiedenen Sprachen
VOICES = {
    "de": BASE / "voices/de/de_DE-thorsten-medium.onnx",
    "en": BASE / "voices/en/en_GB-alan-medium.onnx",
    "es": BASE / "voices/es/es_ES-sharvard-medium.onnx",
    "fr": BASE / "voices/fr/fr_FR-siwis-medium.onnx",
}

WORK.mkdir(parents=True, exist_ok=True)
LOG.parent.mkdir(parents=True, exist_ok=True)
logging.basicConfig(filename=LOG, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

def run(cmd, input_text=None):
    cmd=[str(x) for x in cmd]
    logging.info("CMD: %s", " ".join(cmd))
    r=subprocess.run(cmd,input=input_text,text=True,capture_output=True)
    if r.stdout: logging.info("STDOUT: %s",r.stdout.strip())
    if r.stderr: logging.info("STDERR: %s",r.stderr.strip())
    if r.returncode:
        raise RuntimeError(f"Befehl fehlgeschlagen ({r.returncode}): {' '.join(cmd)}\n{r.stderr.strip()}")
    return r

def record(seconds):
    wav=WORK/"input.wav"
    wav.unlink(missing_ok=True)
    run(["arecord","-D",MIC_DEVICE,"-f","S16_LE","-r","16000","-c","1","-d",seconds,wav])
    if not wav.is_file() or wav.stat().st_size<1000: 
        raise RuntimeError("Aufnahme fehlt oder ist zu klein")
    return wav

def transcribe(wav,lang):
    stem=WORK/"transcript"
    txt=stem.with_suffix(".txt")
    txt.unlink(missing_ok=True)
    run([WHISPER,"-m",WHISPER_MODEL,"-f",wav,"-l",lang,"-nt","-otxt","-of",stem])
    if not txt.is_file(): 
        raise RuntimeError("Whisper erzeugte keine Textdatei (Text file)")
    text=txt.read_text(encoding="utf-8",errors="replace").strip()
    if not text: 
        raise RuntimeError("Kein Text erkannt")
    return text

def translate(text, target_lang):
    lang_names = {"en": "Englische", "de": "Deutsche", "es": "Spanische", "fr": "Französische"}
    prompt = f"Übersetze exakt ins {lang_names[target_lang]}. Gib nur die Übersetzung aus: {text}"
    
    payload = {
        "model": GEMMA_MODEL,
        "prompt": prompt,
        "stream": False,
        "options": {"temperature": 0}
    }
    r = requests.post(OLLAMA_URL, json=payload)
    r.raise_for_status()
    return r.json().get("response", "").strip()

def speak(text, lang):
    voice = VOICES.get(lang)
    if not voice: 
        raise RuntimeError(f"Keine Stimme für die Sprache {lang} gefunden")
    
    out_wav = WORK / "output.wav"
    out_wav.unlink(missing_ok=True)
    
    piper_cmd = [str(PIPER), "--model", str(voice), "--output_file", str(out_wav)]
    logging.info("CMD: echo %s | %s", text, " ".join(piper_cmd))
    
    p = subprocess.run(piper_cmd, input=text, text=True, capture_output=True)
    if not out_wav.is_file():
        raise RuntimeError(f"Piper TTS (Text-zu-Sprache) Fehler: {p.stderr}")
        
    run(["aplay", "-D", PLAYBACK_DEVICE, out_wav])

def main():
    parser = argparse.ArgumentParser(description="Lokaler KI Sprachübersetzer")
    parser.add_argument("--from", dest="from_lang", choices=["de", "en", "es", "fr"], default="de", help="Quellsprache")
    parser.add_argument("--to", dest="to_lang", choices=["de", "en", "es", "fr"], default="en", help="Zielsprache")
    parser.add_argument("--seconds", type=int, default=5, help="Aufnahmedauer in Sekunden")
    args = parser.parse_args()

    print(f"[{args.from_lang.upper()} -> {args.to_lang.upper()}] Aufnahme startet für {args.seconds} Sekunden...")
    wav = record(args.seconds)
    
    print("Spracherkennung (Speech-to-Text / STT) läuft...")
    text = transcribe(wav, args.from_lang)
    print(f"Erkannt: {text}")
    
    print("Übersetzung durch Künstliche Intelligenz (KI) läuft...")
    translated = translate(text, args.to_lang)
    print(f"Übersetzt: {translated}")
    
    print("Sprachausgabe (Text-to-Speech / TTS) läuft...")
    speak(translated, args.to_lang)
    
    print("Fertig.")

if __name__ == "__main__":
    try:
        main()
    except Exception as e:
        logging.error("Fehler: %s", e)
        print(f"Fehler: {e}", file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
import tkinter as tk
from tkinter import font
import subprocess
from pathlib import Path
import threading

# --- FARBANPASSUNGEN (Prilchen LABS Design) ---
BG_COLOR = "#ecefef"      
BTN_COLOR = "#1fbc9c"     
BTN_ACTIVE = "#17997f"    
FRAME_BG = "#747474"      
TEXT_COLOR = "#222222"    
BTN_TEXT = "#ffffff"      
FONT_NAME = "Helvetica"

# --- PFADE ZU DEN PROGRAMMEN ---
BASE_DIR = Path.home() / "translator"
TRANSLATOR_SCRIPT = BASE_DIR / "app/translator.py"
PYTHON_EXEC = BASE_DIR / "venv/bin/python3"

# --- SPRACHEN DEFINIEREN ---
LANGUAGES = {
    "Deutsch": "de",
    "Englisch": "en",
    "Spanisch": "es",
    "Französisch": "fr"
}

class TranslatorGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Prilchen LABS - Sprachübersetzer")
        
        self.root.geometry("480x320")
        self.root.configure(bg=BG_COLOR)
        
        # Schriften verkleinert (size 12 und 14) für mehr Platz
        self.custom_font = font.Font(family=FONT_NAME, size=12, weight="bold")
        self.title_font = font.Font(family=FONT_NAME, size=14, weight="bold")
        
        self.from_lang_name = tk.StringVar(value="Deutsch")
        self.to_lang_name = tk.StringVar(value="Englisch")
        
        self.build_interface()
        
    def build_interface(self):
        # Titel (Kompakter)
        title = tk.Label(self.root, text="Offline Übersetzer", bg=BG_COLOR, fg=TEXT_COLOR, font=self.title_font)
        title.pack(pady=5)
        
        # Rahmen für die Sprachauswahl (Kompakter)
        lang_frame = tk.Frame(self.root, bg=FRAME_BG, padx=5, pady=5)
        lang_frame.pack(pady=2, fill="x", padx=10)
        
        # Linke Seite: Von Sprache
        from_frame = tk.Frame(lang_frame, bg=FRAME_BG)
        from_frame.pack(side="left", expand=True)
        tk.Label(from_frame, text="Von:", bg=FRAME_BG, fg=BTN_TEXT, font=self.custom_font).pack(side="left")
        
        from_menu = tk.OptionMenu(from_frame, self.from_lang_name, *LANGUAGES.keys())
        from_menu.config(bg=BTN_COLOR, fg=BTN_TEXT, font=self.custom_font, activebackground=BTN_ACTIVE, highlightthickness=0)
        from_menu["menu"].config(bg=BG_COLOR, fg=TEXT_COLOR, font=self.custom_font)
        from_menu.pack(side="left", padx=5)
        
        # Rechte Seite: Zu Sprache
        to_frame = tk.Frame(lang_frame, bg=FRAME_BG)
        to_frame.pack(side="right", expand=True)
        tk.Label(to_frame, text="Nach:", bg=FRAME_BG, fg=BTN_TEXT, font=self.custom_font).pack(side="left")
        
        to_menu = tk.OptionMenu(to_frame, self.to_lang_name, *LANGUAGES.keys())
        to_menu.config(bg=BTN_COLOR, fg=BTN_TEXT, font=self.custom_font, activebackground=BTN_ACTIVE, highlightthickness=0)
        to_menu["menu"].config(bg=BG_COLOR, fg=TEXT_COLOR, font=self.custom_font)
        to_menu.pack(side="left", padx=5)

        # Statusanzeige
        self.status_label = tk.Label(self.root, text="Bereit für die Aufnahme.", bg=BG_COLOR, fg=TEXT_COLOR, font=self.custom_font)
        self.status_label.pack(pady=2)

        # Aufnahme-Button (Kompakter, in der Mitte platziert)
        self.record_btn = tk.Button(self.root, text="🎤 Aufnahme", bg=BTN_COLOR, fg=BTN_TEXT, font=self.title_font, 
                                    activebackground=BTN_ACTIVE, command=self.start_translation, height=1, width=15, relief="flat")
        self.record_btn.pack(pady=2)

        # Neues Textfeld für die Terminal-Ausgabe (Texterkennung / Fehler)
        self.output_text = tk.Text(self.root, height=6, bg="#ffffff", fg=TEXT_COLOR, font=("Courier", 10))
        self.output_text.pack(pady=5, padx=10, fill="both", expand=True)
        self.output_text.insert(tk.END, "Hier erscheint die Texterkennung...\n")
        # Textfeld vorübergehend schreibgeschützt machen
        self.output_text.config(state="disabled")

    def log_output(self, text):
        """Hilfsfunktion, um Text in das untere Textfeld zu schreiben"""
        self.output_text.config(state="normal")
        self.output_text.insert(tk.END, text + "\n")
        self.output_text.see(tk.END) # Automatisch nach unten scrollen
        self.output_text.config(state="disabled")

    def start_translation(self):
        self.record_btn.config(state="disabled", text="Arbeitet...", bg=FRAME_BG)
        self.status_label.config(text="Aufnahme läuft...")
        
        # Textfeld für neuen Vorgang leeren
        self.output_text.config(state="normal")
        self.output_text.delete(1.0, tk.END)
        self.output_text.config(state="disabled")
        
        thread = threading.Thread(target=self.run_translator_script)
        thread.start()

    def run_translator_script(self):
        from_code = LANGUAGES.get(self.from_lang_name.get(), "de")
        to_code = LANGUAGES.get(self.to_lang_name.get(), "en")

        cmd = [str(PYTHON_EXEC), str(TRANSLATOR_SCRIPT), "--from", from_code, "--to", to_code, "--seconds", "5"]
        
        try:
            # subprocess mit stdout=subprocess.PIPE starten, um die Text-Ausgabe der translator.py abzufangen
            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
            
            # Die Textausgaben Zeile für Zeile abfangen und ins GUI-Textfeld schreiben
            for line in process.stdout:
                # after() nutzen, da wir aus einem Hintergrund-Thread die GUI aktualisieren
                self.root.after(0, self.log_output, line.strip())
                
            process.wait() # Warten, bis das Hauptprogramm fertig ist
            
            if process.returncode == 0:
                self.root.after(0, lambda: self.status_label.config(text="Übersetzung abgeschlossen."))
            else:
                self.root.after(0, lambda: self.status_label.config(text="Fehler bei der Ausführung!"))
                
        except Exception as e:
            self.root.after(0, lambda: self.status_label.config(text="Ein Fehler ist aufgetreten."))
            self.root.after(0, self.log_output, f"Fehler: {str(e)}")
            
        finally:
            self.root.after(3000, lambda: self.status_label.config(text="Bereit für die Aufnahme."))
            self.root.after(0, lambda: self.record_btn.config(state="normal", text="Aufnahme", bg=BTN_COLOR))

if __name__ == "__main__":
    root = tk.Tk()
    app = TranslatorGUI(root)
    root.mainloop()