supervoxtral 0.1.3__tar.gz → 0.1.5__tar.gz

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/AGENTS.md

@@ -13,7 +13,7 @@ supervoxtral/
 │   │   ├── audio.py               # Recording, ffmpeg detection/conversion
 │   │   ├── config.py              # Structured Config dataclasses, loading, resolution, logging setup
 │   │   ├── pipeline.py            # Centralized RecordingPipeline for CLI/GUI unification
-│   │   ├── prompt.py              # Prompt resolution (via Config)
+│   │   ├── prompt.py              # Prompt resolution (supports multiple prompts via Config dict, key-based)
 │   │   └── storage.py             # Save transcripts and raw JSON (conditional on keep_transcript_files)
 │   ├── providers/                 # API integrations
 │   │   ├── __init__.py            # Provider registry (get_provider with Config support)
@@ -33,10 +33,10 @@ supervoxtral/
 ## Typical Execution Flow
 
 - **Entry**: `svx/cli.py` Typer `record` command parses args (e.g., --prompt, --save-all, --gui, --transcribe).
-- **Config & Prompt**: Load `Config` via `Config.load()` (`core/config.py`); if transcribe_mode, skip prompt resolution; else resolve prompt with `cfg.resolve_prompt()` (`core/prompt.py`).
-- **Pipeline**: Run `RecordingPipeline` (`core/pipeline.py`): record WAV/stop (`core/audio.py`), optional conversion (ffmpeg), get provider/init (`providers/__init__.py`, e.g., `mistral.py` from `cfg`); if transcribe_mode (CLI only): no prompt, model override to voxtral-mini-latest (with warning if changed), pass transcribe_mode to provider.transcribe; for GUI: --transcribe ignored (warning), recording starts immediately, uses modular record()/process()/clean() with dynamic mode (Transcribe: no prompt, model override; Prompt: resolved prompt); transcribe, conditional save (`core/storage.py` based on `keep_*`/`save_all`), clipboard copy, logging setup.
+- **Config & Prompt**: Load `Config` via `Config.load()` (`core/config.py`); supports dict of prompts in config.toml (e.g., [prompt.default], [prompt.other]); if transcribe_mode, skip prompt resolution; else resolve prompt with `cfg.resolve_prompt(key="default" for CLI, or selected key for GUI)` (`core/prompt.py`).
+- **Pipeline**: Run `RecordingPipeline` (`core/pipeline.py`): record WAV/stop (`core/audio.py`), optional conversion (ffmpeg), get provider/init (`providers/__init__.py`, e.g., `mistral.py` from `cfg`); if transcribe_mode (CLI only): no prompt, model override to voxtral-mini-latest (with warning if changed), pass transcribe_mode to provider.transcribe; for GUI: --transcribe ignored (warning), recording starts immediately, uses modular record()/process()/clean() with dynamic mode (Transcribe: no prompt, model override; Prompt key: resolved prompt for selected key); transcribe, conditional save (`core/storage.py` based on `keep_*`/`save_all`), clipboard copy, logging setup.
 - **Cleanup**: Temp files auto-deleted (tempfile) if `keep_*=false`; dirs created only if persistence enabled.
