PayPerTranscript 0.2.9__tar.gz → 0.3.0__tar.gz

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.9
+Version: 0.3.0
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/PayPerTranscript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.9
+Version: 0.3.0
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/__init__.py

@@ -1,3 +1,3 @@
 """PayPerTranscript - Voice-to-Text mit Pay-per-Use Pricing."""
 
-__version__ = "0.2.9"
+__version__ = "0.3.0"

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/core/hotkey.py

@@ -54,6 +54,11 @@ _MODIFIER_GROUPS: dict[str, set[keyboard.Key]] = {
     "cmd": {keyboard.Key.cmd, keyboard.Key.cmd_l, keyboard.Key.cmd_r},
 }
 
+# Alle Modifier-Keys (flach) fuer Exakt-Match-Pruefung
+_ALL_MODIFIER_KEYS: set[keyboard.Key] = set()
+for _grp in _MODIFIER_GROUPS.values():
+    _ALL_MODIFIER_KEYS |= _grp
+
 # Alt-Keys fuer Menu-Bar-Workaround (Windows aktiviert Menueleiste bei bare Alt-Release)
 _ALT_KEYS: set[keyboard.Key] = {keyboard.Key.alt_l, keyboard.Key.alt_r}
 
@@ -149,18 +154,33 @@ class HotkeyListener:
         target_keys: list[keyboard.Key | keyboard.KeyCode],
         modifier_groups: list[set[keyboard.Key]],
     ) -> bool:
-        """Prüft ob eine Tastenkombination aktuell gedrückt ist."""
+        """Prüft ob eine Tastenkombination aktuell gedrückt ist.
+
+        Exaktes Modifier-Matching: es muessen genau die konfigurierten Modifier
+        gedrueckt sein, keine zusaetzlichen. Damit wird verhindert, dass z.B.
+        Ctrl+Win auch durch Ctrl+Shift+Alt+F9 ausgeloest wird.
+        """
         if not target_keys:
             return False
 
+        # Sammle welche Modifier-Gruppen zum Hotkey gehoeren
+        required_modifier_keys: set[keyboard.Key] = set()
+
         for i, target_key in enumerate(target_keys):
             # Für Modifier: prüfe ob *irgendein* Key aus der Gruppe gedrückt ist
             if i < len(modifier_groups) and modifier_groups[i]:
                 if not (modifier_groups[i] & self._pressed_keys):
                     return False
+                required_modifier_keys |= modifier_groups[i]
             else:
                 if target_key not in self._pressed_keys:
                     return False
+
+        # Pruefe ob Extra-Modifier gedrueckt sind, die nicht zum Hotkey gehoeren
+        extra_modifiers = (self._pressed_keys & _ALL_MODIFIER_KEYS) - required_modifier_keys
+        if extra_modifiers:
+            return False
+
         return True
 
     def _combo_uses_alt(self, target_keys: list[keyboard.Key | keyboard.KeyCode]) -> bool:

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/core/text_inserter.py

@@ -19,6 +19,27 @@ log = get_logger("core.text_inserter")
 pyautogui.FAILSAFE = False
 pyautogui.PAUSE = 0
 
