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

meeting_noter/gui/settings_tab.py

@@ -1,249 +0,0 @@
-"""Settings tab for configuring Meeting Noter."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-from PyQt6.QtCore import pyqtSignal
-from PyQt6.QtWidgets import (
-    QWidget,
-    QVBoxLayout,
-    QHBoxLayout,
-    QFormLayout,
-    QLabel,
-    QLineEdit,
-    QPushButton,
-    QComboBox,
-    QCheckBox,
-    QGroupBox,
-    QFileDialog,
-    QMessageBox,
-    QSpinBox,
-)
-
-from meeting_noter.config import get_config
-from meeting_noter.daemon import read_pid_file, is_process_running
-
-
-class SettingsTab(QWidget):
-    """Tab for configuring application settings."""
-
-    settings_saved = pyqtSignal()
-
-    def __init__(self):
-        super().__init__()
-        self.config = get_config()
-        self._setup_ui()
-        self._load_settings()
-
-    def _setup_ui(self):
-        """Set up the user interface."""
-        layout = QVBoxLayout(self)
-        layout.setSpacing(16)
-
-        # Directories group
-        dirs_group = QGroupBox("Directories")
-        dirs_layout = QFormLayout(dirs_group)
-
-        # Recordings directory
-        recordings_layout = QHBoxLayout()
-        self.recordings_input = QLineEdit()
-        self.recordings_input.setReadOnly(True)
-        recordings_layout.addWidget(self.recordings_input)
-
-        recordings_browse = QPushButton("Browse...")
-        recordings_browse.clicked.connect(self._browse_recordings_dir)
-        recordings_layout.addWidget(recordings_browse)
-
-        dirs_layout.addRow("Recordings:", recordings_layout)
-
-        # Transcripts directory
-        transcripts_layout = QHBoxLayout()
-        self.transcripts_input = QLineEdit()
-        self.transcripts_input.setReadOnly(True)
-        transcripts_layout.addWidget(self.transcripts_input)
-
-        transcripts_browse = QPushButton("Browse...")
-        transcripts_browse.clicked.connect(self._browse_transcripts_dir)
-        transcripts_layout.addWidget(transcripts_browse)
-
-        dirs_layout.addRow("Transcripts:", transcripts_layout)
-
-        layout.addWidget(dirs_group)
-
-        # Transcription group
-        transcription_group = QGroupBox("Transcription")
-        transcription_layout = QFormLayout(transcription_group)
-
-        # Whisper model
-        self.model_combo = QComboBox()
-        self.model_combo.addItems([
-            "tiny.en",
-            "base.en",
-            "small.en",
-            "medium.en",
-            "large-v3",
-        ])
-        transcription_layout.addRow("Whisper Model:", self.model_combo)
-
-        # Model descriptions
-        model_desc = QLabel(
-            "tiny.en: Fastest, least accurate (~1GB RAM)\n"
-            "base.en: Fast, decent accuracy (~1GB RAM)\n"
-            "small.en: Good balance (~2GB RAM)\n"
-            "medium.en: Better accuracy (~5GB RAM)\n"
-            "large-v3: Best accuracy (~10GB RAM)"
-        )
-        model_desc.setStyleSheet("color: gray; font-size: 11px;")
-        transcription_layout.addRow("", model_desc)
-
-        # Auto-transcribe
-        self.auto_transcribe_checkbox = QCheckBox("Automatically transcribe after recording stops")
-        transcription_layout.addRow("", self.auto_transcribe_checkbox)
-
-        layout.addWidget(transcription_group)
-
-        # Recording group
-        recording_group = QGroupBox("Recording")
-        recording_layout = QFormLayout(recording_group)
-
-        # Silence timeout
-        silence_layout = QHBoxLayout()
-        self.silence_timeout_spin = QSpinBox()
-        self.silence_timeout_spin.setRange(1, 60)
-        self.silence_timeout_spin.setSuffix(" minutes")
-        self.silence_timeout_spin.setToolTip("Stop recording after this many minutes of silence")
-        silence_layout.addWidget(self.silence_timeout_spin)
-        silence_layout.addStretch()
-
-        recording_layout.addRow("Silence timeout:", silence_layout)
-
-        silence_desc = QLabel("Recording stops automatically after this duration of silence")
-        silence_desc.setStyleSheet("color: gray; font-size: 11px;")
-        recording_layout.addRow("", silence_desc)
-
-        layout.addWidget(recording_group)
-
-        # Appearance group
-        appearance_group = QGroupBox("Appearance")
-        appearance_layout = QFormLayout(appearance_group)
-
-        self.show_menubar_checkbox = QCheckBox("Show menu bar icon (MN)")
-        appearance_layout.addRow("", self.show_menubar_checkbox)
-
-        layout.addWidget(appearance_group)
-
-        # Save button
-        button_layout = QHBoxLayout()
-        button_layout.addStretch()
-
-        self.save_button = QPushButton("Save Settings")
-        self.save_button.setMinimumWidth(120)
-        self.save_button.clicked.connect(self._save_settings)
-        button_layout.addWidget(self.save_button)
-
-        layout.addLayout(button_layout)
-
-        # Stretch to push everything up
-        layout.addStretch()
-
-    def _load_settings(self):
-        """Load current settings into the UI."""
-        self.recordings_input.setText(str(self.config.recordings_dir))
-        self.transcripts_input.setText(str(self.config.transcripts_dir))
-
-        # Set combo box to current model
-        model = self.config.whisper_model
-        index = self.model_combo.findText(model)
-        if index >= 0:
-            self.model_combo.setCurrentIndex(index)
-
-        self.auto_transcribe_checkbox.setChecked(self.config.auto_transcribe)
-        self.silence_timeout_spin.setValue(self.config.silence_timeout)
-        self.show_menubar_checkbox.setChecked(self.config.show_menubar)
-
-    def _browse_recordings_dir(self):
-        """Browse for recordings directory."""
-        current = self.recordings_input.text()
-        directory = QFileDialog.getExistingDirectory(
-            self,
-            "Select Recordings Directory",
-            current,
-        )
-        if directory:
-            self.recordings_input.setText(directory)
-
-    def _browse_transcripts_dir(self):
-        """Browse for transcripts directory."""
-        current = self.transcripts_input.text()
-        directory = QFileDialog.getExistingDirectory(
-            self,
-            "Select Transcripts Directory",
-            current,
-        )
-        if directory:
-            self.transcripts_input.setText(directory)
-
-    def _save_settings(self):
-        """Save settings to config file."""
-        recordings_dir = Path(self.recordings_input.text())
-        transcripts_dir = Path(self.transcripts_input.text())
-
-        # Validate directories
-        try:
-            recordings_dir.mkdir(parents=True, exist_ok=True)
-            transcripts_dir.mkdir(parents=True, exist_ok=True)
-        except Exception as e:
-            QMessageBox.warning(self, "Error", f"Could not create directories: {e}")
-            return
-
-        # Check if menubar setting changed
-        old_show_menubar = self.config.show_menubar
-        new_show_menubar = self.show_menubar_checkbox.isChecked()
-
-        # Update config
-        self.config.recordings_dir = recordings_dir
-        self.config.transcripts_dir = transcripts_dir
-        self.config.whisper_model = self.model_combo.currentText()
-        self.config.auto_transcribe = self.auto_transcribe_checkbox.isChecked()
-        self.config.silence_timeout = self.silence_timeout_spin.value()
-        self.config.show_menubar = new_show_menubar
-
-        try:
-            self.config.save()
-
-            # Handle menubar start/stop
-            if new_show_menubar and not old_show_menubar:
-                self._start_menubar()
-            elif not new_show_menubar and old_show_menubar:
-                self._stop_menubar()
-
-            self.settings_saved.emit()
-            QMessageBox.information(self, "Success", "Settings saved successfully.")
-        except Exception as e:
-            QMessageBox.warning(self, "Error", f"Could not save settings: {e}")
-
-    def _start_menubar(self):
-        """Start the menu bar app in background."""
-        subprocess.Popen(
-            [sys.executable, "-m", "meeting_noter.menubar"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            start_new_session=True,
-        )
-
-    def _stop_menubar(self):
-        """Stop the menu bar app if running."""
-        import os
-        import signal
-
-        menubar_pid_file = Path.home() / ".meeting-noter-menubar.pid"
-
-        pid = read_pid_file(menubar_pid_file)
-        if pid and is_process_running(pid):
-            try:
-                os.kill(pid, signal.SIGTERM)
-            except (OSError, ProcessLookupError):
-                pass

meeting_noter/menubar.py

@@ -1,411 +0,0 @@
-"""Menu bar app for Meeting Noter daemon control."""
-
-from __future__ import annotations
-
-import atexit
-import os
-import subprocess
-import threading
-from pathlib import Path
-from typing import Optional
-
-import rumps
-
-from meeting_noter.daemon import read_pid_file, is_process_running, stop_daemon
-from meeting_noter.config import get_config, generate_meeting_name
-from meeting_noter.mic_monitor import MicrophoneMonitor, get_meeting_window_title
-
-
-DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
-MENUBAR_PID_FILE = Path.home() / ".meeting-noter-menubar.pid"
-RECORDING_STATE_FILE = Path.home() / ".meeting-noter-recording.json"
-
-
-def _write_menubar_pid():
-    """Write the menubar PID file."""
-    with open(MENUBAR_PID_FILE, "w") as f:
-        f.write(str(os.getpid()))
-
-
-def _remove_menubar_pid():
-    """Remove the menubar PID file."""
-    try:
-        MENUBAR_PID_FILE.unlink()
-    except FileNotFoundError:
-        pass
-
-
-class MeetingNoterApp(rumps.App):
-    """Menu bar app for controlling the Meeting Noter daemon."""
-
-    def __init__(self):
-        super().__init__("Meeting Noter", title="▷")
-        self.pid_file = DEFAULT_PID_FILE
-        self.config = get_config()
-        self.mic_monitor = MicrophoneMonitor()
-        self.current_meeting_name: Optional[str] = None
-        self.pending_notification = False  # Avoid duplicate notifications
-        self._pending_app_name: Optional[str] = None
-        self.menu = [
-            "Start Recording",
-            "Stop Recording",
-            None,  # Separator
-            "Open Recordings",
-            "Open UI",
-        ]
-        self._update_title()
-
-    def _is_running(self) -> bool:
-        """Check if daemon is currently running."""
-        pid = read_pid_file(self.pid_file)
-        return pid is not None and is_process_running(pid)
-
-    def _get_current_recording_name(self) -> Optional[str]:
-        """Get the name of the current recording from the log file.
-
-        Parses the daemon log to find the most recent 'Recording started:' entry.
-        Returns the filename (without extension) or None if not recording.
-        """
-        if not self._is_running():
-            return None
-
-        log_path = Path.home() / ".meeting-noter.log"
-        if not log_path.exists():
-            return None
-
-        try:
-            with open(log_path, "r") as f:
-                lines = f.readlines()
-
-            # Find the most recent recording start/save
-            recording_name = None
-            for line in reversed(lines[-50:]):  # Check last 50 lines
-                if "Recording started:" in line:
-                    # Extract filename from "Recording started: filename.mp3"
-                    parts = line.split("Recording started:")
-                    if len(parts) > 1:
-                        filename = parts[1].strip()
-                        # Remove extension and timestamp prefix
-                        name = filename.replace(".mp3", "")
-                        # If format is timestamp_name, extract just the name
-                        parts = name.split("_", 2)  # Split max 2 times
-                        if len(parts) >= 3:
-                            # Format: YYYY-MM-DD_HHMMSS_MeetingName
-                            recording_name = parts[2]
-                        else:
-                            recording_name = name
-                        break
-                elif "Recording saved:" in line or "Recording discarded" in line:
-                    # Recording ended, no active recording
-                    break
-
-            return recording_name
-        except Exception:
-            return None
-
-    def _truncate_name(self, name: str, max_length: int = 15) -> str:
-        """Truncate a name to fit in the menu bar."""
-        if len(name) <= max_length:
-            return name
-        return name[:max_length - 1] + "..."
-
-    def _update_title(self):
-        """Update menu bar title based on daemon status."""
-        if self._is_running():
-            self.title = "▶"  # Filled triangle = recording
-        else:
-            self.title = "▷"  # Outline triangle = idle
-
-    def _save_recording_state(self, meeting_name: str, file_path: Optional[str] = None):
-        """Save current recording state to file."""
-        import json
-        state = {
-            "recording": True,
-            "meeting_name": meeting_name,
-            "file_path": file_path,
-        }
-        try:
-            with open(RECORDING_STATE_FILE, "w") as f:
-                json.dump(state, f)
-        except Exception:
-            pass
-
-    def _clear_recording_state(self):
-        """Clear recording state file."""
-        try:
-            RECORDING_STATE_FILE.unlink()
-        except FileNotFoundError:
-            pass
-
-    def _start_recording_with_name(self, meeting_name: str, app_name: Optional[str] = None):
-        """Start recording with a specific meeting name."""
-        import sys
-
-        if self._is_running():
-            return
-
-        self.current_meeting_name = meeting_name
-        self._save_recording_state(meeting_name)
-        self.mic_monitor.set_recording(True, app_name)
-
-        # Start daemon with the meeting name using current Python
-        subprocess.Popen(
-            [sys.executable, "-m", "meeting_noter.cli", "daemon", "--name", meeting_name],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-        self._update_title()
-
-    @rumps.clicked("Start Recording")
-    def start_recording(self, _):
-        """Start the daemon via subprocess."""
-        if self._is_running():
-            rumps.notification(
-                title="Meeting Noter",
-                subtitle="Already Running",
-                message="The daemon is already recording.",
-            )
-            return
-
-        meeting_name = generate_meeting_name()
-        self._start_recording_with_name(meeting_name)
-
-        rumps.notification(
-            title="Meeting Noter",
-            subtitle="Recording Started",
-            message=meeting_name,
-        )
-
-    def _get_latest_recording(self) -> Optional[Path]:
-        """Get the most recent recording file."""
-        recordings_dir = self.config.recordings_dir
-        if not recordings_dir.exists():
-            return None
-        mp3_files = sorted(recordings_dir.glob("*.mp3"), key=lambda p: p.stat().st_mtime)
-        return mp3_files[-1] if mp3_files else None
-
-    def _get_transcript_path(self, audio_path: Path) -> Path:
-        """Get the transcript path for an audio file."""
-        return self.config.transcripts_dir / audio_path.with_suffix(".txt").name
-
-    def _transcribe_in_background(self, audio_path: Path):
-        """Transcribe a recording in background subprocess."""
-        import sys
-        # Use subprocess to run transcription - more reliable than threading with rumps
-        subprocess.Popen(
-            [sys.executable, "-m", "meeting_noter.cli", "transcribe", str(audio_path)],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-    @rumps.clicked("Stop Recording")
-    def stop_recording(self, _):
-        """Stop the running daemon and optionally transcribe."""
-        if not self._is_running():
-            rumps.notification(
-                title="Meeting Noter",
-                subtitle="Not Running",
-                message="The daemon is not running.",
-            )
-            return
-
-        # Get latest recording before stopping (to compare after)
-        latest_before = self._get_latest_recording()
-        before_mtime = latest_before.stat().st_mtime if latest_before else 0
-
-        stop_daemon(self.pid_file)
-        self._update_title()
-
-        # Check for new recording after stopping
-        import time
-        time.sleep(2)  # Give daemon time to save file
-
-        # Reload config to get current settings
-        self.config.load()
-
-        latest_after = self._get_latest_recording()
-
-        # Check if there's a new or updated recording
-        is_new_recording = False
-        if latest_after:
-            after_mtime = latest_after.stat().st_mtime
-            if latest_before is None or str(latest_after) != str(latest_before) or after_mtime > before_mtime:
-                is_new_recording = True
-
-        # Clear recording state
-        self._clear_recording_state()
-        self.current_meeting_name = None
-
-        if is_new_recording:
-            # New recording was saved
-            if self.config.auto_transcribe:
-                rumps.notification(
-                    title="Meeting Noter",
-                    subtitle="Recording Saved",
-                    message=f"Transcribing {latest_after.name}...",
-                )
-                self._transcribe_in_background(latest_after)
-            else:
-                rumps.notification(
-                    title="Meeting Noter",
-                    subtitle="Recording Saved",
-                    message=latest_after.name,
-                )
-        else:
-            rumps.notification(
-                title="Meeting Noter",
-                subtitle="Stopped",
-                message="Recording daemon stopped.",
-            )
-
-    @rumps.clicked("Open Recordings")
-    def open_recordings(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)])
-
-    @rumps.clicked("Open UI")
-    def open_ui(self, _):
-        """Open the desktop GUI application."""
-        import sys
-        subprocess.Popen(
-            [sys.executable, "-m", "meeting_noter.cli", "gui"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-
-    @rumps.timer(2)
-    def poll_status(self, _):
-        """Periodically update the menu bar title and check for mic usage."""
-        self._update_title()
-
-        is_recording = self._is_running()
-
-        # Tell mic monitor our recording state
-        self.mic_monitor.set_recording(is_recording)
-
-        # Check for mic usage changes
-        mic_started, mic_stopped, app_name = self.mic_monitor.check()
-
-        # Auto-stop recording when mic stops being used
-        if mic_stopped and is_recording:
-            rumps.notification(
-                title="Meeting Noter",
-                subtitle="Call Ended",
-                message="Stopping recording...",
-            )
-            self._auto_stop_recording()
-            return
-
-        # Prompt to record when mic starts being used
-        if mic_started and not is_recording and not self.pending_notification:
-            self.pending_notification = True
-            self._pending_app_name = app_name or "Unknown App"
-            # Try to get meeting name from window title, fall back to timestamp
-            window_title = get_meeting_window_title()
-            self._pending_meeting_name = window_title or generate_meeting_name()
-
-    def _auto_stop_recording(self):
-        """Stop recording automatically when meeting ends."""
-        if not self._is_running():
-            return
-
-        # Get latest recording before stopping
-        latest_before = self._get_latest_recording()
-        before_mtime = latest_before.stat().st_mtime if latest_before else 0
-
-        stop_daemon(self.pid_file)
-        self._update_title()
-
-        # Wait for file to be saved
-        import time
-        time.sleep(2)
-
-        # Reload config
-        self.config.load()
-
-        latest_after = self._get_latest_recording()
-
-        # Check for new recording
-        is_new_recording = False
-        if latest_after:
-            after_mtime = latest_after.stat().st_mtime
-            if latest_before is None or str(latest_after) != str(latest_before) or after_mtime > before_mtime:
-                is_new_recording = True
-
-        # Clear state
-        self._clear_recording_state()
-        self.current_meeting_name = None
-
-        if is_new_recording:
-            if self.config.auto_transcribe:
-                rumps.notification(
-                    title="Meeting Noter",
-                    subtitle="Recording Saved",
-                    message=f"Transcribing {latest_after.name}...",
-                )
-                self._transcribe_in_background(latest_after)
-            else:
-                rumps.notification(
-                    title="Meeting Noter",
-                    subtitle="Recording Saved",
-                    message=latest_after.name,
-                )
-
-    @rumps.timer(1)
-    def check_pending_prompt(self, _):
-        """Check if we need to show a recording prompt (runs on main thread)."""
-        if self.pending_notification and hasattr(self, '_pending_meeting_name'):
-            app_name = self._pending_app_name or "App"
-            meeting_name = self._pending_meeting_name
-
-            # Clear first to prevent re-triggering
-            self._pending_app_name = None
-            self.pending_notification = False
-
-            # Build message with meeting name if available
-            if meeting_name and not meeting_name[0].isdigit():
-                # Has a real meeting name (not timestamp-based)
-                message = f"Meeting: {meeting_name}\n\nDo you want to record?"
-            else:
-                message = "Do you want to record this call?"
-
-            # Show alert on main thread
-            response = rumps.alert(
-                title=f"Microphone in use: {app_name}",
-                message=message,
-                ok="Record",
-                cancel="Skip",
-            )
-
-            if response == 1:  # Record clicked
-                self._start_recording_with_name(meeting_name, app_name)
-                rumps.notification(
-                    title="Meeting Noter",
-                    subtitle="Recording Started",
-                    message=meeting_name,
-                )
-
-
-def _hide_dock_icon():
-    """Hide the dock icon on macOS (make it a background agent app)."""
-    try:
-        from AppKit import NSApplication, NSApplicationActivationPolicyAccessory
-        NSApplication.sharedApplication().setActivationPolicy_(NSApplicationActivationPolicyAccessory)
-    except ImportError:
-        pass
-
-
-def run_menubar():
-    """Run the menu bar app."""
-    _hide_dock_icon()
-    _write_menubar_pid()
-    atexit.register(_remove_menubar_pid)
-
-    app = MeetingNoterApp()
-    app.run()
-
-
-if __name__ == "__main__":
-    run_menubar()