revoxx 1.0.0.dev22__py3-none-any.whl → 1.0.1__py3-none-any.whl

revoxx/__init__.py

@@ -1,6 +1,14 @@
 """Revoxx Recorder - A tool for recording emotional speech."""
 
-__version__ = "1.0.0"
+try:
+    # Try to use versioningit for dynamic version detection
+    from versioningit import get_version
+
+    __version__ = get_version(root="../", config={})
+except (ImportError, Exception):
+    # Fallback if versioningit is not installed or fails
+    __version__ = "1.0.0+dev"
+
 __author__ = "Grammatek"
 
 # Only import main entry point to avoid circular imports

revoxx/app.py

@@ -688,6 +688,12 @@ class Revoxx:
         # Tkinter might have changed it during setup
         self.cleanup_manager.refresh_sigint_handler()
 
+        # Show user guide dialog if configured
+        if self.settings_manager.get_setting("show_user_guide_at_startup", True):
+            from .ui.dialogs.user_guide_dialog import UserGuideDialog
+
+            UserGuideDialog(self.window.window, self.settings_manager)
+
         self.window.focus_window()
         self.window.window.mainloop()
 

revoxx/controllers/display_controller.py

@@ -220,6 +220,36 @@ class DisplayController:
         """Reset the level meter display."""
         self.reset_level_meters()
 
+    def format_take_status(self, label: str) -> str:
+        """Format the take status display string for a given label.
+
+        This returns current take information in the status bar.
+
+        Args:
+            label: The utterance label (e.g., "utterance_001")
+
+        Returns:
+            - Empty string if label is None or empty
+            - Just the label if no active_recordings exist
+            - Just the label if no takes exist for this utterance
+            - "label - Take X/Y" if takes exist, where X is the position of the
+              current take in the list and Y is the total number of takes
+        """
+        if not label:
+            return ""
+
+        if not self.app.active_recordings:
+            return label
+
+        current_take = self.app.state.recording.get_current_take(label)
+        existing_takes = self.app.active_recordings.get_existing_takes(label)
+
+        if existing_takes and current_take in existing_takes:
+            position = existing_takes.index(current_take) + 1
+            return f"{label} - Take {position}/{len(existing_takes)}"
+
+        return label
+
     def set_status(self, status: str, msg_type: MsgType = MsgType.TEMPORARY) -> None:
         """Set the status bar text.
 

revoxx/controllers/navigation_controller.py

@@ -2,7 +2,7 @@
 
 from typing import TYPE_CHECKING
 
-from ..constants import FileConstants
+from ..constants import FileConstants, MsgType
 
 if TYPE_CHECKING:
     from ..app import Revoxx
@@ -134,10 +134,6 @@ class NavigationController:
             # Update info overlay if visible
             if self.app.window.info_panel_visible:
                 self.app.display_controller.update_info_panel()
-        else:
-            # No more takes in that direction
-            direction_text = "forward" if direction > 0 else "backward"
-            self.app.display_controller.set_status(f"No more takes {direction_text}")
 
     def find_utterance(self, index: int) -> None:
         """Navigate directly to a specific utterance by index.
@@ -252,15 +248,8 @@ class NavigationController:
         if not current_label:
             return
 
-        current_take = self.app.state.recording.get_current_take(current_label)
-        if not self.app.active_recordings:
-            existing_takes = []
-        else:
-            existing_takes = self.app.active_recordings.get_existing_takes(
-                current_label
-            )
-
         # Update label with filename if we have a recording
+        current_take = self.app.state.recording.get_current_take(current_label)
         if current_take > 0:
             filename = f"take_{current_take:03d}{FileConstants.AUDIO_FILE_EXTENSION}"
             self.app.window.update_label_with_filename(current_label, filename)
@@ -277,18 +266,8 @@ class NavigationController:
                 if second:
                     second.update_label_with_filename(current_label)
 
