| from __future__ import annotations |
|
|
| import base64 |
| from pathlib import Path |
| from typing import Any |
| from urllib.parse import urlsplit |
|
|
| from ..http import post_json |
| from ..models import SttMode, SttModelConfig, TranscriptionResult |
| from .audio import wav_audio_bytes |
|
|
| MODAL_ENDPOINT_DESCRIPTION = "Modal managed endpoint (set MODAL_INKLING_ENDPOINT)" |
| MODAL_DEFAULT_SAMPLE_RATE_HZ = 16000 |
| MODAL_DEFAULT_CHANNELS = 1 |
| MODAL_DEFAULT_PROMPT = "Transcribe the following speech to text." |
| MODAL_DEFAULT_MAX_TOKENS = 4096 |
| MODAL_DEFAULT_REASONING_EFFORT = "max" |
| MODAL_REASONING_EFFORTS = {"none", "minimal", "low", "medium", "high", "max"} |
| MODAL_DEFAULT_TIMEOUT_SECONDS = 600.0 |
| MODAL_DEFAULT_MAX_ATTEMPTS = 10 |
|
|
|
|
| def transcribe( |
| audio_path: Path, |
| stt_model: SttModelConfig, |
| endpoint: str, |
| proxy_token_id: str, |
| proxy_token_secret: str, |
| ) -> TranscriptionResult: |
| if stt_model.mode != SttMode.BATCH: |
| raise ValueError("Modal Inkling is only supported through batch chat completions.") |
| sample_rate = int(stt_model.options.get("sample_rate", MODAL_DEFAULT_SAMPLE_RATE_HZ)) |
| channels = int(stt_model.options.get("channels", MODAL_DEFAULT_CHANNELS)) |
| audio = wav_audio_bytes(audio_path, sample_rate=sample_rate, channels=channels) |
| payload = modal_transcription_payload(audio, stt_model) |
| response = post_json( |
| modal_chat_completions_endpoint(endpoint), |
| payload, |
| { |
| "Modal-Key": proxy_token_id, |
| "Modal-Secret": proxy_token_secret, |
| }, |
| timeout=float(stt_model.options.get("timeout_seconds", MODAL_DEFAULT_TIMEOUT_SECONDS)), |
| max_attempts=int(stt_model.options.get("max_attempts", MODAL_DEFAULT_MAX_ATTEMPTS)), |
| retryable_empty_error_status_codes={400}, |
| ) |
| return {"transcript": modal_transcript_from_response(response)} |
|
|
|
|
| def modal_chat_completions_endpoint(endpoint: str) -> str: |
| normalized = endpoint.strip().rstrip("/") |
| parsed = urlsplit(normalized) |
| if parsed.scheme != "https" or not parsed.netloc: |
| raise ValueError("MODAL_INKLING_ENDPOINT must be a valid HTTPS URL.") |
| if normalized.endswith("/v1/chat/completions"): |
| return normalized |
| if normalized.endswith("/v1"): |
| return f"{normalized}/chat/completions" |
| return f"{normalized}/v1/chat/completions" |
|
|
|
|
| def modal_transcription_payload( |
| audio: bytes, |
| stt_model: SttModelConfig, |
| ) -> dict[str, Any]: |
| prompt = stt_model.options.get("prompt", MODAL_DEFAULT_PROMPT) |
| if not isinstance(prompt, str) or not prompt.strip(): |
| raise ValueError("Modal Inkling transcription prompt must be a non-empty string.") |
| max_tokens = stt_model.options.get("max_tokens", MODAL_DEFAULT_MAX_TOKENS) |
| if isinstance(max_tokens, bool) or not isinstance(max_tokens, int) or max_tokens <= 0: |
| raise ValueError("Modal Inkling max_tokens must be a positive integer.") |
| reasoning_effort = stt_model.options.get("reasoning_effort", MODAL_DEFAULT_REASONING_EFFORT) |
| if not isinstance(reasoning_effort, str) or reasoning_effort not in MODAL_REASONING_EFFORTS: |
| allowed = ", ".join(sorted(MODAL_REASONING_EFFORTS)) |
| raise ValueError(f"Modal Inkling reasoning_effort must be one of: {allowed}.") |
| encoded_audio = base64.b64encode(audio).decode("ascii") |
| return { |
| "model": stt_model.model, |
| "max_tokens": max_tokens, |
| "reasoning_effort": reasoning_effort, |
| "messages": [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "text", "text": prompt}, |
| { |
| "type": "audio_url", |
| "audio_url": {"url": f"data:audio/wav;base64,{encoded_audio}"}, |
| }, |
| ], |
| } |
| ], |
| } |
|
|
|
|
| def modal_transcript_from_response(response: Any) -> str: |
| try: |
| content = response["choices"][0]["message"]["content"] |
| except (KeyError, IndexError, TypeError) as exc: |
| raise ValueError("Modal Inkling response did not include message content.") from exc |
| if not isinstance(content, str): |
| raise ValueError("Modal Inkling response message content must be a string.") |
| return content |
|
|
