meeting-noter 0.7.0__py3-none-any.whl

meeting_noter/__init__.py

@@ -0,0 +1,3 @@
+"""Meeting Noter - Offline meeting transcription with virtual audio devices."""
+
+__version__ = "0.1.0"

meeting_noter/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m meeting_noter."""
+
+from meeting_noter.cli import cli
+
+if __name__ == "__main__":
+    cli()

meeting_noter/audio/__init__.py

@@ -0,0 +1 @@
+"""Audio capture and processing modules."""

meeting_noter/audio/capture.py

@@ -0,0 +1,209 @@
+"""Audio capture from default microphone."""
+
+from __future__ import annotations
+
+import numpy as np
+import sounddevice as sd
+from queue import Queue
+from threading import Event
+from typing import Optional, Union
+
+
+SAMPLE_RATE = 48000  # Native sample rate for macOS devices
+CHANNELS = 2  # Capture stereo for better quality
+BLOCK_SIZE = 1024
+
+
+def find_capture_device() -> tuple[Optional[int], bool]:
+    """Find the default microphone for capture.
+
+    Returns:
+        Tuple of (device_index, has_system_audio)
+        has_system_audio is always False - system audio comes from ScreenCaptureKit
+    """
+    # Use default input device (microphone)
+    try:
+        default_input = sd.default.device[0]
+        if default_input is not None and default_input >= 0:
+            device_info = sd.query_devices(default_input)
+            if device_info["max_input_channels"] > 0:
+                return default_input, False
+    except Exception:
+        pass
+
+    # Fallback: find any real input device (skip virtual devices)
+    devices = sd.query_devices()
+    for i, device in enumerate(devices):
+        if device["max_input_channels"] > 0:
+            name = device["name"].lower()
+            # Skip virtual audio devices
+            if "blackhole" in name or "virtual" in name or "aggregate" in name:
+                continue
+            return i, False
+
+    # Last resort: any input device
+    for i, device in enumerate(devices):
+        if device["max_input_channels"] > 0:
+            return i, False
+
+    return None, False
+
+
+def find_capture_device_simple() -> Optional[int]:
+    """Simple wrapper for backward compatibility."""
+    device_idx, _ = find_capture_device()
+    return device_idx
+
+
+def find_default_microphone() -> Optional[int]:
+    """Find the default microphone device."""
+    try:
+        default_input = sd.default.device[0]
+        if default_input is not None and default_input >= 0:
+            return default_input
+    except Exception:
+        pass
+    return None
+
+
+# Backward compatibility alias
+find_capture_device_legacy = find_capture_device_simple
+
+
+def find_device_by_name(name: str) -> Optional[int]:
+    """Find a device by name (partial match)."""
+    devices = sd.query_devices()
+    for i, device in enumerate(devices):
+        if name.lower() in device["name"].lower():
+            return i
+    return None
+
+
+class AudioCapture:
+    """Captures audio from default microphone."""
+
+    def __init__(
+        self,
+        device: Union[int, str, None] = None,
+        sample_rate: int = SAMPLE_RATE,
+        channels: Optional[int] = None,
+        block_size: int = BLOCK_SIZE,
+    ):
+        self.sample_rate = sample_rate
+        self.block_size = block_size
+        self.audio_queue: Queue[np.ndarray] = Queue()
+        self.stop_event = Event()
+        self.stream: Optional[sd.InputStream] = None
+
+        # Find device
+        self.has_system_audio = False  # System audio comes from ScreenCaptureKit
+        if device is None:
+            self.device_index, _ = find_capture_device()
+            if self.device_index is None:
+                raise RuntimeError(
+                    "No audio input device found. Please check your microphone."
+                )
+        elif isinstance(device, str):
+            self.device_index = find_device_by_name(device)
+            if self.device_index is None:
+                raise RuntimeError(f"Device '{device}' not found.")
+        else:
+            self.device_index = device
+
+        # Get actual channel count from device (use up to 2 channels)
+        device_info = sd.query_devices(self.device_index)
+        max_channels = device_info["max_input_channels"]
+        self.channels = channels if channels is not None else min(max_channels, CHANNELS)
+
+        print(f"Using microphone: {device_info['name']}")
+
+    def _audio_callback(
+        self,
+        indata: np.ndarray,
+        frames: int,
+        time_info: dict,
+        status: sd.CallbackFlags,
+    ):
+        """Callback for audio stream."""
+        if status:
+            print(f"Audio status: {status}")
+        # Copy data to queue
+        self.audio_queue.put(indata.copy())
+
+    def start(self):
+        """Start capturing audio."""
+        self.stop_event.clear()
+        self.stream = sd.InputStream(
+            device=self.device_index,
+            channels=self.channels,
+            samplerate=self.sample_rate,
+            blocksize=self.block_size,
+            dtype=np.float32,
+            callback=self._audio_callback,
+        )
+        self.stream.start()
+
+    def stop(self):
+        """Stop capturing audio."""
+        self.stop_event.set()
+        if self.stream:
+            self.stream.stop()
+            self.stream.close()
+            self.stream = None
+
+    def get_audio(self, timeout: float = 1.0) -> Optional[np.ndarray]:
+        """Get audio data from queue."""
+        try:
+            return self.audio_queue.get(timeout=timeout)
+        except:
+            return None
+
+    def get_all_audio(self) -> np.ndarray:
+        """Get all accumulated audio from queue."""
+        chunks = []
+        while not self.audio_queue.empty():
+            try:
+                chunks.append(self.audio_queue.get_nowait())
+            except:
+                break
+        if chunks:
+            return np.concatenate(chunks)
+        return np.array([], dtype=np.float32)
+
+
+class SilenceDetector:
+    """Detects extended silence in audio stream."""
+
+    def __init__(
+        self,
+        threshold: float = 0.01,
+        silence_duration: float = 60.0,
+        sample_rate: int = SAMPLE_RATE,
+    ):
+        self.threshold = threshold
+        self.silence_samples = int(silence_duration * sample_rate)
+        self.current_silence = 0
+        self.sample_rate = sample_rate
+
+    def update(self, audio: np.ndarray) -> bool:
+        """Update with new audio data.
+
+        Returns True if extended silence is detected (meeting likely ended).
+        """
+        rms = np.sqrt(np.mean(audio ** 2))
+
+        if rms < self.threshold:
+            self.current_silence += len(audio)
+        else:
+            self.current_silence = 0
+
+        return self.current_silence >= self.silence_samples
+
+    def reset(self):
+        """Reset silence counter."""
+        self.current_silence = 0
+
+    def is_audio_present(self, audio: np.ndarray) -> bool:
+        """Check if there's meaningful audio (not just silence)."""
+        rms = np.sqrt(np.mean(audio ** 2))
+        return rms >= self.threshold

