meeting-noter 2.0.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

meeting_noter/gui/screens/recordings.py

@@ -0,0 +1,279 @@
+"""Recordings browser screen for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from meeting_noter.config import get_config
+from meeting_noter.gui.utils.signals import get_app_state
+from meeting_noter.output.writer import format_duration, format_size, get_audio_duration
+
+
+@dataclass
+class RecordingInfo:
+    """Information about a recording."""
+
+    filepath: Path
+    date: datetime
+    duration: Optional[float]
+    size: int
+    has_transcript: bool
+    is_favorite: bool
+
+
+class RecordingsScreen(QWidget):
+    """Screen for browsing and managing recordings."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._recordings: list[RecordingInfo] = []
+        self._setup_ui()
+        self._connect_signals()
+
+    def _setup_ui(self):
+        """Set up the recordings UI."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(30, 30, 30, 30)
+        layout.setSpacing(20)
+
+        # Title
+        title = QLabel("Recordings")
+        title.setStyleSheet("font-size: 24px; font-weight: 600; color: #ffffff;")
+        layout.addWidget(title)
+
+        # Table
+        self._table = QTableWidget()
+        self._table.setColumnCount(6)
+        self._table.setHorizontalHeaderLabels(
+            ["\u2605", "Date", "Duration", "Size", "Transcript", "File"]
+        )
+        self._table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self._table.setSelectionMode(QAbstractItemView.SingleSelection)
+        self._table.setAlternatingRowColors(True)
+        self._table.setSortingEnabled(True)
+        self._table.verticalHeader().setVisible(False)
+
+        # Column widths
+        header = self._table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.Fixed)
+        header.resizeSection(0, 40)
+        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(3, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(4, QHeaderView.ResizeToContents)
+        header.setSectionResizeMode(5, QHeaderView.Stretch)
+
+        self._table.doubleClicked.connect(self._on_row_double_clicked)
+        layout.addWidget(self._table, 1)
+
+        # Action buttons
+        button_row = QHBoxLayout()
+        button_row.setSpacing(10)
+
+        self._view_btn = QPushButton("View Transcript")
+        self._transcribe_btn = QPushButton("Transcribe")
+        self._favorite_btn = QPushButton("\u2605 Favorite")
+        self._refresh_btn = QPushButton("Refresh")
+        self._refresh_btn.setProperty("class", "secondary")
+        self._refresh_btn.setStyleSheet("background-color: #3c3c3c;")
+
+        button_row.addWidget(self._view_btn)
+        button_row.addWidget(self._transcribe_btn)
+        button_row.addWidget(self._favorite_btn)
+        button_row.addStretch()
+        button_row.addWidget(self._refresh_btn)
+        layout.addLayout(button_row)
+
+        # Status label
+        self._status_label = QLabel("")
+        self._status_label.setStyleSheet("color: #858585;")
+        layout.addWidget(self._status_label)
+
+    def _connect_signals(self):
+        """Connect button signals."""
+        self._view_btn.clicked.connect(self._view_transcript)
+        self._transcribe_btn.clicked.connect(self._transcribe_selected)
+        self._favorite_btn.clicked.connect(self._toggle_favorite)
+        self._refresh_btn.clicked.connect(self.refresh)
+
+    def refresh(self):
+        """Refresh the recordings list."""
+        self._load_recordings()
+        self._populate_table()
+
+    def _load_recordings(self):
+        """Load recordings from disk."""
+        config = get_config()
+        recordings_dir = config.recordings_dir
+
+        if not recordings_dir.exists():
+            self._recordings = []
+            return
+
+        recordings = []
+        mp3_files = sorted(
+            recordings_dir.glob("*.mp3"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:50]  # Limit to 50
+
+        for mp3_path in mp3_files:
+            try:
+                stat = mp3_path.stat()
+                date = datetime.fromtimestamp(stat.st_mtime)
+                size = stat.st_size
+
+                # Check for transcript
+                transcript_name = mp3_path.stem + ".txt"
+                transcript_path = config.transcripts_dir / transcript_name
+                has_transcript = transcript_path.exists()
+
+                # Get duration
+                try:
+                    duration = get_audio_duration(mp3_path)
+                except Exception:
+                    duration = None
+
+                # Check favorite status
+                is_favorite = config.is_favorite(mp3_path.name)
+
+                recordings.append(
+                    RecordingInfo(
+                        filepath=mp3_path,
+                        date=date,
+                        duration=duration,
+                        size=size,
+                        has_transcript=has_transcript,
+                        is_favorite=is_favorite,
+                    )
+                )
+            except Exception:
+                continue
+
+        self._recordings = recordings
+
+    def _populate_table(self):
+        """Populate the table with recordings."""
+        self._table.setRowCount(len(self._recordings))
+
+        for row, rec in enumerate(self._recordings):
+            # Favorite star
+            star_item = QTableWidgetItem("\u2605" if rec.is_favorite else "")
+            star_item.setTextAlignment(Qt.AlignCenter)
+            star_item.setData(Qt.UserRole, rec.filepath)
+            self._table.setItem(row, 0, star_item)
+
+            # Date
+            date_item = QTableWidgetItem(rec.date.strftime("%Y-%m-%d %H:%M"))
+            self._table.setItem(row, 1, date_item)
+
+            # Duration
+            if rec.duration:
+                duration_str = format_duration(rec.duration)
+            else:
+                duration_str = "?"
+            duration_item = QTableWidgetItem(duration_str)
+            duration_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            self._table.setItem(row, 2, duration_item)
+
+            # Size
+            size_item = QTableWidgetItem(format_size(rec.size))
+            size_item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            self._table.setItem(row, 3, size_item)
+
+            # Transcript
+            transcript_item = QTableWidgetItem("Yes" if rec.has_transcript else "No")
+            transcript_item.setTextAlignment(Qt.AlignCenter)
+            if rec.has_transcript:
+                transcript_item.setForeground(Qt.green)
+            self._table.setItem(row, 4, transcript_item)
+
+            # Filename
+            file_item = QTableWidgetItem(rec.filepath.name)
+            self._table.setItem(row, 5, file_item)
+
+        self._status_label.setText(f"{len(self._recordings)} recordings")
+
+    def _get_selected_recording(self) -> Optional[RecordingInfo]:
+        """Get the currently selected recording."""
+        row = self._table.currentRow()
+        if 0 <= row < len(self._recordings):
+            return self._recordings[row]
+        return None
+
+    def _view_transcript(self):
+        """View the transcript for the selected recording."""
+        rec = self._get_selected_recording()
+        if not rec:
+            return
+
+        if not rec.has_transcript:
+            self._status_label.setText("No transcript available. Transcribe first.")
+            return
+
+        config = get_config()
+        transcript_path = config.transcripts_dir / (rec.filepath.stem + ".txt")
+
+        if transcript_path.exists():
+            app_state = get_app_state()
+            app_state.open_transcript.emit(str(transcript_path))
+
+    def _on_row_double_clicked(self):
+        """Handle double-click on a row."""
+        self._view_transcript()
+
+    def _transcribe_selected(self):
+        """Transcribe the selected recording."""
+        rec = self._get_selected_recording()
+        if not rec:
+            return
+
+        if rec.has_transcript:
+            self._status_label.setText("Already transcribed.")
+            return
+
+        self._status_label.setText(f"Transcribing {rec.filepath.name}...")
+
+        # Run transcription in subprocess
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.cli", "transcribe", str(rec.filepath)],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        self._status_label.setText(f"Transcription started for {rec.filepath.name}")
+
+    def _toggle_favorite(self):
+        """Toggle favorite status for the selected recording."""
+        rec = self._get_selected_recording()
+        if not rec:
+            return
+
+        config = get_config()
+        if rec.is_favorite:
+            config.remove_favorite(rec.filepath.name)
+            self._status_label.setText(f"Removed from favorites: {rec.filepath.name}")
+        else:
+            config.add_favorite(rec.filepath.name)
+            self._status_label.setText(f"Added to favorites: {rec.filepath.name}")
+
+        # Refresh to update star display
+        self.refresh()

meeting_noter/gui/screens/search.py

@@ -0,0 +1,229 @@
+"""Search screen for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from meeting_noter.config import get_config
+from meeting_noter.gui.utils.signals import get_app_state
+
+
+@dataclass
+class SearchMatch:
+    """A search match result."""
+
+    filepath: Path
+    line_number: int
+    timestamp: str
+    text: str
+
+
+@dataclass
+class FileSearchResult:
+    """Search results for a single file."""
+
+    filepath: Path
+    matches: list[SearchMatch]
+
+
+class SearchScreen(QWidget):
+    """Screen for searching transcripts."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._results: list[FileSearchResult] = []
+        self._setup_ui()
+        self._connect_signals()
+
+    def _setup_ui(self):
+        """Set up the search UI."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(30, 30, 30, 30)
+        layout.setSpacing(20)
+
+        # Title
+        title = QLabel("Search Transcripts")
+        title.setStyleSheet("font-size: 24px; font-weight: 600; color: #ffffff;")
+        layout.addWidget(title)
+
+        # Search row
+        search_row = QHBoxLayout()
+        search_row.setSpacing(10)
+
+        self._search_input = QLineEdit()
+        self._search_input.setPlaceholderText("Enter search query...")
+        self._search_input.returnPressed.connect(self._do_search)
+
+        self._search_btn = QPushButton("Search")
+        self._search_btn.setFixedWidth(100)
+
+        search_row.addWidget(self._search_input, 1)
+        search_row.addWidget(self._search_btn)
+        layout.addLayout(search_row)
+
+        # Options row
+        options_row = QHBoxLayout()
+        self._case_sensitive = QCheckBox("Case sensitive")
+        options_row.addWidget(self._case_sensitive)
+        options_row.addStretch()
+        layout.addLayout(options_row)
+
+        # Results header
+        self._results_header = QLabel("")
+        self._results_header.setStyleSheet("color: #4ec9b0; font-weight: 500;")
+        layout.addWidget(self._results_header)
+
+        # Results list
+        self._results_list = QListWidget()
+        self._results_list.itemDoubleClicked.connect(self._on_result_clicked)
+        layout.addWidget(self._results_list, 1)
+
+        # Results footer
+        self._results_footer = QLabel("")
+        self._results_footer.setStyleSheet("color: #858585;")
+        layout.addWidget(self._results_footer)
+
+    def _connect_signals(self):
+        """Connect button signals."""
+        self._search_btn.clicked.connect(self._do_search)
+
+    def _do_search(self):
+        """Perform the search."""
+        query = self._search_input.text().strip()
+        if not query:
+            return
+
+        config = get_config()
+        transcripts_dir = config.transcripts_dir
+
+        if not transcripts_dir.exists():
+            self._results_header.setText("No transcripts directory found")
+            self._results_header.setStyleSheet("color: #f14c4c;")
+            return
+
+        case_sensitive = self._case_sensitive.isChecked()
+        results = self._search_files(transcripts_dir, query, case_sensitive)
+
+        self._results = results
+        self._display_results(query)
+
+    def _search_files(
+        self, directory: Path, query: str, case_sensitive: bool
+    ) -> list[FileSearchResult]:
+        """Search all transcript files for the query."""
+        results = []
+
+        txt_files = sorted(
+            directory.glob("*.txt"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+
+        search_query = query if case_sensitive else query.lower()
+
+        for filepath in txt_files:
+            try:
+                content = filepath.read_text()
+                lines = content.splitlines()
+
+                matches = []
+                for i, line in enumerate(lines):
+                    check_line = line if case_sensitive else line.lower()
+                    if search_query in check_line:
+                        # Extract timestamp if present
+                        timestamp = ""
+                        text = line
+                        if line.startswith("[") and "]" in line:
+                            bracket_end = line.index("]")
+                            timestamp = line[1:bracket_end]
+                            text = line[bracket_end + 1 :].strip()
+
+                        matches.append(
+                            SearchMatch(
+                                filepath=filepath,
+                                line_number=i + 1,
+                                timestamp=timestamp,
+                                text=text[:80] + "..." if len(text) > 80 else text,
+                            )
+                        )
+
+                        if len(matches) >= 5:  # Limit matches per file
+                            break
+
+                if matches:
+                    results.append(FileSearchResult(filepath=filepath, matches=matches))
+
+            except Exception:
+                continue
+
+        # Sort by match count
+        results.sort(key=lambda r: len(r.matches), reverse=True)
+        return results[:50]  # Limit total results
+
+    def _display_results(self, query: str):
+        """Display search results."""
+        self._results_list.clear()
+
+        total_matches = sum(len(r.matches) for r in self._results)
+
+        if not self._results:
+            self._results_header.setText(f"No matches found for '{query}'")
+            self._results_header.setStyleSheet("color: #dcdcaa;")
+            self._results_footer.setText("")
+            return
+
+        self._results_header.setText(
+            f"Found {total_matches} matches in {len(self._results)} transcripts"
+        )
+        self._results_header.setStyleSheet("color: #4ec9b0;")
+
+        for result in self._results:
+            # File header
+            header_item = QListWidgetItem(
+                f"\u25b6 {result.filepath.name} ({len(result.matches)} matches)"
+            )
+            header_item.setData(Qt.UserRole, str(result.filepath))
+            header_item.setForeground(Qt.green)
+            font = header_item.font()
+            font.setBold(True)
+            header_item.setFont(font)
+            self._results_list.addItem(header_item)
+
+            # Match items
+            for match in result.matches:
+                if match.timestamp:
+                    text = f"    [{match.timestamp}] {match.text}"
+                else:
+                    text = f"    {match.text}"
+
+                match_item = QListWidgetItem(text)
+                match_item.setData(Qt.UserRole, str(result.filepath))
+                self._results_list.addItem(match_item)
+
+        self._results_footer.setText(f"Searched {len(self._results)} transcripts")
+
+    def _on_result_clicked(self, item: QListWidgetItem):
+        """Handle click on a result item."""
+        filepath = item.data(Qt.UserRole)
+        if filepath:
+            app_state = get_app_state()
+            app_state.open_transcript.emit(filepath)
+
+    def refresh(self):
+        """Refresh the search (focus the input)."""
+        self._search_input.setFocus()