PayPerTranscript 0.2.9__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.9
+Version: 0.3.1
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT
@@ -65,6 +65,7 @@ Kommerzielle Voice-to-Text Dienste kosten **$12-15/Monat** - egal ob du sie 5 Mi
 - **Hold-to-Record**: `Ctrl+Win` halten - sprechen - loslassen - fertig
 - **Blitzschnell**: 30 Sekunden Audio = 0.14 Sekunden Transkription (via Groq Whisper)
 - **Smart Formatting**: WhatsApp bekommt lockere Texte, Outlook professionelle E-Mails
+- **Kontext-Erkennung**: Markierten Text im aktiven Fenster erkennen - das LLM nutzt ihn für korrekte Schreibweisen und Bezüge
 - **Wortliste**: Eigene Namen und Fachbegriffe werden immer korrekt geschrieben
 
 ### 📊 Transparenz & Kontrolle

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.2.9
+Version: 0.3.1
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT
@@ -65,6 +65,7 @@ Kommerzielle Voice-to-Text Dienste kosten **$12-15/Monat** - egal ob du sie 5 Mi
 - **Hold-to-Record**: `Ctrl+Win` halten - sprechen - loslassen - fertig
 - **Blitzschnell**: 30 Sekunden Audio = 0.14 Sekunden Transkription (via Groq Whisper)
 - **Smart Formatting**: WhatsApp bekommt lockere Texte, Outlook professionelle E-Mails
+- **Kontext-Erkennung**: Markierten Text im aktiven Fenster erkennen - das LLM nutzt ihn für korrekte Schreibweisen und Bezüge
 - **Wortliste**: Eigene Namen und Fachbegriffe werden immer korrekt geschrieben
 
 ### 📊 Transparenz & Kontrolle

{paypertranscript-0.2.9 → paypertranscript-0.3.1}/PayPerTranscript.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ paypertranscript/assets/styles/dark.qss
 paypertranscript/core/__init__.py
 paypertranscript/core/audio_manager.py
 paypertranscript/core/config.py
+paypertranscript/core/context_detector.py
 paypertranscript/core/cost_tracker.py
 paypertranscript/core/hotkey.py
 paypertranscript/core/logging.py

{paypertranscript-0.2.9 → paypertranscript-0.3.1}/README.md

@@ -36,6 +36,7 @@ Kommerzielle Voice-to-Text Dienste kosten **$12-15/Monat** - egal ob du sie 5 Mi
 - **Hold-to-Record**: `Ctrl+Win` halten - sprechen - loslassen - fertig
 - **Blitzschnell**: 30 Sekunden Audio = 0.14 Sekunden Transkription (via Groq Whisper)
 - **Smart Formatting**: WhatsApp bekommt lockere Texte, Outlook professionelle E-Mails
+- **Kontext-Erkennung**: Markierten Text im aktiven Fenster erkennen - das LLM nutzt ihn für korrekte Schreibweisen und Bezüge
 - **Wortliste**: Eigene Namen und Fachbegriffe werden immer korrekt geschrieben
 
 ### 📊 Transparenz & Kontrolle

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

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

{paypertranscript-0.2.9 → paypertranscript-0.3.1}/paypertranscript/core/config.py

@@ -49,19 +49,29 @@ DEFAULT_CONFIG: dict[str, Any] = {
             "casual": {
                 "name": "Persönlich",
                 "prompt": (
-                    "Formatiere den folgenden transkribierten Text als lockere "
-                    "Chat-Nachricht. Alles kleingeschrieben, minimale Interpunktion, "
-                    "Kommas zur Trennung von Gedanken. Kein Punkt am Ende. "
-                    "Gib NUR den formatierten Text aus, keine Erklärungen."
+                    "Du bist ein Transkriptions-Assistent fuer lockere Chat-Nachrichten. "
+                    "Deine Aufgabe: Formatiere den transkribierten Text als informelle Nachricht.\n\n"
+                    "Regeln:\n"
+                    "- Alles kleingeschrieben\n"
+                    "- Minimale Interpunktion\n"
+                    "- Kommas NUR zur Trennung von Saetzen, nicht innerhalb eines Satzes\n"
+                    "- Kein Punkt am Satzende (Fragezeichen sind erlaubt)\n"
+                    "- Entferne Fuellwoerter und Wiederholungen\n\n"
+                    "Gib NUR den formatierten Text aus. "
+                    "Beantworte keine Fragen, fuege keine Erklaerungen hinzu."
                 ),
             },
             "professional": {
                 "name": "Professionell",
                 "prompt": (
-                    "Formatiere den folgenden transkribierten Text als professionelle "
-                    "Nachricht. Korrekte Groß-/Kleinschreibung, saubere Interpunktion, "
-                    "entferne Füllwörter und Wiederholungen. Sachlicher Stil, kurze "
-                    "Absätze. Gib NUR den formatierten Text aus, keine Erklärungen."
+                    "Du bist ein Transkriptions-Assistent fuer professionelle Kommunikation. "
+                    "Deine Aufgabe: Formatiere den transkribierten Text als sachliche, professionelle Nachricht.\n\n"
+                    "Regeln:\n"
+                    "- Korrekte Gross-/Kleinschreibung und Interpunktion\n"
+                    "- Entferne Fuellwoerter und Wiederholungen\n"
+                    "- Sachlicher Stil, kurze Absaetze\n\n"
+                    "Gib NUR den formatierten Text aus. "
+                    "Beantworte keine Fragen, fuege keine Erklaerungen hinzu."
                 ),
             },
         },
