patch-chat 0.1.0__py3-none-any.whl

patch/voice.py

@@ -0,0 +1,200 @@
+import math
+import os
+import tempfile
+import time
+import warnings
+
+from prompt_toolkit.shortcuts import prompt
+
+from patch.llm import litellm
+
+from .dump import dump  # noqa: F401
+
+warnings.filterwarnings(
+    "ignore", message="Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work"
+)
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+
+
+from pydub import AudioSegment  # noqa
+from pydub.exceptions import CouldntDecodeError, CouldntEncodeError  # noqa
+
+try:
+    import soundfile as sf
+except (OSError, ModuleNotFoundError):
+    sf = None
+
+
+class SoundDeviceError(Exception):
+    pass
+
+
+class Voice:
+    max_rms = 0
+    min_rms = 1e5
+    pct = 0
+
+    threshold = 0.15
+
+    def __init__(self, audio_format="wav", device_name=None):
+        if sf is None:
+            raise SoundDeviceError
+        try:
+            print("Initializing sound device...")
+            import sounddevice as sd
+
+            self.sd = sd
+
+            devices = sd.query_devices()
+
+            if device_name:
+                # Find the device with matching name
+                device_id = None
+                for i, device in enumerate(devices):
+                    if device_name in device["name"]:
+                        device_id = i
+                        break
+                if device_id is None:
+                    available_inputs = [d["name"] for d in devices if d["max_input_channels"] > 0]
+                    raise ValueError(
+                        f"Device '{device_name}' not found. Available input devices:"
+                        f" {available_inputs}"
+                    )
+
+                print(f"Using input device: {device_name} (ID: {device_id})")
+
+                self.device_id = device_id
+            else:
+                self.device_id = None
+
+        except (OSError, ModuleNotFoundError):
+            raise SoundDeviceError
+        if audio_format not in ["wav", "mp3", "webm"]:
+            raise ValueError(f"Unsupported audio format: {audio_format}")
+        self.audio_format = audio_format
+
+    def callback(self, indata, frames, time, status):
+        """This is called (from a separate thread) for each audio block."""
+        import numpy as np
+
+        rms = np.sqrt(np.mean(indata**2))
+        self.max_rms = max(self.max_rms, rms)
+        self.min_rms = min(self.min_rms, rms)
+
+        rng = self.max_rms - self.min_rms
+        if rng > 0.001:
+            self.pct = (rms - self.min_rms) / rng
+        else:
+            self.pct = 0.5
+
+        self.audio_file.write(indata)
+
+    def get_prompt(self):
+        num = 10
+        if math.isnan(self.pct) or self.pct < self.threshold:
+            cnt = 0
+        else:
+            cnt = int(self.pct * 10)
+
+        bar = "░" * cnt + "█" * (num - cnt)
+        bar = bar[:num]
+
+        dur = time.time() - self.start_time
+        return f"Recording, press ENTER when done... {dur:.1f}sec {bar}"
+
+    def record_and_transcribe(self, history=None, language=None):
+        try:
+            return self.raw_record_and_transcribe(history, language)
+        except KeyboardInterrupt:
+            return
+        except SoundDeviceError as e:
+            print(f"Error: {e}")
+            print("Please ensure you have a working audio input device connected and try again.")
+            return
+
+    def raw_record_and_transcribe(self, history, language):
+        temp_files = set()
+        temp_wav = self._temp_audio_file(".wav")
+        temp_files.add(temp_wav)
+
+        try:
+            try:
+                sample_rate = int(
+                    self.sd.query_devices(self.device_id, "input")["default_samplerate"]
+                )
+            except (TypeError, ValueError):
+                sample_rate = 16000  # fallback to 16kHz if unable to query device
+            except self.sd.PortAudioError:
+                raise SoundDeviceError(
+                    "No audio input device detected. Please check your audio settings and try"
+                    " again."
+                )
+
+            self.start_time = time.time()
+
+            try:
+                with sf.SoundFile(
+                    temp_wav, mode="w", samplerate=sample_rate, channels=1
+                ) as self.audio_file:
+                    with self.sd.InputStream(
+                        samplerate=sample_rate,
+                        channels=1,
+                        callback=self.callback,
+                        device=self.device_id,
+                    ):
+                        prompt(self.get_prompt, refresh_interval=0.1)
+            except self.sd.PortAudioError as err:
+                raise SoundDeviceError(f"Error accessing audio input device: {err}")
+
+            use_audio_format = self.audio_format
+
+            # Check file size and offer to convert to mp3 if too large
+            file_size = os.path.getsize(temp_wav)
+            if file_size > 24.9 * 1024 * 1024 and self.audio_format == "wav":
+                print("\nWarning: {temp_wav} is too large, switching to mp3 format.")
+                use_audio_format = "mp3"
+
+            filename = temp_wav
+            if use_audio_format != "wav":
+                try:
+                    new_filename = self._temp_audio_file(f".{use_audio_format}")
+                    temp_files.add(new_filename)
+                    audio = AudioSegment.from_wav(temp_wav)
+                    audio.export(new_filename, format=use_audio_format)
+                    filename = new_filename
+                except (CouldntDecodeError, CouldntEncodeError) as e:
+                    print(f"Error converting audio: {e}")
+                except (OSError, FileNotFoundError) as e:
+                    print(f"File system error during conversion: {e}")
+                except Exception as e:
+                    print(f"Unexpected error during audio conversion: {e}")
+
+            with open(filename, "rb") as fh:
+                try:
+                    transcript = litellm.transcription(
+                        model="whisper-1", file=fh, prompt=history, language=language
+                    )
+                except Exception as err:
+                    print(f"Unable to transcribe {filename}: {err}")
+                    return
+
+            return transcript.text
+        finally:
+            for filename in temp_files:
+                try:
+                    os.remove(filename)
+                except FileNotFoundError:
+                    pass
+
+    @staticmethod
+    def _temp_audio_file(suffix):
+        file = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+        file.close()
+        return file.name
+
+
+if __name__ == "__main__":
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Please set the OPENAI_API_KEY environment variable.")
+    print(Voice().record_and_transcribe())

