revoxx 1.1.1__tar.gz → 1.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revoxx
-Version: 1.1.1
+Version: 1.1.2
 Summary: Speech recording application for creating high-quality speech datasets
 Author-email: Grammatek ehf <info@grammatek.com>
 Maintainer-email: Grammatek ehf <info@grammatek.com>
@@ -121,6 +121,7 @@ the Icelandic emotional speech dataset, and created this tool to minimize hassle
   - Delete ranges with automatic crossfade
   - Insert new audio at marker position
   - Replace selected ranges with new recordings
+  - Multiple undo/redo for all editing operations
 - **Multi-Screen Support**
   - You can use multiple monitors to **separate recording view from speaker view**
   - We support Apple's [Sidecar](https://support.apple.com/en-us/102597) feature for a **convenient dual screen setup with an external iPad**

{revoxx-1.1.1 → revoxx-1.1.2}/README.md

@@ -72,6 +72,7 @@ the Icelandic emotional speech dataset, and created this tool to minimize hassle
   - Delete ranges with automatic crossfade
   - Insert new audio at marker position
   - Replace selected ranges with new recordings
+  - Multiple undo/redo for all editing operations
 - **Multi-Screen Support**
   - You can use multiple monitors to **separate recording view from speaker view**
   - We support Apple's [Sidecar](https://support.apple.com/en-us/102597) feature for a **convenient dual screen setup with an external iPad**

{revoxx-1.1.1 → revoxx-1.1.2}/revoxx/app.py

@@ -445,12 +445,22 @@ class Revoxx:
             self.window.window.bind("<Command-Q>", lambda e: self._handle_cmd_q())
             # Also try to catch it with createcommand
             self.window.window.createcommand("::tk::mac::Quit", self._handle_cmd_q)
+            # Undo/Redo
+            self.window.window.bind("<Command-z>", lambda e: self._undo())
+            self.window.window.bind("<Command-Z>", lambda e: self._undo())
+            self.window.window.bind("<Shift-Command-z>", lambda e: self._redo())
+            self.window.window.bind("<Shift-Command-Z>", lambda e: self._redo())
 
         # Session keys
         self.window.window.bind("<Control-n>", lambda e: self._new_session())
         self.window.window.bind("<Control-N>", lambda e: self._new_session())
         self.window.window.bind("<Control-o>", lambda e: self._open_session())
         self.window.window.bind("<Control-O>", lambda e: self._open_session())
+        # Undo/Redo (Control for Linux/Windows)
+        self.window.window.bind("<Control-z>", lambda e: self._undo())
+        self.window.window.bind("<Control-Z>", lambda e: self._undo())
+        self.window.window.bind("<Shift-Control-z>", lambda e: self._redo())
+        self.window.window.bind("<Shift-Control-Z>", lambda e: self._redo())
 
         # Window close event
         self.window.window.protocol("WM_DELETE_WINDOW", self._quit)
@@ -534,6 +544,16 @@ class Revoxx:
         self._quit()
         return "break"  # Prevent default handling
 
+    def _undo(self):
+        """Handle undo keyboard shortcut."""
+        self.edit_controller.undo()
+        return "break"
+
+    def _redo(self):
+        """Handle redo keyboard shortcut."""
+        self.edit_controller.redo()
+        return "break"
+
     def _perform_cleanup(self):
         """Perform cleanup when signals are received or on emergency exit."""
         # Only do critical cleanup - no UI interactions

revoxx-1.1.2/revoxx/audio/edit_commands.py