-        if existing_takes and current_take in existing_takes:
-            # Find position in the list
-            position = existing_takes.index(current_take) + 1
-            total = len(existing_takes)
-            self.app.display_controller.set_status(
-                f"{current_label} - Take {position}/{total}"
-            )
-        elif not existing_takes:
-            # Show label even without recordings
-            self.app.display_controller.set_status(f"{current_label}")
-        else:
-            self.app.display_controller.set_status(f"{current_label}")
+        status_text = self.app.display_controller.format_take_status(current_label)
+        self.app.display_controller.set_status(status_text, MsgType.DEFAULT)
 
     def after_recording_saved(self, label: str) -> None:
         """Called after a recording has been saved to disk.

revoxx/controllers/process_manager.py

@@ -77,6 +77,9 @@ class ProcessManager:
         self.set_audio_queue_active(False)
         self.set_save_path(None)
 
+        # Check for VAD availability
+        self._check_vad_availability()
+
     def start_processes(self) -> None:
         """Start background recording and playback processes."""
         if self.app.debug:
@@ -322,3 +325,34 @@ class ProcessManager:
             and self.playback_process is not None
             and self.playback_process.is_alive()
         )
+
+    def _check_vad_availability(self) -> None:
+        """Check if VAD support is available and store in manager_dict."""
+        try:
+            # Try to import the VAD module from scripts_module
+            from scripts_module import vadiate  # noqa: F401
+            from silero_vad import load_silero_vad  # noqa: F401
+
+            vad_available = True
+            if self.app.debug:
+                print("[ProcessManager] VAD support is available")
+        except ImportError:
+            vad_available = False
+            if self.app.debug:
+                print("[ProcessManager] VAD support is not available")
+
+        if self.manager_dict is not None:
+            self.manager_dict["vad_available"] = vad_available
+
+    def is_vad_available(self) -> bool:
+        """Check if VAD support is available.
+
+        Returns:
+            True if VAD is available
+        """
+        if self.manager_dict:
+            try:
+                return self.manager_dict.get("vad_available", False)
+            except (AttributeError, KeyError):
+                return False
+        return False

revoxx/controllers/session_controller.py

@@ -147,10 +147,7 @@ class SessionController:
         self.reload_script_and_recordings()
 
         # Then apply saved sort settings from session (after data is loaded)
-        if session:
-            self.app.active_recordings.set_sort(
-                session.sort_column, session.sort_reverse
-            )
+        self.app.active_recordings.set_sort(session.sort_column, session.sort_reverse)
 
         self.app.window.window.title(f"Revoxx - {session.name}")
         self.app.menu.update_recent_sessions()

revoxx/dataset/exporter.py

@@ -1,6 +1,7 @@
 """Dataset exporter for converting Revoxx sessions to Talrómur 3 format."""
 
 import shutil
+import json
 from pathlib import Path
 from typing import List, Dict, Tuple, Optional, Any
 from collections import Counter
@@ -30,6 +31,7 @@ class DatasetExporter:
         audio_format: str = "flac",
         zero_intensity_emotions: List[str] = None,
         include_intensity: bool = True,
+        include_vad: bool = False,
     ):
         """Initialize dataset exporter.
 
@@ -38,11 +40,13 @@ class DatasetExporter:
             audio_format: Output audio format ('wav' or 'flac')
             zero_intensity_emotions: List of emotions to set intensity to 0
             include_intensity: Whether to include intensity column in index.tsv
+            include_vad: Whether to run VAD analysis on the exported dataset
         """
         self.output_dir = Path(output_dir)
         self.format = audio_format.lower()
         self.zero_intensity_emotions = zero_intensity_emotions or ["neutral"]
         self.include_intensity = include_intensity
+        self.include_vad = include_vad
 
     def _group_sessions_by_speaker(self, session_paths: List[Path]) -> Dict:
         """Group sessions by speaker name.
@@ -172,6 +176,11 @@ class DatasetExporter:
                 }
             )
 
