From 1d9efeb38c1345346e0bfb2ed0d4de3e0117d0bd Mon Sep 17 00:00:00 2001 From: Aryan Pandit <20252503008@iiitvadodara.ac.in> Date: Fri, 13 Nov 2026 17:03:59 +0530 Subject: [PATCH 1/3] Fix Jasper overlay visibility on startup --- src/ui/overlay.py | 46 +++++++++++++++++++++++++++++++--- tests/test_overlay.py | 57 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 99 insertions(+), 4 deletions(-) create mode 100644 tests/test_overlay.py diff --git a/src/ui/overlay.py b/src/ui/overlay.py index 9689124..0f450ad 100644 --- a/src/ui/overlay.py +++ b/src/ui/overlay.py @@ -6,7 +6,7 @@ import sys from queue import Queue -from PyQt5.QtCore import QSize, Qt, QTimer +from PyQt5.QtCore import QSize, Qt, QTimer, pyqtSignal from PyQt5.QtGui import QFont from PyQt5.QtWidgets import ( QApplication, @@ -32,6 +32,10 @@ class TransparentOverlayQt(QMainWindow): """A transparent overlay that displays transcriptions and responses using PyQt.""" + # Emitting this signal from an executor thread queues UI updates on the Qt + # main thread. QTimer.singleShot from a worker has no event loop to target. + message_available = pyqtSignal() + def __init__(self, message_timeout=5, exit_callback=None): """Initialize the overlay. @@ -46,6 +50,8 @@ def __init__(self, message_timeout=5, exit_callback=None): self.message_queue = Queue() self.running = True self.on_new_message = None + self.on_recording_toggled = None + self.message_available.connect(self.process_messages) # Set up the UI self.setup_ui() @@ -141,6 +147,20 @@ def setup_ui(self): control_layout.addWidget(self.send_btn) main_layout.addLayout(control_layout) + # Explicit recording works on macOS without requiring a platform-specific + # Porcupine wake-word model. + self.voice_btn = QPushButton("Start voice") + self.voice_btn.setCheckable(True) + self.voice_btn.setStyleSheet(""" + background-color: #333333; + color: white; + border: none; + padding: 5px; + border-radius: 5px; + """) + self.voice_btn.clicked.connect(self.toggle_voice_recording) + main_layout.addWidget(self.voice_btn) + # Set the central widget self.setCentralWidget(central_widget) @@ -159,7 +179,7 @@ def mouse_move_event(self, event): self.move(event.globalPos() - self.drag_position) event.accept() - def close_event(self, event): + def closeEvent(self, event): # noqa: N802 - Qt callback name is fixed by the framework. """Handle window close event.""" self.running = False if self.exit_callback: @@ -173,7 +193,7 @@ def update_status(self, status, color="gray"): status (str): Status message color (str): Color of the status indicator """ - self.message_queue.put(("status", status, color)) + self.put_message("status", status, color) def add_log_message(self, text, color="white"): label = QLabel(text) @@ -191,7 +211,7 @@ def add_log_message(self, text, color="white"): def put_message(self, msg_type, *args): """Put a message into the queue.""" self.message_queue.put((msg_type, *args)) - QTimer.singleShot(0, self.process_messages) # Schedule async-safe execution + self.message_available.emit() def process_messages(self): """Process messages from the queue.""" @@ -212,12 +232,22 @@ def process_messages(self): text = args[0] self.add_log_message(f"{config.ASSISTANT_NAME}: {text}", "#00FF00") # Green + elif msg_type == "recording": + active = args[0] + self.voice_btn.setChecked(active) + self.voice_btn.setText("Stop voice" if active else "Start voice") + self.voice_btn.setEnabled(True) + except Exception as e: logger.error(f"Error processing message: {e}") def start(self): """Start the overlay.""" self.update_status(f"{config.ASSISTANT_NAME} Active", "lightgreen") + self.show() + self.raise_() + self.activateWindow() + self.input_box.setFocus(Qt.ActiveWindowFocusReason) def shutdown(self): """Shut down the overlay.""" @@ -230,6 +260,14 @@ def send_message(self): if message and self.on_new_message: executor.submit(self.on_new_message, message) + def toggle_voice_recording(self, active): + """Dispatch microphone work away from the Qt event loop.""" + self.voice_btn.setEnabled(False) + if self.on_recording_toggled: + executor.submit(self.on_recording_toggled, active) + else: + self.put_message("recording", False) + app = QApplication(sys.argv) overlay = TransparentOverlayQt(message_timeout=5) diff --git a/tests/test_overlay.py b/tests/test_overlay.py new file mode 100644 index 0000000..6c1ccaf --- /dev/null +++ b/tests/test_overlay.py @@ -0,0 +1,57 @@ +"""Focused regression tests for the overlay's real Qt event-loop behavior.""" + +import threading +import time +import unittest + +from src.ui.overlay import TransparentOverlayQt, app + + +class OverlayTests(unittest.TestCase): + def setUp(self): + self.overlay = TransparentOverlayQt() + + def tearDown(self): + self.overlay.exit_callback = None + self.overlay.close() + app.processEvents() + + def test_start_shows_window_and_focuses_input(self): + self.overlay.start() + app.processEvents() + + assert self.overlay.isVisible() + assert self.overlay.input_box.hasFocus() + + def test_worker_message_is_delivered_on_qt_main_thread(self): + worker = threading.Thread( + target=self.overlay.put_message, + args=("status", "Processing...", "gold"), + ) + worker.start() + worker.join() + app.processEvents() + + assert self.overlay.status_text.text() == "Processing..." + + def test_voice_button_dispatches_and_updates_state(self): + received = [] + + def record(active): + received.append(active) + self.overlay.put_message("recording", active) + + self.overlay.on_recording_toggled = record + self.overlay.voice_btn.click() + for _ in range(20): + app.processEvents() + if received: + break + time.sleep(0.01) + + assert received == [True] + assert self.overlay.voice_btn.text() == "Stop voice" + + +if __name__ == "__main__": + unittest.main() From e50741ed8a9ae93af019b712843e44def443e205 Mon Sep 17 00:00:00 2001 From: Aryan Pandit <20252503008@iiitvadodara.ac.in> Date: Sun, 15 Nov 2026 15:15:32 +0530 Subject: [PATCH 2/3] Add macOS push-to-talk voice input --- .env.example | 5 ++ main.py | 80 +++++++++++++++++++--- src/audio/audio_processor.py | 43 +++++++++--- src/audio/listener.py | 45 ++++++++----- src/audio/manual_recorder.py | 120 +++++++++++++++++++++++++++++++++ src/config.py | 23 ++++++- tests/test_audio_processor.py | 50 ++++++++++++++ tests/test_manual_recorder.py | 83 +++++++++++++++++++++++ tests/test_voice_submission.py | 38 +++++++++++ 9 files changed, 452 insertions(+), 35 deletions(-) create mode 100644 src/audio/manual_recorder.py create mode 100644 tests/test_audio_processor.py create mode 100644 tests/test_manual_recorder.py create mode 100644 tests/test_voice_submission.py diff --git a/.env.example b/.env.example index 76b68c7..0eb9baf 100644 --- a/.env.example +++ b/.env.example @@ -10,6 +10,11 @@ GROQ_API_KEY="" # Get yours at: https://picovoice.ai (free tier available) PORCUPINE_ACCESS_KEY="" +# The bundled Jasper Porcupine model is Linux-only. Wake-word detection +# defaults to enabled on Linux and disabled elsewhere. Set to false to use +# the overlay text input without initializing microphone or wake-word services. +# WAKE_WORD_ENABLED=false + # ======================== # API Keys (Optional) # ======================== diff --git a/main.py b/main.py index ddf22f9..eca8c0d 100644 --- a/main.py +++ b/main.py @@ -13,8 +13,9 @@ import threading from src.audio.audio_processor import AudioProcessor -from src.audio.listener import Listener +from src.audio.manual_recorder import ManualRecorder, MicrophoneError from src.audio.ttsplayer import TTSPlayer +from src.config import config from src.core.assistant import call_agent from src.core.tools import register_stop_assistant from src.ui.overlay import app, overlay @@ -30,6 +31,7 @@ class DesktopAssistant: def __init__(self): """Initialize the assistant with all required components.""" self.lock = threading.Lock() + self._shutting_down = False self._setup_components() self._setup_ui() @@ -41,11 +43,22 @@ def _setup_components(self): # Audio processing self.audio_processor = AudioProcessor() - self.listener = Listener(tts_player=self.speech, overlay=overlay) + self.manual_recorder = ManualRecorder() + self.listener = None + if config.WAKE_WORD_ENABLED: + # Import lazily: the listener's optional voice-verification stack + # should not be required for text-only operation on macOS. + from src.audio.listener import Listener + + self.listener = Listener(tts_player=self.speech, overlay=overlay) + else: + logger.info("Wake-word detection is disabled; use the overlay text input to submit requests.") def _setup_ui(self): """Setup user interface.""" overlay.on_new_message = self.process_query + overlay.on_recording_toggled = self.handle_manual_recording + overlay.exit_callback = self.shutdown overlay.start() def process_audio(self, audio): @@ -54,8 +67,45 @@ def process_audio(self, audio): logger.info("Processing audio...") overlay.put_message("status", "Analyzing voice...", "gold") transcription = self.audio_processor.process_audio(audio) + if not transcription: + detail = self.audio_processor.last_error or "no speech could be transcribed" + logger.error("Speech transcription did not return text: %s", detail) + overlay.put_message("response", f"Voice input failed: {detail}") + overlay.put_message("status", "Voice transcription failed", "red") + return self.process_query(transcription) + def handle_manual_recording(self, should_record: bool): + """Start or stop explicit microphone capture from the overlay control.""" + if should_record: + try: + self.manual_recorder.start() + except MicrophoneError as exc: + self._report_microphone_error(exc) + return + overlay.put_message("recording", True) + overlay.put_message("status", "Recording… click Stop voice when finished", "skyblue") + return + + try: + audio = self.manual_recorder.stop() + except MicrophoneError as exc: + self._report_microphone_error(exc) + return + + overlay.put_message("recording", False) + overlay.put_message("status", "Transcribing voice…", "gold") + self.process_audio(audio) + + def _report_microphone_error(self, error: Exception): + message = f"Microphone unavailable: {error}" + if config.PLATFORM == "Darwin": + message += " Allow this terminal or IDE in System Settings > Privacy & Security > Microphone." + logger.error(message) + overlay.put_message("recording", False) + overlay.put_message("response", message) + overlay.put_message("status", "Microphone error", "red") + def process_query(self, query: str): """Process the text query.""" overlay.put_message("query", query) @@ -69,24 +119,36 @@ def process_query(self, query: str): self.speech.speak(response) except Exception as e: logger.error(f"Error processing query: {e}") + overlay.put_message("response", f"Error: {e}") overlay.put_message("status", "Error occurred", "red") self.speech.speak("Sorry, an error occurred while processing your request.") def start(self): """Start the assistant.""" - logger.info("πŸ”Š Listening in the background... Say something!") - overlay.put_message("status", "Active", "green") - executor.submit(self.listener.listen, self.process_audio) + if self.listener: + logger.info("πŸ”Š Listening in the background... Say something!") + overlay.put_message("status", "Active", "green") + executor.submit(self.listener.listen, self.process_audio) + else: + logger.info("Wake word is disabled. Use text input or Start voice in the overlay.") + overlay.put_message("status", "Wake word disabled β€” use text or voice", "gold") def shutdown(self): """Clean shutdown of the assistant.""" + if self._shutting_down: + return + self._shutting_down = True self.speech.speak("Shutting down!") overlay.put_message("status", "Shutting down...", "red") logger.info("Shutting down...") - self.listener.stop_listening() + if self.listener: + self.listener.stop_listening() + self.manual_recorder.cancel() self.speech.shutdown() executor.shutdown(wait=False, cancel_futures=True) + # Avoid recursing when this shutdown was initiated by the window close. + overlay.exit_callback = None overlay.close() @@ -95,8 +157,10 @@ def main(): assistant = DesktopAssistant() register_stop_assistant(assistant.shutdown) assistant.start() - app.exec() + exit_code = app.exec() + logger.info("Qt event loop exited with code %s", exit_code) + return exit_code if __name__ == "__main__": - main() + sys.exit(main()) diff --git a/src/audio/audio_processor.py b/src/audio/audio_processor.py index 3bc53c1..2bddd35 100644 --- a/src/audio/audio_processor.py +++ b/src/audio/audio_processor.py @@ -17,30 +17,57 @@ class AudioProcessor: """Handles audio transcription and processing.""" def __init__(self): - self.groq_client = Groq(api_key=config.GROQ_API_KEY) + self.groq_client = Groq(api_key=config.GROQ_API_KEY, timeout=config.TRANSCRIPTION_TIMEOUT) + self.last_error: str | None = None def process_audio(self, audio_data): """Process audio data and return transcription.""" - logger.info("Processing audio...") + self.last_error = None temp_file = config.TEMP_AUDIO_FILE try: - # Convert audio bytes to numpy array and save as WAV + # Both sounddevice's manual recorder and the Linux listener produce + # signed 16-bit mono samples. Persist an explicit PCM WAV accepted + # by Groq's transcription endpoint. audio_array = np.frombuffer(audio_data, dtype=np.int16) - sf.write(temp_file, audio_array, config.SAMPLE_RATE) + if not len(audio_array): + raise ValueError("The recording is empty.") + duration = len(audio_array) / config.SAMPLE_RATE + rms = float(np.sqrt(np.mean(np.square(audio_array.astype(np.float32) / np.iinfo(np.int16).max)))) + logger.info( + "Preparing transcription: %.2fs, %d samples, %d bytes, PCM_16 mono/%dHz, rms=%.5f", + duration, + len(audio_array), + audio_array.nbytes, + config.SAMPLE_RATE, + rms, + ) + if rms < config.SILENCE_RMS_THRESHOLD: + raise ValueError("The recording is silent or below the configured microphone threshold.") + sf.write(temp_file, audio_array, config.SAMPLE_RATE, subtype="PCM_16") with open(temp_file, "rb") as f: + payload = f.read() + logger.info( + "Sending %d-byte WAV to Groq transcription model %s.", len(payload), config.TRANSCRIPTION_MODEL + ) transcription = self.groq_client.audio.transcriptions.create( - file=("temp.wav", f.read()), + file=("jasper-recording.wav", payload), model=config.TRANSCRIPTION_MODEL, response_format="text", prompt=config.TRANSCRIPTION_PROMPT, + language=config.TRANSCRIPTION_LANGUAGE, ) - logger.info(f"Transcription: {transcription}") - return transcription + text = getattr(transcription, "text", transcription) + text = str(text).strip() + if not text: + raise ValueError("Groq returned an empty transcription.") + logger.info("Groq transcription completed (%d characters).", len(text)) + return text except Exception as e: - logger.error(f"Error processing audio: {e}") + self.last_error = str(e) + logger.error("Transcription failed: %s", self.last_error) return None finally: if os.path.exists(temp_file): diff --git a/src/audio/listener.py b/src/audio/listener.py index 46844bd..07e27eb 100644 --- a/src/audio/listener.py +++ b/src/audio/listener.py @@ -1,7 +1,6 @@ import collections import os import struct -import sys import threading import time @@ -9,24 +8,27 @@ import pvporcupine import sounddevice as sd import soundfile as sf -import torch -from resemblyzer import VoiceEncoder, preprocess_wav -torch.set_num_threads(1) - -from src.config import config # noqa: E402 -from src.utils.logger import get_logger # noqa: E402 -from src.utils.thread_executor import executor # noqa: E402 - -model, utils = torch.hub.load(repo_or_dir="snakers4/silero-vad", model="silero_vad") - -get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks = utils +from src.config import config +from src.utils.logger import get_logger +from src.utils.thread_executor import executor logger = get_logger() class Listener: def __init__(self, tts_player=None, overlay=None): + if not config.WAKE_WORD_ENABLED: + raise RuntimeError( + "Wake-word detection is disabled. Use the overlay text input, or set " + "WAKE_WORD_ENABLED=true only with a Porcupine model for this platform." + ) + if config.PLATFORM != "Linux": + raise RuntimeError( + f"No bundled Porcupine wake-word model supports {config.PLATFORM}. " + "Set WAKE_WORD_ENABLED=false and use the overlay text input." + ) + # Audio config self.SAMPLE_RATE = config.SAMPLE_RATE self.CHANNELS = config.CHANNELS @@ -64,6 +66,13 @@ def __init__(self, tts_player=None, overlay=None): self.confidence_threshold = config.CONFIDENCE_THRESHOLD + # These imports can pull in Python-version-specific audio dependencies + # and the VAD model. They are only needed when wake-word mode is active. + import torch + from resemblyzer import VoiceEncoder, preprocess_wav + + torch.set_num_threads(1) + self.vad_model, _ = torch.hub.load(repo_or_dir="snakers4/silero-vad", model="silero_vad") self.voice_encoder = VoiceEncoder() self.OWNER_VOICE_FILE = config.OWNER_VOICE_FILE self.owner_embeddings = None @@ -72,11 +81,10 @@ def __init__(self, tts_player=None, overlay=None): self.owner_embeddings = self.voice_encoder.embed_utterance(preprocess_wav(self.OWNER_VOICE_FILE)) logger.info("βœ… Owner voice file found. Loading embeddings...") else: - logger.error( - "Owner voice file not found. Please record your voice and save it in data/owner.wav\n" - "Run `python setup/record_owner_voice.py` to record your voice." + raise FileNotFoundError( + "Owner voice file not found. Run `python setup/record_owner_voice.py` " + "to save it as data/owner.wav before enabling wake-word detection." ) - sys.exit(1) def int2float(self, sound): abs_max = np.abs(sound).max() @@ -105,7 +113,10 @@ def record_audio(self, frames=None): audio_float32 = self.int2float(audio_chunk) frames.append(audio_chunk) - confidence = model(torch.from_numpy(audio_float32), self.SAMPLE_RATE).item() + # Silero VAD accepts the NumPy buffer directly through Torch. + import torch + + confidence = self.vad_model(torch.from_numpy(audio_float32), self.SAMPLE_RATE).item() if confidence > self.confidence_threshold: silence_frames = 0 diff --git a/src/audio/manual_recorder.py b/src/audio/manual_recorder.py new file mode 100644 index 0000000..f6c3500 --- /dev/null +++ b/src/audio/manual_recorder.py @@ -0,0 +1,120 @@ +"""On-demand microphone capture for platforms without a wake-word model.""" + +import threading +from contextlib import suppress + +import numpy as np +import sounddevice as sd + +from src.config import config +from src.utils.logger import get_logger + +logger = get_logger() + + +class MicrophoneError(RuntimeError): + """Raised when an input device cannot be opened or produces no audio.""" + + +class ManualRecorder: + """Capture int16 microphone samples between explicit start and stop actions.""" + + def __init__(self): + self._lock = threading.Lock() + self._frames: list[np.ndarray] = [] + self._stream = None + self._recording = False + self._callback_error: str | None = None + + @property + def is_recording(self) -> bool: + with self._lock: + return self._recording + + def _capture(self, indata, frames, time_info, status): + """Store a copy because sounddevice reuses its callback buffer.""" + del frames, time_info + with self._lock: + if status: + self._callback_error = str(status) + if self._recording: + self._frames.append(indata.copy()) + + def start(self) -> None: + """Open and begin the default input stream, triggering macOS permission if needed.""" + with self._lock: + if self._recording: + return + self._frames = [] + self._callback_error = None + try: + stream = sd.InputStream( + channels=config.CHANNELS, + samplerate=config.SAMPLE_RATE, + dtype="int16", + blocksize=config.NUM_SAMPLES, + callback=self._capture, + ) + self._recording = True + stream.start() + self._stream = stream + except Exception as exc: + self._recording = False + self._stream = None + raise MicrophoneError(f"Could not access the microphone: {exc}") from exc + + def stop(self) -> np.ndarray: + """Stop capture and return mono int16 audio for ``AudioProcessor``.""" + with self._lock: + if not self._recording: + raise MicrophoneError("Voice recording is not active.") + self._recording = False + stream = self._stream + self._stream = None + frames = self._frames + self._frames = [] + callback_error = self._callback_error + self._callback_error = None + + try: + stream.stop() + stream.close() + except Exception as exc: + raise MicrophoneError(f"Could not stop microphone capture: {exc}") from exc + + if callback_error: + raise MicrophoneError(f"Microphone capture error: {callback_error}") + if not frames: + raise MicrophoneError("No microphone audio was captured. Please try again.") + + audio = np.concatenate(frames, axis=0).reshape(-1) + duration = len(audio) / config.SAMPLE_RATE + normalized = audio.astype(np.float32) / np.iinfo(np.int16).max + rms = float(np.sqrt(np.mean(np.square(normalized)))) + peak = float(np.max(np.abs(normalized))) + logger.info( + "Microphone capture: %.2fs, %d samples, %d bytes, int16 mono/%dHz, rms=%.5f, peak=%.5f", + duration, + len(audio), + audio.nbytes, + config.SAMPLE_RATE, + rms, + peak, + ) + if duration < config.MIN_RECORDING_SECONDS: + raise MicrophoneError( + f"Recording was too short ({duration:.2f}s). Hold recording for at least " + f"{config.MIN_RECORDING_SECONDS:.2f}s." + ) + if rms < config.SILENCE_RMS_THRESHOLD: + raise MicrophoneError( + "No audible microphone input was detected. Check the selected input device and macOS Microphone permission." + ) + return audio + + def cancel(self) -> None: + """Release an active stream without submitting audio.""" + if not self.is_recording: + return + with suppress(MicrophoneError): + self.stop() diff --git a/src/config.py b/src/config.py index 965284e..26b00e4 100644 --- a/src/config.py +++ b/src/config.py @@ -2,6 +2,7 @@ """Centralized configuration management for Desktop assistant.""" import os +import platform from dotenv import load_dotenv @@ -11,6 +12,14 @@ BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +def _env_flag(name: str, default: bool) -> bool: + """Read a boolean environment variable without accepting ambiguous values.""" + value = os.environ.get(name) + if value is None: + return default + return value.strip().lower() in {"1", "true", "yes", "on"} + + class Config: """Configuration settings for the Desktop assistant.""" @@ -22,8 +31,10 @@ class Config: TAVILY_API_KEY = os.environ.get("TAVILY_API_KEY") # LLM Configuration - LLM_MODEL = os.environ.get("LLM_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct") - LLM_PROVIDER = os.environ.get("LLM_PROVIDER", " ") + # Current Groq multimodal model: supports chat, image input, and local + # function calling used by the LangGraph agent and screenshot workflow. + LLM_MODEL = os.environ.get("LLM_MODEL", "qwen/qwen3.8-27b") + LLM_PROVIDER = os.environ.get("LLM_PROVIDER", "groq") LLM_TEMPERATURE = float(os.environ.get("LLM_TEMPERATURE", "0.8")) LLM_API_KEY = { "google": GOOGLE_API_KEY, @@ -37,10 +48,18 @@ class Config: LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO") # Audio Configuration + PLATFORM = platform.system() + # The repository includes only a Linux Porcupine keyword model. Keep wake + # word operation enabled on Linux, but make text input the safe default on + # platforms for which no compatible model is bundled. + WAKE_WORD_ENABLED = _env_flag("WAKE_WORD_ENABLED", PLATFORM == "Linux") SAMPLE_RATE = 16000 CHANNELS = 1 CHUNK_SIZE = SAMPLE_RATE // 10 NUM_SAMPLES = 512 + MIN_RECORDING_SECONDS = float(os.environ.get("MIN_RECORDING_SECONDS", "0.25")) + # Reject all-zero or near-silent captures before spending an API request. + SILENCE_RMS_THRESHOLD = float(os.environ.get("SILENCE_RMS_THRESHOLD", "0.003")) # Voice Activity Detection CONFIDENCE_THRESHOLD = 0.5 diff --git a/tests/test_audio_processor.py b/tests/test_audio_processor.py new file mode 100644 index 0000000..2ea56ce --- /dev/null +++ b/tests/test_audio_processor.py @@ -0,0 +1,50 @@ +"""Tests for Groq transcription boundaries without a network request.""" + +import unittest +from unittest.mock import Mock, mock_open, patch + +import numpy as np + +from src.audio.audio_processor import AudioProcessor + + +class AudioProcessorTests(unittest.TestCase): + def setUp(self): + self.processor = AudioProcessor.__new__(AudioProcessor) + self.processor.groq_client = Mock() + self.processor.last_error = None + + @patch("src.audio.audio_processor.os.path.exists", return_value=False) + @patch("src.audio.audio_processor.sf.write") + @patch("builtins.open", new_callable=mock_open, read_data=b"wav-data") + def test_returns_groq_transcription(self, mock_file, mock_write, mock_exists): + self.processor.groq_client.audio.transcriptions.create.return_value = "recognized request" + + result = self.processor.process_audio(np.full(16000, 4000, dtype=np.int16)) + + assert result == "recognized request" + mock_write.assert_called_once() + mock_file.assert_called_once() + assert mock_exists.called + request = self.processor.groq_client.audio.transcriptions.create.call_args.kwargs + assert request["model"] == "whisper-large-v3-turbo" + assert request["language"] == "en" + + @patch("src.audio.audio_processor.os.path.exists", return_value=False) + @patch("src.audio.audio_processor.sf.write", side_effect=OSError("disk unavailable")) + def test_returns_none_when_audio_cannot_be_written(self, mock_write, mock_exists): + result = self.processor.process_audio(np.full(16000, 4000, dtype=np.int16)) + + assert result is None + mock_write.assert_called_once() + assert mock_exists.called + assert self.processor.last_error == "disk unavailable" + + @patch("src.audio.audio_processor.os.path.exists", return_value=False) + def test_silent_audio_is_rejected_before_api_call(self, mock_exists): + result = self.processor.process_audio(np.zeros(16000, dtype=np.int16)) + + assert result is None + assert "silent" in self.processor.last_error + self.processor.groq_client.audio.transcriptions.create.assert_not_called() + assert mock_exists.called diff --git a/tests/test_manual_recorder.py b/tests/test_manual_recorder.py new file mode 100644 index 0000000..8c90349 --- /dev/null +++ b/tests/test_manual_recorder.py @@ -0,0 +1,83 @@ +"""Unit tests for explicit microphone capture without requiring hardware.""" + +import unittest +from unittest.mock import patch + +import numpy as np + +from src.audio.manual_recorder import ManualRecorder, MicrophoneError + + +class FakeInputStream: + def __init__(self, **kwargs): + self.callback = kwargs["callback"] + self.started = False + self.stopped = False + self.closed = False + + def start(self): + self.started = True + + def stop(self): + self.stopped = True + + def close(self): + self.closed = True + + +class ManualRecorderTests(unittest.TestCase): + @patch("src.audio.manual_recorder.sd.InputStream", FakeInputStream) + def test_start_stop_returns_int16_audio(self): + recorder = ManualRecorder() + recorder.start() + + stream = recorder._stream + stream.callback(np.full((5000, 1), 4000, dtype=np.int16), 5000, None, None) + audio = recorder.stop() + + assert stream.started + assert stream.stopped + assert stream.closed + assert audio.dtype == np.int16 + assert len(audio) == 5000 + assert audio[0] == 4000 + assert not recorder.is_recording + + @patch("src.audio.manual_recorder.sd.InputStream", FakeInputStream) + def test_stop_without_samples_explains_failure(self): + recorder = ManualRecorder() + recorder.start() + + with self.assertRaisesRegex(MicrophoneError, "No microphone audio"): # noqa: PT027 + recorder.stop() + + @patch("src.audio.manual_recorder.sd.InputStream", FakeInputStream) + def test_repeated_start_does_not_open_a_second_stream(self): + recorder = ManualRecorder() + recorder.start() + stream = recorder._stream + recorder.start() + + assert recorder._stream is stream + + @patch("src.audio.manual_recorder.sd.InputStream", FakeInputStream) + def test_callback_error_is_reported_when_stopping(self): + recorder = ManualRecorder() + recorder.start() + recorder._stream.callback(np.array([[1]], dtype=np.int16), 1, None, "input overflow") + + with self.assertRaisesRegex(MicrophoneError, "input overflow"): # noqa: PT027 + recorder.stop() + + @patch("src.audio.manual_recorder.sd.InputStream", FakeInputStream) + def test_silent_microphone_capture_is_rejected(self): + recorder = ManualRecorder() + recorder.start() + recorder._stream.callback(np.zeros((5000, 1), dtype=np.int16), 5000, None, None) + + with self.assertRaisesRegex(MicrophoneError, "No audible microphone input"): # noqa: PT027 + recorder.stop() + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_voice_submission.py b/tests/test_voice_submission.py new file mode 100644 index 0000000..6a50348 --- /dev/null +++ b/tests/test_voice_submission.py @@ -0,0 +1,38 @@ +"""Tests voice-to-agent submission without microphone hardware or Groq access.""" + +import threading +import unittest +from unittest.mock import Mock, patch + +import main + + +class VoiceSubmissionTests(unittest.TestCase): + def setUp(self): + self.assistant = main.DesktopAssistant.__new__(main.DesktopAssistant) + self.assistant.lock = threading.Lock() + self.assistant.audio_processor = Mock() + self.assistant.audio_processor.last_error = None + self.assistant.process_query = Mock() + + @patch.object(main, "overlay") + def test_recognized_speech_uses_existing_query_pipeline(self, mock_overlay): + self.assistant.audio_processor.process_audio.return_value = "turn on the lights" + + self.assistant.process_audio(b"audio") + + self.assistant.process_query.assert_called_once_with("turn on the lights") + mock_overlay.put_message.assert_any_call("status", "Analyzing voice...", "gold") + + @patch.object(main, "overlay") + def test_failed_transcription_is_not_submitted(self, mock_overlay): + self.assistant.audio_processor.process_audio.return_value = None + + self.assistant.process_audio(b"audio") + + self.assistant.process_query.assert_not_called() + mock_overlay.put_message.assert_any_call("status", "Voice transcription failed", "red") + + +if __name__ == "__main__": + unittest.main() From 9f7b0b5244307492333565269a9aee1c8c7898e9 Mon Sep 17 00:00:00 2001 From: Aryan Pandit <20252503008@iiitvadodara.ac.in> Date: Sun, 15 Nov 2026 15:18:07 +0530 Subject: [PATCH 3/3] Improve macOS compatibility and audio handling --- .env.example | 18 +++ README.md | 2 +- pyproject.toml | 11 +- run.sh | 9 +- src/audio/ttsplayer.py | 5 +- src/audio/vad.py | 224 ++---------------------------------- src/config.py | 10 +- src/core/assistant.py | 4 + src/core/generate_prompt.py | 2 +- src/core/tools.py | 32 ++++-- uv.lock | 114 ++++++++++++++---- 11 files changed, 174 insertions(+), 257 deletions(-) diff --git a/.env.example b/.env.example index 0eb9baf..01edd13 100644 --- a/.env.example +++ b/.env.example @@ -27,6 +27,24 @@ GOOGLE_API_KEY="" # Get yours at: https://tavily.com TAVILY_API_KEY="" +# ======================== +# LLM Configuration +# ======================== + +# qwen/qwen3.8-27b supports Groq chat, image input, and local function calls. +LLM_PROVIDER="groq" +LLM_MODEL="qwen/qwen3.8-27b" +LLM_TEMPERATURE="0.8" + +# Groq speech-to-text configuration. whisper-large-v3-turbo is the current +# low-latency successor to the retired distil-whisper-large-v3-en. +TRANSCRIPTION_MODEL="whisper-large-v3-turbo" +TRANSCRIPTION_LANGUAGE="en" +TRANSCRIPTION_TIMEOUT="30" + +# Optional persistent LangGraph conversation identifier. +JASPER_THREAD_ID="jasper" + # ======================== # Logging # ======================== diff --git a/README.md b/README.md index 1d425e1..4261ba0 100644 --- a/README.md +++ b/README.md @@ -258,7 +258,7 @@ SPEAKER_SIMILARITY_THRESHOLD = 0.6 # Voice verification threshold ### LLM Configuration ```bash # In your .env file (or defaults in config.py) -LLM_MODEL="meta-llama/llama-4-scout-17b-16e-instruct" +LLM_MODEL="qwen/qwen3.8-27b" LLM_PROVIDER="groq" LLM_TEMPERATURE=0.8 ``` diff --git a/pyproject.toml b/pyproject.toml index f3b82dd..8327b54 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [project] name = "desktopai" version = "0.1.0" -description = "An intelligent, voice-activated AI assistant for Linux desktop environments" +description = "An intelligent AI desktop assistant with Linux wake-word support" readme = "README.md" license = { text = "MIT" } requires-python = ">=3.12" @@ -11,6 +11,7 @@ classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: End Users/Desktop", "License :: OSI Approved :: MIT License", + "Operating System :: MacOS", "Operating System :: POSIX :: Linux", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.12", @@ -20,9 +21,13 @@ classifiers = [ ] dependencies = [ "adbutils>=2.9.3", + # Python 3.13 removed audioop; resemblyzer's audio stack still imports it. + "audioop-lts>=0.2.1; python_version >= '3.13'", "anthropic>=0.51.0", "colorama>=0.4.6", - "edge-tts>=7.0.2", + # 7.3.0 updates the Edge Read Aloud handshake required after Microsoft's + # legacy endpoint began returning WebSocket 403 responses. + "edge-tts>=7.3.0", "groq>=0.24.0", "langchain>=0.3.25", "langchain-anthropic>=0.3.13", @@ -42,6 +47,8 @@ dependencies = [ "resemblyzer>=0.1.4", "sounddevice>=0.5.2", "soundfile>=0.13.1", + # webrtcvad imports pkg_resources during installation; retain its provider. + "setuptools<81", "torch>=2.0.0", ] diff --git a/run.sh b/run.sh index 24d995d..2bcc1e8 100755 --- a/run.sh +++ b/run.sh @@ -1,2 +1,9 @@ #!/usr/bin/env bash -QT_QPA_PLATFORM=xcb uv run python main.py +set -euo pipefail + +# xcb is a Linux Qt backend. macOS uses Qt's native Cocoa backend by default. +if [[ "$(uname -s)" == "Linux" ]]; then + export QT_QPA_PLATFORM="${QT_QPA_PLATFORM:-xcb}" +fi + +exec uv run python main.py diff --git a/src/audio/ttsplayer.py b/src/audio/ttsplayer.py index 7c276a3..312816c 100644 --- a/src/audio/ttsplayer.py +++ b/src/audio/ttsplayer.py @@ -120,7 +120,10 @@ def shutdown(self): self.stop_event.set() # Wait for the queue to be fully processed try: - self.tts_queue.join(timeout=1.0) + # Queue.join has no timeout. The worker is daemonized, so do not + # block shutdown waiting for an interrupted network synthesis. + if self.tts_queue.empty(): + self.tts_queue.join() except Exception as e: # If we time out, just continue with shutdown logger.error(f"Error joining TTS queue: {e}") diff --git a/src/audio/vad.py b/src/audio/vad.py index 80ad1cd..ac4dcc2 100644 --- a/src/audio/vad.py +++ b/src/audio/vad.py @@ -1,222 +1,12 @@ -""" -Voice Activity Detector (VAD) β€” Standalone module. +"""Backward-compatible name for the active listener implementation. -NOTE: This module is NOT currently used by the main application. -The Listener class in `listener.py` handles wake word detection, speaker -verification, and voice activity detection together. This standalone -VoiceActivityDetector class is kept as a reference implementation for -potential future use β€” e.g., if we want to decouple VAD into its own -component or use it in a different pipeline. +The former standalone implementation duplicated Listener and initialized the +Linux-only wake-word stack at import time. Keeping one implementation ensures +that platform and wake-word guards apply consistently. """ -import collections -import os -import struct -import sys -import threading -import time - -import numpy as np -import pvporcupine -import sounddevice as sd -import soundfile as sf -import torch -from resemblyzer import VoiceEncoder, preprocess_wav - -torch.set_num_threads(1) - -from src.config import config # noqa: E402 -from src.utils.logger import get_logger # noqa: E402 -from src.utils.thread_executor import executor # noqa: E402 - -model, utils = torch.hub.load(repo_or_dir="snakers4/silero-vad", model="silero_vad") - -get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks = utils - -logger = get_logger() - - -class VoiceActivityDetector: - def __init__(self, tts_player=None, overlay=None): - # Audio config - self.SAMPLE_RATE = config.SAMPLE_RATE - self.CHANNELS = config.CHANNELS - self.CHUNK = config.CHUNK_SIZE - self.num_samples = config.NUM_SAMPLES - self.recording = False - self.listening = False - self.lock = threading.Lock() - self.tts_player = tts_player - self.overlay = overlay - - # Load sound effects - self.start_sound, self.start_sr = sf.read(config.START_SOUND_FILE) - self.stop_sound, self.stop_sr = sf.read(config.STOP_SOUND_FILE) - - # Initialize Porcupine - self.porcupine = pvporcupine.create( - access_key=config.PORCUPINE_ACCESS_KEY, - keyword_paths=[config.WAKE_WORD_MODEL], - sensitivities=[0.95], - ) - - # Initialize audio stream - self.stream = sd.InputStream( - channels=self.CHANNELS, - samplerate=self.SAMPLE_RATE, - dtype="int16", - blocksize=self.num_samples, - ) - self.stream.start() - - # Initialize audio output stream - self.output_stream = sd.OutputStream(samplerate=44100, channels=1, dtype="float32") - self.output_stream.start() - - self.confidence_threshold = config.CONFIDENCE_THRESHOLD - - self.voice_encoder = VoiceEncoder() - self.OWNER_VOICE_FILE = config.OWNER_VOICE_FILE - self.owner_embeddings = None - - if os.path.exists(self.OWNER_VOICE_FILE): - self.owner_embeddings = self.voice_encoder.embed_utterance(preprocess_wav(self.OWNER_VOICE_FILE)) - logger.info("βœ… Owner voice file found. Loading embeddings...") - else: - logger.error( - "Owner voice file not found. Please record your voice and save it in data/owner.wav\n" - "Run `python setup/record_owner_voice.py` to record your voice." - ) - sys.exit(1) - - def int2float(self, sound): - abs_max = np.abs(sound).max() - sound = sound.astype("float32") - if abs_max > 0: - sound *= 1 / 32768 - return sound.squeeze() - - def record_audio(self, frames=None): - if frames is None: - frames = [] - with self.lock: - if self.overlay: - self.overlay.put_message("status", "Listening...", "skyblue") - self.recording = True - logger.debug("Recording started...") - # Play start sound effect - self.play_sound(self.start_sound, self.start_sr) - - silence_frames = 0 - max_silence_frames = config.MAX_SILENCE_FRAMES - max_recording_frames = config.MAX_RECORDING_FRAMES - - while silence_frames < max_silence_frames and len(frames) < max_recording_frames: - audio_chunk, _ = self.stream.read(self.num_samples) - audio_float32 = self.int2float(audio_chunk) - frames.append(audio_chunk) - - confidence = model(torch.from_numpy(audio_float32), self.SAMPLE_RATE).item() - - if confidence > self.confidence_threshold: - silence_frames = 0 - else: - silence_frames += 1 - - # Convert frames to numpy array - audio_data = np.concatenate(frames[:-60]) - self.recording = False - logger.debug("Recording stopped...") - # Play stop sound effect - self.play_sound(self.stop_sound, self.stop_sr) - - if self.overlay: - self.overlay.put_message("status", "Active", "green") - return audio_data - - def listen(self, func): - self.listening = True - frame_queue = collections.deque(maxlen=60) # for audio_chunk frames (int16) - float_queue = collections.deque(maxlen=60) # for speaker verification (float32) - - while self.listening: - if self.recording: - time.sleep(0.01) # Add small delay to prevent busy waiting - continue - - audio_chunk, _ = self.stream.read(self.num_samples) - audio_float = self.int2float(audio_chunk) - - # Add current frame to queue - frame_queue.append(audio_chunk) - float_queue.append(audio_float) - - # Check for wake word if not already recording - pcm = struct.unpack_from("h" * self.porcupine.frame_length, audio_chunk.tobytes()) - keyword_index = self.porcupine.process(pcm) - if keyword_index == -1: - continue - logger.debug("🎯 Wake word detected!") - - # === Speaker verification before continuing === - if self.owner_embeddings is not None: - float_buffer = np.concatenate(list(float_queue)) # ~1s of audio - predicted_embedding = self.voice_encoder.embed_utterance(float_buffer) - similarity = np.dot(self.owner_embeddings, predicted_embedding) - - logger.debug(f"πŸ” Speaker similarity: {similarity:.3f}") - if similarity < config.SPEAKER_SIMILARITY_THRESHOLD: - logger.warning("🚫 Voice does not match owner. Ignoring wake word.") - continue # Skip further processing - - logger.info("βœ… Speaker verified as owner") - - # Stop TTS playback if available - if self.tts_player: - self.tts_player.stop_current() - logger.debug("Stopped TTS playback due to wake word detection") - - audio_data = self.record_audio(list(frame_queue)) - - # Process in a separate thread to avoid blocking the main loop - future = executor.submit(func, audio_data) - try: - future.result(timeout=config.AUDIO_PROCESSING_TIMEOUT) - except Exception as e: - logger.error(f"Error processing audio: {e}") - - logger.info("πŸ‘‹ Stopped listening") - - def stop_listening(self): - self.listening = False - if hasattr(self, "porcupine"): - self.porcupine.delete() - if hasattr(self, "stream"): - self.stream.stop() - self.stream.close() - if hasattr(self, "output_stream"): - self.output_stream.stop() - self.output_stream.close() - - def play_sound(self, sound_data, sample_rate): - # Stop any currently playing sound - self.output_stream.stop() - self.output_stream.start() - # Convert sound data to float32 before playing - sound_data = sound_data.astype("float32") - # Play the new sound - self.output_stream.write(sound_data) - - def play_audio(self, audio_data): - duration_seconds = len(audio_data) / self.SAMPLE_RATE - logger.debug(f"Received audio data of length: {len(audio_data)} samples ({duration_seconds:.2f} seconds)") - - # Play back the recorded audio - sd.play(audio_data, self.SAMPLE_RATE) - sd.wait() # Wait until audio is finished playing +from src.audio.listener import Listener -if __name__ == "__main__": - # Example usage - vad = VoiceActivityDetector() - vad.listen(vad.play_audio) +class VoiceActivityDetector(Listener): + """Compatibility alias for callers that use the former VAD class.""" diff --git a/src/config.py b/src/config.py index 26b00e4..6d558b7 100644 --- a/src/config.py +++ b/src/config.py @@ -95,14 +95,20 @@ class Config: AUDIO_PROCESSING_TIMEOUT = 10 # Agent Configuration - THREAD_ID = "4" + # A named configurable thread avoids reusing the repository's old numeric + # checkpoint, whose stale messages can affect responses after model swaps. + THREAD_ID = os.environ.get("JASPER_THREAD_ID", "jasper") MAX_TOKENS_HISTORY = 10000 # Personalization β€” customize the assistant's identity ASSISTANT_NAME = os.environ.get("ASSISTANT_NAME", "Jasper") # Whisper Configuration - TRANSCRIPTION_MODEL = "distil-whisper-large-v3-en" + # Groq retired distil-whisper-large-v3-en; Turbo is the supported low- + # latency successor and accepts 16 kHz mono WAV generated by Jasper. + TRANSCRIPTION_MODEL = os.environ.get("TRANSCRIPTION_MODEL", "whisper-large-v3-turbo") + TRANSCRIPTION_LANGUAGE = os.environ.get("TRANSCRIPTION_LANGUAGE", "en") + TRANSCRIPTION_TIMEOUT = float(os.environ.get("TRANSCRIPTION_TIMEOUT", "30")) TRANSCRIPTION_PROMPT = ( "Please transcribe the following audio accurately, maintaining proper " "punctuation and formatting. This is a conversation between a user and " diff --git a/src/core/assistant.py b/src/core/assistant.py index f24902b..667ea1b 100644 --- a/src/core/assistant.py +++ b/src/core/assistant.py @@ -1,5 +1,6 @@ # assistant.py import base64 +import os import sqlite3 from langchain_core.messages import HumanMessage @@ -16,6 +17,9 @@ logger = get_logger() +# A fresh checkout does not contain this runtime directory. Create only the +# parent directory, leaving the SQLite file itself to sqlite3. +os.makedirs(os.path.dirname(config.CHECKPOINTS_DB), exist_ok=True) conn = sqlite3.connect(config.CHECKPOINTS_DB, check_same_thread=False) checkpointer = SqliteSaver(conn) diff --git a/src/core/generate_prompt.py b/src/core/generate_prompt.py index dbb1ee2..3781d57 100644 --- a/src/core/generate_prompt.py +++ b/src/core/generate_prompt.py @@ -46,7 +46,7 @@ def prompt(state: AgentState, config: RunnableConfig) -> list[Any]: user_profile = _build_user_profile() system_msg = f""" -You are **{assistant_name}**, a witty, intelligent desktop AI assistant running locally on {owner_name}'s Linux machine. +You are **{assistant_name}**, a witty, intelligent desktop AI assistant running locally on {owner_name}'s {app_config.PLATFORM} machine. ### 🧠 Your Purpose: diff --git a/src/core/tools.py b/src/core/tools.py index 6bf917d..70ecfee 100644 --- a/src/core/tools.py +++ b/src/core/tools.py @@ -1,4 +1,5 @@ import functools +import platform import subprocess from typing import Literal @@ -7,6 +8,7 @@ from langchain_core.tools import tool as _tool from langchain_core.tools.structured import StructuredTool from langchain_tavily import TavilySearch +from langchain_tavily._utilities import TavilySearchAPIWrapper from PIL import ImageGrab from src.config import config @@ -74,7 +76,7 @@ def wrapper(*args, **kwargs): @tool def run_command(command: str) -> str: - """Run a shell command on the local Linux machine.""" + """Run a shell command on the local machine.""" return subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, text=True) @@ -83,11 +85,21 @@ def open_google_chrome(url: str | None, new_window: bool = False) -> str: """ Open Google Chrome with the specified URL (if url is provided). """ - command = f"google-chrome-stable {'--new-window' if new_window else ''} {url if url else ''}" - logger.info(f"[open_google_chrome] Command: {command}") - try: - subprocess.Popen(command, shell=True) + if platform.system() == "Darwin": + command = ["open", "-a", "Google Chrome"] + if new_window: + command.insert(1, "-n") + if url: + command.append(url) + else: + command = ["google-chrome-stable"] + if new_window: + command.append("--new-window") + if url: + command.append(url) + logger.info(f"[open_google_chrome] Command: {command}") + subprocess.Popen(command) return f"Google Chrome opened with URL: {url}" except Exception as e: logger.error(f"[open_google_chrome] Error: {e}") @@ -101,7 +113,10 @@ def open_whatsapp_web() -> str: """ logger.info("[open_whatsapp_web] Opening WhatsApp Web...") try: - subprocess.Popen(["gtk-launch", "chrome-hnpfjngllnobngcgfapefoaidbinmjnm-Default.desktop"]) + if platform.system() == "Darwin": + subprocess.Popen(["open", "https://web.whatsapp.com"]) + else: + subprocess.Popen(["gtk-launch", "chrome-hnpfjngllnobngcgfapefoaidbinmjnm-Default.desktop"]) return "WhatsApp Web launched." except Exception as e: logger.error(f"[open_whatsapp_web] Error: {e}") @@ -171,8 +186,11 @@ def web_search( """ Execute a search query using the Tavily Search API. """ + if not config.TAVILY_API_KEY: + return "Web search is not configured: set TAVILY_API_KEY to enable it." + search_tool = TavilySearch( - api_key=config.TAVILY_API_KEY, + api_wrapper=TavilySearchAPIWrapper(tavily_api_key=config.TAVILY_API_KEY), max_results=max_results, search_depth=search_depth, ) diff --git a/uv.lock b/uv.lock index d348af4..48c7ecd 100644 --- a/uv.lock +++ b/uv.lock @@ -1,6 +1,10 @@ version = 1 -revision = 3 +revision = 5 requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.13'", + "python_full_version < '3.13'", +] [[package]] name = "adbutils" @@ -200,6 +204,62 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, ] +[[package]] +name = "audioop-lts" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/53/946db57842a50b2da2e0c1e34bd37f36f5aadba1a929a3971c5d7841dbca/audioop_lts-0.2.2.tar.gz", hash = "sha256:64d0c62d88e67b98a1a5e71987b7aa7b5bcffc7dcee65b635823dbdd0a8dbbd0", size = 30686, upload-time = "2025-08-05T16:43:17.409Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/d4/94d277ca941de5a507b07f0b592f199c22454eeaec8f008a286b3fbbacd6/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd3d4602dc64914d462924a08c1a9816435a2155d74f325853c1f1ac3b2d9800", size = 46523, upload-time = "2025-08-05T16:42:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/f8/5a/656d1c2da4b555920ce4177167bfeb8623d98765594af59702c8873f60ec/audioop_lts-0.2.2-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:550c114a8df0aafe9a05442a1162dfc8fec37e9af1d625ae6060fed6e756f303", size = 27455, upload-time = "2025-08-05T16:42:22.283Z" }, + { url = "https://files.pythonhosted.org/packages/1b/83/ea581e364ce7b0d41456fb79d6ee0ad482beda61faf0cab20cbd4c63a541/audioop_lts-0.2.2-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:9a13dc409f2564de15dd68be65b462ba0dde01b19663720c68c1140c782d1d75", size = 26997, upload-time = "2025-08-05T16:42:23.849Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3b/e8964210b5e216e5041593b7d33e97ee65967f17c282e8510d19c666dab4/audioop_lts-0.2.2-cp313-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51c916108c56aa6e426ce611946f901badac950ee2ddaf302b7ed35d9958970d", size = 85844, upload-time = "2025-08-05T16:42:25.208Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2e/0a1c52faf10d51def20531a59ce4c706cb7952323b11709e10de324d6493/audioop_lts-0.2.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47eba38322370347b1c47024defbd36374a211e8dd5b0dcbce7b34fdb6f8847b", size = 85056, upload-time = "2025-08-05T16:42:26.559Z" }, + { url = "https://files.pythonhosted.org/packages/75/e8/cd95eef479656cb75ab05dfece8c1f8c395d17a7c651d88f8e6e291a63ab/audioop_lts-0.2.2-cp313-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba7c3a7e5f23e215cb271516197030c32aef2e754252c4c70a50aaff7031a2c8", size = 93892, upload-time = "2025-08-05T16:42:27.902Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1e/a0c42570b74f83efa5cca34905b3eef03f7ab09fe5637015df538a7f3345/audioop_lts-0.2.2-cp313-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def246fe9e180626731b26e89816e79aae2276f825420a07b4a647abaa84becc", size = 96660, upload-time = "2025-08-05T16:42:28.9Z" }, + { url = "https://files.pythonhosted.org/packages/50/d5/8a0ae607ca07dbb34027bac8db805498ee7bfecc05fd2c148cc1ed7646e7/audioop_lts-0.2.2-cp313-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e160bf9df356d841bb6c180eeeea1834085464626dc1b68fa4e1d59070affdc3", size = 79143, upload-time = "2025-08-05T16:42:29.929Z" }, + { url = "https://files.pythonhosted.org/packages/12/17/0d28c46179e7910bfb0bb62760ccb33edb5de973052cb2230b662c14ca2e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4b4cd51a57b698b2d06cb9993b7ac8dfe89a3b2878e96bc7948e9f19ff51dba6", size = 84313, upload-time = "2025-08-05T16:42:30.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/ba/bd5d3806641564f2024e97ca98ea8f8811d4e01d9b9f9831474bc9e14f9e/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4a53aa7c16a60a6857e6b0b165261436396ef7293f8b5c9c828a3a203147ed4a", size = 93044, upload-time = "2025-08-05T16:42:31.959Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5e/435ce8d5642f1f7679540d1e73c1c42d933331c0976eb397d1717d7f01a3/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:3fc38008969796f0f689f1453722a0f463da1b8a6fbee11987830bfbb664f623", size = 78766, upload-time = "2025-08-05T16:42:33.302Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3b/b909e76b606cbfd53875693ec8c156e93e15a1366a012f0b7e4fb52d3c34/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:15ab25dd3e620790f40e9ead897f91e79c0d3ce65fe193c8ed6c26cffdd24be7", size = 87640, upload-time = "2025-08-05T16:42:34.854Z" }, + { url = "https://files.pythonhosted.org/packages/30/e7/8f1603b4572d79b775f2140d7952f200f5e6c62904585d08a01f0a70393a/audioop_lts-0.2.2-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:03f061a1915538fd96272bac9551841859dbb2e3bf73ebe4a23ef043766f5449", size = 86052, upload-time = "2025-08-05T16:42:35.839Z" }, + { url = "https://files.pythonhosted.org/packages/b5/96/c37846df657ccdda62ba1ae2b6534fa90e2e1b1742ca8dcf8ebd38c53801/audioop_lts-0.2.2-cp313-abi3-win32.whl", hash = "sha256:3bcddaaf6cc5935a300a8387c99f7a7fbbe212a11568ec6cf6e4bc458c048636", size = 26185, upload-time = "2025-08-05T16:42:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/34/a5/9d78fdb5b844a83da8a71226c7bdae7cc638861085fff7a1d707cb4823fa/audioop_lts-0.2.2-cp313-abi3-win_amd64.whl", hash = "sha256:a2c2a947fae7d1062ef08c4e369e0ba2086049a5e598fda41122535557012e9e", size = 30503, upload-time = "2025-08-05T16:42:38.427Z" }, + { url = "https://files.pythonhosted.org/packages/34/25/20d8fde083123e90c61b51afb547bb0ea7e77bab50d98c0ab243d02a0e43/audioop_lts-0.2.2-cp313-abi3-win_arm64.whl", hash = "sha256:5f93a5db13927a37d2d09637ccca4b2b6b48c19cd9eda7b17a2e9f77edee6a6f", size = 24173, upload-time = "2025-08-05T16:42:39.704Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/0a764f77b5c4ac58dc13c01a580f5d32ae8c74c92020b961556a43e26d02/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:73f80bf4cd5d2ca7814da30a120de1f9408ee0619cc75da87d0641273d202a09", size = 47096, upload-time = "2025-08-05T16:42:40.684Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ed/ebebedde1a18848b085ad0fa54b66ceb95f1f94a3fc04f1cd1b5ccb0ed42/audioop_lts-0.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:106753a83a25ee4d6f473f2be6b0966fc1c9af7e0017192f5531a3e7463dce58", size = 27748, upload-time = "2025-08-05T16:42:41.992Z" }, + { url = "https://files.pythonhosted.org/packages/cb/6e/11ca8c21af79f15dbb1c7f8017952ee8c810c438ce4e2b25638dfef2b02c/audioop_lts-0.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fbdd522624141e40948ab3e8cdae6e04c748d78710e9f0f8d4dae2750831de19", size = 27329, upload-time = "2025-08-05T16:42:42.987Z" }, + { url = "https://files.pythonhosted.org/packages/84/52/0022f93d56d85eec5da6b9da6a958a1ef09e80c39f2cc0a590c6af81dcbb/audioop_lts-0.2.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:143fad0311e8209ece30a8dbddab3b65ab419cbe8c0dde6e8828da25999be911", size = 92407, upload-time = "2025-08-05T16:42:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/87/1d/48a889855e67be8718adbc7a01f3c01d5743c325453a5e81cf3717664aad/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfbbc74ec68a0fd08cfec1f4b5e8cca3d3cd7de5501b01c4b5d209995033cde9", size = 91811, upload-time = "2025-08-05T16:42:45.325Z" }, + { url = "https://files.pythonhosted.org/packages/98/a6/94b7213190e8077547ffae75e13ed05edc488653c85aa5c41472c297d295/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cfcac6aa6f42397471e4943e0feb2244549db5c5d01efcd02725b96af417f3fe", size = 100470, upload-time = "2025-08-05T16:42:46.468Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/78450d7cb921ede0cfc33426d3a8023a3bda755883c95c868ee36db8d48d/audioop_lts-0.2.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:752d76472d9804ac60f0078c79cdae8b956f293177acd2316cd1e15149aee132", size = 103878, upload-time = "2025-08-05T16:42:47.576Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e2/cd5439aad4f3e34ae1ee852025dc6aa8f67a82b97641e390bf7bd9891d3e/audioop_lts-0.2.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:83c381767e2cc10e93e40281a04852facc4cd9334550e0f392f72d1c0a9c5753", size = 84867, upload-time = "2025-08-05T16:42:49.003Z" }, + { url = "https://files.pythonhosted.org/packages/68/4b/9d853e9076c43ebba0d411e8d2aa19061083349ac695a7d082540bad64d0/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c0022283e9556e0f3643b7c3c03f05063ca72b3063291834cca43234f20c60bb", size = 90001, upload-time = "2025-08-05T16:42:50.038Z" }, + { url = "https://files.pythonhosted.org/packages/58/26/4bae7f9d2f116ed5593989d0e521d679b0d583973d203384679323d8fa85/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a2d4f1513d63c795e82948e1305f31a6d530626e5f9f2605408b300ae6095093", size = 99046, upload-time = "2025-08-05T16:42:51.111Z" }, + { url = "https://files.pythonhosted.org/packages/b2/67/a9f4fb3e250dda9e9046f8866e9fa7d52664f8985e445c6b4ad6dfb55641/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:c9c8e68d8b4a56fda8c025e538e639f8c5953f5073886b596c93ec9b620055e7", size = 84788, upload-time = "2025-08-05T16:42:52.198Z" }, + { url = "https://files.pythonhosted.org/packages/70/f7/3de86562db0121956148bcb0fe5b506615e3bcf6e63c4357a612b910765a/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:96f19de485a2925314f5020e85911fb447ff5fbef56e8c7c6927851b95533a1c", size = 94472, upload-time = "2025-08-05T16:42:53.59Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/fd772bf9078ae1001207d2df1eef3da05bea611a87dd0e8217989b2848fa/audioop_lts-0.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e541c3ef484852ef36545f66209444c48b28661e864ccadb29daddb6a4b8e5f5", size = 92279, upload-time = "2025-08-05T16:42:54.632Z" }, + { url = "https://files.pythonhosted.org/packages/4f/41/affea7181592ab0ab560044632571a38edaf9130b84928177823fbf3176a/audioop_lts-0.2.2-cp313-cp313t-win32.whl", hash = "sha256:d5e73fa573e273e4f2e5ff96f9043858a5e9311e94ffefd88a3186a910c70917", size = 26568, upload-time = "2025-08-05T16:42:55.627Z" }, + { url = "https://files.pythonhosted.org/packages/28/2b/0372842877016641db8fc54d5c88596b542eec2f8f6c20a36fb6612bf9ee/audioop_lts-0.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:9191d68659eda01e448188f60364c7763a7ca6653ed3f87ebb165822153a8547", size = 30942, upload-time = "2025-08-05T16:42:56.674Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/baf2b9cc7e96c179bb4a54f30fcd83e6ecb340031bde68f486403f943768/audioop_lts-0.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:c174e322bb5783c099aaf87faeb240c8d210686b04bd61dfd05a8e5a83d88969", size = 24603, upload-time = "2025-08-05T16:42:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/5c/73/413b5a2804091e2c7d5def1d618e4837f1cb82464e230f827226278556b7/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f9ee9b52f5f857fbaf9d605a360884f034c92c1c23021fb90b2e39b8e64bede6", size = 47104, upload-time = "2025-08-05T16:42:58.518Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/daa3308dc6593944410c2c68306a5e217f5c05b70a12e70228e7dd42dc5c/audioop_lts-0.2.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:49ee1a41738a23e98d98b937a0638357a2477bc99e61b0f768a8f654f45d9b7a", size = 27754, upload-time = "2025-08-05T16:43:00.132Z" }, + { url = "https://files.pythonhosted.org/packages/4e/86/c2e0f627168fcf61781a8f72cab06b228fe1da4b9fa4ab39cfb791b5836b/audioop_lts-0.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5b00be98ccd0fc123dcfad31d50030d25fcf31488cde9e61692029cd7394733b", size = 27332, upload-time = "2025-08-05T16:43:01.666Z" }, + { url = "https://files.pythonhosted.org/packages/c7/bd/35dce665255434f54e5307de39e31912a6f902d4572da7c37582809de14f/audioop_lts-0.2.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6d2e0f9f7a69403e388894d4ca5ada5c47230716a03f2847cfc7bd1ecb589d6", size = 92396, upload-time = "2025-08-05T16:43:02.991Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d2/deeb9f51def1437b3afa35aeb729d577c04bcd89394cb56f9239a9f50b6f/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9b0b8a03ef474f56d1a842af1a2e01398b8f7654009823c6d9e0ecff4d5cfbf", size = 91811, upload-time = "2025-08-05T16:43:04.096Z" }, + { url = "https://files.pythonhosted.org/packages/76/3b/09f8b35b227cee28cc8231e296a82759ed80c1a08e349811d69773c48426/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2b267b70747d82125f1a021506565bdc5609a2b24bcb4773c16d79d2bb260bbd", size = 100483, upload-time = "2025-08-05T16:43:05.085Z" }, + { url = "https://files.pythonhosted.org/packages/0b/15/05b48a935cf3b130c248bfdbdea71ce6437f5394ee8533e0edd7cfd93d5e/audioop_lts-0.2.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0337d658f9b81f4cd0fdb1f47635070cc084871a3d4646d9de74fdf4e7c3d24a", size = 103885, upload-time = "2025-08-05T16:43:06.197Z" }, + { url = "https://files.pythonhosted.org/packages/83/80/186b7fce6d35b68d3d739f228dc31d60b3412105854edb975aa155a58339/audioop_lts-0.2.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:167d3b62586faef8b6b2275c3218796b12621a60e43f7e9d5845d627b9c9b80e", size = 84899, upload-time = "2025-08-05T16:43:07.291Z" }, + { url = "https://files.pythonhosted.org/packages/49/89/c78cc5ac6cb5828f17514fb12966e299c850bc885e80f8ad94e38d450886/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0d9385e96f9f6da847f4d571ce3cb15b5091140edf3db97276872647ce37efd7", size = 89998, upload-time = "2025-08-05T16:43:08.335Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/6401888d0c010e586c2ca50fce4c903d70a6bb55928b16cfbdfd957a13da/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:48159d96962674eccdca9a3df280e864e8ac75e40a577cc97c5c42667ffabfc5", size = 99046, upload-time = "2025-08-05T16:43:09.367Z" }, + { url = "https://files.pythonhosted.org/packages/de/f8/c874ca9bb447dae0e2ef2e231f6c4c2b0c39e31ae684d2420b0f9e97ee68/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fefe5868cd082db1186f2837d64cfbfa78b548ea0d0543e9b28935ccce81ce9", size = 84843, upload-time = "2025-08-05T16:43:10.749Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c0/0323e66f3daebc13fd46b36b30c3be47e3fc4257eae44f1e77eb828c703f/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:58cf54380c3884fb49fdd37dfb7a772632b6701d28edd3e2904743c5e1773602", size = 94490, upload-time = "2025-08-05T16:43:12.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/6b/acc7734ac02d95ab791c10c3f17ffa3584ccb9ac5c18fd771c638ed6d1f5/audioop_lts-0.2.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:088327f00488cdeed296edd9215ca159f3a5a5034741465789cad403fcf4bec0", size = 92297, upload-time = "2025-08-05T16:43:13.139Z" }, + { url = "https://files.pythonhosted.org/packages/13/c3/c3dc3f564ce6877ecd2a05f8d751b9b27a8c320c2533a98b0c86349778d0/audioop_lts-0.2.2-cp314-cp314t-win32.whl", hash = "sha256:068aa17a38b4e0e7de771c62c60bbca2455924b67a8814f3b0dee92b5820c0b3", size = 27331, upload-time = "2025-08-05T16:43:14.19Z" }, + { url = "https://files.pythonhosted.org/packages/72/bb/b4608537e9ffcb86449091939d52d24a055216a36a8bf66b936af8c3e7ac/audioop_lts-0.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:a5bf613e96f49712073de86f20dbdd4014ca18efd4d34ed18c75bd808337851b", size = 31697, upload-time = "2025-08-05T16:43:15.193Z" }, + { url = "https://files.pythonhosted.org/packages/f6/22/91616fe707a5c5510de2cac9b046a30defe7007ba8a0c04f9c08f27df312/audioop_lts-0.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:b492c3b040153e68b9fdaff5913305aaaba5bb433d8a7f73d5cf6a64ed3cc1dd", size = 25206, upload-time = "2025-08-05T16:43:16.444Z" }, +] + [[package]] name = "certifi" version = "2026.7.22" @@ -479,43 +539,43 @@ wheels = [ [package.optional-dependencies] cublas = [ - { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cublas", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-cuda-nvrtc", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cudart = [ - { name = "nvidia-cuda-runtime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cuda-runtime", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cufft = [ - { name = "nvidia-cufft", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cufft", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cufile = [ - { name = "nvidia-cufile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cufile", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cupti = [ - { name = "nvidia-cuda-cupti", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cuda-cupti", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] curand = [ - { name = "nvidia-curand", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-curand", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cusolver = [ - { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-cusolver", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cublas", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-cusolver", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-cusparse", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] cusparse = [ - { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, - { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cusparse", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, + { name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] nvjitlink = [ - { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-nvjitlink", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] nvrtc = [ - { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cuda-nvrtc", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] nvtx = [ - { name = "nvidia-nvtx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-nvtx", marker = "platform_machine == 'aarch64' or platform_machine == 'x86_64'" }, ] [[package]] @@ -546,6 +606,7 @@ source = { virtual = "." } dependencies = [ { name = "adbutils" }, { name = "anthropic" }, + { name = "audioop-lts", marker = "python_full_version >= '3.13'" }, { name = "colorama" }, { name = "edge-tts" }, { name = "groq" }, @@ -565,6 +626,7 @@ dependencies = [ { name = "pyqt5" }, { name = "python-dotenv" }, { name = "resemblyzer" }, + { name = "setuptools" }, { name = "sounddevice" }, { name = "soundfile" }, { name = "torch" }, @@ -579,8 +641,9 @@ dev = [ requires-dist = [ { name = "adbutils", specifier = ">=2.9.3" }, { name = "anthropic", specifier = ">=0.51.0" }, + { name = "audioop-lts", marker = "python_full_version >= '3.13'", specifier = ">=0.2.1" }, { name = "colorama", specifier = ">=0.4.6" }, - { name = "edge-tts", specifier = ">=7.0.2" }, + { name = "edge-tts", specifier = ">=7.3.0" }, { name = "groq", specifier = ">=0.24.0" }, { name = "langchain", specifier = ">=0.3.25" }, { name = "langchain-anthropic", specifier = ">=0.3.13" }, @@ -598,6 +661,7 @@ requires-dist = [ { name = "pyqt5", specifier = ">=5.15.11" }, { name = "python-dotenv", specifier = ">=1.1.0" }, { name = "resemblyzer", specifier = ">=0.1.4" }, + { name = "setuptools", specifier = "<81" }, { name = "sounddevice", specifier = ">=0.5.2" }, { name = "soundfile", specifier = ">=0.13.1" }, { name = "torch", specifier = ">=2.0.0" }, @@ -626,7 +690,7 @@ wheels = [ [[package]] name = "edge-tts" -version = "7.2.8" +version = "7.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, @@ -634,9 +698,9 @@ dependencies = [ { name = "tabulate" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3f/60/afbf548b43c78355e03926c6b1fff7500303a2da4d84db9e1324119e21ae/edge_tts-7.2.8.tar.gz", hash = "sha256:fcf185a0d527a0d2d003f9d5841facc1d5e0e7b3b88d5df9c32990402c6b8cd0", size = 27875, upload-time = "2026-03-22T19:57:50.962Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/ce/14e713ba774063e00444a091eb790539fe0d848a9d8df35fd81a7639a28e/edge_tts-7.3.1.tar.gz", hash = "sha256:ee1fabf911b9ea83b38ae93aee5619ee41eaf0b109fef6e65d797dc4ebf1f20f", size = 35843, upload-time = "2026-10-13T18:22:53.226Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/2b/a8cb687b92a2690d2ad171f0c2fd1c8f18690363cca7618bab2bbe4cdf2b/edge_tts-7.2.8-py3-none-any.whl", hash = "sha256:361fe48ce7ef613adbe30f664e3765dd71029c6cb57427279eff8ad6df2eb211", size = 31026, upload-time = "2026-03-22T19:57:49.672Z" }, + { url = "https://files.pythonhosted.org/packages/35/86/3b97d755992777d5a9ca0e45a8ec96cc9858b2d6dd8f65f3f688d60e8709/edge_tts-7.3.1-py3-none-any.whl", hash = "sha256:2a3c79d6235a7a736d681233823ce5492e829b43eb47beae49aa181237a8f9a4", size = 38908, upload-time = "2026-10-13T18:22:51.772Z" }, ] [[package]] @@ -2533,11 +2597,11 @@ wheels = [ [[package]] name = "setuptools" -version = "84.0.0" +version = "80.10.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/44/f5da03a8ef95d369145c5bb53050e7877c9f3d312e128605fd9504829143/setuptools-84.0.0.tar.gz", hash = "sha256:f4695c21257f0d9b537ec2692c941d02ee143b7cc1276941349a546573b2ef73", size = 1168449, upload-time = "2026-08-08T18:27:58.365Z" } +sdist = { url = "https://files.pythonhosted.org/packages/76/95/faf61eb8363f26aa7e1d762267a8d602a1b26d4f3a1e758e92cb3cb8b054/setuptools-80.10.2.tar.gz", hash = "sha256:8b0e9d10c784bf7d262c4e5ec5d4ec94127ce206e8738f29a437945fbc219b70", size = 1200343, upload-time = "2026-01-25T22:38:17.252Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/95/9c/c510029fc6ef33a6275cd2c5d3cecd6613dfd6aa401d57c54f1c18852ccf/setuptools-84.0.0-py3-none-any.whl", hash = "sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670", size = 818216, upload-time = "2026-08-08T18:27:56.719Z" }, + { url = "https://files.pythonhosted.org/packages/94/b8/f1f62a5e3c0ad2ff1d189590bfa4c46b4f3b6e49cef6f26c6ee4e575394d/setuptools-80.10.2-py3-none-any.whl", hash = "sha256:95b30ddfb717250edb492926c92b5221f7ef3fbcc2b07579bcd4a27da21d0173", size = 1064234, upload-time = "2026-01-25T22:38:15.216Z" }, ] [[package]]