@@ -0,0 +1,338 @@
+"""Edit commands for undo/redo support.
+
+This module provides command classes that encapsulate audio editing operations.
+Each command stores the data needed to undo the operation.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from ..files.file_manager import FileManager
+
+
+class EditCommand(ABC):
+    """Abstract base class for edit commands.
+
+    Each command represents an audio editing operation that can be
+    undone and redone. Commands store the data needed to reverse
+    the operation.
+    """
+
+    def __init__(self, filepath: Path, sample_rate: int, subtype: Optional[str] = None):
+        """Initialize the command.
+
+        Args:
+            filepath: Path to the audio file being edited
+            sample_rate: Sample rate of the audio
+            subtype: Audio subtype for saving (e.g., "PCM_16")
+        """
+        self.filepath = filepath
+        self.sample_rate = sample_rate
+        self.subtype = subtype
+
+    @abstractmethod
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Execute the command.
+
+        Args:
+            file_manager: FileManager instance for audio I/O
+
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def inverse(self) -> "EditCommand":
+        """Create the inverse command for undo.
+
+        Returns:
+            A command that reverses this operation
+        """
+        pass
+
+    @abstractmethod
+    def description(self) -> str:
+        """Get a human-readable description of this command.
+
+        Returns:
+            Description string (e.g., "Delete Range")
+        """
+        pass
+
+
+class AudioSnapshotCommand(EditCommand):
+    """Command that stores complete audio snapshots for undo/redo.
+
+    This approach ensures exact restoration without re-applying cross-fade.
+    Stores both the audio before and after the operation.
+    """
+
+    def __init__(
+        self,
+        filepath: Path,
+        sample_rate: int,
+        audio_before: np.ndarray,
+        audio_after: np.ndarray,
+        subtype: Optional[str] = None,
+        selection_start_time: Optional[float] = None,
+        selection_end_time: Optional[float] = None,
+        marker_after_edit: Optional[float] = None,
+        operation_description: str = "Edit",
+    ):
+        """Initialize audio snapshot command.
+
+        Args:
+            filepath: Path to the audio file
+            sample_rate: Sample rate of the audio
+            audio_before: Complete audio data before the operation
+            audio_after: Complete audio data after the operation
+            subtype: Audio subtype for saving
+            selection_start_time: Selection to restore on undo
+            selection_end_time: Selection to restore on undo
+            marker_after_edit: Marker to set after redo
+            operation_description: Description of the operation
+        """
+        super().__init__(filepath, sample_rate, subtype)
+        self.audio_before = audio_before
+        self.audio_after = audio_after
+        self.selection_start_time = selection_start_time
+        self.selection_end_time = selection_end_time
+        self.marker_after_edit = marker_after_edit
+        self.operation_description = operation_description
+
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Write audio_after to file (for redo)."""
+        try:
+            file_manager.save_audio(
+                self.filepath, self.audio_after, self.sample_rate, self.subtype
+            )
+            return True
+        except (OSError, ValueError):
+            return False
+
+    def inverse(self) -> "AudioSnapshotCommand":
+        """Create inverse command that restores audio_before."""
+        return AudioSnapshotCommand(
+            filepath=self.filepath,
+            sample_rate=self.sample_rate,
+            audio_before=self.audio_after,
+            audio_after=self.audio_before,
+            subtype=self.subtype,
+            selection_start_time=self.selection_start_time,
+            selection_end_time=self.selection_end_time,
+            marker_after_edit=None,
+            operation_description=self.operation_description,
+        )
+
+    def description(self) -> str:
+        """Get description of this command."""
+        return self.operation_description
+
+
+# Convenience aliases for specific operations (all use AudioSnapshotCommand internally)
+DeleteRangeCommand = AudioSnapshotCommand
+InsertCommand = AudioSnapshotCommand
+ReplaceRangeCommand = AudioSnapshotCommand
+
+
+class TrashClipCommand(EditCommand):
+    """Command for moving a clip to trash.
+
+    Uses the existing trash system (move_to_trash/restore_from_trash).
+    """
+
+    def __init__(
+        self,
+        filepath: Path,
+        sample_rate: int,
+        label: str,
+        take: int,
+    ):
+        """Initialize trash clip command.
+
+        Args:
+            filepath: Path to the audio file
+            sample_rate: Sample rate of the audio
+            label: Script label/ID for the utterance
+            take: Take number
+        """
+        super().__init__(filepath, sample_rate, None)
+        self.label = label
+        self.take = take
+
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Move the clip to trash."""
+        return file_manager.move_to_trash(self.label, self.take)
+
+    def inverse(self) -> "RestoreFromTrashCommand":
+        """Create a restore command to undo this deletion."""
+        return RestoreFromTrashCommand(
+            filepath=self.filepath,
+            sample_rate=self.sample_rate,
+            label=self.label,
+            take=self.take,
+        )
+
+    def description(self) -> str:
+        """Get description of this command."""
+        return f"Delete Clip (take {self.take})"
+
+
+class RestoreFromTrashCommand(EditCommand):
+    """Command for restoring a clip from trash."""
+
+    def __init__(
+        self,
+        filepath: Path,
+        sample_rate: int,
+        label: str,
+        take: int,
+    ):
+        """Initialize restore from trash command."""
+        super().__init__(filepath, sample_rate, None)
+        self.label = label
+        self.take = take
+
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Restore the clip from trash."""
+        return file_manager.restore_from_trash(self.label, self.take)
+
+    def inverse(self) -> "TrashClipCommand":
+        """Create a trash command to undo this restoration."""
+        return TrashClipCommand(
+            filepath=self.filepath,
+            sample_rate=self.sample_rate,
+            label=self.label,
+            take=self.take,
+        )
+
+    def description(self) -> str:
+        """Get description of this command."""
+        return f"Restore Clip (take {self.take})"
+
+
+class DeleteClipCommand(EditCommand):
+    """Command for deleting an entire audio clip.
+
+    Stores the complete audio data so it can be restored on undo.
+    Note: For trash-based deletion, use TrashClipCommand instead.
+    """
+
+    def __init__(
+        self,
+        filepath: Path,
+        sample_rate: int,
+        audio_data: np.ndarray,
+        subtype: Optional[str] = None,
+    ):
+        """Initialize delete clip command.
+
+        Args:
+            filepath: Path to the audio file
+            sample_rate: Sample rate of the audio
+            audio_data: The complete audio data of the deleted clip
+            subtype: Audio subtype for saving (e.g., "PCM_16")
+        """
+        super().__init__(filepath, sample_rate)
+        self.audio_data = audio_data
+        self.subtype = subtype
+
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Execute the delete clip operation (delete the file).
+
+        Args:
+            file_manager: FileManager instance for audio I/O
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            if self.filepath.exists():
+                self.filepath.unlink()
+            return True
+        except OSError:
+            return False
+
+    def inverse(self) -> "RestoreClipCommand":
+        """Create a restore command to undo this deletion.
+
+        Returns:
+            RestoreClipCommand that recreates the deleted file
+        """
+        return RestoreClipCommand(
+            filepath=self.filepath,
+            sample_rate=self.sample_rate,
+            audio_data=self.audio_data,
+            subtype=self.subtype,
+        )
+
+    def description(self) -> str:
+        """Get description of this command."""
+        duration = len(self.audio_data) / self.sample_rate
+        return f"Delete Clip ({duration:.2f}s)"
+
+
+class RestoreClipCommand(EditCommand):
+    """Command for restoring a deleted audio clip.
+
+    Used as the inverse of DeleteClipCommand.
+    """
+
+    def __init__(
+        self,
+        filepath: Path,
+        sample_rate: int,
+        audio_data: np.ndarray,
+        subtype: Optional[str] = None,
+    ):
+        """Initialize restore clip command.
+
+        Args:
+            filepath: Path to the audio file
+            sample_rate: Sample rate of the audio
+            audio_data: The audio data to restore
+            subtype: Audio subtype for saving (e.g., "PCM_16")
+        """
+        super().__init__(filepath, sample_rate)
+        self.audio_data = audio_data
+        self.subtype = subtype
+
+    def execute(self, file_manager: "FileManager") -> bool:
+        """Execute the restore operation (recreate the file).
+
+        Args:
+            file_manager: FileManager instance for audio I/O
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            file_manager.save_audio(
+                self.filepath, self.audio_data, self.sample_rate, self.subtype
+            )
+            return True
+        except (OSError, ValueError):
+            return False
+
+    def inverse(self) -> "DeleteClipCommand":
+        """Create a delete command to undo this restoration.
+
+        Returns:
+            DeleteClipCommand that deletes the file again
+        """
+        return DeleteClipCommand(
+            filepath=self.filepath,
+            sample_rate=self.sample_rate,
+            audio_data=self.audio_data,
+            subtype=self.subtype,
+        )
+
+    def description(self) -> str:
+        """Get description of this command."""
+        duration = len(self.audio_data) / self.sample_rate
+        return f"Restore Clip ({duration:.2f}s)"

revoxx-1.1.2/revoxx/audio/undo_stack.py

@@ -0,0 +1,170 @@
+"""Undo/redo stack for audio editing operations.
+
+This module provides the UndoStack class that manages undo and redo
+operations using the command pattern.
+"""
+
+from typing import TYPE_CHECKING, List, Optional
+
+from .edit_commands import EditCommand
+
+if TYPE_CHECKING:
+    from ..files.file_manager import FileManager
+
+
+class UndoStack:
+    """Manages undo and redo stacks for edit commands.
+
+    Uses two stacks:
+    - Undo stack: Commands that can be undone (most recent on top)
+    - Redo stack: Commands that were undone and can be redone
+
+    When a new command is pushed, the redo stack is cleared.
+    """
+
+    def __init__(self, max_size: int = 50):
+        """Initialize the undo stack.
+
+        Args:
+            max_size: Maximum number of commands to keep in the undo stack.
+                      Older commands are discarded when the limit is reached.
+        """
+        self._max_size = max_size
+        self._undo_stack: List[EditCommand] = []
+        self._redo_stack: List[EditCommand] = []
+
+    def push(self, command: EditCommand) -> None:
+        """Push a new command onto the undo stack.
+
+        This clears the redo stack since a new action invalidates
+        any previously undone commands.
+
+        Args:
+            command: The command that was just executed
+        """
+        self._undo_stack.append(command)
+        self._redo_stack.clear()
+
+        if len(self._undo_stack) > self._max_size:
+            self._undo_stack.pop(0)
+
+    def undo(self, file_manager: "FileManager") -> Optional[EditCommand]:
+        """Undo the most recent command.
+
+        Pops the command from the undo stack, executes its inverse,
+        and pushes the original command to the redo stack.
+
+        Args:
+            file_manager: FileManager instance for audio I/O
+
+        Returns:
+            The command that was undone, or None if undo failed or stack is empty
+        """
+        if not self._undo_stack:
+            return None
+
+        command = self._undo_stack.pop()
+        inverse_command = command.inverse()
+
+        if inverse_command.execute(file_manager):
+            self._redo_stack.append(command)
+            return command
+
+        self._undo_stack.append(command)
+        return None
+
+    def redo(self, file_manager: "FileManager") -> Optional[EditCommand]:
+        """Redo the most recently undone command.
+
+        Pops the command from the redo stack, re-executes it,
+        and pushes it back to the undo stack.
+
+        Args:
+            file_manager: FileManager instance for audio I/O
+
+        Returns:
+            The command that was redone, or None if redo failed or stack is empty
+        """
+        if not self._redo_stack:
+            return None
+
+        command = self._redo_stack.pop()
+
+        if command.execute(file_manager):
+            self._undo_stack.append(command)
+            return command
+
+        self._redo_stack.append(command)
+        return None
+
+    def can_undo(self) -> bool:
+        """Check if there are commands that can be undone.
+
+        Returns:
+            True if undo is available, False otherwise
+        """
+        return len(self._undo_stack) > 0
+
+    def can_redo(self) -> bool:
+        """Check if there are commands that can be redone.
+
+        Returns:
+            True if redo is available, False otherwise
+        """
+        return len(self._redo_stack) > 0
+
+    def clear(self) -> None:
+        """Clear both undo and redo stacks.
+
+        Call this when switching to a different audio file.
+        """
+        self._undo_stack.clear()
+        self._redo_stack.clear()
+
+    def peek_undo(self) -> Optional[EditCommand]:
+        """Get the next command that would be undone without removing it.
+
+        Returns:
+            The command at the top of the undo stack, or None if empty
+        """
+        if self._undo_stack:
+            return self._undo_stack[-1]
+        return None
+
+    def peek_redo(self) -> Optional[EditCommand]:
+        """Get the next command that would be redone without removing it.
+
+        Returns:
+            The command at the top of the redo stack, or None if empty
+        """
+        if self._redo_stack:
+            return self._redo_stack[-1]
+        return None
+
+    def undo_description(self) -> Optional[str]:
+        """Get description of the next undo operation.
+
+        Returns:
+            Description string or None if undo stack is empty
+        """
+        cmd = self.peek_undo()
+        return cmd.description() if cmd else None
+
+    def redo_description(self) -> Optional[str]:
+        """Get description of the next redo operation.
+
+        Returns:
+            Description string or None if redo stack is empty
+        """
+        cmd = self.peek_redo()
+        return cmd.description() if cmd else None
+
+    @property
+    def undo_count(self) -> int:
+        """Get the number of commands in the undo stack."""
+        return len(self._undo_stack)
+
+    @property
+    def redo_count(self) -> int:
+        """Get the number of commands in the redo stack."""
+        return len(self._redo_stack)