This commit is contained in:
waeckerlinfederowicz66-sketch 2026-10-28 07:59:44 +00:00 • committed by GitHub
commit 8dfdea1c52
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
27 changed files with 3000 additions and 92 deletions

View file

@ -269,6 +269,7 @@ jobs:
tests/unit/llms/featherless_ai
tests/unit/llms/firecrawl
tests/unit/llms/fireworks_ai
tests/unit/llms/flowspeech
tests/unit/llms/friendliai
tests/unit/llms/gdc
tests/unit/llms/gemini

View file

@ -674,6 +674,7 @@ nebius_embedding_models: Set = set()
aiml_models: Set = set()
deepgram_models: Set = set()
elevenlabs_models: Set = set()
flowspeech_models: Final[set[str]] = set() # mutable-ok: populated when the shared model catalog loads
dashscope_models: Set = set()
qwencloud_models: Set = set()
qwen_ai_platform_models: Set = set()
@ -950,6 +951,8 @@ def _populate_provider_model_sets(model_cost_map: Mapping[str, Mapping[str, obje
deepgram_models.add(key)
elif value.get("litellm_provider") == "elevenlabs":
elevenlabs_models.add(key)
elif value.get("litellm_provider") == "flowspeech":
flowspeech_models.add(key)
elif value.get("litellm_provider") == "heroku":
heroku_models.add(key)
elif value.get("litellm_provider") == "dashscope":
@ -1132,6 +1135,7 @@ model_list = list(
| nscale_models
| deepgram_models
| elevenlabs_models
| flowspeech_models
| dashscope_models
| qwencloud_models
| qwen_ai_platform_models
@ -1248,6 +1252,7 @@ def _build_models_by_provider() -> dict:
"featherless_ai": featherless_ai_models,
"deepgram": deepgram_models,
"elevenlabs": elevenlabs_models,
"flowspeech": flowspeech_models,
"heroku": heroku_models,
"dashscope": dashscope_models,
"qwencloud": qwencloud_models,

View file

@ -3,7 +3,7 @@ from collections.abc import Set as AbstractSet
from dataclasses import dataclass, field
from typing import Any, Final
from pydantic import BaseModel
from pydantic import BaseModel, TypeAdapter
from litellm.constants import DEFAULT_MAX_RECURSE_DEPTH, DEFAULT_MAX_RECURSE_DEPTH_SENSITIVE_DATA_MASKER
from litellm.litellm_core_utils.secret_redaction import REDACTED
@ -255,6 +255,51 @@ def mask_sensitive_keys(data: Mapping[str, object], sensitive_fields: set[str])
return masked
_REQUEST_LOG_HEADER_NAMES: Final = frozenset(
(
"accept",
"accept-encoding",
"authorization",
"proxy-authorization",
"cookie",
"set-cookie",
"api-key",
"x-api-key",
"x-goog-api-key",
"content-type",
"content-length",
"user-agent",
"idempotency-key",
"x-request-id",
"x-correlation-id",
)
)
_REQUEST_LOG_HEADER_ADAPTER: Final = TypeAdapter(Mapping[object, object])
def _redact_request_headers(value: object) -> object:
if value is None:
return None
if not isinstance(value, Mapping):
return REDACTED
headers: Final = _REQUEST_LOG_HEADER_ADAPTER.validate_python(value)
if any(
not isinstance(name, str) or name.lower() not in _REQUEST_LOG_HEADER_NAMES or not isinstance(item, str)
for name, item in headers.items()
):
return REDACTED
return headers
def redact_credentials_in_request(data: Mapping[str, object]) -> Mapping[str, object]:
return redact_credentials_in_payload(
{
key: _redact_request_headers(value) if key in ("headers", "extra_headers") else value
for key, value in data.items()
}
)
def redact_credentials_in_payload(data: Mapping[str, object]) -> Mapping[str, object]:
"""Return a copy of ``data`` where every value under a credential-named key is
replaced by the shared ``REDACTED`` marker, nested mappings are recursed into,

View file

@ -0,0 +1 @@

View file

@ -0,0 +1 @@

View file

@ -0,0 +1,389 @@
import asyncio
import io
import json
import math
import struct
import time
import wave
from collections.abc import Awaitable, Callable, Generator, Mapping
from datetime import timezone
from email.utils import parsedate_to_datetime
from types import MappingProxyType
from typing import Final, TypeAlias
import httpx
from litellm.llms.custom_httpx.http_handler import (
get_async_httpx_client, # pyright: ignore[reportUnknownVariableType] # unused factory params are untyped upstream
)
from litellm.types.llms.openai import HttpxBinaryResponseContent
from litellm.types.utils import LlmProviders
from .transformation import (
FlowSpeechErrorResponse,
FlowSpeechException,
FlowSpeechJob,
validate_url,
validate_uuid,
)
Flow: TypeAlias = Generator[
httpx.Request | float, httpx.Response | httpx.TransportError | None, HttpxBinaryResponseContent
]
Exchange: TypeAlias = Generator[httpx.Request | float, httpx.Response | httpx.TransportError | None, httpx.Response]
def validate_wav_structure(content: bytes) -> None:
if (
len(content) < 12
or content[:4] != b"RIFF"
or content[8:12] != b"WAVE"
or int.from_bytes(content[4:8], "little") != len(content) - 8
):
raise ValueError("Invalid RIFF container length")
stream: Final = io.BytesIO(content)
stream.seek(12)
for header in iter(lambda: stream.read(8), b""):
if len(header) != 8:
raise ValueError("Truncated WAV chunk header")
size = int.from_bytes(header[4:], "little")
end = stream.tell() + size + size % 2
if end > len(content):
raise ValueError("Truncated WAV chunk")
if header[:4] == b"fmt " and stream.read(min(size, 16))[2:] != struct.pack("<HIIHH", 1, 24000, 48000, 2, 16):
raise ValueError("Invalid PCM format fields")
if header[:4] == b"data" and size % 2:
raise ValueError("Unaligned PCM data")
stream.seek(end)
class FlowSpeechTTS:
MAX_AUDIO_BYTES = 100 * 1024 * 1024
MAX_JSON_BYTES = 1024 * 1024
POLL_INTERVAL = 5.0
def __init__(
self,
url: str,
headers: Mapping[str, str],
body: Mapping[str, object],
timeout: float | httpx.Timeout,
max_retries: object = 2,
*,
clock: Callable[[], float] = time.monotonic,
wall_clock: Callable[[], float] = time.time,
sleep: Callable[[float], None] = time.sleep,
async_sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
on_completed: Callable[[FlowSpeechJob], None] | None = None,
) -> None:
seconds: Final = timeout.read if isinstance(timeout, httpx.Timeout) else timeout
if isinstance(seconds, bool) or seconds is None or not math.isfinite(seconds) or seconds <= 0:
raise ValueError("FlowSpeech timeout must be finite and positive (httpx.Timeout uses read as total)")
if isinstance(max_retries, bool) or not isinstance(max_retries, int) or not 0 <= max_retries <= 10:
raise ValueError("FlowSpeech max_retries must be an integer between 0 and 10")
self.url = str(validate_url(url))
self.headers = httpx.Headers(headers)
self.request_id = validate_uuid(self.headers["Idempotency-Key"])
self.job_id: str | None = None
serialized: Final = json.dumps(
dict(body),
ensure_ascii=False,
separators=(",", ":"),
)
self.body = serialized.encode("utf-8")
if len(self.body) > self.MAX_JSON_BYTES:
raise ValueError("FlowSpeech request exceeds 1 MiB")
self.timeout = timeout
self.deadline = clock() + seconds
self.clock = clock
self.wall_clock = wall_clock
self.sleep = sleep
self.async_sleep = async_sleep
self.max_retries = max_retries
self.on_completed = on_completed
def error(self, status: int, message: str, headers: httpx.Headers | None = None) -> FlowSpeechException:
return FlowSpeechException(
status,
f"{message} (request_id={self.request_id}, job_id={self.job_id or 'unknown'})",
headers,
)
def remaining(self) -> float:
remaining: Final = self.deadline - self.clock()
if remaining <= 0:
raise self.error(408, "FlowSpeech total deadline exceeded; recover using the same request_id")
return remaining
def delay(self, response: httpx.Response | None = None) -> float:
value: Final = (
response.headers["retry-after"] if response is not None and "retry-after" in response.headers else None
)
if not value:
return self.POLL_INTERVAL
try:
seconds: Final = float(value)
except ValueError:
try:
date: Final = parsedate_to_datetime(value)
return max(
self.POLL_INTERVAL, date.replace(tzinfo=date.tzinfo or timezone.utc).timestamp() - self.wall_clock()
)
except (ValueError, TypeError, OverflowError):
return self.POLL_INTERVAL
return max(self.POLL_INTERVAL, seconds) if math.isfinite(seconds) else self.POLL_INTERVAL
def wait_budget(self, delay: float) -> None:
if delay >= self.remaining():
raise self.error(408, "FlowSpeech total deadline cannot accommodate Retry-After/poll delay")
def request(self, method: str, url: str, download: bool) -> httpx.Request:
remaining: Final = self.remaining()
timeouts: Final[Mapping[str, float | None]] = (
self.timeout.as_dict() if isinstance(self.timeout, httpx.Timeout) else MappingProxyType({})
)
return httpx.Request(
method,
url,
headers=MappingProxyType({"Accept-Encoding": "identity"})
if download
else MappingProxyType({**self.headers, "Accept-Encoding": "identity"}),
content=self.body if method == "POST" else None,
extensions=MappingProxyType(
{
"timeout": MappingProxyType(
{
phase: min(limit, remaining) if (limit := timeouts.get(phase)) is not None else remaining
for phase in ("connect", "read", "write", "pool")
}
),
"flowspeech_download": download,
}
),
)
def exchange(self, method: str, url: str, *, download: bool = False) -> Exchange:
for attempt in range(self.max_retries + 1):
response = yield self.request(method, url, download)
self.remaining()
if isinstance(response, httpx.TransportError):
if attempt == self.max_retries:
raise self.error(
502, "FlowSpeech download transport failed" if download else "FlowSpeech API transport failed"
)
yield self.delay()
continue
if not isinstance(response, httpx.Response):
raise self.error(502, "FlowSpeech transport did not return a response")
if response.status_code in ((200,) if download or method == "GET" else (200, 202)):
return response
if response.is_redirect:
raise self.error(502, "FlowSpeech unexpected redirect rejected", response.headers)
try:
payload = FlowSpeechErrorResponse.model_validate_json(response.content)
except ValueError:
payload = None
retryable = response.status_code == 429 or (
response.status_code >= 500 and (download or (payload is not None and payload.error.retryable))
)
if retryable and attempt < self.max_retries:
yield self.delay(response)
continue
detail = (
f"{payload.error.code}: {payload.error.message}; traceId={payload.traceId or 'unknown'}"
if payload
else f"unexpected HTTP {response.status_code}"
)
raise self.error(
response.status_code if response.status_code >= 400 else 502,
f"FlowSpeech {'download' if download else 'API'}: {detail}",
response.headers,
)
raise self.error(502, "FlowSpeech retries exhausted")
def flow(self) -> Flow:
response = yield from self.exchange("POST", self.url) # rebind-ok: advances through job status responses
while True:
try:
job = FlowSpeechJob.model_validate_json(response.content)
job_id = job.id
except ValueError as exc:
raise self.error(502, "FlowSpeech returned an invalid job, ID, status or result") from exc
if job.requestId != self.request_id:
raise self.error(502, "FlowSpeech returned a different request ID")
if self.job_id is not None and self.job_id != job_id:
raise self.error(502, "FlowSpeech returned a different job ID")
self.job_id = job_id
if job.status in ("failed", "cancelled"):
detail = f"{job.error.code}: {job.error.message}" if job.error else job.status
raise self.error(422, f"FlowSpeech job {job.status}: {detail}")
if job.status == "success":
if job.resultDeleted:
raise self.error(410, "FlowSpeech recording was deleted (resultDeleted=true)")
if job.result is None:
raise self.error(502, "FlowSpeech successful job has no result")
try:
audio_url = str(validate_url(job.result.url))
except ValueError as exc:
raise self.error(502, "FlowSpeech returned an unsafe audio URL") from exc
audio = yield from self.exchange("GET", audio_url, download=True)
return self.completed_response(job, audio)
yield self.delay(response)
response = yield from self.exchange("GET", f"{self.url}/{job_id}")
def completed_response(self, job: FlowSpeechJob, response: httpx.Response) -> HttpxBinaryResponseContent:
self.remaining()
result: Final = self.audio_response(response)
self.remaining()
if self.on_completed is not None:
self.on_completed(job)
self.remaining()
return result
def audio_response(self, response: httpx.Response) -> HttpxBinaryResponseContent:
try:
validate_wav_structure(response.content)
with wave.open(io.BytesIO(response.content), "rb") as audio:
if (audio.getframerate(), audio.getnchannels(), audio.getsampwidth(), audio.getcomptype()) != (
24000,
1,
2,
"NONE",
):
raise ValueError("Unexpected WAV encoding")
if audio.getnframes() == 0 or len(audio.readframes(audio.getnframes() + 1)) != audio.getnframes() * 2:
raise ValueError("Empty or truncated WAV")
except (wave.Error, EOFError, ValueError) as exc:
raise self.error(502, "FlowSpeech download is not complete 24 kHz mono 16-bit WAV audio") from exc
return HttpxBinaryResponseContent(
httpx.Response(
200,
content=response.content,
headers=MappingProxyType(
{
"content-type": "audio/wav",
"x-flowspeech-request-id": self.request_id,
"x-flowspeech-job-id": self.job_id or "",
}
),
request=response.request,
)
)
def limit(self, request: httpx.Request, response: httpx.Response) -> int:
maximum: Final = self.MAX_AUDIO_BYTES if request.extensions["flowspeech_download"] else self.MAX_JSON_BYTES
if "content-encoding" in response.headers and response.headers["content-encoding"].lower() != "identity":
raise self.error(502, "FlowSpeech encoded response rejected")
try:
length: Final = int(response.headers["content-length"]) if "content-length" in response.headers else 0
except ValueError as exc:
raise self.error(502, "FlowSpeech invalid Content-Length") from exc
if not 0 <= length <= maximum:
raise self.error(502, "FlowSpeech response exceeds size limit")
return maximum
def read(self, client: httpx.Client, request: httpx.Request) -> httpx.Response:
self.remaining()
response: Final = client.send(request, stream=True, auth=None, follow_redirects=False)
try:
self.remaining()
maximum: Final = self.limit(request, response)
with io.BytesIO() as content:
self.remaining()
for chunk in response.iter_bytes():
self.remaining()
if content.tell() + len(chunk) > maximum:
raise self.error(502, "FlowSpeech response exceeds size limit")
content.write(chunk)
self.remaining()
self.remaining()
return httpx.Response(
response.status_code, headers=response.headers, content=content.getvalue(), request=request
)
finally:
response.close()
async def aread(self, client: httpx.AsyncClient, request: httpx.Request) -> httpx.Response:
self.remaining()
response: Final = await client.send(request, stream=True, auth=None, follow_redirects=False)
try:
self.remaining()
maximum: Final = self.limit(request, response)
with io.BytesIO() as content:
self.remaining()
async for chunk in response.aiter_bytes():
self.remaining()
if content.tell() + len(chunk) > maximum:
raise self.error(502, "FlowSpeech response exceeds size limit")
content.write(chunk)
self.remaining()
self.remaining()
return httpx.Response(
response.status_code, headers=response.headers, content=content.getvalue(), request=request
)
finally:
await response.aclose()
def run(self, client: httpx.Client | None = None) -> HttpxBinaryResponseContent:
if client is None:
with httpx.Client(trust_env=False) as owned_client:
return self._run(owned_client)
return self._run(client)
def _run(self, client: httpx.Client) -> HttpxBinaryResponseContent:
flow: Final = self.flow()
action = next(flow) # rebind-ok: workflow driver advances actions
try:
while True:
result: httpx.Response | httpx.TransportError | None = None
if not isinstance(action, httpx.Request):
self.wait_budget(action)
self.sleep(action)
else:
try:
result = self.read(client, action)
except httpx.TransportError as exc:
result = exc
action = flow.send(result)
except StopIteration as done:
value: Final[object] = done.value # pyright: ignore[reportAny] # StopIteration erases the typed generator return; checked below
if not isinstance(value, HttpxBinaryResponseContent):
raise self.error(502, "FlowSpeech workflow did not return audio")
return value # pyright: ignore[reportUnknownVariableType] # StopIteration erases the response generic
finally:
flow.close()
async def arun(self, client: httpx.AsyncClient | None = None) -> HttpxBinaryResponseContent:
selected_client: Final = (
client if client is not None else get_async_httpx_client(LlmProviders.FLOWSPEECH).client
)
return await self._arun_with_deadline(selected_client)
async def _arun_with_deadline(self, client: httpx.AsyncClient) -> HttpxBinaryResponseContent:
try:
return await asyncio.wait_for(self._arun(client), timeout=self.remaining())
except asyncio.TimeoutError as exc:
raise self.error(408, "FlowSpeech total deadline exceeded; recover using the same request_id") from exc
async def _arun(self, client: httpx.AsyncClient) -> HttpxBinaryResponseContent:
flow: Final = self.flow()
action = next(flow) # rebind-ok: workflow driver advances actions
try:
while True:
result: httpx.Response | httpx.TransportError | None = None
if not isinstance(action, httpx.Request):
self.wait_budget(action)
await self.async_sleep(action)
else:
try:
result = await self.aread(client, action)
except httpx.TransportError as exc:
result = exc
action = flow.send(result)
except StopIteration as done:
value: Final[object] = done.value # pyright: ignore[reportAny] # StopIteration erases the typed generator return; checked below
if not isinstance(value, HttpxBinaryResponseContent):
raise self.error(502, "FlowSpeech workflow did not return audio")
return value # pyright: ignore[reportUnknownVariableType] # StopIteration erases the response generic
finally:
flow.close()

View file

@ -0,0 +1,260 @@
from collections.abc import Mapping
from types import MappingProxyType
from typing import TYPE_CHECKING, Final, Literal
from uuid import UUID, uuid4
import httpx
from pydantic import BaseModel, ConfigDict, Field, StrictStr, TypeAdapter, ValidationError, field_validator
import litellm
from litellm.llms.base_llm.chat.transformation import BaseLLMException
from litellm.llms.base_llm.text_to_speech.transformation import BaseTextToSpeechConfig, TextToSpeechRequestData
from litellm.secret_managers.main import get_secret_str
if TYPE_CHECKING:
from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
from litellm.types.llms.openai import HttpxBinaryResponseContent
class FlowSpeechException(BaseLLMException):
def __init__(
self,
status_code: int,
message: str,
headers: dict[str, str] | httpx.Headers | None = None, # mutable-ok: upstream exception interface
) -> None:
super().__init__( # pyright: ignore[reportUnknownMemberType] # upstream exception has untyped dictionary fields
status_code=status_code, message=message, headers=headers
)
class FlowSpeechSegment(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True, frozen=True)
speaker: str = Field(min_length=1, max_length=100)
text: str = Field(min_length=1, max_length=100_000)
voiceName: str = Field(min_length=1, max_length=100)
class FlowSpeechResult(BaseModel):
model_config = ConfigDict(strict=True, frozen=True)
url: str
mimeType: Literal["audio/wav"]
sampleRate: Literal[24000]
channels: Literal[1]
bitsPerSample: Literal[16]
class FlowSpeechError(BaseModel):
model_config = ConfigDict(strict=True, frozen=True)
code: str
message: str
retryable: bool = False
class FlowSpeechUsage(BaseModel):
model_config = ConfigDict(strict=True, frozen=True)
billableCharacters: int = Field(ge=0)
reservedCredits: int = Field(ge=0)
chargedCredits: int = Field(ge=0)
class FlowSpeechJob(BaseModel):
model_config = ConfigDict(strict=True, frozen=True)
id: str
requestId: str
usage: FlowSpeechUsage
status: Literal["queued", "running", "merging", "settling", "success", "failed", "cancelled"]
result: FlowSpeechResult | None = None
resultDeleted: bool = False
error: FlowSpeechError | None = None
@field_validator("id", "requestId")
@classmethod
def canonical_identifier(cls, value: str) -> str:
return validate_uuid(value)
class FlowSpeechErrorResponse(BaseModel):
model_config = ConfigDict(strict=True, frozen=True)
error: FlowSpeechError
traceId: str | None = None
def validate_uuid(value: object) -> str:
text: Final = TypeAdapter(str).validate_python(value, strict=True)
try:
parsed: Final = str(UUID(text))
except ValueError as exc:
raise ValueError("FlowSpeech requires a UUID") from exc
if parsed != text.lower():
raise ValueError("FlowSpeech requires a hyphenated UUID")
return parsed
def validate_url(value: str) -> httpx.URL:
try:
url: Final = httpx.URL(value)
except httpx.InvalidURL as exc:
raise ValueError("FlowSpeech requires a valid HTTPS URL") from exc
if url.scheme != "https" or not url.host or url.userinfo or url.fragment:
raise ValueError("FlowSpeech requires an HTTPS URL without credentials or fragment")
return url
def credential_headers(value: object) -> Mapping[str, str] | None:
try:
return TypeAdapter(Mapping[StrictStr, StrictStr]).validate_python(value)
except ValidationError:
return None
class FlowSpeechTextToSpeechConfig(BaseTextToSpeechConfig):
TTS_BASE_URL = "https://flowspeech.io"
TTS_ENDPOINT_PATH = "/api/v1/tts/jobs"
DEFAULT_VOICE = "Kore"
def get_supported_openai_params(self, model: str) -> list[str]: # mutable-ok: base provider interface
return ["voice", "response_format"]
def map_openai_params(
self,
model: str,
optional_params: Mapping[str, object],
voice: str | Mapping[str, object] | None = None,
drop_params: bool = False,
kwargs: Mapping[str, object] | None = None,
) -> tuple[str | None, dict[str, object]]: # mutable-ok: base provider interface
if model != "flowspeech-tts":
raise ValueError("FlowSpeech only supports the flowspeech/flowspeech-tts route")
if any(key != "response_format" for key in optional_params):
raise ValueError("FlowSpeech does not support instructions or speed")
if optional_params.get("response_format") not in (None, "wav"):
raise ValueError("FlowSpeech only supports response_format='wav'")
supplied: Final = kwargs or MappingProxyType({})
if any(
key in supplied
for key in ("source", "format", "speakers", "originalText", "prompt", "stream", "extra_body")
):
raise ValueError("Unsupported FlowSpeech option; use voice or segments")
if "segments" in supplied and voice is not None:
raise ValueError("Use segment voiceName fields instead of voice for multi-speaker input")
return self._resolve_voice(voice), {key: supplied[key] for key in ("segments", "request_id") if key in supplied}
def _resolve_voice(self, voice: str | Mapping[str, object] | None) -> str:
if voice is None:
return self.DEFAULT_VOICE
if isinstance(voice, str) and voice.strip():
return voice.strip()
if isinstance(voice, Mapping):
candidate: Final = next(
(voice[key] for key in ("voice_name", "voiceName", "id", "name") if key in voice), None
)
if isinstance(candidate, str) and candidate.strip():
return candidate.strip()
raise ValueError("FlowSpeech voice must be a nonempty voice name")
def validate_environment(
self, headers: object, model: str, api_key: object = None, api_base: str | None = None
) -> dict[str, str]: # mutable-ok: base provider interface
key: Final = api_key if api_key is not None else (litellm.api_key or get_secret_str("FLOWSPEECH_API_KEY"))
if (
not isinstance(key, str)
or not key
or not key.isascii()
or any(char.isspace() or ord(char) < 33 or ord(char) == 127 for char in key)
):
raise ValueError("FlowSpeech API key is required and must be a nonempty token. Set FLOWSPEECH_API_KEY.")
checked_headers: Final = credential_headers(headers)
if checked_headers is None:
raise ValueError("FlowSpeech headers must be a mapping of string names to string values")
if any(name.lower() in ("cookie", "proxy-authorization", "host", "content-length") for name in checked_headers):
raise ValueError("FlowSpeech does not accept cookie, proxy credential, host or content-length overrides")
return {
**{
name: value
for name, value in checked_headers.items()
if name.lower() not in ("authorization", "content-type")
},
"Authorization": f"Bearer {key}",
"Content-Type": "application/json",
}
def get_error_class(
self,
error_message: str,
status_code: int,
headers: dict[str, str] | httpx.Headers, # mutable-ok: upstream exception interface
) -> BaseLLMException:
return FlowSpeechException(status_code, error_message, headers)
def _input_body(
self,
input: str,
voice: str | None,
optional_params: Mapping[str, object],
) -> dict[str, object]: # mutable-ok: JSON body required by base interface
if "segments" in optional_params:
if input:
raise ValueError("Use input='' with FlowSpeech segments")
segments: Final = TypeAdapter(list[FlowSpeechSegment]).validate_python(optional_params["segments"])
if not 1 <= len(segments) <= 1000 or any(
not part.speaker.strip() or not part.text.strip() or not part.voiceName.strip() for part in segments
):
raise ValueError("FlowSpeech requires 1 to 1000 nonempty speaker turns")
return {
"mode": "multi",
"segments": [part.model_dump() for part in segments],
}
if not input.strip():
raise ValueError("FlowSpeech input must contain text")
return {
"mode": "single",
"text": input,
"voiceName": self._resolve_voice(voice),
}
def transform_text_to_speech_request(
self,
model: str,
input: str,
voice: str | None,
optional_params: Mapping[str, object],
litellm_params: Mapping[str, object],
headers: Mapping[str, str],
) -> TextToSpeechRequestData:
if frozenset(optional_params) - frozenset(("segments", "request_id")):
raise ValueError("Unsupported FlowSpeech request options")
body: Final = self._input_body(input, voice, optional_params)
header_id: Final = next((value for key, value in headers.items() if key.lower() == "idempotency-key"), None)
supplied_id: Final = optional_params.get("request_id", header_id)
request_id: Final = validate_uuid(supplied_id) if supplied_id is not None else str(uuid4())
if header_id is not None and validate_uuid(header_id) != request_id:
raise ValueError("FlowSpeech request_id and Idempotency-Key must agree")
return TextToSpeechRequestData(
dict_body={"input": body},
headers={"Idempotency-Key": request_id},
)
def transform_text_to_speech_response(
self,
model: str,
raw_response: httpx.Response,
logging_obj: "LiteLLMLoggingObj",
) -> "HttpxBinaryResponseContent":
from litellm.types.llms.openai import HttpxBinaryResponseContent
if raw_response.status_code != 200 or raw_response.headers.get("content-type") != "audio/wav":
raise FlowSpeechException(502, "FlowSpeech requires completed, downloaded WAV audio")
return HttpxBinaryResponseContent(raw_response)
def get_complete_url(self, model: str, api_base: str | None, litellm_params: Mapping[str, object]) -> str:
base: Final = api_base if api_base is not None else (get_secret_str("FLOWSPEECH_API_BASE") or self.TTS_BASE_URL)
url: Final = validate_url(base)
if url.query or b"?" in url.raw_path:
raise ValueError("FlowSpeech api_base must not contain a query")
if url.path.rstrip("/").endswith("/api/ai/text-to-speech"):
raise ValueError("FlowSpeech api_base must not use the legacy text-to-speech endpoint")
path: Final = url.raw_path.rstrip(b"/")
suffix: Final = self.TTS_ENDPOINT_PATH.encode("ascii")
endpoint: Final = path if path.endswith(suffix) else path + suffix
return str(url.copy_with(raw_path=endpoint))

View file

@ -8881,6 +8881,83 @@ def speech(
client=client,
_is_async=aspeech or False,
)
elif custom_llm_provider == "flowspeech":
from litellm.llms.flowspeech.text_to_speech.handler import FlowSpeechTTS
from litellm.llms.flowspeech.text_to_speech.transformation import (
FlowSpeechJob,
FlowSpeechTextToSpeechConfig,
)
if text_to_speech_provider_config is None:
text_to_speech_provider_config = ( # rebind-ok: provider config is resolved lazily for speech dispatch
FlowSpeechTextToSpeechConfig()
)
if not isinstance(text_to_speech_provider_config, FlowSpeechTextToSpeechConfig):
raise TypeError("FlowSpeech TTS configuration has an unexpected type")
flowspeech_config: Final = text_to_speech_provider_config
if api_base is not None:
litellm_params_dict["api_base"] = api_base
if api_key is not None:
litellm_params_dict["api_key"] = api_key
flowspeech_params: Final = TypeAdapter(Mapping[str, object]).validate_python(litellm_params_dict)
flowspeech_headers: Final = flowspeech_config.validate_environment(
TypeAdapter(object).validate_python(extra_headers or headers or MappingProxyType({})),
model,
flowspeech_params.get("api_key"),
api_base,
)
flowspeech_request: Final = flowspeech_config.transform_text_to_speech_request(
model=model,
input=input,
voice=voice if isinstance(voice, str) else None,
optional_params=TypeAdapter(Mapping[str, object]).validate_python(optional_params),
litellm_params=flowspeech_params,
headers=flowspeech_headers,
)
flowspeech_url: Final = flowspeech_config.get_complete_url(model, api_base, flowspeech_params)
def flowspeech_post_call(job: FlowSpeechJob) -> None:
logging_obj.post_call( # pyright: ignore[reportUnknownMemberType] # upstream logging callback has untyped parameters
input=input,
api_key="",
original_response=job.model_dump_json(include={"id", "requestId", "status", "usage"}),
additional_args=MappingProxyType({"request_id": job.requestId, "job_id": job.id}),
)
flowspeech_job: Final = FlowSpeechTTS(
url=flowspeech_url,
headers=MappingProxyType(
{
**MappingProxyType(
{key: value for key, value in flowspeech_headers.items() if key.lower() != "idempotency-key"}
),
**TypeAdapter(Mapping[str, str]).validate_python(flowspeech_request.get("headers"), strict=True),
}
),
body=TypeAdapter(Mapping[str, object]).validate_python(flowspeech_request.get("dict_body")),
timeout=http_timeout,
max_retries=max_retries,
on_completed=flowspeech_post_call,
)
logging_obj.pre_call( # pyright: ignore[reportUnknownMemberType] # upstream logging callback has untyped parameters
input=input,
api_key="",
additional_args=MappingProxyType({"api_base": flowspeech_url, "request_id": flowspeech_job.request_id}),
)
flowspeech_client: Final = TypeAdapter(object).validate_python(
client.client if isinstance(client, (HTTPHandler, AsyncHTTPHandler)) else client
)
if aspeech:
if flowspeech_client is not None and not isinstance(flowspeech_client, httpx.AsyncClient):
raise ValueError("FlowSpeech client must match the synchronous or asynchronous speech call")
response = flowspeech_job.arun(flowspeech_client) # rebind-ok: provider branch sets dispatch result
else:
if flowspeech_client is not None and not isinstance(flowspeech_client, httpx.Client):
raise ValueError("FlowSpeech client must match the synchronous or asynchronous speech call")
response = flowspeech_job.run(flowspeech_client) # rebind-ok: provider branch sets dispatch result
elif custom_llm_provider == "vertex_ai" or custom_llm_provider == "vertex_ai_beta":
from litellm.llms.vertex_ai.text_to_speech.transformation import (
VertexAILyriaTextToSpeechConfig,

View file

@ -27697,6 +27697,14 @@
"output_cost_per_token": 0.0,
"source": "https://fireworks.ai/pricing"
},
"flowspeech/flowspeech-tts": {
"litellm_provider": "flowspeech",
"mode": "audio_speech",
"source": "https://flowspeech.io/",
"supported_endpoints": [
"/v1/audio/speech"
]
},
"friendliai/zai-org/GLM-5.3-Flash": {
"litellm_provider": "friendliai",
"max_input_tokens": 1048576,

View file

@ -1452,6 +1452,32 @@
"generateContent": false
}
},
"flowspeech": {
"display_name": "FlowSpeech (`flowspeech`)",
"url": "https://docs.litellm.ai/docs/providers/flowspeech",
"endpoints": {
"chat_completions": false,
"responses": false,
"text_completion": false,
"embeddings": false,
"image_generations": false,
"image_edits": false,
"audio_transcriptions": false,
"audio_speech": true,
"rerank": false,
"ocr": false,
"search": false,
"moderations": false,
"realtime": false,
"video_generations": false,
"batches": false,
"messages": false,
"interactions": false,
"systemone": false,
"a2a": false,
"generateContent": false
}
},
"exa_ai": {
"display_name": "Exa AI (`exa_ai`)",
"url": "https://docs.litellm.ai/docs/search/exa_ai",

View file

@ -13378,10 +13378,26 @@ async def audio_speech(
response_format=requested_format if isinstance(requested_format, str) else None,
)
flowspeech_raw_response: Final = _UNTYPED_VALUE.validate_python(
getattr(_UNTYPED_VALUE.validate_python(response), "response", None)
)
flowspeech_recovery_headers: Final[Mapping[str, str]] = (
MappingProxyType(
{
key: flowspeech_raw_response.headers[key]
for key in ("x-flowspeech-job-id", "x-flowspeech-request-id")
if key in flowspeech_raw_response.headers
}
)
if isinstance(flowspeech_raw_response, httpx.Response)
and "x-flowspeech-job-id" in flowspeech_raw_response.headers
else MappingProxyType({})
)
return StreamingResponse(
_audio_speech_chunk_generator(response),
media_type=media_type,
headers=custom_headers,
headers={**TypeAdapter(Mapping[str, str]).validate_python(custom_headers), **flowspeech_recovery_headers},
)
except Exception as e:

View file

@ -1589,6 +1589,34 @@
],
"default_model_placeholder": "gpt-3.5-turbo"
},
{
"provider": "FlowSpeech",
"provider_display_name": "FlowSpeech",
"litellm_provider": "flowspeech",
"credential_fields": [
{
"key": "api_key",
"label": "API Key",
"placeholder": null,
"tooltip": null,
"required": true,
"field_type": "password",
"options": null,
"default_value": null
},
{
"key": "api_base",
"label": "API Base",
"placeholder": "https://flowspeech.io",
"tooltip": "HTTPS origin, trusted gateway prefix, or complete /api/v1/tts/jobs endpoint",
"required": false,
"field_type": "text",
"options": null,
"default_value": null
}
],
"default_model_placeholder": "flowspeech/flowspeech-tts"
},
{
"provider": "FRIENDLIAI",
"provider_display_name": "Friendliai",

View file

@ -4525,6 +4525,7 @@ class LlmProviders(str, Enum):
INFINITY = "infinity"
DEEPGRAM = "deepgram"
ELEVENLABS = "elevenlabs"
FLOWSPEECH = "flowspeech"
NOVITA = "novita"
AIOHTTP_OPENAI = "aiohttp_openai"
LANGFUSE = "langfuse"

View file

@ -94,7 +94,11 @@ from litellm.litellm_core_utils.fallback_generalizations import (
from litellm.litellm_core_utils.get_model_cost_map import AliasedCostEntry
from litellm.litellm_core_utils.model_param_helper import peek_reasoning_summary_aliases
from litellm.litellm_core_utils.offline_mode import is_offline_mode
from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_payload
from litellm.litellm_core_utils.secret_redaction import REDACTED
from litellm.litellm_core_utils.sensitive_data_masker import (
redact_credentials_in_payload,
redact_credentials_in_request,
)
from litellm.litellm_core_utils.tokenizer import strip_special_tokens
from litellm.litellm_core_utils.tool_fields import MalformedField, resolve_deployment_tool_fields
from litellm.rust_bridge import tokenizer as tokenizer_dispatch
@ -1900,7 +1904,15 @@ def client(original_function):
return result
# Prints Exactly what was passed to litellm function - don't execute any logic here - it should just print
print_args_passed_to_litellm(original_function, args, kwargs)
if is_debugging_on():
try:
print_args_passed_to_litellm(
original_function,
TypeAdapter(tuple[object, ...]).validate_python(args, strict=True),
TypeAdapter(Mapping[str, object]).validate_python(kwargs, strict=True),
)
except (TypeError, ValueError):
print_verbose("Skipped malformed request debug logging")
start_time: Final = datetime.datetime.now()
result = None
logging_obj: LiteLLMLoggingObject | None = kwargs.get("litellm_logging_obj", None)
@ -2169,7 +2181,15 @@ def client(original_function):
@wraps(original_function)
async def wrapper_async(*args, **kwargs):
print_args_passed_to_litellm(original_function, args, kwargs)
if is_debugging_on():
try:
print_args_passed_to_litellm(
original_function,
TypeAdapter(tuple[object, ...]).validate_python(args, strict=True),
TypeAdapter(Mapping[str, object]).validate_python(kwargs, strict=True),
)
except (TypeError, ValueError):
print_verbose("Skipped malformed request debug logging")
start_time: Final = datetime.datetime.now()
call_type: Final = _get_call_type_from_public_name(original_function.__name__)
result = None
@ -8532,28 +8552,63 @@ def get_valid_models(
return [] # NON-Blocking
def print_args_passed_to_litellm(original_function, args, kwargs):
def _positional_request_parameter_names(original_function: Callable[..., object]) -> tuple[str, ...]:
parameters: Final = inspect.signature(original_function).parameters.values()
return tuple(
parameter.name
for parameter in parameters
if parameter.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
)
def _request_logging_parameters(original_function: Callable[..., object]) -> tuple[str, ...]:
positional: Final = _positional_request_parameter_names(original_function)
if positional or not inspect.iscoroutinefunction(original_function):
return positional
if original_function.__name__.startswith("a"):
synchronous: Final = getattr(inspect.getmodule(original_function), original_function.__name__[1:], None)
if callable(synchronous) and not inspect.iscoroutinefunction(synchronous):
return _positional_request_parameter_names(synchronous)
return ()
def _redact_positional_request_args(
original_function: Callable[..., object], args: tuple[object, ...]
) -> tuple[object, ...]:
if not args:
return ()
try:
names: Final = _request_logging_parameters(original_function)
except (TypeError, ValueError):
return (REDACTED,) * len(args)
redacted: Final = redact_credentials_in_request(dict(zip(names, args)))
return tuple(redacted[name] for name in names[: len(args)]) + (REDACTED,) * max(0, len(args) - len(names))
def print_args_passed_to_litellm(original_function: Callable[..., object], args: object, kwargs: object) -> None:
if not is_debugging_on():
return
try:
request_args: Final = TypeAdapter(tuple[object, ...]).validate_python(args, strict=True)
request_kwargs: Final = TypeAdapter(Mapping[str, object]).validate_python(kwargs, strict=True)
# we've already printed this for acompletion, don't print for completion
if (
"acompletion" in kwargs
and kwargs["acompletion"] is True
"acompletion" in request_kwargs
and request_kwargs["acompletion"] is True
and original_function.__name__ == "completion"
or "aembedding" in kwargs
and kwargs["aembedding"] is True
or "aembedding" in request_kwargs
and request_kwargs["aembedding"] is True
and original_function.__name__ == "embedding"
or (
"aimg_generation" in kwargs
and kwargs["aimg_generation"] is True
"aimg_generation" in request_kwargs
and request_kwargs["aimg_generation"] is True
and original_function.__name__ == "img_generation"
)
):
return
args_str: Final = ", ".join(map(repr, args))
redacted_kwargs: Final = redact_credentials_in_payload(kwargs)
args_str: Final = ", ".join(map(repr, _redact_positional_request_args(original_function, request_args)))
redacted_kwargs: Final = redact_credentials_in_request(request_kwargs)
kwargs_str: Final = ", ".join(f"{key}={value!r}" for key, value in redacted_kwargs.items())
print_verbose(
"\n",
@ -8561,11 +8616,11 @@ def print_args_passed_to_litellm(original_function, args, kwargs):
print_verbose(
"\033[92mRequest to litellm:\033[0m",
)
if args and kwargs:
if request_args and request_kwargs:
print_verbose(f"\033[92mlitellm.{original_function.__name__}({args_str}, {kwargs_str})\033[0m")
elif args:
elif request_args:
print_verbose(f"\033[92mlitellm.{original_function.__name__}({args_str})\033[0m")
elif kwargs:
elif request_kwargs:
print_verbose(f"\033[92mlitellm.{original_function.__name__}({kwargs_str})\033[0m")
else:
print_verbose(f"\033[92mlitellm.{original_function.__name__}()\033[0m")
@ -10752,6 +10807,12 @@ class ProviderConfigManager:
)
return ElevenLabsTextToSpeechConfig()
elif litellm.LlmProviders.FLOWSPEECH == provider:
from litellm.llms.flowspeech.text_to_speech.transformation import (
FlowSpeechTextToSpeechConfig,
)
return FlowSpeechTextToSpeechConfig()
elif litellm.LlmProviders.RUNWAYML == provider:
from litellm.llms.runwayml.text_to_speech.transformation import (
RunwayMLTextToSpeechConfig,

View file

@ -27697,6 +27697,14 @@
"output_cost_per_token": 0.0,
"source": "https://fireworks.ai/pricing"
},
"flowspeech/flowspeech-tts": {
"litellm_provider": "flowspeech",
"mode": "audio_speech",
"source": "https://flowspeech.io/",
"supported_endpoints": [
"/v1/audio/speech"
]
},
"friendliai/zai-org/GLM-5.3-Flash": {
"litellm_provider": "friendliai",
"max_input_tokens": 1048576,

View file

@ -1452,6 +1452,32 @@
"generateContent": false
}
},
"flowspeech": {
"display_name": "FlowSpeech (`flowspeech`)",
"url": "https://docs.litellm.ai/docs/providers/flowspeech",
"endpoints": {
"chat_completions": false,
"responses": false,
"text_completion": false,
"embeddings": false,
"image_generations": false,
"image_edits": false,
"audio_transcriptions": false,
"audio_speech": true,
"rerank": false,
"ocr": false,
"search": false,
"moderations": false,
"realtime": false,
"video_generations": false,
"batches": false,
"messages": false,
"interactions": false,
"systemone": false,
"a2a": false,
"generateContent": false
}
},
"exa_ai": {
"display_name": "Exa AI (`exa_ai`)",
"url": "https://docs.litellm.ai/docs/search/exa_ai",

View file

@ -296,7 +296,7 @@ ci = [
"anthropic==0.84.0",
"blockbuster==1.5.26",
"beautifulsoup4==4.14.3",
"pylint==4.0.5",
"pylint==4.0.9",
"langchain-openai==1.1.14",
"langgraph>=1.2.4,<1.3.0",
"langgraph-prebuilt>=1.1.0,<1.3.0",

View file

@ -0,0 +1,213 @@
import asyncio
import io
import ipaddress
import json
import ssl
import threading
import time
import wave
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, HTTPServer
import httpx
import pytest
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.x509.oid import NameOID
import litellm
from litellm.llms.flowspeech.text_to_speech.transformation import FlowSpeechException
REQUEST_ID = "b698824b-de05-486d-8833-05d5c4522a39"
JOB_ID = "11111111-2222-4333-8444-555555555555"
BUDGET = 0.3
def wav_bytes():
buffer = io.BytesIO()
with wave.open(buffer, "wb") as audio:
audio.setparams((1, 2, 24000, 0, "NONE", "not compressed"))
audio.writeframes(b"\x00\x00" * 24)
return buffer.getvalue()
def tls_contexts(directory):
key = ec.generate_private_key(ec.SECP256R1())
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "localhost")])
certificate = (
x509.CertificateBuilder()
.subject_name(name)
.issuer_name(name)
.public_key(key.public_key())
.serial_number(1)
.not_valid_before(datetime(2020, 1, 1, tzinfo=timezone.utc))
.not_valid_after(datetime(2100, 1, 1, tzinfo=timezone.utc))
.add_extension(x509.SubjectAlternativeName([x509.IPAddress(ipaddress.ip_address("127.0.0.1"))]), False)
.sign(key, hashes.SHA256())
)
cert_file = directory / "loopback.pem"
key_file = directory / "loopback.key"
cert_file.write_bytes(certificate.public_bytes(serialization.Encoding.PEM))
key_file.write_bytes(
key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption())
)
server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
server_context.load_cert_chain(cert_file, key_file)
return server_context, ssl.create_default_context(cafile=str(cert_file))
@pytest.fixture
def slow_speech_peer(tmp_path, scenario):
requests = []
body = wav_bytes()
server_context, client_context = tls_contexts(tmp_path)
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def setup(self):
super().setup()
self.connection.settimeout(2)
def log_message(self, format, *args):
return
def reply(self, content):
self.send_response(200)
self.send_header("Content-Length", str(len(content)))
self.end_headers()
self.wfile.write(content)
self.wfile.flush()
def do_POST(self):
request_body = self.rfile.read(int(self.headers["Content-Length"]))
requests.append((self.command, self.path, dict(self.headers), json.loads(request_body)))
self.reply(
json.dumps(
{
"id": JOB_ID,
"requestId": self.headers["Idempotency-Key"],
"status": "success",
"usage": {"billableCharacters": 5, "reservedCredits": 0, "chargedCredits": 5},
"result": {
"url": f"{base_url}/audio.wav",
"mimeType": "audio/wav",
"sampleRate": 24000,
"channels": 1,
"bitsPerSample": 16,
},
}
).encode()
)
def do_GET(self):
requests.append((self.command, self.path, dict(self.headers), None))
if self.path == "/health":
self.reply(b"ok")
return
try:
if scenario == "slow_headers_body":
time.sleep(0.2)
self.send_response(200)
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.flush()
time.sleep(0.2)
self.wfile.write(body)
elif scenario == "slow_header_progress":
self.wfile.write(b"HTTP/1.1 200 OK\r\nX-Progress: ")
for _ in range(10):
self.wfile.write(b"x")
self.wfile.flush()
time.sleep(0.05)
self.wfile.write(f"\r\nContent-Length: {len(body)}\r\n\r\n".encode() + body)
else:
self.send_response(200)
self.send_header("Content-Length", str(len(body)))
self.end_headers()
for offset in range(0, len(body), 8):
time.sleep(0.05)
self.wfile.write(body[offset : offset + 8])
self.wfile.flush()
self.wfile.flush()
except (BrokenPipeError, ConnectionResetError, ssl.SSLEOFError):
self.close_connection = True
server = HTTPServer(("127.0.0.1", 0), Handler)
server.socket = server_context.wrap_socket(server.socket, server_side=True)
base_url = f"https://127.0.0.1:{server.server_port}"
worker = threading.Thread(target=server.serve_forever, kwargs={"poll_interval": 0.02})
worker.start()
try:
yield base_url, client_context, requests
finally:
server.shutdown()
server.server_close()
worker.join(timeout=3)
assert not worker.is_alive()
@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["sync", "worker", "async"])
@pytest.mark.parametrize("scenario", ["slow_headers_body", "slow_body_progress", "slow_header_progress"])
async def test_cooperative_deadline_rejects_late_audio_without_retry_or_client_closure(slow_speech_peer, mode):
base_url, client_context, requests = slow_speech_peer
responses = []
completed = []
def log_event(details):
if details.get("log_event_type") == "post_api_call":
completed.append(details)
async def record_response(response):
responses.append(response)
kwargs = {
"model": "flowspeech/flowspeech-tts",
"input": "Hello",
"api_key": "synthetic-loopback-only",
"api_base": base_url,
"request_id": REQUEST_ID,
"timeout": BUDGET,
"max_retries": 2,
"logger_fn": log_event,
}
options = {
"verify": client_context,
"trust_env": False,
"limits": httpx.Limits(max_connections=1, max_keepalive_connections=1),
}
if mode == "async":
async with httpx.AsyncClient(**options, event_hooks={"response": [record_response]}) as client:
with pytest.raises(litellm.Timeout, match="total deadline") as error:
await asyncio.wait_for(litellm.aspeech(**kwargs, client=client), timeout=5)
assert not client.is_closed
assert responses and all(response.is_closed for response in responses)
assert (await client.get(f"{base_url}/health", timeout=3)).content == b"ok"
else:
with httpx.Client(**options, event_hooks={"response": [responses.append]}) as client:
if mode == "worker":
with ThreadPoolExecutor(max_workers=1) as pool:
result = pool.submit(litellm.speech, **kwargs, client=client)
with pytest.raises(FlowSpeechException, match="total deadline") as error:
result.result(timeout=5)
else:
with pytest.raises(FlowSpeechException, match="total deadline") as error:
litellm.speech(**kwargs, client=client)
assert not client.is_closed
assert responses and all(response.is_closed for response in responses)
assert client.get(f"{base_url}/health", timeout=3).content == b"ok"
assert REQUEST_ID in str(error.value)
assert JOB_ID in str(error.value)
assert [(method, path) for method, path, _, _ in requests] == [
("POST", "/api/v1/tts/jobs"),
("GET", "/audio.wav"),
("GET", "/health"),
]
assert httpx.Headers(requests[0][2])["Idempotency-Key"] == REQUEST_ID
assert requests[0][3] == {"input": {"mode": "single", "text": "Hello", "voiceName": "Kore"}}
assert "authorization" not in httpx.Headers(requests[1][2])
assert completed == []

View file

@ -3,13 +3,96 @@ Unit tests for SensitiveDataMasker - List Preservation
"""
from functools import reduce
from types import MappingProxyType
from typing import Final
import httpx
import pytest
from litellm.litellm_core_utils.sensitive_data_masker import SensitiveDataMasker
@pytest.mark.parametrize("field", ["headers", "extra_headers"])
@pytest.mark.parametrize(
"malformed",
[
"synthetic-header-secret",
b"synthetic-header-secret",
[("Authorization", "synthetic-header-secret")],
{b"synthetic-header-secret": "unused"},
{123: "synthetic-header-secret"},
{"Bearer synthetic-header-secret": "unused"},
{"synthetic-header-secret\r\n": "unused"},
{"": "synthetic-header-secret"},
{"\u2603": "synthetic-header-secret"},
{"SYNTHETIC_KEY": "Bearer synthetic-header-secret"},
{"q8m4p9x2": "synthetic-header-secret"},
{"X-Request-Id": b"synthetic-header-secret"},
{"X-Request-Id": {"value": "synthetic-header-secret"}},
{"X-Request-Id": ["synthetic-header-secret"]},
],
)
def test_request_redaction_hides_malformed_headers_only(field: str, malformed: object) -> None:
from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_request
payload: Final = {field: malformed, "model": "synthetic-model", "temperature": 0.25}
assert redact_credentials_in_request(payload) == {
field: "REDACTED",
"model": "synthetic-model",
"temperature": 0.25,
}
assert payload[field] is malformed
@pytest.mark.parametrize("factory", [dict, MappingProxyType, httpx.Headers])
@pytest.mark.parametrize("field", ["headers", "extra_headers"])
def test_request_redaction_preserves_normal_headers_and_tool_schema(factory, field: str) -> None:
from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_request
headers: Final = factory(
{
"authorization": "synthetic-header-secret",
"cookie": "synthetic-cookie",
"x-request-id": "safe-correlation",
"content-type": "application/json",
}
)
schema: Final = {
"type": "object",
"properties": {"headers": {"type": "string"}, "extra_headers": {"type": "array"}},
}
result: Final = redact_credentials_in_request({field: headers, "tools": [{"parameters": schema}]})
assert result == {
field: {
"authorization": "REDACTED",
"cookie": "REDACTED",
"x-request-id": "safe-correlation",
"content-type": "application/json",
},
"tools": [{"parameters": schema}],
}
assert headers["authorization"] == "synthetic-header-secret"
@pytest.mark.parametrize("headers", [None, {}])
def test_request_redaction_preserves_unset_headers(headers) -> None:
from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_request
assert redact_credentials_in_request({"headers": headers}) == {"headers": headers}
def test_request_redaction_never_renders_non_string_header_values() -> None:
from litellm.litellm_core_utils.sensitive_data_masker import redact_credentials_in_request
class SensitiveHeaderValue:
def __repr__(self) -> str:
pytest.fail("A non-string header value must not be rendered")
assert redact_credentials_in_request({"headers": {"X-Request-Id": SensitiveHeaderValue()}}) == {
"headers": "REDACTED"
}
def test_lists_are_preserved_not_converted_to_strings():
"""
Regression test: Ensure lists are preserved as JSON arrays, not converted to strings.

View file

@ -0,0 +1 @@

View file

@ -0,0 +1,680 @@
import asyncio
import io
import json
import struct
import wave
from datetime import datetime, timezone
from email.utils import format_datetime
import httpx
import pytest
from litellm.llms.custom_httpx.http_handler import get_async_httpx_client
from litellm.llms.flowspeech.text_to_speech.handler import FlowSpeechTTS
from litellm.llms.flowspeech.text_to_speech.transformation import FlowSpeechException, FlowSpeechTextToSpeechConfig
from litellm.types.utils import LlmProviders
REQUEST_ID = "b698824b-de05-486d-8833-05d5c4522a39"
JOB_ID = "11111111-2222-4333-8444-555555555555"
URL = "https://flowspeech.io/api/v1/tts/jobs"
AUDIO_URL = "https://audio.example.com/recording.wav"
def wav_bytes(pcm=b"\x00\x00" * 24, metadata=False):
output = io.BytesIO()
with wave.open(output, "wb") as audio:
audio.setparams((1, 2, 24000, 0, "NONE", "not compressed"))
audio.writeframes(pcm)
content = output.getvalue()
if metadata:
content = content[:12] + b"JUNK" + struct.pack("<I", 3) + b"abc\x00" + content[12:]
content = resized_riff(content)
return content
def resized_riff(content):
return content[:4] + struct.pack("<I", len(content) - 8) + content[8:]
def changed_wav(offset, replacement):
content = wav_bytes()
return content[:offset] + replacement + content[offset + len(replacement) :]
def job(status="success", **overrides):
return {
"id": JOB_ID,
"requestId": REQUEST_ID,
"status": status,
"usage": {
"billableCharacters": 2,
"reservedCredits": 2 if status in ("queued", "running", "merging", "settling") else 0,
"chargedCredits": 2 if status == "success" else 0,
},
"result": {
"url": AUDIO_URL,
"mimeType": "audio/wav",
"sampleRate": 24000,
"channels": 1,
"bitsPerSample": 16,
}
if status == "success"
else None,
**overrides,
}
class Clock:
def __init__(self):
self.now = 0
self.sleeps = []
def time(self):
return self.now
def sleep(self, delay):
self.sleeps.append(delay)
self.now += delay
async def asleep(self, delay):
self.sleep(delay)
await asyncio.sleep(0)
def handler(clock, timeout=120, url=URL, **kwargs):
return FlowSpeechTTS(
url,
{
"Authorization": "Bearer test-key",
"Idempotency-Key": REQUEST_ID,
"Content-Type": "application/json",
"X-Private-Api-Header": "test",
},
{"input": {"mode": "single", "text": "Hi", "voiceName": "Kore"}},
timeout,
clock=clock.time,
sleep=clock.sleep,
async_sleep=clock.asleep,
wall_clock=lambda: 0,
**kwargs,
)
@pytest.fixture(params=["sync", "async"])
def invoke(request):
def run(tts, respond):
options = {
"transport": httpx.MockTransport(respond),
"headers": {"Authorization": "discard-default", "X-Client-Secret": "discard"},
"cookies": {"session": "discard"},
"auth": ("discard", "discard"),
"follow_redirects": True,
}
if request.param == "sync":
with httpx.Client(**options) as client:
return tts.run(client)
async def async_run():
async with httpx.AsyncClient(**options) as client:
return await tts.arun(client)
return asyncio.run(async_run())
return run
def test_all_pending_states_and_uncredentialed_download(invoke):
clock = Clock()
requests = []
states = iter(["queued", "running", "merging", "settling", "success"])
def respond(request):
requests.append(request)
assert "cookie" not in request.headers
assert "x-client-secret" not in request.headers
if request.url.host == "audio.example.com":
assert "authorization" not in request.headers
assert "x-private-api-header" not in request.headers
assert "idempotency-key" not in request.headers
return httpx.Response(200, content=wav_bytes())
assert request.headers["authorization"] == "Bearer test-key"
assert request.url == (URL if request.method == "POST" else f"{URL}/{JOB_ID}")
return httpx.Response(
202 if request.method == "POST" else 200,
json=job(next(states)),
headers={"set-cookie": "session=discard-from-server"},
)
result = invoke(handler(clock), respond)
assert result.content == wav_bytes()
assert result.response.headers["x-flowspeech-request-id"] == REQUEST_ID
assert "set-cookie" not in result.response.headers
assert clock.sleeps == [5, 5, 5, 5]
assert len(requests) == 6
assert requests[-1].extensions["timeout"]["read"] == 100
@pytest.mark.parametrize("prefix", ["/p%2Fq", "/p%2fq", "/p%252Fq", "/p%3Fq", "/p%23q"])
def test_encoded_gateway_prefix_survives_submission_and_polling(invoke, prefix):
requests = []
endpoint = f"{prefix}/api/v1/tts/jobs"
url = FlowSpeechTextToSpeechConfig().get_complete_url("flowspeech-tts", f"https://gateway.example{prefix}/", {})
def respond(request):
requests.append(request)
if request.method == "POST":
return httpx.Response(202, json=job("queued"))
if request.url.host == "gateway.example":
return httpx.Response(200, json=job())
return httpx.Response(200, content=wav_bytes())
assert invoke(handler(Clock(), url=url), respond).content == wav_bytes()
assert [(request.method, request.url.raw_path) for request in requests] == [
("POST", endpoint.encode()),
("GET", f"{endpoint}/{JOB_ID}".encode()),
("GET", b"/recording.wav"),
]
assert requests[0].headers["Idempotency-Key"] == REQUEST_ID
@pytest.mark.parametrize("failure", ["network", "server", "rate_limit"])
def test_create_retry_preserves_uuid_and_body(invoke, failure):
clock = Clock()
requests = []
def respond(request):
requests.append(request)
if len(requests) == 1:
if failure == "network":
raise httpx.ReadTimeout("lost response")
return httpx.Response(
429 if failure == "rate_limit" else 503,
headers={"Retry-After": "11"},
json={"error": {"code": "busy", "message": "wait", "retryable": True}, "traceId": "trace"},
)
return httpx.Response(200, json=job()) if request.method == "POST" else httpx.Response(200, content=wav_bytes())
assert invoke(handler(clock), respond).content == wav_bytes()
assert requests[0].content == requests[1].content
assert requests[0].headers["idempotency-key"] == requests[1].headers["idempotency-key"] == REQUEST_ID
assert clock.sleeps == [5 if failure == "network" else 11]
def test_http_date_retry_after_and_poll_rate_limit(invoke):
clock = Clock()
responses = iter(
[
httpx.Response(
202,
json=job("queued"),
headers={"Retry-After": format_datetime(datetime.fromtimestamp(12, timezone.utc))},
),
httpx.Response(
429,
json={"error": {"code": "rate", "message": "wait", "retryable": True}},
headers={"Retry-After": "8"},
),
httpx.Response(200, json=job()),
httpx.Response(200, content=wav_bytes()),
]
)
invoke(handler(clock), lambda request: next(responses))
assert clock.sleeps == [12, 8]
@pytest.mark.parametrize("status", ["failed", "cancelled"])
def test_terminal_failure_is_not_http_success(invoke, status):
calls = []
completed = []
def respond(request):
calls.append(request)
return httpx.Response(
200, json=job(status, error={"code": "stopped", "message": "stopped", "retryable": False})
)
with pytest.raises(FlowSpeechException, match=f"job {status}.*{REQUEST_ID}.*{JOB_ID}"):
invoke(handler(Clock(), on_completed=completed.append), respond)
assert len(calls) == 1
assert completed == []
@pytest.mark.parametrize(
"payload,match",
[
(job(result=None, resultDeleted=True), "deleted"),
(job(result=None), "no result"),
(job(status="mystery"), "invalid job"),
(job(id="../other"), "invalid job"),
({"status": "queued"}, "invalid job"),
(job(result={"url": AUDIO_URL}), "invalid job"),
(job(result={**job()["result"], "sampleRate": 48000}), "invalid job"),
({"code": 0, "data": {"audioBase64": "test"}}, "invalid job"),
],
)
def test_bad_job_responses(invoke, payload, match):
with pytest.raises(FlowSpeechException, match=match):
invoke(handler(Clock()), lambda request: httpx.Response(200, json=payload))
def test_rejects_changed_job_id(invoke):
responses = iter([httpx.Response(202, json=job("queued")), httpx.Response(200, json=job(id=REQUEST_ID))])
with pytest.raises(FlowSpeechException, match="different job ID"):
invoke(handler(Clock()), lambda request: next(responses))
@pytest.mark.parametrize("poll", [False, True])
@pytest.mark.parametrize(
"request_id", [None, 7, "invalid", REQUEST_ID.replace("-", ""), "{" + REQUEST_ID + "}", JOB_ID]
)
def test_rejects_invalid_or_mismatched_request_id_before_audio(invoke, poll, request_id):
calls, completed = [], []
responses = iter(([job("queued")] if poll else []) + [job(requestId=request_id)])
def respond(request):
calls.append(request)
assert request.url.host == "flowspeech.io"
return httpx.Response(200, json=next(responses))
with pytest.raises(FlowSpeechException):
invoke(handler(Clock(), on_completed=completed.append), respond)
assert len(calls) == (2 if poll else 1) and completed == []
@pytest.mark.parametrize("poll", [False, True])
@pytest.mark.parametrize("status", ["queued", "running", "merging", "settling", "success", "failed", "cancelled"])
def test_identity_checked_for_every_job_state(invoke, poll, status):
responses = iter(([job("queued")] if poll else []) + [job(status, requestId=JOB_ID)])
with pytest.raises(FlowSpeechException, match="different request ID"):
invoke(handler(Clock()), lambda request: httpx.Response(200, json=next(responses)))
@pytest.mark.parametrize("poll", [False, True])
@pytest.mark.parametrize("field", ["requestId", "usage"])
def test_job_requires_identity_and_usage(invoke, poll, field):
payload = {key: value for key, value in job().items() if key != field}
responses = iter(([job("queued")] if poll else []) + [payload])
with pytest.raises(FlowSpeechException, match="invalid job"):
invoke(handler(Clock()), lambda request: httpx.Response(200, json=next(responses)))
@pytest.mark.parametrize("poll", [False, True])
@pytest.mark.parametrize("field", ["billableCharacters", "reservedCredits", "chargedCredits"])
@pytest.mark.parametrize("value", [None, -1, True, "2", 1.5, float("nan"), float("inf")])
def test_rejects_invalid_usage_on_every_response(invoke, poll, field, value):
payload = job(usage={**job()["usage"], field: value})
responses = iter(([job("queued")] if poll else []) + [payload])
def respond(request):
assert request.url.host == "flowspeech.io"
return httpx.Response(200, content=json.dumps(next(responses)))
with pytest.raises(FlowSpeechException, match="invalid job"):
invoke(handler(Clock()), respond)
@pytest.mark.parametrize("usage", [None, {}, {"billableCharacters": 2, "reservedCredits": 0}])
def test_rejects_missing_usage_counters(invoke, usage):
with pytest.raises(FlowSpeechException, match="invalid job"):
invoke(handler(Clock()), lambda request: httpx.Response(200, json=job(usage=usage)))
def test_uppercase_response_ids_are_normalized_and_completion_follows_audio(invoke):
completed = []
mixed_case_id = "aa111111-2222-4333-8444-555555555555"
responses = iter(
[
job("queued", requestId=REQUEST_ID.upper(), id=mixed_case_id.upper()),
job(requestId=REQUEST_ID.upper(), id=mixed_case_id),
]
)
def respond(request):
assert completed == []
if request.url.host == "audio.example.com":
return httpx.Response(200, content=wav_bytes())
return httpx.Response(200, json=next(responses))
result = invoke(handler(Clock(), on_completed=completed.append), respond)
assert result.content == wav_bytes() and len(completed) == 1
assert completed[0].requestId == REQUEST_ID and completed[0].id == mixed_case_id
def test_invalid_wav_never_calls_completion(invoke):
completed = []
responses = iter([httpx.Response(200, json=job()), httpx.Response(200, content=b"RIFF-invalid")])
with pytest.raises(FlowSpeechException):
invoke(handler(Clock(), on_completed=completed.append), lambda request: next(responses))
assert completed == []
@pytest.mark.parametrize(
"url",
[
"http://audio.example.com/a",
"https://user:pass@audio.example.com/a",
"file:///etc/passwd",
"https://audio.example.com/a#fragment",
],
)
def test_rejects_unsafe_download_url(invoke, url):
with pytest.raises(FlowSpeechException, match="unsafe audio URL"):
invoke(handler(Clock()), lambda request: httpx.Response(200, json=job(result={**job()["result"], "url": url})))
@pytest.mark.parametrize("download", [False, True])
def test_redirects_rejected_without_following(invoke, download):
calls = []
def respond(request):
calls.append(request)
if download and len(calls) == 1:
return httpx.Response(200, json=job())
return httpx.Response(307, headers={"Location": "https://untrusted.example/collect"})
with pytest.raises(FlowSpeechException, match="redirect"):
invoke(handler(Clock()), respond)
assert len(calls) == (2 if download else 1)
def test_download_retries_do_not_create_another_job(invoke):
calls = []
completed = []
def respond(request):
calls.append(request)
if len(calls) == 1:
return httpx.Response(200, json=job())
if len(calls) == 2:
raise httpx.ReadError("download interrupted")
return httpx.Response(200, content=wav_bytes())
assert invoke(handler(Clock(), on_completed=completed.append), respond).content == wav_bytes()
assert [request.method for request in calls] == ["POST", "GET", "GET"]
assert calls[1].url == calls[2].url
assert len(completed) == 1
def test_download_exhaustion_has_recovery_ids(invoke):
calls = []
def respond(request):
calls.append(request)
if request.method == "POST":
return httpx.Response(200, json=job())
return httpx.Response(503)
with pytest.raises(FlowSpeechException, match=f"download.*{REQUEST_ID}.*{JOB_ID}"):
invoke(handler(Clock(), max_retries=1), respond)
assert [request.method for request in calls] == ["POST", "GET", "GET"]
@pytest.mark.parametrize("status", [400, 401, 402, 403, 404, 409, 413, 415, 503])
def test_api_errors_preserve_code_trace_and_no_retry(invoke, status):
calls = []
def respond(request):
calls.append(request)
return httpx.Response(
status,
json={
"error": {"code": "test_error", "message": "test message", "retryable": False},
"traceId": "trace-id",
},
)
with pytest.raises(FlowSpeechException, match=f"test_error.*trace-id.*{REQUEST_ID}") as exc:
invoke(handler(Clock()), respond)
assert exc.value.status_code == status
assert len(calls) == 1
def test_deadline_before_long_retry_after(invoke):
clock = Clock()
with pytest.raises(FlowSpeechException, match="deadline"):
invoke(
handler(clock, timeout=10),
lambda request: httpx.Response(202, json=job("queued"), headers={"Retry-After": "30"}),
)
assert clock.sleeps == []
def test_deadline_during_request(invoke):
clock = Clock()
def respond(request):
clock.now = 11
return httpx.Response(202, json=job("queued"))
with pytest.raises(FlowSpeechException, match="deadline"):
invoke(handler(clock, timeout=10), respond)
@pytest.mark.parametrize("stage", ["submission", "download"])
@pytest.mark.parametrize("header_delay,body_delay,expected_reads", [(0.125, 0, 0), (0.075, 0.075, 1)])
def test_expired_stream_is_closed_without_more_work(invoke, stage, header_delay, body_delay, expected_reads):
clock = Clock()
completed = []
requests = []
class Stream(httpx.SyncByteStream, httpx.AsyncByteStream):
def __init__(self):
self.reads = 0
self.closed = False
def __iter__(self):
self.reads += 1
clock.now += body_delay
yield wav_bytes() if stage == "download" else json.dumps(job()).encode()
pytest.fail("must not advance a stream after its budget expires")
async def __aiter__(self):
for chunk in self:
yield chunk
def close(self):
self.closed = True
async def aclose(self):
self.close()
stream = Stream()
def respond(request):
requests.append(request)
if stage == "download" and request.method == "POST":
return httpx.Response(202, json=job())
clock.now += header_delay
return httpx.Response(200, stream=stream)
with pytest.raises(FlowSpeechException, match="total deadline") as error:
invoke(handler(clock, timeout=0.1, on_completed=completed.append), respond)
assert error.value.status_code == 408
assert REQUEST_ID in str(error.value)
assert f"job_id={JOB_ID if stage == 'download' else 'unknown'}" in str(error.value)
assert stream.reads == expected_reads
assert stream.closed
assert [request.method for request in requests] == (["POST", "GET"] if stage == "download" else ["POST"])
assert clock.sleeps == []
assert completed == []
def test_deadline_after_wav_validation_prevents_success_callback(invoke, monkeypatch):
clock = Clock()
completed = []
content = wav_bytes()
open_wav = wave.open
def delayed_open(*args, **kwargs):
clock.now = 11
return open_wav(*args, **kwargs)
monkeypatch.setattr(wave, "open", delayed_open)
responses = iter([httpx.Response(202, json=job()), httpx.Response(200, content=content)])
with pytest.raises(FlowSpeechException, match="total deadline"):
invoke(handler(clock, timeout=10, on_completed=completed.append), lambda request: next(responses))
assert completed == []
assert clock.sleeps == []
@pytest.mark.parametrize("timeout", [0, -1, float("inf"), float("nan"), httpx.Timeout(None)])
def test_invalid_timeout(timeout):
with pytest.raises(ValueError, match="timeout"):
handler(Clock(), timeout=timeout)
@pytest.mark.parametrize("retries", [-1, 11, 1.5, True])
def test_invalid_retries(retries):
with pytest.raises(ValueError, match="max_retries"):
handler(Clock(), max_retries=retries)
@pytest.mark.parametrize(
"content,headers",
[
(b"not wav", {}),
(wav_bytes(b""), {}),
(wav_bytes()[:-2], {}),
(wav_bytes(b"\x00" * 49), {}),
(changed_wav(4, struct.pack("<I", 9999)), {}),
(changed_wav(34, struct.pack("<H", 9)), {}),
(changed_wav(32, struct.pack("<H", 4)), {}),
(changed_wav(28, struct.pack("<I", 24000)), {}),
(resized_riff(wav_bytes() + b"x"), {}),
(resized_riff(wav_bytes() + b"JUNK" + struct.pack("<I", 5)), {}),
(resized_riff(wav_bytes(b"\x00" * 49) + b"\x00"), {}),
(resized_riff(wav_bytes()[:-2]), {}),
(wav_bytes(), {"content-length": str(101 * 1024 * 1024)}),
(wav_bytes(), {"content-length": "invalid"}),
(wav_bytes(), {"content-encoding": "unknown"}),
],
)
def test_rejects_invalid_or_unbounded_audio(invoke, content, headers):
responses = iter([httpx.Response(200, json=job()), httpx.Response(200, content=content, headers=headers)])
with pytest.raises(FlowSpeechException):
invoke(handler(Clock()), lambda request: next(responses))
def test_accepts_wav_with_padded_metadata_chunk(invoke):
audio = wav_bytes(metadata=True)
responses = iter([httpx.Response(200, json=job()), httpx.Response(200, content=audio)])
assert invoke(handler(Clock()), lambda request: next(responses)).content == audio
def test_stream_size_limit_without_content_length(invoke):
tts = handler(Clock())
tts.MAX_AUDIO_BYTES = 10
responses = iter([httpx.Response(200, json=job()), httpx.Response(200, content=wav_bytes())])
def respond(request):
response = next(responses)
response.headers.pop("content-length", None)
return response
with pytest.raises(FlowSpeechException, match="size limit"):
invoke(tts, respond)
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("owned", [False, True])
@pytest.mark.parametrize("successful", [False, True])
@pytest.mark.asyncio
async def test_client_lifetime(monkeypatch, asynchronous, owned, successful):
methods = []
def respond(request):
methods.append(request.method)
if request.method == "POST":
return httpx.Response(202, json=job("success" if successful else "failed"))
return httpx.Response(200, content=wav_bytes())
client_type = httpx.AsyncClient if asynchronous else httpx.Client
client = client_type(transport=httpx.MockTransport(respond))
def create_client(*, trust_env):
assert trust_env is False
return client
if owned:
if asynchronous:
get_async_httpx_client(LlmProviders.FLOWSPEECH).client = client
else:
monkeypatch.setattr(httpx, "Client", create_client)
tts = handler(Clock())
async def call():
if asynchronous:
return await tts.arun(None if owned else client)
return tts.run(None if owned else client)
try:
if successful:
result = await call()
assert result.content == wav_bytes()
else:
with pytest.raises(FlowSpeechException, match="FlowSpeech job failed"):
await call()
assert methods == (["POST", "GET"] if successful else ["POST"])
assert client.is_closed is (owned and not asynchronous)
finally:
if asynchronous:
await client.aclose()
else:
client.close()
@pytest.mark.asyncio
async def test_default_async_client_is_reused_without_download_credentials():
requests = []
def respond(request):
requests.append(request)
if request.method == "POST":
return httpx.Response(202, json=job())
assert "authorization" not in request.headers
assert "cookie" not in request.headers
assert "x-client-secret" not in request.headers
return httpx.Response(200, content=wav_bytes())
cached = get_async_httpx_client(LlmProviders.FLOWSPEECH)
async with httpx.AsyncClient(
transport=httpx.MockTransport(respond),
headers={"Authorization": "discard", "X-Client-Secret": "discard"},
cookies={"session": "discard"},
) as client:
cached.client = client
for _ in range(2):
result = await handler(Clock()).arun()
assert result.content == wav_bytes()
assert not client.is_closed
assert get_async_httpx_client(LlmProviders.FLOWSPEECH).client is client
assert [request.method for request in requests] == ["POST", "GET", "POST", "GET"]
@pytest.mark.asyncio
async def test_async_total_deadline_interrupts_network():
async def respond(request):
await asyncio.sleep(1)
return httpx.Response(202, json=job("queued"))
tts = FlowSpeechTTS(URL, {"Idempotency-Key": REQUEST_ID}, {"input": {}}, timeout=0.02)
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
with pytest.raises(FlowSpeechException, match="total deadline"):
await tts.arun(client)
@pytest.mark.asyncio
async def test_async_cancellation_propagates():
started = asyncio.Event()
async def respond(request):
started.set()
await asyncio.sleep(100)
return httpx.Response(200, json=job())
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
task = asyncio.create_task(handler(Clock()).arun(client))
await started.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task

View file

@ -0,0 +1,578 @@
import io
import json
import logging
import traceback
import wave
from typing import Final
from uuid import UUID
import httpx
import pytest
import litellm
from litellm.integrations.custom_logger import CustomLogger
from litellm.llms.custom_httpx.http_handler import HTTPHandler
from litellm.llms.flowspeech.text_to_speech.transformation import FlowSpeechException, FlowSpeechTextToSpeechConfig
REQUEST_ID = "b698824b-de05-486d-8833-05d5c4522a39"
JOB_ID = "11111111-2222-4333-8444-555555555555"
SECRET_SENTINEL = "credential-value-must-not-appear-672911"
def assert_clean_exception_chain(error: BaseException | None, seen: frozenset[int] = frozenset()) -> None:
if error is None or id(error) in seen:
return
assert SECRET_SENTINEL not in repr(error.args)
assert SECRET_SENTINEL not in repr(vars(error))
assert SECRET_SENTINEL not in "".join(traceback.format_exception(error))
request: Final = getattr(error, "request", None)
if isinstance(request, httpx.Request):
assert SECRET_SENTINEL not in str(request.url) + repr(request.headers) + repr(request.content)
assert_clean_exception_chain(error.__cause__, seen | {id(error)})
assert_clean_exception_chain(error.__context__, seen | {id(error)})
class FailureRecorder(CustomLogger):
def __init__(self):
super().__init__()
self.errors = []
def log_failure_event(self, kwargs, response_obj, start_time, end_time):
self.errors.append(
(str(kwargs["exception"]), kwargs["traceback_exception"], kwargs["standard_logging_object"]["error_str"])
)
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
self.log_failure_event(kwargs, response_obj, start_time, end_time)
def wav_bytes():
output = io.BytesIO()
with wave.open(output, "wb") as audio:
audio.setparams((1, 2, 24000, 0, "NONE", "not compressed"))
audio.writeframes(b"\x00\x00" * 24)
return output.getvalue()
def success(request_id=REQUEST_ID):
return {
"id": JOB_ID,
"requestId": request_id,
"status": "success",
"usage": {"billableCharacters": 5, "reservedCredits": 0, "chargedCredits": 5},
"result": {
"url": "https://audio.example.com/recording.wav",
"mimeType": "audio/wav",
"sampleRate": 24000,
"channels": 1,
"bitsPerSample": 16,
},
}
def test_maps_single_voice_and_uuid():
config = FlowSpeechTextToSpeechConfig()
voice, params = config.map_openai_params("flowspeech-tts", {"response_format": "wav"}, {"voiceName": "Aoede"})
request = config.transform_text_to_speech_request("flowspeech-tts", "Hello", voice, params, {}, {})
assert request["dict_body"] == {"input": {"mode": "single", "text": "Hello", "voiceName": "Aoede"}}
assert UUID(request["headers"]["Idempotency-Key"]).version == 4
assert config.get_supported_openai_params("flowspeech-tts") == ["voice", "response_format"]
def test_maps_multi_and_recovery_id():
config = FlowSpeechTextToSpeechConfig()
segments = [{"speaker": "Alice", "text": "Hi", "voiceName": "Kore"}]
voice, params = config.map_openai_params(
"flowspeech-tts", {}, kwargs={"segments": segments, "request_id": REQUEST_ID}
)
request = config.transform_text_to_speech_request("flowspeech-tts", "", voice, params, {}, {})
assert request["dict_body"] == {"input": {"mode": "multi", "segments": segments}}
assert request["headers"]["Idempotency-Key"] == REQUEST_ID
@pytest.mark.parametrize(
"params,message",
[
({"speed": 1}, "FlowSpeech does not support instructions or speed"),
({"instructions": "calm"}, "FlowSpeech does not support instructions or speed"),
({"response_format": "mp3"}, "FlowSpeech only supports response_format='wav'"),
],
)
def test_rejects_unsupported_options_even_with_drop_params(params, message):
with pytest.raises(ValueError, match=message):
FlowSpeechTextToSpeechConfig().map_openai_params("flowspeech-tts", params, drop_params=True)
@pytest.mark.parametrize("key", ["source", "format", "speakers", "originalText", "prompt", "stream", "extra_body"])
def test_rejects_legacy_and_unsupported_kwargs(key):
with pytest.raises(ValueError, match="Unsupported"):
FlowSpeechTextToSpeechConfig().map_openai_params("flowspeech-tts", {}, kwargs={key: "unused"})
@pytest.mark.parametrize("voice", ["", " ", {}, {"voiceName": ""}, {"voiceName": 7}])
def test_rejects_invalid_voice(voice):
with pytest.raises(ValueError, match="FlowSpeech voice must be a nonempty voice name"):
FlowSpeechTextToSpeechConfig().map_openai_params("flowspeech-tts", {}, voice)
@pytest.mark.parametrize(
"params,text,message",
[
({"segments": []}, "", "FlowSpeech requires 1 to 1000 nonempty speaker turns"),
(
{"segments": [{"speaker": "A", "text": "Hi", "voiceName": "Kore", "speed": 1}]},
"",
"Extra inputs are not permitted",
),
(
{"segments": [{"speaker": " ", "text": "Hi", "voiceName": "Kore"}]},
"",
"FlowSpeech requires 1 to 1000 nonempty speaker turns",
),
(
{"segments": [{"speaker": "A", "text": "Hi", "voiceName": "Kore"}]},
"ambiguous",
"Use input='' with FlowSpeech segments",
),
({"request_id": "../bad"}, "Hi", "FlowSpeech requires a UUID"),
({}, " ", "FlowSpeech input must contain text"),
],
)
def test_invalid_requests(params, text, message):
with pytest.raises(ValueError, match=message):
FlowSpeechTextToSpeechConfig().transform_text_to_speech_request("flowspeech-tts", text, None, params, {}, {})
def test_conflicting_idempotency_keys():
with pytest.raises(ValueError, match="must agree"):
FlowSpeechTextToSpeechConfig().transform_text_to_speech_request(
"flowspeech-tts", "Hi", None, {"request_id": REQUEST_ID}, {}, {"idempotency-key": JOB_ID}
)
def test_rejects_multi_with_voice_or_unknown_model():
with pytest.raises(ValueError, match="segment"):
FlowSpeechTextToSpeechConfig().map_openai_params("flowspeech-tts", {}, "Kore", kwargs={"segments": []})
with pytest.raises(ValueError, match="route"):
FlowSpeechTextToSpeechConfig().map_openai_params("unsupported", {})
def test_bearer_header_overrides_case_insensitively():
headers = FlowSpeechTextToSpeechConfig().validate_environment(
{"authorization": "discard", "content-type": "discard", "X-Correlation-Id": "test"},
"flowspeech-tts",
"test-key",
)
assert httpx.Headers(headers)["authorization"] == "Bearer test-key"
assert len(httpx.Headers(headers).get_list("authorization")) == 1
assert headers["Content-Type"] == "application/json"
@pytest.mark.parametrize("key", ["", " ", "two tokens", "bad\nkey", "bad\x00key"])
def test_rejects_invalid_key(key):
with pytest.raises(ValueError, match="API key"):
FlowSpeechTextToSpeechConfig().validate_environment({}, "flowspeech-tts", key)
@pytest.mark.parametrize("name", ["Cookie", "Proxy-Authorization", "Host", "content-length"])
def test_rejects_unsafe_api_headers(name):
with pytest.raises(ValueError, match="does not accept cookie, proxy credential, host or content-length overrides"):
FlowSpeechTextToSpeechConfig().validate_environment({name: "test"}, "flowspeech-tts", "test-key")
def test_missing_key(monkeypatch):
monkeypatch.setattr(litellm, "api_key", None)
monkeypatch.delenv("FLOWSPEECH_API_KEY", raising=False)
with pytest.raises(ValueError, match="API key"):
FlowSpeechTextToSpeechConfig().validate_environment({}, "flowspeech-tts")
@pytest.mark.parametrize("base", ["https://flowspeech.io", "https://flowspeech.io/api/v1/tts/jobs/"])
def test_complete_url(base):
assert (
FlowSpeechTextToSpeechConfig().get_complete_url("flowspeech-tts", base, {})
== "https://flowspeech.io/api/v1/tts/jobs"
)
@pytest.mark.parametrize(
"base,message",
[
("http://example.com", "FlowSpeech requires an HTTPS URL without credentials or fragment"),
("https://u:p@example.com", "FlowSpeech requires an HTTPS URL without credentials or fragment"),
("file:///tmp/test", "FlowSpeech requires an HTTPS URL without credentials or fragment"),
("https://example.com/?key=x", "FlowSpeech api_base must not contain a query"),
("https://example.com/p?", "FlowSpeech api_base must not contain a query"),
("https://example.com/#x", "FlowSpeech requires an HTTPS URL without credentials or fragment"),
(
"https://example.com/api/ai/text-to-speech",
"FlowSpeech api_base must not use the legacy text-to-speech endpoint",
),
("", "FlowSpeech requires an HTTPS URL without credentials or fragment"),
],
)
def test_rejects_invalid_base(base, message):
with pytest.raises(ValueError, match=message):
FlowSpeechTextToSpeechConfig().get_complete_url("flowspeech-tts", base, {})
@pytest.mark.parametrize(
"base,expected",
[
("https://gateway.example/p", "https://gateway.example/p/api/v1/tts/jobs"),
("https://gateway.example/p/", "https://gateway.example/p/api/v1/tts/jobs"),
("https://gateway.example/p/api/v1/tts/jobs/", "https://gateway.example/p/api/v1/tts/jobs"),
("https://api/v1/", "https://api/v1/api/v1/tts/jobs"),
],
)
def test_gateway_base_preserves_prefix_without_duplicating_endpoint(base, expected):
assert FlowSpeechTextToSpeechConfig().get_complete_url("flowspeech-tts", base, {}) == expected
@pytest.mark.parametrize("prefix", ["/p%2Fq", "/p%2fq", "/p%252Fq", "/p%3Fq", "/p%23q"])
@pytest.mark.parametrize("suffix", ["/", "/api/v1/tts/jobs", "/api/v1/tts/jobs/"])
def test_gateway_prefix_preserves_encoded_path(prefix, suffix):
url = FlowSpeechTextToSpeechConfig().get_complete_url(
"flowspeech-tts", f"https://gateway.example{prefix}{suffix}", {}
)
assert httpx.URL(url).raw_path == f"{prefix}/api/v1/tts/jobs".encode("ascii")
assert httpx.URL(url).query == b""
assert httpx.URL(url).fragment == ""
@pytest.mark.parametrize(
"headers",
[SECRET_SENTINEL, {SECRET_SENTINEL.encode(): "invalid"}, {"Authorization": {"value": SECRET_SENTINEL}}],
)
def test_invalid_headers_raise_no_input_bearing_exception_chain(headers):
with pytest.raises(ValueError, match="FlowSpeech headers must be a mapping") as error:
FlowSpeechTextToSpeechConfig().validate_environment(headers, "flowspeech-tts", "test-key")
assert error.value.__context__ is None
assert SECRET_SENTINEL not in "".join(traceback.format_exception(error.value))
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("positional", [False, True])
@pytest.mark.parametrize(
"invalid,message",
[
({"api_key": SECRET_SENTINEL.encode()}, "FlowSpeech API key is required"),
({"api_key": {"value": SECRET_SENTINEL}}, "FlowSpeech API key is required"),
({"headers": {"Authorization": SECRET_SENTINEL.encode()}}, "FlowSpeech headers must be a mapping"),
({"headers": {"Authorization": {"value": SECRET_SENTINEL}}}, "FlowSpeech headers must be a mapping"),
({"extra_headers": {"Authorization": SECRET_SENTINEL.encode()}}, "FlowSpeech headers must be a mapping"),
({"extra_headers": {"Authorization": {"value": SECRET_SENTINEL}}}, "FlowSpeech headers must be a mapping"),
({"headers": SECRET_SENTINEL}, "FlowSpeech headers must be a mapping"),
({"extra_headers": SECRET_SENTINEL}, "FlowSpeech headers must be a mapping"),
({"headers": {SECRET_SENTINEL.encode(): "unused"}}, "FlowSpeech headers must be a mapping"),
({"extra_headers": {SECRET_SENTINEL.encode(): "unused"}}, "FlowSpeech headers must be a mapping"),
({"headers": {"X-Correlation-Id": SECRET_SENTINEL.encode()}}, "FlowSpeech headers must be a mapping"),
({"headers": {"X-Correlation-Id": {"value": SECRET_SENTINEL}}}, "FlowSpeech headers must be a mapping"),
({"extra_headers": {"X-Correlation-Id": SECRET_SENTINEL.encode()}}, "FlowSpeech headers must be a mapping"),
({"extra_headers": {"X-Correlation-Id": {"value": SECRET_SENTINEL}}}, "FlowSpeech headers must be a mapping"),
],
)
async def test_invalid_credentials_never_reach_errors_or_logs(
asynchronous,
positional,
invalid,
message,
monkeypatch,
caplog,
capsys,
):
caplog.set_level(logging.DEBUG, logger="LiteLLM")
recorder = FailureRecorder()
monkeypatch.setattr(litellm, "failure_callback", [recorder])
monkeypatch.setattr(litellm, "_async_failure_callback", [recorder])
requests = []
def respond(request):
requests.append(request)
return httpx.Response(200, json=success())
kwargs = {"model": "flowspeech/flowspeech-tts", "input": "Hello", "api_key": "test-key", **invalid}
args: Final = (kwargs["model"], kwargs["input"], None, kwargs["api_key"]) if positional else ()
call_kwargs: Final = (
{key: value for key, value in kwargs.items() if key not in ("model", "input", "api_key")}
if positional
else kwargs
)
if asynchronous:
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
with pytest.raises(litellm.APIConnectionError, match=message) as error:
await litellm.aspeech(*args, **call_kwargs, client=client)
else:
with httpx.Client(transport=httpx.MockTransport(respond)) as client:
with pytest.raises(ValueError, match=message) as error:
litellm.speech(*args, **call_kwargs, client=client)
captured = capsys.readouterr()
assert requests == []
assert recorder.errors
assert SECRET_SENTINEL not in str(error.value)
assert SECRET_SENTINEL not in "".join(traceback.format_exception(error.value))
assert SECRET_SENTINEL not in repr(recorder.errors)
assert SECRET_SENTINEL not in caplog.text + captured.out + captured.err
assert_clean_exception_chain(error.value)
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("positional", [False, True])
@pytest.mark.parametrize("successful", [False, True])
@pytest.mark.parametrize("verbose", [False, True])
@pytest.mark.parametrize("header_field", ["headers", "extra_headers"])
@pytest.mark.parametrize("header_name", ["Authorization", SECRET_SENTINEL])
async def test_request_log_redaction_preserves_speech_transport(
asynchronous: bool,
positional: bool,
successful: bool,
verbose: bool,
header_field: str,
header_name: str,
monkeypatch: pytest.MonkeyPatch,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
) -> None:
monkeypatch.setattr(litellm, "set_verbose", verbose)
monkeypatch.setattr("litellm._logging.set_verbose", verbose)
caplog.set_level(logging.WARNING if verbose else logging.DEBUG, logger="LiteLLM")
headers: Final = {header_name: SECRET_SENTINEL, "X-Correlation-Id": "safe-correlation"}
args: Final = ("flowspeech/flowspeech-tts", "Hello", "Kore", SECRET_SENTINEL) if positional else ()
kwargs: Final = (
{}
if positional
else {
"model": "flowspeech/flowspeech-tts",
"input": "Hello",
"voice": "Kore",
"api_key": SECRET_SENTINEL,
}
)
calls: Final = []
def respond(request: httpx.Request) -> httpx.Response:
calls.append(request.method)
if request.method == "POST":
assert request.headers["authorization"] == f"Bearer {SECRET_SENTINEL}"
assert request.headers["x-correlation-id"] == "safe-correlation"
assert request.headers["idempotency-key"] == REQUEST_ID
assert json.loads(request.content) == {"input": {"mode": "single", "text": "Hello", "voiceName": "Kore"}}
if not successful:
return httpx.Response(
400, json={"error": {"code": "synthetic", "message": "synthetic", "retryable": False}}
)
return httpx.Response(200, json=success())
assert "authorization" not in request.headers
assert "cookie" not in request.headers
assert "x-correlation-id" not in request.headers
return httpx.Response(200, content=wav_bytes())
async def call():
if asynchronous:
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
return await litellm.aspeech(
*args,
**kwargs,
**{header_field: headers},
request_id=REQUEST_ID,
max_retries=0,
client=client,
)
with httpx.Client(transport=httpx.MockTransport(respond)) as client:
return litellm.speech(
*args,
**kwargs,
**{header_field: headers},
request_id=REQUEST_ID,
max_retries=0,
client=client,
)
if successful:
result: Final = await call()
assert result.content == wav_bytes()
else:
with pytest.raises(litellm.BadRequestError if asynchronous else FlowSpeechException) as error:
await call()
assert_clean_exception_chain(error.value)
assert error.value.status_code == 400
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert SECRET_SENTINEL not in output
assert "REDACTED" in output
assert ("safe-correlation" in output) is (header_name == "Authorization")
assert "Hello" in output and "Kore" in output
assert calls == (["POST", "GET"] if successful else ["POST"])
assert headers == {header_name: SECRET_SENTINEL, "X-Correlation-Id": "safe-correlation"}
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("debug", [False, True])
async def test_positional_key_debug_controls(
asynchronous: bool,
debug: bool,
monkeypatch: pytest.MonkeyPatch,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
) -> None:
monkeypatch.setattr(litellm, "set_verbose", False)
monkeypatch.setattr("litellm._logging.set_verbose", False)
caplog.set_level(logging.DEBUG if debug else logging.ERROR, logger="LiteLLM")
calls: Final = []
def respond(request: httpx.Request) -> httpx.Response:
calls.append(request.method)
assert request.headers["authorization"] == f"Bearer {SECRET_SENTINEL}"
return httpx.Response(400, json={"error": {"code": "synthetic", "message": "synthetic", "retryable": False}})
async def call() -> None:
if asynchronous:
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
await litellm.aspeech(
"flowspeech/flowspeech-tts", "Hello", "Kore", SECRET_SENTINEL, client=client, max_retries=0
)
else:
with httpx.Client(transport=httpx.MockTransport(respond)) as client:
litellm.speech(
"flowspeech/flowspeech-tts", "Hello", "Kore", SECRET_SENTINEL, client=client, max_retries=0
)
with pytest.raises(litellm.BadRequestError if asynchronous else FlowSpeechException) as error:
await call()
captured: Final = capsys.readouterr()
assert SECRET_SENTINEL not in caplog.text + captured.out + captured.err
assert ("Request to litellm:" in caplog.text) is debug
assert calls == ["POST"]
assert_clean_exception_chain(error.value)
def test_registers_provider():
from litellm.utils import ProviderConfigManager
model, provider, _, _ = litellm.get_llm_provider("flowspeech/flowspeech-tts")
config = ProviderConfigManager.get_provider_text_to_speech_config(model, litellm.LlmProviders.FLOWSPEECH)
assert model == "flowspeech-tts"
assert provider == "flowspeech"
assert isinstance(config, FlowSpeechTextToSpeechConfig)
assert "flowspeech/flowspeech-tts" in litellm.model_list
assert litellm.models_by_provider[provider] == litellm.flowspeech_models
assert "flowspeech/flowspeech-tts" in litellm.models_by_provider[provider]
@pytest.mark.parametrize("multi", [False, True])
@pytest.mark.parametrize("timeout_args", [{}, {"timeout": None}, {"timeout": 60}])
def test_speech_dispatch(multi, timeout_args):
requests = []
logs = []
segments = [{"speaker": "A", "text": "Hi", "voiceName": "Kore"}]
def log_event(details):
if details.get("log_event_type") == "post_api_call":
logs.append((details["api_key"], details["original_response"], dict(details["additional_args"])))
def respond(request):
requests.append(request)
if request.method == "POST":
assert request.url.path == "/api/v1/tts/jobs"
assert request.headers["authorization"] == "Bearer test-key"
assert request.headers["idempotency-key"] == REQUEST_ID
assert json.loads(request.content) == {
"input": (
{"mode": "multi", "segments": segments}
if multi
else {"mode": "single", "text": "Hello", "voiceName": "Aoede"}
)
}
return httpx.Response(202, json=success())
assert request.url.host == "audio.example.com"
assert logs == []
assert "authorization" not in request.headers and "cookie" not in request.headers
return httpx.Response(200, content=wav_bytes())
with httpx.Client(transport=httpx.MockTransport(respond)) as http_client:
result = litellm.speech(
model="flowspeech/flowspeech-tts",
input="" if multi else "Hello",
api_key="test-key",
response_format="wav",
request_id=REQUEST_ID,
client=HTTPHandler(client=http_client),
logger_fn=log_event,
**timeout_args,
**({"segments": segments} if multi else {"voice": "Aoede"}),
)
assert result.content == wav_bytes()
assert result.response.headers["content-type"] == "audio/wav"
assert result.response.headers["x-flowspeech-job-id"] == JOB_ID
assert len(requests) == 2
assert len(logs) == 1 and logs[0][0] == ""
assert json.loads(logs[0][1]) == {key: success()[key] for key in ("id", "requestId", "status", "usage")}
assert logs[0][2] == {"request_id": REQUEST_ID, "job_id": JOB_ID}
assert "test-key" not in repr(logs) and "audio.example.com" not in repr(logs)
@pytest.mark.asyncio
@pytest.mark.parametrize("timeout_args", [{}, {"timeout": None}, {"timeout": 60}])
async def test_aspeech_dispatch(timeout_args):
requests = []
logs = []
def log_event(details):
if details.get("log_event_type") == "post_api_call":
logs.append((details["api_key"], details["original_response"], dict(details["additional_args"])))
async def respond(request):
requests.append(request)
if request.method == "POST":
assert json.loads(request.content)["input"]["voiceName"] == "Kore"
return httpx.Response(200, json=success(request.headers["idempotency-key"]))
assert "authorization" not in request.headers
assert logs == []
return httpx.Response(200, content=wav_bytes())
async with httpx.AsyncClient(transport=httpx.MockTransport(respond)) as client:
result = await litellm.aspeech(
model="flowspeech/flowspeech-tts",
input="Hello",
api_key="test-key",
client=client,
logger_fn=log_event,
**timeout_args,
)
assert result.content == wav_bytes()
assert len(requests) == 2
assert len(logs) == 1 and logs[0][0] == ""
assert json.loads(logs[0][1])["requestId"] == requests[0].headers["idempotency-key"]
assert logs[0][2]["job_id"] == JOB_ID
assert "test-key" not in repr(logs) and "audio.example.com" not in repr(logs)
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
async def test_dispatch_rejects_mismatched_client_before_sending(asynchronous):
requests = []
def respond(request):
requests.append(request)
return httpx.Response(200, json=success())
client_type = httpx.Client if asynchronous else httpx.AsyncClient
client = client_type(transport=httpx.MockTransport(respond))
try:
kwargs = {"model": "flowspeech/flowspeech-tts", "input": "Hello", "api_key": "test-key", "client": client}
message = "client must match the synchronous or asynchronous speech call"
if asynchronous:
with pytest.raises(litellm.APIConnectionError, match=message):
await litellm.aspeech(**kwargs)
else:
with pytest.raises(ValueError, match=message):
litellm.speech(**kwargs)
assert requests == []
finally:
if isinstance(client, httpx.AsyncClient):
await client.aclose()
else:
client.close()

View file

@ -172,6 +172,46 @@ def test_audio_speech_happy_path(client, auth_as, patched_speech, path):
}
@pytest.mark.parametrize("path", ["/v1/audio/speech", "/audio/speech"])
def test_flowspeech_proxy_preserves_wav_and_recovery_ids(client, auth_as, patched_speech, monkeypatch, path):
job_id = "11111111-2222-4333-8444-555555555555"
request_id = "b698824b-de05-486d-8833-05d5c4522a39"
async def audio():
return HttpxBinaryResponseContent(
httpx.Response(
200,
content=b"RIFF-test-WAVE",
headers={
"content-type": "audio/wav",
"x-flowspeech-job-id": job_id,
"x-flowspeech-request-id": request_id,
},
)
)
async def route(*args, **kwargs):
assert kwargs["data"]["request_id"] == request_id
return audio()
monkeypatch.setattr(proxy_server, "route_request", route)
with auth_as():
response = client.post(
path,
json={
"model": "narration-alias",
"input": "Hi",
"voice": "Kore",
"request_id": request_id,
},
)
assert response.status_code == 200
assert response.content == b"RIFF-test-WAVE"
assert response.headers["content-type"] == "audio/wav"
assert response.headers["x-flowspeech-job-id"] == job_id
assert response.headers["x-flowspeech-request-id"] == request_id
@pytest.mark.parametrize(
("patched_speech", "response_format", "expected_content_type"),
[

View file

@ -560,6 +560,24 @@ def test_every_backend_provider_is_listed_in_add_model_or_frozen_as_unlisted():
)
def test_flowspeech_provider_fields_support_configured_credentials():
app_instance = FastAPI()
app_instance.include_router(router)
test_client = TestClient(app_instance)
response = test_client.get("/public/providers/fields")
assert response.status_code == 200
entry = next(p for p in response.json() if p["litellm_provider"] == "flowspeech")
fields = {field["key"]: field for field in entry["credential_fields"]}
assert entry["provider_display_name"] == "FlowSpeech"
assert entry["default_model_placeholder"] in litellm.models_by_provider["flowspeech"]
assert fields["api_key"]["required"] is True
assert fields["api_key"]["field_type"] == "password"
assert fields["api_base"]["required"] is False
assert fields["api_base"]["field_type"] == "text"
assert fields["api_base"]["placeholder"] == "https://flowspeech.io"
def test_google_ai_studio_provider_fields_expose_api_base():
"""The Google AI Studio (gemini) credential form must let admins set a custom
api_base so they can point at a Gemini-compatible gateway (e.g. a self-hosted

View file

@ -4,6 +4,7 @@ import base64
import copy
import contextlib
import contextvars
import inspect
import io
import json
import logging
@ -22,6 +23,7 @@ import httpx
import pytest
import respx
from jsonschema import Draft7Validator, validate
from pydantic import ValidationError
import litellm
from litellm.exceptions import MidStreamFallbackError
@ -6986,6 +6988,344 @@ class TestVerboseRequestLineRedaction:
FAKE_API_KEY: Final = "sk-fake-lit6823-0000000000000000"
@pytest.mark.parametrize("verbose", [False, True])
@pytest.mark.parametrize(
"args, kwargs",
[
(["synthetic-model", "SYNTHETIC-BOUNDARY-SECRET"], {"api_key": "SYNTHETIC-BOUNDARY-SECRET"}),
("SYNTHETIC-BOUNDARY-SECRET", {"model": "synthetic-model"}),
(None, {"api_key": "SYNTHETIC-BOUNDARY-SECRET"}),
((), [("api_key", "SYNTHETIC-BOUNDARY-SECRET")]),
((), {123: "SYNTHETIC-BOUNDARY-SECRET"}),
((), {b"api_key": "SYNTHETIC-BOUNDARY-SECRET"}),
],
)
def test_malformed_request_containers_do_not_emit_or_raise(
self,
args: object,
kwargs: object,
verbose: bool,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.utils import print_args_passed_to_litellm
monkeypatch.setattr(litellm, "set_verbose", verbose)
monkeypatch.setattr("litellm._logging.set_verbose", verbose)
with caplog.at_level(logging.DEBUG if not verbose else logging.WARNING, logger=verbose_logger.name):
print_args_passed_to_litellm(litellm.completion, args, kwargs)
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert "litellm.completion(" not in output
assert "SYNTHETIC-BOUNDARY-SECRET" not in output
def test_disabled_logging_does_not_validate_or_emit_request_containers(
self,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.utils import print_args_passed_to_litellm
adapter: Final = Mock(side_effect=RuntimeError("Disabled logging constructed a validator"))
monkeypatch.setattr(litellm, "set_verbose", False)
monkeypatch.setattr("litellm._logging.set_verbose", False)
with monkeypatch.context() as validation:
validation.setattr("litellm.utils.TypeAdapter", adapter)
with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
print_args_passed_to_litellm(
litellm.completion, (self.FAKE_API_KEY,), {"api_key": self.FAKE_API_KEY}
)
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert adapter.call_count == 0
assert "litellm.completion(" not in output
assert self.FAKE_API_KEY not in output
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("verbose", [False, True])
@pytest.mark.parametrize("stage", ["args", "kwargs"])
@pytest.mark.parametrize("error_type", [TypeError, ValueError, ValidationError])
async def test_shape_validation_failure_keeps_mock_operation_and_drops_error_details(
self,
asynchronous: bool,
verbose: bool,
stage: str,
error_type: type[Exception],
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
monkeypatch: pytest.MonkeyPatch,
) -> None:
from pydantic import TypeAdapter
rendered: Final = Mock()
class UnrenderedInput:
def __repr__(self) -> str:
rendered()
return "SYNTHETIC-INPUT-REPR"
signed_url: Final = "https://audio.example.test/result.wav?sig=SYNTHETIC-URL-SECRET"
diagnostic: Final = f"SYNTHETIC-INPUT-REPR {self.FAKE_API_KEY} {signed_url}"
unrendered: Final = UnrenderedInput()
def fail_validation(value: object, *, strict: bool) -> None:
assert strict is True
assert isinstance(value, tuple if stage == "args" else dict)
if error_type is ValidationError:
TypeAdapter(int).validate_python({"diagnostic": diagnostic, "input": unrendered}, strict=True)
pytest.fail("Expected a real Pydantic validation failure")
raise error_type(diagnostic, unrendered)
broken: Final = Mock()
broken.validate_python.side_effect = fail_validation
def adapter_factory(annotation: object) -> object:
if annotation == (tuple[object, ...] if stage == "args" else Mapping[str, object]):
return broken
return TypeAdapter(annotation)
monkeypatch.setattr(litellm, "set_verbose", verbose)
monkeypatch.setattr("litellm._logging.set_verbose", verbose)
with monkeypatch.context() as validation:
validation.setattr("litellm.utils.TypeAdapter", adapter_factory)
with caplog.at_level(logging.DEBUG if not verbose else logging.WARNING, logger=verbose_logger.name):
response: Final = (
await litellm.acompletion(
model="openai/synthetic-model",
messages=[{"role": "user", "content": "synthetic input"}],
api_key=self.FAKE_API_KEY,
mock_response="synthetic output",
)
if asynchronous
else litellm.completion(
model="openai/synthetic-model",
messages=[{"role": "user", "content": "synthetic input"}],
api_key=self.FAKE_API_KEY,
mock_response="synthetic output",
)
)
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert response.choices[0].message.content == "synthetic output"
assert broken.validate_python.call_count >= 1
assert rendered.call_count == 0
assert "Skipped malformed request debug logging" in output
assert self.FAKE_API_KEY not in output
assert signed_url not in output
assert "SYNTHETIC-INPUT-REPR" not in output
assert all(record.exc_info is None for record in caplog.records)
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
async def test_disabled_wrapper_logging_does_not_construct_shape_validators(
self,
asynchronous: bool,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
monkeypatch: pytest.MonkeyPatch,
) -> None:
from pydantic import TypeAdapter
constructed: Final = Mock()
def adapter_factory(annotation: object) -> object:
if annotation in (tuple[object, ...], Mapping[str, object]):
constructed(annotation)
return TypeAdapter(annotation)
monkeypatch.setattr(litellm, "set_verbose", False)
monkeypatch.setattr("litellm._logging.set_verbose", False)
with monkeypatch.context() as validation:
validation.setattr("litellm.utils.TypeAdapter", adapter_factory)
with caplog.at_level(logging.WARNING, logger=verbose_logger.name):
response: Final = (
await litellm.acompletion(
model="openai/synthetic-model",
messages=[{"role": "user", "content": "synthetic input"}],
api_key=self.FAKE_API_KEY,
mock_response="synthetic output",
)
if asynchronous
else litellm.completion(
model="openai/synthetic-model",
messages=[{"role": "user", "content": "synthetic input"}],
api_key=self.FAKE_API_KEY,
mock_response="synthetic output",
)
)
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert response.choices[0].message.content == "synthetic output"
assert constructed.call_count == 0
assert "Skipped malformed request debug logging" not in output
assert self.FAKE_API_KEY not in output
@pytest.mark.parametrize(
"function_name", ["speech", "aspeech", "embedding", "aembedding", "completion", "acompletion"]
)
@pytest.mark.parametrize("verbose", [False, True])
def test_positional_credentials_follow_public_signatures(
self,
function_name: str,
verbose: bool,
caplog: pytest.LogCaptureFixture,
capsys: pytest.CaptureFixture[str],
monkeypatch: pytest.MonkeyPatch,
) -> None:
from litellm.utils import print_args_passed_to_litellm
function: Final = getattr(litellm, function_name)
signature_name: Final = function_name[1:] if function_name in ("aspeech", "aembedding") else function_name
signature_function: Final = getattr(litellm, signature_name)
sentinel: Final = "SYNTHETIC-POSITIONAL-KEY-ONLY"
input_value: Final = "synthetic-input" if signature_name in ("speech", "embedding") else []
bound: Final = inspect.signature(signature_function).bind_partial(
"synthetic-model", input_value, api_key=sentinel
)
bound.apply_defaults()
args: Final = bound.args
monkeypatch.setattr(litellm, "set_verbose", verbose)
monkeypatch.setattr("litellm._logging.set_verbose", verbose)
with caplog.at_level(logging.DEBUG if not verbose else logging.WARNING, logger=verbose_logger.name):
print_args_passed_to_litellm(function, args, {"max_retries": 0})
captured: Final = capsys.readouterr()
output: Final = caplog.text + captured.out + captured.err
assert f"litellm.{function_name}(" in output
assert "synthetic-model" in output
assert "max_retries=0" in output
assert "REDACTED" in output
assert sentinel not in output
assert sentinel in args
@pytest.mark.parametrize("field", ["headers", "extra_headers"])
@pytest.mark.parametrize("malformed", ["synthetic-header-value", {b"synthetic-header-value": "unused"}])
def test_malformed_headers_do_not_reach_request_line(
self,
field: str,
malformed: object,
caplog: pytest.LogCaptureFixture,
) -> None:
from litellm.utils import print_args_passed_to_litellm
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
print_args_passed_to_litellm(litellm.completion, (), {"model": "synthetic-model", field: malformed})
assert "synthetic-header-value" not in caplog.text
assert f"{field}='REDACTED'" in caplog.text
assert "model='synthetic-model'" in caplog.text
@pytest.mark.asyncio
@pytest.mark.parametrize("asynchronous", [False, True])
@pytest.mark.parametrize("positional", [False, True])
async def test_non_speech_mock_completion_preserves_result_and_context(
self,
asynchronous: bool,
positional: bool,
caplog: pytest.LogCaptureFixture,
) -> None:
function: Final = litellm.acompletion if asynchronous else litellm.completion
params: Final = {
"model": "openai/synthetic-model",
"messages": [{"role": "user", "content": "synthetic input"}],
"api_key": self.FAKE_API_KEY,
"temperature": 0.25,
"extra_headers": {"Authorization": self.FAKE_API_KEY, "X-Request-Id": "safe-correlation"},
}
bound: Final = inspect.signature(function).bind_partial(**params)
bound.apply_defaults()
args: Final = bound.args if positional else ()
kwargs: Final = bound.kwargs if positional else params
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
response: Final = (
await litellm.acompletion(*args, **kwargs, mock_response="synthetic output")
if asynchronous
else litellm.completion(*args, **kwargs, mock_response="synthetic output")
)
assert response.choices[0].message.content == "synthetic output"
assert self.FAKE_API_KEY not in caplog.text
assert "safe-correlation" in caplog.text
assert "synthetic input" in caplog.text
assert "0.25" in caplog.text
assert params["api_key"] == self.FAKE_API_KEY
assert params["extra_headers"]["Authorization"] == self.FAKE_API_KEY
def test_unidentified_varargs_are_hidden_without_losing_keyword_context(
self,
caplog: pytest.LogCaptureFixture,
) -> None:
from litellm.utils import print_args_passed_to_litellm
def opaque(*args: object, **kwargs: object) -> None:
pass
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
print_args_passed_to_litellm(opaque, (self.FAKE_API_KEY,), {"model": "synthetic-model"})
assert self.FAKE_API_KEY not in caplog.text
assert "litellm.opaque('REDACTED', model='synthetic-model')" in caplog.text
@pytest.mark.parametrize("async_prefix", [False, True])
def test_async_varargs_without_sync_signature_hide_credentials(
self,
async_prefix: bool,
caplog: pytest.LogCaptureFixture,
) -> None:
from litellm.utils import print_args_passed_to_litellm
async def opaque_async(*args: object, **kwargs: object) -> None:
pass
async def aopaque(*args: object, **kwargs: object) -> None:
pass
function: Final = aopaque if async_prefix else opaque_async
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
print_args_passed_to_litellm(function, (self.FAKE_API_KEY,), {"model": "synthetic-model"})
assert self.FAKE_API_KEY not in caplog.text
assert f"litellm.{function.__name__}('REDACTED', model='synthetic-model')" in caplog.text
@pytest.mark.parametrize("error_type", [TypeError, ValueError])
def test_unavailable_signature_hides_all_positional_values(
self,
error_type: type[Exception],
caplog: pytest.LogCaptureFixture,
) -> None:
from litellm.utils import print_args_passed_to_litellm
class OpaqueCallable:
__name__ = "opaque"
@property
def __signature__(self) -> inspect.Signature:
raise error_type("signature unavailable")
def __call__(self, *args: object, **kwargs: object) -> None:
pass
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
print_args_passed_to_litellm(
OpaqueCallable(), (self.FAKE_API_KEY, self.FAKE_API_KEY), {"model": "synthetic-model"}
)
assert self.FAKE_API_KEY not in caplog.text
assert "litellm.opaque('REDACTED', 'REDACTED', model='synthetic-model')" in caplog.text
def test_positional_only_and_surplus_arguments_are_sanitized(
self,
caplog: pytest.LogCaptureFixture,
) -> None:
from litellm.utils import print_args_passed_to_litellm
def endpoint(model: str, api_key: str, /, *, timeout: int = 10) -> None:
pass
with caplog.at_level(logging.DEBUG, logger=verbose_logger.name):
print_args_passed_to_litellm(
endpoint, ("synthetic-model", self.FAKE_API_KEY, self.FAKE_API_KEY), {"timeout": 2}
)
assert self.FAKE_API_KEY not in caplog.text
assert "litellm.endpoint('synthetic-model', 'REDACTED', 'REDACTED', timeout=2)" in caplog.text
def _verbose_request_line(self, capsys, monkeypatch, **kwargs) -> str:
monkeypatch.setattr(litellm, "set_verbose", True)
monkeypatch.setattr("litellm._logging.set_verbose", True)

144
uv.lock generated
View file

@ -5329,7 +5329,7 @@ ci = [
{ name = "psycopg2-binary", specifier = "==2.9.11" },
{ name = "pyarrow", specifier = "==23.0.1" },
{ name = "pygithub", specifier = "==2.8.1" },
{ name = "pylint", specifier = "==4.0.5" },
{ name = "pylint", specifier = "==4.0.9" },
{ name = "pytest-codspeed", specifier = "==4.3.0" },
{ name = "pytest-retry", specifier = "==1.7.0" },
{ name = "tenacity", specifier = "==8.5.0" },
@ -6111,75 +6111,77 @@ wheels = [
[[package]]
name = "msgpack"
version = "1.2.1"
version = "1.2.3"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/31/f9/c0a1c127f9049db9155afc316952ea571720dd01833ff5e4d7e8e6352dbb/msgpack-1.2.1.tar.gz", hash = "sha256:04c721c2c7448767e9e3f2520a475663d8ee0f09c31890f6d2bd70fd636a9647", size = 183960, upload-time = "2026-06-18T16:13:52.594Z" }
sdist = { url = "https://files.pythonhosted.org/packages/0a/e7/bb605a7bab2d8425a64b3fa762b39dc1bf1c7e3f11ba6fb5413d6db0ff8c/msgpack-1.2.3.tar.gz", hash = "sha256:32edb81a2b5eb7cd7c9d941b2bfbbb082fd2cd09e0e725930316af6b708db186", size = 196517, upload-time = "2026-09-29T02:33:52.276Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/5b/16/f70100614b69feb3ade7285f08c9c52d6cda0a5c03f3f5e2facd63acb211/msgpack-1.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8c7b398c56ff125feae96c2737abfec5595f1fa0aa186df60c56040b8accb95c", size = 82926, upload-time = "2026-06-18T16:12:31.531Z" },
{ url = "https://files.pythonhosted.org/packages/e4/3c/08ecd5cdfe4e2de43aec79062028ad0f7b2d9b1fea5430068c198ba570da/msgpack-1.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1548006a91aa93c5da81f3bdcebc1a0d10cea2d25969754fbe848da622b2b895", size = 82730, upload-time = "2026-06-18T16:12:32.894Z" },
{ url = "https://files.pythonhosted.org/packages/19/9f/a70c9cb1a04ecc134005149367dcfe35d167284e8f65035a1e4156ad17b5/msgpack-1.2.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1dabedcd0f23559f3596428c6589c1cd8c6eaed3a0d720795b07b0225d769203", size = 400729, upload-time = "2026-06-18T16:12:34.052Z" },
{ url = "https://files.pythonhosted.org/packages/fa/7f/5ce020168cf0439041526e95aa068c722c016aee21624e331aeabeee2e8e/msgpack-1.2.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:83efa1c898e0fc5380fc0cabbf75164c52e3b5cbb45973710d75821928380c73", size = 407625, upload-time = "2026-06-18T16:12:35.239Z" },
{ url = "https://files.pythonhosted.org/packages/79/70/fb7668ce0386819303047057aef6fc1da73b584291d9cff82b821744e2ef/msgpack-1.2.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01e2dd6c9b19d333a00282330cc8a73d38d8dabc306dc5b42cd668c3ac82e833", size = 377891, upload-time = "2026-06-18T16:12:36.684Z" },
{ url = "https://files.pythonhosted.org/packages/3d/dc/9ebe654a73c3aed2e40aa6b52e3c2a02b5f53ef0085fa235a45d5b367f87/msgpack-1.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:350cb813d0af6e65d2f7ef0d729f7ff5be5a8bce03665892f43e5883d4ecc1b8", size = 391987, upload-time = "2026-06-18T16:12:37.839Z" },
{ url = "https://files.pythonhosted.org/packages/42/eb/b67cf64218a2fa25e1c671fe1d3dbb06cbeb973e71bc4b822da079862d0b/msgpack-1.2.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ee1d9ed27d0497b848923746cf762ed2e7db24f4be7eec8e5cbe8c766aa707b7", size = 374603, upload-time = "2026-06-18T16:12:39.221Z" },
{ url = "https://files.pythonhosted.org/packages/a2/2e/9ee200cde32fd1a0101b4006202fde554c1860adfb9bf7bff31ea4c08df8/msgpack-1.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:633727297ed063441fd1cda2288865487f33ad14eeb8831afb5f0c396a62cfce", size = 405121, upload-time = "2026-06-18T16:12:40.524Z" },
{ url = "https://files.pythonhosted.org/packages/43/b6/f10117be7ca7a51e8feed699a907b8e663a8cd66e115ae6b4fb30cc7945c/msgpack-1.2.1-cp310-cp310-win32.whl", hash = "sha256:298872ecf9e61950f1c6af4ca969b859ee91783bb920ef6e6172697d0c8aad74", size = 64088, upload-time = "2026-06-18T16:12:41.762Z" },
{ url = "https://files.pythonhosted.org/packages/ba/93/89976c696fb0224662239d952c47b4d1661b34d79a332ef5584facaa8579/msgpack-1.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:2ff164c1b0bcb740b073b99e945234d0212852fa378e44a208c425379140dbeb", size = 70113, upload-time = "2026-06-18T16:12:42.78Z" },
{ url = "https://files.pythonhosted.org/packages/f4/6b/e9b1cdc042c4458801d2545ed782a95f3d6ba8e270cce8745b8603c7f748/msgpack-1.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:29a3f6e9667868429d8240dfd063ea5ffdc1321c13d783aa23827a38de0dcb22", size = 82812, upload-time = "2026-06-18T16:12:45.022Z" },
{ url = "https://files.pythonhosted.org/packages/0c/3a/dd518a1bf78ed1e9ad8afe57307c079a00eafe4b3068932a27ca1ea56b4f/msgpack-1.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:aded5bdf32609dc7987a49bbbd15a8ef096193f96dd8bbeb791de729e650acf5", size = 82739, upload-time = "2026-06-18T16:12:46.025Z" },
{ url = "https://files.pythonhosted.org/packages/70/e0/7ba9e1542bf0771a27b8b37c1316e3f95ae9d748fd765284655c476ad4ef/msgpack-1.2.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:146ee4e9ce80b365c6d4c47073da9da7bcec473e58194ceee5dd7620ace77e06", size = 414233, upload-time = "2026-06-18T16:12:47.029Z" },
{ url = "https://files.pythonhosted.org/packages/03/8d/671d81534ea0e2b0e8a121be100020da09eb78861fe3aa8f3ef7dcd3bed1/msgpack-1.2.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a28d076ca7c82b9c8728ad90b7147489449557038bed50e4241eb832395169b4", size = 423843, upload-time = "2026-06-18T16:12:48.19Z" },
{ url = "https://files.pythonhosted.org/packages/d2/b6/e5c737515ed1f166664b87601b532f58cbb73d8aa6a90b99f7c2c5037e8e/msgpack-1.2.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d31c0ac0c640f877804c67cb2bc9f4e23dc2db97e96c2e67fa27d38283b41f8", size = 390772, upload-time = "2026-06-18T16:12:49.624Z" },
{ url = "https://files.pythonhosted.org/packages/a8/46/62ed8c2e87d7021eab19921594d961ef3aa3794eec76c716dc30f3bfd433/msgpack-1.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8ff92d7feeaf5bc26c51495b69e2f99ed97ab79346fb6555f44be7dd2ac6503b", size = 409559, upload-time = "2026-06-18T16:12:50.936Z" },
{ url = "https://files.pythonhosted.org/packages/70/ff/59aa3887b860bbf43532835e192b1c388a17590d6068ae4f8b2bc74c906e/msgpack-1.2.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:779197a6513bab3c3632265e3d0f7cb3227e62510841a6f34f1eaa37efbb345e", size = 387838, upload-time = "2026-06-18T16:12:52.161Z" },
{ url = "https://files.pythonhosted.org/packages/09/11/f8563e471093420cf6478cb3271a0175d8402b82d879783d4035d2d03360/msgpack-1.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:67f6dd22fa72a93752643f07889796d62739a13415ee630169a8ce764f86cf9f", size = 421732, upload-time = "2026-06-18T16:12:53.556Z" },
{ url = "https://files.pythonhosted.org/packages/57/cf/e673683c4c6c90c1022b24c65af4b03eda72b182a1176ef6449069d66acc/msgpack-1.2.1-cp311-cp311-win32.whl", hash = "sha256:91054a783328e0ea7954b8771095705c8d2243b814743fbaadf14552c9c52c5d", size = 64091, upload-time = "2026-06-18T16:12:54.821Z" },
{ url = "https://files.pythonhosted.org/packages/3f/07/ca212739d179f9083bff2c7c08c24101c3555a334fadc2b876b18768a3ae/msgpack-1.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2eda0b7ebb1283a98d3e4492ac933c8af6aff59fd3df1c3ed024f536af4b1dc8", size = 70462, upload-time = "2026-06-18T16:12:55.898Z" },
{ url = "https://files.pythonhosted.org/packages/6d/be/6798347b425e26f35db82e69dd83c09716c856a3714e7bffc4c0860fd830/msgpack-1.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:6ee967f7c7e1df2890c671ff2ee51a28ded0efc95da3e507176dee881ce36c66", size = 65059, upload-time = "2026-06-18T16:12:57.053Z" },
{ url = "https://files.pythonhosted.org/packages/bc/dd/9e8cbd8f5582ca4b590336f2b91ee5662f6a6ca562b565abaf696a0f81ff/msgpack-1.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2ef59c659f289eddf8aa6623823f19fa2f40a4029266889eac7a2505dd210c35", size = 83531, upload-time = "2026-06-18T16:12:58.249Z" },
{ url = "https://files.pythonhosted.org/packages/50/2e/ebdb85a8da151397a2790363676b7ed7c125924fe618e4c6d8befb0cc62c/msgpack-1.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d3567748a5107cb40cdf66a275430c2f87c07777698f4bfd25c35f44d533258c", size = 82657, upload-time = "2026-06-18T16:12:59.396Z" },
{ url = "https://files.pythonhosted.org/packages/26/aa/753ad8b007b464e1d8aa0c8e650b9c5f4f725e658fc5ac8a7635c55b7f6e/msgpack-1.2.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60926b75d00c8e816ef98f3034f484a8bc64242d66839cef4cf7e503142316a0", size = 410634, upload-time = "2026-06-18T16:13:00.383Z" },
{ url = "https://files.pythonhosted.org/packages/6a/fd/6adabd4f6d5e686f97dd02ce7fce3fe4cf672cbac36b8f67ff4040e8ad8b/msgpack-1.2.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:020e881a764b20d8d7ca1a54fc01b8175519d108e3c3f194fddc200bda95951a", size = 419989, upload-time = "2026-06-18T16:13:01.776Z" },
{ url = "https://files.pythonhosted.org/packages/5a/cc/85039b7b0eb168aaad7383a23c97e291a11f08351cb45a606ce865e4e3f1/msgpack-1.2.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4202c74688ca06591f78cb18988228bd4cca2cc75d57b60008372892d2f1e6e6", size = 377544, upload-time = "2026-06-18T16:13:03.637Z" },
{ url = "https://files.pythonhosted.org/packages/ed/bf/35963899493b32030c85fc513b723ae66144ac70c11ebc52e889e16e3d99/msgpack-1.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8b267ce94efb76fbd1b3373511420074ee3187f0f7811bf394531de13294735a", size = 400842, upload-time = "2026-06-18T16:13:05.012Z" },
{ url = "https://files.pythonhosted.org/packages/a6/df/8e2ac970c8f99264cd9997d1c73df5466bc19da3301d7dc5500862a9b089/msgpack-1.2.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e4f1d0f8f98ade9634e01fb704a408f9336c0a8f1117b369f5db83dc7551d8b1", size = 374108, upload-time = "2026-06-18T16:13:06.232Z" },
{ url = "https://files.pythonhosted.org/packages/17/dd/fa8bd265110dfa51c20cb529f9e6d240a16fafe7e645004c6af2d01353ba/msgpack-1.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f02cf17a6ca1abe29b5f980644f7551f94d71f2011509b26d8625ce038f0df64", size = 414939, upload-time = "2026-06-18T16:13:07.478Z" },
{ url = "https://files.pythonhosted.org/packages/2e/b9/8377a5ad8953fc0437c70cc98d9ae29f27fe5ac5109fbec0812085865735/msgpack-1.2.1-cp312-cp312-win32.whl", hash = "sha256:0c0d9802354507bcba62af19c17918e3eb437cc25e6f50657d511b5856a77aac", size = 64504, upload-time = "2026-06-18T16:13:08.822Z" },
{ url = "https://files.pythonhosted.org/packages/57/7f/ce1e377df7e62461fefd9eb23bfb93a4a523f40a517b377b8f844d836828/msgpack-1.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:5c24aa15d5963051e1a5c62b12c50cd705992502b5ec1f3bece6046f33c9fc24", size = 71421, upload-time = "2026-06-18T16:13:09.828Z" },
{ url = "https://files.pythonhosted.org/packages/8f/32/ebfe84c9929f08f188d56c7a2fd913406a9ddad76a634697c1c43b8112e6/msgpack-1.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:4227224aaec8f7fbcbfbd4272319347b2bb4030366502600f8c45588c5187b07", size = 64775, upload-time = "2026-06-18T16:13:11.056Z" },
{ url = "https://files.pythonhosted.org/packages/b0/ac/dcddcab6f6c20ecb387ca5e980371cdb3f87ff69aeca388be97eebc4c074/msgpack-1.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0a70e3cf2804a300d921bb0940426e35f4e489a23adfb77a808892241db0a064", size = 83151, upload-time = "2026-06-18T16:13:12.173Z" },
{ url = "https://files.pythonhosted.org/packages/64/71/fbcfa83a1d6a9c6091942d1cfd070962244664b87427a9a49a6897b1b219/msgpack-1.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:491cc39455ca765fad51fb451bf2915eb2cf41192ab5801ce8d67c1d614fe056", size = 82351, upload-time = "2026-06-18T16:13:13.194Z" },
{ url = "https://files.pythonhosted.org/packages/e3/10/ddf7b06db879e8792d13934ddda09ff20bd2a583fd84c9b59aae9b0e650b/msgpack-1.2.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f310233ef7fb9c14e201c93639fe5f5260b005f56f0b29048e999c30935596cc", size = 407518, upload-time = "2026-06-18T16:13:14.233Z" },
{ url = "https://files.pythonhosted.org/packages/79/d3/36a46a8ed992b781acbc05928bd5bee3c810cb0c3563bf81a7b0c04a1a76/msgpack-1.2.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:787c9bebb5833e8f6fc8abca3c0597683d8d87f56a8842b6b89c75a5f3176e2d", size = 416405, upload-time = "2026-06-18T16:13:15.435Z" },
{ url = "https://files.pythonhosted.org/packages/f9/84/e8e9598b557c0ba6ddae901a73780a4c75ac667dddf59414b1e56a42fb34/msgpack-1.2.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dc871b997a9370d855b7394465f2f350e847a5b806dd38dcc9c989e7d87da155", size = 376257, upload-time = "2026-06-18T16:13:17.022Z" },
{ url = "https://files.pythonhosted.org/packages/40/16/738fe6d875ad7e2a9429c165322a4ec088f4f273cdfae63d96a89c467961/msgpack-1.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:85f57e960d877f2977f6430896191b04a21f8901b3b4baf2e4604329f4db5402", size = 397469, upload-time = "2026-06-18T16:13:18.287Z" },
{ url = "https://files.pythonhosted.org/packages/ca/be/6d5952df75a7f24f35833af764c3a6860780364cb3a0030beb8099e1b2b4/msgpack-1.2.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1233ee2dd0cefba127583de50ea654677277047d238303521db35def3d7b2e7c", size = 372802, upload-time = "2026-06-18T16:13:19.685Z" },
{ url = "https://files.pythonhosted.org/packages/e1/39/e2ef7dbf0473bcb8dc7c50bf782a892d67414877b63e47fc88eb189ef5e6/msgpack-1.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3dc2feb0876209d9c38aa56cb1de169bd6c4348f1aa48271f241226590993e6", size = 411273, upload-time = "2026-06-18T16:13:21.028Z" },
{ url = "https://files.pythonhosted.org/packages/ef/c5/133f4512a56e983a93445c836c9d94d88f3bc2e0980ff4b9e577bd8416ce/msgpack-1.2.1-cp313-cp313-win32.whl", hash = "sha256:6d09badf350af2be9d189184e04e64cf54ad93569ab3d96fca58bd3e84aad707", size = 64471, upload-time = "2026-06-18T16:13:22.293Z" },
{ url = "https://files.pythonhosted.org/packages/e2/98/577e10b055096a7dd40732358cabaf7180a20c79ed1dcdbb618e4b9deac7/msgpack-1.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:33f14fba63278b714efe6ad07e50ea5f03d91537aa6a1c5f1ceca4cf44013ca9", size = 71274, upload-time = "2026-06-18T16:13:23.455Z" },
{ url = "https://files.pythonhosted.org/packages/ba/ee/0c0048e7cfbef23c6a94791b8959ab28155232e7956de8a305b5ff588f05/msgpack-1.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:afc5febcd4c99effbc02b528e49d6fd0760b2b7d48c05239e345a5fa6e743d9a", size = 64795, upload-time = "2026-06-18T16:13:24.687Z" },
{ url = "https://files.pythonhosted.org/packages/77/58/cce442852c6b9e1639c7c8ac8fd9143121cb32dab0f308df4d1426a8eb9c/msgpack-1.2.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:05f340e47e7e47d2da8db9b53e1bb1d294369e9ef45a747441309f6650b8351d", size = 83610, upload-time = "2026-06-18T16:13:25.724Z" },
{ url = "https://files.pythonhosted.org/packages/60/5c/15b4c7a0182f75ffa90751958ba36a9c01cafee367d49a3edc10ed140b01/msgpack-1.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:810b916696c86ef0deb3b74588480224df4c1b071136c34183e4a2a4284d7ac7", size = 83138, upload-time = "2026-06-18T16:13:26.781Z" },
{ url = "https://files.pythonhosted.org/packages/b8/a6/99e58722feaffc5f2fbcc0c8c0d1451ab9f84097f7af87291b46af2390f4/msgpack-1.2.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ca0dacff965c47afdc3749a8469d7302a8f801d6a28758d55120d75e66ce6889", size = 406090, upload-time = "2026-06-18T16:13:28.072Z" },
{ url = "https://files.pythonhosted.org/packages/19/03/8c63e8cf52958534ef688625965ab04c269a6cadd8caef16758b380a821a/msgpack-1.2.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e2bf9280bceb5efca998435904b5d3e9fdbcc11d90dc9df30aec7973252b720", size = 412106, upload-time = "2026-06-18T16:13:29.427Z" },
{ url = "https://files.pythonhosted.org/packages/63/d2/155d9e71b40e41fd934bc0c48b9b2770f22263e1ac20aad8e29fdca7be3f/msgpack-1.2.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:aa6c4be5d1c02a42b066ca6ddb71adf36432868fdcdb6ee87e634e86e0674190", size = 374851, upload-time = "2026-06-18T16:13:30.631Z" },
{ url = "https://files.pythonhosted.org/packages/98/48/deaf2326262a8d5ea3295ce9649912ecd3f551ba7ec8e33c665d2ba583f3/msgpack-1.2.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec0e675d59150a6269ddc9139087c722292664a37d071a849c05c473350f1f2d", size = 396168, upload-time = "2026-06-18T16:13:31.977Z" },
{ url = "https://files.pythonhosted.org/packages/10/2a/b4410f906c2ec0008f1608d3ab5143afc3ad3f4e6da0fed3ea2231d0bef4/msgpack-1.2.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:dd3bfe82d53edfe4b7fc9a7ec9761e23a7a5b1dac22264505af428253c29ed24", size = 371959, upload-time = "2026-06-18T16:13:33.282Z" },
{ url = "https://files.pythonhosted.org/packages/59/86/1edc67270099a528fa2093ea60fe191233cd238e4bd30cfacf7db79fc959/msgpack-1.2.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5ad5467fc3f68b5468e06c5f788d712e9f8ffc8b0cd1bcb160c105c1ee92dae7", size = 408457, upload-time = "2026-06-18T16:13:34.567Z" },
{ url = "https://files.pythonhosted.org/packages/82/90/8b630fef07d8c5ab457b71ff2c217910c83d333c7a68472c186e87cc504a/msgpack-1.2.1-cp314-cp314-win32.whl", hash = "sha256:98b58bdb89c46190e4609bb36abe17c6d4105ad13f9c5f8f6f64d320f8ced3fb", size = 65942, upload-time = "2026-06-18T16:13:36.056Z" },
{ url = "https://files.pythonhosted.org/packages/16/f1/467b81e98b24dd3885d7b1857728797b4ffc76a7a7483af4fb321a07de3c/msgpack-1.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:74847557e28ce71bd3c438a447ca90e4b507e997ddbdef8a12a7b283b86c156b", size = 72627, upload-time = "2026-06-18T16:13:37.079Z" },
{ url = "https://files.pythonhosted.org/packages/a7/1d/5d8c4c89985feb6acefb82a09e501c60392261856d2408d20bfe4f0360b1/msgpack-1.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:b50b727bd652bdc37d950336c848ef20ec54a4cafc38dce19b1cd86ad625d0f7", size = 66908, upload-time = "2026-06-18T16:13:38.23Z" },
{ url = "https://files.pythonhosted.org/packages/1b/02/ad2afb678b4de94496cd432b581759b756a92c1192d8c767edd6b132efdc/msgpack-1.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8d00f177ca88a77c1cf848d204a38f249751650b601cb6532acc68805d8a8273", size = 86000, upload-time = "2026-06-18T16:13:39.44Z" },
{ url = "https://files.pythonhosted.org/packages/54/74/0b797484013128837f3b1cbb6cea019277c4de4e377dc512b4d9a0f92940/msgpack-1.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5bb9c386f0a329c035ddbab4b72d1028bf9627add8dda41070288563d57ed1b1", size = 86544, upload-time = "2026-06-18T16:13:40.447Z" },
{ url = "https://files.pythonhosted.org/packages/a9/b4/b774d7eb95561739907fec675582f83203cf41c597a418c2589b4bfb8e9d/msgpack-1.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20466cca18c49c7292a8984bc15d65857b171e7264bdcb5f96baf8be238791fc", size = 427661, upload-time = "2026-06-18T16:13:41.574Z" },
{ url = "https://files.pythonhosted.org/packages/b2/f9/3243191dc9937e00756c8bc1b0272fed8f23758e43df2a3b46f533e5090f/msgpack-1.2.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:196300e7e5d6e74d50f1607ab9c06c4a1484c383cd22defd727902591f7e8dde", size = 426375, upload-time = "2026-06-18T16:13:42.936Z" },
{ url = "https://files.pythonhosted.org/packages/23/c7/1693111db9944ba4ad4b67a1e788400d78a0b6af7a6523dc7e4e58f8274b/msgpack-1.2.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575957e79cd51903a4e8495a242442949641e08f1efd5197b43bebd3ea7682b4", size = 380495, upload-time = "2026-06-18T16:13:44.306Z" },
{ url = "https://files.pythonhosted.org/packages/3e/2b/92f86956a0c13e8662f7e2ad630c4eb4db07497b967589bd5245e018b2c1/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8c2ed1e48cc0f460bf3c7780e7137ff21a4e18433451916f2442c1b21036cd7d", size = 410897, upload-time = "2026-06-18T16:13:45.629Z" },
{ url = "https://files.pythonhosted.org/packages/da/ea/1479f72d200313a76fc2f823a79d1e07ed052ab7b8a0280640aa7b95de42/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5f6277e5f783c36786a145e0247fc189a03f35f84b251646e53592d2bc12b355", size = 378519, upload-time = "2026-06-18T16:13:46.998Z" },
{ url = "https://files.pythonhosted.org/packages/f5/4d/fa006060ffa1011d32bfae826fe766fe73e02982183601633b7121058ab3/msgpack-1.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9389552ecf4784886345ead0647e4edc96bee37cbab05b75540f542f766c48c", size = 419815, upload-time = "2026-06-18T16:13:48.205Z" },
{ url = "https://files.pythonhosted.org/packages/2f/e1/aab6c946570496b78e67804721f3d5e2d62a93081b9b37df77764ef56347/msgpack-1.2.1-cp314-cp314t-win32.whl", hash = "sha256:c1c79a604a2969a868a78b6ebd27a887e00c624f14f66b3038e0590cb23332d1", size = 70914, upload-time = "2026-06-18T16:13:49.385Z" },
{ url = "https://files.pythonhosted.org/packages/13/0a/e608956488a2af014cfe6e3d665e090b8ee42aa14b07f8f95b8880d66b09/msgpack-1.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f12038a35fabd52e56a3547bab42401af49a45caa6dd00b34c44de235bc93ee2", size = 77999, upload-time = "2026-06-18T16:13:50.467Z" },
{ url = "https://files.pythonhosted.org/packages/d2/8a/27e2e57055176e366a46b85d02d68e7a5bcfbdd8474c9706375d965f24d3/msgpack-1.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0adcf06ffde0777c0e1a9b771a2b1c4226ba1bbf748c8efcc02fcdeca3299107", size = 71160, upload-time = "2026-06-18T16:13:51.498Z" },
{ url = "https://files.pythonhosted.org/packages/6d/aa/5b6b09f835791045282dc5d08431db599a5f4743a69fe2f6670045a2cd85/msgpack-1.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ec0030361cc861ac699b2ef1c695b741fa145c88f8667fa3d7e3f73deeb648a3", size = 90927, upload-time = "2026-09-29T02:31:28.286Z" },
{ url = "https://files.pythonhosted.org/packages/c9/91/7b288e9133bd1ba92ca0ca4e7f2a4cfc53cf467d99d8d2f57b9939908fac/msgpack-1.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5c1efdd9181cb1b719ee46865f368a927f1c0c65d577798340b1194545b7515a", size = 89798, upload-time = "2026-09-29T02:31:30.028Z" },
{ url = "https://files.pythonhosted.org/packages/71/9b/5c3dbc450d14645dcec987970692d6ab24008cc33d2155474b1d818486f9/msgpack-1.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c309a7abae1d14ba29a8bd0ddbd704a5e469d8e9bd9c3dee0e4ff53d7ae01d56", size = 450687, upload-time = "2026-09-29T02:31:32.407Z" },
{ url = "https://files.pythonhosted.org/packages/2b/21/ea60a8fd0d9e0897fce823e9fd9bf6742567784b35c7eee8f4a18a56eb19/msgpack-1.2.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bf390259cb25a6a1cd197c65810999b811f64cd38683251538bcc5a1e41f7d3", size = 459808, upload-time = "2026-09-29T02:31:34.282Z" },
{ url = "https://files.pythonhosted.org/packages/ee/f7/42140e6afdac8e94bfedae4cfb67ee004b6ad5c4cadd024df42f759bf3b5/msgpack-1.2.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:39b6986c19e1f2dfa549d185dba6ccf1de2e4c0ba10d8cfc0048935b1c5f9109", size = 423845, upload-time = "2026-09-29T02:31:35.713Z" },
{ url = "https://files.pythonhosted.org/packages/19/7b/cd54f27b59dfbdc438a12361fbb6798b66d377a978f946bc9512598290e9/msgpack-1.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fcc6800daac4922960f6eeb7a0dda3dd4105e0bf7bce0e83ebc465a78cb7bdba", size = 445608, upload-time = "2026-09-29T02:31:37.65Z" },
{ url = "https://files.pythonhosted.org/packages/57/38/52bc0dc44cc9f7c2339b632f93d02f8badc78cfb0bb070f2a50a51945e53/msgpack-1.2.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:968583e956d0427878050b371308c5f8647088732ef3e66a117dbe1192ec91e0", size = 421721, upload-time = "2026-09-29T02:31:39.151Z" },
{ url = "https://files.pythonhosted.org/packages/89/e6/451c9a42274fb2be82d8ba8b76a5219c613e20f8de1da521d10cb758a9ef/msgpack-1.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1d6bcec3dbbdb89ca385d3a73e63ceae7b841fa0d7ca7c676f1a7bfe7fb2cdb8", size = 460430, upload-time = "2026-09-29T02:31:40.843Z" },
{ url = "https://files.pythonhosted.org/packages/57/bb/663e3100327b58caaa5fb66379e557a2717dac08bb586f22f885756bee47/msgpack-1.2.3-cp310-cp310-win32.whl", hash = "sha256:a6b63917d60d6df451f328bd6afba8565e33c4afe1f62ec4ad758b78731c827b", size = 67987, upload-time = "2026-09-29T02:31:42.157Z" },
{ url = "https://files.pythonhosted.org/packages/28/7a/a00d5d7abc5601099260e0d0af8fadc54fbfac2191315aa56eaee3641d9d/msgpack-1.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:4c0780095871ecc49a58b2ff6b1b43b25214704da67646557ca287a3f49fb2dd", size = 75572, upload-time = "2026-09-29T02:31:43.544Z" },
{ url = "https://files.pythonhosted.org/packages/2a/95/b9c651ccb9d720b2e2c8d537954dff528ab869a03bf89598145716db823c/msgpack-1.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ec90a9ae3e1169fa1171147340f0e97d941aa19fcd3b34e8339a55933ed042af", size = 90404, upload-time = "2026-09-29T02:31:44.826Z" },
{ url = "https://files.pythonhosted.org/packages/50/cd/fc9e2e367e80f1493e2ec5f610dda558b344eeede296f88976db133e8f2c/msgpack-1.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9d7e9cbb0998bbfd363fd9a09c330520d5e9cb323c05b5a1a05865d23ccf2226", size = 89683, upload-time = "2026-09-29T02:31:46.413Z" },
{ url = "https://files.pythonhosted.org/packages/19/9e/1028485c6886c1c117f777cc9b053e541eff0fedb3292dfb1da95040edb5/msgpack-1.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6707d2fa2aa1bb5424ea0b05f44ffc989b15ab41a73ff5855bff4944fec7c8ac", size = 465347, upload-time = "2026-09-29T02:31:47.934Z" },
{ url = "https://files.pythonhosted.org/packages/aa/83/800570e6a22376eb8d599920f70aead4779a63611696f567477c4e85a70f/msgpack-1.2.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:382b219de3d436de3baba0f4b0c6d4336e8f5858d0eb047918b13b69a71c6c55", size = 477820, upload-time = "2026-09-29T02:31:49.479Z" },
{ url = "https://files.pythonhosted.org/packages/ab/ff/817e4a2052f848d3fb67726908d6e4e7c19f68ee7c19553a82ce7b0ed415/msgpack-1.2.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:186e6c602b8a9968b8e864c67d622a69279f7d1e55ae25f40e3bff7e815b2b62", size = 436656, upload-time = "2026-09-29T02:31:51.18Z" },
{ url = "https://files.pythonhosted.org/packages/3d/42/040cc55dde6a7d92057baac8d1fc9cfb9f4fd4162900e2ec16dc33917a7d/msgpack-1.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9276ba88891338f2617044429dfd080ae008c9868a25f6f1a7d004a35dc9ac0a", size = 460939, upload-time = "2026-09-29T02:31:53.026Z" },
{ url = "https://files.pythonhosted.org/packages/09/93/4dc007bdef930eed247346773bc0189b710078961d3218d5ee7ba59f322c/msgpack-1.2.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:c942c21a93f36b3a69e828c8945bb72c94dc2ffe488a2086950c812f3edf046c", size = 433608, upload-time = "2026-09-29T02:31:54.981Z" },
{ url = "https://files.pythonhosted.org/packages/c0/97/a1b944046f283ec89445cb2a982c42233b5b07cc630f9be739f4f1d469a3/msgpack-1.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:18a6ed513023001b28dcd3ba54966f6bb90a38274ba8d2640464bcab3a1b81d4", size = 477373, upload-time = "2026-09-29T02:31:56.713Z" },
{ url = "https://files.pythonhosted.org/packages/59/79/ab411d0d172743732ab2503f4c32a22dd1a7d1436a6feecbb160e4b6376a/msgpack-1.2.3-cp311-cp311-win32.whl", hash = "sha256:d0238cd05dec9ffbe0de1071df685ba63e30a36ac155285b1a094e727c38cbe9", size = 67514, upload-time = "2026-09-29T02:31:58.267Z" },
{ url = "https://files.pythonhosted.org/packages/63/8d/6f0cb2b84e484e96278455c26870196d025bb0cec312b226a663f1fa9000/msgpack-1.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:30e1522e4173230dca4d9ad896f038f73c0da6c1edd42f4dbad88ac583cf5d46", size = 75850, upload-time = "2026-09-29T02:31:59.449Z" },
{ url = "https://files.pythonhosted.org/packages/aa/25/f99e13a2c1d3f5a1dcaa5aab27f474e8c4358188bbc68ad79fecb0d1aefe/msgpack-1.2.3-cp311-cp311-win_arm64.whl", hash = "sha256:8ca67f77938ea6a3663aa9bd22b3e031f6da84d665be850abab910ee90728dfd", size = 72338, upload-time = "2026-09-29T02:32:00.885Z" },
{ url = "https://files.pythonhosted.org/packages/af/12/4d7c6d6203416d9fbf0f59ebaa805e70fb929b93a41b611bc821ec5964a0/msgpack-1.2.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:89c930aece4e972b208ba589c8410b4167b05e411a5ea2cb25fd96f8bc47ee43", size = 91577, upload-time = "2026-09-29T02:32:02.141Z" },
{ url = "https://files.pythonhosted.org/packages/eb/c7/8576ad39f4ca42ddad26f68eb8621d2d0a60501193d480f504bd9d7f36c4/msgpack-1.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:905a189853d6bdb204c7ae5f4ab77fb857448abfff574d3d93c62e2815b24b4f", size = 90027, upload-time = "2026-09-29T02:32:03.508Z" },
{ url = "https://files.pythonhosted.org/packages/0a/3a/aa9c580aea1314529a0f3562461479780b0d254b064f0880956bfbcc74a8/msgpack-1.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7b3d0018746b5997dd6b14a1870b07cc4c327d9101145d94a1fc264a51a06", size = 460343, upload-time = "2026-09-29T02:32:04.906Z" },
{ url = "https://files.pythonhosted.org/packages/3a/cf/9c2e4d6c179529d5bf4a64cff76fa581486569e9fbdd35bd98f51cb624bf/msgpack-1.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede33b2892ceb976283e009ad12fa1834cfdf1f9c43ee9c97849fc588d00a618", size = 472998, upload-time = "2026-09-29T02:32:06.69Z" },
{ url = "https://files.pythonhosted.org/packages/7b/41/915c81fe6df2d3cbdb0dece4f1a5cd313e1cd2abd9f501d0f50c0582517e/msgpack-1.2.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:666ef5601ab0e6e345e47febc96aa81143cc932201543480cbb9499164f05ffb", size = 423216, upload-time = "2026-09-29T02:32:08.739Z" },
{ url = "https://files.pythonhosted.org/packages/a2/e7/7dda8b1039abfd9bba4c5068172c67135c9e33089f503512db9226f23c24/msgpack-1.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:87cf2ef05ff2f2493ba29fcdaef27e960ca64dacfd13460ae29e6f92e0ed05bb", size = 451218, upload-time = "2026-09-29T02:32:10.517Z" },
{ url = "https://files.pythonhosted.org/packages/16/5b/ce995c1ed4a0522b7f2d034bc2034fd63005f240b945961b70fb56fbaf3d/msgpack-1.2.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b774ff994d844e541439ac5d2d49a14def4104830c3465e9394c153f86200ffb", size = 422453, upload-time = "2026-09-29T02:32:11.956Z" },
{ url = "https://files.pythonhosted.org/packages/d2/3f/ce191fb87e2650d0166b34c437e499ee4a7f9db9c1eb164f41725eb6160e/msgpack-1.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eaf7e82249837e3aa97297b34a0bb9ff562027381631e057cea6e1367f10b438", size = 469003, upload-time = "2026-09-29T02:32:13.663Z" },
{ url = "https://files.pythonhosted.org/packages/42/35/539123407fe200fb16609c835675496fbeb6017ace9fc93909f0613223ae/msgpack-1.2.3-cp312-cp312-win32.whl", hash = "sha256:7c047250096f9fc19dba26e3d1639b5e7a84114003605c94def667149a70ced1", size = 68303, upload-time = "2026-09-29T02:32:15.02Z" },
{ url = "https://files.pythonhosted.org/packages/6f/4c/331b45f9b86fbda6b9e103244d189068e51f726d8c40021ed66e1f2c415e/msgpack-1.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:3ec409b0d6aa8e9eec6eaf881b893caa215dbe68c5319ca96e8a271d81bb111d", size = 76744, upload-time = "2026-09-29T02:32:16.344Z" },
{ url = "https://files.pythonhosted.org/packages/13/9f/fb572dc42b9fac06c7ea848aaee6e140d84469743bd1402bc07089fc4566/msgpack-1.2.3-cp312-cp312-win_arm64.whl", hash = "sha256:59612b4ed48a04cf024584218e813562f3b30a3bafa5f55abe300b15da314751", size = 71580, upload-time = "2026-09-29T02:32:17.617Z" },
{ url = "https://files.pythonhosted.org/packages/1f/8b/3824d65e912e925d09ce30d9130fa9970d6d2855d7888b13639a6604967f/msgpack-1.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:21bfa4d2aa0b04c1806ef778a1199e9e53ea2441bcbf284420a32083896320b8", size = 91728, upload-time = "2026-09-29T02:32:18.949Z" },
{ url = "https://files.pythonhosted.org/packages/05/e6/df7f2c9ebb94760113debbcea2bd3afe5fdab88a4f7bec1b618755517460/msgpack-1.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:db84203b13aecc222f465061397fdd5b53b7ae73d2c95ffc1c8dc5be0153a709", size = 89955, upload-time = "2026-09-29T02:32:20.224Z" },
{ url = "https://files.pythonhosted.org/packages/08/6a/e5fc57136e8bacccb2b39627dea2cd546540a06181e22fe6db90e15b3ae4/msgpack-1.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e0d7950ca3c1bbae291d0552dd3bb2792fc680629c4c0d44e47e5bab969f3ca", size = 454930, upload-time = "2026-09-29T02:32:21.771Z" },
{ url = "https://files.pythonhosted.org/packages/b0/30/c394d37898db9212d1693456cdf363c7e1a097d0b63e10664007f3df3ec1/msgpack-1.2.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:07c9733089d1b176c3dd2f7fa268452f9d5d784d076473499d754a58e8d1fbbb", size = 466866, upload-time = "2026-09-29T02:32:23.742Z" },
{ url = "https://files.pythonhosted.org/packages/4a/c8/1e4ddf6f6b829b3ee6c530c79dfae89cb609d2b0eedb5e0ae716851c52d1/msgpack-1.2.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f24a43b3560e20f825b807fe1e874bd73d53abaf8bbdcf258a6eb152cddbc1f5", size = 418715, upload-time = "2026-09-29T02:32:25.262Z" },
{ url = "https://files.pythonhosted.org/packages/11/a5/f460ba6d7a12d4301002f3efbb8f841e8bdc9c5fc98d771689677a352885/msgpack-1.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6576f348ed6cc4f31db6fd915a8e94245f042f50eae08d48732425e70638ea37", size = 446489, upload-time = "2026-09-29T02:32:26.988Z" },
{ url = "https://files.pythonhosted.org/packages/49/23/adface88db909bed321c85dd673655152d4a514c67e1f0800eb51c777d07/msgpack-1.2.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:cd5a9f9f86a52c24713679aa2631956835f3842512964ff93f736ff76f1f530d", size = 416998, upload-time = "2026-09-29T02:32:28.606Z" },
{ url = "https://files.pythonhosted.org/packages/36/00/5bb3a239ccfc3763c4d0fa49b13b1b7010b00182c499ab3c1fecfe6294bc/msgpack-1.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f9ddd28d3e9bbc602a9dced1591882c7fb9ab776eef8837da2c326fde19e2853", size = 463288, upload-time = "2026-09-29T02:32:30.375Z" },
{ url = "https://files.pythonhosted.org/packages/29/8c/456df77f00d701df9d6980ffb80291bce6e4e2e112e25a4dfae216f0715a/msgpack-1.2.3-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:62cc1a4ef0e553bac32c8342e1f04834aca7de276b92744eb7307db77759b890", size = 53347, upload-time = "2026-09-29T02:32:31.867Z" },
{ url = "https://files.pythonhosted.org/packages/9d/22/ce780be666f89b77cdb855daa9ec62e87bb7f69e9f403e4a5d83a2b2208f/msgpack-1.2.3-cp313-cp313-win32.whl", hash = "sha256:d2f9c4f85e47a44d26d5baf3b041eef23436e224d44eed273f01bd8a12048d9f", size = 68258, upload-time = "2026-09-29T02:32:33.163Z" },
{ url = "https://files.pythonhosted.org/packages/51/06/c3def9bc4db283103c5901b302ee2a4305cb1e69729244f94d9bd8f8e8e7/msgpack-1.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:bb89b5dc30469c84bbf8684826eb851d82412ca95690e111b9ac5e8fb343961a", size = 76569, upload-time = "2026-09-29T02:32:34.412Z" },
{ url = "https://files.pythonhosted.org/packages/12/9f/cef344073858b80adb92d6ea342e20b0eae7a8f6fe70281b69cf03707270/msgpack-1.2.3-cp313-cp313-win_arm64.whl", hash = "sha256:471e12a6a42498a31490c206e0069e343b6a7c35db540be73a879eb06f5be047", size = 71530, upload-time = "2026-09-29T02:32:35.892Z" },
{ url = "https://files.pythonhosted.org/packages/3f/8e/f777f74e38731c428857933c8011596f2d2f3160c821152f23b6ffba862f/msgpack-1.2.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3a31905206722103a84c1f72633fe30692cff6732c9d262e09a27dbc468797c8", size = 92042, upload-time = "2026-09-29T02:32:37.464Z" },
{ url = "https://files.pythonhosted.org/packages/a0/71/551608543ee5d590f7e8d522267665d6d9946866ad2a2a70a770f7c70793/msgpack-1.2.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3372475211a9ce1a23acefe512cb3e121d18c95dc74ed56cb1819ef40836ebf4", size = 90578, upload-time = "2026-09-29T02:32:38.883Z" },
{ url = "https://files.pythonhosted.org/packages/ea/11/6d78ce5a9a58bf9ba7b1b6a8f649173b030e6770c8019cf330b91825ee5d/msgpack-1.2.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9324c54995641c3d1f92a9d55093c8cde0ffa2fbc87a467a688ef60428393220", size = 454352, upload-time = "2026-09-29T02:32:40.34Z" },
{ url = "https://files.pythonhosted.org/packages/3d/08/feb9a196269ba7809f44f9117d9e4a601c41c313f6144fd0c337293a5488/msgpack-1.2.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d8ef3a66e4b52d2d7fdd90df2984670124b2ff7546d76bb25dcf68ef47f7df58", size = 462562, upload-time = "2026-09-29T02:32:42.176Z" },
{ url = "https://files.pythonhosted.org/packages/f5/77/3a674f366def24140b103d1ffd4fd27b3d912a13e47da67422afa16bebb3/msgpack-1.2.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:902f3490db0e07a7d40b48536a85c9b28fbf1397e7e1658a45a55f958e303620", size = 418134, upload-time = "2026-09-29T02:32:43.693Z" },
{ url = "https://files.pythonhosted.org/packages/48/82/944e71f280577490d99a3951cbce21aa4cbe04e7ab42cb373fd668af883c/msgpack-1.2.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e51eca14fbb65c4e0a5a9657346962bd3dca78c08e04e3d4dee70ef48687d30", size = 445937, upload-time = "2026-09-29T02:32:45.739Z" },
{ url = "https://files.pythonhosted.org/packages/b1/ec/feddd629c4a3edf1395313680450c525086cceab56dec0d4de9da9ccb618/msgpack-1.2.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f42f146752eedb6765f07dcc04d72dab0a25779ec8d4a88c0085263ce114f22c", size = 416450, upload-time = "2026-09-29T02:32:47.558Z" },
{ url = "https://files.pythonhosted.org/packages/e4/59/263a10f8c4613ba0713f48cbda7695ac8dd6d6fab2fcbc9168f03f23a94d/msgpack-1.2.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0ed5823c4efc20fe87d3530665f40ec18a002be003114814c21235cc8d256207", size = 459546, upload-time = "2026-09-29T02:32:49.145Z" },
{ url = "https://files.pythonhosted.org/packages/1e/21/addcfa1e583cfc8a22fbdc57526621b5decd7ad676ae12e9150b7be1be5d/msgpack-1.2.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:2487453ca1b6104442c6442f9a1a8fee1fe8f428a70d99d4cba799108b304150", size = 53462, upload-time = "2026-09-29T02:32:50.708Z" },
{ url = "https://files.pythonhosted.org/packages/8d/2c/3cb5c8524a1335ee27ca952c7ab78d375a16fea8e18ae3767ba0c880416c/msgpack-1.2.3-cp314-cp314-win32.whl", hash = "sha256:6df430419f2338cb71e4a34d6e64f83c88ccd321f91f40ba4513400b36d864ec", size = 70294, upload-time = "2026-09-29T02:32:52.037Z" },
{ url = "https://files.pythonhosted.org/packages/23/f9/9172ff3cdb85d160ad06df5e2708a5fce7682982a5eee8d31869b9f69d2e/msgpack-1.2.3-cp314-cp314-win_amd64.whl", hash = "sha256:84a6616d396ec1bc18a1e83e67c96a393ec35dfe5e17434a5be7b9aa0fe988ab", size = 77778, upload-time = "2026-09-29T02:32:53.429Z" },
{ url = "https://files.pythonhosted.org/packages/04/e8/b4c23178bcf605ae17cec48a75530dd69d49b0a5a6f5f4df5c47d59f746e/msgpack-1.2.3-cp314-cp314-win_arm64.whl", hash = "sha256:7a003b02c6ee2eea6dfe0bb08818631e3597e69f0131f2a8250488a1cc553290", size = 73794, upload-time = "2026-09-29T02:32:54.763Z" },
{ url = "https://files.pythonhosted.org/packages/66/b1/92704be352c4f428b7e0a0e0fb210cb1aa2b1c42c102b8dc22d34b82fac0/msgpack-1.2.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ccea05b5542f6d283fef3f0a8e93a7f0be90af0ddeeef84c25c0216ba76dcae1", size = 93721, upload-time = "2026-09-29T02:32:56.342Z" },
{ url = "https://files.pythonhosted.org/packages/49/78/9c91f1e86cadcbc100b3780fd429c3715648704032a612e77a00646ebe79/msgpack-1.2.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b1631e12fe572e181cd77e831f69335d6cd5278eac22e3db3f33cf264ac2ac18", size = 94256, upload-time = "2026-09-29T02:32:58.056Z" },
{ url = "https://files.pythonhosted.org/packages/91/4d/270f9725921ae88a29d37a774a77ac24f0ef1411fc960a63f5a4665e81b4/msgpack-1.2.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e54394b7dbe2e12ab032d9d21feef7bb61a90a150a2623633ba3781ba69dcb1f", size = 471673, upload-time = "2026-09-29T02:32:59.886Z" },
{ url = "https://files.pythonhosted.org/packages/48/b8/eaa8d930f72dc1d1dd79511dc2ccf965922b059f2f0ed3b30aebac8c4b11/msgpack-1.2.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63bb7448a1e9111319ae2430c09a5596140c160422830d6271bc75730ff2ff9a", size = 466257, upload-time = "2026-09-29T02:33:01.517Z" },
{ url = "https://files.pythonhosted.org/packages/5b/5a/97adc805037bc7e24c4e2f711bbcd3b28be8ec9aea3e778f18208cfbdb46/msgpack-1.2.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:382bc88fe90f29f5ac8a0b65c7046ff255356f2f2f3186c30e370215736fa1dc", size = 418484, upload-time = "2026-09-29T02:33:03.402Z" },
{ url = "https://files.pythonhosted.org/packages/0d/7e/1c53302606fe436ab48ba539ebafafe4a6a9efe12c4f04dc7eb36912d93e/msgpack-1.2.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c77e27790ad72989db783d5303825fba0b71550f00a490efba35cde7dc4b719f", size = 454064, upload-time = "2026-09-29T02:33:04.977Z" },
{ url = "https://files.pythonhosted.org/packages/00/2d/9ee0170f638907b396c15c6cd26b3e54f869159efc6206683acfd8f696e1/msgpack-1.2.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:700bc0fc9e968a292b9137ee70e7a012f7e115bf0107ce45e3a88202788dfc1e", size = 417901, upload-time = "2026-09-29T02:33:06.489Z" },
{ url = "https://files.pythonhosted.org/packages/cc/d2/905c84490a75cd15a27065407cd085d201f7d392e1e0411f49f03fd31ade/msgpack-1.2.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5bd5f91ea75c45cafcc5433ba8fae59b708b736ec178d2441c40c499e9e079db", size = 459896, upload-time = "2026-09-29T02:33:08.361Z" },
{ url = "https://files.pythonhosted.org/packages/37/cd/4ce5809b9ab3b114d7cca64863e436820fa1614b49d55ccb93d49824ac2d/msgpack-1.2.3-cp314-cp314t-win32.whl", hash = "sha256:7995a7c6a62a1d6e7df211b4a16de513bd99fd053525050a319f80f44fb8015e", size = 75983, upload-time = "2026-09-29T02:33:10.023Z" },
{ url = "https://files.pythonhosted.org/packages/8a/31/853bb580744c24be0dbd8b090c3e6987dce466a1fc840fe50c0ac2ef9044/msgpack-1.2.3-cp314-cp314t-win_amd64.whl", hash = "sha256:bfe7d5b62cbe7aa664f0b3e2c49077f10fcdd06183d3014f8271ff3c5edbfbf9", size = 83757, upload-time = "2026-09-29T02:33:11.441Z" },
{ url = "https://files.pythonhosted.org/packages/0d/49/9f1b2ee484414eef9e21ee2b2b23b482bb71433ab9bac1da03cbda15ebf5/msgpack-1.2.3-cp314-cp314t-win_arm64.whl", hash = "sha256:1f585407f740a9eac04a3bb82c61d68a0ea78f90e29e670bfb086b9ce3a518dd", size = 78128, upload-time = "2026-09-29T02:33:13.063Z" },
]
[[package]]
@ -8743,7 +8745,7 @@ crypto = [
[[package]]
name = "pylint"
version = "4.0.5"
version = "4.0.9"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "astroid" },
@ -8755,9 +8757,9 @@ dependencies = [
{ name = "tomli", marker = "python_full_version < '3.11'" },
{ name = "tomlkit" },
]
sdist = { url = "https://files.pythonhosted.org/packages/e4/b6/74d9a8a68b8067efce8d07707fe6a236324ee1e7808d2eb3646ec8517c7d/pylint-4.0.5.tar.gz", hash = "sha256:8cd6a618df75deb013bd7eb98327a95f02a6fb839205a6bbf5456ef96afb317c", size = 1572474, upload-time = "2026-02-20T09:07:33.621Z" }
sdist = { url = "https://files.pythonhosted.org/packages/e0/5e/d5ec2c861010cf8577a3e5baaf2405fdf1004f1657d9245c4efb006c1dfd/pylint-4.0.9.tar.gz", hash = "sha256:6f1305780229ae720e89b8aff2b3ff857cbb268fbab98c8b586960267667ad34", size = 1604187, upload-time = "2026-09-23T15:26:43.144Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/d5/6f/9ac2548e290764781f9e7e2aaf0685b086379dabfb29ca38536985471eaf/pylint-4.0.5-py3-none-any.whl", hash = "sha256:00f51c9b14a3b3ae08cff6b2cdd43f28165c78b165b628692e428fb1f8dc2cf2", size = 536694, upload-time = "2026-02-20T09:07:31.028Z" },
{ url = "https://files.pythonhosted.org/packages/66/46/12e94ae1f9db89152223bdb17920b12c79e94ac51e19dce1da9fb63627b0/pylint-4.0.9-py3-none-any.whl", hash = "sha256:c4ba5bbaf1e70ecf05f08cd7d6091ea04824b79a2b2d9f5b10dc25fc34cb1124", size = 542068, upload-time = "2026-09-23T15:26:41.626Z" },
]
[[package]]

View file

@ -2920,9 +2920,9 @@
}
},
"node_modules/qs": {
"version": "6.16.0",
"resolved": "https://registry.npmjs.org/qs/-/qs-6.16.0.tgz",
"integrity": "sha512-h6fhOIaRrID2CbEY2fqs+7t+UXZo+MLAnU5gRIq85uFtdiUPCdsApMlHhXogKVM4HM2DVbIjGNTTYH2OcmP1vA==",
"version": "6.16.1",
"resolved": "https://registry.npmjs.org/qs/-/qs-6.16.1.tgz",
"integrity": "sha512-5Px6J7rfHBAGUhNQ3es4YzcOdBBw0SDcVtThJml4RdnKw4tKs2epA0kPZ+K8X+WiHktT93RHVcQ/3ym5aTCgtg==",
"dev": true,
"license": "BSD-3-Clause",
"dependencies": {