PayPerTranscript 0.3.1__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.3.1
+Version: 0.3.2
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT
@@ -22,6 +22,7 @@ Requires-Dist: pyperclip
 Requires-Dist: pyautogui
 Requires-Dist: keyring
 Requires-Dist: soundfile
+Requires-Dist: packaging
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PayPerTranscript
-Version: 0.3.1
+Version: 0.3.2
 Summary: Open-Source Voice-to-Text mit Pay-per-Use Pricing
 Author: PayPerTranscript Contributors
 License-Expression: MIT
@@ -22,6 +22,7 @@ Requires-Dist: pyperclip
 Requires-Dist: pyautogui
 Requires-Dist: keyring
 Requires-Dist: soundfile
+Requires-Dist: packaging
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

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

@@ -20,7 +20,9 @@ paypertranscript/assets/sounds/start.wav
 paypertranscript/assets/sounds/stop.wav
 paypertranscript/assets/styles/dark.qss
 paypertranscript/core/__init__.py
+paypertranscript/core/atomic_io.py
 paypertranscript/core/audio_manager.py
+paypertranscript/core/clipboard_manager.py
 paypertranscript/core/config.py
 paypertranscript/core/context_detector.py
 paypertranscript/core/cost_tracker.py
@@ -52,4 +54,14 @@ paypertranscript/ui/pages/home_page.py
 paypertranscript/ui/pages/settings_page.py
 paypertranscript/ui/pages/statistics_page.py
 paypertranscript/ui/pages/window_mapping_page.py
-paypertranscript/ui/pages/word_list_page.py
+paypertranscript/ui/pages/word_list_page.py
+tests/test_atomic_and_session_logger.py
+tests/test_clipboard_integration.py
+tests/test_clipboard_manager_formats.py
+tests/test_groq_provider_logging.py
+tests/test_home_page_config_key.py
+tests/test_hotkey_settings_and_timer.py
+tests/test_pipeline_privacy_and_transcripts.py
+tests/test_recorder_thread_safety.py
+tests/test_release_script.py
+tests/test_updater_version.py

{paypertranscript-0.3.1 → paypertranscript-0.3.2}/PayPerTranscript.egg-info/requires.txt

@@ -9,6 +9,7 @@ pyperclip
 pyautogui
 keyring
 soundfile
+packaging
 
 [dev]
 build

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

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

paypertranscript-0.3.2/paypertranscript/core/atomic_io.py

@@ -0,0 +1,29 @@
+"""Atomic file writing helpers."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+
+def atomic_write_text(path: Path, content: str, encoding: str = "utf-8") -> None:
+    """Atomically write text content to a file."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=str(path.parent),
+    )
+    try:
+        with os.fdopen(fd, "w", encoding=encoding, newline="") as tmp_file:
+            tmp_file.write(content)
+            tmp_file.flush()
+            os.fsync(tmp_file.fileno())
+        os.replace(tmp_name, path)
+    except Exception:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise

paypertranscript-0.3.2/paypertranscript/core/clipboard_manager.py

