remdb 0.2.6__py3-none-any.whl

rem/services/audio/chunker.py

@@ -0,0 +1,354 @@
+"""
+Audio chunker - splits audio by silence near minute boundaries.
+
+Lightweight implementation using minimal dependencies:
+- wave (stdlib) for WAV files
+- pydub (optional) for format conversion
+
+Design: Split audio near minute boundaries (58-62s range) at silence points.
+This optimizes for OpenAI Whisper API 25MB file size limits while maintaining
+natural speech boundaries.
+"""
+
+import struct
+import tempfile
+import wave
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+# Check for pydub availability (optional for non-WAV formats)
+try:
+    from pydub import AudioSegment
+    from pydub.silence import detect_silence
+
+    PYDUB_AVAILABLE = True
+except ImportError:
+    PYDUB_AVAILABLE = False
+    logger.warning("pydub not available - only WAV files will be supported")
+
+
+class AudioChunk:
+    """Represents a chunk of audio with temporal boundaries."""
+
+    def __init__(
+        self,
+        file_path: str,
+        start_ms: int,
+        end_ms: int,
+        chunk_index: int,
+    ):
+        """
+        Initialize audio chunk.
+
+        Args:
+            file_path: Path to temporary audio file for this chunk
+            start_ms: Start time in milliseconds
+            end_ms: End time in milliseconds
+            chunk_index: Index of this chunk in sequence
+        """
+        self.file_path = file_path
+        self.start_ms = start_ms
+        self.end_ms = end_ms
+        self.chunk_index = chunk_index
+        self.duration_ms = end_ms - start_ms
+
+    @property
+    def start_seconds(self) -> float:
+        """Start time in seconds."""
+        return self.start_ms / 1000.0
+
+    @property
+    def end_seconds(self) -> float:
+        """End time in seconds."""
+        return self.end_ms / 1000.0
+
+    @property
+    def duration_seconds(self) -> float:
+        """Duration in seconds."""
+        return self.duration_ms / 1000.0
+
+    def __repr__(self) -> str:
+        return f"AudioChunk(index={self.chunk_index}, start={self.start_seconds:.1f}s, end={self.end_seconds:.1f}s, duration={self.duration_seconds:.1f}s)"
+
+
+class AudioChunker:
+    """
+    Chunks audio files by silence near minute boundaries.
+
+    Strategy:
+    1. Target chunks around 60 seconds (configurable)
+    2. Look for silence in a window around the target (e.g., 58-62s)
+    3. Split at the longest silence in that window
+    4. If no silence found, split at the target boundary
+
+    This creates natural breaks while keeping chunks under OpenAI's
+    25MB file size limit (~10 minutes of audio at typical bitrates).
+    """
+
+    def __init__(
+        self,
+        target_chunk_seconds: float = 60.0,
+        chunk_window_seconds: float = 2.0,
+        silence_threshold_db: float = -40.0,
+        min_silence_ms: int = 500,
+    ):
+        """
+        Initialize audio chunker.
+
+        Args:
+            target_chunk_seconds: Target chunk duration (default: 60s)
+            chunk_window_seconds: Window around target to search for silence (±seconds)
+            silence_threshold_db: dB threshold for silence detection (lower = stricter)
+            min_silence_ms: Minimum silence duration to consider (milliseconds)
+        """
+        self.target_chunk_ms = int(target_chunk_seconds * 1000)
+        self.chunk_window_ms = int(chunk_window_seconds * 1000)
+        self.silence_threshold_db = silence_threshold_db
+        self.min_silence_ms = min_silence_ms
+
+    def chunk_audio(
+        self,
+        audio_path: str | Path,
+        output_dir: Optional[str | Path] = None,
+    ) -> list[AudioChunk]:
+        """
+        Chunk audio file by silence near minute boundaries.
+
+        Args:
+            audio_path: Path to audio file (WAV, M4A, MP3, etc.)
+            output_dir: Directory for chunk files (temp dir if None)
+
+        Returns:
+            List of AudioChunk objects
+
+        Raises:
+            ValueError: If audio format not supported
+            RuntimeError: If pydub not available for non-WAV files
+        """
+        audio_path = Path(audio_path)
+
+        if not audio_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+        # Determine output directory
+        if output_dir is None:
+            output_dir = Path(tempfile.mkdtemp(prefix="rem_audio_chunks_"))
+        else:
+            output_dir = Path(output_dir)
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+        logger.info(f"Chunking audio: {audio_path}")
+        logger.info(
+            f"Target: {self.target_chunk_ms/1000:.0f}s chunks, "
+            f"window: ±{self.chunk_window_ms/1000:.0f}s, "
+            f"silence: {self.silence_threshold_db}dB"
+        )
+
+        # Load audio (convert to WAV if needed)
+        if audio_path.suffix.lower() == ".wav":
+            audio = self._load_wav(audio_path)
+        elif PYDUB_AVAILABLE:
+            logger.info(f"Converting {audio_path.suffix} to AudioSegment")
+            audio = AudioSegment.from_file(str(audio_path))
+        else:
+            raise RuntimeError(
+                f"pydub required for {audio_path.suffix} files. "
+                "Install with: pip install pydub"
+            )
+
+        duration_ms = len(audio)
+        logger.info(f"Audio duration: {duration_ms/1000:.1f}s")
+
+        # Find chunk boundaries
+        boundaries = self._find_chunk_boundaries(audio, duration_ms)
+        logger.info(f"Found {len(boundaries)-1} chunk boundaries: {[f'{b/1000:.1f}s' for b in boundaries]}")
+
+        # Create chunks
+        chunks = []
+        for i in range(len(boundaries) - 1):
+            start_ms = boundaries[i]
+            end_ms = boundaries[i + 1]
+
+            # Extract segment
+            segment = audio[start_ms:end_ms]
+
+            # Save to file
+            chunk_filename = f"chunk_{i:03d}_{start_ms}_{end_ms}.wav"
+            chunk_path = output_dir / chunk_filename
+
+            segment.export(str(chunk_path), format="wav")
+
+            chunk = AudioChunk(
+                file_path=str(chunk_path),
+                start_ms=start_ms,
+                end_ms=end_ms,
+                chunk_index=i,
+            )
+            chunks.append(chunk)
+            logger.debug(f"Created {chunk}")
+
+        logger.info(f"Created {len(chunks)} chunks in {output_dir}")
+        return chunks
+
+    def _load_wav(self, wav_path: Path) -> "AudioSegment":
+        """
+        Load WAV file using pydub or wave module.
+
+        Args:
+            wav_path: Path to WAV file
+
+        Returns:
+            AudioSegment
+
+        Raises:
+            ValueError: If WAV file invalid
+        """
+        if PYDUB_AVAILABLE:
+            return AudioSegment.from_wav(str(wav_path))
+
+        # Fallback: use wave module and convert to AudioSegment-like interface
+        # This is a minimal implementation for WAV-only support
+        raise RuntimeError(
+            "pydub required for audio processing. Install with: pip install pydub"
+        )
+
+    def _find_chunk_boundaries(
+        self,
+        audio: "AudioSegment",
+        duration_ms: int,
+    ) -> list[int]:
+        """
+        Find chunk boundaries by detecting silence near target intervals.
+
+        Strategy:
+        1. Start at 0, target boundary at 60s
+        2. Look for silence in window [58s, 62s]
+        3. Split at longest silence in window
+        4. If no silence, split at target (60s)
+        5. Repeat until end of audio
+
+        Args:
+            audio: AudioSegment
+            duration_ms: Total audio duration in milliseconds
+
+        Returns:
+            List of boundary timestamps in milliseconds
+        """
+        boundaries = [0]  # Start at beginning
+        current_pos = 0
+
+        while current_pos < duration_ms:
+            # Target next boundary
+            target_boundary = current_pos + self.target_chunk_ms
+
+            if target_boundary >= duration_ms:
+                # Last chunk - use end of audio
+                boundaries.append(duration_ms)
+                break
+
+            # Define search window around target
+            window_start = max(
+                current_pos, target_boundary - self.chunk_window_ms
+            )
+            window_end = min(duration_ms, target_boundary + self.chunk_window_ms)
+
+            # Find best split point (longest silence in window)
+            split_point = self._find_best_split(
+                audio,
+                window_start,
+                window_end,
+                target_boundary,
+            )
+
+            boundaries.append(split_point)
+            current_pos = split_point
+
+        return boundaries
+
+    def _find_best_split(
+        self,
+        audio: "AudioSegment",
+        window_start: int,
+        window_end: int,
+        target: int,
+    ) -> int:
+        """
+        Find best split point in window by detecting silence.
+
+        Args:
+            audio: AudioSegment
+            window_start: Start of search window (ms)
+            window_end: End of search window (ms)
+            target: Target split point (ms)
+
+        Returns:
+            Best split point in milliseconds
+        """
+        if not PYDUB_AVAILABLE:
+            # No pydub - split at target
+            return target
+
+        # Extract window
+        window = audio[window_start:window_end]
+
+        # Detect silence
+        silence_ranges = detect_silence(
+            window,
+            min_silence_len=self.min_silence_ms,
+            silence_thresh=self.silence_threshold_db,
+            seek_step=10,  # Check every 10ms
+        )
+
+        if not silence_ranges:
+            # No silence found - split at target
+            logger.debug(f"No silence in window [{window_start/1000:.1f}s, {window_end/1000:.1f}s], splitting at target {target/1000:.1f}s")
+            return target
+
+        # Find longest silence closest to target
+        best_silence = None
+        best_score = float("-inf")
+
+        for silence_start, silence_end in silence_ranges:
+            silence_duration = silence_end - silence_start
+            silence_midpoint = (silence_start + silence_end) // 2
+            absolute_midpoint = window_start + silence_midpoint
+
+            # Score: prefer longer silences closer to target
+            # Distance penalty: further from target = lower score
+            distance_from_target = abs(absolute_midpoint - target)
+            distance_penalty = 1.0 / (1.0 + distance_from_target / 1000.0)
+
+            # Duration bonus: longer silence = higher score
+            duration_bonus = silence_duration / 1000.0
+
+            score = duration_bonus * distance_penalty
+
+            if score > best_score:
+                best_score = score
+                best_silence = absolute_midpoint
+
+        if best_silence is not None:
+            logger.debug(
+                f"Found silence at {best_silence/1000:.1f}s "
+                f"(target: {target/1000:.1f}s, score: {best_score:.3f})"
+            )
+            return best_silence
+
+        # Fallback to target
+        return target
+
+    def cleanup_chunks(self, chunks: list[AudioChunk]) -> None:
+        """
+        Clean up chunk files.
+
+        Args:
+            chunks: List of AudioChunk objects to clean up
+        """
+        for chunk in chunks:
+            try:
+                Path(chunk.file_path).unlink(missing_ok=True)
+                logger.debug(f"Deleted chunk file: {chunk.file_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete {chunk.file_path}: {e}")

