revoxx 1.1.0__tar.gz → 1.1.1__tar.gz

{revoxx-1.1.0/revoxx.egg-info → revoxx-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revoxx
-Version: 1.1.0
+Version: 1.1.1
 Summary: Speech recording application for creating high-quality speech datasets
 Author-email: Grammatek ehf <info@grammatek.com>
 Maintainer-email: Grammatek ehf <info@grammatek.com>
@@ -32,7 +32,8 @@ Requires-Dist: sounddevice>=0.5.1
 Requires-Dist: soundfile>=0.12.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: markdown2>2.5.1
-Requires-Dist: tkinterweb>4.4.1
+Provides-Extra: html
+Requires-Dist: tkinterweb>4.4.1; extra == "html"
 Provides-Extra: vad
 Requires-Dist: torch>=2.0.0; extra == "vad"
 Requires-Dist: silero-vad>=5.0; extra == "vad"

{revoxx-1.1.0 → revoxx-1.1.1}/pyproject.toml

@@ -38,10 +38,12 @@ dependencies = [
     "soundfile>=0.12.0",
     "tqdm>=4.65.0",
     "markdown2>2.5.1",  # User guide dependencies
-    "tkinterweb>4.4.1"
 ]
 
 [project.optional-dependencies]
+html = [
+    "tkinterweb>4.4.1"  # Requires Tkhtml - may need manual compilation for Tcl/Tk 9
+]
 vad = [
     "torch>=2.0.0",
     "silero-vad>=5.0",

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/constants.py

@@ -162,7 +162,9 @@ class UIConstants:
     # Playback display
     PLAYBACK_LINE_WIDTH = 2
     PLAYBACK_LINE_ALPHA = 0.8
-    PLAYBACK_UPDATE_MS = 10
+    PLAYBACK_UPDATE_MS = (
+        16  # Target ~60fps (adaptive frame rate adjusts for slower systems)
+    )
     PLAYBACK_INITIAL_CHECK_MS = 50
     PLAYBACK_IDLE_RETRY_MS = 20
     PLAYBACK_WATCHDOG_NEAR_END_RATIO = 0.95
@@ -175,17 +177,24 @@ class UIConstants:
     EDGE_INDICATOR_ALPHA = 0.8
     EDGE_INDICATOR_TIMEOUT_MS = 350
 
+    # Tkinter event types
+    TK_EVENT_BUTTON_PRESS = "4"
+    TK_EVENT_SCROLL_UP = 4  # Linux mouse wheel scroll up
+    TK_EVENT_SCROLL_DOWN = 5  # Linux mouse wheel scroll down
+
     # Selection and marker display
     COLOR_POSITION_MARKER = "#00FFFF"  # Cyan
     COLOR_SELECTION_FILL = (1.0, 1.0, 1.0, 0.15)  # Semi-transparent white (RGBA)
     COLOR_SELECTION_BORDER = "#FFFFFF"  # White
     SELECTION_BORDER_WIDTH = 1
     POSITION_MARKER_WIDTH = 2
+    SELECTION_LINE_OFFSET = 0.5  # spec_frames offset for edge visibility
+    POSITION_MARKER_OFFSET = 1.0  # spec_frames offset for thicker marker
     SELECTION_DRAG_THRESHOLD = 5  # Pixels
     MARKER_HOVER_THRESHOLD = 8  # Pixels - distance for resize cursor activation
 
     # Timing (milliseconds)
-    ANIMATION_UPDATE_MS = 20
+    ANIMATION_UPDATE_MS = 100  # ~10fps (TkAgg + Tcl/Tk 9 needs ~100ms per frame on x86)
     PLAYBACK_CHECK_MS = 50
     PLAYBACK_STOP_DELAY_MS = 50  # Delay after stopping playback
     FOCUS_DELAY_MS = 100

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/dialogs/import_text_dialog.py

@@ -9,6 +9,7 @@ from typing import Optional, List
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 from ...utils.text_importer import TextImporter
+from ...utils.tk_compat import trace_var_write
 from .dialog_utils import setup_dialog_window
 
 
@@ -333,7 +334,7 @@ class ImportTextDialog:
                     validatecommand=vcmd_dist,
                 )
                 spinbox.pack(side=tk.LEFT, padx=(self.PADDING_SMALL, 0))
-                var.trace("w", lambda *args: self._on_distribution_change())
+                trace_var_write(var, lambda *args: self._on_distribution_change())
                 self.emotion_spinboxes.append(spinbox)
 
         # Matplotlib plot

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/dialogs/open_session_dialog.py

@@ -7,6 +7,7 @@ from typing import Optional
 import json
 
 from .dialog_utils import setup_dialog_window
+from revoxx.utils.tk_compat import trace_var_write
 
 
 class OpenSessionDialog:
@@ -92,7 +93,7 @@ class OpenSessionDialog:
         ttk.Label(filter_frame, text="Filter:").pack(side=tk.LEFT, padx=(0, 5))
 
         self.filter_var = tk.StringVar()
-        self.filter_var.trace("w", lambda *args: self._apply_filter())
+        trace_var_write(self.filter_var, lambda *args: self._apply_filter())
         filter_entry = ttk.Entry(filter_frame, textvariable=self.filter_var, width=30)
         filter_entry.pack(side=tk.LEFT, padx=(0, 10))
 

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/dialogs/user_guide_dialog.py

@@ -2,10 +2,19 @@
 
 import tkinter as tk
 from tkinter import ttk
+from tkinter.scrolledtext import ScrolledText
 from pathlib import Path
 import re
 import markdown2
-from tkinterweb import HtmlFrame
+
+# Try to import tkinterweb for HTML rendering, fall back to plain text if unavailable
+# (tkinterweb requires Tkhtml which may not be available for Tcl/Tk 9)
+try:
+    from tkinterweb import HtmlFrame
+
+    TKINTERWEB_AVAILABLE = True
+except (ImportError, Exception):
+    TKINTERWEB_AVAILABLE = False
 
 from .dialog_utils import setup_dialog_window
 
@@ -62,7 +71,26 @@ class UserGuideDialog:
         )
         self.checkbox.pack(side=tk.LEFT)
 