+        # Run VAD processing if requested
+        if self.include_vad:
+            vad_stats = self._run_vad_processing(all_datasets, progress_callback)
+            total_statistics["vad_statistics"] = vad_stats
+
         return all_datasets, total_statistics
 
     def _process_emotion_group(
@@ -387,3 +396,115 @@ class DatasetExporter:
         readme_path = dataset_dir / "README.txt"
         with open(readme_path, "w", encoding="utf-8") as f:
             f.write(readme_content)
+
+    def _run_vad_processing(
+        self, dataset_paths: List[Path], progress_callback=None
+    ) -> Dict:
+        """Run VAD processing on exported datasets using multiprocessing.
+
+        Args:
+            dataset_paths: List of dataset directories to process
+            progress_callback: Optional progress callback (count, message)
+
+        Returns:
+            Dictionary with total files processed and warnings
+        """
+        try:
+            from scripts_module.vadiate import get_audio_files
+            import multiprocessing as mp
+            from concurrent.futures import ProcessPoolExecutor, as_completed
+        except ImportError:
+            return {}  # VAD not available
+
+        # Count total files for progress
+        total_files = sum(len(get_audio_files(str(d))) for d in dataset_paths)
+        if total_files == 0:
+            return {}
+
+        processed = 0
+        vad_statistics = {"total_files": total_files, "warnings": []}
+
+        # Use process pool for parallel processing
+        # Each process handles VAD analysis for one complete dataset (speaker)
+        # This means if we export 3 speakers, we use up to 3 processes
+        # Each process analyzes all audio files within its assigned speaker's dataset
+        num_workers = min(mp.cpu_count(), len(dataset_paths))
+
+        with ProcessPoolExecutor(max_workers=num_workers) as executor:
+            # Submit one VAD processing task per dataset (per speaker)
+            # Each task processes all audio files in that speaker's dataset directory
+            future_to_dataset = {
+                executor.submit(self._process_dataset_vad, dataset_path): dataset_path
+                for dataset_path in dataset_paths
+            }
+
+            # Process completed tasks
+            for future in as_completed(future_to_dataset):
+                dataset_path = future_to_dataset[future]
+                try:
+                    result = future.result()
+                    processed += result["files_processed"]
+                    vad_statistics["warnings"].extend(result["warnings"])
+                    if progress_callback:
+                        progress_callback(
+                            processed, f"VAD analysis: {processed}/{total_files}"
+                        )
+                except Exception as e:
+                    vad_statistics["warnings"].append(
+                        f"VAD processing error for {dataset_path}: {e}"
+                    )
+
+        return vad_statistics
+
+    @staticmethod
+    def _process_dataset_vad(dataset_path: Path) -> Dict:
+        """Process VAD for a single dataset (one speaker's complete dataset).
+
+        This method runs in a separate process and handles all audio files
+        for one speaker. If multiple speakers were exported, each speaker's
+        dataset is processed by a different process in parallel.
+
+        Args:
+            dataset_path: Path to the dataset directory for one speaker
+
+        Returns:
+            Dictionary with files processed and warnings
+        """
+        from scripts_module.vadiate import (
+            get_audio_files,
+            process_audio,
+            load_silero_vad,
+        )
+
+        vad_output = dataset_path / "vad.json"
+        audio_files = get_audio_files(str(dataset_path))
+
+        result_info = {"files_processed": 0, "warnings": []}
+
+        if not audio_files:
+            return result_info
+
+        # Load model for this process
+        model = load_silero_vad()
+        results = {}
+
+        for file_path in audio_files:
+            try:
+                rel_path, result, warnings = process_audio(
+                    file_path,
+                    model,
+                    str(dataset_path),
+                    use_dynamic_threshold=True,
+                    collect_warnings=True,
+                )
+                results[rel_path] = result
+                result_info["warnings"].extend(warnings)
+                result_info["files_processed"] += 1
+            except Exception as e:
+                result_info["warnings"].append(f"VAD error for {file_path}: {e}")
+
+        # Save results
+        with open(vad_output, "w") as f:
+            json.dump(results, f, indent=2)
+
+        return result_info

revoxx/ui/dialogs/dataset_dialog.py

@@ -41,16 +41,24 @@ class DatasetDialog:
     # Entry field widths
     ENTRY_WIDTH_STANDARD = 40
 
-    def __init__(self, parent, base_dir: Path, settings_manager: SettingsManager):
+    def __init__(
+        self,
+        parent,
+        base_dir: Path,
+        settings_manager: SettingsManager,
+        process_manager=None,
+    ):
         """Initialize dataset creation dialog.
 
         Args:
             parent: Parent window
             base_dir: Base directory containing sessions
             settings_manager: Shared SettingsManager instance
+            process_manager: Optional ProcessManager instance for VAD check
         """
         self.parent = parent
         self.settings_manager = settings_manager
+        self.process_manager = process_manager
         self.result = None
 
         # Use provided base_dir
@@ -229,11 +237,45 @@ class DatasetDialog:
                 self.settings_manager.settings, "export_include_intensity", True
             )
         )