@@ -0,0 +1,263 @@
+"""Windows clipboard snapshot/restore helpers.
+
+Designed for low-latency clipboard preservation during context detection and paste
+operations. The implementation preserves clipboard formats best-effort by copying
+raw global-memory payloads for each available format.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import threading
+import time
+from dataclasses import dataclass
+from typing import Final
+
+from paypertranscript.core.logging import get_logger
+
+log = get_logger("core.clipboard_manager")
+
+if ctypes.sizeof(ctypes.c_void_p) == 8:
+    _SIZE_T = ctypes.c_uint64
+else:
+    _SIZE_T = ctypes.c_uint32
+
+_user32 = ctypes.WinDLL("user32", use_last_error=True)
+_kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+_user32.OpenClipboard.argtypes = [ctypes.c_void_p]
+_user32.OpenClipboard.restype = ctypes.c_int
+_user32.CloseClipboard.argtypes = []
+_user32.CloseClipboard.restype = ctypes.c_int
+_user32.EmptyClipboard.argtypes = []
+_user32.EmptyClipboard.restype = ctypes.c_int
+_user32.EnumClipboardFormats.argtypes = [ctypes.c_uint]
+_user32.EnumClipboardFormats.restype = ctypes.c_uint
+_user32.GetClipboardData.argtypes = [ctypes.c_uint]
+_user32.GetClipboardData.restype = ctypes.c_void_p
+_user32.SetClipboardData.argtypes = [ctypes.c_uint, ctypes.c_void_p]
+_user32.SetClipboardData.restype = ctypes.c_void_p
+_user32.IsClipboardFormatAvailable.argtypes = [ctypes.c_uint]
+_user32.IsClipboardFormatAvailable.restype = ctypes.c_int
+_user32.GetClipboardSequenceNumber.argtypes = []
+_user32.GetClipboardSequenceNumber.restype = ctypes.c_uint
+
+_kernel32.GlobalAlloc.argtypes = [ctypes.c_uint, _SIZE_T]
+_kernel32.GlobalAlloc.restype = ctypes.c_void_p
+_kernel32.GlobalLock.argtypes = [ctypes.c_void_p]
+_kernel32.GlobalLock.restype = ctypes.c_void_p
+_kernel32.GlobalUnlock.argtypes = [ctypes.c_void_p]
+_kernel32.GlobalUnlock.restype = ctypes.c_int
+_kernel32.GlobalSize.argtypes = [ctypes.c_void_p]
+_kernel32.GlobalSize.restype = _SIZE_T
+_kernel32.GlobalFree.argtypes = [ctypes.c_void_p]
+_kernel32.GlobalFree.restype = ctypes.c_void_p
+
+_GMEM_MOVEABLE: Final[int] = 0x0002
+_CF_UNICODETEXT: Final[int] = 13
+
+_OPEN_RETRIES: Final[int] = 5
+_OPEN_DELAY_SECONDS: Final[float] = 0.002
+
+_lock = threading.RLock()
+
+
+@dataclass(frozen=True)
+class ClipboardFormatPayload:
+    """Raw bytes for a single clipboard format."""
+
+    format_id: int
+    data: bytes
+
+
+@dataclass(frozen=True)
+class ClipboardSnapshot:
+    """Clipboard snapshot containing copied format payloads."""
+
+    sequence_number: int
+    formats: tuple[ClipboardFormatPayload, ...]
+
+
+_EMPTY_SNAPSHOT = ClipboardSnapshot(sequence_number=0, formats=())
+
+
+def _open_clipboard() -> bool:
+    for attempt in range(_OPEN_RETRIES):
+        if _user32.OpenClipboard(None):
+            return True
+        if attempt < _OPEN_RETRIES - 1:
+            time.sleep(_OPEN_DELAY_SECONDS)
+    return False
+
+
+def _copy_hglobal(handle: ctypes.c_void_p) -> bytes | None:
+    size = int(_kernel32.GlobalSize(handle))
+    if size < 0:
+        return None
+
+    ptr = _kernel32.GlobalLock(handle)
+    if not ptr:
+        return None
+
+    try:
+        if size == 0:
+            return b""
+        raw = (ctypes.c_ubyte * size).from_address(ptr)
+        return bytes(raw)
+    finally:
+        _kernel32.GlobalUnlock(handle)
+
+
+def _alloc_hglobal(data: bytes) -> ctypes.c_void_p:
+    size = max(len(data), 1)
+    handle = _kernel32.GlobalAlloc(_GMEM_MOVEABLE, size)
+    if not handle:
+        return ctypes.c_void_p()
+
+    ptr = _kernel32.GlobalLock(handle)
+    if not ptr:
+        _kernel32.GlobalFree(handle)
+        return ctypes.c_void_p()
+
+    try:
+        if data:
+            ctypes.memmove(ptr, data, len(data))
+        if size > len(data):
+            ctypes.memset(ptr + len(data), 0, size - len(data))
+    finally:
+        _kernel32.GlobalUnlock(handle)
+
+    return handle
+
+
+def snapshot_clipboard() -> ClipboardSnapshot:
+    """Capture the current clipboard in a best-effort, format-preserving way."""
+    start = time.perf_counter()
+    with _lock:
+        if not _open_clipboard():
+            log.debug("Clipboard snapshot skipped: OpenClipboard failed")
+            return _EMPTY_SNAPSHOT
+
+        try:
+            sequence_number = int(_user32.GetClipboardSequenceNumber())
+            payloads: list[ClipboardFormatPayload] = []
+
+            fmt = 0
+            while True:
+                fmt = int(_user32.EnumClipboardFormats(fmt))
+                if fmt == 0:
+                    break
+
+                handle = _user32.GetClipboardData(fmt)
+                if not handle:
+                    continue
+
+                copied = _copy_hglobal(handle)
+                if copied is None:
+                    continue
+
+                payloads.append(ClipboardFormatPayload(format_id=fmt, data=copied))
+
+            snapshot = ClipboardSnapshot(
+                sequence_number=sequence_number,
+                formats=tuple(payloads),
+            )
+            elapsed_ms = (time.perf_counter() - start) * 1000
+            log.debug(
+                "Clipboard snapshot: %d formats in %.2fms",
+                len(snapshot.formats),
+                elapsed_ms,
+            )
+            return snapshot
+        finally:
+            _user32.CloseClipboard()
+
+
+def restore_clipboard(snapshot: ClipboardSnapshot) -> bool:
+    """Restore a previously captured clipboard snapshot."""
+    start = time.perf_counter()
+    with _lock:
+        if not _open_clipboard():
+            log.warning("Clipboard restore failed: OpenClipboard failed")
+            return False
+
+        try:
+            if not _user32.EmptyClipboard():
+                log.warning("Clipboard restore failed: EmptyClipboard failed")
+                return False
+
+            restored_count = 0
+            for payload in snapshot.formats:
+                handle = _alloc_hglobal(payload.data)
+                if not handle:
+                    continue
+
+                result = _user32.SetClipboardData(payload.format_id, handle)
+                if not result:
+                    _kernel32.GlobalFree(handle)
+                    continue
+
+                restored_count += 1
+
+            elapsed_ms = (time.perf_counter() - start) * 1000
+            log.debug(
+                "Clipboard restore: %d/%d formats in %.2fms",
+                restored_count,
+                len(snapshot.formats),
+                elapsed_ms,
+            )
+            return restored_count == len(snapshot.formats)
+        finally:
+            _user32.CloseClipboard()
+
+
+def get_clipboard_text() -> str:
+    """Read UTF-16 text from clipboard if available."""
+    with _lock:
+        if not _open_clipboard():
+            return ""
+
+        try:
+            if not _user32.IsClipboardFormatAvailable(_CF_UNICODETEXT):
+                return ""
+
+            handle = _user32.GetClipboardData(_CF_UNICODETEXT)
+            if not handle:
+                return ""
+
+            ptr = _kernel32.GlobalLock(handle)
+            if not ptr:
+                return ""
+
+            try:
+                return ctypes.wstring_at(ptr) or ""
+            finally:
+                _kernel32.GlobalUnlock(handle)
+        finally:
+            _user32.CloseClipboard()
+
+
+def set_clipboard_text(text: str) -> bool:
+    """Replace clipboard contents with UTF-16 text."""
+    utf16 = text.encode("utf-16-le") + b"\x00\x00"
+
+    with _lock:
+        if not _open_clipboard():
+            return False
+
+        try:
+            if not _user32.EmptyClipboard():
+                return False
+
+            handle = _alloc_hglobal(utf16)
+            if not handle:
+                return False
+
+            result = _user32.SetClipboardData(_CF_UNICODETEXT, handle)
+            if not result:
+                _kernel32.GlobalFree(handle)
+                return False
+
+            return True
+        finally:
+            _user32.CloseClipboard()

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

@@ -11,6 +11,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
+from paypertranscript.core.atomic_io import atomic_write_text
 from paypertranscript.core.logging import APPDATA_DIR, get_logger
 
 log = get_logger("core.config")
@@ -164,14 +165,14 @@ def _validate_config(config: dict) -> dict:
 
         key = parts[-1]
         if key not in node:
-            # Fehlender Wert → Default einsetzen
+            # Fehlender Wert -> Default einsetzen
             node[key] = copy.deepcopy(default_node[key])
-            log.warning("Config: Fehlender Wert '%s' → Default verwendet", path)
+            log.warning("Config: Fehlender Wert '%s' -> Default verwendet", path)
         elif not isinstance(node[key], expected_type):
             old_val = node[key]
             node[key] = copy.deepcopy(default_node[key])
             log.warning(
-                "Config: Ungültiger Typ für '%s' (%s statt %s) → Default verwendet",
+                "Config: Ungültiger Typ für '%s' (%s statt %s) -> Default verwendet",
                 path,
                 type(old_val).__name__,
                 expected_type,
@@ -204,13 +205,13 @@ class ConfigManager:
             try:
                 raw = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
                 if not isinstance(raw, dict):
-                    log.warning("Config-Datei enthält kein Dict → Defaults verwendet")
+                    log.warning("Config-Datei enthält kein Dict -> Defaults verwendet")
                     raw = {}
             except (json.JSONDecodeError, OSError) as e:
-                log.warning("Config-Datei konnte nicht gelesen werden: %s → Defaults verwendet", e)
+                log.warning("Config-Datei konnte nicht gelesen werden: %s -> Defaults verwendet", e)
                 raw = {}
         else:
-            log.info("Keine Config-Datei gefunden → Defaults werden verwendet")
+            log.info("Keine Config-Datei gefunden -> Defaults werden verwendet")
             raw = {}
 
         merged = _deep_merge(DEFAULT_CONFIG, raw)
@@ -221,7 +222,8 @@ class ConfigManager:
         """Speichert aktuelle Config in Datei."""
         _ensure_dirs()
         try:
-            CONFIG_FILE.write_text(
+            atomic_write_text(
+                CONFIG_FILE,
                 json.dumps(self._config, indent=2, ensure_ascii=False),
                 encoding="utf-8",
             )
@@ -258,7 +260,7 @@ class ConfigManager:
             path: Punkt-separierter Pfad (z.B. 'general.language').
             value: Neuer Wert.
         """
