PayPerTranscript 0.2.8__tar.gz → 0.2.9__tar.gz

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

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

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

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

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

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

{paypertranscript-0.2.8 → 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,

{paypertranscript-0.2.8 → 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.8 → 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.8 → 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.8 → 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.8 → 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.8 → 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.8 → 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.8 → paypertranscript-0.2.9}/pyproject.toml

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