+        options_frame = ttk.Frame(output_frame)
+        options_frame.grid(row=3, column=1, columnspan=2, sticky=tk.W, pady=2)
+
         ttk.Checkbutton(
-            output_frame,
+            options_frame,
             text="Include intensity levels in index.tsv",
             variable=self.include_intensity_var,
-        ).grid(row=3, column=1, sticky=tk.W, pady=2)
+        ).pack(anchor=tk.W)
+
+        # VAD support checkbox
+        self.include_vad_var = tk.BooleanVar(
+            value=getattr(self.settings_manager.settings, "export_include_vad", False)
+        )
+        self.vad_checkbox = ttk.Checkbutton(
+            options_frame,
+            text="Include VAD analysis",
+            variable=self.include_vad_var,
+        )
+        self.vad_checkbox.pack(anchor=tk.W, pady=(2, 0))
+
+        # Enable/disable VAD checkbox based on availability
+        vad_available = (
+            self.process_manager.is_vad_available() if self.process_manager else False
+        )
+        if vad_available:
+            self.vad_checkbox.configure(state="normal")
+            # Add tooltip
+            self._create_tooltip(
+                self.vad_checkbox,
+                "Voice Activity Detection provides speech segment timestamps",
+            )
+        else:
+            self.vad_checkbox.configure(state="disabled")
+            self.include_vad_var.set(False)
+            # Add different tooltip for disabled state
+            self._create_tooltip(
+                self.vad_checkbox,
+                "VAD not available - install Revoxx with '[vad]' option to enable",
+            )
 
         output_frame.columnconfigure(1, weight=1)
 
@@ -577,6 +619,9 @@ class DatasetDialog:
         self.settings_manager.update_setting(
             "export_include_intensity", self.include_intensity_var.get()
         )