rem/services/audio/transcriber.py

@@ -0,0 +1,259 @@
+"""
+Audio transcriber using OpenAI Whisper API.
+
+Lightweight implementation using only requests (no httpx dependency).
+Handles file uploads and response parsing for OpenAI's Whisper API.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import requests
+from loguru import logger
+
+
+class TranscriptionResult:
+    """Result from audio transcription."""
+
+    def __init__(
+        self,
+        text: str,
+        start_seconds: float,
+        end_seconds: float,
+        duration_seconds: float,
+        language: Optional[str] = None,
+        confidence: float = 0.9,
+    ):
+        """
+        Initialize transcription result.
+
+        Args:
+            text: Transcribed text
+            start_seconds: Start time of segment
+            end_seconds: End time of segment
+            duration_seconds: Duration of segment
+            language: Detected language (if available)
+            confidence: Confidence score (0.0-1.0)
+        """
+        self.text = text
+        self.start_seconds = start_seconds
+        self.end_seconds = end_seconds
+        self.duration_seconds = duration_seconds
+        self.language = language
+        self.confidence = confidence
+
+    def __repr__(self) -> str:
+        return f"TranscriptionResult(start={self.start_seconds:.1f}s, end={self.end_seconds:.1f}s, chars={len(self.text)})"
+
+
+class AudioTranscriber:
+    """
+    Transcribe audio using OpenAI Whisper API.
+
+    Uses only requests library (no httpx) for minimal dependencies.
+    Supports all Whisper-compatible audio formats.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "whisper-1",
+        language: Optional[str] = None,
+        temperature: float = 0.0,
+    ):
+        """
+        Initialize audio transcriber.
+
+        Args:
+            api_key: OpenAI API key (from env if None)
+            model: Whisper model name (default: whisper-1)
+            language: ISO-639-1 language code (auto-detect if None)
+            temperature: Sampling temperature 0.0-1.0 (0 = deterministic)
+        """
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            logger.warning("No OpenAI API key found - transcription will fail")
+
+        self.model = model
+        self.language = language
+        self.temperature = temperature
+        self.api_url = "https://api.openai.com/v1/audio/transcriptions"
+
+    def transcribe_file(
+        self,
+        audio_path: str | Path,
+        start_seconds: float = 0.0,
+        end_seconds: Optional[float] = None,
+    ) -> TranscriptionResult:
+        """
+        Transcribe audio file using OpenAI Whisper API.
+
+        Args:
+            audio_path: Path to audio file
+            start_seconds: Start time (for metadata only)
+            end_seconds: End time (for metadata, auto-detect if None)
+
+        Returns:
+            TranscriptionResult with text and metadata
+
+        Raises:
+            ValueError: If API key missing or file invalid
+            RuntimeError: If API request fails
+        """
+        if not self.api_key:
+            raise ValueError("OpenAI API key required for transcription")
+
+        audio_path = Path(audio_path)
+        if not audio_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_path}")
+
+        file_size_mb = audio_path.stat().st_size / (1024 * 1024)
+        logger.info(
+            f"Transcribing {audio_path.name} ({file_size_mb:.1f} MB) "
+            f"with Whisper API"
+        )
+
+        # Check file size (Whisper API limit: 25 MB)
+        if file_size_mb > 25:
+            raise ValueError(
+                f"Audio file too large: {file_size_mb:.1f} MB "
+                "(max 25 MB for Whisper API)"
+            )
+
+        # Prepare request
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        # Build form data
+        data = {
+            "model": self.model,
+            "response_format": "text",  # Simple text response
+            "temperature": self.temperature,
+        }
+
+        if self.language:
+            data["language"] = self.language
+
+        # Open file and make request
+        try:
+            with open(audio_path, "rb") as audio_file:
+                files = {"file": (audio_path.name, audio_file, "audio/wav")}
+
+                logger.debug(f"Sending request to {self.api_url}")
+                response = requests.post(
+                    self.api_url,
+                    headers=headers,
+                    data=data,
+                    files=files,
+                    timeout=120.0,  # 2 minute timeout
+                )
+
+            # Check response
+            if response.status_code != 200:
+                error_detail = response.text
+                logger.error(
+                    f"Whisper API error: {response.status_code} - {error_detail}"
+                )
+                raise RuntimeError(
+                    f"Transcription failed: {response.status_code} - {error_detail}"
+                )
+
+            # Extract text
+            transcription_text = response.text.strip()
+            logger.info(
+                f"✓ Transcription complete: {len(transcription_text)} characters"
+            )
+
+            # Calculate duration (use provided or estimate)
+            if end_seconds is None:
+                # Estimate from file size (rough approximation)
+                # WAV: ~10KB per second at 16kHz mono
+                # This is very rough, but better than nothing
+                end_seconds = start_seconds + (file_size_mb * 1024 * 10)
+
+            duration = end_seconds - start_seconds
+
+            return TranscriptionResult(
+                text=transcription_text,
+                start_seconds=start_seconds,
+                end_seconds=end_seconds,
+                duration_seconds=duration,
+                language=self.language,
+                confidence=0.9,  # Whisper doesn't provide confidence
+            )
+
+        except requests.exceptions.Timeout:
+            logger.error("Whisper API request timed out")
+            raise RuntimeError("Transcription timed out after 120 seconds")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request error: {e}")
+            raise RuntimeError(f"Transcription request failed: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error during transcription: {e}")
+            raise
+
+    def transcribe_chunks(
+        self,
+        chunks: list,  # List of AudioChunk objects from AudioChunker
+    ) -> list[TranscriptionResult]:
+        """
+        Transcribe multiple audio chunks.
+
+        Args:
+            chunks: List of AudioChunk objects from AudioChunker
+
+        Returns:
+            List of TranscriptionResult objects
+
+        Raises:
+            ValueError: If API key missing
+            RuntimeError: If any transcription fails
+        """
+        if not self.api_key:
+            raise ValueError("OpenAI API key required for transcription")
+
+        logger.info(f"Transcribing {len(chunks)} audio chunks")
+
+        results = []
+        total_duration = sum(c.duration_seconds for c in chunks)
+        estimated_cost = (total_duration / 60) * 0.006  # $0.006 per minute
+
+        logger.info(
+            f"Estimated cost: ${estimated_cost:.3f} "
+            f"(${total_duration / 60:.1f} minutes)"
+        )
+
+        for i, chunk in enumerate(chunks, 1):
+            logger.info(
+                f"Processing chunk {i}/{len(chunks)} "
+                f"({chunk.start_seconds:.1f}s - {chunk.end_seconds:.1f}s)"
+            )
+
+            try:
+                result = self.transcribe_file(
+                    chunk.file_path,
+                    start_seconds=chunk.start_seconds,
+                    end_seconds=chunk.end_seconds,
+                )
+                results.append(result)
+                logger.debug(f"✓ Chunk {i} transcribed: {len(result.text)} chars")
+
+            except Exception as e:
+                logger.error(f"Failed to transcribe chunk {i}: {e}")
+                # Add error result
+                results.append(
+                    TranscriptionResult(
+                        text=f"[Transcription failed: {e}]",
+                        start_seconds=chunk.start_seconds,
+                        end_seconds=chunk.end_seconds,
+                        duration_seconds=chunk.duration_seconds,
+                        confidence=0.0,
+                    )
+                )
+
+        successful = sum(1 for r in results if r.confidence > 0)
+        logger.info(
+            f"Transcription complete: {successful}/{len(chunks)} chunks successful"
+        )
+
+        return results