-- **End**: Return `{"text": str, "raw": dict, "duration": float, "paths": dict}`; CLI prints result, GUI emits progress/updates via callback (buttons: 'Transcribe' for stop/transcribe without prompt; 'Prompt' for stop/use resolved prompt; default 'Prompt' on Esc/close).
+- **End**: Return `{"text": str, "raw": dict, "duration": float, "paths": dict}`; CLI prints result (uses "default" prompt), GUI emits progress/updates via callback (buttons: 'Transcribe' for no prompt; capitalized prompt keys (e.g., 'Default', 'Test') for selected prompt; 'Cancel'; Esc/close cancels).
 
 ## Build & test
 ```bash

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervoxtral
-Version: 0.1.3
+Version: 0.1.5
 Summary: CLI/GUI audio recorder and transcription client using Mistral Voxtral (chat with audio and transcription).
 License: MIT
 License-File: LICENSE

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/README.md

@@ -4,7 +4,7 @@
 
 SuperVoxtral is a lightweight Python CLI/GUI utility for recording microphone audio and integrate with Mistral's Voxtral APIs for transcription or audio-enabled chat.
 
-Voxtral models, such as `voxtral-mini-latest` and `voxtral-small-latest`, deliver fast inference times, high transcription accuracy across languages and accents, and minimal API costs. In contrast to OpenAI's Whisper, which performs only standalone transcription, Voxtral supports two modes: pure transcription via a dedicated endpoint (no prompts needed) or chat mode, where audio input combines with text prompts for refined outputs—like error correction or contextual summarization—without invoking a separate LLM.
+Voxtral models, such as `voxtral-mini-latest` and `voxtral-small-latest`, deliver fast inference times, high transcription accuracy across languages and accents, and minimal API costs. Voxtral supports two modes: pure transcription via a dedicated endpoint (no prompts needed) or chat mode, where audio input combines with text prompts for refined outputs—like error correction or contextual summarization—without invoking a separate LLM.
 
 For instance, use a prompt like: "_Transcribe this audio precisely and remove all minor speech hesitations: "um", "uh", "er", "euh", "ben", etc._"
 
@@ -26,6 +26,7 @@ The package is available on PyPI. We recommend using `uv` (a fast Python package
 - For GUI support (includes PySide6):
   ```
   uv tool install "supervoxtral[gui]"
+  # to update: uv tool update "supervoxtral[gui]"
   ```
 
 - For core CLI only functionality:
@@ -84,7 +85,7 @@ To get started quickly with SuperVoxtral:
    ```
 
 3. Launch the GUI: `svx record --gui`
-   This opens the minimal GUI, starts recording immediately; click 'Transcribe' for pure transcription (no prompt) or 'Prompt' for prompted transcription (resolved prompt); --transcribe ignored with warning (results copied to clipboard).
+   This opens the minimal GUI, starts recording immediately; click 'Transcribe' for pure transcription (no prompt) or a button for each configured prompt (e.g., 'Default', 'Mail', 'Translate') for prompted transcription using the selected prompt; --transcribe ignored with warning (results copied to clipboard).
 
 ### macOS Shortcuts Integration
 
@@ -171,13 +172,18 @@ copy = true
 # Log level: "DEBUG" | "INFO" | "WARNING" | "ERROR"
 log_level = "INFO"
 
-[prompt]
+[prompt.default]
 # Default user prompt source:
 # - Option 1: Use a file (recommended)
 file = "~/.config/supervoxtral/prompt/user.md"
 #
 # - Option 2: Inline prompt (less recommended for long text)
 # text = "Please transcribe the audio and provide a concise summary in French."