+        self.settings_manager.update_setting(
+            "export_include_vad", self.include_vad_var.get()
+        )
 
     def _run_export(
         self, session_paths: List[Path], output_dir: Path, dataset_name: Optional[str]
@@ -592,15 +637,24 @@ class DatasetDialog:
 
         try:
             # Create exporter
+            vad_enabled = self.include_vad_var.get() and (
+                self.process_manager.is_vad_available()
+                if self.process_manager
+                else False
+            )
             exporter = DatasetExporter(
                 output_dir=output_dir,
                 audio_format=self.format_var.get(),
                 include_intensity=self.include_intensity_var.get(),
+                include_vad=vad_enabled,
             )
 
             # Export sessions
-            def progress_callback(count):
-                progress_dialog.update(count, f"Processing utterance {count}")
+            def progress_callback(count, message=None):
+                if message:
+                    progress_dialog.update(count, message)
+                else:
+                    progress_dialog.update(count, f"Processing utterance {count}")
 
             dataset_paths, statistics = exporter.export_sessions(
                 session_paths,
@@ -684,6 +738,20 @@ class DatasetDialog:
             summary += "\n" + "-" * 50 + "\n"
             summary += f"⚠ Warning: {statistics['missing_recordings']} recordings were missing\n"
 
+        # Add VAD statistics if available
+        if "vad_statistics" in statistics and statistics["vad_statistics"]:
+            vad_stats = statistics["vad_statistics"]
+            summary += "\n" + "-" * 50 + "\n"
+            summary += (
+                f"VAD Analysis: {vad_stats.get('total_files', 0)} files processed\n"
+            )
+
+            # Add warnings if any
+            if vad_stats.get("warnings"):
+                summary += "\nWarnings:\n"
+                for warning in vad_stats["warnings"]:
+                    summary += f"{warning}\n"
+
         # Insert text and make read-only
         text_widget.insert("1.0", summary)
         text_widget.configure(state="disabled")
@@ -714,6 +782,41 @@ class DatasetDialog:
         """Cancel dialog."""
         self.dialog.destroy()
 
+    @staticmethod
+    def _create_tooltip(widget, text) -> None:
+        """Create a tooltip for a widget.
+
+        Args:
+            widget: The widget to attach the tooltip to
+            text: The tooltip text
+        """
+        tooltip = None
+
+        def on_enter(event):
+            nonlocal tooltip
+            tooltip = tk.Toplevel()
+            tooltip.wm_overrideredirect(True)
+            tooltip.wm_geometry(f"+{event.x_root+10}+{event.y_root+10}")
+            label = ttk.Label(
+                tooltip,
+                text=text,
+                justify=tk.LEFT,
+                background="#ffffe0",
+                relief=tk.SOLID,
+                borderwidth=1,
+                font=("TkDefaultFont", "9", "normal"),
+            )
+            label.pack()
+
+        def on_leave(event):
+            nonlocal tooltip
+            if tooltip:
+                tooltip.destroy()
+                tooltip = None
+
+        widget.bind("<Enter>", on_enter)
+        widget.bind("<Leave>", on_leave)
+
     def show(self) -> Optional[Path]:
         """Show dialog and return result.
 

revoxx/ui/dialogs/open_session_dialog.py

@@ -173,7 +173,9 @@ class OpenSessionDialog:
         )
 
         if new_dir:
-            self._load_directory(Path(new_dir))
+            new_path = Path(new_dir)
+            # Always load the directory, even if it's a .revoxx session
+            self._load_directory(new_path)
 
     def _go_to_parent(self):
         """Navigate to parent directory."""
@@ -201,6 +203,27 @@ class OpenSessionDialog:
             self.info_label.config(text="Directory does not exist")
             return
 
+        # Check if current directory itself is a .revoxx session
+        if self._is_valid_session(self.current_dir):
+            session_info = self._get_session_info(self.current_dir)
+            if session_info:
+                # Show this directory as the only session
+                self.tree.insert(
+                    "",
+                    "end",
+                    text=self.current_dir.name,
+                    values=(
+                        "Session",
+                        session_info.get("speaker", ""),
+                        session_info.get("emotion", ""),
+                        session_info.get("utterances", ""),
+                        session_info.get("recordings", ""),
+                    ),
+                    tags=("session", "current"),
+                )
+                self.info_label.config(text="Current directory is a Revoxx session")
+                return
+
         # Find sessions and subdirectories
         sessions = []
         subdirs = []
@@ -374,10 +397,31 @@ class OpenSessionDialog:
             # Open the session
             self._on_open()
 
+    def _is_valid_session(self, path: Path) -> bool:
+        """Check if a path is a valid Revoxx session.
+
+        Args:
+            path: Path to check
+
+        Returns:
+            True if the path is a valid session, False otherwise
+        """
+        return (
+            path.suffix == ".revoxx"
+            and path.is_dir()
+            and (path / "session.json").exists()
+        )
+
     def _on_open(self):
         """Handle Open button click."""
         selection = self.tree.selection()
+
+        # If no selection, check if current directory is a .revoxx session
         if not selection:
+            if self._is_valid_session(self.current_dir):
+                self.result = self.current_dir
+                self.dialog.destroy()
+                return
             messagebox.showwarning(
                 "No Selection", "Please select a session to open.", parent=self.dialog
             )
@@ -385,6 +429,7 @@ class OpenSessionDialog:
 
         item = self.tree.item(selection[0])
         item_type = item["values"][0] if item["values"] else ""
+        item_tags = item.get("tags", [])
 
         if item_type != "Session":
             messagebox.showwarning(
@@ -394,12 +439,15 @@ class OpenSessionDialog:
             )
             return
 
-        # Get the selected session path
-        session_name = item["text"]
-        self.result = self.current_dir / session_name
+        # Determine the session path
+        if "current" in item_tags:
+            self.result = self.current_dir
+        else:
+            session_name = item["text"]
+            self.result = self.current_dir / session_name
 
-        # Verify it's a valid session
-        if not self.result.exists() or not self.result.suffix == ".revoxx":
+        # Final validation
+        if not self._is_valid_session(self.result):
             messagebox.showerror(
                 "Invalid Session",
                 "The selected directory is not a valid Revoxx session.",