+# Clipboard-Wiederherstellung: Retry-Konfiguration
+_CLIPBOARD_RESTORE_RETRIES = 3
+_CLIPBOARD_RESTORE_DELAY = 0.05  # 50ms zwischen Versuchen
+
+
+def _restore_clipboard(content: str) -> None:
+    """Stellt die Zwischenablage wieder her mit Retry-Logik.
+
+    Andere Apps (Clipboard-Manager, Password-Manager) koennen die
+    Zwischenablage kurzzeitig sperren. Daher mehrere Versuche.
+    """
+    for attempt in range(1, _CLIPBOARD_RESTORE_RETRIES + 1):
+        try:
+            pyperclip.copy(content)
+            return
+        except Exception:
+            if attempt < _CLIPBOARD_RESTORE_RETRIES:
+                time.sleep(_CLIPBOARD_RESTORE_DELAY)
+            else:
+                log.warning("Zwischenablage konnte nicht wiederhergestellt werden (nach %d Versuchen)", _CLIPBOARD_RESTORE_RETRIES)
+
 
 def insert_text(text: str) -> None:
     """Fügt Text an der aktuellen Cursor-Position ein.
@@ -62,10 +83,7 @@ def insert_text(text: str) -> None:
 
     finally:
         # 5. Alte Zwischenablage wiederherstellen
-        try:
-            pyperclip.copy(old_clipboard)
-        except Exception:
-            log.debug("Zwischenablage konnte nicht wiederhergestellt werden")
+        _restore_clipboard(old_clipboard)
 
 
 # Intervall (Sekunden) zwischen Chunk-Pastes bei Streaming-Typing
@@ -125,7 +143,4 @@ def insert_text_streaming(chunks: Iterator[str]) -> None:
                 log.error("Auch Fallback-Paste fehlgeschlagen")
 
     finally:
-        try:
-            pyperclip.copy(old_clipboard)
-        except Exception:
-            log.debug("Zwischenablage konnte nicht wiederhergestellt werden")
+        _restore_clipboard(old_clipboard)

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/pipeline/transcription.py

@@ -26,9 +26,38 @@ STATUS_STT_DONE = "stt_done"
 STATUS_LLM_START = "llm_start"
 STATUS_DONE = "done"
 STATUS_ERROR = "error"
+STATUS_LLM_FALLBACK = "llm_fallback"
 
 log = get_logger("pipeline.transcription")
 
+# Halluzinationsfilter: Whisper halluziniert bei kurzen Aufnahmen ohne Sprache
+_HALLUCINATION_PATTERNS = [
+    "copyright", "untertitel", "subtitles by",
+    "thanks for watching", "thank you for watching",
+    "sous-titres", "amara.org",
+]
+_HALLUCINATION_MAX_DURATION = 5.0
+
+
+def _is_hallucination(text: str, audio_duration: float) -> bool:
+    """Prueft ob ein STT-Ergebnis eine Whisper-Halluzination ist.
+
+    Bei kurzen Aufnahmen (< 5s) ohne Sprache halluziniert Whisper
+    stereotypische Strings wie "Copyright Australian Broadcasting Corporation".
+
+    Args:
+        text: STT-Ergebnis.
+        audio_duration: Audio-Dauer in Sekunden.
+
+    Returns:
+        True wenn der Text als Halluzination erkannt wurde.
+    """
+    if audio_duration >= _HALLUCINATION_MAX_DURATION:
+        return False
+    text_lower = text.lower()
+    return any(pattern in text_lower for pattern in _HALLUCINATION_PATTERNS)
+
+
 # Maximale Prompt-Laenge fuer Whisper (224 Tokens).
 # Konservative Schaetzung: ~4 Zeichen pro Token fuer gemischten DE/EN Text.
 _MAX_PROMPT_CHARS = 896
@@ -86,6 +115,7 @@ class TranscriptionPipeline:
         self._config = config
         self._session_logger = session_logger
         self.last_transcription: str | None = None
+        self.last_wav_path: Path | None = None
         log.info(
             "TranscriptionPipeline initialisiert (LLM: %s, Tracking: %s)",
             "aktiv" if llm_provider else "deaktiviert",
@@ -219,6 +249,8 @@ class TranscriptionPipeline:
                 except Exception:
                     pass
 
+        self.last_wav_path = wav_path
+
         try:
             # Audio-Dauer: entweder uebergeben oder aus WAV-Datei berechnen
             if audio_duration is None:
@@ -241,7 +273,16 @@ class TranscriptionPipeline:
 
             if not text:
                 log.info("Pipeline: STT lieferte leeren Text - uebersprungen")
-                _notify(STATUS_DONE)
+                _notify(STATUS_ERROR, "Kein Text erkannt")
+                return
+
+            if _is_hallucination(text, audio_duration):
+                log.info(
+                    "Pipeline: Halluzination erkannt (%.1fs, '%s') - uebersprungen",
+                    audio_duration,
+                    text[:80],
+                )
+                _notify(STATUS_ERROR, "Keine Sprache erkannt")
                 return
 
             # LLM-Formatierung (falls Window-Mapping existiert)
@@ -262,7 +303,7 @@ class TranscriptionPipeline:
                 except Exception as e:
                     insert_ok = False
                     log.error("Pipeline: Text-Einfuegung fehlgeschlagen: %s", e)
-                    _notify(STATUS_ERROR, "Text konnte nicht eingefuegt werden")
+                    _notify(STATUS_ERROR, f"Text-Einfuegung fehlgeschlagen: {e}")
 
             def _do_insert_stream(chunks_iter: object) -> None:
                 nonlocal insert_ok
@@ -271,7 +312,7 @@ class TranscriptionPipeline:
                 except Exception as e:
                     insert_ok = False
                     log.error("Pipeline: Streaming-Einfuegung fehlgeschlagen: %s", e)
-                    _notify(STATUS_ERROR, "Text konnte nicht eingefuegt werden")
+                    _notify(STATUS_ERROR, f"Text-Einfuegung fehlgeschlagen: {e}")
 
             if system_prompt and self._llm:
                 _notify(STATUS_LLM_START)
@@ -299,6 +340,7 @@ class TranscriptionPipeline:
 
                 except ProviderError as e:
                     log.warning("Pipeline: LLM-Fehler - Fallback auf Rohtext: %s", e)
+                    _notify(STATUS_LLM_FALLBACK, str(e))
                     _do_insert(text)
             else:
                 # Kein Mapping oder kein LLM-Provider -> Rohtext direkt einfuegen

paypertranscript-0.3.0/paypertranscript/providers/groq_provider.py

@@ -0,0 +1,273 @@
+"""GroqCloud API-Provider für PayPerTranscript.
+
+Implementiert STT (Whisper) und LLM-Formatierung über die GroqCloud API.
+"""
+
+import time
+from collections.abc import Iterator
+from pathlib import Path
+
+import groq
+
+from paypertranscript.core.logging import get_logger
+from paypertranscript.providers.base import AbstractLLMProvider, AbstractSTTProvider, ProviderError
+
+log = get_logger("providers.groq")
+
+# Retry-Konfiguration fuer transiente API-Fehler
+_MAX_RETRIES = 3
+_RETRY_BASE_DELAY = 1.0  # Sekunden (exponential: 1s, 2s, 4s)
+_RETRYABLE_ERRORS = (groq.RateLimitError, groq.APITimeoutError, groq.APIConnectionError)
+
+# Minimale WAV-Dateigroesse (44 Bytes = WAV-Header ohne Audio-Daten)
+_MIN_WAV_SIZE = 44
+
+
+class GroqSTTProvider(AbstractSTTProvider):
+    """GroqCloud Whisper STT-Provider.
+
+    Nutzt whisper-large-v3-turbo für Speech-to-Text.
+    Der Groq-Client wird einmal instanziiert und wiederverwendet
+    (Connection Pooling via httpx).
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "whisper-large-v3-turbo",
+    ) -> None:
+        self._model = model
+        try:
+            self._client = groq.Groq(api_key=api_key)
+        except groq.GroqError as e:
+            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
+        log.info("GroqSTTProvider initialisiert (Modell: %s)", self._model)
+
+    def transcribe(self, audio_path: Path, language: str, prompt: str = "") -> str:
+        """Transkribiert eine WAV-Datei via GroqCloud Whisper API."""
+        if not audio_path.exists():
+            raise ProviderError(f"Audio-Datei nicht gefunden: {audio_path}")
+
+        # V05: Audio-Datei validieren (WAV-Header = 44 Bytes, leere Datei vermeiden)
+        file_size = audio_path.stat().st_size
+        if file_size <= _MIN_WAV_SIZE:
+            raise ProviderError(
+                f"Audio-Datei ist leer oder beschädigt ({file_size} Bytes)"
+            )
+
+        log.info(
+            "STT-Anfrage: %s (Sprache: %s, Modell: %s)",
+            audio_path.name,
+            language,
+            self._model,
+        )
+        if prompt:
+            log.info("STT-Prompt: %s", prompt)
+
+        # V01: Retry-Loop fuer transiente Fehler
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                with open(audio_path, "rb") as audio_file:
+                    transcription = self._client.audio.transcriptions.create(
+                        model=self._model,
+                        file=audio_file,
+                        language=language,
+                        prompt=prompt,
+                        response_format="text",
+                        temperature=0.0,
+                    )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "STT-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("STT: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            # Alle Retries erschoepft
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # response_format="text" gibt direkt einen String zurück
+        text = transcription.strip() if isinstance(transcription, str) else transcription.text.strip()
+
+        log.info("STT-Ergebnis: %d Zeichen", len(text))
+        return text
+
+
+class GroqLLMProvider(AbstractLLMProvider):
+    """GroqCloud LLM-Provider für Textformatierung.
+
+    Nutzt openai/gpt-oss-20b für kontextabhängige Formatierung.
+    Der Groq-Client wird einmal instanziiert und wiederverwendet.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "openai/gpt-oss-20b",
+        temperature: float | None = None,
+    ) -> None:
+        self._model = model
+        self._temperature = temperature
+        self._last_usage: dict[str, int] | None = None
+        try:
+            self._client = groq.Groq(api_key=api_key)
+        except groq.GroqError as e:
+            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
+        log.info("GroqLLMProvider initialisiert (Modell: %s, Temperature: %s)", self._model, self._temperature)
+
+    @property
+    def last_usage(self) -> dict[str, int] | None:
+        """Token-Usage der letzten LLM-Anfrage."""
+        return self._last_usage
+
+    def _build_messages(
+        self, system_prompt: str, text: str
+    ) -> list[dict[str, str]]:
+        return [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": f"<transcript>{text}</transcript>"},
+        ]
+
+    def _completion_kwargs(self) -> dict:
+        """Baut gemeinsame kwargs für chat.completions.create."""
+        kwargs: dict = {}
+        if self._temperature is not None:
+            kwargs["temperature"] = self._temperature
+        return kwargs
+
+    def format_text(self, system_prompt: str, text: str) -> str:
+        log.info("LLM-Anfrage (non-streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
+        self._last_usage = None
+
+        # V01: Retry-Loop fuer transiente Fehler
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                response = self._client.chat.completions.create(
+                    model=self._model,
+                    messages=self._build_messages(system_prompt, text),
+                    stream=False,
+                    **self._completion_kwargs(),
+                )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "LLM-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("LLM: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # Usage-Daten erfassen
+        if hasattr(response, "usage") and response.usage:
+            self._last_usage = {
+                "prompt_tokens": response.usage.prompt_tokens or 0,
+                "completion_tokens": response.usage.completion_tokens or 0,
+            }
+
+        result = response.choices[0].message.content or ""
+        result = result.strip()
+        log.info("LLM-Ergebnis: %d Zeichen", len(result))
+        return result
+
+    def format_text_stream(self, system_prompt: str, text: str) -> Iterator[str]:
+        log.info("LLM-Anfrage (streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
+        self._last_usage = None
+
+        # V01: Retry-Loop fuer transiente Fehler beim Stream-Aufbau
+        last_error: Exception | None = None
+        for attempt in range(1, _MAX_RETRIES + 1):
+            try:
+                stream = self._client.chat.completions.create(
+                    model=self._model,
+                    messages=self._build_messages(system_prompt, text),
+                    stream=True,
+                    **self._completion_kwargs(),
+                )
+                break  # Erfolg
+            except groq.AuthenticationError as e:
+                raise ProviderError(f"API-Key ungültig: {e}") from e
+            except _RETRYABLE_ERRORS as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    delay = _RETRY_BASE_DELAY * (2 ** (attempt - 1))
+                    log.warning(
+                        "LLM-Stream-Versuch %d/%d fehlgeschlagen: %s - Retry in %.1fs",
+                        attempt, _MAX_RETRIES, e, delay,
+                    )
+                    time.sleep(delay)
+                else:
+                    log.error("LLM-Stream: Alle %d Versuche fehlgeschlagen", _MAX_RETRIES)
+            except groq.APIError as e:
+                raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
+        else:
+            e = last_error
+            if isinstance(e, groq.RateLimitError):
+                raise ProviderError(f"Rate Limit erreicht: {e}") from e
+            elif isinstance(e, groq.APITimeoutError):
+                raise ProviderError(f"GroqCloud Timeout: {e}") from e
+            else:
+                raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
+
+        # V02: Stream-Iteration in try/except — Verbindungsabbruch waehrend Streaming erkennen
+        total_chars = 0
+        try:
+            for chunk in stream:
+                delta = chunk.choices[0].delta.content
+                if delta:
+                    total_chars += len(delta)
+                    yield delta
+                # Groq streaming: Usage im letzten Chunk via x_groq
+                if (
+                    hasattr(chunk, "x_groq")
+                    and chunk.x_groq
+                    and hasattr(chunk.x_groq, "usage")
+                    and chunk.x_groq.usage
+                ):
+                    usage = chunk.x_groq.usage
+                    self._last_usage = {
+                        "prompt_tokens": getattr(usage, "prompt_tokens", 0) or 0,
+                        "completion_tokens": getattr(usage, "completion_tokens", 0) or 0,
+                    }
+        except groq.APIError as e:
+            raise ProviderError(
+                f"LLM-Stream abgebrochen nach {total_chars} Zeichen: {e}"
+            ) from e
+        except Exception as e:
+            raise ProviderError(
+                f"LLM-Stream abgebrochen nach {total_chars} Zeichen: {e}"
+            ) from e
+        log.info("LLM-Stream abgeschlossen: %d Zeichen", total_chars)

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/ui/app.py

@@ -29,6 +29,7 @@ from paypertranscript.core.window_detector import WindowInfo, get_foreground_win
 from paypertranscript.pipeline.transcription import (
     STATUS_DONE,
     STATUS_ERROR,
+    STATUS_LLM_FALLBACK,
     STATUS_LLM_START,
     STATUS_STT_START,
     TranscriptionPipeline,
@@ -76,6 +77,7 @@ class AppSignals(QObject):
     formatting_started = Signal()
     processing_done = Signal()
     processing_error = Signal(str)
+    done_message = Signal(str)
     update_available = Signal(str)
     update_not_available = Signal()
 
@@ -144,6 +146,8 @@ class PayPerTranscriptApp:
             show_done_overlay=self._overlay.show_done,
             on_update_check=self.trigger_update_check,
             on_perform_update=self.perform_update_and_restart,
+            get_last_wav_path=self._get_last_wav_path,
+            on_retranscribe_precise=self._retranscribe_precise,
         )
 
         # Amplitude-Polling-Timer (30fps, laeuft nur waehrend Aufnahme)
@@ -154,6 +158,10 @@ class PayPerTranscriptApp:
         self._connect_signals()
         self._tray.show()
 
+        # V04: LLM-Initialisierungs-Warnung als Overlay anzeigen (nach Tray-Erstellung)
+        if self._llm_init_warning:
+            self._overlay.show_error("LLM deaktiviert")
+
         # Periodischer Update-Check
         self._update_timer = QTimer()
         check_hours = self._config.get("updates.check_interval_hours", 24)
@@ -236,6 +244,7 @@ class PayPerTranscriptApp:
 
         # LLM-Provider erstellen (optional)
         self._llm_provider = None
+        self._llm_init_warning: str | None = None
         try:
             self._llm_provider = create_llm_provider(
                 config.get("api.provider", "groq"),
@@ -247,6 +256,10 @@ class PayPerTranscriptApp:
             log.warning(
                 "LLM-Provider konnte nicht erstellt werden: %s - LLM-Formatierung deaktiviert", e
             )
+            self._llm_init_warning = (
+                "LLM-Formatierung deaktiviert — Rohtext wird eingefügt.\n"
+                f"Grund: {e}"
+            )
 
         # Session-Logger
         self._session_logger = SessionLogger()
@@ -282,6 +295,58 @@ class PayPerTranscriptApp:
         """Gibt die letzte Transkription aus der Pipeline zurueck."""
         return self._pipeline.last_transcription
 
+    def _get_last_wav_path(self):
+        """Gibt den Pfad der letzten WAV-Datei zurueck (oder None)."""
+        path = self._pipeline.last_wav_path
+        if path and path.exists():
+            return path
+        return None
+
+    def _retranscribe_precise(self) -> None:
+        """Transkribiert die letzte Aufnahme erneut mit whisper-large-v3."""
+        import threading
+
+        wav_path = self._get_last_wav_path()
+        if not wav_path:
+            self._signals.processing_error.emit("Keine Aufnahme")
+            return
+
+        def _worker():
+            try:
+                self._signals.recording_stopped.emit()  # Overlay: "Transkribiere..."
+
+                api_key = load_api_key() or os.environ.get("GROQ_API_KEY")
+                stt = create_stt_provider(
+                    self._config.get("api.provider", "groq"),
+                    model="whisper-large-v3",
+                    api_key=api_key,
+                )
+
+                language = self._config.get("general.language", "de")
+                words = self._config.get("words.misspelled_words", [])
+                from paypertranscript.pipeline.transcription import _build_word_list_prompt
+                prompt = _build_word_list_prompt(words)
+
+                text = stt.transcribe(wav_path, language=language, prompt=prompt)
+                if not text:
+                    self._signals.processing_error.emit("Kein Text erkannt")
+                    return
+
+                import pyperclip
+                pyperclip.copy(text)
+                self._pipeline.last_transcription = text
+
+                self._signals.processing_done.emit()
+                self._signals.done_message.emit("Kopiert")
+            except ProviderError as e:
+                log.error("Re-Transkription fehlgeschlagen: %s", e)
+                self._signals.processing_error.emit(f"Re-Transkription fehlgeschlagen: {e}")
+            except Exception as e:
+                log.error("Re-Transkription: Unerwarteter Fehler: %s", e, exc_info=True)
+                self._signals.processing_error.emit("Re-Transkription fehlgeschlagen")
+
+        threading.Thread(target=_worker, daemon=True, name="retranscribe-precise").start()
+
     def _connect_signals(self) -> None:
         """Verbindet AppSignals mit Tray- und Overlay-Slots."""
         # Tray
@@ -300,6 +365,9 @@ class PayPerTranscriptApp:
         self._signals.processing_done.connect(self._overlay.show_done)
         self._signals.processing_error.connect(self._overlay.show_error)
 
+        # Done mit Text (z.B. "Kopiert")
+        self._signals.done_message.connect(self._overlay.show_done_message)
+
         # Update
         self._signals.update_available.connect(self._tray.on_update_available)
         self._signals.update_not_available.connect(self._tray.on_update_not_available)
@@ -334,7 +402,7 @@ class PayPerTranscriptApp:
         self._signals.recording_stopped.emit()
 
         if audio is None:
-            self._signals.processing_done.emit()
+            self._signals.processing_error.emit("Keine Aufnahme")
             return
 
         actual_duration = len(audio) / 16000
@@ -345,7 +413,7 @@ class PayPerTranscriptApp:
                 MIN_RECORDING_DURATION,
             )
             self._current_window = None
-            self._signals.processing_done.emit()
+            self._signals.processing_error.emit("Aufnahme zu kurz")
             return
 
         # WAV speichern
@@ -365,10 +433,6 @@ class PayPerTranscriptApp:
                 "Aufnahme sehr lang (%.0fs) - wird trotzdem gesendet",
                 actual_duration,
             )
-            self._tray.show_info(
-                f"Lange Aufnahme ({actual_duration / 60:.0f} Min). "
-                "Wird trotzdem gesendet."
-            )
 
         # Pipeline in Hintergrund-Thread starten (non-blocking)
         self._pipeline.process_async(
@@ -392,6 +456,8 @@ class PayPerTranscriptApp:
             self._signals.formatting_started.emit()
         elif status == STATUS_DONE:
             self._signals.processing_done.emit()
+        elif status == STATUS_LLM_FALLBACK:
+            log.info("LLM-Fallback auf Rohtext: %s", detail)
         elif status == STATUS_ERROR:
             self._signals.processing_error.emit(detail or "Transkription fehlgeschlagen")
 

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/ui/overlay.py

@@ -51,6 +51,7 @@ _FPS_INTERVAL = 16  # ~60fps
 _FADE_IN_MS = 120
 _FADE_OUT_MS = 200  # Smooth fade-out (nicht abrupt)
 _DONE_SHOW_MS = 700  # Kurz sichtbar, dann smooth weg
+_DONE_MSG_SHOW_MS = 1200  # Done mit Text: laenger sichtbar damit lesbar
 _ERROR_SHOW_MS = 2500
 
 # -- Visualizer --
@@ -76,6 +77,7 @@ class StatusOverlay(QWidget):
     TRANSCRIBING = "transcribing"
     FORMATTING = "formatting"
     DONE = "done"
+    DONE_MESSAGE = "done_message"
     ERROR = "error"
 
     def __init__(self, config: ConfigManager, parent: QWidget | None = None) -> None:
@@ -83,6 +85,7 @@ class StatusOverlay(QWidget):
         self._config = config
         self._state: str | None = None
         self._error_message = ""
+        self._done_message = ""
 
         # Animation
         self._tick = 0
@@ -134,6 +137,12 @@ class StatusOverlay(QWidget):
         self._switch_state(self.DONE)
         self._hide_timer.start(_DONE_SHOW_MS)
 
+    @Slot(str)
+    def show_done_message(self, message: str) -> None:
+        self._done_message = message
+        self._switch_state(self.DONE_MESSAGE)
+        self._hide_timer.start(_DONE_MSG_SHOW_MS)
+
     @Slot(str)
     def show_error(self, message: str) -> None:
         self._error_message = message
@@ -263,13 +272,15 @@ class StatusOverlay(QWidget):
             self._draw_processing(p)
         elif self._state == self.DONE:
             self._draw_done(p)
+        elif self._state == self.DONE_MESSAGE:
+            self._draw_done_message(p)
         elif self._state == self.ERROR:
             self._draw_error(p)
 
         p.end()
 
     def _accent_color(self) -> QColor:
-        if self._state == self.DONE:
+        if self._state in (self.DONE, self.DONE_MESSAGE):
             return _GREEN
         if self._state == self.ERROR:
             return _RED
@@ -365,6 +376,37 @@ class StatusOverlay(QWidget):
         p.drawLine(int(cx - 6), int(cy), int(cx - 2), int(cy + 5))
         p.drawLine(int(cx - 2), int(cy + 5), int(cx + 7), int(cy - 4))
 
+    def _draw_done_message(self, p: QPainter) -> None:
+        """Gruener Checkmark + Text (z.B. 'Kopiert')."""
+        ix = 24
+        cy = _HEIGHT / 2
+
+        # Glow
+        glow = QRadialGradient(ix, cy, 12)
+        g = QColor(_GREEN)
+        g.setAlpha(30)
+        glow.setColorAt(0.0, g)
+        glow.setColorAt(1.0, QColor(0, 0, 0, 0))
+        p.setPen(Qt.PenStyle.NoPen)
+        p.setBrush(glow)
+        p.drawEllipse(QRectF(ix - 12, cy - 12, 24, 24))
+
+        # Checkmark
+        pen = QPen(_GREEN, 2.0, Qt.PenStyle.SolidLine,
+                   Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin)
+        p.setPen(pen)
+        p.drawLine(int(ix - 6), int(cy), int(ix - 2), int(cy + 5))
+        p.drawLine(int(ix - 2), int(cy + 5), int(ix + 7), int(cy - 4))
+
+        # Text
+        font = QFont("Segoe UI", 8)
+        font.setWeight(QFont.Weight.Medium)
+        p.setFont(font)
+        p.setPen(QPen(_TEXT_PRIMARY))
+        msg = self._done_message or "OK"
+        p.drawText(QRectF(ix + 14, 0, _WIDTH - ix - 24, _HEIGHT),
+                   Qt.AlignmentFlag.AlignVCenter | Qt.TextFlag.TextSingleLine, msg)
+
     def _draw_error(self, p: QPainter) -> None:
         """Rotes X + Fehlermeldung."""
         ix = 24

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/paypertranscript/ui/tray.py

@@ -178,6 +178,8 @@ class SystemTray:
         show_done_overlay: Callable[[], None] | None = None,
         on_update_check: Callable[[], None] | None = None,
         on_perform_update: Callable[[], None] | None = None,
+        get_last_wav_path: Callable | None = None,
+        on_retranscribe_precise: Callable[[], None] | None = None,
         parent: QWidget | None = None,
     ) -> None:
         self._config = config
@@ -187,6 +189,8 @@ class SystemTray:
         self._show_done_overlay = show_done_overlay
         self._on_update_check = on_update_check
         self._on_perform_update = on_perform_update
+        self._get_last_wav_path = get_last_wav_path
+        self._on_retranscribe_precise = on_retranscribe_precise
         self._icons = create_tray_icons()
 
         # MainWindow (lazy creation)
@@ -207,15 +211,6 @@ class SystemTray:
         self._tray.show()
         log.info("System Tray angezeigt")
 
-    def show_info(self, message: str) -> None:
-        """Zeigt eine Info-Benachrichtigung im System Tray."""
-        self._tray.showMessage(
-            "PayPerTranscript",
-            message,
-            QSystemTrayIcon.MessageIcon.Information,
-            3000,
-        )
-
     def hide(self) -> None:
         """Versteckt das Tray-Icon."""
         self._tray.hide()
@@ -247,6 +242,8 @@ class SystemTray:
         self._tray.setToolTip(self._build_tooltip())
         if self._get_last_transcription and self._get_last_transcription():
             self._act_copy_last.setEnabled(True)
+        if self._get_last_wav_path and self._get_last_wav_path():
+            self._act_retranscribe.setEnabled(True)
 
     @Slot(str)
     def on_processing_error(self, message: str) -> None:
@@ -271,6 +268,10 @@ class SystemTray:
         self._act_copy_last.triggered.connect(self._on_copy_last_transcription)
         self._act_copy_last.setEnabled(False)
 
+        self._act_retranscribe = self._menu.addAction("Erneut transkribieren (Pr\u00e4zise)")
+        self._act_retranscribe.triggered.connect(self._on_retranscribe)
+        self._act_retranscribe.setEnabled(False)
+
         self._menu.addSeparator()
 
         act_quit = self._menu.addAction("Beenden")
@@ -321,6 +322,11 @@ class SystemTray:
         else:
             log.info("Keine Transkription zum Kopieren vorhanden")
 
+    def _on_retranscribe(self) -> None:
+        """Startet Re-Transkription mit praezisem Modell."""
+        if self._on_retranscribe_precise:
+            self._on_retranscribe_precise()
+
     # -- Update-Callbacks --
 
     def _get_update_dialog(self) -> _UpdateInfoDialog:

{paypertranscript-0.2.9 → paypertranscript-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PayPerTranscript"
-version = "0.2.9"
+version = "0.3.0"
 description = "Open-Source Voice-to-Text mit Pay-per-Use Pricing"
 license = "MIT"
 requires-python = ">=3.12"

paypertranscript-0.2.9/paypertranscript/providers/groq_provider.py

@@ -1,193 +0,0 @@
-"""GroqCloud API-Provider für PayPerTranscript.
-
-Implementiert STT (Whisper) und LLM-Formatierung über die GroqCloud API.
-"""
-
-from collections.abc import Iterator
-from pathlib import Path
-
-import groq
-
-from paypertranscript.core.logging import get_logger
-from paypertranscript.providers.base import AbstractLLMProvider, AbstractSTTProvider, ProviderError
-
-log = get_logger("providers.groq")
-
-
-class GroqSTTProvider(AbstractSTTProvider):
-    """GroqCloud Whisper STT-Provider.
-
-    Nutzt whisper-large-v3-turbo für Speech-to-Text.
-    Der Groq-Client wird einmal instanziiert und wiederverwendet
-    (Connection Pooling via httpx).
-    """
-
-    def __init__(
-        self,
-        api_key: str | None = None,
-        model: str = "whisper-large-v3-turbo",
-    ) -> None:
-        self._model = model
-        try:
-            self._client = groq.Groq(api_key=api_key)
-        except groq.GroqError as e:
-            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
-        log.info("GroqSTTProvider initialisiert (Modell: %s)", self._model)
-
-    def transcribe(self, audio_path: Path, language: str, prompt: str = "") -> str:
-        """Transkribiert eine WAV-Datei via GroqCloud Whisper API."""
-        if not audio_path.exists():
-            raise ProviderError(f"Audio-Datei nicht gefunden: {audio_path}")
-
-        log.info(
-            "STT-Anfrage: %s (Sprache: %s, Modell: %s)",
-            audio_path.name,
-            language,
-            self._model,
-        )
-        if prompt:
-            log.info("STT-Prompt: %s", prompt)
-
-        try:
-            with open(audio_path, "rb") as audio_file:
-                transcription = self._client.audio.transcriptions.create(
-                    model=self._model,
-                    file=audio_file,
-                    language=language,
-                    prompt=prompt,
-                    response_format="text",
-                    temperature=0.0,
-                )
-        except groq.AuthenticationError as e:
-            raise ProviderError(f"API-Key ungültig: {e}") from e
-        except groq.RateLimitError as e:
-            raise ProviderError(f"Rate Limit erreicht: {e}") from e
-        except groq.APIConnectionError as e:
-            raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
-        except groq.APITimeoutError as e:
-            raise ProviderError(f"GroqCloud Timeout: {e}") from e
-        except groq.APIError as e:
-            raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
-
-        # response_format="text" gibt direkt einen String zurück
-        text = transcription.strip() if isinstance(transcription, str) else transcription.text.strip()
-
-        log.info("STT-Ergebnis: %d Zeichen", len(text))
-        return text
-
-
-class GroqLLMProvider(AbstractLLMProvider):
-    """GroqCloud LLM-Provider für Textformatierung.
-
-    Nutzt openai/gpt-oss-20b für kontextabhängige Formatierung.
-    Der Groq-Client wird einmal instanziiert und wiederverwendet.
-    """
-
-    def __init__(
-        self,
-        api_key: str | None = None,
-        model: str = "openai/gpt-oss-20b",
-        temperature: float | None = None,
-    ) -> None:
-        self._model = model
-        self._temperature = temperature
-        self._last_usage: dict[str, int] | None = None
-        try:
-            self._client = groq.Groq(api_key=api_key)
-        except groq.GroqError as e:
-            raise ProviderError(f"Groq-Client konnte nicht erstellt werden: {e}") from e
-        log.info("GroqLLMProvider initialisiert (Modell: %s, Temperature: %s)", self._model, self._temperature)
-
-    @property
-    def last_usage(self) -> dict[str, int] | None:
-        """Token-Usage der letzten LLM-Anfrage."""
-        return self._last_usage
-
-    def _build_messages(
-        self, system_prompt: str, text: str
-    ) -> list[dict[str, str]]:
-        return [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"<transcript>{text}</transcript>"},
-        ]
-
-    def _completion_kwargs(self) -> dict:
-        """Baut gemeinsame kwargs für chat.completions.create."""
-        kwargs: dict = {}
-        if self._temperature is not None:
-            kwargs["temperature"] = self._temperature
-        return kwargs
-
-    def format_text(self, system_prompt: str, text: str) -> str:
-        log.info("LLM-Anfrage (non-streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
-        self._last_usage = None
-        try:
-            response = self._client.chat.completions.create(
-                model=self._model,
-                messages=self._build_messages(system_prompt, text),
-                stream=False,
-                **self._completion_kwargs(),
-            )
-        except groq.AuthenticationError as e:
-            raise ProviderError(f"API-Key ungültig: {e}") from e
-        except groq.RateLimitError as e:
-            raise ProviderError(f"Rate Limit erreicht: {e}") from e
-        except groq.APIConnectionError as e:
-            raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
-        except groq.APITimeoutError as e:
-            raise ProviderError(f"GroqCloud Timeout: {e}") from e
-        except groq.APIError as e:
-            raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
-
-        # Usage-Daten erfassen
-        if hasattr(response, "usage") and response.usage:
-            self._last_usage = {
-                "prompt_tokens": response.usage.prompt_tokens or 0,
-                "completion_tokens": response.usage.completion_tokens or 0,
-            }
-
-        result = response.choices[0].message.content or ""
-        result = result.strip()
-        log.info("LLM-Ergebnis: %d Zeichen", len(result))
-        return result
-
-    def format_text_stream(self, system_prompt: str, text: str) -> Iterator[str]:
-        log.info("LLM-Anfrage (streaming, Modell: %s, Temperature: %s)", self._model, self._temperature)
-        self._last_usage = None
-        try:
-            stream = self._client.chat.completions.create(
-                model=self._model,
-                messages=self._build_messages(system_prompt, text),
-                stream=True,
-                **self._completion_kwargs(),
-            )
-        except groq.AuthenticationError as e:
-            raise ProviderError(f"API-Key ungültig: {e}") from e
-        except groq.RateLimitError as e:
-            raise ProviderError(f"Rate Limit erreicht: {e}") from e
-        except groq.APIConnectionError as e:
-            raise ProviderError(f"Keine Verbindung zu GroqCloud: {e}") from e
-        except groq.APITimeoutError as e:
-            raise ProviderError(f"GroqCloud Timeout: {e}") from e
-        except groq.APIError as e:
-            raise ProviderError(f"GroqCloud API-Fehler: {e}") from e
-
-        total_chars = 0
-        for chunk in stream:
-            delta = chunk.choices[0].delta.content
-            if delta:
-                total_chars += len(delta)
-                yield delta
-            # Groq streaming: Usage im letzten Chunk via x_groq
-            if (
-                hasattr(chunk, "x_groq")
-                and chunk.x_groq
-                and hasattr(chunk.x_groq, "usage")
-                and chunk.x_groq.usage
-            ):
-                usage = chunk.x_groq.usage
-                self._last_usage = {
-                    "prompt_tokens": getattr(usage, "prompt_tokens", 0) or 0,
-                    "completion_tokens": getattr(usage, "completion_tokens", 0) or 0,
-                }
-        log.info("LLM-Stream abgeschlossen: %d Zeichen", total_chars)