-        self.text_widget = HtmlFrame(main_frame, messages_enabled=False)
+        # Use HtmlFrame if available, otherwise fall back to ScrolledText
+        # Note: HtmlFrame import may succeed but instantiation can fail if Tkhtml
+        # binaries are not available (e.g., on Tcl/Tk 9 without compiled Tkhtml)
+        self.use_html = False
+        if TKINTERWEB_AVAILABLE:
+            try:
+                self.text_widget = HtmlFrame(main_frame, messages_enabled=False)
+                self.use_html = True
+            except Exception:
+                # Tkhtml not available - fall through to ScrolledText fallback
+                pass
+
+        if not self.use_html:
+            self.text_widget = ScrolledText(
+                main_frame,
+                wrap=tk.WORD,
+                font=("Helvetica", 12),
+                padx=20,
+                pady=20,
+            )
         self.text_widget.pack(fill=tk.BOTH, expand=True)
 
         bottom_frame = ttk.Frame(main_frame)
@@ -80,29 +108,100 @@ class UserGuideDialog:
 
         if not guide_path.exists():
             error_msg = f"User Guide not found at: {guide_path}"
-            error_html = (
-                f"<html><body><p style='color: red;'>{error_msg}</p></body></html>"
-            )
-            self.text_widget.load_html(error_html)
+            self._display_error(error_msg)
             raise FileNotFoundError(error_msg)
 
         try:
-            # Read user guide content & convert markdown to HTML
+            # Read user guide content
             with open(guide_path, "r", encoding="utf-8") as f:
                 content = f.read()
 
-            html_body = markdown2.markdown(
-                content, extras=["tables", "fenced-code-blocks", "code-friendly"]
-            )
-
-            html_body = self._remove_links(html_body)
-            html_content = self._wrap_html_with_css(html_body)
-            self.text_widget.load_html(html_content)
+            if self.use_html:
+                # Convert markdown to HTML for HtmlFrame
+                html_body = markdown2.markdown(
+                    content, extras=["tables", "fenced-code-blocks", "code-friendly"]
+                )
+                html_body = self._remove_links(html_body)
+                html_content = self._wrap_html_with_css(html_body)
+                self.text_widget.load_html(html_content)
+            else:
+                # Display as formatted plain text in ScrolledText
+                self._display_markdown_as_text(content)
 
         except Exception as e:
             error_msg = f"Error loading guide: {e}"
-            error_html = f"<html><body><p>{error_msg}</p></body></html>"
+            self._display_error(error_msg)
+
+    def _display_error(self, error_msg: str):
+        """Display an error message in the text widget."""
+        if self.use_html:
+            error_html = (
+                f"<html><body><p style='color: red;'>{error_msg}</p></body></html>"
+            )
             self.text_widget.load_html(error_html)