-        # Aktuellen Stand von Disk lesen (falls von außen geändert)
+        # Aktuellen Stand von Disk lesen (falls von aussen geändert)
         if CONFIG_FILE.exists():
             try:
                 disk_config = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))

{paypertranscript-0.3.1 → paypertranscript-0.3.2}/paypertranscript/core/context_detector.py

@@ -14,8 +14,14 @@ import time
 from concurrent.futures import Future
 
 import pyautogui
-import pyperclip
 
+from paypertranscript.core.clipboard_manager import (
+    ClipboardSnapshot,
+    get_clipboard_text,
+    restore_clipboard,
+    set_clipboard_text,
+    snapshot_clipboard,
+)
 from paypertranscript.core.config import ConfigManager
 from paypertranscript.core.logging import get_logger
 from paypertranscript.core.window_detector import WindowInfo
@@ -58,10 +64,10 @@ def detect_selected_text(
 
     Ablauf:
     1. Feature-Flag und Terminal-Blocklist pruefen
-    2. Clipboard sichern → Sentinel setzen → Ctrl+C → Clipboard lesen → wiederherstellen
+    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.
+    Gibt in ALLEN Fehler-/Abbruch-Faellen "" zurueck - wirft nie Exceptions.
     Die Pipeline wird dadurch nie blockiert oder gestoert.
 
     Args:
@@ -108,17 +114,12 @@ def detect_selected_text(
             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))
