meeting-noter 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

meeting_noter/gui/meetings_tab.py

@@ -1,348 +0,0 @@
-"""Meetings list tab for browsing and managing recordings."""
-
-from __future__ import annotations
-
-import os
-import subprocess
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-from PyQt6.QtCore import Qt, QUrl
-from PyQt6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QTableWidget,
-    QTableWidgetItem,
-    QPushButton,
-    QHeaderView,
-    QDialog,
-    QTextEdit,
-    QLineEdit,
-    QLabel,
-    QMessageBox,
-    QDialogButtonBox,
-)
-from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
-
-from meeting_noter.config import get_config
-
-
-class TranscriptDialog(QDialog):
-    """Dialog for viewing a transcript."""
-
-    def __init__(self, title: str, content: str, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle(f"Transcript: {title}")
-        self.setMinimumSize(600, 400)
-
-        layout = QVBoxLayout(self)
-
-        self.text_edit = QTextEdit()
-        self.text_edit.setReadOnly(True)
-        self.text_edit.setPlainText(content)
-        layout.addWidget(self.text_edit)
-
-        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
-        button_box.rejected.connect(self.close)
-        layout.addWidget(button_box)
-
-
-class RenameDialog(QDialog):
-    """Dialog for renaming a meeting."""
-
-    def __init__(self, current_name: str, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("Rename Meeting")
-        self.setMinimumWidth(400)
-
-        layout = QVBoxLayout(self)
-
-        layout.addWidget(QLabel("New name:"))
-
-        self.name_input = QLineEdit()
-        self.name_input.setText(current_name)
-        self.name_input.selectAll()
-        layout.addWidget(self.name_input)
-
-        button_box = QDialogButtonBox(
-            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
-        )
-        button_box.accepted.connect(self.accept)
-        button_box.rejected.connect(self.reject)
-        layout.addWidget(button_box)
-
-    def get_name(self) -> str:
-        """Get the entered name."""
-        return self.name_input.text().strip()
-
-
-class MeetingsTab(QWidget):
-    """Tab for browsing and managing meeting recordings."""
-
-    def __init__(self):
-        super().__init__()
-        self.config = get_config()
-        self.player: Optional[QMediaPlayer] = None
-        self.audio_output: Optional[QAudioOutput] = None
-        self.current_playing: Optional[Path] = None
-
-        self._setup_ui()
-        self.refresh()
-
-    def _setup_ui(self):
-        """Set up the user interface."""
-        layout = QVBoxLayout(self)
-
-        # Table for meetings
-        self.table = QTableWidget()
-        self.table.setColumnCount(5)
-        self.table.setHorizontalHeaderLabels(["Date", "Name", "Duration", "Transcript", "Actions"])
-        self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
-        self.table.setSelectionMode(QTableWidget.SelectionMode.SingleSelection)
-        self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
-        self.table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
-        self.table.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
-        self.table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
-        self.table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeMode.ResizeToContents)
-        layout.addWidget(self.table)
-
-        # Bottom buttons
-        button_layout = QHBoxLayout()
-
-        self.refresh_button = QPushButton("Refresh")
-        self.refresh_button.clicked.connect(self.refresh)
-        button_layout.addWidget(self.refresh_button)
-
-        self.open_folder_button = QPushButton("Open Folder")
-        self.open_folder_button.clicked.connect(self._open_folder)
-        button_layout.addWidget(self.open_folder_button)
-
-        button_layout.addStretch()
-
-        layout.addLayout(button_layout)
-
-    def refresh(self):
-        """Refresh the meetings list."""
-        self.table.setRowCount(0)
-
-        recordings_dir = self.config.recordings_dir
-        if not recordings_dir.exists():
-            return
-
-        # Find all MP3 files
-        mp3_files = sorted(recordings_dir.glob("*.mp3"), reverse=True)
-
-        for mp3_path in mp3_files:
-            self._add_meeting_row(mp3_path)
-
-    def _get_transcript_path(self, mp3_path: Path) -> Path:
-        """Get the transcript path for an audio file."""
-        transcripts_dir = self.config.transcripts_dir
-        return transcripts_dir / mp3_path.with_suffix(".txt").name
-
-    def _add_meeting_row(self, mp3_path: Path):
-        """Add a row for a meeting recording."""
-        row = self.table.rowCount()
-        self.table.insertRow(row)
-
-        # Parse filename
-        name = mp3_path.stem
-        parts = name.split("_", 2)
-
-        if len(parts) >= 2:
-            # Format: YYYY-MM-DD_HHMMSS or YYYY-MM-DD_HHMMSS_name
-            try:
-                date_str = parts[0]
-                time_str = parts[1]
-                date_obj = datetime.strptime(f"{date_str}_{time_str}", "%Y-%m-%d_%H%M%S")
-                display_date = date_obj.strftime("%Y-%m-%d %H:%M")
-            except ValueError:
-                display_date = name
-            meeting_name = parts[2] if len(parts) > 2 else ""
-        else:
-            display_date = name
-            meeting_name = ""
-
-        # Date column
-        date_item = QTableWidgetItem(display_date)
-        date_item.setData(Qt.ItemDataRole.UserRole, str(mp3_path))
-        self.table.setItem(row, 0, date_item)
-
-        # Name column
-        name_item = QTableWidgetItem(meeting_name)
-        self.table.setItem(row, 1, name_item)
-
-        # Duration column
-        duration = self._get_duration(mp3_path)
-        duration_item = QTableWidgetItem(duration)
-        self.table.setItem(row, 2, duration_item)
-
-        # Transcript column
-        transcript_path = self._get_transcript_path(mp3_path)
-        has_transcript = transcript_path.exists()
-        transcript_item = QTableWidgetItem("Yes" if has_transcript else "No")
-        self.table.setItem(row, 3, transcript_item)
-
-        # Actions column - widget with buttons
-        actions_widget = QWidget()
-        actions_layout = QHBoxLayout(actions_widget)
-        actions_layout.setContentsMargins(4, 2, 4, 2)
-        actions_layout.setSpacing(4)
-
-        play_btn = QPushButton("Play")
-        play_btn.setFixedWidth(50)
-        play_btn.clicked.connect(lambda checked, p=mp3_path: self._play_audio(p))
-        actions_layout.addWidget(play_btn)
-
-        if has_transcript:
-            view_btn = QPushButton("View")
-            view_btn.setFixedWidth(50)
-            tp = transcript_path  # Capture for lambda
-            view_btn.clicked.connect(lambda checked, p=tp: self._view_transcript(p))
-            actions_layout.addWidget(view_btn)
-        else:
-            transcribe_btn = QPushButton("Transcribe")
-            transcribe_btn.setFixedWidth(70)
-            transcribe_btn.clicked.connect(lambda checked, p=mp3_path: self._transcribe_recording(p))
-            actions_layout.addWidget(transcribe_btn)
-
-        rename_btn = QPushButton("Rename")
-        rename_btn.setFixedWidth(60)
-        rename_btn.clicked.connect(lambda checked, p=mp3_path, r=row: self._rename_meeting(p, r))
-        actions_layout.addWidget(rename_btn)
-
-        self.table.setCellWidget(row, 4, actions_widget)
-
-    def _get_duration(self, mp3_path: Path) -> str:
-        """Get the duration of an MP3 file."""
-        try:
-            # Use file size as rough estimate (128kbps = 16KB/s)
-            size_bytes = mp3_path.stat().st_size
-            duration_secs = size_bytes / (128 * 1000 / 8)
-            mins, secs = divmod(int(duration_secs), 60)
-            return f"{mins:02d}:{secs:02d}"
-        except Exception:
-            return "--:--"
-
-    def _play_audio(self, mp3_path: Path):
-        """Play or stop audio playback."""
-        # Stop current playback if any
-        if self.player and self.current_playing == mp3_path:
-            self.player.stop()
-            self.player = None
-            self.audio_output = None
-            self.current_playing = None
-            return
-
-        # Stop any existing playback
-        if self.player:
-            self.player.stop()
-
-        # Create new player
-        self.audio_output = QAudioOutput()
-        self.player = QMediaPlayer()
-        self.player.setAudioOutput(self.audio_output)
-        self.player.setSource(QUrl.fromLocalFile(str(mp3_path)))
-        self.player.play()
-        self.current_playing = mp3_path
-
-    def _view_transcript(self, transcript_path: Path):
-        """View a transcript in a dialog."""
-        try:
-            content = transcript_path.read_text()
-            dialog = TranscriptDialog(transcript_path.stem, content, self)
-            dialog.exec()
-        except Exception as e:
-            QMessageBox.warning(self, "Error", f"Could not read transcript: {e}")
-
-    def _rename_meeting(self, mp3_path: Path, row: int):
-        """Rename a meeting (both MP3 and transcript files)."""
-        # Extract current name
-        name = mp3_path.stem
-        parts = name.split("_", 2)
-        current_name = parts[2] if len(parts) > 2 else ""
-
-        dialog = RenameDialog(current_name, self)
-        if dialog.exec() != QDialog.DialogCode.Accepted:
-            return
-
-        new_name = dialog.get_name()
-        if not new_name:
-            return
-
-        # Sanitize new name
-        import re
-        sanitized = new_name.replace(" ", "_")
-        sanitized = re.sub(r"[^\w\-]", "", sanitized)
-        if len(sanitized) > 50:
-            sanitized = sanitized[:50].rstrip("_-")
-
-        # Build new filename
-        if len(parts) >= 2:
-            new_stem = f"{parts[0]}_{parts[1]}_{sanitized}"
-        else:
-            new_stem = f"{name}_{sanitized}"
-
-        new_mp3_path = mp3_path.with_stem(new_stem)
-        transcript_path = self._get_transcript_path(mp3_path)
-        new_transcript_path = self._get_transcript_path(new_mp3_path)
-
-        try:
-            # Rename MP3
-            mp3_path.rename(new_mp3_path)
-
-            # Rename transcript if exists
-            if transcript_path.exists():
-                transcript_path.rename(new_transcript_path)
-
-            self.refresh()
-        except Exception as e:
-            QMessageBox.warning(self, "Error", f"Could not rename files: {e}")
-
-    def _transcribe_recording(self, mp3_path: Path):
-        """Transcribe a recording that doesn't have a transcript."""
-        from PyQt6.QtCore import QThread, pyqtSignal
-
-        class TranscribeWorker(QThread):
-            finished = pyqtSignal(bool, str)
-
-            def __init__(self, audio_path, config):
-                super().__init__()
-                self.audio_path = audio_path
-                self.config = config
-
-            def run(self):
-                try:
-                    from meeting_noter.transcription.engine import transcribe_file
-                    transcribe_file(
-                        str(self.audio_path),
-                        self.config.recordings_dir,
-                        self.config.whisper_model,
-                        self.config.transcripts_dir,
-                    )
-                    self.finished.emit(True, "")
-                except Exception as e:
-                    self.finished.emit(False, str(e))
-
-        def on_finished(success, error):
-            self._transcribe_worker = None
-            if success:
-                QMessageBox.information(self, "Success", f"Transcription complete: {mp3_path.name}")
-                self.refresh()
-            else:
-                QMessageBox.warning(self, "Error", f"Transcription failed: {error}")
-
-        # Show progress
-        QMessageBox.information(self, "Transcribing", f"Transcribing {mp3_path.name}...\nThis may take a while.")
-
-        self._transcribe_worker = TranscribeWorker(mp3_path, self.config)
-        self._transcribe_worker.finished.connect(on_finished)
-        self._transcribe_worker.start()
-
-    def _open_folder(self):
-        """Open the recordings folder in Finder."""
-        recordings_dir = self.config.recordings_dir
-        recordings_dir.mkdir(parents=True, exist_ok=True)
-        subprocess.run(["open", str(recordings_dir)])

meeting_noter/gui/recording_tab.py

@@ -1,358 +0,0 @@
-"""Recording tab for starting/stopping meeting recordings."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-from PyQt6.QtCore import Qt, QThread, pyqtSignal, QTimer
-from PyQt6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QLabel,
-    QLineEdit,
-    QPushButton,
-    QTextEdit,
-    QGroupBox,
-)
-
-from meeting_noter.config import get_config, generate_meeting_name, is_default_meeting_name
-
-
-class RecordingWorker(QThread):
-    """Background worker thread for audio recording."""
-
-    log_message = pyqtSignal(str)
-    recording_started = pyqtSignal(str)  # filepath
-    recording_stopped = pyqtSignal(str, float)  # filepath, duration
-    silence_stopped = pyqtSignal()  # stopped due to silence
-    error = pyqtSignal(str)
-
-    def __init__(self, output_dir: Path, meeting_name: str, silence_timeout_minutes: int = 5):
-        super().__init__()
-        self.output_dir = output_dir
-        self.meeting_name = meeting_name
-        self.silence_timeout_minutes = silence_timeout_minutes
-        self._stop_requested = False
-        self.saved_filepath: Optional[Path] = None
-
-    def run(self):
-        """Run the recording in background thread."""
-        # Import audio modules in thread
-        try:
-            from meeting_noter.audio.capture import SilenceDetector
-            from meeting_noter.audio.system_audio import CombinedAudioCapture
-            from meeting_noter.audio.encoder import RecordingSession
-        except ImportError as e:
-            self.error.emit(f"Import error: {e}")
-            return
-
-        from meeting_noter.daemon import check_audio_available
-        if not check_audio_available():
-            self.error.emit("No audio input device found. Please check your microphone.")
-            return
-
-        try:
-            # Use CombinedAudioCapture for mic + system audio
-            capture = CombinedAudioCapture()
-            capture.start()
-        except Exception as e:
-            self.error.emit(f"Audio capture error: {e}")
-            return
-
-        session = RecordingSession(
-            self.output_dir,
-            sample_rate=capture.sample_rate,
-            channels=capture.channels,
-            meeting_name=self.meeting_name,
-        )
-
-        # Silence detection
-        silence_detector = SilenceDetector(
-            threshold=0.01,
-            silence_duration=self.silence_timeout_minutes * 60.0,
-            sample_rate=capture.sample_rate,
-        )
-        stopped_by_silence = False
-
-        # Log capture mode
-        if capture.has_system_audio:
-            self.log_message.emit("Capturing: microphone + system audio")
-        else:
-            self.log_message.emit("Capturing: microphone only")
-
-        try:
-            filepath = session.start()
-            self.recording_started.emit(str(filepath))
-            self.log_message.emit(f"Will stop after {self.silence_timeout_minutes} min of silence")
-
-            while not self._stop_requested:
-                audio = capture.get_audio(timeout=0.5)
-                if audio is None:
-                    continue
-
-                if audio.ndim > 1:
-                    audio = audio.flatten()
-
-                session.write(audio)
-
-                # Check for extended silence
-                if silence_detector.update(audio):
-                    self.log_message.emit("Stopped: silence timeout reached")
-                    stopped_by_silence = True
-                    break
-
-        except Exception as e:
-            self.error.emit(f"Recording error: {e}")
-        finally:
-            capture.stop()
-
-            if session.is_active:
-                filepath, duration = session.stop()
-                if filepath:
-                    self.saved_filepath = filepath
-                    self.recording_stopped.emit(str(filepath), duration)
-                    if stopped_by_silence:
-                        self.silence_stopped.emit()
-                else:
-                    self.log_message.emit("Recording discarded (too short)")
-
-    def stop(self):
-        """Request the recording to stop."""
-        self._stop_requested = True
-
-
-class RecordingTab(QWidget):
-    """Tab for recording meetings."""
-
-    recording_saved = pyqtSignal()
-
-    def __init__(self):
-        super().__init__()
-        self.config = get_config()
-        self.worker: Optional[RecordingWorker] = None
-        self.is_recording = False
-
-        self._setup_ui()
-        self._setup_meeting_detection()
-
-    def _setup_ui(self):
-        """Set up the user interface."""
-        layout = QVBoxLayout(self)
-        layout.setSpacing(16)
-
-        # Meeting name input
-        name_group = QGroupBox("Meeting Name")
-        name_layout = QHBoxLayout(name_group)
-
-        self.name_input = QLineEdit()
-        self.name_input.setPlaceholderText("Enter meeting name or leave blank to auto-detect")
-        self.name_input.returnPressed.connect(self._on_start_clicked)
-        name_layout.addWidget(self.name_input)
-
-        self.detect_button = QPushButton("Detect")
-        self.detect_button.setMaximumWidth(80)
-        self.detect_button.clicked.connect(self._detect_meeting)
-        name_layout.addWidget(self.detect_button)
-
-        layout.addWidget(name_group)
-
-        # Control buttons
-        button_layout = QHBoxLayout()
-
-        self.start_button = QPushButton("Start Recording")
-        self.start_button.setMinimumHeight(50)
-        self.start_button.clicked.connect(self._on_start_clicked)
-        button_layout.addWidget(self.start_button)
-
-        self.stop_button = QPushButton("Stop Recording")
-        self.stop_button.setMinimumHeight(50)
-        self.stop_button.setEnabled(False)
-        self.stop_button.clicked.connect(self._on_stop_clicked)
-        button_layout.addWidget(self.stop_button)
-
-        layout.addLayout(button_layout)
-
-        # Status
-        self.status_label = QLabel("Ready to record")
-        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self.status_label.setStyleSheet("font-size: 14px; padding: 10px;")
-        layout.addWidget(self.status_label)
-
-        # Log output
-        log_group = QGroupBox("Log")
-        log_layout = QVBoxLayout(log_group)
-
-        self.log_output = QTextEdit()
-        self.log_output.setReadOnly(True)
-        self.log_output.setMaximumHeight(200)
-        log_layout.addWidget(self.log_output)
-
-        layout.addWidget(log_group)
-
-        # Stretch to push everything up
-        layout.addStretch()
-
-    def _setup_meeting_detection(self):
-        """Set up periodic meeting detection."""
-        self._detection_timer = QTimer()
-        self._detection_timer.timeout.connect(self._check_for_meeting)
-        self._detection_timer.start(3000)  # Check every 3 seconds
-
-        # Initial check
-        self._detect_meeting()
-
-    def _check_for_meeting(self):
-        """Check for active meeting and update UI if not recording."""
-        if self.is_recording:
-            return
-
-        # Only auto-update if field is empty or has default timestamp
-        current = self.name_input.text().strip()
-        if current and not is_default_meeting_name(current):
-            return
-
-        try:
-            from meeting_noter.meeting_detector import detect_active_meeting
-            meeting = detect_active_meeting()
-            if meeting and meeting.meeting_name:
-                self.name_input.setText(meeting.meeting_name)
-                self.status_label.setText(f"Meeting detected: {meeting.app_name}")
-        except Exception:
-            pass
-
-    def _detect_meeting(self):
-        """Manually detect current meeting."""
-        try:
-            from meeting_noter.meeting_detector import detect_active_meeting
-            meeting = detect_active_meeting()
-            if meeting:
-                name = meeting.meeting_name or meeting.app_name
-                self.name_input.setText(name)
-                self._log(f"Detected: {meeting.app_name} - {name}")
-            else:
-                self.name_input.setText(generate_meeting_name())
-                self._log("No meeting detected, using timestamp")
-        except Exception as e:
-            self._log(f"Detection error: {e}")
-            self.name_input.setText(generate_meeting_name())
-
-    def _on_start_clicked(self):
-        """Handle start button click."""
-        meeting_name = self.name_input.text().strip()
-
-        # Auto-detect or generate name if empty
-        if not meeting_name:
-            try:
-                from meeting_noter.meeting_detector import detect_active_meeting
-                meeting = detect_active_meeting()
-                if meeting and meeting.meeting_name:
-                    meeting_name = meeting.meeting_name
-                else:
-                    meeting_name = generate_meeting_name()
-            except Exception:
-                meeting_name = generate_meeting_name()
-            self.name_input.setText(meeting_name)
-
-        self.start_recording(meeting_name)
-
-    def _on_stop_clicked(self):
-        """Handle stop button click."""
-        self.stop_recording()
-
-    def start_recording(self, meeting_name: str):
-        """Start a new recording."""
-        if self.is_recording:
-            return
-
-        self.is_recording = True
-        self.start_button.setEnabled(False)
-        self.stop_button.setEnabled(True)
-        self.name_input.setEnabled(False)
-        self.detect_button.setEnabled(False)
-
-        self.status_label.setText(f"Recording: {meeting_name}")
-        self.status_label.setStyleSheet(
-            "font-size: 14px; padding: 10px; color: white; background-color: #c0392b;"
-        )
-
-        self.log_output.clear()
-        self._log(f"Starting recording: {meeting_name}")
-
-        # Start worker thread
-        output_dir = self.config.recordings_dir
-        output_dir.mkdir(parents=True, exist_ok=True)
-
-        self.worker = RecordingWorker(
-            output_dir,
-            meeting_name,
-            silence_timeout_minutes=self.config.silence_timeout,
-        )
-        self.worker.log_message.connect(self._log)
-        self.worker.recording_started.connect(self._on_recording_started)
-        self.worker.recording_stopped.connect(self._on_recording_stopped)
-        self.worker.error.connect(self._on_error)
-        self.worker.finished.connect(self._on_worker_finished)
-        self.worker.start()
-
-    def stop_recording(self):
-        """Stop the current recording."""
-        if not self.is_recording or not self.worker:
-            return
-
-        self._log("Stopping recording...")
-        self.worker.stop()
-        self.worker.wait(5000)  # Wait up to 5 seconds
-
-    def _on_recording_started(self, filepath: str):
-        """Handle recording started."""
-        self._log(f"Recording to: {Path(filepath).name}")
-
-    def _on_recording_stopped(self, filepath: str, duration: float):
-        """Handle recording stopped."""
-        mins, secs = divmod(int(duration), 60)
-        self._log(f"Saved: {Path(filepath).name} ({mins:02d}:{secs:02d})")
-
-        # Auto-transcribe if enabled
-        if self.config.auto_transcribe:
-            self._log("Auto-transcribing...")
-            try:
-                from meeting_noter.transcription.engine import transcribe_file
-                transcribe_file(
-                    filepath,
-                    self.config.recordings_dir,
-                    self.config.whisper_model,
-                    self.config.transcripts_dir,
-                )
-                self._log("Transcription complete")
-            except Exception as e:
-                self._log(f"Transcription error: {e}")
-
-        self.recording_saved.emit()
-
-    def _on_error(self, message: str):
-        """Handle error from worker."""
-        self._log(f"Error: {message}")
-        self.status_label.setText(f"Error: {message}")
-        self.status_label.setStyleSheet("font-size: 14px; padding: 10px; color: red;")
-
-    def _on_worker_finished(self):
-        """Handle worker thread finished."""
-        self.is_recording = False
-        self.start_button.setEnabled(True)
-        self.stop_button.setEnabled(False)
-        self.name_input.setEnabled(True)
-        self.detect_button.setEnabled(True)
-
-        # Clear the name field for next recording
-        self.name_input.clear()
-
-        self.status_label.setText("Ready to record")
-        self.status_label.setStyleSheet("font-size: 14px; padding: 10px;")
-
-        self.worker = None
-
-    def _log(self, message: str):
-        """Add a message to the log output."""
-        self.log_output.append(message)