@@ -74,6 +84,14 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "auto_update": True,
         "check_interval_hours": 24,
     },
+    "context": {
+        "detect_selection": True,
+        "terminal_blocklist": [
+            "cmd.exe", "powershell.exe", "pwsh.exe",
+            "WindowsTerminal.exe", "mintty.exe", "bash.exe",
+            "wsl.exe", "conhost.exe",
+        ],
+    },
 }
 
 # Schema: Erlaubte Typen pro Pfad für Validierung
@@ -96,6 +114,8 @@ _SCHEMA: dict[str, type | tuple[type, ...]] = {
     "data.save_transcripts": bool,
     "updates.auto_update": bool,
     "updates.check_interval_hours": (int, float),
+    "context.detect_selection": bool,
+    "context.terminal_blocklist": list,
 }
 
 

paypertranscript-0.3.1/paypertranscript/core/context_detector.py

@@ -0,0 +1,255 @@
+"""Kontext-Erkennung fuer PayPerTranscript.
+
+Prueft ob im aktiven Fenster Text markiert ist (via Clipboard-Sentinel + Ctrl+C).
+Der erkannte Text wird dem LLM als Kontext mitgegeben, z.B. fuer Antworten auf E-Mails.
+
+Die Erkennung laeuft parallel zum STT-API-Call und fuegt 0ms zusaetzliche Latenz hinzu.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import threading
+import time
+from concurrent.futures import Future
+
+import pyautogui
+import pyperclip
+
+from paypertranscript.core.config import ConfigManager
+from paypertranscript.core.logging import get_logger
+from paypertranscript.core.window_detector import WindowInfo
+
+log = get_logger("core.context_detector")
+
+# Sentinel: Null-Bytes koennen nicht in normalem Clipboard-Text vorkommen
+_SENTINEL = "\x00__PPT_SENTINEL__\x00"
+
+# Wartezeit nach Ctrl+C bevor Clipboard gelesen wird (ms)
+_CLIPBOARD_WAIT_MS = 80
+
+# Timeout fuer Modifier-Release-Wait (ms)
+_MODIFIER_RELEASE_TIMEOUT_MS = 400
+
+# Virtual-Key-Codes fuer Modifier-Keys (Win32)
+_VK_MODIFIERS = (
+    0x10,  # VK_SHIFT
+    0x11,  # VK_CONTROL
+    0x12,  # VK_MENU (Alt)
+    0x5B,  # VK_LWIN
+    0x5C,  # VK_RWIN
+)
+
+# Terminal-Prozesse in denen Ctrl+C nicht gesendet werden darf (SIGINT-Gefahr)
+_DEFAULT_TERMINAL_BLOCKLIST = frozenset({
+    "cmd.exe", "powershell.exe", "pwsh.exe",
+    "windowsterminal.exe", "mintty.exe", "bash.exe",
+    "wsl.exe", "conhost.exe", "alacritty.exe",
+    "wezterm-gui.exe", "hyper.exe",
+})
+
+
+def detect_selected_text(
+    window: WindowInfo | None,
+    config: ConfigManager,
+    cancel_event: threading.Event | None = None,
+) -> str:
+    """Prueft ob im aktiven Fenster Text markiert ist und gibt ihn zurueck.
+
+    Ablauf:
+    1. Feature-Flag und Terminal-Blocklist pruefen
+    2. Clipboard sichern → Sentinel setzen → Ctrl+C → Clipboard lesen → wiederherstellen
+    3. Wenn Clipboard != Sentinel: markierter Text gefunden
+
+    Gibt in ALLEN Fehler-/Abbruch-Faellen "" zurueck — wirft nie Exceptions.
+    Die Pipeline wird dadurch nie blockiert oder gestoert.
+
+    Args:
+        window: Info ueber das aktive Fenster (fuer Blocklist-Check).
+        config: ConfigManager-Instanz.
+        cancel_event: Optionales Event zum Abbrechen der Erkennung.
+
+    Returns:
+        Markierter Text oder "" wenn nichts markiert / Fehler / deaktiviert.
+    """
+    t_start = time.perf_counter()
+
+    try:
+        # 1. Feature-Flag pruefen
+        if not config.get("context.detect_selection", True):
+            log.debug("Context detection disabled by config")
+            return ""
+
+        # 2. Abbruch pruefen
+        if cancel_event and cancel_event.is_set():
+            log.debug("Context detection cancelled before start")
+            return ""
+
+        # 3. Terminal-Blocklist pruefen
+        if window and window.process_name:
+            process_lower = window.process_name.lower()
+            blocklist = config.get("context.terminal_blocklist", [])
+            blocklist_lower = {p.lower() for p in blocklist}
+            # Auch Default-Blocklist pruefen
+            blocklist_lower.update(p.lower() for p in _DEFAULT_TERMINAL_BLOCKLIST)
+
+            if process_lower in blocklist_lower:
+                log.debug(
+                    "Context detection skipped: terminal process '%s'",
+                    window.process_name,
+                )
+                return ""
+
+            log.debug(
+                "Context detection started for window '%s'",
+                window.process_name,
+            )
+        else:
+            log.debug("Context detection started (no window info)")
+
+        # 4. Clipboard sichern
+        try:
+            original_clipboard = pyperclip.paste()
+        except Exception:
+            original_clipboard = ""
+        log.debug("Clipboard backed up (%d chars)", len(original_clipboard))
+
+        # 5. Sentinel auf Clipboard setzen
+        try:
+            pyperclip.copy(_SENTINEL)
+        except Exception as e:
+            log.warning("Context detection: clipboard write failed: %s", e)
+            return ""
+        log.debug("Sentinel placed on clipboard")
+
+        # 6. Abbruch pruefen
+        if cancel_event and cancel_event.is_set():
+            _restore_clipboard(original_clipboard)
+            log.debug("Context detection cancelled before Ctrl+C")
+            return ""
+
+        # 7. Warten bis Modifier-Keys losgelassen sind (noetig fuer Toggle-Hotkey:
+        #    User haelt noch Ctrl+Alt → Ctrl+C wuerde als Ctrl+Alt+C ankommen)
+        _wait_for_modifiers_released()
+
+        # 8. Ctrl+C senden
+        pyautogui.hotkey("ctrl", "c")
+        t_ctrlc = time.perf_counter()
+        log.debug("Ctrl+C sent (%.1fms after start)", (t_ctrlc - t_start) * 1000)
+
+        # 9. Warten bis Clipboard aktualisiert
+        time.sleep(_CLIPBOARD_WAIT_MS / 1000)
+
+        # 10. Clipboard lesen
+        try:
+            clipboard_content = pyperclip.paste()
+        except Exception as e:
+            log.warning("Context detection: clipboard read failed: %s", e)
+            _restore_clipboard(original_clipboard)
+            return ""
+
+        t_read = time.perf_counter()
+        log.debug(
+            "Clipboard read after Ctrl+C (%.1fms after start)",
+            (t_read - t_start) * 1000,
+        )
+
+        # 11. Auswerten: Hat Ctrl+C den Sentinel ueberschrieben?
+        if clipboard_content == _SENTINEL:
+            # Sentinel unveraendert → nichts war markiert
+            _restore_clipboard(original_clipboard)
+            t_end = time.perf_counter()
+            log.debug("No text selected (%.1fms total)", (t_end - t_start) * 1000)
+            return ""
+
+        # Text war markiert!
+        selected_text = clipboard_content.strip()
+
+        # 12. Original-Clipboard wiederherstellen
+        _restore_clipboard(original_clipboard)
+
+        t_end = time.perf_counter()
+        if selected_text:
+            log.info(
+                "Selected text detected: %d chars (%.1fms total)",
+                len(selected_text),
+                (t_end - t_start) * 1000,
+            )
+        else:
+            log.debug("No text selected (empty after strip, %.1fms total)", (t_end - t_start) * 1000)
+
+        return selected_text
+
+    except Exception as e:
+        t_end = time.perf_counter()
+        log.warning(
+            "Context detection failed (%.1fms): %s",
+            (t_end - t_start) * 1000,
+            e,
+        )
+        return ""
+
+
+def _wait_for_modifiers_released() -> None:
+    """Wartet bis alle Modifier-Keys (Ctrl, Alt, Shift, Win) losgelassen sind.
+
+    Noetig fuer Toggle-Hotkey: Der User haelt noch Ctrl+Alt wenn die
+    Context-Detection startet. Ctrl+C waehrend Ctrl+Alt gehalten wird,
+    wuerde als Ctrl+Alt+C interpretiert und Copy nicht ausloesen.
+
+    Beim Hold-Hotkey sind die Keys bereits losgelassen → returned sofort.
+    """
+    user32 = ctypes.windll.user32
+    deadline = time.perf_counter() + _MODIFIER_RELEASE_TIMEOUT_MS / 1000
+
+    while time.perf_counter() < deadline:
+        if not any(user32.GetAsyncKeyState(vk) & 0x8000 for vk in _VK_MODIFIERS):
+            return
+        time.sleep(0.01)  # 10ms polling
+
+    # Timeout: Modifier immer noch gehalten — trotzdem weitermachen
+    log.debug(
+        "Modifier keys still held after %dms timeout",
+        _MODIFIER_RELEASE_TIMEOUT_MS,
+    )
+
+
+def _restore_clipboard(content: str) -> None:
+    """Stellt den Clipboard-Inhalt wieder her (best-effort)."""
+    try:
+        pyperclip.copy(content)
+    except Exception as e:
+        log.warning("Context detection: clipboard restore failed: %s", e)
+
+
+def detect_selected_text_async(
+    window: WindowInfo | None,
+    config: ConfigManager,
+    cancel_event: threading.Event | None = None,
+) -> Future[str]:
+    """Startet detect_selected_text() in einem daemon-Thread.
+
+    Args:
+        window: Info ueber das aktive Fenster.
+        config: ConfigManager-Instanz.
+        cancel_event: Optionales Event zum Abbrechen.
+
+    Returns:
+        Future[str] das den markierten Text (oder "") enthaelt.
+    """
+    future: Future[str] = Future()
+
+    def _worker() -> None:
+        try:
+            result = detect_selected_text(window, config, cancel_event)
+            future.set_result(result)
+        except Exception as e:
+            future.set_exception(e)
+
+    thread = threading.Thread(
+        target=_worker,
+        daemon=True,
+        name="context-detector",
+    )
+    thread.start()
+    return future

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

@@ -5,6 +5,7 @@ Unterstützt Hold-to-Record und Toggle-Modus.
 """
 
 import threading