+        original_clipboard = snapshot_clipboard()
+        log.debug("Clipboard snapshot captured (%d formats)", len(original_clipboard.formats))
 
         # 5. Sentinel auf Clipboard setzen
-        try:
-            pyperclip.copy(_SENTINEL)
-        except Exception as e:
-            log.warning("Context detection: clipboard write failed: %s", e)
+        if not set_clipboard_text(_SENTINEL):
+            log.warning("Context detection: clipboard write failed")
             return ""
         log.debug("Sentinel placed on clipboard")
 
@@ -129,7 +130,7 @@ def detect_selected_text(
             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)
+        #    User haelt noch Ctrl+Alt -> Ctrl+C wuerde als Ctrl+Alt+C ankommen)
         _wait_for_modifiers_released()
 
         # 8. Ctrl+C senden
@@ -141,12 +142,7 @@ def detect_selected_text(
         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 ""
+        clipboard_content = get_clipboard_text()
 
         t_read = time.perf_counter()
         log.debug(
@@ -156,7 +152,7 @@ def detect_selected_text(
 
         # 11. Auswerten: Hat Ctrl+C den Sentinel ueberschrieben?
         if clipboard_content == _SENTINEL:
-            # Sentinel unveraendert → nichts war markiert
+            # 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)
@@ -197,7 +193,7 @@ def _wait_for_modifiers_released() -> None:
     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.
+    Beim Hold-Hotkey sind die Keys bereits losgelassen -> returned sofort.
     """
     user32 = ctypes.windll.user32
     deadline = time.perf_counter() + _MODIFIER_RELEASE_TIMEOUT_MS / 1000
@@ -207,19 +203,18 @@ def _wait_for_modifiers_released() -> None:
             return
         time.sleep(0.01)  # 10ms polling
 
-    # Timeout: Modifier immer noch gehalten — trotzdem weitermachen
+    # 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:
+def _restore_clipboard(snapshot: ClipboardSnapshot) -> 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)
+    restored = restore_clipboard(snapshot)
+    if not restored and snapshot.formats:
+        log.warning("Context detection: clipboard restore incomplete")
 
 
 def detect_selected_text_async(

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

@@ -1,4 +1,4 @@
-"""Globaler Hotkey-Listener für PayPerTranscript.
+"""Globaler Hotkey-Listener für PayPerTranscript.
 
 Nutzt pynput für systemweite Hotkey-Erkennung.
 Unterstützt Hold-to-Record und Toggle-Modus.
@@ -67,6 +67,9 @@ _ALT_KEYS: set[keyboard.Key] = {keyboard.Key.alt_l, keyboard.Key.alt_r}
 # Verhindert Ghost-Toggles durch synthetische Key-Events (z.B. pyautogui Ctrl+C).
 _TOGGLE_DEBOUNCE_S = 0.5
 
+# Sentinel fuer "nicht aktualisieren" in update_hotkeys.
+_UNSET = object()
+
 
 def _resolve_key(key_str: str) -> keyboard.Key | keyboard.KeyCode:
     """Löst einen Config-String in ein pynput-Key-Objekt auf."""
@@ -287,32 +290,38 @@ class HotkeyListener:
 
     def update_hotkeys(
         self,
-        hold_hotkey: list[str] | None = None,
-        toggle_hotkey: list[str] | None = None,
+        hold_hotkey: list[str] | None | object = _UNSET,
+        toggle_hotkey: list[str] | None | object = _UNSET,
     ) -> None:
         """Aktualisiert die Hotkey-Konfiguration zur Laufzeit."""
         with self._lock:
-            if hold_hotkey is not None:
+            if hold_hotkey is not _UNSET:
                 self._hold_keys = []
                 self._hold_modifier_groups = []
-                for key_str in hold_hotkey:
-                    group = _get_modifier_group(key_str)
-                    if group:
-                        self._hold_modifier_groups.append(group)
-                    self._hold_keys.append(_resolve_key(key_str))
-                log.info("Hold-Hotkey aktualisiert: %s", " + ".join(hold_hotkey))
-
-            if toggle_hotkey is not None:
+                if hold_hotkey:
+                    for key_str in hold_hotkey:
+                        group = _get_modifier_group(key_str)
+                        if group:
+                            self._hold_modifier_groups.append(group)
+                        self._hold_keys.append(_resolve_key(key_str))
+                    log.info("Hold-Hotkey aktualisiert: %s", " + ".join(hold_hotkey))
+                else:
+                    log.info("Hold-Hotkey deaktiviert")
+
+            if toggle_hotkey is not _UNSET:
                 self._toggle_keys = []
                 self._toggle_modifier_groups = []
-                for key_str in toggle_hotkey:
-                    group = _get_modifier_group(key_str)
-                    if group:
-                        self._toggle_modifier_groups.append(group)
-                    self._toggle_keys.append(_resolve_key(key_str))
-                log.info("Toggle-Hotkey aktualisiert: %s", " + ".join(toggle_hotkey))
-
-            # State zurücksetzen
+                if toggle_hotkey:
+                    for key_str in toggle_hotkey:
+                        group = _get_modifier_group(key_str)
+                        if group:
+                            self._toggle_modifier_groups.append(group)
+                        self._toggle_keys.append(_resolve_key(key_str))
+                    log.info("Toggle-Hotkey aktualisiert: %s", " + ".join(toggle_hotkey))
+                else:
+                    log.info("Toggle-Hotkey deaktiviert")
+
+            # State zuruecksetzen
             self._hold_active = False
             self._toggle_combo_held = False
             self._toggle_last_fired = 0.0

{paypertranscript-0.3.1 → paypertranscript-0.3.2}/paypertranscript/core/recorder.py

@@ -47,10 +47,11 @@ class AudioRecorder:
         """Callback des InputStream - sammelt Frames während der Aufnahme."""
         if status:
             log.warning("Audio-Callback Status: %s", status)
-        if self._is_recording:
-            self._frames.append(indata.copy())
-            # Amplitude berechnen (RMS, normalisiert auf 0-1 für int16)
-            self._amplitude = float(np.sqrt(np.mean(indata.astype(np.float32) ** 2)) / 32768.0)
+        with self._lock:
+            if self._is_recording:
+                self._frames.append(indata.copy())
+                # Amplitude berechnen (RMS, normalisiert auf 0-1 fuer int16)
+                self._amplitude = float(np.sqrt(np.mean(indata.astype(np.float32) ** 2)) / 32768.0)
 
     def start_stream(self) -> None:
         """Erstellt und startet den persistenten Audio-Stream."""
@@ -74,13 +75,13 @@ class AudioRecorder:
             raise
 
     def stop_stream(self) -> None:
-        """Stoppt und schließt den persistenten Audio-Stream."""
+        """Stoppt und schliesst den persistenten Audio-Stream."""
         if self._stream is not None:
             try:
                 self._stream.stop()
                 self._stream.close()
             except sd.PortAudioError as e:
-                log.warning("Fehler beim Schließen des Audio-Streams: %s", e)
+                log.warning("Fehler beim Schliessen des Audio-Streams: %s", e)
             self._stream = None
             log.info("Audio-Stream gestoppt")
 
@@ -110,8 +111,8 @@ class AudioRecorder:
 
             self._is_recording = False
             duration = time.perf_counter() - self._start_time
-            frames = self._frames.copy()
-            self._frames.clear()
+            frames = self._frames
+            self._frames = []
             self._amplitude = 0.0
 
         if not frames: