PayPerTranscript 0.2.7__tar.gz → 0.2.9__tar.gz

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

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

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

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

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

@@ -14,6 +14,8 @@ paypertranscript/assets/icons/app.png
 paypertranscript/assets/icons/app_big.png
 paypertranscript/assets/icons/arrow_down.svg
 paypertranscript/assets/icons/tray.png
+paypertranscript/assets/icons/tray_green.png
+paypertranscript/assets/icons/tray_orange.png
 paypertranscript/assets/sounds/start.wav
 paypertranscript/assets/sounds/stop.wav
 paypertranscript/assets/styles/dark.qss

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

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

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

@@ -33,6 +33,7 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "provider": "groq",
         "stt_model": "whisper-large-v3-turbo",
         "llm_model": "openai/gpt-oss-20b",
+        "llm_temperature": 1.0,
     },
     "words": {
         "misspelled_words": [],
@@ -87,6 +88,7 @@ _SCHEMA: dict[str, type | tuple[type, ...]] = {
     "api.provider": str,
     "api.stt_model": str,
     "api.llm_model": str,
+    "api.llm_temperature": (int, float),
     "words.misspelled_words": list,
     "formatting.window_mappings": dict,
     "formatting.categories": dict,
@@ -97,11 +99,22 @@ _SCHEMA: dict[str, type | tuple[type, ...]] = {
 }
 
 
+# Keys whose dict values represent user data collections (not config structure).
+# These are replaced entirely by the user's saved value, not recursively merged,
+# so that deletions of default entries persist across restarts.
+_REPLACE_KEYS = frozenset({"window_mappings", "categories"})
+
+
 def _deep_merge(base: dict, override: dict) -> dict:
     """Merge override in base (rekursiv). Gibt neues Dict zurück."""
     result = copy.deepcopy(base)
     for key, value in override.items():
-        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+        if (
+            key in result
+            and isinstance(result[key], dict)
+            and isinstance(value, dict)
+            and key not in _REPLACE_KEYS
+        ):
             result[key] = _deep_merge(result[key], value)
         else:
             result[key] = copy.deepcopy(value)

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/core/cost_tracker.py

@@ -6,12 +6,18 @@ Keine I/O, keine Seiteneffekte - einfach testbar.
 
 from dataclasses import dataclass
 
-# STT/LLM API-Preise (Stand: 2026-02)
+# STT API-Preise (Stand: 2026-02)
 STT_PRICE_PER_HOUR_USD = 0.04
 STT_MIN_BILLED_SECONDS = 10  # API-seitiges Minimum-Billing
 
-LLM_INPUT_PRICE_PER_M_TOKENS = 0.075   # USD per million input tokens
-LLM_OUTPUT_PRICE_PER_M_TOKENS = 0.30   # USD per million output tokens
+# LLM-Preise pro Modell: (Input USD/M Tokens, Output USD/M Tokens)
+LLM_PRICES: dict[str, tuple[float, float]] = {
+    "openai/gpt-oss-20b": (0.075, 0.30),
+    "openai/gpt-oss-120b": (0.15, 0.60),
+    "moonshotai/kimi-k2-instruct-0905": (1.00, 3.00),
+}
+
+_DEFAULT_LLM_PRICES = (0.075, 0.30)  # Fallback
 
 
 @dataclass(frozen=True)
@@ -41,19 +47,22 @@ def calculate_stt_cost(audio_duration_seconds: float) -> tuple[float, float]:
     return billed, cost
 
 
-def calculate_llm_cost(input_tokens: int, output_tokens: int) -> float:
+def calculate_llm_cost(
+    input_tokens: int, output_tokens: int, model: str = "",
+) -> float:
     """Berechnet LLM-Kosten.
 
     Args:
         input_tokens: Anzahl Input-Tokens.
         output_tokens: Anzahl Output-Tokens.
+        model: LLM-Modellname fuer modellspezifische Preise.
 
     Returns:
         Kosten in USD.
     """
+    input_price, output_price = LLM_PRICES.get(model, _DEFAULT_LLM_PRICES)
     return (
-        input_tokens * LLM_INPUT_PRICE_PER_M_TOKENS
-        + output_tokens * LLM_OUTPUT_PRICE_PER_M_TOKENS
+        input_tokens * input_price + output_tokens * output_price
     ) / 1_000_000
 
 
@@ -61,6 +70,7 @@ def calculate_total_cost(
     audio_duration_seconds: float,
     llm_input_tokens: int = 0,
     llm_output_tokens: int = 0,
+    llm_model: str = "",
 ) -> CostResult:
     """Berechnet Gesamtkosten einer Transkription.
 
@@ -68,12 +78,13 @@ def calculate_total_cost(
         audio_duration_seconds: Audio-Dauer in Sekunden.
         llm_input_tokens: LLM Input-Tokens (0 wenn kein LLM).
         llm_output_tokens: LLM Output-Tokens (0 wenn kein LLM).
+        llm_model: LLM-Modellname fuer modellspezifische Preise.
 
     Returns:
         CostResult mit allen Kosten-Details.
     """
     billed, stt_cost = calculate_stt_cost(audio_duration_seconds)
-    llm_cost = calculate_llm_cost(llm_input_tokens, llm_output_tokens)
+    llm_cost = calculate_llm_cost(llm_input_tokens, llm_output_tokens, llm_model)
     return CostResult(
         audio_duration_seconds=audio_duration_seconds,
         billed_seconds=billed,

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

@@ -165,6 +165,7 @@ class TranscriptionPipeline:
             audio_duration_seconds=audio_duration,
             llm_input_tokens=llm_input_tokens,
             llm_output_tokens=llm_output_tokens,
+            llm_model=self._config.get("api.llm_model", ""),
         )
 
         session_data = {

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/providers/groq_provider.py

@@ -87,14 +87,16 @@ class GroqLLMProvider(AbstractLLMProvider):
         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)", self._model)
+        log.info("GroqLLMProvider initialisiert (Modell: %s, Temperature: %s)", self._model, self._temperature)
 
     @property
     def last_usage(self) -> dict[str, int] | None:
@@ -106,17 +108,25 @@ class GroqLLMProvider(AbstractLLMProvider):
     ) -> list[dict[str, str]]:
         return [
             {"role": "system", "content": system_prompt},
-            {"role": "user", "content": text},
+            {"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)", self._model)
+        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
@@ -142,13 +152,14 @@ class GroqLLMProvider(AbstractLLMProvider):
         return result
 
     def format_text_stream(self, system_prompt: str, text: str) -> Iterator[str]:
-        log.info("LLM-Anfrage (streaming, Modell: %s)", self._model)
+        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

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

@@ -241,6 +241,7 @@ class PayPerTranscriptApp:
                 config.get("api.provider", "groq"),
                 model=config.get("api.llm_model", "openai/gpt-oss-20b"),
                 api_key=api_key,
+                temperature=config.get("api.llm_temperature"),
             )
         except ProviderError as e:
             log.warning(

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/constants.py

@@ -46,4 +46,13 @@ STT_MODELS: list[str] = [
 # LLM-Modelle
 LLM_MODELS: list[str] = [
     "openai/gpt-oss-20b",
+    "openai/gpt-oss-120b",
+    "moonshotai/kimi-k2-instruct-0905",
 ]
+
+# LLM-Modell-Metadaten: (Standard-Temperature, Empfohlene Temperature)
+LLM_MODEL_DEFAULTS: dict[str, tuple[float, float]] = {
+    "openai/gpt-oss-20b": (1.0, 0.6),
+    "openai/gpt-oss-120b": (1.0, 0.6),
+    "moonshotai/kimi-k2-instruct-0905": (0.6, 0.4),
+}

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/main_window.py

@@ -16,10 +16,6 @@ from paypertranscript.core.logging import get_logger
 from paypertranscript.core.paths import get_icons_dir
 from paypertranscript.core.session_logger import SessionLogger
 from paypertranscript.ui.pages.home_page import HomePage
-from paypertranscript.ui.pages.settings_page import SettingsPage
-from paypertranscript.ui.pages.statistics_page import StatisticsPage
-from paypertranscript.ui.pages.window_mapping_page import WindowMappingPage
-from paypertranscript.ui.pages.word_list_page import WordListPage
 from paypertranscript.ui.sidebar import Sidebar
 
 log = get_logger("ui.main_window")
@@ -86,29 +82,81 @@ class MainWindow(QDialog):
         self._stack = QStackedWidget()
         self._stack.setStyleSheet("QStackedWidget { background-color: #121218; }")
 
-        # Seiten erstellen (Reihenfolge muss mit Sidebar-Indizes uebereinstimmen)
-        self._home_page = HomePage(config, session_logger, get_last_transcription)
-        self._statistics_page = StatisticsPage(session_logger) if session_logger else QWidget()
-        self._settings_page = SettingsPage(config, hotkey_listener)
-        self._word_list_page = WordListPage(config)
-        self._window_mapping_page = WindowMappingPage(config)
+        # Lazy Page Loading: Nur HomePage sofort erstellen, Rest on-demand.
+        self._pages: dict[int, QWidget] = {}
+        self._page_factories: dict[int, Callable[[], QWidget]] = {
+            1: lambda: self._create_statistics_page(session_logger),
+            2: lambda: self._create_settings_page(config, hotkey_listener),
+            3: lambda: self._create_word_list_page(config),
+            4: lambda: self._create_window_mapping_page(config),
+        }
 
-        self._stack.addWidget(self._home_page)         # 0
-        self._stack.addWidget(self._statistics_page)    # 1
-        self._stack.addWidget(self._settings_page)      # 2
-        self._stack.addWidget(self._word_list_page)     # 3
-        self._stack.addWidget(self._window_mapping_page)  # 4
+        # HomePage (Index 0) sofort — wird bei jedem Oeffnen angezeigt
+        home = HomePage(config, session_logger, get_last_transcription)
+        self._pages[0] = home
+        self._stack.addWidget(home)  # 0
+
+        # Placeholders fuer restliche Seiten
+        for _ in range(1, 5):
+            self._stack.addWidget(QWidget())
 
         layout.addWidget(self._stack, 1)
 
+    # -- Lazy Page Factories --
+
+    @staticmethod
+    def _create_statistics_page(session_logger: SessionLogger | None) -> QWidget:
+        from paypertranscript.ui.pages.statistics_page import StatisticsPage
+
+        return StatisticsPage(session_logger) if session_logger else QWidget()
+
+    @staticmethod
+    def _create_settings_page(
+        config: ConfigManager, hotkey_listener: HotkeyListener | None
+    ) -> QWidget:
+        from paypertranscript.ui.pages.settings_page import SettingsPage
+
+        return SettingsPage(config, hotkey_listener)
+
+    @staticmethod
+    def _create_word_list_page(config: ConfigManager) -> QWidget:
+        from paypertranscript.ui.pages.word_list_page import WordListPage
+
+        return WordListPage(config)
+
+    @staticmethod
+    def _create_window_mapping_page(config: ConfigManager) -> QWidget:
+        from paypertranscript.ui.pages.window_mapping_page import WindowMappingPage
+
+        return WindowMappingPage(config)
+
+    def _ensure_page(self, index: int) -> None:
+        """Erstellt die Seite beim ersten Zugriff (lazy loading)."""
+        if index in self._pages:
+            return
+        factory = self._page_factories.pop(index, None)
+        if factory is None:
+            return
+        page = factory()
+        self._pages[index] = page
+        old = self._stack.widget(index)
+        self._stack.removeWidget(old)
+        self._stack.insertWidget(index, page)
+        old.deleteLater()
+        log.debug("Seite %d lazy erstellt: %s", index, type(page).__name__)
+
+    # -- Navigation --
+
     def _on_page_changed(self, index: int) -> None:
-        """Wechselt zur angeforderten Seite."""
+        """Wechselt zur angeforderten Seite (lazy creation bei Erstaufruf)."""
+        self._ensure_page(index)
         self._stack.setCurrentIndex(index)
         self._sidebar.set_active(index)
 
     def navigate_to(self, page_index: int) -> None:
         """Navigiert zu einer bestimmten Seite und zeigt das Fenster."""
         if 0 <= page_index < self._stack.count():
+            self._ensure_page(page_index)
             self._stack.setCurrentIndex(page_index)
             self._sidebar.set_active(page_index)
         self.show()

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/pages/home_page.py

@@ -209,8 +209,8 @@ class HomePage(QWidget):
         self._hotkey_value.setText("  ·  ".join(parts))
 
         # -- Modelle --
-        stt_model = self._config.get("stt.model", "whisper-large-v3-turbo")
-        llm_model = self._config.get("llm.model", "openai/gpt-oss-20b")
+        stt_model = self._config.get("api.stt_model", "whisper-large-v3-turbo")
+        llm_model = self._config.get("api.llm_model", "openai/gpt-oss-20b")
         self._model_value.setText(f"STT: {stt_model}  ·  LLM: {llm_model}")
 
         # -- Sprache + API-Status --

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/pages/settings_page.py

@@ -18,6 +18,7 @@ from PySide6.QtWidgets import (
     QPushButton,
     QRadioButton,
     QScrollArea,
+    QSlider,
     QSpinBox,
     QVBoxLayout,
     QWidget,
@@ -29,6 +30,7 @@ from paypertranscript.core.logging import get_logger
 from paypertranscript.ui.constants import (
     HOLD_PRESETS,
     LANGUAGES,
+    LLM_MODEL_DEFAULTS,
     LLM_MODELS,
     STT_MODELS,
     TOGGLE_PRESETS,
@@ -221,6 +223,34 @@ class SettingsPage(QWidget):
         self._llm_combo.currentTextChanged.connect(self._on_llm_model_changed)
         api_layout.addWidget(self._llm_combo)
 
+        api_layout.addSpacing(8)
+
+        # Temperature
+        temp_header = QHBoxLayout()
+        temp_label = QLabel("LLM Temperature:")
+        temp_header.addWidget(temp_label)
+        temp_header.addStretch()
+        self._temp_value_label = QLabel("Standard")
+        self._temp_value_label.setProperty("subheading", True)
+        temp_header.addWidget(self._temp_value_label)
+        api_layout.addLayout(temp_header)
+
+        self._temp_slider = QSlider(Qt.Orientation.Horizontal)
+        self._temp_slider.setRange(0, 20)  # 0..20 → 0.0..2.0 in 0.1-Schritten
+        self._temp_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self._temp_slider.setTickInterval(2)
+        self._temp_slider.setSingleStep(1)
+        self._temp_slider.setPageStep(2)
+        self._temp_slider.valueChanged.connect(self._on_temperature_changed)
+        api_layout.addWidget(self._temp_slider)
+
+        self._temp_hint = QLabel("")
+        self._temp_hint.setProperty("subheading", True)
+        self._temp_hint.setWordWrap(True)
+        api_layout.addWidget(self._temp_hint)
+
+        api_layout.addSpacing(4)
+
         hint = QLabel("Modell-\u00c4nderungen werden nach Neustart wirksam.")
         hint.setProperty("subheading", True)
         api_layout.addWidget(hint)
@@ -337,6 +367,17 @@ class SettingsPage(QWidget):
         if idx >= 0:
             self._llm_combo.setCurrentIndex(idx)
 
+        llm_temp = self._config.get("api.llm_temperature", 1.0)
+        # Fallback fuer alte Configs mit None
+        if llm_temp is None:
+            model = self._llm_combo.currentText()
+            llm_temp = LLM_MODEL_DEFAULTS.get(model, (1.0, 1.0))[0]
+        slider_val = round(float(llm_temp) * 10)
+        self._temp_slider.setValue(max(0, min(20, slider_val)))
+        self._temp_value_label.setText(f"{llm_temp:.1f}")
+
+        self._update_temp_hint()
+
         self._retention_spin.setValue(self._config.get("data.audio_retention_hours", 24))
         self._chk_transcripts.setChecked(self._config.get("data.save_transcripts", False))
 
@@ -485,6 +526,35 @@ class SettingsPage(QWidget):
         if self._updating:
             return
         self._config.set("api.llm_model", text)
+        # Slider auf den Standard-Wert des neuen Modells setzen
+        default_temp = LLM_MODEL_DEFAULTS.get(text, (1.0, 1.0))[0]
+        self._updating = True
+        slider_val = round(default_temp * 10)
+        self._temp_slider.setValue(max(0, min(20, slider_val)))
+        self._temp_value_label.setText(f"{default_temp:.1f}")
+        self._updating = False
+        self._config.set("api.llm_temperature", default_temp)
+        self._update_temp_hint()
+
+    def _on_temperature_changed(self, value: int) -> None:
+        if self._updating:
+            return
+        temp = value / 10.0
+        self._temp_value_label.setText(f"{temp:.1f}")
+        self._config.set("api.llm_temperature", temp)
+
+    def _update_temp_hint(self) -> None:
+        """Zeigt modellspezifischen Temperature-Hinweis."""
+        model = self._llm_combo.currentText()
+        meta = LLM_MODEL_DEFAULTS.get(model)
+        if meta:
+            default_temp, recommended_temp = meta
+            self._temp_hint.setText(
+                f"Standard: {default_temp:.1f} | Empfohlen: {recommended_temp:.1f}"
+            )
+            self._temp_hint.setVisible(True)
+        else:
+            self._temp_hint.setVisible(False)
 
     # -- Callbacks: Daten & Updates --
 

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/pages/window_mapping_page.py

@@ -166,30 +166,18 @@ class _MappingItemDelegate(QStyledItemDelegate):
         option: QStyleOptionViewItem,
         index: QModelIndex,
     ) -> bool:
-        if event.type() in (QEvent.Type.MouseMove, QEvent.Type.MouseButtonRelease):
+        # Click handling is done via viewport event filter in WindowMappingPage
+        # (editorEvent does not receive MouseButtonRelease with default edit triggers)
+        if event.type() == QEvent.Type.MouseMove:
             mouse: QMouseEvent = event  # type: ignore[assignment]
-            x = mouse.position().x()
-            delete_left = option.rect.right() - self._ICON_SIZE
-            edit_left = option.rect.right() - self._ICONS_TOTAL
-            over_icon = x >= edit_left
-
-            if event.type() == QEvent.Type.MouseMove:
-                view = option.widget
-                if view is not None:
-                    if over_icon:
-                        view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-                    else:
-                        view.unsetCursor()
-                return False
-
-            # MouseButtonRelease
-            if x >= delete_left:
-                self._on_delete(index.row())
-                return True
-            if x >= edit_left:
-                self._on_edit(index.row())
-                return True
-
+            over_icon = mouse.position().x() >= option.rect.right() - self._ICONS_TOTAL
+            view = option.widget
+            if view is not None:
+                if over_icon:
+                    view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+                else:
+                    view.unsetCursor()
+            return False
         return super().editorEvent(event, model, option, index)
 
     def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
@@ -263,24 +251,17 @@ class _CategoryItemDelegate(QStyledItemDelegate):
         option: QStyleOptionViewItem,
         index: QModelIndex,
     ) -> bool:
-        if event.type() in (QEvent.Type.MouseMove, QEvent.Type.MouseButtonRelease):
+        # Click handling is done via viewport event filter in WindowMappingPage
+        if event.type() == QEvent.Type.MouseMove:
             mouse: QMouseEvent = event  # type: ignore[assignment]
             over_icon = mouse.position().x() >= option.rect.right() - self._ICON_SIZE
-
-            if event.type() == QEvent.Type.MouseMove:
-                view = option.widget
-                if view is not None:
-                    if over_icon:
-                        view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-                    else:
-                        view.unsetCursor()
-                return False
-
-            # MouseButtonRelease
-            if over_icon:
-                self._on_delete(index.row())
-                return True
-
+            view = option.widget
+            if view is not None:
+                if over_icon:
+                    view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+                else:
+                    view.unsetCursor()
+            return False
         return super().editorEvent(event, model, option, index)
 
     def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
@@ -321,6 +302,11 @@ class WindowMappingPage(QWidget):
         self._tabs.addTab(self._create_categories_tab(), "Kategorien")
         layout.addWidget(self._tabs, 1)
 
+        # Viewport event filters for reliable icon click handling
+        # (editorEvent does not receive MouseButtonRelease with default edit triggers)
+        self._mapping_list.viewport().installEventFilter(self)
+        self._cat_list.viewport().installEventFilter(self)
+
     # -- Tab: Zuordnungen --
 
     def _create_mappings_tab(self) -> QWidget:
@@ -438,6 +424,46 @@ class WindowMappingPage(QWidget):
 
         return tab
 
+    # -- Viewport event filter: icon clicks --
+
+    def eventFilter(self, watched: object, event: QEvent) -> bool:
+        """Intercept mouse clicks on delegate icons (edit/delete)."""
+        if event.type() == QEvent.Type.MouseButtonRelease:
+            mouse: QMouseEvent = event  # type: ignore[assignment]
+            if watched is self._mapping_list.viewport():
+                return self._handle_mapping_icon_click(mouse)
+            if watched is self._cat_list.viewport():
+                return self._handle_category_icon_click(mouse)
+        return super().eventFilter(watched, event)
+
+    def _handle_mapping_icon_click(self, event: QMouseEvent) -> bool:
+        pos = event.position().toPoint()
+        index = self._mapping_list.indexAt(pos)
+        if not index.isValid():
+            return False
+        rect = self._mapping_list.visualRect(index)
+        x = event.position().x()
+        delete_left = rect.right() - _MappingItemDelegate._ICON_SIZE
+        edit_left = rect.right() - _MappingItemDelegate._ICONS_TOTAL
+        if x >= delete_left:
+            self._remove_mapping_at(index.row())
+            return True
+        if x >= edit_left:
+            self._edit_mapping_at(index.row())
+            return True
+        return False
+
+    def _handle_category_icon_click(self, event: QMouseEvent) -> bool:
+        pos = event.position().toPoint()
+        index = self._cat_list.indexAt(pos)
+        if not index.isValid():
+            return False
+        rect = self._cat_list.visualRect(index)
+        if event.position().x() >= rect.right() - _CategoryItemDelegate._ICON_SIZE:
+            self._delete_category_at(index.row())
+            return True
+        return False
+
     # -- Daten laden --
 
     def _reload_all(self) -> None:

{paypertranscript-0.2.7 → paypertranscript-0.2.9}/paypertranscript/ui/pages/word_list_page.py

@@ -110,27 +110,17 @@ class _WordItemDelegate(QStyledItemDelegate):
         option: QStyleOptionViewItem,
         index: QModelIndex,
     ) -> bool:
-        """Start editing when the edit icon area is clicked."""
-        if event.type() in (QEvent.Type.MouseMove, QEvent.Type.MouseButtonRelease):
+        """Cursor change on hover; click handling via viewport event filter."""
+        if event.type() == QEvent.Type.MouseMove:
             mouse: QMouseEvent = event  # type: ignore[assignment]
-            edit_left = option.rect.right() - self._EDIT_WIDTH
-            over_icon = mouse.position().x() >= edit_left
-
-            if event.type() == QEvent.Type.MouseMove:
-                view = option.widget
-                if view is not None:
-                    if over_icon:
-                        view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
-                    else:
-                        view.unsetCursor()
-                return False
-
-            # MouseButtonRelease
-            if over_icon:
-                view = option.widget
-                if view is not None:
-                    view.edit(index)
-                return True
+            over_icon = mouse.position().x() >= option.rect.right() - self._EDIT_WIDTH
+            view = option.widget
+            if view is not None:
+                if over_icon:
+                    view.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+                else:
+                    view.unsetCursor()
+            return False
         return super().editorEvent(event, model, option, index)
 
     def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
@@ -200,6 +190,9 @@ class WordListPage(QWidget):
         self._list.itemChanged.connect(self._on_word_edited)
         layout.addWidget(self._list, 1)
 
+        # Viewport event filter for reliable edit icon click handling
+        self._list.viewport().installEventFilter(self)
+
         # Entfernen + Token-Counter
         action_row = QHBoxLayout()
         btn_remove = QPushButton("Entfernen")
@@ -213,6 +206,22 @@ class WordListPage(QWidget):
         action_row.addWidget(self._counter_label)
         layout.addLayout(action_row)
 
+    def eventFilter(self, watched: object, event: QEvent) -> bool:
+        """Intercept mouse clicks on the edit (pencil) icon."""
+        if (
+            event.type() == QEvent.Type.MouseButtonRelease
+            and watched is self._list.viewport()
+        ):
+            mouse: QMouseEvent = event  # type: ignore[assignment]
+            pos = mouse.position().toPoint()
+            index = self._list.indexAt(pos)
+            if index.isValid():
+                rect = self._list.visualRect(index)
+                if mouse.position().x() >= rect.right() - _WordItemDelegate._EDIT_WIDTH:
+                    self._list.edit(index)
+                    return True
+        return super().eventFilter(watched, event)
+
     def _load_words(self) -> None:
         self._updating = True
         words = self._config.get("words.misspelled_words", [])

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

@@ -5,8 +5,8 @@ QSystemTrayIcon mit Kontextmenue und Icon-Zustandswechsel.
 
 from collections.abc import Callable
 
-from PySide6.QtCore import QRectF, Qt, Slot
-from PySide6.QtGui import QColor, QIcon, QPainter, QPen, QPixmap
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtGui import QIcon, QPixmap
 from PySide6.QtWidgets import (
     QHBoxLayout,
     QLabel,
@@ -27,84 +27,39 @@ from paypertranscript.core.session_logger import SessionLogger
 
 log = get_logger("ui.tray")
 
-# Status-Dot Farben (konsistent mit Overlay-Design)
-_DOT_RECORDING = "#f87171"  # Rot (universelle Aufnahme-Konvention)
-_DOT_PROCESSING = "#34d399"  # Emerald (aktive Verarbeitung)
+# Icon-Dateinamen fuer die drei Zustaende
+_ICON_FILES: dict[str, str] = {
+    "idle": "tray.png",
+    "recording": "tray_orange.png",
+    "processing": "tray_green.png",
+}
 
-# Dot-Groesse relativ zum Icon
-_DOT_RADIUS_RATIO = 0.30  # 30% der Icon-Groesse (~60% Durchmesser)
-_DOT_BORDER_RATIO = 0.04  # Dunkler Rand um den Dot
 
+def _load_icon(filename: str, size: int = 64) -> QIcon:
+    """Laedt ein Tray-Icon aus den Assets.
 
-def _load_base_pixmap(size: int = 64) -> QPixmap:
-    """Laedt das Basis-Logo fuer das Tray-Icon.
-
-    Sucht nach tray.png in den Assets. Fallback: weisser Kreis.
+    Args:
+        filename: Dateiname im icons-Ordner.
+        size: Zielgroesse in Pixeln.
     """
-    tray_path = get_icons_dir() / "tray.png"
-    if tray_path.exists():
-        source = QPixmap(str(tray_path))
-        if not source.isNull():
-            return source.scaled(
+    path = get_icons_dir() / filename
+    if path.exists():
+        pixmap = QPixmap(str(path))
+        if not pixmap.isNull():
+            scaled = pixmap.scaled(
                 size, size,
                 Qt.AspectRatioMode.KeepAspectRatio,
                 Qt.TransformationMode.SmoothTransformation,
             )
+            return QIcon(scaled)
 
-    # Fallback: weisser Kreis (wie bisher)
-    pixmap = QPixmap(size, size)
-    pixmap.fill(QColor(0, 0, 0, 0))
-    painter = QPainter(pixmap)
-    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-    painter.setBrush(QColor("#ffffff"))
-    painter.setPen(QColor(0, 0, 0, 0))
-    painter.drawEllipse(4, 4, size - 8, size - 8)
-    painter.end()
-    return pixmap
-
-
-def _create_icon_with_dot(base: QPixmap, dot_color: str | None = None) -> QIcon:
-    """Erstellt ein Tray-Icon aus dem Basis-Logo, optional mit Status-Dot.
-
-    Args:
-        base: Basis-Pixmap (Logo).
-        dot_color: Hex-Farbe fuer den Status-Dot. None = kein Dot (idle).
-    """
-    pixmap = base.copy()
-
-    if dot_color is not None:
-        size = pixmap.width()
-        dot_r = size * _DOT_RADIUS_RATIO
-        border_w = max(1.0, size * _DOT_BORDER_RATIO)
-
-        # Position: unten rechts mit kleinem Abstand zum Rand
-        cx = size - dot_r - border_w - 1
-        cy = size - dot_r - border_w - 1
-
-        painter = QPainter(pixmap)
-        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
-
-        # Dunkler Rand (hebt den Dot vom Logo ab)
-        painter.setPen(QPen(QColor(18, 18, 24, 200), border_w))
-        painter.setBrush(QColor(dot_color))
-        painter.drawEllipse(QRectF(cx - dot_r, cy - dot_r, dot_r * 2, dot_r * 2))
-
-        painter.end()
-
-    return QIcon(pixmap)
+    log.warning("Tray-Icon nicht gefunden: %s", path)
+    return QIcon()
 
 
 def create_tray_icons() -> dict[str, QIcon]:
-    """Erstellt alle Tray-Icons (idle, recording, processing).
-
-    Idle: Logo pur. Recording: Logo + Emerald-Dot. Processing: Logo + Grau-Dot.
-    """
-    base = _load_base_pixmap(64)
-    return {
-        "idle": _create_icon_with_dot(base),
-        "recording": _create_icon_with_dot(base, _DOT_RECORDING),
-        "processing": _create_icon_with_dot(base, _DOT_PROCESSING),
-    }
+    """Laedt alle Tray-Icons (idle, recording, processing) aus PNG-Dateien."""
+    return {state: _load_icon(fname) for state, fname in _ICON_FILES.items()}
 
 
 # ---------------------------------------------------------------------------

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

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