+        else:
+            self.text_widget.insert(tk.END, f"Error: {error_msg}")
+
+    def _display_markdown_as_text(self, content: str):
+        """Display markdown content as formatted plain text.
+
+        Args:
+            content: Raw markdown content
+        """
+        # Configure text tags for basic formatting
+        self.text_widget.tag_configure("h1", font=("Helvetica", 18, "bold"))
+        self.text_widget.tag_configure("h2", font=("Helvetica", 16, "bold"))
+        self.text_widget.tag_configure("h3", font=("Helvetica", 14, "bold"))
+        self.text_widget.tag_configure(
+            "code", font=("Courier", 11), background="#f0f0f0"
+        )
+        self.text_widget.tag_configure("bold", font=("Helvetica", 12, "bold"))
+
+        # Process markdown line by line
+        lines = content.split("\n")
+        for line in lines:
+            stripped = line.strip()
+
+            if stripped.startswith("### "):
+                self.text_widget.insert(tk.END, stripped[4:] + "\n", "h3")
+            elif stripped.startswith("## "):
+                self.text_widget.insert(tk.END, "\n" + stripped[3:] + "\n", "h2")
+            elif stripped.startswith("# "):
+                self.text_widget.insert(tk.END, stripped[2:] + "\n\n", "h1")
+            elif stripped.startswith("```"):
+                continue  # Skip code fence markers
+            elif stripped.startswith("`") and stripped.endswith("`"):
+                self.text_widget.insert(tk.END, stripped[1:-1] + "\n", "code")
+            elif stripped.startswith("- ") or stripped.startswith("* "):
+                self.text_widget.insert(tk.END, "  • " + stripped[2:] + "\n")
+            elif stripped.startswith("|"):
+                # Simple table handling - just show as text
+                self.text_widget.insert(tk.END, stripped + "\n", "code")
+            else:
+                # Handle inline formatting
+                self._insert_with_inline_formatting(line + "\n")
+
+        self.text_widget.config(state=tk.DISABLED)
+
+    def _insert_with_inline_formatting(self, text: str):
+        """Insert text with basic inline markdown formatting.
+
+        Args:
+            text: Text that may contain inline markdown
+        """
+        # Simple approach: just insert plain text, stripping markdown markers
+        # Remove bold markers
+        text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
+        text = re.sub(r"__([^_]+)__", r"\1", text)
+        # Remove italic markers
+        text = re.sub(r"\*([^*]+)\*", r"\1", text)
+        text = re.sub(r"_([^_]+)_", r"\1", text)
+        # Remove inline code markers
+        text = re.sub(r"`([^`]+)`", r"\1", text)
+        # Remove links, keep text
+        text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
+
+        self.text_widget.insert(tk.END, text)
 
     @staticmethod
     def _remove_links(html: str) -> str:

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/dialogs/utterance_list_base.py

@@ -7,6 +7,7 @@ import re
 from enum import Enum
 
 from .dialog_utils import setup_dialog_window
+from revoxx.utils.tk_compat import trace_var_write
 
 
 class SortDirection(Enum):
@@ -324,7 +325,7 @@ class UtteranceListDialog:
         )
 
         self.search_var = tk.StringVar()
-        self.search_var.trace("w", self._on_search_changed)
+        trace_var_write(self.search_var, self._on_search_changed)
         self.search_entry = ttk.Entry(search_frame, textvariable=self.search_var)
         self.search_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
 

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/spectrogram/controllers/selection_visualizer.py

@@ -200,12 +200,23 @@ class SelectionVisualizer:
                 self._marker_time_text.set_visible(False)
             return
 
-        line.set_xdata([x_pos])
+        # Offset only at absolute edges (time 0.0 or recording end)
+        offset = UIConstants.POSITION_MARKER_OFFSET
+        at_absolute_start = time_seconds <= 0
+        at_absolute_end = time_seconds >= ctx.recording_duration
+        if at_absolute_start:
+            x_pos_draw = x_pos + offset
+        elif at_absolute_end:
+            x_pos_draw = x_pos - offset
+        else:
+            x_pos_draw = x_pos
+
+        line.set_xdata([x_pos_draw])
         line.set_visible(True)
 
         # Update time text below the marker
         if self._marker_time_text:
-            self._marker_time_text.set_position((x_pos, -2))
+            self._marker_time_text.set_position((x_pos_draw, -2))
             self._marker_time_text.set_text(_format_time(time_seconds))
             self._marker_time_text.set_visible(True)
 
@@ -253,14 +264,31 @@ class SelectionVisualizer:
         self._selection_patch.set_height(ctx.n_mels)
         self._selection_patch.set_visible(True)
 