patch/waiting.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python
+
+"""
+Thread-based, killable spinner utility.
+
+Use it like:
+
+    from patch.waiting import WaitingSpinner
+
+    spinner = WaitingSpinner("Waiting for LLM")
+    spinner.start()
+    ...  # long task
+    spinner.stop()
+"""
+
+import sys
+import threading
+import time
+
+from rich.console import Console
+
+
+class Spinner:
+    """
+    Minimal spinner that scans a single marker back and forth across a line.
+
+    The animation is pre-rendered into a list of frames.  If the terminal
+    cannot display unicode the frames are converted to plain ASCII.
+    """
+
+    def __init__(self, text: str, width: int = 7):
+        self.text = text
+        self.start_time = time.time()
+        self.last_update = 0.0
+        self.visible = False
+        self.is_tty = sys.stdout.isatty()
+        self.console = Console()
+
+        # Pre-render the animation frames using pure ASCII so they will
+        # always display, even on very limited terminals.
+        ascii_frames = [
+            "#=        ",  # C1 C2 space(8)
+            "=#        ",  # C2 C1 space(8)
+            " =#       ",  # space(1) C2 C1 space(7)
+            "  =#      ",  # space(2) C2 C1 space(6)
+            "   =#     ",  # space(3) C2 C1 space(5)
+            "    =#    ",  # space(4) C2 C1 space(4)
+            "     =#   ",  # space(5) C2 C1 space(3)
+            "      =#  ",  # space(6) C2 C1 space(2)
+            "       =# ",  # space(7) C2 C1 space(1)
+            "        =#",  # space(8) C2 C1
+            "        #=",  # space(8) C1 C2
+            "       #= ",  # space(7) C1 C2 space(1)
+            "      #=  ",  # space(6) C1 C2 space(2)
+            "     #=   ",  # space(5) C1 C2 space(3)
+            "    #=    ",  # space(4) C1 C2 space(4)
+            "   #=     ",  # space(3) C1 C2 space(5)
+            "  #=      ",  # space(2) C1 C2 space(6)
+            " #=       ",  # space(1) C1 C2 space(7)
+        ]
+
+        self.unicode_palette = "░█"
+        xlate_from, xlate_to = ("=#", self.unicode_palette)
+
+        # If unicode is supported, swap the ASCII chars for nicer glyphs.
+        if self._supports_unicode():
+            translation_table = str.maketrans(xlate_from, xlate_to)
+            frames = [f.translate(translation_table) for f in ascii_frames]
+            self.scan_char = xlate_to[xlate_from.find("#")]
+        else:
+            frames = ascii_frames
+            self.scan_char = "#"
+
+        # Bounce the scanner back and forth.
+        self.frames = frames
+        self.frame_idx = 0
+        self.width = len(frames[0]) - 2  # number of chars between the brackets
+        self.animation_len = len(frames[0])
+        self.last_display_len = 0  # Length of the last spinner line (frame + text)
+
+    def _supports_unicode(self) -> bool:
+        if not self.is_tty:
+            return False
+        try:
+            out = self.unicode_palette
+            out += "\b" * len(self.unicode_palette)
+            out += " " * len(self.unicode_palette)
+            out += "\b" * len(self.unicode_palette)
+            sys.stdout.write(out)
+            sys.stdout.flush()
+            return True
+        except UnicodeEncodeError:
+            return False
+        except Exception:
+            return False
+
+    def _next_frame(self) -> str:
+        frame = self.frames[self.frame_idx]
+        self.frame_idx = (self.frame_idx + 1) % len(self.frames)
+        return frame
+
+    def step(self, text: str = None) -> None:
+        if text is not None:
+            self.text = text
+
+        if not self.is_tty:
+            return
+
+        now = time.time()
+        if not self.visible and now - self.start_time >= 0.5:
+            self.visible = True
+            self.last_update = 0.0
+            if self.is_tty:
+                self.console.show_cursor(False)
+
+        if not self.visible or now - self.last_update < 0.1:
+            return
+
+        self.last_update = now
+        frame_str = self._next_frame()
+
+        # Determine the maximum width for the spinner line
+        # Subtract 2 as requested, to leave a margin or prevent cursor wrapping issues
+        max_spinner_width = self.console.width - 2
+        if max_spinner_width < 0:  # Handle extremely narrow terminals
+            max_spinner_width = 0
+
+        current_text_payload = f" {self.text}"
+        line_to_display = f"{frame_str}{current_text_payload}"
+
+        # Truncate the line if it's too long for the console width
+        if len(line_to_display) > max_spinner_width:
+            line_to_display = line_to_display[:max_spinner_width]
+
+        len_line_to_display = len(line_to_display)
+
+        # Calculate padding to clear any remnants from a longer previous line
+        padding_to_clear = " " * max(0, self.last_display_len - len_line_to_display)
+
+        # Write the spinner frame, text, and any necessary clearing spaces
+        sys.stdout.write(f"\r{line_to_display}{padding_to_clear}")
+        self.last_display_len = len_line_to_display
+
+        # Calculate number of backspaces to position cursor at the scanner character
+        scan_char_abs_pos = frame_str.find(self.scan_char)
+
+        # Total characters written to the line (frame + text + padding)
+        total_chars_written_on_line = len_line_to_display + len(padding_to_clear)
+
+        # num_backspaces will be non-positive if scan_char_abs_pos is beyond
+        # total_chars_written_on_line (e.g., if the scan char itself was truncated).
+        # (e.g., if the scan char itself was truncated).
+        # In such cases, (effectively) 0 backspaces are written,
+        # and the cursor stays at the end of the line.
+        num_backspaces = total_chars_written_on_line - scan_char_abs_pos
+        sys.stdout.write("\b" * num_backspaces)
+        sys.stdout.flush()
+
+    def end(self) -> None:
+        if self.visible and self.is_tty:
+            clear_len = self.last_display_len  # Use the length of the last displayed content
+            sys.stdout.write("\r" + " " * clear_len + "\r")
+            sys.stdout.flush()
+            self.console.show_cursor(True)
+        self.visible = False
+
+
+class WaitingSpinner:
+    """Background spinner that can be started/stopped safely."""
+
+    def __init__(self, text: str = "Waiting for LLM", delay: float = 0.15):
+        self.spinner = Spinner(text)
+        self.delay = delay
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+
+    def _spin(self):
+        try:
+            while not self._stop_event.is_set():
+                self.spinner.step()
+                if self._stop_event.wait(self.delay):
+                    break
+        finally:
+            self.spinner.end()
+
+    def start(self):
+        """Start the spinner in a background thread."""
+        if not self._thread.is_alive():
+            self._thread.start()
+
+    def stop(self):
+        """Request the spinner to stop and wait for the worker to restore the terminal."""
+        self._stop_event.set()
+        if self._thread.is_alive():
+            self._thread.join()
+        else:
+            self.spinner.end()
+
+    # Allow use as a context-manager
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+
+
+def main():
+    spinner = Spinner("Running spinner...")
+    try:
+        for _ in range(100):
+            time.sleep(0.15)
+            spinner.step()
+        print("Success!")
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.")
+    finally:
+        spinner.end()
+
+
+if __name__ == "__main__":
+    main()