fala 0.0.1__py3-none-any.whl

fala/__init__.py

@@ -0,0 +1,3 @@
+"""fala package."""
+
+__all__ = []

fala/audio_capture.py

@@ -0,0 +1,156 @@
+"""Audio capture from microphone in real-time."""
+
+import threading
+import time
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Self
+
+import pyaudio
+
+# Audio configuration for transcription APIs
+SAMPLE_RATE = 16000
+CHANNELS = 1
+FORMAT = pyaudio.paInt16
+FRAMES_PER_BUFFER = 800  # 50ms at 16kHz
+
+
+class AudioCapture:
+    """Captures audio from microphone and yields chunks in real-time."""
+
+    def __init__(
+        self,
+        device_index: int | None = None,
+        sample_rate: int = SAMPLE_RATE,
+        channels: int = CHANNELS,
+        frames_per_buffer: int = FRAMES_PER_BUFFER,
+    ) -> None:
+        """Initialize audio capture with device and format settings."""
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.frames_per_buffer = frames_per_buffer
+        self.device_index = device_index
+        self._pyaudio: pyaudio.PyAudio | None = None
+        self._stream: pyaudio.Stream | None = None
+        self._stop_event = threading.Event()
+
+    def __enter__(self) -> Self:
+        """Context manager entry: start capture."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit: stop capture."""
+        self.stop()
+
+    def start(self) -> None:
+        """Open the audio stream for capture."""
+        self._pyaudio = pyaudio.PyAudio()
+        self._stream = self._pyaudio.open(
+            format=FORMAT,
+            channels=self.channels,
+            rate=self.sample_rate,
+            input=True,
+            frames_per_buffer=self.frames_per_buffer,
+            input_device_index=self.device_index,
+        )
+        self._stop_event.clear()
+
+    def stop(self) -> None:
+        """Stop capture and release resources."""
+        self.request_stop()
+        if self._stream:
+            try:
+                self._stream.stop_stream()
+                self._stream.close()
+            except Exception:  # noqa: S110
+                pass
+            finally:
+                self._stream = None
+        if self._pyaudio:
+            try:
+                self._pyaudio.terminate()
+            except Exception:  # noqa: S110
+                pass
+            finally:
+                self._pyaudio = None
+
+    def request_stop(self) -> None:
+        """Signal the capture loop to stop without tearing down audio resources."""
+        self._stop_event.set()
+
+    def chunks(self) -> Iterator[bytes]:
+        """Yield audio chunks from the microphone."""
+        if self._stream is None:
+            raise RuntimeError("AudioCapture not started. Call start() first.")
+        # Capture local reference to avoid None during iteration
+        stream = self._stream
+        while not self._stop_event.is_set():
+            try:
+                assert stream is not None  # for type checker
+                data = stream.read(self.frames_per_buffer, exception_on_overflow=False)
+                yield data
+            except Exception as e:
+                print(f"Audio capture error: {e}", flush=True)
+                if self._stop_event.is_set():
+                    break
+                time.sleep(0.01)
+
+    @staticmethod
+    def list_devices() -> list[dict]:
+        """Return list of available audio input devices."""
+        p = pyaudio.PyAudio()
+        devices = []
+        try:
+            for i in range(p.get_device_count()):
+                info = p.get_device_info_by_index(i)
+                # Cast to int to satisfy type checker
+                if int(info["maxInputChannels"]) > 0:
+                    devices.append(
+                        {
+                            "index": i,
+                            "name": info["name"],
+                            "channels": int(info["maxInputChannels"]),
+                            "sample_rate": int(info["defaultSampleRate"]),
+                        }
+                    )
+        finally:
+            p.terminate()
+        return devices
+
+
+def record_to_file(
+    device_index: int | None,
+    duration_seconds: float,
+    output_path: Path,
+    sample_rate: int = SAMPLE_RATE,
+    channels: int = CHANNELS,
+) -> None:
+    """Record audio for a fixed duration and save to WAV file."""
+    import wave
+
+    p = pyaudio.PyAudio()
+    try:
+        stream = p.open(
+            format=FORMAT,
+            channels=channels,
+            rate=sample_rate,
+            input=True,
+            frames_per_buffer=FRAMES_PER_BUFFER,
+            input_device_index=device_index,
+        )
+        frames = []
+        chunks_needed = int(duration_seconds * sample_rate / FRAMES_PER_BUFFER)
+        for _ in range(chunks_needed):
+            data = stream.read(FRAMES_PER_BUFFER, exception_on_overflow=False)
+            frames.append(data)
+        stream.stop_stream()
+        stream.close()
+
+        with wave.open(str(output_path), "wb") as wf:
+            wf.setnchannels(channels)
+            wf.setsampwidth(p.get_sample_size(FORMAT))
+            wf.setframerate(sample_rate)
+            wf.writeframes(b"".join(frames))
+    finally:
+        p.terminate()