-        # Only show border lines if they are within visible range
-        self._selection_start_line.set_xdata([x_start])
-        start_visible = visible_start <= start_seconds <= visible_end
-        self._selection_start_line.set_visible(start_visible)
+        # Show border lines only if they are within the visible range
+        # Apply offset only at absolute edges (time 0.0 or recording end)
+        offset = UIConstants.SELECTION_LINE_OFFSET
+        start_visible = start_seconds >= visible_start
+        end_visible = end_seconds <= visible_end
+
+        if start_visible:
+            # Offset only if at absolute start (time 0.0)
+            at_absolute_start = start_seconds <= 0
+            x_start_draw = x_start + offset if at_absolute_start else x_start
+            self._selection_start_line.set_xdata([x_start_draw])
+            self._selection_start_line.set_visible(True)
+        else:
+            self._selection_start_line.set_visible(False)
 
-        end_visible = visible_start <= end_seconds <= visible_end
-        self._selection_end_line.set_data([x_end, x_end], [0, ctx.n_mels - 8])
-        self._selection_end_line.set_visible(end_visible)
+        if end_visible:
+            # Offset only if at absolute end (end of recording)
+            at_absolute_end = end_seconds >= ctx.recording_duration
+            x_end_draw = x_end - offset if at_absolute_end else x_end
+            self._selection_end_line.set_data(
+                [x_end_draw, x_end_draw], [0, ctx.n_mels - 8]
+            )
+            self._selection_end_line.set_visible(True)
+        else:
+            self._selection_end_line.set_visible(False)
 
         # Show duration text in horizontal center, vertically near top
         if self._selection_duration_text:
@@ -271,15 +299,22 @@ class SelectionVisualizer:
             self._selection_duration_text.set_visible(True)
 
         # Show time labels at selection boundaries (start at bottom, end at top)
+        # Only show labels if the corresponding marker is within visible range
         if self._selection_start_text:
-            self._selection_start_text.set_position((x_start, -2))
-            self._selection_start_text.set_text(_format_time(start_seconds))
-            self._selection_start_text.set_visible(start_visible)
+            if start_visible:
+                self._selection_start_text.set_position((x_start, -2))
+                self._selection_start_text.set_text(_format_time(start_seconds))
+                self._selection_start_text.set_visible(True)
+            else:
+                self._selection_start_text.set_visible(False)
 
         if self._selection_end_text:
-            self._selection_end_text.set_position((x_end, ctx.n_mels - 2))
-            self._selection_end_text.set_text(_format_time(end_seconds))
-            self._selection_end_text.set_visible(end_visible)
+            if end_visible:
+                self._selection_end_text.set_position((x_end, ctx.n_mels - 2))
+                self._selection_end_text.set_text(_format_time(end_seconds))
+                self._selection_end_text.set_visible(True)
+            else:
+                self._selection_end_text.set_visible(False)
 
     def _hide_selection(self) -> None:
         """Hide all selection visual elements."""

{revoxx-1.1.0 → revoxx-1.1.1}/revoxx/ui/spectrogram/playback_handler.py

@@ -11,6 +11,7 @@ import time
 from matplotlib.lines import Line2D
 
 from ...constants import UIConstants
+from ...utils.adaptive_frame_rate import get_adaptive_frame_rate, DEBUG_FPS
 from .controllers import PlaybackController, ViewportMode, ZoomController
 
 from ...audio.shared_state import (
@@ -337,7 +338,8 @@ class PlaybackHandler:
 
     def _update_playback_position(self) -> None:
         """Update playback position from shared audio state."""
-        # Check if still playing
+        get_adaptive_frame_rate().frame_start()
+
         if not self.shared_audio_state:
             return
 
@@ -460,15 +462,20 @@ class PlaybackHandler:
             self._schedule_next_frame()
 
     def _schedule_next_frame(self) -> None:
-        """Schedule next animation frame."""
+        """Schedule next animation frame with adaptive timing."""
         if self.animation_id:
             try:
                 self.parent.after_cancel(self.animation_id)
             except ValueError:
                 pass
 
-        # Update interval
-        update_interval = UIConstants.PLAYBACK_UPDATE_MS
+        afr = get_adaptive_frame_rate()
+        update_interval = afr.frame_end()
+        if DEBUG_FPS:
+            print(
+                f"[PLAY] overshoot={afr.get_overshoot():.1f}ms "
+                f"interval={update_interval}ms fps={afr.get_current_fps():.1f}"
+            )
 
         self.animation_id = self.parent.after(
             update_interval, self._update_playback_position