diff --git a/.github/workflows/deepseek-python-tests.yml b/.github/workflows/deepseek-python-tests.yml index c0670631d..825045c56 100644 --- a/.github/workflows/deepseek-python-tests.yml +++ b/.github/workflows/deepseek-python-tests.yml @@ -25,7 +25,7 @@ jobs: - {python: '3.10', openai: '1.0.0', core: source, shared: false} - {python: '3.10', openai: '1.69.0', core: source, shared: true} - {python: '3.12', openai: '3.42.1', core: source, shared: true} - - {python: '3.12', openai: '3.42.1', core: '1.2.2', shared: true} + - {python: '3.12', openai: '3.42.1', core: wheel, shared: true} steps: - uses: actions/checkout@v4 with: @@ -44,7 +44,11 @@ jobs: if [ "$CORE_VERSION" = source ]; then "$PYTHON" -m pip install -e python else - "$PYTHON" -m pip install "fi-instrumentation-otel==$CORE_VERSION" + # Validate the installed candidate required by traceAI-openai; + # the previous published core is now below its dependency floor. + "$PYTHON" -m pip install build + "$PYTHON" -m build --wheel python + "$PYTHON" -m pip install python/dist/*.whl fi "$PYTHON" -m pip install -e python/frameworks/deepseek "openai==$SDK_VERSION" 'httpx==0.27.2' pytest pytest-asyncio if [ "$SHARED" = true ]; then @@ -56,7 +60,8 @@ jobs: FI_BASE_URL: http://127.0.0.1:9 FI_GRPC_URL: http://127.0.0.1:9 run: | - sudo -E unshare --net bash -euo pipefail -c ' + # ubuntu-26.04 sudo ignores -E; pass exactly the variables the tests need. + sudo --preserve-env=RUNNER_TEMP,SHARED,FI_BASE_URL,FI_GRPC_URL unshare --net bash -euo pipefail -c ' ip link set lo up PYTHON="$RUNNER_TEMP/deepseek-venv/bin/python" "$PYTHON" -I -m pytest -q --import-mode=importlib python/frameworks/openai/tests/test_deepseek_route.py diff --git a/.github/workflows/ollama-provider-tests.yml b/.github/workflows/ollama-provider-tests.yml index 348445463..8b64d22c3 100644 --- a/.github/workflows/ollama-provider-tests.yml +++ b/.github/workflows/ollama-provider-tests.yml @@ -30,7 +30,7 @@ jobs: strategy: fail-fast: false matrix: - openai: ['1.69.0', '3.42.0'] + openai: ['1.69.0', '3.45.0'] steps: - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 with: @@ -53,6 +53,7 @@ jobs: ip link set lo up "$1" -m pytest "$2/python/frameworks/openai/tests/test_ollama_provider.py" \ "$2/python/frameworks/openai/tests/test_vllm_migration.py" \ + "$2/python/frameworks/openai/tests/test_granular_privacy.py" \ -q -o addopts="" -p no:cacheprovider --disable-socket \ --allow-hosts=127.0.0.1 --allow-unix-socket "$1" -m pytest "$2/python/frameworks/vllm/tests" \ diff --git a/.github/workflows/openai-sdk-contracts.yml b/.github/workflows/openai-sdk-contracts.yml index 810c85bfb..a58934f90 100644 --- a/.github/workflows/openai-sdk-contracts.yml +++ b/.github/workflows/openai-sdk-contracts.yml @@ -22,7 +22,7 @@ jobs: strategy: fail-fast: false matrix: - sdk: ['4.0.0', '5.23.2', '6.0.0', '7.0.0', '7.47.0'] + sdk: ['4.0.0', '5.23.2', '6.0.0', '7.0.0', '7.47.0', 'latest'] defaults: run: shell: bash @@ -92,7 +92,8 @@ jobs: packages/traceai_openai/test/reviewRegressions.cjs \ packages/traceai_openai/test/reviewRoundTwo.cjs \ packages/traceai_openai/test/reviewRoundThree.cjs \ - packages/traceai_openai/test/choiceIndexes.cjs + packages/traceai_openai/test/choiceIndexes.cjs \ + packages/traceai_openai/test/mixedImports.cjs - name: Typecheck current SDK request contracts if: matrix.sdk == '7.47.0' env: diff --git a/.github/workflows/parallel-python-tests.yml b/.github/workflows/parallel-python-tests.yml index 553945dd8..29be5b9ee 100644 --- a/.github/workflows/parallel-python-tests.yml +++ b/.github/workflows/parallel-python-tests.yml @@ -57,12 +57,13 @@ jobs: run: | python -m venv .parallel-test-venv .parallel-test-venv/bin/pip install build + .parallel-test-venv/bin/python -m build "--$DISTRIBUTION" python .parallel-test-venv/bin/python -m build "--$DISTRIBUTION" python/frameworks/parallel .parallel-test-venv/bin/python -m build "--$DISTRIBUTION" python/frameworks/openai if [ "$DISTRIBUTION" = wheel ]; then - packages=(python/frameworks/{parallel,openai}/dist/*.whl) + packages=(python/dist/*.whl python/frameworks/{parallel,openai}/dist/*.whl) else - packages=(python/frameworks/{parallel,openai}/dist/*.tar.gz) + packages=(python/dist/*.tar.gz python/frameworks/{parallel,openai}/dist/*.tar.gz) fi .parallel-test-venv/bin/pip install "${packages[@]}" \ "parallel-web==$PARALLEL_VERSION" "openai==$OPENAI_VERSION" pytest pytest-asyncio diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 1b7c7f4a3..e873a1851 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -126,7 +126,7 @@ "go/lambda": "0.1.0", "go/openai": "0.1.0", "csharp/src/FIInstrumentation": "1.0.0", - "python": "1.2.2", + "python": "1.2.3", "typescript/packages/traceai_elevenlabs": "0.1.0", "go/bedrock": "0.1.0", "typescript/packages/traceai_huggingface_transformers": "0.1.0", diff --git a/python/fi_instrumentation/instrumentation/_chat_input.py b/python/fi_instrumentation/instrumentation/_chat_input.py new file mode 100644 index 000000000..24f65c2f5 --- /dev/null +++ b/python/fi_instrumentation/instrumentation/_chat_input.py @@ -0,0 +1,241 @@ +"""A narrow, core-masked representation of chat input, not a trusted JSON marker. + +Only exact built-in containers/scalars are inspected. No serializers, properties, +iterators or Mapping protocols are invoked. Unknown fields are omitted; malformed +known fields fail closed. The caller's objects are never modified. Validation and +policy run on EVERY use (including objects forged without calling __init__). +""" + +import json +import math +from typing import TYPE_CHECKING, Any, Optional + +from .pii_redaction import redact_pii_in_string + +if TYPE_CHECKING: + from .config import TraceConfig + +_REDACTED = "__REDACTED__" +_ROLES = frozenset({"system", "developer", "user", "assistant", "tool", "function"}) +_NUMBERS = frozenset({ + "frequency_penalty", "presence_penalty", "max_completion_tokens", "max_tokens", + "temperature", "top_p", "top_logprobs", "n", "seed", +}) +_BOOLEANS = frozenset({"logprobs", "parallel_tool_calls", "store"}) +_TEXT = frozenset({"stop", "user"}) +# These fields have no modality boundary. Under a granular policy they are +# redacted, not recursively searched for strings that merely look like images. +_OPAQUE = frozenset({ + "audio", "function_call", "functions", "logit_bias", "modalities", + "prediction", "reasoning_effort", "response_format", "service_tier", + "stream_options", "tool_choice", "tools", +}) + + +def _object(value: Any) -> bool: + return type(value) is dict and all(type(key) is str for key in value) + + +def _passive(value: Any, budget: list, depth: int = 0) -> Any: + """Bounded copy; reject active subclasses, cycles and non-JSON values.""" + budget[0] -= 1 + if budget[0] < 0 or depth > 32: + raise ValueError("chat input exceeds copy limits") + kind = type(value) + if value is None or kind is str or kind is bool or kind is int: + return value + if kind is float and math.isfinite(value): + return value + if kind is list or kind is tuple: + return [_passive(item, budget, depth + 1) for item in value] + if _object(value): + return {key: _passive(item, budget, depth + 1) for key, item in value.items()} + raise ValueError("chat input must contain passive JSON values") + + +def _content(value: Any, config: "TraceConfig") -> Any: + if value is None: + return None + if type(value) is str: + return _REDACTED if config.hide_input_text else value + if type(value) is not list: + raise ValueError("unsupported chat content") + result = [] + for part in value: + if not _object(part) or type(part.get("type")) is not str: + raise ValueError("untyped chat content") + kind = part["type"] + if kind in ("text", "refusal"): + if type(part.get(kind)) is not str: + raise ValueError("invalid text content") + result.append({"type": kind, kind: _REDACTED if config.hide_input_text else part[kind]}) + elif kind == "image_url": + image = part.get("image_url") + if type(image) is str: + url, detail = image, None + elif _object(image): + url, detail = image.get("url"), image.get("detail") + else: + raise ValueError("invalid image content") + if type(url) is not str: + raise ValueError("invalid image reference") + prefix = url[:11].lower() + if not prefix.startswith(("https://", "http://", "data:image/")): + raise ValueError("invalid image reference") + if detail is not None and (type(detail) is not str or detail not in ("auto", "low", "high")): + raise ValueError("invalid image detail") + # Data URL markers are ASCII case-insensitive (";BASE64," is valid). + hidden = config.hide_input_images or ( + prefix == "data:image/" and "base64" in url.lower() + and len(url) > config.base64_image_max_length + ) + if hidden: + result.append({"type": kind, "image_url": _REDACTED}) + elif type(image) is str: + result.append({"type": kind, "image_url": url}) + else: + reference = {"url": url} + if detail is not None: + reference["detail"] = detail + result.append({"type": kind, "image_url": reference}) + else: + # Never trust a caller-supplied modality label we do not understand. + result.append(_REDACTED) + return result + + +def _parameters(payload: dict, config: "TraceConfig", budget: list) -> dict: + result = {} + if config.hide_inputs or config.hide_llm_invocation_parameters: + return result + for key in (_NUMBERS | _BOOLEANS | _TEXT | _OPAQUE) & payload.keys(): + value = payload[key] + if value is None: + continue + if key in _NUMBERS: + if (type(value) is not int and type(value) is not float) or (type(value) is float and not math.isfinite(value)): + raise ValueError("invalid numeric parameter") + result[key] = value + elif key in _BOOLEANS: + if type(value) is not bool: + raise ValueError("invalid boolean parameter") + result[key] = value + elif key in _TEXT: + if config.hide_input_text: + result[key] = _REDACTED + elif type(value) is str: + result[key] = value + elif type(value) is list: + # Check the shared allowance before ANY scan, iteration or copy. + # The container and every string leaf each consume one node. + if len(value) + 1 > budget[0]: + raise ValueError("chat input exceeds copy limits") + copied = _passive(value, budget) + if not all(type(item) is str for item in copied): + raise ValueError("invalid text parameter") + result[key] = copied + else: + raise ValueError("invalid text parameter") + else: + result[key] = (_REDACTED if config.hide_input_messages or config.hide_input_text or config.hide_input_images + else _passive(value, budget)) + return result + + +def _redact_validated_leaves(value: Any) -> Any: + """Scan only the validated, detached built-ins, before JSON/str escaping.""" + if type(value) is str: + return redact_pii_in_string(value) + if type(value) is list: + return [_redact_validated_leaves(item) for item in value] + if type(value) is dict: + # Keys (e.g. JSON-schema property names) are escaped by json.dumps too. + return {redact_pii_in_string(key): _redact_validated_leaves(item) for key, item in value.items()} + return value + + +class ChatInput: + """Unserialized chat request for FiSpan.set_attribute's input keys only. + + Import ChatInput from fi_instrumentation.instrumentation.config. + Use ``span.set_attribute("input.value", ChatInput(request))`` (or + ``raw.input``). Creation-time sampler results remain opaque and fail closed; + this type does not let a sampler mark returned strings as trusted. + + Core validates model/messages and allowlisted chat request parameters before + serializing. This is NOT an assertion that input was sanitized by a caller. + Opaque strings and lazy values passed to TraceConfig.mask retain their old + fail-closed behavior. Outputs and arbitrary attribute aliases are unsupported. + """ + + __slots__ = ("_payload",) + + def __init__(self, payload: Any) -> None: + # Do not inspect even passive data before the whole-input policy runs. + self._payload = payload + + def masked(self, config: "TraceConfig") -> Optional[dict]: + """Return a fresh, policy-filtered built-in copy, or None (fail closed).""" + if config.hide_inputs or config.hide_input_messages: + return None + try: + # Validate again even when the slot was forged or changed by caller. + payload = object.__getattribute__(self, "_payload") + if not _object(payload) or type(payload.get("model")) is not str: + return None + result = {"model": payload["model"]} + budget = [10000] + if "messages" in payload: + messages = payload["messages"] + if (type(messages) is not list and type(messages) is not tuple) or len(messages) > 10000: + return None + result["messages"] = [] + for message in messages: + if not _object(message): + return None + role = message.get("role") + if type(role) is not str or role not in _ROLES: + return None + copy = {"role": role} + if "content" in message: + # Copy first so no custom leaf can reach masking or JSON. + copy["content"] = _content(_passive(message["content"], budget), config) + for key in ("name", "tool_call_id", "refusal", "tool_calls", "function_call", "audio"): + if key in message: + copy[key] = (_REDACTED if config.hide_input_text or config.hide_input_images + else _passive(message[key], budget)) + result["messages"].append(copy) + result.update(_parameters(payload, config, budget)) + return _redact_validated_leaves(result) if config.pii_redaction else result + except (AttributeError, ValueError, RecursionError): + return None + + def masked_invocation_parameters(self, config: "TraceConfig") -> Optional[dict]: + """Independently allowed parameters, without inspecting hidden messages. + + Uses the same strict validator and actual policy as the input projection. + Message hiding does not hide typed invocation metadata, but opaque fields + that could duplicate message/tool content are still redacted. + """ + if config.hide_inputs or config.hide_llm_invocation_parameters: + return None + try: + payload = object.__getattribute__(self, "_payload") + if not _object(payload): + return None + result = _parameters(payload, config, [10000]) + return _redact_validated_leaves(result) if config.pii_redaction else result + except (AttributeError, ValueError, RecursionError): + return None + + +def mask_chat_input(value: ChatInput, config: "TraceConfig") -> str: + # Call the class implementation, never an instance-provided serializer. + payload = ChatInput.masked(value, config) + if payload is None: + return _REDACTED + try: + return json.dumps(payload, ensure_ascii=False, allow_nan=False) + except (ValueError, OverflowError): + # Even built-in integers can exceed the interpreter's JSON digit limit. + return _REDACTED diff --git a/python/fi_instrumentation/instrumentation/_spans.py b/python/fi_instrumentation/instrumentation/_spans.py index c0ab066ba..929e4acf4 100644 --- a/python/fi_instrumentation/instrumentation/_spans.py +++ b/python/fi_instrumentation/instrumentation/_spans.py @@ -12,6 +12,7 @@ get_output_attributes, get_tool_attributes, ) +from ._chat_input import ChatInput from ._errors import ( ERROR_TYPE, ERROR_TYPE_OTHER, @@ -265,7 +266,7 @@ def set_attributes(self, attributes: Dict[str, AttributeValue]) -> None: def set_attribute( self, key: str, - value: Union[AttributeValue, Callable[[], AttributeValue]], + value: Union[AttributeValue, Callable[[], AttributeValue], ChatInput], ) -> None: masked_value = self._self_config.mask(key, value) if masked_value is not None: diff --git a/python/fi_instrumentation/instrumentation/config.py b/python/fi_instrumentation/instrumentation/config.py index 1df7ea1f7..2e37f5279 100644 --- a/python/fi_instrumentation/instrumentation/config.py +++ b/python/fi_instrumentation/instrumentation/config.py @@ -19,6 +19,7 @@ ) from opentelemetry.util.types import AttributeValue +from ._chat_input import ChatInput, mask_chat_input from ._errors import is_error_detail_key from .logging import logger from .pii_redaction import redact_pii_in_value @@ -359,8 +360,13 @@ def __post_init__(self) -> None: def mask( self, key: str, - value: Union[AttributeValue, Callable[[], AttributeValue]], + value: Union[AttributeValue, Callable[[], AttributeValue], ChatInput], ) -> Optional[AttributeValue]: + # Opaque payloads can duplicate structured messages. Treat their whole + # value as private before evaluating a lazy serializer; no safe modality + # boundary exists inside arbitrary JSON or strings. + private_input = self.hide_inputs or self.hide_input_messages or self.hide_input_text + private_output = self.hide_outputs or self.hide_output_messages or self.hide_output_text if self.hide_error_details and is_error_detail_key(key): return None elif ( @@ -368,20 +374,24 @@ def mask( and key == SpanAttributes.GEN_AI_REQUEST_PARAMETERS ): return None - elif self.hide_inputs and _has_content_prefix(key, (SpanAttributes.INPUT_VALUE,)): + elif type(value) is ChatInput: + # Exact type and exact input keys only. Core validates and masks the + # passive structure itself; a caller cannot mark an opaque string safe. + value = (mask_chat_input(value, self) + if key in (SpanAttributes.INPUT_VALUE, SpanAttributes.RAW_INPUT) + else REDACTED_VALUE) + elif (private_input or self.hide_input_images) and _has_content_prefix( + key, (SpanAttributes.INPUT_VALUE, *tuple(_HIDDEN_WITH_INPUTS)) + ): value = REDACTED_VALUE elif self.hide_inputs and key == SpanAttributes.INPUT_MIME_TYPE: return None - elif self.hide_inputs and _has_content_prefix(key, tuple(_HIDDEN_WITH_INPUTS)): - # The raw request body (messages included) and the values filled - # into a prompt template are inputs too. - value = REDACTED_VALUE - elif self.hide_outputs and _has_content_prefix(key, (SpanAttributes.OUTPUT_VALUE,)): + elif private_output and _has_content_prefix( + key, (SpanAttributes.OUTPUT_VALUE, SpanAttributes.RAW_OUTPUT) + ): value = REDACTED_VALUE elif self.hide_outputs and key == SpanAttributes.OUTPUT_MIME_TYPE: return None - elif self.hide_outputs and _has_content_prefix(key, (SpanAttributes.RAW_OUTPUT,)): - value = REDACTED_VALUE # The aggregate tool call can contain both arguments and results; hide # it if either direction is private. Specific child fields remain # directional, and identifiers like gen_ai.tool.name stay visible. @@ -515,4 +525,6 @@ def _cast_value( def is_base64_url(url: str) -> bool: if not isinstance(url, str): return False - return url.startswith("data:image/") and "base64" in url + # Data URL schemes, media types and the base64 marker are case-insensitive. + lowered = url.lower() + return lowered.startswith("data:image/") and "base64" in lowered diff --git a/python/fi_instrumentation/instrumentation/version.py b/python/fi_instrumentation/instrumentation/version.py index 48c9c4fc4..aa52eaa3f 100644 --- a/python/fi_instrumentation/instrumentation/version.py +++ b/python/fi_instrumentation/instrumentation/version.py @@ -1 +1 @@ -__version__ = "1.2.2" # x-release-please-version +__version__ = "1.2.3" # x-release-please-version diff --git a/python/frameworks/deepseek/tests/test_privacy_sdk.py b/python/frameworks/deepseek/tests/test_privacy_sdk.py index 56c395497..6eb94a377 100644 --- a/python/frameworks/deepseek/tests/test_privacy_sdk.py +++ b/python/frameworks/deepseek/tests/test_privacy_sdk.py @@ -1,8 +1,10 @@ """Exercise real OpenAI parsing, including DeepSeek reasoning and tool streams.""" import json +from importlib.metadata import version import openai import pytest +from packaging.version import Version from fi_instrumentation import TraceConfig from fi_instrumentation.instrumentation.config import REDACTED_VALUE from opentelemetry.sdk.trace import TracerProvider @@ -11,6 +13,9 @@ from traceai_deepseek import DeepSeekInstrumentor +# Older published cores predate the opaque-payload privacy repair. +GRANULAR_RAW_PRIVACY = Version(version("fi-instrumentation-otel")) >= Version("1.2.3") + # Use the transport accepted by the installed OpenAI SDK (1.x and 3.x). try: from openai._base_client import httpx2 as httpx @@ -122,7 +127,7 @@ def respond(request): tool_key = "deepseek.tool_calls.0.function.arguments" content_key = "gen_ai.output.messages.0.message.content" if hide_content: - if policy == "hide_outputs": + if policy == "hide_outputs" or GRANULAR_RAW_PRIVACY: assert attributes["output.value"] == REDACTED_VALUE if policy == "hide_output_text": for key in (*reasoning_keys, tool_key, content_key): @@ -131,10 +136,10 @@ def respond(request): assert not any(key.startswith("gen_ai.output.messages") for key in attributes) for key in (*reasoning_keys, tool_key): assert key not in attributes - # Text/message policies intentionally do not hide the separate raw - # output.value field. Everything else must be free of private output. + # Core >=1.2.3 also hides the raw duplicate. Retain the older + # expectation only when qualifying a previously published core. masked_attributes = dict(attributes) - if policy != "hide_outputs": + if policy != "hide_outputs" and not GRANULAR_RAW_PRIVACY: masked_attributes.pop("output.value") for private in (answer, reasoning, arguments, "PRIVATE_TOOL_ARGUMENTS_6823"): assert private not in json.dumps(masked_attributes) @@ -143,7 +148,7 @@ def respond(request): assert attributes[key] == reasoning assert attributes[tool_key] == arguments assert attributes[content_key] == answer - if not hide_content or policy != "hide_outputs": + if not hide_content or (policy != "hide_outputs" and not GRANULAR_RAW_PRIVACY): payload = json.loads(attributes["output.value"]) output = payload if streaming else payload["choices"][0]["message"] assert output["content"] == answer diff --git a/python/frameworks/discoveryengine/tests/test_discoveryengine_config.py b/python/frameworks/discoveryengine/tests/test_discoveryengine_config.py index e8c551d7d..23750167b 100644 --- a/python/frameworks/discoveryengine/tests/test_discoveryengine_config.py +++ b/python/frameworks/discoveryengine/tests/test_discoveryengine_config.py @@ -3,8 +3,10 @@ from __future__ import annotations import asyncio +from importlib.metadata import version import pytest +from packaging.version import Version from google.api_core import exceptions as core_exceptions from opentelemetry.trace import StatusCode @@ -26,6 +28,9 @@ ) from traceai_discoveryengine import DiscoveryEngineInstrumentor, _wrappers +# Older published cores predate the opaque-payload privacy repair. +GRANULAR_RAW_PRIVACY = Version(version("fi-instrumentation-otel")) >= Version("1.2.3") + EMAIL = "jane.doe@example.com" EMAIL_TOKEN = "" REDACTED_VALUE = "__REDACTED__" @@ -210,8 +215,8 @@ def test_hide_outputs_changes_nothing_because_no_output_text_is_recorded(fake): @pytest.mark.parametrize("source", ["config", "env"]) @pytest.mark.parametrize("flag", OTHER_CONTENT_HIDE_FLAGS) def test_other_content_hide_flags_follow_core_error_policy(fake, monkeypatch, flag, source): - # These flags do not hide a retrieval query, but native core derives error - # privacy from all content-hide flags, not only hide_inputs. No opt-out. + # New cores also hide opaque input.value for input text/message flags. + # Output-only flags remain directional; error privacy applies to all. plain = _denied(fake, {}) options = {} if source == "config": @@ -219,7 +224,8 @@ def test_other_content_hide_flags_follow_core_error_policy(fake, monkeypatch, fl else: monkeypatch.setenv("FI_" + flag.upper(), "true") span = _denied(fake, options) - assert attrs(span)["input.value"] == DENIED_QUERY + private_input = GRANULAR_RAW_PRIVACY and flag in ("hide_input_messages", "hide_input_text") + assert attrs(span)["input.value"] == (REDACTED_VALUE if private_input else DENIED_QUERY) assert attrs(span)["discoveryengine.error.code"] == 403 assert attrs(span)["discoveryengine.error.status"] == "PERMISSION_DENIED" assert span.status.status_code is StatusCode.ERROR diff --git a/python/frameworks/fireworks/tests/test_core_modality_contract.py b/python/frameworks/fireworks/tests/test_core_modality_contract.py new file mode 100644 index 000000000..b276f489a --- /dev/null +++ b/python/frameworks/fireworks/tests/test_core_modality_contract.py @@ -0,0 +1,79 @@ +"""The deprecated route uses core's typed policy, not a pre-sanitized marker.""" +import copy +import json + +import pytest +from fi_instrumentation import TraceConfig +from traceai_fireworks._wrappers import _get_input_attributes + +from .test_privacy_and_raw_streams import configured_tracing +from .test_privacy_regressions import IMAGE, MESSAGES, MODEL, PROMPT, call_client, exported + + +@pytest.mark.parametrize("asynchronous", [False, True]) +@pytest.mark.parametrize("mode", ["normal", "stream", "raw", "raw_stream"]) +def test_text_hiding_retains_typed_image_reference(asynchronous, mode): + with configured_tracing(hide_input_text=True) as exporter: + requests = [] + call_client(asynchronous, mode, requests) + attrs, everything = exported(exporter) + assert PROMPT not in everything + assert IMAGE in attrs["input.value"] + content = json.loads(attrs["input.value"])["messages"][0]["content"] + assert content[0]["text"] == "__REDACTED__" + assert content[1]["image_url"]["url"] == IMAGE + assert requests[0]["body"]["messages"] == MESSAGES + + +def test_granular_core_path_never_calls_unknown_serializers(): + # API is optional only at the published pre-guard core floor. When present, + # malformed data must fail closed rather than falling back to serialization. + pytest.importorskip("fi_instrumentation.instrumentation._chat_input") + + class Active: + def model_dump(self): + raise AssertionError("hidden serializer called") + + def __str__(self): + raise AssertionError("hidden string conversion called") + + config = TraceConfig(hide_input_images=True) + messages = [{"role": "user", "content": Active()}] + attrs = _get_input_attributes(MODEL, messages, config=config, stop=Active(), + extra_headers={"credential": "SYNTHETIC-SECRET"}) + assert config.mask("input.value", attrs["input.value"]) == "__REDACTED__" + assert not any(key.startswith("gen_ai.input.messages") for key in attrs) + + +def test_core_not_instrumentor_applies_image_mask(): + module = pytest.importorskip("fi_instrumentation.instrumentation._chat_input") + original = copy.deepcopy(MESSAGES) + attrs = _get_input_attributes(MODEL, original, config=TraceConfig(hide_input_images=True)) + assert type(attrs["input.value"]) is module.ChatInput + # Reapply a different policy to the same ORIGINAL typed data. This cannot + # work with a package-sanitized string or a boolean assertion of trust. + visible = TraceConfig().mask("input.value", attrs["input.value"]) + assert IMAGE in visible and PROMPT in visible + hidden = TraceConfig(hide_input_text=True).mask("input.value", attrs["input.value"]) + assert IMAGE in hidden and PROMPT not in hidden + assert original == MESSAGES + + +def test_repository_package_collection_with_installed_core(): + # pytest also imports the repository's python package while collecting recipe + # and framework tests. It must not demand a new API from an older installed + # canonical fi_instrumentation package (the supported published-floor job). + import subprocess + import sys + from pathlib import Path + + root = Path(__file__).resolve().parents[4] + assert (root / "python" / "__init__.py").is_file() + result = subprocess.run([ + sys.executable, "-I", "-c", + "import sys, fi_instrumentation; before = fi_instrumentation.__file__; " + "sys.path.insert(0, sys.argv[1]); import python; " + "assert fi_instrumentation.__file__ == before", + str(root), + ], text=True, capture_output=True, timeout=30) + assert result.returncode == 0, result.stdout + result.stderr diff --git a/python/frameworks/fireworks/tests/test_leaf_privacy_contract.py b/python/frameworks/fireworks/tests/test_leaf_privacy_contract.py new file mode 100644 index 000000000..00a7e484e --- /dev/null +++ b/python/frameworks/fireworks/tests/test_leaf_privacy_contract.py @@ -0,0 +1,288 @@ +"""Typed leaf privacy and independently permitted invocation metadata.""" +import copy +import json + +import pytest +from openai import _types as sdk_types +from fi_instrumentation import TraceConfig +from traceai_fireworks._wrappers import _get_input_attributes + +pytestmark = pytest.mark.filterwarnings("ignore::DeprecationWarning") + +TEXT = "visible-text" +IMAGE = "https://example.invalid/image" +MESSAGES = [{"role": "user", "content": [ + {"type": "text", "text": TEXT}, {"type": "image_url", "image_url": {"url": IMAGE}}, +]}] + + +@pytest.fixture(autouse=True) +def new_core(): + pytest.importorskip("fi_instrumentation.instrumentation._chat_input") + + +@pytest.mark.parametrize("flag", ["hide_input_images", "hide_input_text"]) +@pytest.mark.parametrize("sentinel", [getattr(sdk_types, name)() for name in ("NotGiven", "Omit") if hasattr(sdk_types, name)]) +def test_exact_sdk_omission_types_do_not_invalidate_permitted_content(flag, sentinel): + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", MESSAGES, config=config, temperature=sentinel) + parsed = json.loads(config.mask("input.value", attrs["input.value"])) + assert "temperature" not in parsed + assert (TEXT if flag == "hide_input_images" else IMAGE) in json.dumps(parsed) + + +@pytest.mark.parametrize("hide_inputs", [False, True]) +@pytest.mark.parametrize("hide_messages", [False, True]) +@pytest.mark.parametrize("hide_parameters", [False, True]) +@pytest.mark.parametrize("hide_text,hide_images", [(False, False), (True, False), (False, True), (True, True)]) +def test_invocation_policy_matrix(hide_inputs, hide_messages, hide_parameters, hide_text, hide_images): + config = TraceConfig(hide_inputs=hide_inputs, hide_input_messages=hide_messages, + hide_llm_invocation_parameters=hide_parameters, + hide_input_text=hide_text, hide_input_images=hide_images) + original = copy.deepcopy(MESSAGES) + attrs = _get_input_attributes("model", MESSAGES, config=config, temperature=0.7, max_tokens=100, + tools=[{"hidden": TEXT}], extra_body={"credential": "SYNTHETIC-SECRET"}) + masked = {k: config.mask(k, v) for k, v in attrs.items()} + if hide_inputs or hide_parameters: + assert "gen_ai.request.parameters" not in attrs + else: + params = json.loads(masked["gen_ai.request.parameters"]) + assert params["temperature"] == 0.7 and params["max_tokens"] == 100 + if hide_messages or hide_text or hide_images: + assert params["tools"] == "__REDACTED__" + if hide_inputs or hide_messages: + assert masked["input.value"] == "__REDACTED__" + assert not any(k.startswith("gen_ai.input.messages") for k in attrs) + assert "SYNTHETIC-SECRET" not in json.dumps(masked) + assert MESSAGES == original + + +@pytest.mark.parametrize("separator", ["\t", "\n", "\r"]) +@pytest.mark.parametrize("hide_images", [False, True]) +def test_pii_flattened_and_raw_copies_share_leaf_redaction(separator, hide_images): + pii = separator.join(["123", "45", "6789"]) + messages = [{"role": "user", "content": [{"type": "text", "text": pii}]}] + original = copy.deepcopy(messages) + config = TraceConfig(pii_redaction=True, hide_input_images=hide_images) + attrs = _get_input_attributes("model", messages, config=config, stop=[pii]) + parsed = json.loads(config.mask("input.value", attrs["input.value"])) + assert parsed["messages"][0]["content"][0]["text"] == "" + assert attrs["gen_ai.input.messages.0.message.content"] == "[{'type': 'text', 'text': ''}]" + assert json.loads(attrs["gen_ai.request.parameters"])["stop"] == [""] + assert messages == original + + +def test_fake_omission_objects_and_sdk_subclasses_are_not_trusted(): + class NotGiven: + def touch(self, *args, **kwargs): + raise AssertionError("fake omission protocol invoked") + __str__ = __bool__ = __iter__ = model_dump = touch + + class Subclass(sdk_types.NotGiven): + pass + + for sentinel in (NotGiven(), Subclass()): + config = TraceConfig(hide_input_images=True) + attrs = _get_input_attributes("model", MESSAGES, config=config, temperature=sentinel) + assert config.mask("input.value", attrs["input.value"]) == "__REDACTED__" + assert not any(k.startswith("gen_ai.input.messages") for k in attrs) + + +def test_omission_detection_does_not_call_custom_type_equality(): + class ActiveType(type): + def __eq__(cls, other): + raise AssertionError("omission detection called custom equality") + + class Active(metaclass=ActiveType): + pass + + attrs = _get_input_attributes("model", MESSAGES, config=TraceConfig(hide_input_images=True), + temperature=0.7, unknown=Active()) + assert json.loads(attrs["gen_ai.request.parameters"])["temperature"] == 0.7 + + +def test_message_hiding_does_not_inspect_hidden_messages_or_tools(): + class Active: + def touch(self, *args, **kwargs): + raise AssertionError("hidden protocol invoked") + __str__ = __iter__ = model_dump = touch + + config = TraceConfig(hide_input_messages=True) + attrs = _get_input_attributes("model", [{"role": "user", "content": Active()}], config=config, + temperature=0.7, tools=Active(), unknown=Active()) + assert json.loads(attrs["gen_ai.request.parameters"]) == {"temperature": 0.7, "tools": "__REDACTED__"} + attrs = _get_input_attributes("model", MESSAGES, config=config, temperature=Active()) + assert "gen_ai.request.parameters" not in attrs + + +def _assistant_tool_call_message(): + from openai.types.chat import ChatCompletionMessage + return ChatCompletionMessage.construct( + role="assistant", content=None, + tool_calls=[{"id": "call-1", "type": "function", + "function": {"name": "lookup", "arguments": '{"q": "tool-args"}'}}], + ) + + +@pytest.mark.parametrize("flag", ["pii_redaction", "hide_input_images", "hide_input_text"]) +def test_sdk_message_objects_in_a_tool_loop_keep_permitted_telemetry(flag): + sdk_message = _assistant_tool_call_message() + messages = [{"role": "user", "content": TEXT}, sdk_message, + {"role": "tool", "tool_call_id": "call-1", "content": "tool-result"}] + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", messages, config=config, temperature=0.7, max_tokens=100) + masked = config.mask("input.value", attrs["input.value"]) + assert masked != "__REDACTED__" + assert attrs["gen_ai.input.messages.1.message.role"] == "assistant" + assert attrs["gen_ai.input.messages.2.message.role"] == "tool" + if flag == "hide_input_text": + assert TEXT not in json.dumps(masked) and "tool-args" not in masked + else: + assert TEXT in masked + params = json.loads(attrs["gen_ai.request.parameters"]) + assert params["temperature"] == 0.7 and params["max_tokens"] == 100 + assert messages[1] is sdk_message and sdk_message.tool_calls is not None + + +@pytest.mark.parametrize("flag", ["pii_redaction", "hide_input_images", "hide_input_text"]) +def test_parsed_structured_output_messages_keep_permitted_telemetry(flag): + chat_types = pytest.importorskip("openai.types.chat") + parsed_message = getattr(chat_types, "ParsedChatCompletionMessage", None) + if parsed_message is None: + pytest.skip("parse() structured outputs are not available in this SDK") + import pydantic + + class Answer(pydantic.BaseModel): + answer: str + + message = parsed_message[Answer].construct( + role="assistant", content='{"answer": "x"}', parsed=Answer(answer="x")) + messages = [{"role": "user", "content": TEXT}, message] + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", messages, config=config, temperature=0.7) + assert config.mask("input.value", attrs["input.value"]) != "__REDACTED__" + assert attrs["gen_ai.input.messages.1.message.role"] == "assistant" + assert messages[1] is message + + +@pytest.mark.parametrize("flag", ["hide_input_images", "hide_input_text", "pii_redaction"]) +@pytest.mark.parametrize("invalid", [{"url": "ftp://example.invalid/i.png"}, + {"url": "https://example.invalid/i.png", "detail": "ultra"}]) +def test_unprojectable_messages_keep_independent_parameters(flag, invalid): + messages = [{"role": "user", "content": [{"type": "text", "text": TEXT}, + {"type": "image_url", "image_url": invalid}]}] + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", messages, config=config, temperature=0.7, max_tokens=100) + params = json.loads(attrs["gen_ai.request.parameters"]) + assert params["temperature"] == 0.7 and params["max_tokens"] == 100 + if flag != "pii_redaction": + assert config.mask("input.value", attrs["input.value"]) == "__REDACTED__" + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_input_text", "pii_redaction"]) +def test_plain_conversion_does_not_run_metaclass_hooks(flag): + calls = [] + + class HookMeta(type): + @property + def __module__(cls): + calls.append("module") + raise AssertionError("metaclass __module__ descriptor ran") + + def __eq__(cls, other): + calls.append("eq") + raise AssertionError("metaclass equality ran") + + class Hostile(metaclass=HookMeta): + pass + + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", MESSAGES, config=config, temperature=Hostile()) + config.mask("input.value", attrs["input.value"]) + assert calls == [] + + +@pytest.mark.parametrize("flag", ["hide_input_text", "pii_redaction"]) +def test_plain_conversion_does_not_hash_custom_dict_keys(flag): + class Key: + calls = 0 + def __hash__(self): + type(self).calls += 1 + return 7 + def __eq__(self, other): + type(self).calls += 1 + return self is other + + key = Key() + payload = {key: -100} # constructing the original dict hashes once + Key.calls = 0 + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", MESSAGES, config=config, logit_bias=payload) + config.mask("input.value", attrs["input.value"]) + assert Key.calls == 0 + + +class _Hostile: + evaluated = [] + + def __getattr__(self, name): + type(self).evaluated.append(name) + raise AssertionError(f"__getattr__({name}) evaluated") + + @property + def __class__(self): + type(self).evaluated.append("__class__") + raise AssertionError("__class__ evaluated") + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_input_messages", "hide_input_text", + "hide_input_images", "pii_redaction"]) +@pytest.mark.parametrize("where", ["temperature", "message", "tools-item"]) +def test_sdk_conversion_never_evaluates_caller_hooks(flag, where): + _Hostile.evaluated = [] + messages = [{"role": "user", "content": TEXT}] + kwargs = {"temperature": 0.7} + if where == "temperature": + kwargs["temperature"] = _Hostile() + elif where == "message": + messages.append(_Hostile()) + else: + kwargs["tools"] = [_Hostile()] + config = TraceConfig(**{flag: True}) + attrs = _get_input_attributes("model", messages, config=config, **kwargs) + config.mask("input.value", attrs["input.value"]) + assert _Hostile.evaluated == [] + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_input_messages", "hide_input_text"]) +def test_sdk_conversion_writes_no_hidden_values_to_warnings(flag, recwarn): + from openai.types.chat import ChatCompletionMessage + sdk_message = ChatCompletionMessage.construct( + role="assistant", content=None, + tool_calls=[{"id": "c", "type": "function", + "function": {"name": "f", "arguments": {"q": "HIDDEN-ARGUMENT-TEXT"}}}], + ) + config = TraceConfig(**{flag: True}) + _get_input_attributes("model", [{"role": "user", "content": TEXT}, sdk_message], config=config) + assert not any("HIDDEN-ARGUMENT-TEXT" in str(w.message) for w in recwarn.list) + + +def test_sdk_conversion_is_bounded_and_fails_closed(): + import time + config = TraceConfig(hide_input_images=True) + start = time.perf_counter() + attrs = _get_input_attributes("model", [{"role": "user", "content": TEXT}], config=config, + stop=["x"] * 1_000_001) + assert time.perf_counter() - start < 2.0 + assert config.mask("input.value", attrs["input.value"]) == "__REDACTED__" + + +def test_int_keyed_logit_bias_keeps_pii_only_telemetry(): + config = TraceConfig(pii_redaction=True) + attrs = _get_input_attributes("model", [{"role": "user", "content": TEXT}], config=config, + temperature=0.7, max_tokens=100, logit_bias={50256: -100}) + parsed = json.loads(config.mask("input.value", attrs["input.value"])) + assert parsed["logit_bias"] == {"50256": -100} + assert attrs["gen_ai.input.messages.0.message.content"] == TEXT + params = json.loads(attrs["gen_ai.request.parameters"]) + assert params["temperature"] == 0.7 and params["max_tokens"] == 100 diff --git a/python/frameworks/fireworks/traceai_fireworks/_wrappers.py b/python/frameworks/fireworks/traceai_fireworks/_wrappers.py index 2411d2ddc..96ebbf8b1 100644 --- a/python/frameworks/fireworks/traceai_fireworks/_wrappers.py +++ b/python/frameworks/fireworks/traceai_fireworks/_wrappers.py @@ -9,6 +9,13 @@ from urllib.parse import urlsplit from fi_instrumentation import REDACTED_VALUE, TraceConfig, safe_json_dumps + +try: + from fi_instrumentation.instrumentation.config import ChatInput +except ImportError: + # The declared published 1.2.2 floor predates the structured-input API and + # the opaque-input guard. Retain its existing path, not a validation fallback. + ChatInput = None from fi_instrumentation.fi_types import FiSpanKindValues, SpanAttributes, MessageAttributes from opentelemetry import trace as trace_api from opentelemetry.trace import INVALID_SPAN, Span, Status, StatusCode @@ -57,8 +64,18 @@ def _start_span( attributes: Dict[str, AttributeValue], ) -> Iterator[Span]: """Start a span with the given name and attributes.""" + # Structured input belongs on the supported FI span setter. A sampler + # is allowed to return/replace opaque attributes, which core must mask + # fail-closed again. Never turn its returned JSON into a trusted string. + structured = attributes.get(SpanAttributes.INPUT_VALUE) + if ChatInput is not None and type(structured) is ChatInput: + attributes = {k: v for k, v in attributes.items() if k != SpanAttributes.INPUT_VALUE} + else: + structured = None try: span = self._tracer.start_span(name=span_name, attributes=attributes) + if structured is not None: + span.set_attribute(SpanAttributes.INPUT_VALUE, structured) except Exception: span = INVALID_SPAN @@ -96,6 +113,122 @@ def _shared_instrumentor_enabled() -> bool: return bool(instrumentor and instrumentor().is_instrumented_by_opentelemetry) +_SDK_PLAIN_NODES = 10000 # same allowance as core's ChatInput copy budget +_type_mro = type.__dict__["__mro__"].__get__ +_type_dict = type.__dict__["__dict__"].__get__ +_type_name = type.__dict__["__name__"].__get__ + + +class _OverBudget(Exception): + pass + + +def _exported_openai_class(kind: type) -> bool: + """True only for the exact class exported by its already-loaded openai.* module.""" + module_name = _type_dict(kind).get("__module__") + # __name__ is stored in type's native slot, not the class namespace. + class_name = _type_name(kind) + if (type(module_name) is not str or not module_name.startswith("openai.") + or type(class_name) is not str): + return False + # ModuleType's native dict descriptor and dict.get avoid user attribute hooks. + from types import ModuleType + module = __import__("sys").modules.get(module_name) + if type(module) is not ModuleType: + return False + return ModuleType.__dict__["__dict__"].__get__(module).get(class_name) is kind + + +def _genuine_sdk_model(kind: type, sdk_model: type) -> bool: + """Classify canonical OpenAI classes without metaclass equality/descriptors.""" + try: + mro = _type_mro(kind) + found_base = False + for base in mro: + if base is sdk_model: # identity only; tuple membership may call metaclass __eq__ + found_base = True + break + # A subclass override can install its own serializer or metaclass hooks. + if "model_dump" in _type_dict(base): + return False + if not found_base: + return False + if _exported_openai_class(kind): + return True + # parse() returns runtime pydantic parametrizations such as + # ParsedChatCompletionMessage[T], which their module does not export. + # Accept one only when its recorded generic origin is itself an exported + # OpenAI class and sits in its own MRO (identity comparison only). + metadata = _type_dict(kind).get("__pydantic_generic_metadata__") + if type(metadata) is not dict: + return False + origin = metadata.get("origin") + if origin is None or origin is kind: + return False + if not any(base is origin for base in mro): + return False + return _exported_openai_class(origin) + except Exception: + return False + + +def _sdk_plain(value: Any) -> Any: + """Copy built-in containers, converting only genuine OpenAI SDK models to plain JSON. + + Mirrors what the SDK sends on the wire: SDK models become JSON and exact-int + dict keys (e.g. logit_bias token ids) become strings. Everything else, + including user subclasses of SDK types, is returned unchanged so core's + strict validator rejects it without evaluating it. Bounded by the same node + budget as core; past it the original value is returned (and fails closed). + Caller objects are never modified. + """ + try: + from openai._models import BaseModel as sdk_model + except ImportError: # pragma: no cover - openai is a hard dependency + return value + budget = [_SDK_PLAIN_NODES] + + def walk(item: Any, depth: int) -> Any: + budget[0] -= 1 + if budget[0] < 0 or depth > 32: + raise _OverBudget + kind = type(item) + if kind is dict: + copied = {} + for key, child in item.items(): + key_kind = type(key) + if key_kind is str: + normalized = key + elif key_kind is int: + try: + # This is the SDK/JSON wire normalization for integer keys. + normalized = str(key) + except (ValueError, OverflowError): + return item + else: + # Never rehash or stringify a caller-controlled key. Core's + # strict validator will fail this original mapping closed. + return item + copied[normalized] = walk(child, depth + 1) + return copied + if kind is list or kind is tuple: + return [walk(child, depth + 1) for child in item] + if _genuine_sdk_model(kind, sdk_model): + try: + # pydantic's own implementation, never an override; warnings off + # so mismatched values are not written to the warning stream. + dumped = sdk_model.model_dump(item, mode="json", exclude_unset=True, warnings=False) + except Exception: + return item + return walk(dumped, depth + 1) + return item + + try: + return walk(value, 0) + except (_OverBudget, RecursionError): + return value + + def _get_input_attributes( model: str, messages: Any, @@ -111,6 +244,49 @@ def _get_input_attributes( SpanAttributes.GEN_AI_REQUEST_MODEL: model, } + # Resolve SDK types only at the request boundary; package import must stay + # usable without OpenAI. Never infer omission from names, equality or hooks. + from openai import _types as sdk_types + + omission_types = tuple( + kind for name in ("NotGiven", "Omit") + if (kind := getattr(sdk_types, name, None)) is not None + ) + kwargs = {k: v for k, v in kwargs.items() + if not any(type(v) is kind for kind in omission_types)} + if ChatInput is not None and any((config.hide_inputs, config.hide_input_messages, + config.hide_input_text, config.hide_input_images, + config.pii_redaction)): + # Pass the ORIGINAL typed input, not a previously sanitized string. + # Core applies policy independently for this copy and at the span setter. + # SDK models (e.g. a ChatCompletionMessage appended in a tool loop) are + # converted to the plain JSON the SDK itself sends; core still validates. + # Hidden inputs are never projected, so skip conversion entirely there. + convert = (lambda value: value) if config.hide_inputs else _sdk_plain + raw_input = {"model": model} + if type(messages) is list or type(messages) is tuple: + raw_input["messages"] = messages if config.hide_input_messages else convert(messages) + raw_input.update({k: convert(v) for k, v in kwargs.items() if k in _REQUEST_BODY_FIELDS}) + structured = ChatInput(raw_input) + attributes[SpanAttributes.INPUT_VALUE] = structured + telemetry = ChatInput.masked(structured, config) + invocation_params = None + if telemetry is not None: + for i, message in enumerate(telemetry.get("messages", [])): + prefix = f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}" + attributes[f"{prefix}.{MessageAttributes.MESSAGE_ROLE}"] = message["role"] + if "content" in message: + content = message["content"] + attributes[f"{prefix}.{MessageAttributes.MESSAGE_CONTENT}"] = str(content) if content else "" + invocation_params = {k: v for k, v in telemetry.items() if k not in ("model", "messages")} + else: + # Typed invocation metadata is allowed independently of whether the + # messages could be projected; input core rejects stays fail-closed. + invocation_params = ChatInput.masked_invocation_parameters(structured, config) + if invocation_params: + attributes[SpanAttributes.GEN_AI_REQUEST_PARAMETERS] = safe_json_dumps(invocation_params) + return attributes + # Add invocation parameters invocation_params = {} if "max_tokens" in kwargs and kwargs["max_tokens"] is not None: diff --git a/python/frameworks/openai/poetry.lock b/python/frameworks/openai/poetry.lock index ab4084324..826a61b5c 100644 --- a/python/frameworks/openai/poetry.lock +++ b/python/frameworks/openai/poetry.lock @@ -6,7 +6,7 @@ version = "0.7.0" description = "Reusable constraint types to use with typing.Annotated" optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"}, {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"}, @@ -41,7 +41,7 @@ version = "25.3.0" description = "Classes Without Boilerplate" optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3"}, {file = "attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b"}, @@ -61,7 +61,7 @@ version = "2024.6.2" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "certifi-2024.6.2-py3-none-any.whl", hash = "sha256:ddc6c8ce995e6987e7faf5e3f1b02b302836a0e5d98ece18392cb1a36c72ad56"}, {file = "certifi-2024.6.2.tar.gz", hash = "sha256:3cd43f1c6fa7dedc5899d69d3ad0398fd018ad1a17fba83ddaf78aa46c747516"}, @@ -73,7 +73,7 @@ version = "3.3.2" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7.0" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, @@ -199,7 +199,7 @@ description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" groups = ["main"] -markers = "python_version < \"3.11\"" +markers = "python_version == \"3.10\"" files = [ {file = "exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10"}, {file = "exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88"}, @@ -213,38 +213,40 @@ test = ["pytest (>=6)"] [[package]] name = "fi-instrumentation-otel" -version = "1.1.0" -description = "OpenTelemetry instrumentation" +version = "1.2.3" +description = "OpenTelemetry tracing for AI applications: tracer setup, span helpers, exporters, and semantic conventions for Future AGI." optional = false -python-versions = "<3.14,>3.9" -groups = ["main"] -files = [ - {file = "fi_instrumentation_otel-1.1.0-py3-none-any.whl", hash = "sha256:4fa2bf663e0ce09447aca92ae798cd7b0dee35c5c92c2e033f1d89d158a9e62c"}, - {file = "fi_instrumentation_otel-1.1.0.tar.gz", hash = "sha256:7ec324c3c9242aa87a88cf23a21c11919b8736c6451c5fb50917f592a853b059"}, -] +python-versions = ">=3.10,<3.16" +groups = ["main", "dev"] +files = [] +develop = true [package.dependencies] -jsonschema = ">=4.21.1,<5.0.0" -opentelemetry-api = ">=1.29.0,<2.0.0" -opentelemetry-exporter-otlp-proto-http = ">=1.29.0,<2.0.0" +jsonschema = "^4.21.1" +opentelemetry-api = "^1.29.0" +opentelemetry-exporter-otlp-proto-http = "^1.29.0" opentelemetry-instrumentation = "*" -opentelemetry-sdk = ">=1.29.0,<2.0.0" -pydantic = ">=2.9.2,<3.0.0" -requests = ">=2.32.3,<3.0.0" -typing-extensions = ">=4.9.0,<5.0.0" -wrapt = ">=1.15.0,<2.0.0" +opentelemetry-sdk = "^1.29.0" +pydantic = "^2.9.2" +requests = "^2.32.3" +typing-extensions = "^4.9.0" +wrapt = "^1.15.0" [package.extras] evaluation = ["ai-evaluation (>=0.1.0)", "futureagi (>=0.6.0)"] grpc = ["opentelemetry-exporter-otlp-proto-grpc (>=1.29.0,<2.0.0)"] +[package.source] +type = "directory" +url = "../.." + [[package]] name = "googleapis-common-protos" version = "1.70.0" description = "Common protobufs used in Google APIs" optional = false python-versions = ">=3.7" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "googleapis_common_protos-1.70.0-py3-none-any.whl", hash = "sha256:b8bfcca8c25a2bb253e0e0b0adaf8c00773e5e6af6fd92397576680b807e0fd8"}, {file = "googleapis_common_protos-1.70.0.tar.gz", hash = "sha256:0e1b44e0ea153e6594f9f394fef15193a68aaaea2d843f83e2742717ca753257"}, @@ -321,7 +323,7 @@ version = "3.7" description = "Internationalized Domain Names in Applications (IDNA)" optional = false python-versions = ">=3.5" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"}, {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"}, @@ -333,7 +335,7 @@ version = "8.7.0" description = "Read metadata from Python packages" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd"}, {file = "importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000"}, @@ -444,7 +446,7 @@ version = "4.24.0" description = "An implementation of JSON Schema validation for Python" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "jsonschema-4.24.0-py3-none-any.whl", hash = "sha256:a462455f19f5faf404a7902952b6f0e3ce868f3ee09a359b05eca6673bd8412d"}, {file = "jsonschema-4.24.0.tar.gz", hash = "sha256:0b4e8069eb12aedfa881333004bccaec24ecef5a8a6a4b6df142b2cc9599d196"}, @@ -466,7 +468,7 @@ version = "2025.4.1" description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af"}, {file = "jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608"}, @@ -509,7 +511,7 @@ version = "1.34.1" description = "OpenTelemetry Python API" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_api-1.34.1-py3-none-any.whl", hash = "sha256:b7df4cb0830d5a6c29ad0c0691dbae874d8daefa934b8b1d642de48323d32a8c"}, {file = "opentelemetry_api-1.34.1.tar.gz", hash = "sha256:64f0bd06d42824843731d05beea88d4d4b6ae59f9fe347ff7dfa2cc14233bbb3"}, @@ -525,7 +527,7 @@ version = "1.34.1" description = "OpenTelemetry Protobuf encoding" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_exporter_otlp_proto_common-1.34.1-py3-none-any.whl", hash = "sha256:8e2019284bf24d3deebbb6c59c71e6eef3307cd88eff8c633e061abba33f7e87"}, {file = "opentelemetry_exporter_otlp_proto_common-1.34.1.tar.gz", hash = "sha256:b59a20a927facd5eac06edaf87a07e49f9e4a13db487b7d8a52b37cb87710f8b"}, @@ -540,7 +542,7 @@ version = "1.34.1" description = "OpenTelemetry Collector Protobuf over HTTP Exporter" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_exporter_otlp_proto_http-1.34.1-py3-none-any.whl", hash = "sha256:5251f00ca85872ce50d871f6d3cc89fe203b94c3c14c964bbdc3883366c705d8"}, {file = "opentelemetry_exporter_otlp_proto_http-1.34.1.tar.gz", hash = "sha256:aaac36fdce46a8191e604dcf632e1f9380c7d5b356b27b3e0edb5610d9be28ad"}, @@ -561,7 +563,7 @@ version = "0.55b1" description = "Instrumentation Tools & Auto Instrumentation for OpenTelemetry Python" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_instrumentation-0.55b1-py3-none-any.whl", hash = "sha256:cbb1496b42bc394e01bc63701b10e69094e8564e281de063e4328d122cc7a97e"}, {file = "opentelemetry_instrumentation-0.55b1.tar.gz", hash = "sha256:2dc50aa207b9bfa16f70a1a0571e011e737a9917408934675b89ef4d5718c87b"}, @@ -579,7 +581,7 @@ version = "1.34.1" description = "OpenTelemetry Python Proto" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_proto-1.34.1-py3-none-any.whl", hash = "sha256:eb4bb5ac27f2562df2d6857fc557b3a481b5e298bc04f94cc68041f00cebcbd2"}, {file = "opentelemetry_proto-1.34.1.tar.gz", hash = "sha256:16286214e405c211fc774187f3e4bbb1351290b8dfb88e8948af209ce85b719e"}, @@ -594,7 +596,7 @@ version = "1.34.1" description = "OpenTelemetry Python SDK" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_sdk-1.34.1-py3-none-any.whl", hash = "sha256:308effad4059562f1d92163c61c8141df649da24ce361827812c40abb2a1e96e"}, {file = "opentelemetry_sdk-1.34.1.tar.gz", hash = "sha256:8091db0d763fcd6098d4781bbc80ff0971f94e260739aa6afe6fd379cdf3aa4d"}, @@ -611,7 +613,7 @@ version = "0.55b1" description = "OpenTelemetry Semantic Conventions" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "opentelemetry_semantic_conventions-0.55b1-py3-none-any.whl", hash = "sha256:5da81dfdf7d52e3d37f8fe88d5e771e191de924cfff5f550ab0b8f7b2409baed"}, {file = "opentelemetry_semantic_conventions-0.55b1.tar.gz", hash = "sha256:ef95b1f009159c28d7a7849f5cbc71c4c34c845bb514d66adfdf1b3fff3598b3"}, @@ -627,7 +629,7 @@ version = "25.0" description = "Core utilities for Python packages" optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484"}, {file = "packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f"}, @@ -639,7 +641,7 @@ version = "5.29.5" description = "" optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "protobuf-5.29.5-cp310-abi3-win32.whl", hash = "sha256:3f1c6468a2cfd102ff4703976138844f78ebd1fb45f49011afc5139e9e283079"}, {file = "protobuf-5.29.5-cp310-abi3-win_amd64.whl", hash = "sha256:3f76e3a3675b4a4d867b52e4a5f5b78a2ef9565549d4037e06cf7b0942b1d3fc"}, @@ -660,7 +662,7 @@ version = "2.11.7" description = "Data validation using Python type hints" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b"}, {file = "pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db"}, @@ -682,7 +684,7 @@ version = "2.33.2" description = "Core functionality for Pydantic validation and serialization" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8"}, {file = "pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d"}, @@ -794,7 +796,7 @@ version = "0.36.2" description = "JSON Referencing + Python" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0"}, {file = "referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa"}, @@ -811,7 +813,7 @@ version = "2.32.3" description = "Python HTTP for Humans." optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, @@ -833,7 +835,7 @@ version = "0.26.0" description = "Python bindings to Rust's persistent data structures (rpds)" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "rpds_py-0.26.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:4c70c70f9169692b36307a95f3d8c0a9fcd79f7b4a383aad5eaa0e9718b79b37"}, {file = "rpds_py-0.26.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:777c62479d12395bfb932944e61e915741e364c843afc3196b694db3d669fcd0"}, @@ -1021,7 +1023,7 @@ version = "4.14.1" description = "Backported and Experimental Type Hints for Python 3.9+" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76"}, {file = "typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36"}, @@ -1033,7 +1035,7 @@ version = "0.4.1" description = "Runtime typing introspection tools" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51"}, {file = "typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28"}, @@ -1048,7 +1050,7 @@ version = "2.2.2" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"}, {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"}, @@ -1066,7 +1068,7 @@ version = "1.17.2" description = "Module for decorators, wrappers and monkey patching." optional = false python-versions = ">=3.8" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "wrapt-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3d57c572081fed831ad2d26fd430d565b76aa277ed1d30ff4d40670b1c0dd984"}, {file = "wrapt-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5e251054542ae57ac7f3fba5d10bfff615b6c2fb09abeb37d2f1463f841ae22"}, @@ -1155,7 +1157,7 @@ version = "3.23.0" description = "Backport of pathlib-compatible object wrapper for zip files" optional = false python-versions = ">=3.9" -groups = ["main"] +groups = ["main", "dev"] files = [ {file = "zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e"}, {file = "zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166"}, @@ -1171,5 +1173,5 @@ type = ["pytest-mypy"] [metadata] lock-version = "2.1" -python-versions = ">3.9,<3.14" -content-hash = "0acc5e8ccc1ccab2cf75b5046531d39cacfe7bfc4c63f864c0ebee76e32e06ba" +python-versions = ">=3.10,<3.14" +content-hash = "2e8683a6d509738353d5e4097f83fc2cc5b278cd553e7fd74bbc89e18b608590" diff --git a/python/frameworks/openai/pyproject.toml b/python/frameworks/openai/pyproject.toml index 3a189f628..a6aec7dd2 100644 --- a/python/frameworks/openai/pyproject.toml +++ b/python/frameworks/openai/pyproject.toml @@ -15,7 +15,6 @@ classifiers = [ "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", @@ -27,10 +26,15 @@ classifiers = [ ] [tool.poetry.dependencies] -python = ">3.9,<3.14" -fi-instrumentation-otel = ">=0.1.11" +python = ">=3.10,<3.14" +fi-instrumentation-otel = ">=1.2.3" openai = ">=1.69.0" +# Test the release candidate before it exists on PyPI. This dev-only source +# never appears in the wheel's runtime requirements (which retain >=1.2.3). +[tool.poetry.group.dev.dependencies] +fi-instrumentation-otel = {path = "../..", develop = true} + [tool.poetry.urls] Homepage = "https://futureagi.com" Documentation = "https://docs.futureagi.com/docs/integrations/traceai/openai" diff --git a/python/frameworks/openai/tests/test_deepseek_route.py b/python/frameworks/openai/tests/test_deepseek_route.py index 2c786aed0..30edccacf 100644 --- a/python/frameworks/openai/tests/test_deepseek_route.py +++ b/python/frameworks/openai/tests/test_deepseek_route.py @@ -644,14 +644,15 @@ def test_responses_plaintext_reasoning( a = attrs(spans) assert a["gen_ai.usage.output_tokens"] == 7 assert spans[0].status.code == 1 - if policy != "hide_outputs": + if policy is None: if streaming: assert a["output.value"] == ANSWER else: assert json.loads(a["output.value"])["output_text"] == ANSWER if policy: - if policy != "hide_outputs": - a.pop("output.value", None) # Raw output has an independent policy. + # Granular privacy also covers the raw duplicate; do not remove it + # from the assertion and accidentally permit a leak. + assert a["output.value"] == "__REDACTED__" encoded = json.dumps(a) assert REASONING not in encoded assert summary not in encoded diff --git a/python/frameworks/openai/tests/test_granular_privacy.py b/python/frameworks/openai/tests/test_granular_privacy.py new file mode 100644 index 000000000..aee5558f3 --- /dev/null +++ b/python/frameworks/openai/tests/test_granular_privacy.py @@ -0,0 +1,64 @@ +"""Granular text flags hide all copies, with real SDK requests and streams.""" +import json + +import openai +import pytest +from fi_instrumentation import TraceConfig +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import SimpleSpanProcessor +from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter +from traceai_openai import OpenAIInstrumentor + +if int(openai.__version__.split(".")[0]) >= 3: + import httpx2 as httpx +else: + import httpx + + +@pytest.mark.parametrize("route", ["shared", "legacy"]) +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("flag", ["text", "messages"]) +def test_every_copy_hidden(route, stream, flag): + input_text, output_text = "PRIVATE_INPUT_SENTINEL", "PRIVATE_OUTPUT_SENTINEL" + exporter = InMemorySpanExporter() + provider = TracerProvider() + provider.add_span_processor(SimpleSpanProcessor(exporter)) + inst = (OpenAIInstrumentor() if route == "shared" else + pytest.importorskip("traceai_vllm").VLLMInstrumentor()) + + def handle(request): + assert json.loads(request.content)["messages"][0]["content"] == input_text + data = { + "id": "test", "object": "chat.completion", "created": 1, "model": "test", + "choices": [{"index": 0, "message": {"role": "assistant", "content": output_text}, "finish_reason": "stop"}], + "usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, + } + if stream: + data["object"] = "chat.completion.chunk" + data["choices"][0]["delta"] = data["choices"][0].pop("message") + return httpx.Response(200, headers={"content-type": "text/event-stream"}, + content=f"data: {json.dumps(data)}\n\ndata: [DONE]\n\n") + return httpx.Response(200, json=data) + + try: + inst.instrument(tracer_provider=provider, config=TraceConfig(**{ + "hide_input_" + flag: True, "hide_output_" + flag: True, + })) + with openai.OpenAI(api_key="synthetic-key", base_url="http://localhost:8000/v1", max_retries=0, + http_client=httpx.Client(transport=httpx.MockTransport(handle))) as client: + result = client.chat.completions.create(model="test", stream=stream, + messages=[{"role": "user", "content": input_text}]) + if stream: + assert "".join(chunk.choices[0].delta.content for chunk in result) == output_text + else: + assert result.choices[0].message.content == output_text + spans = exporter.get_finished_spans() + assert len(spans) == 1 + assert input_text not in spans[0].to_json() + assert output_text not in spans[0].to_json() + assert spans[0].attributes["gen_ai.request.model"] == "test" + assert spans[0].attributes["gen_ai.usage.input_tokens"] == 2 + assert spans[0].attributes["gen_ai.usage.output_tokens"] == 3 + finally: + inst.uninstrument() + provider.shutdown() diff --git a/python/frameworks/vllm/poetry.lock b/python/frameworks/vllm/poetry.lock new file mode 100644 index 000000000..2387540d5 --- /dev/null +++ b/python/frameworks/vllm/poetry.lock @@ -0,0 +1,1476 @@ +# This file is automatically @generated by Poetry 2.1.2 and should not be changed by hand. + +[[package]] +name = "annotated-types" +version = "0.8.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0"}, + {file = "annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7"}, +] + +[[package]] +name = "anyio" +version = "4.16.0" +description = "High-level concurrency and networking framework on top of asyncio or Trio" +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "anyio-4.16.0-py3-none-any.whl", hash = "sha256:c66ae634e0b8228396b801741beb3294326d4b6102f7bba4041c0dfb58c29026"}, + {file = "anyio-4.16.0.tar.gz", hash = "sha256:59bb03251907983d1603d27c3087ddb1e93299ea2163adcdba37899a4fb12ffb"}, +] + +[package.dependencies] +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} +idna = ">=2.8" +typing_extensions = {version = ">=4.16.0", markers = "python_version < \"3.15\""} + +[package.extras] +trio = ["trio (>=0.32.0)"] + +[[package]] +name = "attrs" +version = "26.1.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.9" +groups = ["main", "dev"] +files = [ + {file = "attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309"}, + {file = "attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32"}, +] + +[[package]] +name = "backports-asyncio-runner" +version = "1.2.0" +description = "Backport of asyncio.Runner, a context manager that controls event loop life cycle." +optional = false +python-versions = "<3.11,>=3.8" +groups = ["dev"] +markers = "python_version == \"3.10\"" +files = [ + {file = "backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5"}, + {file = "backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162"}, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.7" +groups = ["main", "dev"] +files = [ + {file = "certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1"}, + {file = "certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7" +groups = ["main", "dev"] +files = [ + {file = "charset_normalizer-3.5.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:195c26fb65950f8fce54e26349852b7bdd7c5f120aeefbcc440b8a20faaed4a3"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9373ad13ef0d2c0fb761e04e55bfdee5a08b52cef2c882c8fbe9935b1517152e"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ddf19c062bea7a0cc80f519243d2c01dd091be0cf952a0750d4ad576709559f5"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3d14b50de6bf4d0edf857a9386836846f982b8f524e188e2e68b96d702bcf4aa"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:28a15fdad492a99b6eccfaaed66ef3f74050680545ea61ec8b2f4c538f1f1320"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a893cc101149f80a653f82062ebc95b34525a2614382e1da5458fe7c6997249"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:619799369eeef6366ed3e8755a5670f4f2f0fb6b30a0fd7264dc0fdc2357058e"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:447441e76ec720b15e64418d32e092297340387053047c7c694f579efb0ee1d9"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:62588a277bfb59def052abd940703fa35107152bf479781a878617d60faf8fb5"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:44bd4fbb29dfbeba60e7d2bd000c59e4b21ddb3cc53912b14048d37092706d7c"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:30fcd120b732aa79317f08dee04d7de0847822e4cf7ee0e9f445bb958832252c"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:50e3adfb96fc189eb27b1cf62d3b598b89b4bb0420d93a3d3e42e137409011be"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b736353c0a625bbd5fcec108576e2385db3496f4f771f785ff32e108d3c3bc45"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-win32.whl", hash = "sha256:f5833ad231be5eb6553de524a70f48d71b2c8563101750531e0b80184e175cd4"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:1461ac396c4fdb983a675f20aa555624f0ee18ac83d832b9244ffff3d8055275"}, + {file = "charset_normalizer-3.5.2-cp310-cp310-win_arm64.whl", hash = "sha256:c6708715abcf3c73b99508253e961a9967f02fe536532834149574eda6de0d1c"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d21b8b13c7592db2ac5e544a6d83187b995257472b0c9e8351b6d507ae37ed6"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d760fe2a4d7c3b226cb9026d6a842868d52a7901bd98420e1baf14e80da85cf5"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9790464842f85f437dbbb54417eda1e0e6bfc52dd8d22d6fd1c994b73b2dc74"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4685902cf26edf013ed7a3da0f426ebba7a00ebb9541386d835afbf002c11cab"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4495c5002a7b28557e7e222e77e0b661183e432b7d6d2e788101e3f240e05b8c"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:211d5a3eb6af8f513b8d4ca19a8c1b7accab1b5f0d3175f9826b03c1a920dc1f"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef4fcbf3327382cd4c9f540babd61248208af7b93eec4de397b4d5f58a09e288"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd16aabe4a02a297c23417aa17ac6299dbd8c49f673bcd645b4929b11f5a4400"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:fb9e68df06293761f9fe66ade60a9bc6d0f5e42b8acf2939a9158af86ab0e5bd"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:59f63901b0031c3136cf64704dcb21de0bbae62ce2c9529bc39d27665463de37"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:304d5463e65a35d7bb0850550e0780395395f6fcf452f04db7d5ca7cecc425ac"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9cf9b1a857e25c4baceeb3624e92a56df3668f398c4acba74e174d81fb4d1d3a"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:114e4d0c92d618409ed82a99e22b5c5e768fe995f2973f78265f4524f49d4640"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-win32.whl", hash = "sha256:2625388c6c754520c37abaf3b41eb34d1cc4a373f457898f08606c8e362b891d"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:87e50a3e7cb90af586b6c5faf23e302a970415ac73bd7bd90a515a04b427ef96"}, + {file = "charset_normalizer-3.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:254eb48b9fa5ee9898a3c445825a1f340fe53712a098904b39b0bddba8ea3cb1"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc"}, + {file = "charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639"}, + {file = "charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c"}, + {file = "charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc"}, + {file = "charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8"}, + {file = "charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21"}, + {file = "charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036"}, + {file = "charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a3ceed0724d625d64b86ca20aba182e4df462e04c2414fc941c0f523f06aac"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0891b9d3903c5571c03771ca669a4b0ec5618ca722a5c957d3d29cd4e5062848"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fc14a032f813bf5fe624d991960ea83e9715adc27e4c1830a2361eb1d02ac341"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b2bfab86aa71ae13aa41a6a26aab338e0db2b8bc75434b05aea89e011ff35a4"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9bde855991b7e362c146535e3136a50bfaffc0487d38b33ca7e5edefc6e23849"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55ea99acb17b9325618de155a0cd6a2e8f5d10be008113e1d433bbb58db543b2"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:68eb192d85ab8e5f6ec69c2bc6ac0179fbf04a5ac1569d12fbef74883fe102d0"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:d913de495d90407cd859d263bee2e5d1a4ed3eb6573c04e70d9ec619a7cbed7f"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:3ddacd27458c45bdacd6bd6db644bfb730efbf9e830310186e3045c9c5be8fb2"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:588461c2e8384d309bd63e5826019b6977bc66d629b99ac8737bb795d7b2cb5a"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:e80e6c2f55656b4824d72065abb4ddd6a525c74bd78a0aab5d9fc2cf4fb5af50"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:d4a7319f304a774bed22115bc891618e45f85065ab44ea6acd07d274e750519a"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:fd1fbe0f116b6e55da77aca2c6ddcddcfac2186cbf78bdebf40fc156efca389d"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-win32.whl", hash = "sha256:93223adc95033dd47133a46ccfc316a0139176fd79085762e27202ec56018f03"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:15bb4005af6320d259dc7593ca84a38d7fe06a421dbcf7b910ae23979101e787"}, + {file = "charset_normalizer-3.5.2-cp39-cp39-win_arm64.whl", hash = "sha256:2cc961b171b3f3440f410489ab3573e86aea8736134ebbb40ea1338b7f0831bc"}, + {file = "charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685"}, + {file = "charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +groups = ["dev"] +markers = "sys_platform == \"win32\"" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +groups = ["main", "dev"] +markers = "python_version == \"3.10\"" +files = [ + {file = "exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598"}, + {file = "exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.6.0", markers = "python_version < \"3.13\""} + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "fi-instrumentation-otel" +version = "1.2.3" +description = "OpenTelemetry tracing for AI applications: tracer setup, span helpers, exporters, and semantic conventions for Future AGI." +optional = false +python-versions = ">=3.10,<3.16" +groups = ["main", "dev"] +files = [] +develop = true + +[package.dependencies] +jsonschema = "^4.21.1" +opentelemetry-api = "^1.29.0" +opentelemetry-exporter-otlp-proto-http = "^1.29.0" +opentelemetry-instrumentation = "*" +opentelemetry-sdk = "^1.29.0" +pydantic = "^2.9.2" +requests = "^2.32.3" +typing-extensions = "^4.9.0" +wrapt = "^1.15.0" + +[package.extras] +evaluation = ["ai-evaluation (>=0.1.0)", "futureagi (>=0.6.0)"] +grpc = ["opentelemetry-exporter-otlp-proto-grpc (>=1.29.0,<2.0.0)"] + +[package.source] +type = "directory" +url = "../.." + +[[package]] +name = "googleapis-common-protos" +version = "1.76.0" +description = "Common protobufs used in Google APIs" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "googleapis_common_protos-1.76.0-py3-none-any.whl", hash = "sha256:59e13344a9f3651aa201a03e2bee815a3bf43a4baf1f9ff8a9b62a840ce25fac"}, + {file = "googleapis_common_protos-1.76.0.tar.gz", hash = "sha256:71db0e44a1d4c2dd024ebad44ca67129cc1e2892e4861df466764749d5ef8642"}, +] + +[package.dependencies] +protobuf = ">=6.33.5,<8.0.0" + +[package.extras] +grpc = ["grpcio (>=1.59.0,<2.0.0)"] + +[[package]] +name = "h11" +version = "0.16.0" +description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +optional = false +python-versions = ">=3.8" +groups = ["main"] +markers = "sys_platform != \"emscripten\"" +files = [ + {file = "h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86"}, + {file = "h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1"}, +] + +[[package]] +name = "httpcore2" +version = "2.14.0" +description = "A minimal low-level HTTP client." +optional = false +python-versions = ">=3.10" +groups = ["main"] +markers = "sys_platform != \"emscripten\"" +files = [ + {file = "httpcore2-2.14.0-py3-none-any.whl", hash = "sha256:4c4f64f4b544afeb778c42c0ffb5941b29e671157e90ed3f6dc787c4bca90cd1"}, + {file = "httpcore2-2.14.0.tar.gz", hash = "sha256:4f57a1a8249fe6af589d935cfd456f1d13bbdcb0f0fc72af9142368fc94811d7"}, +] + +[package.dependencies] +h11 = ">=0.16" +truststore = ">=0.10" + +[package.extras] +asyncio = ["anyio (>=4.5.0,<5.0)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +trio = ["trio (>=0.34.0,<1.0)"] + +[[package]] +name = "httpx2" +version = "2.14.0" +description = "The next generation HTTP client." +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "httpx2-2.14.0-py3-none-any.whl", hash = "sha256:9d20c13a10bae1773a0be3b0f1e5beeb4bdd549bc3a2ba18efa32897c65403e4"}, + {file = "httpx2-2.14.0.tar.gz", hash = "sha256:47ad61a3c40282cd8d0dc96311531f00f5bfc71a066c6fe3b36d8f63fb9e4f6e"}, +] + +[package.dependencies] +anyio = {version = ">=4.10", markers = "sys_platform != \"emscripten\""} +httpcore2 = {version = "2.14.0", markers = "sys_platform != \"emscripten\""} +httpx2-jsfetch = {version = "*", markers = "sys_platform == \"emscripten\" and python_version >= \"3.12\""} +idna = ">=3.18" +truststore = {version = ">=0.10", markers = "sys_platform != \"emscripten\""} +typing-extensions = {version = ">=4.5.0", markers = "python_version < \"3.13\""} + +[package.extras] +brotli = ["brotli (>=1.2.0) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=1.2.0.2) ; platform_python_implementation != \"CPython\""] +cli = ["click (>=8.4.2)", "pygments (==2.*)", "rich (>=10,<16)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +ws = ["wsproto (>=1.2)"] +zstd = ["backports-zstd (>=1.0.0) ; python_version <= \"3.13\""] + +[[package]] +name = "httpx2-jsfetch" +version = "1.0" +description = "httpx2 transports for Emscripten/Pyodide, backed by the JavaScript fetch API." +optional = false +python-versions = ">=3.12" +groups = ["main"] +markers = "sys_platform == \"emscripten\" and python_version >= \"3.12\"" +files = [ + {file = "httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32"}, + {file = "httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60"}, +] + +[[package]] +name = "idna" +version = "3.20" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.9" +groups = ["main", "dev"] +files = [ + {file = "idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c"}, + {file = "idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44"}, +] + +[package.extras] +all = ["coverage (>=7.10.0)", "hypothesis (>=6.141.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.16.0)", "ty (>=0.0.37)"] + +[[package]] +name = "iniconfig" +version = "2.3.1" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.10" +groups = ["dev"] +files = [ + {file = "iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7"}, + {file = "iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960"}, +] + +[[package]] +name = "jiter" +version = "0.18.0" +description = "Fast iterable JSON parser." +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "jiter-0.18.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:74b8d31a39b9d22293c75bfdf0e6ab54d9dc16d32b540b2cb8f7c162961769ee"}, + {file = "jiter-0.18.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:77d61c53ab1732e84ad20f77c44bfc761183ef323eef84a59ffdd9201bd51386"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ea6d553fe513447a7a8ef6175aeacecd9a6dbb7f68f9215c751389c58e1288c"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7779088592f8994e021cd79b9b334f41363cfa10a654af9bd5dd82b99c80497f"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:879cf95bb0266643c1e8214be0862f2dd7186c9bb2e279f63d7b5fe099cb9a4b"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b291352b1f7dcf095b2a9d540777d59588c81685cc23f7c53f4356e07385e62"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a4ff2d7905b0f3f5c54b29626c7747cd4af3fcddfdedf0cce75fbd06b66e4d40"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:4d5ce30facd564d97aceb49013a02661daef1cf9c34ce322c1afbb841f1e5984"}, + {file = "jiter-0.18.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:131446a60b54ff9d4db62633a74189056387f6b2ad4e5171d3e7ed7977e31eb4"}, + {file = "jiter-0.18.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:389f5379f7cc5b09f6586db99bf91c5d828fac88f1a52fdeb4fc3b040c1dacc9"}, + {file = "jiter-0.18.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:db7804a8d3a433a3c5e08cd658ea69a6ee9a2ee43b756dd20048dae5a3d7ac67"}, + {file = "jiter-0.18.0-cp310-cp310-win32.whl", hash = "sha256:5c2a5dac57aec416140812f6d3824cdaf1da8a4f8f009ece64e50f507b6a709a"}, + {file = "jiter-0.18.0-cp310-cp310-win_amd64.whl", hash = "sha256:a447ed784b8013b518e0b1effe05424d5dfaa6974fed69aebdd4c1349d82fc54"}, + {file = "jiter-0.18.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:97cdff6fffc79d915e3d2691110e014f3f43c7529a73c0bfe8de63530b6efbd9"}, + {file = "jiter-0.18.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c938de3832ca88ca879bbf0c24673cbe0176b502eec8d2364f35c9edb9bdf890"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a41d8ef9f757fd5c11ce2fa56c9c4d008d857e97b6d0edfccbaacbd50830a75"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b2cad787346aa8f458ed6d5ecbbe3b6dd13d6d40fdbaa44980c9e29a8b536048"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3027e8ec2c86106bfd4b125af27aa6dd5eed2ab63427c35138e039931a98ba7c"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2485807c282b6df64d9135551c2d8e9ac2b098b4c85157979fc7ca8bd884a3b4"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55f808bce951fae459fc916359cc54097d386bef3e72265ddf02b39ba3275118"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:4656c4b24fd711d6caa61cb2fe895dcc55d0d6944828df23f2fb05504435204b"}, + {file = "jiter-0.18.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5893dc87a2a5297e271dfc5f8f710c3e61ebeb64c137a0b4b786d5bcd11c8fb7"}, + {file = "jiter-0.18.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:867a217d4a1857fba97c4cc5dc82a38ea257beee8c2a753b3d9b9310c01d12c0"}, + {file = "jiter-0.18.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1df7b0ce46d869c49c77670ba31db737d96fd1bd4ae44d790d33bb731962c994"}, + {file = "jiter-0.18.0-cp311-cp311-win32.whl", hash = "sha256:b8b97658b0914e90a352a9a1d515e597bcc89c88514fe4bcb4e37fa2a2fbaa29"}, + {file = "jiter-0.18.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ad1a36e3d5ebbff515b85468d8e279b336eaa326953b1b36fa21d5e2b8e8f9d"}, + {file = "jiter-0.18.0-cp311-cp311-win_arm64.whl", hash = "sha256:908f310576554379becf2e8c7730a8962693ebfba9395a54ef3c05c57b1cd9d8"}, + {file = "jiter-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:77a01cdf4381a1becbe5b827f682006f47b712581667451c5b1eb259b9ae7041"}, + {file = "jiter-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7b41cd64ee6b54db94bea6274e6e37002ed526aa06c114a8be6f36ffe21c184e"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7424194e68ef44e94290961f59319850d7ce11a329a3957f91709c15ded6618"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04a484fce032a8b2c21dec0410a805d7b16573eb34297156a3b4d242c507d2b4"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:860ac97858116bda0ac02ef5f50c541fc1a84ad7b9368cac68d4de5697a9012d"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39ef656cf371971486ec545ca0ae2da8d037d5479bc906121e3e46de86ee73c4"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c741e6b778c951a6861964ee475118812a33208426c54fb92bf4e318bda834"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:1277ac083a58d2f49a24ff9a28fd9876a6443a1992d4467a1db80fb45e354b18"}, + {file = "jiter-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ccf224d2e706be81d464b59c2bc3f98ba65d12c092c1789e625127e64488944e"}, + {file = "jiter-0.18.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5c7fc8e5357d1ad082bb177be71e398fcd3d458726439255ca5cb0d706060269"}, + {file = "jiter-0.18.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a6bba0404b46157a651d1fe512cf2c59c8e42836a9284c35cdff35310758ba4f"}, + {file = "jiter-0.18.0-cp312-cp312-win32.whl", hash = "sha256:07ae058bc052ead609b49bbae78c01bf4dee8f5f9d21705cbae9bfe59b33efc9"}, + {file = "jiter-0.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:79d1fe529bd7065c6f3f50279a08c2ab82eaa0631a6f5dfafa9c65105eeaaafa"}, + {file = "jiter-0.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:1f8b3b3d8761dee3cddcb5d3e99eaccc0155bbefc345affcdedcc758a4933a1f"}, + {file = "jiter-0.18.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1517648b5f6268513dea206241a99d9991d6ffcbdbc406848e77a7f02ed3ccf1"}, + {file = "jiter-0.18.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7161217e2190b9b2c8c79b81699be29d67010f6f77e09a53a3b62261792d5489"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9623fc90f1a4754452a525383ce70476476c16556098944709b8cdbd9ad905f0"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f9083a7c2a4ee6358bc0401c46b4d5090f208f6fadfb6275c7b5fe3217e13506"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4632f5172800da4cd42fd53f4553c772acd08f1c33dd7ac135e29d735080fa0d"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c00b1f8fc1dd06c610305be36778b38148ed1e9a532bdd81189c3c0d9905c888"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e3350b7431f7b8315b925d9ca0f29a44e8fb6ed45c1fe552392cb6297966bb9"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:3b49071fb7917cdbc6d80c81a491c6ad146c1a8fd6cb3076cd3c1bfeb6e266f6"}, + {file = "jiter-0.18.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04e210f5ddcccdbde484821040216a112381e6484abc549c20c38e9698ab07ca"}, + {file = "jiter-0.18.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5b339f6ae14fe7be92f391cc65cc5c80ff76e8da76d63b18fc14664f09b7cece"}, + {file = "jiter-0.18.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:5cb43336244e063f9cc11e44730e4b92dea70c6eb9b649d268c5ebebc4bc7685"}, + {file = "jiter-0.18.0-cp313-cp313-win32.whl", hash = "sha256:9656d0e9001f69c4af6523874ff445ab4e5db7b835f59733cc5ff51e73a9aa57"}, + {file = "jiter-0.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f26198220165eb9627847401fff4d0ca8bebf3ef840a88c6312918d2291c33a"}, + {file = "jiter-0.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:bef1fe687dc6af17bef9f644a95d465f15f0efa20b743c858e0b6a14e2c0c73e"}, + {file = "jiter-0.18.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:248e939f67a9f8030e2624260a9f417decfe275af37aa96728d256468a9c4086"}, + {file = "jiter-0.18.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0390fa550fcafbf69fb97ccb287bd71192f90410a1c7dd600ca4000aa9aabcf2"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8013186f2b9a8c27ededa601050392527aa9d27ffd35d49aae424fbd2062f38"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd4316df8e2074fcf5173f6001f1fc9596e7c1e8c4bf499b02f9ebe92babdfb1"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a9e474da7a9f65d3b460cca93cc8a0f4ec0220d1fa41f1f7a3709195ead60056"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d55acd326db8ecfc94f21951abd20902c7939d35925444e48d94527e287bead7"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a01642d403b8925f2b1e1bb51b4ba49ece8a2bdc9b9560fc8ed0b1f2b35b567a"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:89ba6b674d4bd7290f9943bbeba0e1bf35955bbb1e07e41ba94691648cf133d5"}, + {file = "jiter-0.18.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:feadebdfee32c61e91066433f4aa74c891752e26e43032c1feef08dda6d9b6ed"}, + {file = "jiter-0.18.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:dd7e57efd54a3580620f635c48a3226f910e23649b7eb83ffbc6f0f3386293b8"}, + {file = "jiter-0.18.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:ea69e23481497c2143775a98d273ccc43de5c92a6387df18c903d2d37bc2b181"}, + {file = "jiter-0.18.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:d9b61af76a3cd90ad9656a331737d97dab8c05facb2d04cb41fb16c9adadc966"}, + {file = "jiter-0.18.0-cp314-cp314-win32.whl", hash = "sha256:fe42726d7fe171cd8fc1966d4457a6aae03bd408d519d2cc5e7726805460b51e"}, + {file = "jiter-0.18.0-cp314-cp314-win_amd64.whl", hash = "sha256:f1e738b851019d6bb6ff4a42c6319bdede967dec958ef3ec6feb7ab9d12408f7"}, + {file = "jiter-0.18.0-cp314-cp314-win_arm64.whl", hash = "sha256:80a961b1c5c7786bc03b332deb7f7ebe818b7baa6e26685e2bf480548ca128b4"}, + {file = "jiter-0.18.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b066f37dd9ec19fc7931d79dee38f56b6f849217bbe824a7dad4518ef96ee515"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccdc09887b04f50f1761eedcfd19da882d9d834096bc1215049af637023f7db7"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6133abcd0f332964fbb8145adb1ce775cd0312c9eaf6e4bf26b7a5c9b6f7cca7"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ca381b4a466023d1fdd04c889c759b46f7d9654f622b28bb01e65abf31d07bba"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b961fedf589ffa182fe302fc4371acf4606d3ed4a6a48a151fbfd724d811f5a"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b77eabfbae1ac47872be0076899e66340bbef39b862971c3d6c9a4b7c91fd10"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:92a16933d0fa852133500837d33cd6a4f75e4414d77389c58269e12bafc2ee02"}, + {file = "jiter-0.18.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f7ba518893a4ccef5afb38e41bc3e126bf652354417ec4e75e5a5b000fb1ef6"}, + {file = "jiter-0.18.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:04d67a44b040a6662a35edc9869030f7aa566bf5baaf3549c99d847aa44213e2"}, + {file = "jiter-0.18.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:e4d4819398d5330636bc0b91ccc0048dba782076fb99257038257ba6f121c840"}, + {file = "jiter-0.18.0-cp314-cp314t-win32.whl", hash = "sha256:c435e795a7ea4b372166a058a5b49a25caeb9c94e469a1414868b14c83ee5c41"}, + {file = "jiter-0.18.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5a3d5397da7ae46c7a9601ef02d2c9ec47a6c3abe15e1ea940eaf93e675ee20e"}, + {file = "jiter-0.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:4b81b474e4a8ec745ab20a6762275a360e1147cb70cf08872ec14e1aa5debc37"}, + {file = "jiter-0.18.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:30f8ae18425e0247ffff4e4a5753ec1952e1b81ed4e7949b84e5ecfaf8315833"}, + {file = "jiter-0.18.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:93150a3bb0317d8f5a94d4c3ea68db1cb434b94ac819e08c443cea97b7645f2f"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9c8a61d6227cdcb0a67c678f30a020837c9f3dd7e0b3f916781defa157e4eb9"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:285cc15ff9ffcd4ce7f0b9ce02fcbc65e22fcf7dfbda1a3d71ccac8d7b73f8a1"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8f69ef2e28f8c1759bc1522385ab3e4ade0b1056053cecf67449a947c4525a8"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eec2da60423287bd60377b0fad1723560dcc51cfb2b99615be8431ad425c4438"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5db2cdae6a2f01e8f52ab2154886dcf5bb1844b4f31245440bf623ec91b65b08"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:029da1f29852beac2f9001f20209b73b29b4d7bdc748c7f8028895769e2cc0d8"}, + {file = "jiter-0.18.0-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:67c6662b1b7e5728a507db06ad1b8a7ff8ade04c2a74f092d467209ef744d3a4"}, + {file = "jiter-0.18.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:4db12daef4a231df528a16f70d5ff7f5e3be21f70e8ad904e4c61442366e8a10"}, + {file = "jiter-0.18.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:4654ea93f525ea96adf289afcf1ead32d773b8325ec326862b4f81f5f4570835"}, + {file = "jiter-0.18.0-cp315-cp315-win32.whl", hash = "sha256:f035d01b450ac4e141502f1ce142462cee638198ff5a0237c80e6683798b3b87"}, + {file = "jiter-0.18.0-cp315-cp315-win_amd64.whl", hash = "sha256:4a18ef4fe95685b000d95eca797cc683e0c178a4b364f2e39f6c79ab107a26e6"}, + {file = "jiter-0.18.0-cp315-cp315-win_arm64.whl", hash = "sha256:c73922e4ff4b1ad2929cd795c98223c6688a43c5fd42e9deb8955e4d43b00abb"}, + {file = "jiter-0.18.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0ccf55f6fcdcee82fe40ae617e9d64b8e5f433fa6cb5bf7d2969e584e6df0e5d"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:163a55e77f8e92d739b1f4ef212f1d445ddc58ecdf0da1feca44ef424b5331f8"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9de6c9133be12a51ea2d8c270f39a04ed45ee369802bb6270649b952e6cec256"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ea4f2ed18eba7454182d4ff727444788ae51ad11bf5a25ad892f5f0ad3e754b"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:626d5c9fb8b57babc6ce9d03224846ecb094e1d22ff5bff6080398e7f8aee162"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3c3318cc6ef857b6554b43479c30e8249fc143189d500d4137cde9c58412e6d"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:9a70f25f6de76a01e309e109c9bcf2143c5c126b3488dd17a25c7aa404b28f16"}, + {file = "jiter-0.18.0-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:22d8dd757e603224e46786d63cb7d7bfbddc8f579a02e7b082840468d18c06f3"}, + {file = "jiter-0.18.0-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:552a8714f26ddcb43115c82da6d045b3b9f2fa5997d8b21b2f8ec3721503bebb"}, + {file = "jiter-0.18.0-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:8060a206e290410d3bfc3bd91715f3ec90a499246f8335d48927e0b3b6a6ccc5"}, + {file = "jiter-0.18.0-cp315-cp315t-win32.whl", hash = "sha256:91d463858f11ee76ce8e39f391bbcbf1d4c3cc4703a1496fed3a5666dcd5e01d"}, + {file = "jiter-0.18.0-cp315-cp315t-win_amd64.whl", hash = "sha256:6ee49daab0b826279c152ad8d61171ea17f4197f91a5e14251d0d5d4adf51059"}, + {file = "jiter-0.18.0-cp315-cp315t-win_arm64.whl", hash = "sha256:bec676a0dc24d4dabd4bdfb3d1f1bf80d4d3dd892fc5c5b3f8f953e2459dbfce"}, + {file = "jiter-0.18.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:04aa358fd3217dedd673e9331febe8cccfa4a00382e5372b39efcafe7447ff63"}, + {file = "jiter-0.18.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:f5e5d58f589412c7774b3a2c4878b8ee54f9804840075822ad2bd2356a5080fd"}, + {file = "jiter-0.18.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df6d792b41ad90783cf9c3c8f66b02f06025250533b92997913ec600bcb0d075"}, + {file = "jiter-0.18.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f39e7316ee0f16a1e74f23010a058e2bd59481992c7adec0470db4ea57a38e5"}, + {file = "jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:118c1fd995f349f1cad0557f31d6860f336b4aeef7f002dedbc068027f68e2c3"}, + {file = "jiter-0.18.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:44d0d719cd7845e66b01a0cf346ec9882073e710a05e89a5b6d87be47a9dc69c"}, + {file = "jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4d1d2dc4d930ebc225f488b6b3790acebb2e51b3a165a4a42cc1d05bb927f83e"}, + {file = "jiter-0.18.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebb0c346b6c5d9c033fe9e9b6ed6a1ff6dac0288fe681c3434dde6eb9c264fa1"}, + {file = "jiter-0.18.0.tar.gz", hash = "sha256:a0ca63fd9450a212e4e658d4cfe0ab4977c4f9b0003c68828b843c65e27662ff"}, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce"}, + {file = "jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +jsonschema-specifications = ">=2023.03.6" +referencing = ">=0.28.4" +rpds-py = ">=0.25.0" + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "rfc3987-syntax (>=1.1.0)", "uri-template", "webcolors (>=24.6.0)"] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.9" +groups = ["main", "dev"] +files = [ + {file = "jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe"}, + {file = "jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d"}, +] + +[package.dependencies] +referencing = ">=0.31.0" + +[[package]] +name = "openai" +version = "3.45.0" +description = "The official Python library for the openai API" +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "openai-3.45.0-py3-none-any.whl", hash = "sha256:b63aa90e3b7b57b501f2bba231a17976618aa133f457562ad84a5c6431fd0425"}, +] + +[package.dependencies] +anyio = ">=4.10.0,<5" +httpx2 = ">=2.12.0,<3" +jiter = ">=0.16.0,<1" +pydantic = ">=1.10.13,<2.0.dev0 || >=2.4.dev0,<3" +sniffio = "*" +typing-extensions = ">=4.14,<5" + +[package.extras] +aiohttp = ["aiohttp (>=3.14.3)"] +bedrock = ["botocore (>=1.40.0,<2)", "urllib3 (>=2.7.0,<3)"] +datalib = ["numpy (>=1)", "pandas (>=1.2.3)"] +realtime = ["websockets (>=13,<16)"] +vertex = ["google-auth[requests] (>=2.36,<3)"] +voice-helpers = ["numpy (>=2.0.2)", "sounddevice (>=0.5.1)"] + +[[package]] +name = "opentelemetry-api" +version = "1.45.2" +description = "OpenTelemetry Python API" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_api-1.45.2-py3-none-any.whl", hash = "sha256:2cbd737377e710ee740d261c94e93fa0f08e6d037c18f17513cc0a2d94479a34"}, + {file = "opentelemetry_api-1.45.2.tar.gz", hash = "sha256:d7b0008e21e5fd61cbe7a7f34ca3b6905a78ab677d9bc395e299359c75cda6b4"}, +] + +[package.dependencies] +typing-extensions = ">=4.5.0" + +[[package]] +name = "opentelemetry-exporter-http-transport" +version = "0.66b2" +description = "OpenTelemetry Exporters HTTP transport" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_exporter_http_transport-0.66b2-py3-none-any.whl", hash = "sha256:fd5f5b490c099acda1cd7b909d5e8981436bf18cc8c6098d302d114c271720e9"}, + {file = "opentelemetry_exporter_http_transport-0.66b2.tar.gz", hash = "sha256:66d6ed810a515432c8891da9a834464332fd70badeca45bdeeae81b4280c903b"}, +] + +[package.dependencies] +opentelemetry-api = ">=1.15,<2.0" +requests = {version = ">=2.25,<3.0", optional = true, markers = "extra == \"requests\""} + +[package.extras] +requests = ["requests (>=2.25,<3.0)"] +urllib3 = ["urllib3 (>=1.26)"] + +[[package]] +name = "opentelemetry-exporter-otlp-common" +version = "0.66b2" +description = "OpenTelemetry OTLP HTTP export utilities" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_exporter_otlp_common-0.66b2-py3-none-any.whl", hash = "sha256:ace86efb75489f925f1ef809856ae5f0c7db534e4afdc624530222228b1236a5"}, + {file = "opentelemetry_exporter_otlp_common-0.66b2.tar.gz", hash = "sha256:06f5a9b88638e310efa1f1d206cdf6b75393e112aba4e174a963416192bd1028"}, +] + +[package.dependencies] +opentelemetry-sdk = ">=1.45.2,<1.46.0" + +[package.extras] +http = ["opentelemetry-exporter-http-transport (==0.66b2)"] + +[[package]] +name = "opentelemetry-exporter-otlp-proto-common" +version = "1.45.2" +description = "OpenTelemetry Protobuf encoding" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_exporter_otlp_proto_common-1.45.2-py3-none-any.whl", hash = "sha256:af483b24217028892f017096731b794b196b785025d2e6808874720fd0b05a80"}, + {file = "opentelemetry_exporter_otlp_proto_common-1.45.2.tar.gz", hash = "sha256:f1f2806f3f28ce7938033823e50934fcd91595a39de38e69a28a51e19f40fc6d"}, +] + +[package.dependencies] +opentelemetry-proto = "1.45.2" + +[[package]] +name = "opentelemetry-exporter-otlp-proto-http" +version = "1.45.2" +description = "OpenTelemetry Collector Protobuf over HTTP Exporter" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_exporter_otlp_proto_http-1.45.2-py3-none-any.whl", hash = "sha256:6e4d025138829d0ee57946930c2ccad6491ad4d92a958e9c7eea69278fe60cfc"}, + {file = "opentelemetry_exporter_otlp_proto_http-1.45.2.tar.gz", hash = "sha256:5984a3fb46bc4628e4e2b85d4a6e72637e03962aae6cf372791137768a4ad939"}, +] + +[package.dependencies] +googleapis-common-protos = ">=1.52,<2.0" +opentelemetry-api = ">=1.15,<2.0" +opentelemetry-exporter-http-transport = {version = "0.66b2", extras = ["requests"]} +opentelemetry-exporter-otlp-common = "0.66b2" +opentelemetry-exporter-otlp-proto-common = "1.45.2" +opentelemetry-proto = "1.45.2" +opentelemetry-sdk = ">=1.45.2,<1.46.0" +requests = ">=2.7,<3.0" +typing-extensions = ">=4.5.0" + +[package.extras] +gcp-auth = ["opentelemetry-exporter-credential-provider-gcp (>=0.59b0)"] +requests = ["opentelemetry-exporter-http-transport[requests] (==0.66b2)", "requests (>=2.7,<3.0)"] + +[[package]] +name = "opentelemetry-instrumentation" +version = "0.66b2" +description = "Instrumentation Tools & Auto Instrumentation for OpenTelemetry Python" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_instrumentation-0.66b2-py3-none-any.whl", hash = "sha256:fa9ccfdab147a14af8107d19ef0a7b5015675273c5adced7a1fc38f28b42ec4c"}, + {file = "opentelemetry_instrumentation-0.66b2.tar.gz", hash = "sha256:02b094150e53b76f5906d75e628dbb3833bbc6e62fa109b5c7ba0c081865e923"}, +] + +[package.dependencies] +opentelemetry-api = ">=1.4,<2.0" +opentelemetry-semantic-conventions = "0.66b2" +packaging = ">=18.0" +wrapt = ">=1.0.0,<3.0.0" + +[[package]] +name = "opentelemetry-proto" +version = "1.45.2" +description = "OpenTelemetry Python Proto" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_proto-1.45.2-py3-none-any.whl", hash = "sha256:03a7ca1b43f89fd5b965d5975902bb2515c0c86e2428b456836e9a6149c6235a"}, + {file = "opentelemetry_proto-1.45.2.tar.gz", hash = "sha256:bd8d23cf770605b0af9b7be2071d26a464fea289d35429abfd2a66226114ad64"}, +] + +[package.dependencies] +protobuf = ">=5.0,<8.0" + +[[package]] +name = "opentelemetry-sdk" +version = "1.45.2" +description = "OpenTelemetry Python SDK" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_sdk-1.45.2-py3-none-any.whl", hash = "sha256:ff974ea70ee4f1d51e2ec152db37c2b626c7bf82bb3f7d86114fd8704e7199c6"}, + {file = "opentelemetry_sdk-1.45.2.tar.gz", hash = "sha256:7eec4de13dd21ff3a1670dcb0e02079e692736f94d733dfdce5af461d884248d"}, +] + +[package.dependencies] +opentelemetry-api = "1.45.2" +opentelemetry-semantic-conventions = "0.66b2" +typing-extensions = ">=4.5.0" + +[package.extras] +file-configuration = ["opentelemetry-configuration (==0.66b2)"] + +[[package]] +name = "opentelemetry-semantic-conventions" +version = "0.66b2" +description = "OpenTelemetry Semantic Conventions" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "opentelemetry_semantic_conventions-0.66b2-py3-none-any.whl", hash = "sha256:4cbe61e5f9275d57ab31708446e7938ef4291ebbe6a7fca6f7a629c5acae87d8"}, + {file = "opentelemetry_semantic_conventions-0.66b2.tar.gz", hash = "sha256:7da5f1a5dc4383eb66711d4d3d3e71824d9403ac1559fea021cc103c1a4c4976"}, +] + +[package.dependencies] +opentelemetry-api = "1.45.2" +typing-extensions = ">=4.5.0" + +[[package]] +name = "packaging" +version = "26.3" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.9" +groups = ["main", "dev"] +files = [ + {file = "packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c"}, + {file = "packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79"}, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.10" +groups = ["dev"] +files = [ + {file = "pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec"}, + {file = "pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8"}, +] + +[[package]] +name = "protobuf" +version = "7.36.2" +description = "" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "protobuf-7.36.2-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:cbc70b17ee27e28894c7fee8bb04be1abead49e936bc70eb60052531eee2079e"}, + {file = "protobuf-7.36.2-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:e11e1f0180583a2af89db6a2ecd9e8dc40aa6d2988ca175bfd0e6d12ea72d74e"}, + {file = "protobuf-7.36.2-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:f4fee11ec330d238b34a05c9b675f693c20415d1c5bd7d5320cc2f8a798eb9cf"}, + {file = "protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2"}, + {file = "protobuf-7.36.2-cp310-abi3-win32.whl", hash = "sha256:912c1221170e16c08d1f086762f563dd61ff83c18b5fa6652952dfaded66f728"}, + {file = "protobuf-7.36.2-cp310-abi3-win_amd64.whl", hash = "sha256:a300819d441e078a5608c0d3c709796bb548136058fda017ae51d425b44fd353"}, + {file = "protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e"}, + {file = "protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb"}, +] + +[[package]] +name = "pydantic" +version = "2.14.2" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "pydantic-2.14.2-py3-none-any.whl", hash = "sha256:7efbf7507b937931cd32a5755acb00ea1cf5ccb1d4e8067a5850d5069e382118"}, + {file = "pydantic-2.14.2.tar.gz", hash = "sha256:fb7b2db6cefe8414dd612edeede49c4c433acb0432b0f92b95024e45f66c505d"}, +] + +[package.dependencies] +annotated-types = ">=0.6.0" +pydantic-core = "2.50.2" +typing-extensions = ">=4.16.0" +typing-inspection = ">=0.4.4" + +[package.extras] +email = ["email-validator (>=2.0.0)"] +timezone = ["tzdata ; platform_system == \"Windows\""] + +[[package]] +name = "pydantic-core" +version = "2.50.2" +description = "Core functionality for Pydantic validation and serialization" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "pydantic_core-2.50.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:6258754c473b3045a7aa30b833a8a331a1ab36c6147cb230789861d80bb26f83"}, + {file = "pydantic_core-2.50.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a786cf782ebb2e45a43c7118d75d452aac982b79577dfe804d8dbf2878f0b589"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:ea71b94a2eb5d2fc102926321f56d2ee8eddfad2673eadb1d23e9f287a492715"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:71615edeaf1ae70f5f3f558426072eede0168b7e5190fd9633878e29a0b85732"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:1a5e859f5a8a6d834b0a13acaa0eaddf1a9b4b015fcda13bab7b471e18299d32"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:d71a9a9352acbcb5c73d39dd003383599428067b6eda5cf7c5d335a7a0da37e1"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:bf7f99a0e6616cea754e2334d129091f3260d011369d9b8c658522bfb2427619"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5c12a5a080570a91bbcbf6d10db008b80e3f5dea015ef2f0137bbec70f24f3f3"}, + {file = "pydantic_core-2.50.2-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:89213368eef163350af37127939ace099010e8102757905c3e329f1175950ed8"}, + {file = "pydantic_core-2.50.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d93c066a38f83376b5bc020e563666784d1b680a70d6ceb625fdb541af7a312e"}, + {file = "pydantic_core-2.50.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:eec187d2876abb6a74203efbe2aa796455c1809334acf4e739dde35da8cfb69f"}, + {file = "pydantic_core-2.50.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:701bc55d08c22f981973ca4f6fdf4ea102ee1ee3a21b818b66fdb161ea711a4a"}, + {file = "pydantic_core-2.50.2-cp310-cp310-win32.whl", hash = "sha256:7f9821dfc0c473c96ad55ce4189c7cb4f9c94e7d4f563afb874173243dec1162"}, + {file = "pydantic_core-2.50.2-cp310-cp310-win_amd64.whl", hash = "sha256:3939538e640c94ab779a05f2d45dafedd01d65d93e1290797f3ac5b59fcb6455"}, + {file = "pydantic_core-2.50.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:2115d7ca6d58554af8a14da3dd32d361a4fe999fae52f115a6155679b5b00e72"}, + {file = "pydantic_core-2.50.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b2dd65864aad38dbcc57c3d0e2c978d4286e063378137d8fc0c9fcd558943285"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:26b778d4ebb75f181d36220ff0f54a513fc46f053d9b09ce79993c2f00bc45cc"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e80c47314c7233e7105a7efcfffd89d56e479e558189d1959eeeaf2639a27680"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:3bfe12243b3ded517c6734d91f127489e2f51bf95cb533b53130fe360333db80"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:01eb0282d0b3a065d55956d1be9ce398c46db3dd6d277a6cb2358c8aa8c53179"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:196b87b48b2695426920e8470d20f9e99f019ebd86f15808aa018b68086840cd"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:86e7abd24a67f61a4bfe8df059b67a2bdd8bf33705178e98463195d140bd3780"}, + {file = "pydantic_core-2.50.2-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:aff31602e8518594e6f6bc670cdb27e37cb7dbeb2d5d0b76a7707b70fe951ddf"}, + {file = "pydantic_core-2.50.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a88851e8e332588cb8cced8b5318d1163c7d0bb87830aa8dcafbc4ae9602b73c"}, + {file = "pydantic_core-2.50.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:3b1bb3950e0794a795c9344d818d5b476189b0c9c9755e8eb8fde87c3acee17a"}, + {file = "pydantic_core-2.50.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:928a44ad1e21a7e923eb924d601605f0694cd187d2ce5d40bf7ad76650f4627d"}, + {file = "pydantic_core-2.50.2-cp311-cp311-win32.whl", hash = "sha256:9a87744e683d9a13f60b7fa5242c17f8d283ffa94ad727cb19063b48c3d34960"}, + {file = "pydantic_core-2.50.2-cp311-cp311-win_amd64.whl", hash = "sha256:b958c217c6e56bef261f516e4caf5d490b079ad6a428752afada5a764cca6c71"}, + {file = "pydantic_core-2.50.2-cp311-cp311-win_arm64.whl", hash = "sha256:b0e6a2152706d84f7da8b9d34dcecc7e9bde678af32c40bd5b405f427ae0fbdb"}, + {file = "pydantic_core-2.50.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e3d824b6152e1c0fd58dc6266f2de470eb7b2286135294f5f7cd26a0f0693738"}, + {file = "pydantic_core-2.50.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:596921489390a002d6a5e303384a0f1f98384f8bb550fbf38a1aafa6093da0f9"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:36d8b9725684ca3bf658b90a101d335fc8cae405bb22196b7b5ef41344913756"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:43a8fd56f3c681f3cda2d5c842ad28e88241df742dfcbe8fd1dd437a3056e1f6"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:6f5a432c6c1ef18a1a02a04b3616b8d3f2f88b13faa46caae1ac6559ab202234"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5d3cd8be71c4da3c9b42cc92f17e5e3036bdca98bf18555a0e072c3fe87abbb4"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6a438cb8a3f87f2c49e82e43fb19511d4d5043f53e0787dc4df937ccb904373a"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9667637665acba166a7dbbc786f14c50512d3a01f7199e0e1a13b929e92d7c7a"}, + {file = "pydantic_core-2.50.2-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:b3e681208e2d39fde13fbea449ef2736a85ec1ea2afa41e9193a8c536e71dafe"}, + {file = "pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:6eb6ff07964f39e33c6f57fefe939514e76b8c0d4a694e5663e2e04e80cc1798"}, + {file = "pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:4eb54c25e3463d73e1e4ed439ffc45d1d7e590df40bc7bb06f11a906afd996c3"}, + {file = "pydantic_core-2.50.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:91238117cd296352f54f24117ff5a227bdea428865dba1244aa0cdd1424c0bc2"}, + {file = "pydantic_core-2.50.2-cp312-cp312-win32.whl", hash = "sha256:98722314e12a8e4fa346e0afd3fff2098b5732875ff45592b450a7b589b43c4f"}, + {file = "pydantic_core-2.50.2-cp312-cp312-win_amd64.whl", hash = "sha256:b381574614245f18fdb2d6d1aa8f149e225869c47b5ee7f81812de8977817314"}, + {file = "pydantic_core-2.50.2-cp312-cp312-win_arm64.whl", hash = "sha256:f07c965a8aa6d62145f122641f292129984f39a3e3697585b19298a1488287db"}, + {file = "pydantic_core-2.50.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:93eb41d626d9a2749a678823c70bba8c25033cef474ae8001fd7621adbbd8437"}, + {file = "pydantic_core-2.50.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c539d452cba22f250103c7d1c00cbe9038eb705e657476e701c43374efd9f2e"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:53bd25e8ab54c02bb4c55d4848c1d36f75f3b9a7356e83179fe27794d9e9e6c4"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f142cd663d1148ed32993ed9a58e5c67ea312f446a01a6c13a956945aafc9f23"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:126f158474346f457c0759c29c1a6334acd5f7f99dd272bb27d19314f3d81b4d"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0b94a515f44f1ebcb25395bcdba506c4cdaf6d3fcb0466b9658521b41e5ff057"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a55c1163e829a08707b4a92c8ee02a5a3a3847ced74aa4da94e3e975ffe1ec63"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:31a1fb3ffbd1195b24490f671d12623dd4c9bfa56d6af0a299fa43b516134f5b"}, + {file = "pydantic_core-2.50.2-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:83d6f42ae6eba44548a1a3d4f900a5b1500fdd14f09f04754a8800ab0d544432"}, + {file = "pydantic_core-2.50.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:9fcde11462e0faab4c2a2ae8cd4516f7dd8239eec583bd88c5524d8064ad2d0c"}, + {file = "pydantic_core-2.50.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:848984e231190ae49bc8b5229e64d2a6fba4231dc6046e1b6b28ddc060bc7601"}, + {file = "pydantic_core-2.50.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:8772c2c0091e6fc2d0499151793d31bf811826986b0727052935a95104845544"}, + {file = "pydantic_core-2.50.2-cp313-cp313-win32.whl", hash = "sha256:bd6ecae08c0d871cf93b6f0d4ee76b06c65be44ea22311981a022b2f1948cf9d"}, + {file = "pydantic_core-2.50.2-cp313-cp313-win_amd64.whl", hash = "sha256:e5c801bdf3cc92274b8fc2c7023c8751e5ae81260c009ac558ff55ce712a2d45"}, + {file = "pydantic_core-2.50.2-cp313-cp313-win_arm64.whl", hash = "sha256:fd9aa71a800c87c0f7ab53fa38009169a23a82c685989626ca74a4bd483e1b67"}, + {file = "pydantic_core-2.50.2-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:efad0bdc67d3b119c3bab6b94d341a27333c2bb89ed75dfa182a4a06cd0ea329"}, + {file = "pydantic_core-2.50.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6ffb4dce3ecb2cd563aa30f9eb5088a1cf1f4f688b90cbb374fa96e49fc50b02"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:150f6e101f575c21a4ecfed1be1c05bb89a0ad49cb9c846ed377583bd71b32c2"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1db9cab6197e797824f0479dd2ae5fd2e272aa61c61b7faa5a6e450ca7a0d3b7"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:1b9f652e17a13bbc09b45f74c3c326cca72059ce4dcdef687fcb04389db413a9"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:823b222c4fc861a82c650998a6117ecbd150cc71bf8b78f9a31bf3f48c456108"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:783abdfac21247d33bec40aa683d26bba30d61655c40de38b2decc4797aabf92"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b29b7c5adf4b2be7c941f7f76432aa3269cd5052ff8610376b8ece24d7b02c51"}, + {file = "pydantic_core-2.50.2-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:4ac996e42a93d80122a23edce44e02c6b9c4913f5c6198a077da31475341a39a"}, + {file = "pydantic_core-2.50.2-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:99e1d482138a71902415ba375bb4627679a5fefd3bd07803c3a8f37632f4981d"}, + {file = "pydantic_core-2.50.2-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:a53d5f11cd6d15569ba3e53f3498077f0d5e633f6ec604d2ea613e895017ebee"}, + {file = "pydantic_core-2.50.2-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23385c4626f8b5a7792aa381ea573d9432cfbf4c21375a0a5eed2a4fb64e0e58"}, + {file = "pydantic_core-2.50.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:9a8a62281fd9c6a373b3fd3d473685e6838d43341eecde5f47729748e2c11ee3"}, + {file = "pydantic_core-2.50.2-cp314-cp314-win32.whl", hash = "sha256:18f008ef58cd30782f81b6e0119e20b7e884edcefbc2d370162ebe033f6e5c99"}, + {file = "pydantic_core-2.50.2-cp314-cp314-win_amd64.whl", hash = "sha256:b62c89545d21d930c333208fd548e7b4f262228ba3a322fd75c987a75ab11f31"}, + {file = "pydantic_core-2.50.2-cp314-cp314-win_arm64.whl", hash = "sha256:6e731bf5a5e8e25398544d7709e39068ec4230b0177e4db7fa955692fd415ba3"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:33c6800ab9563adaa0d7893e9cd8f5b972ef1e6a23df70498e05c24f3fcec5e1"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f81df206b937d0dca5efb38c25fc99037d82dbcd3740e34c3f81997d2322ac1c"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:21ea3b00f1e87c66f3f9e92f9f6fec20495ac0e60d7d2e68ba1fc49739d7cf40"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9eff570402175c7d5fff8497d5a9c05580664a79bb66c07b8f205d17f69e580b"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:240fec32a74af0979f7253532859b3fd209ad5eea822416bb010929dba445c3d"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92acf02c770b9d5c4e9a3e8d64e9d95ae26456a86ebb7b7cf64a97f899e5871b"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:1ac5b99bc7b0a68ec64f5f75a6828a7bab5535c8df0cdc07901deb50e0815910"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:713d7c33c0e231e3786eb0ec95885814dd65d5f3a09754399b6acbf5e9365f11"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:61e13100b30d8d25fc0d1f0297014b32941bf0975a3584bd08f3adebb68d1ead"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:523fe6574aea50f456cbc301c1cdddcbf237939f7657f9af99b4f0f71942b59c"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:6c25b8826be85714b27dafe908d3461e1b09e3e31c0279a7029040c832c781ef"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a59db03b80a156a6fbeae41096866d1cb89cdf31031ba44c768a804538880636"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-win32.whl", hash = "sha256:0d090ae76d5b09c003600c7779b3adcf3d1b49268f616c5c51d844e54c8e318d"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9b01a092955c1c7530196ad526755cff4f2d11f37ca9a6fc9ebe37ca49a48977"}, + {file = "pydantic_core-2.50.2-cp314-cp314t-win_arm64.whl", hash = "sha256:4ea01f30e119f1ec7a2034e85c40f491d469896aef02cd6436fd9292fe1be3fb"}, + {file = "pydantic_core-2.50.2-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:a3317630e2791f56071b82f89bb71624146125e4311e6643f708c6ba744b5ac5"}, + {file = "pydantic_core-2.50.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f73930dacad5e611fe019e18df6f53c30629b1843d038d303b8dec86a32493bd"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:e2e6240a0a5ad847017b3d65187877fdb7a11d5a58d43c30736f9f523478913b"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1fdf5b52ed22f1404c2433d0b46df2d86d9befb742d0b9b4042a2325c43cdb97"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:4e9392ddf67fe97ab9889f796d468c9908a8754b8b6c7520eb03a65012b9a1e7"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:48e944091b7bff233920bed8a60b0ed6c96c73d3c5836bf51c4b9a4bfb58e4ca"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:91c92856b846aa690ea6239ffd6c5003c5e3e296a69095570bf4efee5bfa0bdc"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5299296ff5cafcb69851fd652de8f9268a0bb036bcbedbfcaa94cf743baf3986"}, + {file = "pydantic_core-2.50.2-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:d3d049b557875f9d15230eec8a731749a7a873d8ed6a051903b05bdf46e0e65f"}, + {file = "pydantic_core-2.50.2-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b0b25d647036972c2951059046cb498f72b7af5a2def27bf8e5f44c3067ab7dd"}, + {file = "pydantic_core-2.50.2-cp315-cp315-musllinux_1_1_armv7l.whl", hash = "sha256:8835566b3e94026da3ce2249f9ee35c9d2ebe4cd131f6a39bfc82708d3010a46"}, + {file = "pydantic_core-2.50.2-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:3fbcd402e4b607d4b8de5d4591215f31f042af03f9d09e58f693a6221e32833f"}, + {file = "pydantic_core-2.50.2-cp315-cp315-win32.whl", hash = "sha256:8431ecb131489cbdaf6f51f7ade47475f73aff4f1912552f75ba19a6cfe233a8"}, + {file = "pydantic_core-2.50.2-cp315-cp315-win_amd64.whl", hash = "sha256:04cf672960b8c4fc28bb159c8cdd101fbd311c520237a5c0360448b851adfb41"}, + {file = "pydantic_core-2.50.2-cp315-cp315-win_arm64.whl", hash = "sha256:36917e29c0b815d6b940bc91560fcf453b5b85d55c579796373f0ea11d1c111a"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:bd1fe69056a19c377a6c6de2c1240fb8676ba0512a969965efb486510c5e0f1f"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9b2383933b1dd7a8c93e02f99ebfd305f1286057172483b8e6898bed3fef69d3"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:a1b4d60bad57d6e0e7cd30cc4d1dc646d258dd6dfb7935ce76c7dd72dd1e98b0"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:93bedc68c4138088ea3c042189c01d2945f530f0dcc36e1ea02df8418bd4f1cd"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:d684ff87d00de2f6abcbbfa9b0fdce8b513dd799a900809dcfa7eb62ad69832a"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bb6d49f00e2babd40af4889d6b9f4bf50879f522dd4e2e22cb705cac5e0c5e8e"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6d47b2d0e00e030e0ebdb08115a37da7294e7a6d196d134a77ed7ee6c142284b"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:95838be125133fa314753f8cc5168f7c41e3a9dd5eef5383dbbbeed511bd4853"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:2d4a043c820363359e40ac96270e1915e5376e116be1f59cee0701775de3e376"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:57bccd3e1128736c792094da1feac6da46ec3feb1957ef649a9b3e4f8de6fa04"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-musllinux_1_1_armv7l.whl", hash = "sha256:24120c644322a35b5eb765416ac8442214c45689e255f5fc6e761e7e7c743c8b"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:b1adf2f37521b578c438f6ec61d1c1d0c20b076863ddd5d8b6f3ab658857db3f"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-win32.whl", hash = "sha256:d79aaa468193c1bed6b0560d3c5c9f9e369e3efb0b128b38a2537e2d51d42773"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-win_amd64.whl", hash = "sha256:cc488daac19e6f5292180fac5e0ef7efffabeef4e096af9a17a75a7d3d6781f6"}, + {file = "pydantic_core-2.50.2-cp315-cp315t-win_arm64.whl", hash = "sha256:91315aea7adb51821d4a3378ede953bfdd76e3bf71551de4a82d7638cef7dc02"}, + {file = "pydantic_core-2.50.2-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:adec010c824290d4ca87047e8d8bfa4f85ac29f545f326cd5321696805d311ed"}, + {file = "pydantic_core-2.50.2-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:f47c1349c3b4274aeb18459d54244881a5c0dee0fdccedffca45704ba5c9e0a0"}, + {file = "pydantic_core-2.50.2-graalpy311-graalpy242_311_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4ee64baeab403b9de9c92846c5c1abec28ffb046cbc023bfae059897841f88af"}, + {file = "pydantic_core-2.50.2-graalpy311-graalpy242_311_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:16ec8e07c37f02dcf68939cc7f202ba9a148cc155ee2acf22d337e10b24c2cb7"}, + {file = "pydantic_core-2.50.2-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:d18d56c1ec63b304f4bb3c7db7e0d311e61cca1b1c944590a4b13ac39b2ca92b"}, + {file = "pydantic_core-2.50.2-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:41ed8abeffda6a880207fdc0cd1343a448cec3cc6b38b53f730c0745f745292d"}, + {file = "pydantic_core-2.50.2-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b7abcfaf66c1dc14c5ed928c349614f223c972a8b021b4be9548dbea6c817371"}, + {file = "pydantic_core-2.50.2-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e7460abce637f90e37f8c443559fbd687c38884d05cb69ef265e634945f4324"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b583ddeee6a6bb5bbc04462167c68034913221139d52d9f155ca6d1637a2fdcf"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:5ab5738c39b25b5dc5a721270e2269a2f5e86e614375e6c07ee6caab8cbc0f2f"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:21a902e546032c82b7275552345a2342d862e0541aea7226c91067c396e68b3f"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:92ada606285dab054e40848a951f583c537cde1e54701ea1305ec0096877012d"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c1b65a42afc73b39e6ae908ec7b9c3b9898676a7b15ce4c66d4965f7071007c8"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c324a7e0c0012e3974053f81a270d8f1aa23227571f4ddd3254c911bb356459b"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:cb8d2d7b07cbe2d7488de7e53671f836c4f4a8032dcda079df33dc1b7e2397c0"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:7c6e1bd6cadae13958e52897ef020e85c9916a95917149fca463bb0c0421a7c6"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp80-macosx_10_12_x86_64.whl", hash = "sha256:f078e276848bc23d1f92f46fc88d5b9cbb824b9acc60d9e07116620e502e16a9"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp80-macosx_11_0_arm64.whl", hash = "sha256:3435c443da7510a6de1a30c68beae338852a11f0440cc8320ea756a162f38dbe"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp80-manylinux_2_28_x86_64.whl", hash = "sha256:b5675a12a7b67063fe3ca187e735b0463cf13fabc10166ae4d4b2f775fd0632d"}, + {file = "pydantic_core-2.50.2-pp311-pypy311_pp80-win_amd64.whl", hash = "sha256:f5ba7ef10ce82737e173fa95cafa1c8210918f7e653715b2c7a7a31877a74848"}, + {file = "pydantic_core-2.50.2.tar.gz", hash = "sha256:1b0e8dc3932cf4e9ed5727570325cacc716b9409ffc794a221c0ccc72e8eb775"}, +] + +[package.dependencies] +typing-extensions = ">=4.16.0" + +[[package]] +name = "pygments" +version = "2.21.0" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.9" +groups = ["dev"] +files = [ + {file = "pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9"}, + {file = "pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c"}, +] + +[package.extras] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pytest" +version = "9.2.0" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.10" +groups = ["dev"] +files = [ + {file = "pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588"}, + {file = "pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b"}, +] + +[package.dependencies] +colorama = {version = ">=0.4", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1", markers = "python_version < \"3.11\""} +iniconfig = ">=2" +packaging = ">=24" +pluggy = ">=1.6,<2" +pygments = ">=2.15" +tomli = {version = ">=2", markers = "python_version < \"3.11\""} + +[package.extras] +dev = ["argcomplete", "asynctest ; python_version < \"3.11\"", "attrs (>=23.1)", "coverage (>=7.5)", "hypothesis (>=6.75)", "mock", "numpy (>=1.26)", "pexpect (>=4.9)", "pytest-xdist (>=3.5)", "pyyaml", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "pytest-asyncio" +version = "1.4.1.post1" +description = "Pytest support for asyncio" +optional = false +python-versions = ">=3.10" +groups = ["dev"] +files = [ + {file = "pytest_asyncio-1.4.1.post1-py3-none-any.whl", hash = "sha256:0755e488cc0a2b9bd2eab7292cc6390d4cbb8390f1020745647bae5a708e0165"}, + {file = "pytest_asyncio-1.4.1.post1.tar.gz", hash = "sha256:f582d9ea4a1c082195abe8bd29a1fe106aeb1cd435e3dad2d3bc2749935c36a2"}, +] + +[package.dependencies] +backports-asyncio-runner = {version = ">=1.1,<2", markers = "python_version < \"3.11\""} +pytest = ">=8.4" +typing-extensions = {version = ">=4.12", markers = "python_version < \"3.13\""} + +[package.extras] +docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)", "sphinx-tabs (>=3.5)"] +testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"] + +[[package]] +name = "referencing" +version = "0.37.0" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231"}, + {file = "referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" +typing-extensions = {version = ">=4.4.0", markers = "python_version < \"3.13\""} + +[[package]] +name = "requests" +version = "2.34.2" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0"}, + {file = "requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed"}, +] + +[package.dependencies] +certifi = ">=2023.5.7" +charset_normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.26,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<8)"] + +[[package]] +name = "rpds-py" +version = "0.30.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288"}, + {file = "rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221"}, + {file = "rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7"}, + {file = "rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff"}, + {file = "rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7"}, + {file = "rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139"}, + {file = "rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464"}, + {file = "rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169"}, + {file = "rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425"}, + {file = "rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d"}, + {file = "rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038"}, + {file = "rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7"}, + {file = "rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed"}, + {file = "rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85"}, + {file = "rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c"}, + {file = "rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825"}, + {file = "rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229"}, + {file = "rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad"}, + {file = "rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6"}, + {file = "rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51"}, + {file = "rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5"}, + {file = "rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e"}, + {file = "rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394"}, + {file = "rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf"}, + {file = "rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b"}, + {file = "rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e"}, + {file = "rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2"}, + {file = "rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e"}, + {file = "rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d"}, + {file = "rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7"}, + {file = "rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31"}, + {file = "rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95"}, + {file = "rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d"}, + {file = "rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15"}, + {file = "rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1"}, + {file = "rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a"}, + {file = "rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9"}, + {file = "rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0"}, + {file = "rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94"}, + {file = "rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08"}, + {file = "rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27"}, + {file = "rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6"}, + {file = "rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d"}, + {file = "rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0"}, + {file = "rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07"}, + {file = "rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f"}, + {file = "rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65"}, + {file = "rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f"}, + {file = "rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53"}, + {file = "rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed"}, + {file = "rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950"}, + {file = "rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6"}, + {file = "rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb"}, + {file = "rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8"}, + {file = "rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5"}, + {file = "rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404"}, + {file = "rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856"}, + {file = "rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40"}, + {file = "rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0"}, + {file = "rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4"}, + {file = "rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e"}, + {file = "rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84"}, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +description = "Sniff out which async library your code is running under" +optional = false +python-versions = ">=3.7" +groups = ["main"] +files = [ + {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"}, + {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"}, +] + +[[package]] +name = "tomli" +version = "2.5.0" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.8" +groups = ["dev"] +markers = "python_version == \"3.10\"" +files = [ + {file = "tomli-2.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c4dc1c1781f2f716de763d1e9a7b34c6a894e167e291c7c5d16c72f7a9538545"}, + {file = "tomli-2.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eff8babca5a7999bc137acbc7482a8b7e17ffca5075ab41f5d770ab408c7bfef"}, + {file = "tomli-2.5.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86665cee9c4835b7a7f1e8ec2c719b5258d4dc782887aded5a8ae7352a96843b"}, + {file = "tomli-2.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e369fd63331746182360977b1892bfc215476a30d61612d732425311639f56"}, + {file = "tomli-2.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ad1ea345759240d6463efa0ed1c704402752e49aa21476620738d74d72d8aa1"}, + {file = "tomli-2.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96243987194634bd411066ce40c952e108f86af04db533ecd8ac3ff2a85b1885"}, + {file = "tomli-2.5.0-cp311-cp311-win32.whl", hash = "sha256:610b27d99f28ec5f191c7064a48f3ddb179a1fe6ca73d571483ae859f57b605e"}, + {file = "tomli-2.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:c804ae44fe7b4bab5da295e4f980a1ff04670bca9d23fe0a4e887e08ebd741a8"}, + {file = "tomli-2.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:cfac177ebd6236003846ea339981f71457cb6eb748f23381eb257e45092e3980"}, + {file = "tomli-2.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f4a40d03fb9f63424f0979855bdeaf44dd7696b8d59501822c10ed30ba532df"}, + {file = "tomli-2.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9ebf8d19b17bd0daeb7b7dec81a946a439b753942fd0210d6e96c532249eea6b"}, + {file = "tomli-2.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf0b5e8e0f68ebb494356e577c06c139161efd8d3b9050f93b39b7c26cc54ff0"}, + {file = "tomli-2.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cf74416bdc94ae458b14e37286c1073081850ac8459a00d0c5efef5d44294c6"}, + {file = "tomli-2.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:61ea1ebe1e55a34ea8199cc8dbff398d35027b82271c8ac4802fd3a1fd5b1bcc"}, + {file = "tomli-2.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed53f7e89bb04f6d9e8e7799112360b0c4d5cbff067de0814c98c37c39b920f7"}, + {file = "tomli-2.5.0-cp312-cp312-win32.whl", hash = "sha256:e7ad033e27a516a233bea839cdb77b80146facb3b4f40bf02cd0cac165cdd5c2"}, + {file = "tomli-2.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd05de8c1698f8413dd7d869492693a0bf2211543b787ac78cd5e7536af1a6d7"}, + {file = "tomli-2.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:069435bd5480429b98c5e5afb02ab21c219b6f0064680671c6dc0d46817346ea"}, + {file = "tomli-2.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:943276cf269e0071948d9ff697159c1735e623c1151d88abb09b74659ef0cbea"}, + {file = "tomli-2.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:463b16086865b97facd8d0b3fb4cb7c544e3f58d2a69dc3113d6db9653fdb043"}, + {file = "tomli-2.5.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1245a6638fc4bb0a60af38a7d45413db34a13842027c77597c712c998c62fdf0"}, + {file = "tomli-2.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d8bac3d603c97e6854424e5b2b5b741bdbde387e09f162fb0446812b4a8362b"}, + {file = "tomli-2.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:21e4cae4114aba25aa0d4f85cdf486d290fb35c0954d7bba536248da64d43066"}, + {file = "tomli-2.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bbaefc84548d754be821bba7c4141c4787dda182f9e77f2f87b71213529efa7b"}, + {file = "tomli-2.5.0-cp313-cp313-win32.whl", hash = "sha256:abdbf6313b8d9efe157edeb7ab6eae4de064b1300ad31abf73755154b30abe68"}, + {file = "tomli-2.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:fd4dc129784e0c5335bd4e61dfcc4487499a013419e655cf2da1d091b7e0efdc"}, + {file = "tomli-2.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:69491c143d2fe063046e0301e62a810bed338fa4d1ce0fd870c27dc1e09b0d84"}, + {file = "tomli-2.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d3182ee2d887e507bd67319a0a61105d1dd33facc111329559a233b772c1a105"}, + {file = "tomli-2.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:521345fd1f19d45b8df87657aaa38b6f2ca3800059fadf428e7ebf479a383646"}, + {file = "tomli-2.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e95c7614e705bfe2b04b27aa124adec59752d15813df37e2156747cab3a006b"}, + {file = "tomli-2.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ac2027d37c3afbdf4bdd377f2676f6f1d2122a5be1f1137b49dced590b37e75"}, + {file = "tomli-2.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c414be4ed9d3cac80c42e348fa5a956117d1a48227f48026e31f59cb4a7671eb"}, + {file = "tomli-2.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9b03d7dc168353b4132965bde20feceabaa470e570c6f59660dfae59b1f9eeb3"}, + {file = "tomli-2.5.0-cp314-cp314-win32.whl", hash = "sha256:6f041843c4d3a37245c0c056fd955b186bf8b1fb85690cbe40b81230891dc34b"}, + {file = "tomli-2.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:f4b653094e18f9031102d3a1da5c729c8f222d85225b18037dac621695e46e1a"}, + {file = "tomli-2.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:3f89d10c1ff6a38d992c27fc8a4816af71a909e08a40ec66934240b1e74347c3"}, + {file = "tomli-2.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e9e15b4a6c7dd6b85b5fbab29488a73f1f70de516942308daa266bf0e0aeb0d4"}, + {file = "tomli-2.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e12bbcd32897272fb05929110362ae9ff4c1b9bb26bd9e971e71dcd3275b4c3d"}, + {file = "tomli-2.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20aa36de8f2cf87237143bc1fa1aae8d6612c09118f4da21c6a684db5dd1f6f9"}, + {file = "tomli-2.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22185fad8a1e622f064e78008018a0dd3323550dcb479cb7a1d296888d74024f"}, + {file = "tomli-2.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:984012f71908165449a951de2050d52f276bfe3aa5d5f570f63ddad814370374"}, + {file = "tomli-2.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f79203b3965b4000e91808aaa7c040206093f2b8bf86f455982f2274c9ccf442"}, + {file = "tomli-2.5.0-cp314-cp314t-win32.whl", hash = "sha256:91294a9fb94a75542f6e46e4a2ae709bd8d9b51134098cae5cf3bea5478b6d03"}, + {file = "tomli-2.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f15e3e0b835a6d68b10c86bf80a3149780498d6911c93c3ffd1861d19f9200f1"}, + {file = "tomli-2.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6664b7ae7af7294256c53960a6103077f4914cec8ff98479c352f622c6f6b2f0"}, + {file = "tomli-2.5.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a525685c2f97da40762b8695eb7aa0af4c8344ca1905c73e4e29cb04d34607dc"}, + {file = "tomli-2.5.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9dbb18c1cfb2f6517942fc9314437f66aa06d94436ffb1f06102ef3572f35276"}, + {file = "tomli-2.5.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:752e8b1aa6a4367ef8bf6a1a1e005540f7ed055ba36d7193796812ca5404eb52"}, + {file = "tomli-2.5.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47300f9bf791808f77d82747691c4bb09cb14bdf3060cca99b42cdc4361d5a7"}, + {file = "tomli-2.5.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:19b0dd8749f4ea2f112c5fcfb3c5248390c899d7e2e173f1d91abee1fa0ff391"}, + {file = "tomli-2.5.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:57b1c3b01fab802e2899bc3d168dca320e14165e2fd9fd584760fb4ca5826859"}, + {file = "tomli-2.5.0-cp315-cp315-win32.whl", hash = "sha256:667e521b37a6c5ccaa044202c235b530f90177ffe2cd4a64ecc213c7dd535feb"}, + {file = "tomli-2.5.0-cp315-cp315-win_amd64.whl", hash = "sha256:d747252933c8a65ef6bd8da0fbb7ce28a90eb6119d8cd00772cd528aa07b68d5"}, + {file = "tomli-2.5.0-cp315-cp315-win_arm64.whl", hash = "sha256:75dbcde8751b0a960aa3de173aa5e894d590755c6d7758b7e774c06f1dc3cbdd"}, + {file = "tomli-2.5.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2419c2a189551987b59d80e63ec355671283336f41c6b9b89462df679c7d0c57"}, + {file = "tomli-2.5.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0dc598040da8d42cf20f0be588ed7004f46db12a0ac6c32e03a59dccedaaadcd"}, + {file = "tomli-2.5.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49096930c8d886c9bbdab62d2d0d17ce823ddeea522309a190b36245d5b49e01"}, + {file = "tomli-2.5.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8ade5023067f99fe72b88accd30d0ea05a158e9e32a11f124e731ea9695313f"}, + {file = "tomli-2.5.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b69564772b5c8f22ea5f498dff08cfa825045b4d4c4400529000bdf818aa3b2a"}, + {file = "tomli-2.5.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8ff3a2ca028c7eee0c777f9a092038d0a594a9fa04e215f929a22c329e2cb142"}, + {file = "tomli-2.5.0-cp315-cp315t-win32.whl", hash = "sha256:62fc1bc8eb03e3a9cadfca713d65614ed8e09d974a283295ffe3a831976b4dc5"}, + {file = "tomli-2.5.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f3fcbc57b1791fa6cbe5d8434179d51de12be1a4811469529f47f6e7487a2571"}, + {file = "tomli-2.5.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d2ba24db8a9376921b5e87b4762b9adb0f3f1deaea68f2b8b0bb2c11efb9c3e7"}, + {file = "tomli-2.5.0-py3-none-any.whl", hash = "sha256:32a7b79ac57a2e83670ce329ccf675798bc5a2094783a63676866b70503f2e2b"}, + {file = "tomli-2.5.0.tar.gz", hash = "sha256:264507556cd8b8c8e7c6ee037cdf443a463f03f4c958e57195e3d369711b8ff6"}, +] + +[[package]] +name = "truststore" +version = "0.10.5" +description = "Verify certificates using native system trust stores" +optional = false +python-versions = ">=3.10" +groups = ["main"] +markers = "sys_platform != \"emscripten\"" +files = [ + {file = "truststore-0.10.5-py3-none-any.whl", hash = "sha256:9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c"}, + {file = "truststore-0.10.5.tar.gz", hash = "sha256:30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd"}, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +description = "Backported and Experimental Type Hints for Python 3.9+" +optional = false +python-versions = ">=3.9" +groups = ["main", "dev"] +files = [ + {file = "typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8"}, + {file = "typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5"}, +] + +[[package]] +name = "typing-inspection" +version = "0.4.4" +description = "Runtime typing introspection tools" +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147"}, + {file = "typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47"}, +] + +[package.dependencies] +typing-extensions = ">=4.15.0" + +[[package]] +name = "urllib3" +version = "2.8.0" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.10" +groups = ["main", "dev"] +files = [ + {file = "urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3"}, + {file = "urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63"}, +] + +[package.extras] +brotli = ["brotli (>=1.2.0) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=1.2.0.0) ; platform_python_implementation != \"CPython\""] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["backports-zstd (>=1.0.0) ; python_version < \"3.14\""] + +[[package]] +name = "wrapt" +version = "1.17.3" +description = "Module for decorators, wrappers and monkey patching." +optional = false +python-versions = ">=3.8" +groups = ["main", "dev"] +files = [ + {file = "wrapt-1.17.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88bbae4d40d5a46142e70d58bf664a89b6b4befaea7b2ecc14e03cedb8e06c04"}, + {file = "wrapt-1.17.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b13af258d6a9ad602d57d889f83b9d5543acd471eee12eb51f5b01f8eb1bc2"}, + {file = "wrapt-1.17.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd341868a4b6714a5962c1af0bd44f7c404ef78720c7de4892901e540417111c"}, + {file = "wrapt-1.17.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f9b2601381be482f70e5d1051a5965c25fb3625455a2bf520b5a077b22afb775"}, + {file = "wrapt-1.17.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343e44b2a8e60e06a7e0d29c1671a0d9951f59174f3709962b5143f60a2a98bd"}, + {file = "wrapt-1.17.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:33486899acd2d7d3066156b03465b949da3fd41a5da6e394ec49d271baefcf05"}, + {file = "wrapt-1.17.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e6f40a8aa5a92f150bdb3e1c44b7e98fb7113955b2e5394122fa5532fec4b418"}, + {file = "wrapt-1.17.3-cp310-cp310-win32.whl", hash = "sha256:a36692b8491d30a8c75f1dfee65bef119d6f39ea84ee04d9f9311f83c5ad9390"}, + {file = "wrapt-1.17.3-cp310-cp310-win_amd64.whl", hash = "sha256:afd964fd43b10c12213574db492cb8f73b2f0826c8df07a68288f8f19af2ebe6"}, + {file = "wrapt-1.17.3-cp310-cp310-win_arm64.whl", hash = "sha256:af338aa93554be859173c39c85243970dc6a289fa907402289eeae7543e1ae18"}, + {file = "wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7"}, + {file = "wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85"}, + {file = "wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f"}, + {file = "wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311"}, + {file = "wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1"}, + {file = "wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5"}, + {file = "wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2"}, + {file = "wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89"}, + {file = "wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77"}, + {file = "wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a"}, + {file = "wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0"}, + {file = "wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba"}, + {file = "wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd"}, + {file = "wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828"}, + {file = "wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9"}, + {file = "wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396"}, + {file = "wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc"}, + {file = "wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe"}, + {file = "wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c"}, + {file = "wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6"}, + {file = "wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0"}, + {file = "wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77"}, + {file = "wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7"}, + {file = "wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277"}, + {file = "wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d"}, + {file = "wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa"}, + {file = "wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050"}, + {file = "wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8"}, + {file = "wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb"}, + {file = "wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16"}, + {file = "wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39"}, + {file = "wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235"}, + {file = "wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c"}, + {file = "wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b"}, + {file = "wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa"}, + {file = "wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7"}, + {file = "wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4"}, + {file = "wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10"}, + {file = "wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6"}, + {file = "wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58"}, + {file = "wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a"}, + {file = "wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067"}, + {file = "wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454"}, + {file = "wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e"}, + {file = "wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f"}, + {file = "wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056"}, + {file = "wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804"}, + {file = "wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977"}, + {file = "wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116"}, + {file = "wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6"}, + {file = "wrapt-1.17.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:70d86fa5197b8947a2fa70260b48e400bf2ccacdcab97bb7de47e3d1e6312225"}, + {file = "wrapt-1.17.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:df7d30371a2accfe4013e90445f6388c570f103d61019b6b7c57e0265250072a"}, + {file = "wrapt-1.17.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:caea3e9c79d5f0d2c6d9ab96111601797ea5da8e6d0723f77eabb0d4068d2b2f"}, + {file = "wrapt-1.17.3-cp38-cp38-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:758895b01d546812d1f42204bd443b8c433c44d090248bf22689df673ccafe00"}, + {file = "wrapt-1.17.3-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02b551d101f31694fc785e58e0720ef7d9a10c4e62c1c9358ce6f63f23e30a56"}, + {file = "wrapt-1.17.3-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:656873859b3b50eeebe6db8b1455e99d90c26ab058db8e427046dbc35c3140a5"}, + {file = "wrapt-1.17.3-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:a9a2203361a6e6404f80b99234fe7fb37d1fc73487b5a78dc1aa5b97201e0f22"}, + {file = "wrapt-1.17.3-cp38-cp38-win32.whl", hash = "sha256:55cbbc356c2842f39bcc553cf695932e8b30e30e797f961860afb308e6b1bb7c"}, + {file = "wrapt-1.17.3-cp38-cp38-win_amd64.whl", hash = "sha256:ad85e269fe54d506b240d2d7b9f5f2057c2aa9a2ea5b32c66f8902f768117ed2"}, + {file = "wrapt-1.17.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:30ce38e66630599e1193798285706903110d4f057aab3168a34b7fdc85569afc"}, + {file = "wrapt-1.17.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:65d1d00fbfb3ea5f20add88bbc0f815150dbbde3b026e6c24759466c8b5a9ef9"}, + {file = "wrapt-1.17.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a7c06742645f914f26c7f1fa47b8bc4c91d222f76ee20116c43d5ef0912bba2d"}, + {file = "wrapt-1.17.3-cp39-cp39-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e18f01b0c3e4a07fe6dfdb00e29049ba17eadbc5e7609a2a3a4af83ab7d710a"}, + {file = "wrapt-1.17.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f5f51a6466667a5a356e6381d362d259125b57f059103dd9fdc8c0cf1d14139"}, + {file = "wrapt-1.17.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:59923aa12d0157f6b82d686c3fd8e1166fa8cdfb3e17b42ce3b6147ff81528df"}, + {file = "wrapt-1.17.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:46acc57b331e0b3bcb3e1ca3b421d65637915cfcd65eb783cb2f78a511193f9b"}, + {file = "wrapt-1.17.3-cp39-cp39-win32.whl", hash = "sha256:3e62d15d3cfa26e3d0788094de7b64efa75f3a53875cdbccdf78547aed547a81"}, + {file = "wrapt-1.17.3-cp39-cp39-win_amd64.whl", hash = "sha256:1f23fa283f51c890eda8e34e4937079114c74b4c81d2b2f1f1d94948f5cc3d7f"}, + {file = "wrapt-1.17.3-cp39-cp39-win_arm64.whl", hash = "sha256:24c2ed34dc222ed754247a2702b1e1e89fdbaa4016f324b4b8f1a802d4ffe87f"}, + {file = "wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22"}, + {file = "wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0"}, +] + +[metadata] +lock-version = "2.1" +python-versions = ">=3.10,<3.14" +content-hash = "73335aa8604d5b675d2071269c62bc0854acc819c1599a732631b8566f0a1b5c" diff --git a/python/frameworks/vllm/pyproject.toml b/python/frameworks/vllm/pyproject.toml index 738c677fa..d9e9aa208 100644 --- a/python/frameworks/vllm/pyproject.toml +++ b/python/frameworks/vllm/pyproject.toml @@ -15,7 +15,6 @@ classifiers = [ "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", @@ -27,11 +26,13 @@ classifiers = [ ] [tool.poetry.dependencies] -python = ">3.9,<3.14" -fi-instrumentation-otel = ">=0.1.11" +python = ">=3.10,<3.14" +fi-instrumentation-otel = ">=1.2.3" openai = ">=1.0.0" [tool.poetry.group.dev.dependencies] +# Use the candidate core in this monorepo without weakening the published floor. +fi-instrumentation-otel = {path = "../..", develop = true} pytest = ">=7.0.0" pytest-asyncio = ">=0.21.0" diff --git a/python/frameworks/vllm/tests/test_message_and_usage_shapes.py b/python/frameworks/vllm/tests/test_message_and_usage_shapes.py new file mode 100644 index 000000000..37f926b21 --- /dev/null +++ b/python/frameworks/vllm/tests/test_message_and_usage_shapes.py @@ -0,0 +1,60 @@ +"""Legacy SDK dictionaries and typed models must share privacy/accounting rules.""" + +import json +from types import MappingProxyType, SimpleNamespace + +import pytest +from fi_instrumentation.fi_types import SpanAttributes +from traceai_vllm._wrappers import ( + _get_input_attributes, + _get_output_attributes, + _get_stream_output_attributes, +) + + +@pytest.mark.parametrize("objects", [False, True]) +@pytest.mark.parametrize("hide_images", [False, True]) +def test_typed_multimodal_parts(export_attributes, objects, hide_images): + image = "https://example.invalid/synthetic-private-image" + text = "Keep this text visible" + parts = [ + {"type": "text", "text": text}, + {"type": "image_url", "image_url": {"url": image}}, + ] + if objects: + parts = [SimpleNamespace(**parts[0]), SimpleNamespace( + type="image_url", image_url=SimpleNamespace(url=image) + )] + message = SimpleNamespace(role="user", content=parts) + else: + message = MappingProxyType({"role": "user", "content": parts}) + attributes = _get_input_attributes("test", [message]) + assert "gen_ai.input.messages.0.message.content" not in attributes + captured = export_attributes(attributes, hide_input_images=hide_images) + assert text in json.dumps(captured) + assert (image in json.dumps(captured)) == (not hide_images) + # Attribute projection must not replace or redact the caller's values. + assert (parts[1].image_url.url if objects else parts[1]["image_url"]["url"]) == image + + +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("mapping", [False, True]) +@pytest.mark.parametrize("count", [0, 7, None, True, False, -1, "7", 1.5, float("nan"), float("inf")]) +def test_usage_validates_token_counts(stream, mapping, count): + values = {"prompt_tokens": count, "completion_tokens": 5, "total_tokens": 8} + usage = MappingProxyType(values) if mapping else SimpleNamespace(**values) + response = SimpleNamespace(model="test", usage=usage) + attrs = (_get_stream_output_attributes([response], "hello") if stream + else _get_output_attributes(response)) + if type(count) is int and count >= 0: + assert attrs[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS] == count + else: + assert SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS not in attrs + assert attrs[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS] == 5 + assert attrs[SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS] == 8 + + +@pytest.mark.parametrize("usage", [None, {}, SimpleNamespace()]) +def test_missing_usage_is_not_invented(usage): + attrs = _get_stream_output_attributes([SimpleNamespace(usage=usage)], "") + assert not any(key.startswith("gen_ai.usage.") for key in attrs) diff --git a/python/frameworks/vllm/tests/test_release_contracts.py b/python/frameworks/vllm/tests/test_release_contracts.py new file mode 100644 index 000000000..bf22f96a6 --- /dev/null +++ b/python/frameworks/vllm/tests/test_release_contracts.py @@ -0,0 +1,252 @@ +"""Real SDK regressions: transport privacy, native streams and cancellation.""" + +import asyncio +import json + +import openai +import pytest +from fi_instrumentation import TraceConfig +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import SimpleSpanProcessor +from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter +from traceai_vllm import VLLMInstrumentor + +if int(openai.__version__.split(".")[0]) >= 3: + import httpx2 as httpx +else: + import httpx + +INPUT = "PRIVATE_INPUT_SENTINEL" +IMAGE = "https://images.example.invalid/SYNTHETIC_PRIVATE_IMAGE.png" +OUTPUT = "PRIVATE_OUTPUT_SENTINEL" +SECRET = "SYNTHETIC_TRANSPORT_SECRET" +PARAMS = {"model": "test", "messages": [{"role": "user", "content": INPUT}]} +OPTIONS = {"api_key": "synthetic-key", "base_url": "http://localhost:8000/v1", "max_retries": 0} + + +@pytest.fixture +def tracing(): + exporter = InMemorySpanExporter() + provider = TracerProvider() + provider.add_span_processor(SimpleSpanProcessor(exporter)) + inst = VLLMInstrumentor() + + def start(**privacy): + with pytest.warns(DeprecationWarning): + inst.instrument(tracer_provider=provider, config=TraceConfig(**privacy)) + return exporter + + yield start + inst.uninstrument() + provider.shutdown() + + +def response(request): + body = json.loads(request.content) + data = { + "id": "test", "object": "chat.completion", "created": 1, "model": "test", + "choices": [{"index": 0, "message": {"role": "assistant", "content": OUTPUT}, "finish_reason": "stop"}], + "usage": {"prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5}, + } + if body.get("stream"): + data["object"] = "chat.completion.chunk" + data["choices"][0]["delta"] = data["choices"][0].pop("message") + return httpx.Response(200, headers={"content-type": "text/event-stream"}, + content=f"data: {json.dumps(data)}\n\ndata: [DONE]\n\n") + return httpx.Response(200, json=data) + + +@pytest.mark.parametrize("use_async", [False, True]) +def test_transport_credentials_excluded_without_changing_request(tracing, use_async): + exporter = tracing() + seen = [] + + def handle(request): + seen.append(request) + assert request.headers["authorization"] == "Bearer " + SECRET + assert json.loads(request.content)["transport_secret"] == SECRET + assert request.url.params["secret"] == SECRET + return response(request) + + params = {**PARAMS, "extra_headers": {"Authorization": "Bearer " + SECRET}, + "extra_query": {"secret": SECRET}, "extra_body": {"transport_secret": SECRET}} + + async def run(): + async with openai.AsyncOpenAI(**OPTIONS, http_client=httpx.AsyncClient(transport=httpx.MockTransport(handle))) as client: + await client.chat.completions.create(**params) + + if use_async: + asyncio.run(run()) + else: + with openai.OpenAI(**OPTIONS, http_client=httpx.Client(transport=httpx.MockTransport(handle))) as client: + client.chat.completions.create(**params) + assert len(seen) == 1 + spans = exporter.get_finished_spans() + assert len(spans) == 1 + assert SECRET not in spans[0].to_json() + assert INPUT in spans[0].to_json() + + +@pytest.mark.parametrize("use_async", [False, True]) +@pytest.mark.parametrize("mode", ["exhaust", "early", "unused", "close"]) +def test_native_stream_lifecycle(tracing, use_async, mode): + exporter = tracing() + + async def run(): + async with openai.AsyncOpenAI(**OPTIONS, http_client=httpx.AsyncClient(transport=httpx.MockTransport(response))) as client: + stream = await client.chat.completions.create(**PARAMS, stream=True) + assert isinstance(stream, openai.AsyncStream) + if mode == "close": + await stream.close() + else: + async with stream as entered: + assert entered is stream + if mode == "exhaust": + assert [chunk async for chunk in stream] + elif mode == "early": + assert (await stream.__anext__()).choices[0].delta.content == OUTPUT + assert stream.response.is_closed + await stream.close() + + if use_async: + asyncio.run(run()) + else: + with openai.OpenAI(**OPTIONS, http_client=httpx.Client(transport=httpx.MockTransport(response))) as client: + stream = client.chat.completions.create(**PARAMS, stream=True) + assert isinstance(stream, openai.Stream) + if mode == "close": + stream.close() + else: + with stream as entered: + assert entered is stream + if mode == "exhaust": + assert list(stream) + elif mode == "early": + assert next(stream).choices[0].delta.content == OUTPUT + assert stream.response.is_closed + stream.close() + spans = exporter.get_finished_spans() + assert len(spans) == 1 + assert spans[0].status.is_ok + + +@pytest.mark.parametrize("hide", [False, True]) +@pytest.mark.parametrize("phase", ["request", "stream"]) +def test_cancel_preserves_exception_and_finishes_once(tracing, hide, phase): + exporter = tracing(hide_error_details=hide) + + async def run(): + entered = asyncio.Event() + + class BlockedBody(httpx.AsyncByteStream): + async def __aiter__(self): + entered.set() + await asyncio.Event().wait() + yield b"" + + async def handle(request): + if phase == "request": + entered.set() + await asyncio.Event().wait() + return httpx.Response(200, headers={"content-type": "text/event-stream"}, stream=BlockedBody()) + + async with openai.AsyncOpenAI(**OPTIONS, http_client=httpx.AsyncClient(transport=httpx.MockTransport(handle))) as client: + stream = None + cancellation_args = [] + + async def observe_cancellation(operation): + try: + return await operation + except asyncio.CancelledError as error: + cancellation_args.append(error.args) + raise + + if phase == "stream": + stream = await client.chat.completions.create(**PARAMS, stream=True) + task = asyncio.create_task(observe_cancellation(stream.__anext__())) + else: + task = asyncio.create_task(observe_cancellation(client.chat.completions.create(**PARAMS))) + await asyncio.wait_for(entered.wait(), 3) + task.cancel(SECRET) + # Python 3.10 can recreate CancelledError without its message when + # awaiting a Task. Assert the original args inside the task instead. + with pytest.raises(asyncio.CancelledError): + await task + assert cancellation_args == [(SECRET,)] + if stream is not None: + await stream.close() + + asyncio.run(run()) + spans = exporter.get_finished_spans() + assert len(spans) == 1 + assert spans[0].status.status_code.name == "ERROR" + assert (SECRET not in spans[0].to_json()) == hide + + +@pytest.mark.parametrize("use_async", [False, True]) +@pytest.mark.parametrize("stream", [False, True]) +@pytest.mark.parametrize("privacy", ["visible", "hide_input_images", "env", "hide_input_text"]) +def test_multimodal_privacy_preserves_provider_request(tracing, monkeypatch, use_async, stream, privacy): + if privacy == "env": + monkeypatch.setenv("FI_HIDE_INPUT_IMAGES", "true") + exporter = tracing(**({privacy: True} if privacy.startswith("hide_") else {})) + messages = [{"role": "user", "content": [ + {"type": "text", "text": INPUT}, + {"type": "image_url", "image_url": {"url": IMAGE}}, + ]}] + seen = [] + + def handle(request): + seen.append(json.loads(request.content)) + return response(request) + + params = {"model": "test", "messages": messages, "stream": stream} + + async def run(): + async with openai.AsyncOpenAI(**OPTIONS, http_client=httpx.AsyncClient(transport=httpx.MockTransport(handle))) as client: + result = await client.chat.completions.create(**params) + if stream: + assert [chunk async for chunk in result] + + if use_async: + asyncio.run(run()) + else: + with openai.OpenAI(**OPTIONS, http_client=httpx.Client(transport=httpx.MockTransport(handle))) as client: + result = client.chat.completions.create(**params) + if stream: + assert list(result) + assert seen == [params] + assert messages[0]["content"][1]["image_url"]["url"] == IMAGE + spans = exporter.get_finished_spans() + assert len(spans) == 1 + serialized = spans[0].to_json() + assert (IMAGE in serialized) == (privacy not in ("hide_input_images", "env")) + assert (INPUT in serialized) == (privacy != "hide_input_text") + + +@pytest.mark.parametrize("use_async", [False, True]) +def test_reported_stream_usage_exported_at_sdk_floor_and_latest(tracing, use_async): + exporter = tracing() + + async def run(): + async with openai.AsyncOpenAI(**OPTIONS, http_client=httpx.AsyncClient(transport=httpx.MockTransport(response))) as client: + result = await client.chat.completions.create(**PARAMS, stream=True) + return [chunk async for chunk in result] + + if use_async: + chunks = asyncio.run(run()) + else: + with openai.OpenAI(**OPTIONS, http_client=httpx.Client(transport=httpx.MockTransport(response))) as client: + chunks = list(client.chat.completions.create(**PARAMS, stream=True)) + # OpenAI 1.0 retains this extension as a dict; newer SDKs model CompletionUsage. + usage = chunks[-1].usage + reported = usage if isinstance(usage, dict) else usage.model_dump() + assert {key: reported[key] for key in ("prompt_tokens", "completion_tokens", "total_tokens")} == { + "prompt_tokens": 2, "completion_tokens": 3, "total_tokens": 5, + } + spans = exporter.get_finished_spans() + assert len(spans) == 1 + attributes = spans[0].attributes + assert attributes.get("gen_ai.usage.input_tokens") == 2 + assert attributes.get("gen_ai.usage.output_tokens") == 3 + assert attributes.get("gen_ai.usage.total_tokens") == 5 diff --git a/python/frameworks/vllm/traceai_vllm/_wrappers.py b/python/frameworks/vllm/traceai_vllm/_wrappers.py index 7fe061aee..29a3ab580 100644 --- a/python/frameworks/vllm/traceai_vllm/_wrappers.py +++ b/python/frameworks/vllm/traceai_vllm/_wrappers.py @@ -3,14 +3,22 @@ import logging import sys from abc import ABC +from collections.abc import Mapping from contextlib import contextmanager -from typing import Any, Dict, Iterator, List, Tuple +from typing import Any, Dict, Iterator, List, Optional, Tuple from fi_instrumentation import safe_json_dumps -from fi_instrumentation.fi_types import FiSpanKindValues, SpanAttributes, MessageAttributes +from fi_instrumentation.fi_types import ( + FiSpanKindValues, + ImageAttributes, + MessageAttributes, + MessageContentAttributes, + SpanAttributes, +) from opentelemetry import trace as trace_api from opentelemetry.trace import INVALID_SPAN, Span, Status, StatusCode from opentelemetry.util.types import AttributeValue +from wrapt import ObjectProxy logger = logging.getLogger(__name__) logger.addHandler(logging.NullHandler()) @@ -77,6 +85,25 @@ def _start_span( yield span +def _get_field(value: Any, name: str) -> Any: + """Read both SDK models and unmodeled extensions (dicts on older SDKs).""" + return value.get(name) if isinstance(value, Mapping) else getattr(value, name, None) + + +def _get_usage_attributes(usage: Any) -> Dict[str, AttributeValue]: + attributes: Dict[str, AttributeValue] = {} + for field, key in ( + ("prompt_tokens", SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS), + ("completion_tokens", SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS), + ("total_tokens", SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS), + ): + count = _get_field(usage, field) + # Token counts are non-negative integers, not booleans or numeric strings. + if isinstance(count, int) and not isinstance(count, bool) and count >= 0: + attributes[key] = count + return attributes + + def _get_input_attributes( model: str, messages: list, @@ -115,21 +142,37 @@ def _get_input_attributes( # Add input messages for i, message in enumerate(messages): prefix = f"{SpanAttributes.GEN_AI_INPUT_MESSAGES}.{i}" - if isinstance(message, dict): - if "role" in message: - attributes[f"{prefix}.{MessageAttributes.MESSAGE_ROLE}"] = message["role"] - if "content" in message: - attributes[f"{prefix}.{MessageAttributes.MESSAGE_CONTENT}"] = str(message["content"]) if message["content"] else "" - else: - # Handle message objects - if hasattr(message, "role"): - attributes[f"{prefix}.{MessageAttributes.MESSAGE_ROLE}"] = message.role - if hasattr(message, "content"): - attributes[f"{prefix}.{MessageAttributes.MESSAGE_CONTENT}"] = str(message.content) if message.content else "" - - # Add raw input - raw_input = {"model": model, "messages": messages} - raw_input.update({k: v for k, v in kwargs.items() if v is not None}) + role = _get_field(message, "role") + if isinstance(role, str): + attributes[f"{prefix}.{MessageAttributes.MESSAGE_ROLE}"] = role + content = _get_field(message, "content") + if isinstance(content, str) or content is None: + attributes[f"{prefix}.{MessageAttributes.MESSAGE_CONTENT}"] = content or "" + elif isinstance(content, (list, tuple)): + # Never stringify multimodal parts into a text attribute: that hides + # image URLs from FITracer's image-specific privacy boundary. Keep + # typed copies only; the SDK receives the original message unchanged. + for j, part in enumerate(content): + part_prefix = f"{prefix}.{MessageAttributes.MESSAGE_CONTENTS}.{j}" + part_type = _get_field(part, "type") + if part_type == "text": + text = _get_field(part, "text") + if isinstance(text, str): + attributes[f"{part_prefix}.{MessageContentAttributes.MESSAGE_CONTENT_TYPE}"] = "text" + attributes[f"{part_prefix}.{MessageContentAttributes.MESSAGE_CONTENT_TEXT}"] = text + elif part_type == "image_url": + url = _get_field(_get_field(part, "image_url"), "url") + if isinstance(url, str): + attributes[f"{part_prefix}.{MessageContentAttributes.MESSAGE_CONTENT_TYPE}"] = "image" + attributes[f"{part_prefix}.{MessageContentAttributes.MESSAGE_CONTENT_IMAGE}.{ImageAttributes.IMAGE_URL}"] = url + + # Project semantic fields only. Transport options (headers, query, body, + # timeout and future SDK kwargs) must never enter telemetry. The original + # kwargs are still passed unchanged to the SDK. + raw_input = {"model": model, "messages": messages, **invocation_params} + for key in ("tools", "tool_choice", "response_format", "max_completion_tokens", "n", "seed"): + if key in kwargs and kwargs[key] is not None: + raw_input[key] = kwargs[key] attributes[SpanAttributes.INPUT_VALUE] = safe_json_dumps(raw_input) return attributes @@ -157,14 +200,7 @@ def _get_output_attributes(response: Any) -> Dict[str, AttributeValue]: attributes[SpanAttributes.OUTPUT_VALUE] = message.content # Get usage metrics - if hasattr(response, "usage") and response.usage: - usage = response.usage - if hasattr(usage, "prompt_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS] = usage.prompt_tokens - if hasattr(usage, "completion_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS] = usage.completion_tokens - if hasattr(usage, "total_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS] = usage.total_tokens + attributes.update(_get_usage_attributes(_get_field(response, "usage"))) # Add raw output try: @@ -195,14 +231,7 @@ def _get_stream_output_attributes( if hasattr(last_chunk, "model"): attributes[SpanAttributes.GEN_AI_REQUEST_MODEL] = last_chunk.model - if hasattr(last_chunk, "usage") and last_chunk.usage: - usage = last_chunk.usage - if hasattr(usage, "prompt_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS] = usage.prompt_tokens - if hasattr(usage, "completion_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS] = usage.completion_tokens - if hasattr(usage, "total_tokens"): - attributes[SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS] = usage.total_tokens + attributes.update(_get_usage_attributes(_get_field(last_chunk, "usage"))) # Add raw output try: @@ -243,7 +272,7 @@ def __call__( response = wrapped(*args, **kwargs) if stream: - return self._wrap_stream(response, span) + return _Stream(response, span) # Non-streaming response output_attrs = _get_output_attributes(response) @@ -252,39 +281,12 @@ def __call__( span.end() return response - except Exception as e: + except BaseException as e: span.record_exception(e) span.set_status(Status(StatusCode.ERROR, str(e))) span.end() raise - def _wrap_stream(self, stream: Any, span: Span) -> Any: - """Wrap a streaming response to capture all chunks.""" - chunks = [] - full_content = "" - - try: - for chunk in stream: - chunks.append(chunk) - if hasattr(chunk, "choices") and chunk.choices: - choice = chunk.choices[0] - if hasattr(choice, "delta") and hasattr(choice.delta, "content"): - if choice.delta.content: - full_content += choice.delta.content - yield chunk - - output_attrs = _get_stream_output_attributes(chunks, full_content) - span.set_attributes(output_attrs) - span.set_status(Status(StatusCode.OK)) - - except Exception as e: - span.record_exception(e) - span.set_status(Status(StatusCode.ERROR, str(e))) - raise - - finally: - span.end() - class _AsyncCompletionsWrapper(_WithTracer): """Wrapper for asynchronous chat completions.""" @@ -314,7 +316,7 @@ async def __call__( response = await wrapped(*args, **kwargs) if stream: - return self._wrap_async_stream(response, span) + return _AsyncStream(response, span) # Non-streaming response output_attrs = _get_output_attributes(response) @@ -323,35 +325,156 @@ async def __call__( span.end() return response - except Exception as e: + except BaseException as e: span.record_exception(e) span.set_status(Status(StatusCode.ERROR, str(e))) span.end() raise - async def _wrap_async_stream(self, stream: Any, span: Span) -> Any: - """Wrap an async streaming response to capture all chunks.""" - chunks = [] - full_content = "" +class _StreamState(ObjectProxy): + """Observe the caller's stream without replacing its SDK interfaces.""" + + def __init__(self, stream: Any, span: Span) -> None: + super().__init__(stream) + self._self_span = span + self._self_finished = False + self._self_chunks = [] + self._self_content = [] + self._self_iterator = None + + def _observe(self, chunk: Any) -> Any: + if not self._self_finished: + self._self_chunks.append(chunk) + if getattr(chunk, "choices", None): + content = getattr(getattr(chunk.choices[0], "delta", None), "content", None) + if content: + self._self_content.append(content) + return chunk + + def _finish(self, error: Optional[BaseException] = None) -> None: + if self._self_finished: + return + self._self_finished = True + span = self._self_span + try: + span.set_attributes(_get_stream_output_attributes( + self._self_chunks, "".join(self._self_content) + )) + if error is not None: + # FITracer applies error-detail privacy to both surfaces. + span.record_exception(error) + span.set_status(Status(StatusCode.ERROR, str(error))) + else: + span.set_status(Status(StatusCode.OK)) + except Exception: + logger.warning("Failed to collect vLLM stream telemetry") + finally: + self._self_chunks.clear() + self._self_content.clear() + span.end() + + +class _Stream(_StreamState): + def __iter__(self) -> Any: + return self + + def __next__(self) -> Any: + try: + if self._self_iterator is None: + self._self_iterator = iter(self.__wrapped__) + with trace_api.use_span(self._self_span, end_on_exit=False, + record_exception=False, set_status_on_exception=False): + chunk = next(self._self_iterator) + except StopIteration: + self._finish() + raise + except BaseException as error: + self._finish(error) + raise + return self._observe(chunk) + + def __enter__(self) -> Any: + try: + enter = getattr(self.__wrapped__, "__enter__", None) + if enter is not None: + enter() + except BaseException as error: + self._finish(error) + raise + return self + + def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: try: - async for chunk in stream: - chunks.append(chunk) - if hasattr(chunk, "choices") and chunk.choices: - choice = chunk.choices[0] - if hasattr(choice, "delta") and hasattr(choice.delta, "content"): - if choice.delta.content: - full_content += choice.delta.content - yield chunk - - output_attrs = _get_stream_output_attributes(chunks, full_content) - span.set_attributes(output_attrs) - span.set_status(Status(StatusCode.OK)) - - except Exception as e: - span.record_exception(e) - span.set_status(Status(StatusCode.ERROR, str(e))) + exit_stream = getattr(self.__wrapped__, "__exit__", None) + if exit_stream is not None: + return exit_stream(exc_type, exc_value, traceback) + return self.__wrapped__.response.close() + except BaseException as error: + self._finish(error) raise + finally: + self._finish(exc_value) + def close(self) -> Any: + try: + # OpenAI 1.0 exposes only response.close(), not Stream.close(). + close = getattr(self.__wrapped__, "close", None) or self.__wrapped__.response.close + return close() + except BaseException as error: + self._finish(error) + raise finally: - span.end() + self._finish() + + +class _AsyncStream(_StreamState): + def __aiter__(self) -> Any: + return self + + async def __anext__(self) -> Any: + try: + if self._self_iterator is None: + self._self_iterator = self.__wrapped__.__aiter__() + with trace_api.use_span(self._self_span, end_on_exit=False, + record_exception=False, set_status_on_exception=False): + chunk = await self._self_iterator.__anext__() + except StopAsyncIteration: + self._finish() + raise + except BaseException as error: + self._finish(error) + raise + return self._observe(chunk) + + async def __aenter__(self) -> Any: + try: + enter = getattr(self.__wrapped__, "__aenter__", None) + if enter is not None: + await enter() + except BaseException as error: + self._finish(error) + raise + return self + + async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: + try: + exit_stream = getattr(self.__wrapped__, "__aexit__", None) + if exit_stream is not None: + return await exit_stream(exc_type, exc_value, traceback) + return await self.__wrapped__.response.aclose() + except BaseException as error: + self._finish(error) + raise + finally: + self._finish(exc_value) + + async def close(self) -> Any: + try: + close = getattr(self.__wrapped__, "close", None) or self.__wrapped__.response.aclose + return await close() + except BaseException as error: + self._finish(error) + raise + finally: + self._finish() diff --git a/python/pyproject.toml b/python/pyproject.toml index 63e4973fd..8e28c1f97 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "fi-instrumentation-otel" -version = "1.2.2" +version = "1.2.3" description = "OpenTelemetry tracing for AI applications: tracer setup, span helpers, exporters, and semantic conventions for Future AGI." authors = ["Future AGI "] readme = "README.md" diff --git a/python/tests/test_batch_span_processor_tuning.py b/python/tests/test_batch_span_processor_tuning.py index d00a3f779..2d6009fe4 100644 --- a/python/tests/test_batch_span_processor_tuning.py +++ b/python/tests/test_batch_span_processor_tuning.py @@ -14,7 +14,8 @@ import pytest import requests -from opentelemetry.sdk.trace import SpanLimits, TracerProvider as OTelTracerProvider +from opentelemetry.sdk.trace import SpanLimits, TracerProvider as SDKTracerProvider +OTelTracerProvider = SDKTracerProvider from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter from opentelemetry.sdk.trace.sampling import TraceIdRatioBased @@ -124,9 +125,67 @@ def test_explicit_kwarg_overrides_env(self, clean_bsp_env): assert _queue_batch(p)[0] == 9000 +@pytest.fixture +def assert_http_export_timeout(monkeypatch): + """Observe an actual OTLP export at requests' public transport boundary. + + Recent OTel releases delegate HTTP exporting to a shared client and no + longer store `_timeout` on the exporter. Verify behavior, not its layout. + """ + timeouts = [] + + def send(session, request, **kwargs): + assert request.method == "POST" + assert request.body # An encoded OTLP payload, not just construction. + timeouts.append(kwargs["timeout"]) + response = requests.Response() + response.status_code = 200 + response.request = request + return response + + # Older OTel calls Session.post(), newer releases call Session.request(). + # Both reach this public method with the effective per-attempt timeout. + monkeypatch.setattr(requests.Session, "send", send) + + def check(processor, expected): + provider = SDKTracerProvider() + provider.add_span_processor(processor) + try: + with provider.get_tracer(__name__).start_as_current_span("timeout-contract"): + pass + assert provider.force_flush() + assert len(timeouts) == 1 + # OTel subtracts elapsed serialization time from the export budget. + assert 0 < timeouts[0] <= expected + assert timeouts[0] == pytest.approx(expected, abs=1) + finally: + provider.shutdown() + + return check + + class TestExporterTuning: """timeout must reach the default OTLP exporter (both processors).""" + def test_batch_forwards_timeout(self, assert_http_export_timeout): + assert_http_export_timeout(BatchSpanProcessor(timeout=42), 42) + + def test_simple_forwards_timeout(self, assert_http_export_timeout): + assert_http_export_timeout(SimpleSpanProcessor(timeout=7), 7) + + def test_unset_timeout_uses_upstream_default(self, clean_exporter_env, assert_http_export_timeout): + """Backward-compat: no timeout -> upstream default (10s).""" + assert_http_export_timeout(BatchSpanProcessor(span_exporter=None), 10) + + @pytest.mark.parametrize("traces_timeout", [None, "19"]) + def test_unset_timeout_respects_exporter_env( + self, clean_exporter_env, monkeypatch, assert_http_export_timeout, traces_timeout + ): + monkeypatch.setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "17") + if traces_timeout is not None: + monkeypatch.setenv("OTEL_EXPORTER_OTLP_TRACES_TIMEOUT", traces_timeout) + assert_http_export_timeout(SimpleSpanProcessor(), 19 if traces_timeout else 17) + @pytest.mark.parametrize("processor_type", [BatchSpanProcessor, SimpleSpanProcessor]) @pytest.mark.parametrize("timeout", [7, 42, None]) def test_timeout_reaches_http_request(self, processor_type, timeout, clean_exporter_env): diff --git a/python/tests/test_chat_input_leaf_privacy.py b/python/tests/test_chat_input_leaf_privacy.py new file mode 100644 index 000000000..676691b34 --- /dev/null +++ b/python/tests/test_chat_input_leaf_privacy.py @@ -0,0 +1,143 @@ +"""Regressions for validation before representation, and shared copy bounds.""" +import copy +import json + +import pytest +from fi_instrumentation import REDACTED_VALUE, TraceConfig +from fi_instrumentation.instrumentation.config import ChatInput +from fi_instrumentation.instrumentation.pii_redaction import redact_pii_in_string + + +@pytest.mark.parametrize("separator", ["\t", "\n", "\r"]) +@pytest.mark.parametrize("structured", [False, True]) +@pytest.mark.parametrize("key", ["input.value", "raw.input"]) +def test_pii_leaves_are_scanned_before_escaping(separator, structured, key): + pii = separator.join(["123", "45", "6789"]) + assert redact_pii_in_string(pii) == "" + content = [{"type": "text", "text": pii}] if structured else pii + payload = {"model": "model", "messages": [{"role": "user", "content": content}], + "stop": [pii], "user": pii} + original = copy.deepcopy(payload) + config = TraceConfig(hide_input_images=True, pii_redaction=True) + projection = ChatInput(payload).masked(config) + assert projection["messages"][0]["content"] == ( + [{"type": "text", "text": ""}] if structured else "" + ) + assert projection["stop"] == [""] and projection["user"] == "" + assert json.loads(config.mask(key, ChatInput(payload))) == projection + assert payload == original + + +@pytest.mark.parametrize("url", ["HTTPS://example.invalid/image", "hTtPs://example.invalid/image", "HtTp://example.invalid/image"]) +@pytest.mark.parametrize("hide", ["hide_input_images", "hide_input_text"]) +def test_case_insensitive_scheme_preserves_original_reference(url, hide): + payload = {"model": "model", "messages": [{"role": "user", "content": [ + {"type": "text", "text": "visible"}, {"type": "image_url", "image_url": {"url": url}}, + ]}]} + result = json.loads(TraceConfig(**{hide: True}).mask("input.value", ChatInput(payload))) + text, image = result["messages"][0]["content"] + assert text["text"] == (REDACTED_VALUE if hide == "hide_input_text" else "visible") + assert image["image_url"] == (REDACTED_VALUE if hide == "hide_input_images" else {"url": url}) + + +@pytest.mark.parametrize("url", ["ftp://example.invalid/image", "javascript:alert(1)", "relative.png"]) +def test_unsupported_image_schemes_still_fail_closed(url): + payload = {"model": "model", "messages": [{"role": "user", "content": [ + {"type": "image_url", "image_url": url}, + ]}]} + assert TraceConfig(hide_input_images=True).mask("input.value", ChatInput(payload)) == REDACTED_VALUE + + +@pytest.mark.parametrize("limit", [31, 32]) +def test_mixed_case_data_scheme_keeps_base64_limit(limit): + url = "DaTa:image/png;base64," + "x" * 10 + assert len(url) == 32 + payload = {"model": "model", "messages": [{"role": "user", "content": [ + {"type": "image_url", "image_url": url}, + ]}]} + result = ChatInput(payload).masked(TraceConfig(base64_image_max_length=limit)) + assert result["messages"][0]["content"][0]["image_url"] == (url if limit == 32 else REDACTED_VALUE) + + +@pytest.mark.parametrize("content_nodes,count,allowed", [ + (0, 9999, True), (0, 10000, False), (0, 10001, False), + (1, 9998, True), (1, 9999, False), +]) +def test_stop_list_shares_content_copy_budget(content_nodes, count, allowed): + payload = {"model": "model", "messages": ([{"role": "user", "content": "text"}] if content_nodes else []), + "stop": ["x"] * count} + result = TraceConfig(hide_input_images=True).mask("input.value", ChatInput(payload)) + if allowed: + assert json.loads(result)["stop"] == payload["stop"] + else: + assert result == REDACTED_VALUE + assert len(payload["stop"]) == count + + +def test_over_budget_list_rejected_before_scanning_or_copying(monkeypatch): + from fi_instrumentation.instrumentation import _chat_input + + def forbidden(*args, **kwargs): + raise AssertionError("over-budget list was traversed") + + monkeypatch.setattr(_chat_input, "_passive", forbidden) + monkeypatch.setattr(_chat_input, "redact_pii_in_string", forbidden) + payload = {"model": "model", "messages": [], "stop": ["x"] * 10001} + assert TraceConfig(hide_input_images=True, pii_redaction=True).mask("input.value", ChatInput(payload)) == REDACTED_VALUE + + +class Active: + def touch(self, *args, **kwargs): + raise AssertionError("hidden or invalid protocol evaluated") + __str__ = __iter__ = __call__ = model_dump = touch + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_input_messages"]) +def test_pii_does_not_evaluate_hidden_payload(flag): + config = TraceConfig(pii_redaction=True, **{flag: True}) + assert config.mask("input.value", ChatInput(Active())) == REDACTED_VALUE + + +def test_independent_invocations_validate_without_hidden_message_access(): + payload = {"model": "model", "messages": Active(), "temperature": 0.7, "max_tokens": 100, + "tools": Active(), "unknown": Active(), "stop": ["123\t45\t6789"]} + config = TraceConfig(hide_input_messages=True, pii_redaction=True) + value = ChatInput(payload) + assert value.masked(config) is None + assert value.masked_invocation_parameters(config) == { + "temperature": 0.7, "max_tokens": 100, "tools": REDACTED_VALUE, "stop": [""], + } + payload["temperature"] = Active() + assert value.masked_invocation_parameters(config) is None + assert ChatInput(Active()).masked_invocation_parameters(TraceConfig(hide_inputs=True)) is None + + +def test_pii_never_scans_unvalidated_string_subclasses(): + class CustomString(str): + pass + payload = {"model": "model", "messages": [{"role": "user", "content": CustomString("123\t45\t6789")}]} + assert TraceConfig(hide_input_images=True, pii_redaction=True).mask("input.value", ChatInput(payload)) == REDACTED_VALUE + + +@pytest.mark.parametrize("separator", ["\t", "\n", "\r", "\x0b", "\x0c"]) +def test_pii_dict_keys_are_scanned_before_escaping(separator): + pii = separator.join(["531", "72", "4086"]) + payload = {"model": "model", "messages": [{"role": "user", "content": "x"}], + "response_format": {"type": "json_schema", "json_schema": { + "name": "s", "schema": {"type": "object", "properties": {pii: {"type": "string"}}}}}} + config = TraceConfig(pii_redaction=True) + exported = config.mask("input.value", ChatInput(payload)) + assert "531" not in exported and "" in exported + assert pii in payload["response_format"]["json_schema"]["schema"]["properties"] + + +@pytest.mark.parametrize("prefix", ["data:image/png;BASE64,", "DATA:IMAGE/PNG;BASE64,", "data:image/png;Base64,"]) +def test_base64_length_limit_marker_is_case_insensitive(prefix): + url = prefix + "A" * 230 + payload = {"model": "model", "messages": [{"role": "user", "content": [ + {"type": "text", "text": "visible"}, {"type": "image_url", "image_url": {"url": url}}]}]} + config = TraceConfig(hide_input_text=True, base64_image_max_length=64) + exported = config.mask("input.value", ChatInput(payload)) + assert "A" * 230 not in exported + from fi_instrumentation.instrumentation.config import is_base64_url + assert is_base64_url(url) diff --git a/python/tests/test_chat_input_privacy.py b/python/tests/test_chat_input_privacy.py new file mode 100644 index 000000000..b1f45c22f --- /dev/null +++ b/python/tests/test_chat_input_privacy.py @@ -0,0 +1,276 @@ +"""Core-owned modality boundaries; real protobuf export, never trusted JSON.""" +import copy +import json +import threading +from contextlib import contextmanager +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer + +import pytest +from fi_instrumentation import FITracer, REDACTED_VALUE, TraceConfig +from fi_instrumentation.instrumentation.config import ChatInput +from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter +from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.sdk.trace.export import SimpleSpanProcessor + +TEXT = "PRIVATE-TEXT-SENTINEL" +IMAGE = "data:image/png;base64,PRIVATE-IMAGE-SENTINEL" +SECRET = "TRANSPORT-SECRET-SENTINEL" + + +def payload(): + return {"model": "visible-model", "messages": [{"role": "user", "content": [ + {"type": "text", "text": TEXT}, + {"type": "image_url", "image_url": {"url": IMAGE, "detail": "auto"}}, + ]}], "temperature": 0.5, "stop": "private-stop", "extra_headers": {"token": SECRET}} + + +@contextmanager +def exported(config): + records = [] + + class Collector(BaseHTTPRequestHandler): + def do_POST(self): + data = self.rfile.read(int(self.headers["Content-Length"])) + ExportTraceServiceRequest.FromString(data) + records.append(data) + self.send_response(200) + self.end_headers() + + def log_message(self, *args): + pass + + server = ThreadingHTTPServer(("127.0.0.1", 0), Collector) + thread = threading.Thread(target=lambda: server.serve_forever(poll_interval=0.01), daemon=True) + thread.start() + provider = TracerProvider() + provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter( + endpoint=f"http://127.0.0.1:{server.server_port}/v1/traces", timeout=5, + ))) + tracer = FITracer(provider.get_tracer(__name__), config=config) + try: + yield tracer, records + finally: + provider.shutdown() + server.shutdown() + server.server_close() + thread.join(timeout=5) + assert not thread.is_alive() + + +def attributes(records): + spans = [span for data in records + for rs in ExportTraceServiceRequest.FromString(data).resource_spans + for ss in rs.scope_spans for span in ss.spans] + assert len(spans) == 1 + return {a.key: getattr(a.value, a.value.WhichOneof("value")) for a in spans[0].attributes} + + +@pytest.mark.parametrize("key", ["input.value", "raw.input"]) +@pytest.mark.parametrize("options,hidden", [ + ({}, []), + ({"hide_input_images": True}, [IMAGE]), + ({"hide_input_text": True}, [TEXT]), + ({"hide_inputs": True}, [TEXT, IMAGE]), + ({"hide_input_messages": True}, [TEXT, IMAGE]), + ({"hide_input_images": True, "hide_input_text": True}, [TEXT, IMAGE]), + ({"base64_image_max_length": len(IMAGE) - 1}, [IMAGE]), + ({"base64_image_max_length": len(IMAGE)}, []), + ({"hide_outputs": True}, []), + ({"hide_llm_invocation_parameters": True}, []), +]) +def test_typed_modalities_in_actual_otlp(key, options, hidden): + original = payload() + unchanged = copy.deepcopy(original) + config = TraceConfig(**options) + with exported(config) as (tracer, records): + span = tracer.start_span("typed-input") + span.set_attribute(key, ChatInput(original)) + span.set_attribute("gen_ai.request.model", "visible-model") + span.set_attribute("gen_ai.usage.input_tokens", 7) + span.end() + wire = b"".join(records) + attrs = attributes(records) + assert SECRET.encode() not in wire + for value in hidden: + assert value.encode() not in wire + if TEXT not in hidden: + assert TEXT in attrs[key] + if IMAGE not in hidden: + assert IMAGE in attrs[key] + if config.hide_inputs or config.hide_input_messages: + assert attrs[key] == REDACTED_VALUE + else: + request = json.loads(attrs[key]) + assert request["messages"][0]["role"] == "user" + assert len(request["messages"][0]["content"]) == 2 + if config.hide_llm_invocation_parameters: + assert "temperature" not in request and "stop" not in request + else: + assert request["temperature"] == 0.5 + assert attrs["gen_ai.request.model"] == "visible-model" + assert attrs["gen_ai.usage.input_tokens"] == 7 + assert original == unchanged + + +class Active: + def __call__(self): + raise AssertionError("must not call") + + def __str__(self): + raise AssertionError("must not stringify") + + def model_dump(self): + raise AssertionError("must not serialize") + + def __iter__(self): + raise AssertionError("must not iterate") + + +class ActiveDict(dict): + def items(self): + raise AssertionError("must not inspect a dict subclass") + + +class ActiveString(str): + def startswith(self, *args): + raise AssertionError("must not inspect a str subclass") + + +def invalid_values(): + values = [Active(), ActiveDict(payload()), "{\"trusted\":true}", lambda: payload(), None] + for location, value in [ + ("model", Active()), ("messages", Active()), + ("messages", [ActiveDict(role="user", content=TEXT)]), + ("messages", [{"role": ActiveString("user"), "content": TEXT}]), + ("messages", [{"role": "user", "content": Active()}]), + ("messages", [{"role": "user", "content": [{"type": "text", "text": Active()}]}]), + ("messages", [{"role": "user", "content": [{"type": "image_url", "image_url": {"url": ActiveString(IMAGE)}}]}]), + ("messages", [{"role": "user", "content": [{"type": "image_url", "image_url": {"url": TEXT}}]}]), + ("messages", [{"role": "user", "content": [{"text": TEXT}]}]), + ("temperature", float("nan")), ("temperature", Active()), + ]: + request = payload() + request[location] = value + values.append(request) + cyclic = []; cyclic.append(cyclic) + values.append({"model": "m", "messages": [{"role": "user", "content": cyclic}]}) + return values + + +@pytest.mark.parametrize("value", invalid_values()) +@pytest.mark.parametrize("flag", ["hide_input_text", "hide_input_images"]) +def test_malformed_and_active_values_fail_closed_without_hooks(value, flag): + config = TraceConfig(**{flag: True}) + structured = ChatInput(value) + assert config.mask("input.value", structured) == REDACTED_VALUE + # Forge without __init__, or replace the slot after a legitimate construction. + forged = object.__new__(ChatInput) + forged._payload = value + assert config.mask("raw.input", forged) == REDACTED_VALUE + with exported(config) as (tracer, records): + span = tracer.start_span("malformed") + span.set_attribute("input.value", forged) + span.end() + assert attributes(records)["input.value"] == REDACTED_VALUE + assert TEXT.encode() not in b"".join(records) + assert IMAGE.encode() not in b"".join(records) + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_input_messages"]) +def test_whole_input_hiding_never_inspects_payload(flag): + assert TraceConfig(**{flag: True}).mask("input.value", ChatInput(Active())) == REDACTED_VALUE + + +def test_unknown_fields_and_forged_labels_cannot_export_hidden_data(): + request = payload() + request["trusted"] = True + request["unknown"] = Active() + request["messages"][0]["private_extension"] = IMAGE + request["messages"][0]["content"].extend([ + {"type": "already_sanitized", "text": IMAGE}, + {"type": "text", "text": "allowed", "image_url": IMAGE}, + ]) + with exported(TraceConfig(hide_input_images=True)) as (tracer, records): + span = tracer.start_span("unknown-fields") + span.set_attribute("input.value", ChatInput(request)) + span.end() + wire = b"".join(records) + assert IMAGE.encode() not in wire and SECRET.encode() not in wire + assert TEXT.encode() in wire + assert "unknown" not in attributes(records)["input.value"] + + +def test_hidden_opaque_parameters_are_not_evaluated_and_invocations_are_excluded(): + request = payload() + request["tools"] = Active() + request["messages"][0]["tool_calls"] = Active() + masked = TraceConfig(hide_input_images=True).mask("input.value", ChatInput(request)) + assert TEXT in masked and IMAGE not in masked + request["messages"] = [] + request["temperature"] = Active() + masked = TraceConfig(hide_llm_invocation_parameters=True).mask("input.value", ChatInput(request)) + assert json.loads(masked) == {"model": "visible-model", "messages": []} + + +def test_snapshot_is_detached_and_policy_is_reapplied_after_forging(): + request = payload() + value = ChatInput(request) + config = TraceConfig(hide_input_images=True) + detached = value.masked(config) + detached["messages"][0]["content"][0]["text"] = "changed" + assert TEXT in config.mask("input.value", value) + value._payload = "forged trusted JSON" + assert config.mask("input.value", value) == REDACTED_VALUE + assert config.mask("input.value", object.__new__(ChatInput)) == REDACTED_VALUE + + +@pytest.mark.parametrize("key", ["output.value", "raw.output", "metadata", "input.value.nested"]) +def test_no_output_or_attribute_alias_escape_hatch(key): + assert TraceConfig().mask(key, ChatInput(payload())) == REDACTED_VALUE + + +def test_opaque_json_and_lazy_values_still_cannot_opt_in(): + config = TraceConfig(hide_input_images=True) + assert config.mask("input.value", json.dumps(payload())) == REDACTED_VALUE + assert config.mask("input.value", Active()) == REDACTED_VALUE + assert config.mask("input.value", lambda: ChatInput(payload())) == REDACTED_VALUE + assert config.mask("raw.input", {"type": "ChatInput", "payload": payload()}) == REDACTED_VALUE + + +def test_huge_builtin_integer_cannot_break_serialization(): + request = payload() + request['temperature'] = 10 ** 10000 + # CPython's default integer digit limit rejects this passive but unserializable + # value. With a disabled interpreter limit, a normal JSON value is also safe. + result = TraceConfig(hide_input_images=True).mask('input.value', ChatInput(request)) + assert IMAGE not in result + assert result == REDACTED_VALUE or json.loads(result)['model'] == 'visible-model' + + +def test_pii_policy_still_runs_after_structural_masking(): + request = payload() + request['messages'][0]['content'][0]['text'] = 'contact user@example.com' + masked = TraceConfig(hide_input_images=True, pii_redaction=True).mask('input.value', ChatInput(request)) + assert 'user@example.com' not in masked and IMAGE not in masked + + +def test_sampler_returned_opaque_strings_are_not_trusted(): + from opentelemetry.sdk.trace.sampling import Decision, Sampler, SamplingResult + from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter + + class ReturnsPrivateJSON(Sampler): + def should_sample(self, *args, **kwargs): + return SamplingResult(Decision.RECORD_AND_SAMPLE, {'input.value': json.dumps(payload())}) + + def get_description(self): + return 'synthetic-opaque-sampler' + + provider = TracerProvider(sampler=ReturnsPrivateJSON()) + exporter = InMemorySpanExporter() + provider.add_span_processor(SimpleSpanProcessor(exporter)) + tracer = FITracer(provider.get_tracer(__name__), TraceConfig(hide_input_images=True)) + span = tracer.start_span('sampled', attributes={'input.value': ChatInput(payload())}) + span.end() + assert exporter.get_finished_spans()[0].attributes['input.value'] == REDACTED_VALUE + provider.shutdown() diff --git a/python/tests/test_granular_payload_privacy.py b/python/tests/test_granular_payload_privacy.py new file mode 100644 index 000000000..08ffb0b53 --- /dev/null +++ b/python/tests/test_granular_payload_privacy.py @@ -0,0 +1,41 @@ +"""Opaque payloads cannot bypass granular content privacy.""" +import pytest + +from fi_instrumentation import TraceConfig +from fi_instrumentation.instrumentation.config import REDACTED_VALUE + + +@pytest.mark.parametrize("flag,keys", [ + ("hide_input_text", ("input.value", "raw.input", "gen_ai.prompt.template.variables")), + ("hide_input_messages", ("input.value", "raw.input")), + ("hide_input_images", ("input.value", "raw.input")), + ("hide_output_text", ("output.value", "raw.output")), + ("hide_output_messages", ("output.value", "raw.output")), +]) +def test_opaque_payloads_are_not_evaluated(flag, keys): + config = TraceConfig(**{flag: True}) + + def private_value(): + raise AssertionError("private lazy value must not be evaluated") + + for key in keys: + assert config.mask(key, private_value) == REDACTED_VALUE + if "messages" not in key: + assert config.mask(key + ".nested", private_value) == REDACTED_VALUE + assert config.mask("gen_ai.request.model", "visible-model") == "visible-model" + assert config.mask("gen_ai.usage.input_tokens", 12) == 12 + + +@pytest.mark.parametrize("direction,opposite", [("input", "output"), ("output", "input")]) +def test_text_privacy_is_directional(direction, opposite): + config = TraceConfig(**{"hide_" + direction + "_text": True}) + assert config.mask(direction + ".value", "private") == REDACTED_VALUE + assert config.mask(opposite + ".value", "visible") == "visible" + assert config.mask("gen_ai." + direction + ".messages.0.message.role", "user") == "user" + assert config.mask("gen_ai." + direction + ".messages.0.message.content", "private") == REDACTED_VALUE + + +def test_text_flag_keeps_explicitly_typed_images(): + config = TraceConfig(hide_input_text=True) + assert config.mask("gen_ai.input.images.0", "image-reference") == "image-reference" + assert config.mask("gen_ai.input.messages.0.message.contents.0.message_content.image.image.url", "image-reference") == "image-reference" diff --git a/python/tests/test_structured_content_privacy.py b/python/tests/test_structured_content_privacy.py index 34e003eda..4deda319f 100644 --- a/python/tests/test_structured_content_privacy.py +++ b/python/tests/test_structured_content_privacy.py @@ -20,7 +20,14 @@ @pytest.mark.parametrize( "direction,key", - [("inputs", "gen_ai.tool.call.arguments"), ("outputs", "gen_ai.tool.call.result")], + [ + ("inputs", "gen_ai.tool.call.arguments"), + ("outputs", "gen_ai.tool.call.result"), + ("input_text", "input.value"), + ("input_text", "raw.input"), + ("output_text", "output.value"), + ("output_text", "raw.output"), + ], ) def test_structured_credentials_hidden_on_native_span_surfaces(direction, key): sentinel = "synthetic-credential-never-export" diff --git a/typescript/packages/traceai_openai/src/instrumentation.ts b/typescript/packages/traceai_openai/src/instrumentation.ts index 850080ce0..cc4ea2ac7 100644 --- a/typescript/packages/traceai_openai/src/instrumentation.ts +++ b/typescript/packages/traceai_openai/src/instrumentation.ts @@ -61,17 +61,25 @@ import { const MODULE_NAME = "openai"; -/** - * Flag to check if the openai module has been patched - * Note: This is a fallback in case the module is made immutable (e.x. Deno, webpack, etc.) - */ -let _isFIPatched = false; +// Both public package entry points (and duplicate package installations) must +// agree on the owner. A module-local WeakMap lets one build overwrite another's +// wrappers. Key by SDK class, without writing to immutable module namespaces. +const patchRegistryKey = Symbol.for("@traceai/openai/patch-registry/v1"); +interface PatchRegistry { + owners: WeakMap; + count: number; +} +const registryHost = globalThis as typeof globalThis & { + [patchRegistryKey]?: PatchRegistry; +}; +const patchRegistry = (registryHost[patchRegistryKey] ??= { + owners: new WeakMap(), + count: 0, +}); -/** - * function to check if instrumentation is enabled / disabled - */ +/** Whether any SDK class is currently patched across the package entry points. */ export function isPatched() { - return _isFIPatched; + return patchRegistry.count > 0; } /** @@ -98,10 +106,9 @@ function getExecContext(span: Span) { export class OpenAIInstrumentation extends InstrumentationBase{ private fiTracer!: FITracer; private _traceConfig?: TraceConfigOptions; - private manuallyPatchedModule?: typeof openai; - // Only the instance that applied a patch may remove it. Another instrumentor - // sharing the module returns early from patch() but is still asked to unpatch. - private readonly patchedModules = new WeakSet(); + // Lazily initialized: InstrumentationBase can patch during super(). + // A Set is needed so disable() also undoes every manually patched ESM SDK. + private patchedModules?: Set; constructor({ instrumentationConfig, @@ -148,17 +155,13 @@ export class OpenAIInstrumentation extends InstrumentationBase{ * @param {openai} module */ manuallyInstrument(module: typeof openai) { - if (_isFIPatched) return; this.patch(module); - if (_isFIPatched) this.manuallyPatchedModule = module; } public override disable(): void { super.disable(); - // The base class tracks require-hook patches, not manually loaded ESM clients. - if (this.manuallyPatchedModule) { - this.unpatch(this.manuallyPatchedModule); - this.manuallyPatchedModule = undefined; + for (const module of this.patchedModules ?? []) { + this.unpatch(module); } } @@ -166,11 +169,12 @@ export class OpenAIInstrumentation extends InstrumentationBase{ * Patches the OpenAI module */ private patch( - module: typeof openai & { fiPatched?: boolean }, + module: typeof openai, moduleVersion?: string, ) { // diag.debug(`Applying patch for ${MODULE_NAME}@${moduleVersion}`); - if (module?.fiPatched || _isFIPatched) { + const sdk = module?.OpenAI; + if (sdk && patchRegistry.owners.has(sdk)) { return module; } const resources = [ @@ -193,7 +197,7 @@ export class OpenAIInstrumentation extends InstrumentationBase{ // Here, we ensure it uses the (potentially updated) Tracer. // Accessing FITracer's internal tracer `tracer` for comparison. // This assumes FITracer has an internal property named `tracer`. - if (!(instrumentation.fiTracer as any).tracer || (instrumentation.fiTracer as any).tracer !== instrumentation.tracer) { + if (!(instrumentation.fiTracer as any)?.tracer || (instrumentation.fiTracer as any).tracer !== instrumentation.tracer) { // diag.debug( // `OpenAIInstrumentation.patch: fiTracer's internal tracer (${(instrumentation.fiTracer as any).tracer?.constructor?.name}) ` + // `differs from current base tracer (${instrumentation.tracer?.constructor?.name}) or is not set. Re-initializing fiTracer.` @@ -597,42 +601,34 @@ export class OpenAIInstrumentation extends InstrumentationBase{ ); } - _isFIPatched = true; - this.patchedModules.add(module); - try { - // This can fail if the module is made immutable via the runtime or bundler - module.fiPatched = true; - } catch (e) { - // diag.debug(`Failed to set ${MODULE_NAME} patched flag on the module`, e); - diag.warn(`Failed to set fiPatched flag on module '${MODULE_NAME}'. This is usually not an issue. Error: ${e}`); - } + // Keep the legacy diagnostic property, but never use it as the guard. + // Immutable class exports still work via the identity map. + try { (sdk as typeof openai & { fiPatched?: boolean }).fiPatched = true; } catch { /* immutable SDK */ } + patchRegistry.owners.set(sdk, this); + (this.patchedModules ??= new Set()).add(module); + patchRegistry.count++; return module; } /** * Un-patches the OpenAI module's chat completions API */ - private unpatch( - moduleExports: typeof openai & { fiPatched?: boolean }, - moduleVersion?: string, - ) { - // diag.debug(`Removing patch for ${MODULE_NAME}@${moduleVersion}`); - if (!moduleExports || !this.patchedModules.delete(moduleExports)) return; - this._unwrap(moduleExports.OpenAI.Chat.Completions.prototype, "create"); - this._unwrap(moduleExports.OpenAI.Completions.prototype, "create"); - this._unwrap(moduleExports.OpenAI.Embeddings.prototype, "create"); - if (moduleExports.OpenAI.Responses) { - this._unwrap(moduleExports.OpenAI.Responses.prototype, "create"); - } - - _isFIPatched = false; - try { - // This can fail if the module is made immutable via the runtime or bundler - moduleExports.fiPatched = false; - } catch (e) { - diag.warn(`Failed to unset fiPatched flag on module '${MODULE_NAME}'. This is usually not an issue. Error: ${e}`); + private unpatch(moduleExports: typeof openai, moduleVersion?: string) { + const sdk = moduleExports?.OpenAI; + if (!sdk || patchRegistry.owners.get(sdk) !== this) return; + this._unwrap(sdk.Chat.Completions.prototype, "create"); + this._unwrap(sdk.Completions.prototype, "create"); + this._unwrap(sdk.Embeddings.prototype, "create"); + if (sdk.Responses) this._unwrap(sdk.Responses.prototype, "create"); + try { (sdk as typeof openai & { fiPatched?: boolean }).fiPatched = false; } catch { /* immutable SDK */ } + patchRegistry.owners.delete(sdk); + // An automatic require hook may use a different namespace for this class. + for (const module of this.patchedModules ?? []) { + if (module.OpenAI === sdk) this.patchedModules!.delete(module); } + patchRegistry.count--; } + } /** Observe the caller's iterator, including errors and early return, without a diff --git a/typescript/packages/traceai_openai/test/mixedImports.cjs b/typescript/packages/traceai_openai/test/mixedImports.cjs new file mode 100644 index 000000000..dd29b5219 --- /dev/null +++ b/typescript/packages/traceai_openai/test/mixedImports.cjs @@ -0,0 +1,123 @@ +// Run against packed consumers at the SDK floor and latest, not workspace mocks. +const { test, after, afterEach } = require('node:test'); +const assert = require('node:assert/strict'); +const { createRequire } = require('node:module'); +const { writeFileSync } = require('node:fs'); +const { pathToFileURL } = require('node:url'); + +const base = process.env.OPENAI_CONSUMER_DIR; +const req = createRequire(base + '/package.json'); +const CJS = req('openai'); +const { OpenAIInstrumentation, isPatched } = req('@traceai/openai'); +const { BasicTracerProvider, SimpleSpanProcessor, InMemorySpanExporter } = req('@opentelemetry/sdk-trace-base'); +const exporter = new InMemorySpanExporter(); +const provider = new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] }); +const instances = []; +writeFileSync(base + '/mixed-sdk.mjs', 'import OpenAI from "openai"; export { OpenAI }; export { OpenAIInstrumentation, isPatched } from "@traceai/openai";\n'); +const load = () => import(pathToFileURL(base + '/mixed-sdk.mjs').href); + +function instrument(Instrumentation = OpenAIInstrumentation) { + const inst = new Instrumentation({ instrumentationConfig: { enabled: false } }); + inst.setTracerProvider(provider); + instances.push(inst); + return inst; +} +async function call(SDK) { + const client = new SDK({ apiKey: 'synthetic-key', maxRetries: 0, fetch: async () => new Response(JSON.stringify({ + id: 'chat', object: 'chat.completion', created: 1, model: 'test', + choices: [{ index: 0, message: { role: 'assistant', content: 'hello' }, finish_reason: 'stop' }], + usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }, + }), { headers: { 'content-type': 'application/json' } }) }); + await client.chat.completions.create({ model: 'test', messages: [{ role: 'user', content: 'hello' }] }); +} +afterEach(async () => { + for (const inst of instances.splice(0)) inst.disable(); + await provider.forceFlush(); + exporter.reset(); +}); +after(() => provider.shutdown()); + +test('ESM-only control', async () => { + const esm = await load(); + instrument().manuallyInstrument(esm.OpenAI); + await call(esm.OpenAI); + assert.equal(exporter.getFinishedSpans().length, 1); +}); + +for (const reverse of [false, true]) { + test(`mixed SDKs, immutable namespace, duplicate alias, disable and repatch (reverse=${reverse})`, async () => { + const esm = await load(); // A genuine immutable module namespace. + const modules = reverse ? [esm, CJS] : [CJS, esm]; + const inst = instrument(); + for (const module of modules) inst.manuallyInstrument(module); + inst.manuallyInstrument({ OpenAI: CJS.OpenAI }); // Same class through another namespace. + inst.manuallyInstrument(esm.OpenAI); + await call(CJS); + await call(esm.OpenAI); + assert.equal(exporter.getFinishedSpans().length, 2); + assert.equal(isPatched(), true); + inst.disable(); + assert.equal(isPatched(), false); + await call(CJS); + await call(esm.OpenAI); + assert.equal(exporter.getFinishedSpans().length, 2, 'disable unpatches every SDK'); + for (const module of modules) inst.manuallyInstrument(module); + await call(CJS); + await call(esm.OpenAI); + assert.equal(exporter.getFinishedSpans().length, 4); + }); +} + +test('disabling one owner leaves the other SDK and its tracer intact', async () => { + const esm = await load(); + const owner = instrument(); + const other = instrument(); + owner.manuallyInstrument(CJS); + other.manuallyInstrument(CJS); // Not an owner of this class. + other.manuallyInstrument(esm); + other.disable(); + assert.equal(isPatched(), true); + await call(CJS); + await call(esm.OpenAI); + assert.equal(exporter.getFinishedSpans().length, 1); + owner.disable(); + assert.equal(isPatched(), false); +}); + +for (const reverse of [false, true]) { + for (const sdkFormat of ['cjs', 'esm']) { + test(`public CJS/ESM instrumentors share ownership (${sdkFormat}, reverse=${reverse})`, async () => { + const esm = await load(); + assert.notEqual(esm.OpenAIInstrumentation, OpenAIInstrumentation, 'exercise both public entry points'); + const constructors = [OpenAIInstrumentation, esm.OpenAIInstrumentation]; + if (reverse) constructors.reverse(); + const owner = instrument(constructors[0]); + const other = instrument(constructors[1]); + const module = sdkFormat === 'cjs' ? CJS : esm; // Includes immutable ESM namespace. + const SDK = module.OpenAI; + const original = SDK.Chat.Completions.prototype.create; + owner.manuallyInstrument(module); + other.manuallyInstrument(module); + await call(SDK); + assert.equal(exporter.getFinishedSpans().length, 1, 'no duplicate spans'); + other.disable(); + await call(SDK); + assert.equal(exporter.getFinishedSpans().length, 2, 'non-owner disable must retain the first owner'); + assert.equal(isPatched(), true); + assert.equal(esm.isPatched(), true); + owner.disable(); + assert.equal(SDK.Chat.Completions.prototype.create, original); + assert.equal(isPatched(), false); + assert.equal(esm.isPatched(), false); + await call(SDK); + assert.equal(exporter.getFinishedSpans().length, 2); + // Either entry point can acquire ownership after the original owner leaves. + other.manuallyInstrument(module); + await call(SDK); + assert.equal(exporter.getFinishedSpans().length, 3); + owner.disable(); + await call(SDK); + assert.equal(exporter.getFinishedSpans().length, 4, 'former owner cannot unwrap the new owner'); + }); + } +}