+
+[prompt.test]
+# Example additional prompt
+# file = "/path/to/another_prompt.md"
+# text = "Summarize the meeting in bullet points."
 ```
 
 **Configuration is centralized via a structured `Config` object loaded from your user configuration file (`config.toml`). CLI arguments override select values (e.g., prompt, log level), but most defaults (provider, model, keep flags) come from `config.toml`. No environment variables are used for API keys or settings.**
@@ -219,14 +225,18 @@ svx record [OPTIONS]
   - Interactive mode: recording starts immediately; click 'Transcribe' (pure transcription, no prompt) or 'Prompt' (with resolved prompt); --transcribe ignored with warning. GUI respects config.toml and CLI flags (e.g., `--gui --save-all`).
 
 **Prompt Resolution Priority** (for non-transcribe mode):
+By default in CLI, uses the 'default' prompt from config.toml [prompt.default]. For overrides:
 1. CLI `--user-prompt` or `--user-prompt-file`
-2. config.toml [prompt] section (text or file)
-3. User prompt file (user.md in config dir)
-4. Fallback: "What's in this audio?"
+2. Specified prompt key (future: via --prompt-key; currently implicit 'default')
+3. config.toml [prompt.default] (text or file)
+4. User prompt file (user.md in config dir)
+5. Fallback: "What's in this audio?"
 
 ## Changelog
 
-- 0.1.3: Minor sytle update
+- 0.1.5: Fix bug on prompt selecting
+- 0.1.4: Support for multiple prompts in config.toml with dynamic GUI buttons for each prompt key
+- 0.1.3: Minor style update
 - 0.1.2: Interactive mode in GUI (choose transcribe / prompt / cancel while recording)
 - 0.1.1: Minor updates to default config and default prompt
 

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "supervoxtral"
-version = "0.1.3"
+version = "0.1.5"
 description = "CLI/GUI audio recorder and transcription client using Mistral Voxtral (chat with audio and transcription)."
 requires-python = ">=3.11"
 license = { text = "MIT" }

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/svx/cli.py

@@ -72,7 +72,7 @@ def config_show() -> None:
     user_prompt_file = cfg.user_prompt_dir / "user.md"
 
     defaults_section = asdict(cfg.defaults)
-    prompt_section = asdict(cfg.prompt)
+    prompt_section = {k: asdict(e) for k, e in cfg.prompt.prompts.items()}
 
     # Resolve prompt source (same logic as record command, but read-only)
     resolved_prompt = cfg.resolve_prompt(None, None)

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/svx/core/config.py

@@ -242,13 +242,15 @@ def init_user_config(force: bool = False, prompt_file: Path | None = None) -> Pa
         "copy = true\n\n"
         '# Log level: "DEBUG" | "INFO" | "WARNING" | "ERROR"\n'
         'log_level = "INFO"\n\n'
-        "[prompt]\n"
+        "[prompt.default]\n"
         "# Default user prompt source:\n"
         "# - Option 1: Use a file (recommended)\n"
         f'file = "{str(prompt_file)}"\n'
         "#\n"
         "# - Option 2: Inline prompt (less recommended for long text)\n"
         '# text = "Please transcribe the audio and provide a concise summary in French."\n'
+        "#\n"
+        "# For multiple prompts in future, add [prompt.other] sections.\n"
     )
 
     if not USER_CONFIG_FILE.exists() or force:
@@ -282,11 +284,16 @@ class DefaultsConfig:
 
 
 @dataclass
-class PromptConfig:
+class PromptEntry:
     text: str | None = None
     file: str | None = None
 
 
+@dataclass
+class PromptConfig:
+    prompts: dict[str, PromptEntry] = field(default_factory=lambda: {"default": PromptEntry()})
+
+
 @dataclass
 class Config:
     providers: dict[str, ProviderConfig] = field(default_factory=dict)
@@ -356,11 +363,39 @@ class Config:
                 providers_data[name] = ProviderConfig(api_key=api_key)
         # Prompt
         prompt_raw = user_config.get("prompt", {})
-        prompt_data = {
-            "text": prompt_raw.get("text") if isinstance(prompt_raw.get("text"), str) else None,
-            "file": prompt_raw.get("file") if isinstance(prompt_raw.get("file"), str) else None,
-        }
-        prompt = PromptConfig(**prompt_data)
+        prompts_data: dict[str, PromptEntry] = {}
+        if isinstance(prompt_raw, dict):
+            if any(k in prompt_raw for k in ["text", "file"]):  # old flat style
+                logging.warning(
+                    "Old [prompt] format detected in %s; "
+                    "please migrate to [prompt.default] manually.",
+                    USER_CONFIG_FILE,
+                )
+                entry = PromptEntry(
+                    text=prompt_raw.get("text")
+                    if isinstance(prompt_raw.get("text"), str)
+                    else None,
+                    file=prompt_raw.get("file")
+                    if isinstance(prompt_raw.get("file"), str)
+                    else None,
+                )
+                prompts_data["default"] = entry
+            else:  # new nested style
+                for key, entry_raw in prompt_raw.items():
+                    if isinstance(entry_raw, dict):
+                        entry = PromptEntry(
+                            text=entry_raw.get("text")
+                            if isinstance(entry_raw.get("text"), str)
+                            else None,
+                            file=entry_raw.get("file")
+                            if isinstance(entry_raw.get("file"), str)
+                            else None,
+                        )
+                        prompts_data[key] = entry
+        # Ensure "default" always exists
+        if "default" not in prompts_data:
+            prompts_data["default"] = PromptEntry()
+        prompt = PromptConfig(prompts=prompts_data)
         data = {
             "defaults": defaults,
             "providers": providers_data,
@@ -376,7 +411,7 @@ class Config:
     def resolve_prompt(self, inline: str | None = None, file_path: Path | None = None) -> str:
         from svx.core.prompt import resolve_user_prompt
 
-        return resolve_user_prompt(self, inline, file_path, self.user_prompt_dir)
+        return resolve_user_prompt(self, inline, file_path, self.user_prompt_dir, key="default")
 
     def get_provider_config(self, name: str) -> dict[str, Any]:
         return asdict(self.providers.get(name, ProviderConfig()))

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/svx/core/pipeline.py

@@ -180,6 +180,8 @@ class RecordingPipeline:
         else:
             self._status("Transcribe mode activated: no prompt used.")
 
+        logging.debug(f"Applied prompt: {final_user_prompt or 'None (transcribe mode)'}")
+
         paths: dict[str, Path | None] = {"wav": wav_path}
 
         # Convert if needed

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/svx/core/prompt.py

@@ -12,9 +12,10 @@ Intended to be small and dependency-light so it can be imported broadly.
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from pathlib import Path
 
-from .config import USER_PROMPT_DIR, Config
+from .config import USER_PROMPT_DIR, Config, PromptEntry
 
 __all__ = [
     "read_text_file",
@@ -68,16 +69,16 @@ def resolve_user_prompt(
     inline: str | None = None,
     file: Path | None = None,
     user_prompt_dir: Path | None = None,
+    key: str | None = None,
 ) -> str:
     """
     Resolve the effective user prompt from multiple sources, by priority:
 
     1) inline text (CLI --user-prompt)
     2) explicit file (CLI --user-prompt-file)
-    3) user config inline text (cfg.prompt.text)
-    4) user config file path (cfg.prompt.file)
-    5) user prompt dir file (user_prompt_dir / 'user.md')
-    6) literal fallback: "What's in this audio?"
+    3) user config prompt for key (cfg.prompt.prompts[key or "default"])
+    4) user prompt dir file (user_prompt_dir / 'user.md')
+    5) literal fallback: "What's in this audio?"
 
     Returns the first non-empty string after stripping.
     """
@@ -94,17 +95,18 @@ def resolve_user_prompt(
             logging.warning("Failed to read user prompt file: %s", p)
             return ""
 
-    def _from_user_cfg() -> str:
+    def _from_user_cfg(key: str) -> str:
         try:
-            cfg_prompt = cfg.prompt
-            cfg_text = cfg_prompt.text
-            if isinstance(cfg_text, str) and cfg_text.strip():
-                return cfg_text.strip()
-            cfg_file = cfg_prompt.file
-            if isinstance(cfg_file, str) and cfg_file.strip():
-                return read_text_file(Path(cfg_file).expanduser()).strip()
+            entry = cfg.prompt.prompts.get(key, PromptEntry())
+            if entry.text and entry.text.strip():
+                return entry.text.strip()
+            if entry.file:
+                file_path = Path(entry.file).expanduser()
+                if not file_path.is_absolute():
+                    file_path = (user_prompt_dir or cfg.user_prompt_dir) / entry.file
+                return read_text_file(file_path).strip()
         except Exception:
-            logging.debug("User config prompt processing failed.", exc_info=True)
+            logging.debug("User config prompt processing failed for key '%s'.", key, exc_info=True)
         return ""
 
     def _from_user_prompt_dir() -> str:
@@ -119,22 +121,46 @@ def resolve_user_prompt(
             )
         return ""
 
-    suppliers = [
-        lambda: _strip(inline),
-        lambda: _read(file),
-        _from_user_cfg,
-        _from_user_prompt_dir,
+    key = key or "default"
+
+    # Suppliers annotated with a name for tracing which one returned the prompt.
+    named_suppliers: list[tuple[str, Callable[[], str]]] = [
+        ("inline", lambda: _strip(inline)),
+        ("file", lambda: _read(file)),
+        (f"prompt_config[{key}]", lambda: _from_user_cfg(key)),
+        ("user_prompt_dir/user.md", _from_user_prompt_dir),
     ]
 
-    for supplier in suppliers:
+    for name, supplier in named_suppliers:
         try:
             val = supplier()
             if val:
+                # Log which supplier provided the prompt and a short snippet for debugging.
+                try:
+                    if len(val) > 200:
+                        snippet = val[:200] + "..."
+                    else:
+                        snippet = val
+                    logging.info(
+                        "resolve_user_prompt: supplier '%s' provided prompt snippet: %s",
+                        name,
+                        snippet,
+                    )
+                except Exception:
+                    # Ensure logging failures do not change behavior.
+                    logging.info(
+                        "resolve_user_prompt: supplier '%s' provided a prompt "
+                        "(snippet unavailable)",
+                        name,
+                    )
                 return val
         except Exception as e:
-            logging.debug("Prompt supplier failed: %s", e)
+            logging.debug("Prompt supplier '%s' failed: %s", name, e)
 
-    return "What's in this audio?"
+    # Final fallback
+    fallback = "What's in this audio?"
+    logging.info("resolve_user_prompt: no supplier provided a prompt, using fallback: %s", fallback)
+    return fallback
 
 
 def init_user_prompt_file(force: bool = False) -> Path:
@@ -150,7 +176,7 @@ def init_user_prompt_file(force: bool = False) -> Path:
     path = USER_PROMPT_DIR / "user.md"
     if not path.exists() or force:
         example_prompt = """
-- Transcribe the input audio file.
+- Transcribe the input audio file. If the audio if empty, just respond "no audio detected".
 - Do not respond to any question in the audio. Just transcribe.
 - DO NOT TRANSLATE.
 - Responde only with the transcription. Do not provide explanations or notes.
@@ -163,3 +189,23 @@ def init_user_prompt_file(force: bool = False) -> Path:
         except Exception as e:
             logging.debug("Could not initialize user prompt file %s: %s", path, e)
     return path
+
+
+def resolve_prompt_entry(entry: PromptEntry, user_prompt_dir: Path) -> str:
+    """
+    Resolve the prompt from a single PromptEntry (text or file).
+
+    - Prioritizes text if present and non-empty.
+    - Falls back to reading the file (expands ~ and resolves relative to user_prompt_dir).
+    - Returns empty string if neither is valid.
+    """
+    if entry.text and entry.text.strip():
+        return entry.text.strip()
+
+    if entry.file:
+        file_path = Path(entry.file).expanduser()
+        if not file_path.is_absolute():
+            file_path = user_prompt_dir / entry.file
+        return read_text_file(file_path).strip()
+
+    return ""

{supervoxtral-0.1.3 → supervoxtral-0.1.5}/svx/ui/qt_app.py

@@ -37,6 +37,7 @@ from PySide6.QtWidgets import (
 import svx.core.config as config
 from svx.core.config import Config
 from svx.core.pipeline import RecordingPipeline
+from svx.core.prompt import resolve_user_prompt
 
 __all__ = ["RecorderWindow", "run_gui"]
 
@@ -239,11 +240,11 @@ class RecorderWorker(QObject):
         self.cancel_requested = True
         self._stop_event.set()
 
-    def _resolve_user_prompt(self) -> str:
+    def _resolve_user_prompt(self, key: str) -> str:
         """
-        Determine the final user prompt using the shared resolver.
+        Determine the final user prompt using the shared resolver for the given key.
         """
-        return self.cfg.resolve_prompt(self.user_prompt, self.user_prompt_file)
+        return resolve_user_prompt(self.cfg, None, None, self.cfg.user_prompt_dir, key=key)
 
     def run(self) -> None:
         """
@@ -272,10 +273,39 @@ class RecorderWorker(QObject):
                 self.canceled.emit()
                 return
             self.status.emit("Processing in progress...")
+            # Wait for user to select mode in the GUI
             while self.mode is None:
                 time.sleep(0.05)
+
+            # Log the selected mode/key for debugging prompt application
+            try:
+                logging.info("RecorderWorker: selected mode/key: %s", self.mode)
+            except Exception:
+                # ensure failures in logging don't break the worker
+                pass
+
             transcribe_mode = self.mode == "transcribe"
-            user_prompt = None if transcribe_mode else self._resolve_user_prompt()
+            if transcribe_mode:
+                user_prompt = None
+            else:
+                # Resolve the user prompt for the selected key and log a short snippet
+                user_prompt = self._resolve_user_prompt(self.mode)
+                try:
+                    if user_prompt:
+                        snippet = (
+                            user_prompt[:200] + "..." if len(user_prompt) > 200 else user_prompt
+                        )
+                    else:
+                        snippet = "<EMPTY>"
+                    logging.info(
+                        "RecorderWorker: resolved prompt snippet for key '%s': %s",
+                        self.mode,
+                        snippet,
+                    )
+                except Exception:
+                    # avoid breaking the flow on logging errors
+                    pass
+
             result = pipeline.process(wav_path, duration, transcribe_mode, user_prompt)
             keep_audio = self.save_all or self.cfg.defaults.keep_audio_files
             pipeline.clean(wav_path, result["paths"], keep_audio)
@@ -310,6 +340,7 @@ class RecorderWindow(QWidget):
         self.user_prompt_file = user_prompt_file
         self.save_all = save_all
         self.outfile_prefix = outfile_prefix
+        self.prompt_keys = sorted(self.cfg.prompt.prompts.keys())
 
         # Background worker (create early for signal connections)
         self._worker = RecorderWorker(
@@ -381,12 +412,17 @@ class RecorderWindow(QWidget):
         button_layout.addStretch()
         self._transcribe_btn = QPushButton("Transcribe")
         self._transcribe_btn.setToolTip("Stop and transcribe without prompt")
-        self._transcribe_btn.clicked.connect(lambda: self._on_button_clicked("transcribe"))
+        self._transcribe_btn.clicked.connect(
+            lambda checked=False, m="transcribe": self._on_mode_selected(m)
+        )
         button_layout.addWidget(self._transcribe_btn)
-        self._prompt_btn = QPushButton("Prompt")
-        self._prompt_btn.setToolTip("Stop and transcribe with prompt")
-        self._prompt_btn.clicked.connect(lambda: self._on_button_clicked("prompt"))
-        button_layout.addWidget(self._prompt_btn)
+        self._prompt_buttons: dict[str, QPushButton] = {}
+        for key in self.prompt_keys:
+            btn = QPushButton(key.capitalize())
+            btn.setToolTip(f"Stop and transcribe with '{key}' prompt")
+            btn.clicked.connect(lambda checked=False, k=key: self._on_mode_selected(k))
+            self._prompt_buttons[key] = btn
+            button_layout.addWidget(btn)
         self._cancel_btn = QPushButton("Cancel")
         self._cancel_btn.setObjectName("cancel_btn")
         self._cancel_btn.setToolTip("Stop recording and quit without processing")
@@ -397,6 +433,8 @@ class RecorderWindow(QWidget):
         button_widget.setLayout(button_layout)
         layout.addWidget(button_widget, 0, Qt.AlignmentFlag.AlignCenter)
 
+        self._action_buttons = [self._transcribe_btn] + list(self._prompt_buttons.values())
+
         # Keyboard shortcut: Esc to stop
         stop_action = QAction(self)
         stop_action.setShortcut(QKeySequence.StandardKey.Cancel)  # Esc
@@ -456,17 +494,17 @@ class RecorderWindow(QWidget):
         self._worker.cancel()
         super().closeEvent(event)
 
-    def _on_button_clicked(self, mode: str) -> None:
-        self._transcribe_btn.setEnabled(False)
-        self._prompt_btn.setEnabled(False)
+    def _on_mode_selected(self, mode: str) -> None:
+        for btn in self._action_buttons:
+            btn.setEnabled(False)
         self._cancel_btn.setEnabled(False)
         self._status_label.setText("Stopping and processing...")
         self._worker.set_mode(mode)
         self._worker.stop()
 
     def _on_cancel_clicked(self) -> None:
-        self._transcribe_btn.setEnabled(False)
-        self._prompt_btn.setEnabled(False)
+        for btn in self._action_buttons:
+            btn.setEnabled(False)
         self._cancel_btn.setEnabled(False)
         self._status_label.setText("Canceling...")
         self._worker.cancel()