+import time
 from collections.abc import Callable
 from typing import Any
 
@@ -54,9 +55,18 @@ _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}
 
+# Minimale Zeit zwischen zwei Toggle-Ausloesungen (Sekunden).
+# Verhindert Ghost-Toggles durch synthetische Key-Events (z.B. pyautogui Ctrl+C).
+_TOGGLE_DEBOUNCE_S = 0.5
+
 
 def _resolve_key(key_str: str) -> keyboard.Key | keyboard.KeyCode:
     """Löst einen Config-String in ein pynput-Key-Objekt auf."""
@@ -136,6 +146,7 @@ class HotkeyListener:
         self._pressed_keys: set[keyboard.Key | keyboard.KeyCode] = set()
         self._hold_active = False
         self._toggle_combo_held = False
+        self._toggle_last_fired: float = 0.0
         self._listener: keyboard.Listener | None = None
         self._lock = threading.Lock()
         self._kb_controller: keyboard.Controller | None = None
@@ -149,18 +160,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:
@@ -192,12 +218,20 @@ class HotkeyListener:
                 if self._on_hold_start:
                     threading.Thread(target=self._on_hold_start, daemon=True).start()
 
-            # Toggle-Hotkey prüfen
-            if self._toggle_keys and self._check_combo(self._toggle_keys, self._toggle_modifier_groups):
-                self._toggle_combo_held = True
-                log.debug("Toggle-Hotkey gedrückt")
-                if self._on_toggle:
-                    threading.Thread(target=self._on_toggle, daemon=True).start()
+            # Toggle-Hotkey prüfen (Guard + Debounce gegen synthetische Key-Events)
+            if (self._toggle_keys
+                    and not self._toggle_combo_held
+                    and self._check_combo(self._toggle_keys, self._toggle_modifier_groups)):
+                now = time.monotonic()
+                if (now - self._toggle_last_fired) >= _TOGGLE_DEBOUNCE_S:
+                    self._toggle_combo_held = True
+                    self._toggle_last_fired = now
+                    log.debug("Toggle-Hotkey gedrückt")
+                    if self._on_toggle:
+                        threading.Thread(target=self._on_toggle, daemon=True).start()
+                else:
+                    self._toggle_combo_held = True
+                    log.debug("Toggle-Hotkey ignoriert (Debounce)")
 
     def _on_release(self, key: keyboard.Key | keyboard.KeyCode) -> None:
         """Callback für Key-Release-Events."""
@@ -281,6 +315,7 @@ class HotkeyListener:
             # State zurücksetzen
             self._hold_active = False
             self._toggle_combo_held = False
+            self._toggle_last_fired = 0.0
             self._pressed_keys.clear()
 
     @property

{paypertranscript-0.2.9 → paypertranscript-0.3.1}/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)