meeting_noter/audio/encoder.py

@@ -0,0 +1,208 @@
+"""MP3 encoding for audio recordings using ffmpeg."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import numpy as np
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, Tuple
+
+# Get bundled ffmpeg binary path
+try:
+    import imageio_ffmpeg
+    FFMPEG_PATH = imageio_ffmpeg.get_ffmpeg_exe()
+except ImportError:
+    # Fallback to system ffmpeg
+    FFMPEG_PATH = "ffmpeg"
+
+
+def _sanitize_filename(name: str, max_length: int = 50) -> str:
+    """Sanitize a string for use as a filename.
+
+    Args:
+        name: The name to sanitize
+        max_length: Maximum length for the sanitized name
+
+    Returns:
+        A safe filename string with spaces replaced by underscores
+    """
+    # Replace spaces with underscores
+    name = name.replace(" ", "_")
+    # Remove any character that isn't alphanumeric, underscore, or hyphen
+    name = re.sub(r"[^\w\-]", "", name)
+    # Truncate to max length
+    if len(name) > max_length:
+        name = name[:max_length]
+    # Remove trailing underscores/hyphens
+    name = name.rstrip("_-")
+    return name
+
+
+def _is_timestamp_name(name: str) -> bool:
+    """Check if name is a default timestamp pattern (DD_Mon_YYYY_HHMM)."""
+    return bool(re.match(r"^\d{2}_[A-Z][a-z]{2}_\d{4}_\d{4}$", name))
+
+
+class MP3Encoder:
+    """Encodes audio data to MP3 format using ffmpeg."""
+
+    def __init__(
+        self,
+        output_path: Path,
+        sample_rate: int = 16000,
+        channels: int = 1,
+        bitrate: int = 128,
+    ):
+        self.output_path = output_path
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.bitrate = bitrate
+        self._process: Optional[subprocess.Popen] = None
+        self._start_ffmpeg()
+
+    def _start_ffmpeg(self):
+        """Start ffmpeg process for encoding."""
+        cmd = [
+            FFMPEG_PATH,
+            "-y",  # Overwrite output
+            "-f", "s16le",  # Input format: signed 16-bit little-endian PCM
+            "-ar", str(self.sample_rate),  # Sample rate
+            "-ac", str(self.channels),  # Channels
+            "-i", "pipe:0",  # Read from stdin
+            "-codec:a", "libmp3lame",  # MP3 encoder
+            "-b:a", f"{self.bitrate}k",  # Bitrate
+            "-f", "mp3",  # Output format
+            str(self.output_path),
+        ]
+        self._process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    def encode_chunk(self, audio: np.ndarray) -> bytes:
+        """Encode a chunk of audio data.
+
+        Args:
+            audio: Float32 audio data, values between -1 and 1
+
+        Returns:
+            Empty bytes (ffmpeg writes directly to file)
+        """
+        if self._process is None or self._process.stdin is None:
+            return b""
+
+        # Convert float32 to int16
+        int_data = (audio * 32767).astype(np.int16)
+        try:
+            self._process.stdin.write(int_data.tobytes())
+        except BrokenPipeError:
+            pass
+        return b""  # ffmpeg writes to file, not returning data
+
+    def finalize(self) -> bytes:
+        """Finalize encoding."""
+        if self._process is not None and self._process.stdin is not None:
+            try:
+                self._process.stdin.close()
+            except Exception:
+                pass
+            self._process.wait()
+            self._process = None
+        return b""
+
+
+class RecordingSession:
+    """Manages a single recording session (one meeting)."""
+
+    def __init__(
+        self,
+        output_dir: Path,
+        sample_rate: int = 16000,
+        channels: int = 1,
+        meeting_name: Optional[str] = None,
+    ):
+        self.output_dir = output_dir
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.meeting_name = meeting_name
+        self.encoder: Optional[MP3Encoder] = None
+        self.filepath: Optional[Path] = None
+        self.start_time: Optional[datetime] = None
+        self.total_samples = 0
+
+    def start(self) -> Path:
+        """Start a new recording session."""
+        self.start_time = datetime.now()
+
+        if self.meeting_name:
+            sanitized = _sanitize_filename(self.meeting_name)
+            if _is_timestamp_name(self.meeting_name):
+                # Default timestamp name - use as-is without extra prefix
+                filename = f"{sanitized}.mp3"
+            else:
+                # Custom name - add timestamp prefix for uniqueness
+                timestamp = self.start_time.strftime("%Y-%m-%d_%H%M%S")
+                filename = f"{timestamp}_{sanitized}.mp3"
+        else:
+            timestamp = self.start_time.strftime("%Y-%m-%d_%H%M%S")
+            filename = f"{timestamp}.mp3"
+        self.filepath = self.output_dir / filename
+
+        self.encoder = MP3Encoder(
+            output_path=self.filepath,
+            sample_rate=self.sample_rate,
+            channels=self.channels,
+        )
+        self.total_samples = 0
+
+        return self.filepath
+
+    def write(self, audio: np.ndarray):
+        """Write audio data to the recording."""
+        if self.encoder is None:
+            raise RuntimeError("Recording session not started")
+
+        self.encoder.encode_chunk(audio)
+        self.total_samples += len(audio)
+
+    def stop(self) -> Tuple[Optional[Path], float]:
+        """Stop the recording session.
+
+        Returns:
+            Tuple of (filepath, duration_seconds)
+        """
+        duration = 0.0
+        filepath = self.filepath
+
+        if self.encoder:
+            # Finalize encoding
+            self.encoder.finalize()
+            duration = self.total_samples / self.sample_rate
+
+            # Delete if too short (less than 5 seconds)
+            if duration < 5.0 and filepath and filepath.exists():
+                filepath.unlink()
+                filepath = None
+
+        self.encoder = None
+        self.filepath = None
+        self.start_time = None
+        self.total_samples = 0
+
+        return filepath, duration
+
+    @property
+    def is_active(self) -> bool:
+        """Check if a recording is in progress."""
+        return self.encoder is not None
+
+    @property
+    def duration(self) -> float:
+        """Get current recording duration in seconds."""
+        if self.sample_rate > 0:
+            return self.total_samples / self.sample_rate
+        return 0.0