diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 145eb42c4..2c01cc259 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -11,12 +11,14 @@ # as well as @temporalio/sdk, so the SDK team can continue to # manage repo-wide concerns. /temporalio/contrib/google_adk_agents/ @temporalio/ai-sdk @temporalio/sdk +/temporalio/contrib/google_genai/ @temporalio/ai-sdk @temporalio/sdk /temporalio/contrib/langgraph/ @temporalio/ai-sdk @temporalio/sdk /temporalio/contrib/langsmith/ @temporalio/ai-sdk @temporalio/sdk /temporalio/contrib/openai_agents/ @temporalio/ai-sdk @temporalio/sdk /temporalio/contrib/strands/ @temporalio/ai-sdk @temporalio/sdk /temporalio/contrib/workflow_streams/ @temporalio/ai-sdk @temporalio/sdk /tests/contrib/google_adk_agents/ @temporalio/ai-sdk @temporalio/sdk +/tests/contrib/google_genai/ @temporalio/ai-sdk @temporalio/sdk /tests/contrib/langgraph/ @temporalio/ai-sdk @temporalio/sdk /tests/contrib/langsmith/ @temporalio/ai-sdk @temporalio/sdk /tests/contrib/openai_agents/ @temporalio/ai-sdk @temporalio/sdk diff --git a/pyproject.toml b/pyproject.toml index 99aea21bf..9017519b2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,7 +29,7 @@ grpc = ["grpcio>=1.48.2,<2"] opentelemetry = ["opentelemetry-api>=1.11.1,<2", "opentelemetry-sdk>=1.11.1,<2"] pydantic = ["pydantic>=2.0.0,<3"] openai-agents = ["openai-agents>=0.17.5", "mcp>=1.9.4, <2"] -google-adk = ["google-adk>=1.27.0,<2"] +google-adk = ["google-adk>=2.2.0,<3"] langgraph = ["langgraph>=1.1.0"] langsmith = ["langsmith>=0.7.34,<0.9"] lambda-worker-otel = [ @@ -40,6 +40,7 @@ lambda-worker-otel = [ "opentelemetry-sdk-extension-aws>=2.0.0,<3", ] aioboto3 = ["aioboto3>=10.4.0", "types-aioboto3[s3]>=10.4.0"] +google-genai = ["google-genai>=2.10.0,<3.0.0"] strands-agents = ["strands-agents>=1.39.0"] [project.urls] @@ -88,6 +89,7 @@ dev = [ "async-timeout>=4.0,<6; python_version < '3.11'", "strands-agents>=1.39.0", "strands-agents-tools>=0.5.2", + "mcp>=1.9.4,<2", ] [tool.poe.tasks] @@ -260,4 +262,4 @@ exclude = ["temporalio/bridge/target/**/*"] # Prevent uv commands from building the package by default package = false exclude-newer = "2 weeks" -exclude-newer-package = { openai-agents = false } +exclude-newer-package = { google-adk = false, google-genai = false, openai-agents = false } diff --git a/temporalio/contrib/google_genai/README.md b/temporalio/contrib/google_genai/README.md new file mode 100644 index 000000000..fca5311f5 --- /dev/null +++ b/temporalio/contrib/google_genai/README.md @@ -0,0 +1,285 @@ +# Google Gemini SDK Integration for Temporal + +> ⚠️ **Experimental.** This integration may change in future versions. Use with +> caution in production. + +## Overview + +This plugin lets you use the [Google Gemini SDK](https://googleapis.github.io/python-genai/) +(`google-genai`) inside Temporal workflows with durable execution. Every Gemini +API call becomes a **Temporal activity**, so model calls, tool calls, file +operations, interactions, and managed agents are retried, recorded in history, +and survive worker restarts. + +Key properties: + +- **Credentials never enter the workflow.** The real `genai.Client` lives only + on the worker, inside activities; no API keys or tokens appear in event + history. +- **The SDK's automatic function calling (AFC) loop runs in the workflow**, so + tool wrappers (`activity_as_tool`) work naturally — no manual agent loop. +- **Temporal owns retries.** Configure them via the activity `retry_policy`; the + SDK's own retry loop is rejected to avoid double-retry (see + [Retries & errors](#retries--errors)). + +## Install + +```bash +uv add temporalio google-genai +# For client-side MCP support, also: +uv add mcp +``` + +## Hello World + +```python +import os +from datetime import timedelta + +from google import genai +from google.genai import types + +from temporalio import activity, workflow +from temporalio.client import Client +from temporalio.contrib.google_genai import ( + GoogleGenAIPlugin, + TemporalAsyncClient, + activity_as_tool, +) +from temporalio.worker import Worker +from temporalio.workflow import ActivityConfig + + +# ---- a tool, as a normal Temporal activity (runs on the worker) ---- +@activity.defn +async def get_weather(city: str) -> str: + return f"It's sunny in {city}." + + +# ---- the workflow (runs in the Temporal sandbox) ---- +@workflow.defn +class WeatherAgent: + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + get_weather, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=30), + ), + ), + ], + ), + ) + return response.text or "" + + +# ---- worker setup (outside the sandbox: real client + credentials) ---- +async def main() -> None: + gemini = genai.Client(api_key=os.environ["GOOGLE_API_KEY"]) + plugin = GoogleGenAIPlugin(gemini) + + client = await Client.connect("localhost:7233", plugins=[plugin]) + async with Worker( + client, + task_queue="gemini", + workflows=[WeatherAgent], + activities=[get_weather], + ): + result = await client.execute_workflow( + WeatherAgent.run, + "What's the weather in Tokyo?", + id="weather-1", + task_queue="gemini", + ) + print(result) +``` + +Construct `TemporalAsyncClient` **inside** the workflow; construct the real +`genai.Client` and `GoogleGenAIPlugin` **on the worker**. + +## What this plugin gives you + +| Surface | Workflow API | Runs as | +| --- | --- | --- | +| Model calls | `client.models.generate_content` / `generate_content_stream` | activity (AFC loop in workflow) | +| Tools | `activity_as_tool(fn, ...)` | one activity per tool call | +| Files | `client.files.upload` / `download` | activity | +| File search | `client.file_search_stores.upload_to_file_search_store` | activity | +| Interactions | `client.interactions.create` / `get` / `cancel` / `delete` | whole-operation activity | +| Managed agents | `client.agents.create` / `get` / `list` / `delete` | whole-operation activity | +| MCP (client-side) | `TemporalMcpClientSession(name)` in `tools=[...]` | `list_tools` / `call_tool` activities | + +Streamed responses are batched: the activity drains the stream and the workflow +iterates the collected chunks/events. `client.webhooks` is not supported in +workflows and raises. + +## Tool calling + +`activity_as_tool` wraps any `@activity.defn` function as a Gemini tool. When the +model calls it, the AFC loop (running in the workflow) dispatches it as a +durable activity: + +```python +activity_as_tool( + get_weather, + activity_config=ActivityConfig(start_to_close_timeout=timedelta(seconds=30)), +) +``` + +A timeout is required — `activity_config` must set `start_to_close_timeout` or +`schedule_to_close_timeout` (Temporal needs one; there is no default for tools). + +## MCP support + +Client-side MCP (Gemini Developer API) is wired through the plugin: register the +server on the worker and reference it by name in the workflow. + +```python +from contextlib import asynccontextmanager +import sys + +from mcp import ClientSession, StdioServerParameters +from mcp.client.stdio import stdio_client + +from temporalio.contrib.google_genai import TemporalMcpClientSession + + +# ---- worker: a factory yielding a connected, initialized session ---- +@asynccontextmanager +async def weather_mcp(): + params = StdioServerParameters(command=sys.executable, args=["weather_server.py"]) + async with stdio_client(params) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + yield session + + +plugin = GoogleGenAIPlugin( + genai.Client(api_key=os.environ["GOOGLE_API_KEY"]), + mcp_servers={"weather": weather_mcp}, + mcp_connection_idle_timeout=timedelta(minutes=5), +) + + +# ---- workflow: reference the server by name in the tools list ---- +@workflow.defn +class McpAgent: + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + session = TemporalMcpClientSession( + "weather", + activity_config=ActivityConfig(start_to_close_timeout=timedelta(seconds=30)), + ) + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig(tools=[session]), + ) + return response.text or "" +``` + +The MCP connection lives on the worker (pooled, idle-evicted); the workflow only +carries the server name. Tool discovery and calls run as `{name}-list-tools` / +`{name}-call-tool` activities, so the full tool parameter schema reaches the +model. Set `cache_tools=True` to list a server's tools once per workflow instead +of per turn. + +## Streaming + +`generate_content_stream` works as usual — the workflow iterates chunks (batched +from the activity). To let an **external** consumer (a chat UI) observe chunks in +real time while the workflow runs durably, set `streaming_topic` on the client +and host a [`WorkflowStream`](../workflow_streams/) in the workflow. Each +streamed `GenerateContentResponse` is published to that topic as it arrives: + +```python +from temporalio.contrib.workflow_streams import WorkflowStream + + +@workflow.defn +class StreamingAgent: + @workflow.init + def __init__(self, prompt: str) -> None: + self.stream = WorkflowStream() # required when streaming_topic is set + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient(streaming_topic="gemini") + text = [] + async for chunk in await client.models.generate_content_stream( + model="gemini-2.5-flash", contents=prompt, + ): + text.append(chunk.text or "") + return "".join(text) +``` + +Consume the stream from outside the workflow: + +```python +from temporalio.contrib.workflow_streams import WorkflowStreamClient + + +async def consume(client, workflow_id): + stream = WorkflowStreamClient.create(client, workflow_id) + async for item in stream.subscribe( + ["gemini"], result_type=types.GenerateContentResponse, + ): + print(item.data.text, end="", flush=True) +``` + +The workflow's own iteration is unchanged (it still receives batched chunks for +the SDK to parse); the topic is purely for external real-time observation. If +`streaming_topic` is set but the workflow hosts no `WorkflowStream`, the call +raises `GoogleGenAIError`. Tune flush cadence with +`TemporalAsyncClient(streaming_topic=..., streaming_batch_interval=...)` +(default 100ms). + +## Retries & errors + +Temporal owns retries. Configure them with the activity `retry_policy` via +`activity_config`. The plugin **rejects** the SDK's own retry config so retries +don't compound: + +- Constructing the plugin with a `genai.Client` that has + `http_options.retry_options` raises `ValueError`. +- Setting `http_options.retry_options` on a per-request call raises + `GoogleGenAIError`. + +API-call activities classify failures: transient statuses (408, 429, 5xx) stay +retryable (the activity's `retry_policy` applies); other statuses (e.g. 4xx) are +non-retryable so the workflow fails fast. + +## Vertex AI + +Pass `vertexai=True` to both the worker-side `genai.Client` and the +workflow-side `TemporalAsyncClient`. On the workflow side you must also set +`project` and `location` **explicitly**: + +```python +# worker +genai.Client(vertexai=True, project="my-project", location="us-central1") + +# workflow +TemporalAsyncClient(vertexai=True, project="my-project", location="us-central1") +``` + +Normally the SDK auto-discovers `project`/`location` from the environment +(credentials, ADC, metadata server). That discovery +would be non-deterministic and break replay. Setting them by hand +keeps it deterministic. + +## Composing with other plugins + +`GoogleGenAIPlugin` is a `temporalio.plugin.SimplePlugin`; pass it in the +`plugins=[...]` list alongside others (e.g. OpenTelemetry). It contributes a +Pydantic data converter, the Gemini activities, a sandbox-passthrough config for +`google.genai` (and `mcp`), and registers `GoogleGenAIError` as a workflow +failure type. When composing data converters, construct the plugins so their +converters are compatible. diff --git a/temporalio/contrib/google_genai/__init__.py b/temporalio/contrib/google_genai/__init__.py new file mode 100644 index 000000000..8cedcbc63 --- /dev/null +++ b/temporalio/contrib/google_genai/__init__.py @@ -0,0 +1,119 @@ +"""First-class Temporal integration for the Google Gemini SDK. + +.. warning:: + This module is experimental and may change in future versions. + Use with caution in production environments. + +This integration lets you use the Gemini SDK's async client with full +automatic function calling (AFC) support. Every API call becomes a +**durable Temporal activity**. Tools default to plain workflow methods +that run deterministically in-workflow; wrap any ``@activity.defn`` with +:func:`activity_as_tool` to run a tool as a durable activity instead. + +No credentials are fetched in the workflow, and no auth material appears in +Temporal's event history. + +- :class:`GoogleGenAIPlugin` — registers the Gemini SDK activities using a + caller-provided ``genai.Client`` on the worker side. +- :class:`TemporalAsyncClient` — construct from a workflow to get an + ``AsyncClient`` that routes API calls through activities. +- :func:`activity_as_tool` — convert any ``@activity.defn`` function into a + Gemini tool callable; Gemini's AFC invokes it as a Temporal activity. + +The Interactions API (``client.interactions``) and managed agents +(``client.agents``) are supported as whole-operation activities; streamed +interactions are batched (the activity drains the SSE stream and the +workflow iterates the collected events). ``client.webhooks`` is not +supported in workflows. The Interactions API has no automatic function +calling: declare tools as ``{"type": "function", ...}`` dicts (per the +Gemini docs) and drive the tool loop yourself, executing each call via +``workflow.execute_activity`` or an :func:`activity_as_tool` callable. + +MCP is supported across three paths. Client-side MCP (Gemini Developer API) +uses :class:`TemporalMcpClientSession`: register a server with +``GoogleGenAIPlugin(mcp_servers={name: factory})`` on the worker, then place +``TemporalMcpClientSession(name)`` in a ``generate_content`` ``tools`` list — +the SDK's AFC loop drives it, with ``list_tools`` / ``call_tool`` running as +activities against a pooled worker-side connection. Server-side MCP on Vertex +AI (``Tool(mcp_servers=[McpServer(...)])``) and the Interactions API's MCP step +types are executed by Google's backend and flow through unchanged as request / +response data — no extra wiring needed. Client-side MCP requires the ``mcp`` +package. + +Streaming: set ``TemporalAsyncClient(streaming_topic=...)`` and host a +:class:`temporalio.contrib.workflow_streams.WorkflowStream` in the workflow's +``@workflow.init``. Each ``generate_content_stream`` chunk is then published to +that topic as it arrives, so external consumers can observe model output in real +time while the workflow runs durably; the workflow's own iteration is unchanged. + +Quickstart:: + + # ---- worker setup (outside the Temporal Python Sandbox) ---- + client = genai.Client(api_key=os.environ["GOOGLE_API_KEY"]) + plugin = GoogleGenAIPlugin(client) + + @activity.defn + async def get_weather(state: str) -> str: ... + + # ---- workflow (inside the Temporal Python Sandbox) ---- + @workflow.defn + class AgentWorkflow: + @workflow.run + async def run(self, query: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=query, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + get_weather, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=30), + ), + ), + ], + ), + ) + return response.text +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +from temporalio.contrib.google_genai._errors import GoogleGenAIError +from temporalio.contrib.google_genai._google_genai_plugin import GoogleGenAIPlugin +from temporalio.contrib.google_genai._temporal_async_client import ( + TemporalAsyncClient, +) +from temporalio.contrib.google_genai.workflow import ( + activity_as_tool, +) + +if TYPE_CHECKING: + from temporalio.contrib.google_genai._temporal_mcp import TemporalMcpClientSession + +__all__ = [ + "GoogleGenAIError", + "GoogleGenAIPlugin", + "TemporalAsyncClient", + "TemporalMcpClientSession", + "activity_as_tool", +] + + +def __getattr__(name: str) -> Any: + """Lazily expose ``TemporalMcpClientSession`` without importing ``mcp`` eagerly. + + ``mcp`` is an optional dependency, so importing this package must not require + it; the import (and any resulting ``ImportError``) is deferred until the + symbol is actually accessed. + """ + if name == "TemporalMcpClientSession": + from temporalio.contrib.google_genai._temporal_mcp import ( + TemporalMcpClientSession, + ) + + return TemporalMcpClientSession + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/temporalio/contrib/google_genai/_errors.py b/temporalio/contrib/google_genai/_errors.py new file mode 100644 index 000000000..3f6595e4b --- /dev/null +++ b/temporalio/contrib/google_genai/_errors.py @@ -0,0 +1,16 @@ +"""Error types for the Google Gemini SDK Temporal integration.""" + +from __future__ import annotations + +from temporalio.exceptions import ApplicationError + + +class GoogleGenAIError(ApplicationError): + """Error raised by the Google Gemini Temporal integration. + + Registered with the worker (and replayer) via + ``workflow_failure_exception_types`` so that, when raised in workflow code, + it terminally fails the workflow execution rather than failing the workflow + task and retrying it indefinitely. Use it for conditions that cannot be + recovered by retry — e.g. a tool that is not a valid Temporal activity. + """ diff --git a/temporalio/contrib/google_genai/_gemini_activity.py b/temporalio/contrib/google_genai/_gemini_activity.py new file mode 100644 index 000000000..2e92c56a1 --- /dev/null +++ b/temporalio/contrib/google_genai/_gemini_activity.py @@ -0,0 +1,356 @@ +"""Temporal activity that executes Gemini SDK API calls with real credentials. + +The ``TemporalApiClient`` in the workflow dispatches calls here. This +activity holds a user-provided ``genai.Client`` and forwards structured +requests. Credentials are fetched/refreshed only within the activity — +they never appear in workflow event history. +""" + +from __future__ import annotations + +from collections.abc import Sequence +from contextlib import AsyncExitStack +from datetime import timedelta +from typing import Any, Callable + +import google.auth.credentials +from google.genai import Client as GeminiClient +from google.genai import errors as genai_errors +from google.genai import types +from google.genai.interactions import Interaction +from google.genai.types import HttpOptions +from google.genai.types import HttpResponse as SdkHttpResponse + +from temporalio import activity +from temporalio.contrib.google_genai._models import ( + _GeminiApiRequest, + _GeminiApiResponse, + _GeminiApiStreamedResponse, + _GeminiDownloadFileRequest, + _GeminiInteractionIdRequest, + _GeminiInteractionRequest, + _GeminiInteractionStreamedResponse, + _GeminiRegisterFilesRequest, + _GeminiUploadFileRequest, + _GeminiUploadToFileSearchStoreRequest, +) +from temporalio.contrib.workflow_streams import WorkflowStreamClient +from temporalio.exceptions import ApplicationError + + +def _resolve_http_options( + overrides: Any, +) -> HttpOptions | None: + """Reconstruct ``HttpOptions`` from serializable overrides, or None.""" + if overrides is None: + return None + return HttpOptions.model_validate(overrides.model_dump(exclude_none=True)) + + +# HTTP status codes the Gemini SDK itself treats as transient/retryable. +_RETRYABLE_HTTP_STATUS = frozenset({408, 429, 500, 502, 503, 504}) + + +def _classify_api_error(err: genai_errors.APIError) -> ApplicationError: + """Map a Gemini ``APIError`` to an ``ApplicationError`` Temporal can act on. + + Transient statuses (timeouts, rate limits, 5xx) stay retryable so the + activity's retry policy applies; everything else (e.g. 4xx client errors) + is marked non-retryable so the workflow fails fast instead of retrying a + request that cannot succeed. + """ + code = getattr(err, "code", None) + retryable = code in _RETRYABLE_HTTP_STATUS + return ApplicationError( + str(err), + type=type(err).__name__, + non_retryable=not retryable, + ) + + +async def _drain_interaction_stream( + stream: Any, +) -> _GeminiInteractionStreamedResponse: + """Collect every SSE event from an interaction stream, heartbeating per event. + + ``stream`` is the SDK's async streaming response; its concrete class is not a + stable public name, so it is typed structurally — only ``async with`` / + ``async for`` / ``event.model_dump(...)`` are used. + """ + events: list[dict[str, Any]] = [] + async with stream: + async for event in stream: + activity.heartbeat() + events.append( + event.model_dump(by_alias=True, exclude_none=True, mode="json") + ) + return _GeminiInteractionStreamedResponse(events=events) + + +class GeminiApiCaller: + """Wraps a ``genai.Client`` and exposes Temporal activities for SDK calls. + + The caller owns a reference to the user-provided ``genai.Client``. + All credential management, HTTP client configuration, etc. is the + responsibility of whoever constructs the client. + """ + + def __init__( + self, + client: GeminiClient, + credentials: google.auth.credentials.Credentials | None = None, + ) -> None: + """Initialize with a genai.Client and optional extra credentials.""" + self._client = client + self._credentials = credentials + + def activities(self) -> Sequence[Callable]: + """Return activities that route SDK calls through this client.""" + + @activity.defn + async def gemini_api_client_async_request( + req: _GeminiApiRequest, + ) -> _GeminiApiResponse: + """Execute a Gemini SDK API call with real credentials.""" + try: + response: SdkHttpResponse = ( + await self._client.aio._api_client.async_request( + http_method=req.http_method, + path=req.path, + request_dict=req.request_dict, + http_options=_resolve_http_options(req.http_options_overrides), + ) + ) + except genai_errors.APIError as err: + raise _classify_api_error(err) from err + return _GeminiApiResponse( + headers=response.headers or {}, + body=response.body or "", + ) + + @activity.defn + async def gemini_api_client_async_request_streamed( + req: _GeminiApiRequest, + ) -> _GeminiApiStreamedResponse: + """Execute a streamed Gemini SDK API call, collecting all chunks. + + When ``req.streaming_topic`` is set, each chunk is also published to + that workflow-stream topic (parsed as ``GenerateContentResponse``) + as it arrives, so external consumers see the model output in real + time. Chunks are still returned batched for the SDK to parse + in-workflow; publishing is best-effort and never breaks that path. + """ + chunks: list[_GeminiApiResponse] = [] + try: + async with AsyncExitStack() as stack: + topic = None + if req.streaming_topic: + publisher = WorkflowStreamClient.from_within_activity( + batch_interval=timedelta( + milliseconds=req.streaming_batch_interval_ms + ), + ) + await stack.enter_async_context(publisher) + topic = publisher.topic( + req.streaming_topic, type=types.GenerateContentResponse + ) + + stream = await self._client.aio._api_client.async_request_streamed( + http_method=req.http_method, + path=req.path, + request_dict=req.request_dict, + http_options=_resolve_http_options(req.http_options_overrides), + ) + async for chunk in stream: + body = chunk.body or "" + chunks.append( + _GeminiApiResponse(headers=chunk.headers or {}, body=body) + ) + if topic is not None and body: + try: + topic.publish( + types.GenerateContentResponse.model_validate_json( + body + ) + ) + except Exception: + # Best-effort: a malformed/transform-needing chunk + # must not break the batched return. + pass + except genai_errors.APIError as err: + raise _classify_api_error(err) from err + return _GeminiApiStreamedResponse(chunks=chunks) + + @activity.defn + async def gemini_files_upload( + req: _GeminiUploadFileRequest, + ) -> types.File: + """Upload a file using the real genai.Client on the worker.""" + if req.file_bytes is not None: + import io + + file_arg: Any = io.BytesIO(req.file_bytes) + else: + file_arg = req.file_path + + return await self._client.aio.files.upload(file=file_arg, config=req.config) + + @activity.defn + async def gemini_files_download( + req: _GeminiDownloadFileRequest, + ) -> bytes: + """Download a file using the real genai.Client on the worker.""" + return await self._client.aio.files.download( + file=req.file, config=req.config + ) + + @activity.defn + async def gemini_files_register( + req: _GeminiRegisterFilesRequest, + ) -> types.RegisterFilesResponse: + """Register GCS files using the real genai.Client on the worker. + + Uses ``credentials`` if provided at plugin init, + otherwise falls back to the client's own credentials. + Token refresh happens here on the worker side, so no auth + material enters the workflow event history. + """ + auth = self._credentials or self._client._api_client._credentials + if auth is None: + raise ValueError( + "No credentials available for register_files(). " + "Pass extra_credentials to GoogleGenAIPlugin or initialize " + "the genai.Client with credentials." + ) + return await self._client.aio.files.register_files( + auth=auth, + uris=req.uris, + config=req.config, + ) + + @activity.defn + async def gemini_file_search_stores_upload( + req: _GeminiUploadToFileSearchStoreRequest, + ) -> types.UploadToFileSearchStoreOperation: + """Upload a file to a file search store on the worker.""" + if req.file_bytes is not None: + import io + + file_arg: Any = io.BytesIO(req.file_bytes) + else: + file_arg = req.file_path + + return ( + await self._client.aio.file_search_stores.upload_to_file_search_store( + file_search_store_name=req.file_search_store_name, + file=file_arg, + config=req.config, + ) + ) + + @activity.defn + async def gemini_interactions_create( + req: _GeminiInteractionRequest, + ) -> dict[str, Any]: + """Create an interaction using the real genai.Client on the worker.""" + interaction = await self._client.aio.interactions.create(**req.params) + assert isinstance(interaction, Interaction) + return interaction.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_interactions_create_streamed( + req: _GeminiInteractionRequest, + ) -> _GeminiInteractionStreamedResponse: + """Create a streamed interaction, collecting all SSE events.""" + stream = await self._client.aio.interactions.create( + stream=True, **req.params + ) + assert not isinstance(stream, Interaction) + return await _drain_interaction_stream(stream) + + @activity.defn + async def gemini_interactions_get( + req: _GeminiInteractionIdRequest, + ) -> dict[str, Any]: + """Get an interaction using the real genai.Client on the worker.""" + interaction = await self._client.aio.interactions.get(req.id, **req.params) + return interaction.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_interactions_get_streamed( + req: _GeminiInteractionIdRequest, + ) -> _GeminiInteractionStreamedResponse: + """Get a streamed interaction, collecting all SSE events.""" + stream = await self._client.aio.interactions.get( + req.id, stream=True, **req.params + ) + assert not isinstance(stream, Interaction) + return await _drain_interaction_stream(stream) + + @activity.defn + async def gemini_interactions_delete( + req: _GeminiInteractionIdRequest, + ) -> Any: + """Delete an interaction using the real genai.Client on the worker.""" + return await self._client.aio.interactions.delete(req.id, **req.params) + + @activity.defn + async def gemini_interactions_cancel( + req: _GeminiInteractionIdRequest, + ) -> dict[str, Any]: + """Cancel an interaction using the real genai.Client on the worker.""" + interaction = await self._client.aio.interactions.cancel( + req.id, **req.params + ) + return interaction.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_agents_create( + req: _GeminiInteractionRequest, + ) -> dict[str, Any]: + """Create a managed agent using the real genai.Client on the worker.""" + agent = await self._client.aio.agents.create(**req.params) + return agent.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_agents_list( + req: _GeminiInteractionRequest, + ) -> dict[str, Any]: + """List managed agents using the real genai.Client on the worker.""" + response = await self._client.aio.agents.list(**req.params) + return response.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_agents_get( + req: _GeminiInteractionIdRequest, + ) -> dict[str, Any]: + """Get a managed agent using the real genai.Client on the worker.""" + agent = await self._client.aio.agents.get(req.id, **req.params) + return agent.model_dump(by_alias=True, exclude_none=True, mode="json") + + @activity.defn + async def gemini_agents_delete( + req: _GeminiInteractionIdRequest, + ) -> dict[str, Any]: + """Delete a managed agent using the real genai.Client on the worker.""" + response = await self._client.aio.agents.delete(req.id, **req.params) + return response.model_dump(by_alias=True, exclude_none=True, mode="json") + + return [ + gemini_api_client_async_request, + gemini_api_client_async_request_streamed, + gemini_files_upload, + gemini_files_download, + gemini_files_register, + gemini_file_search_stores_upload, + gemini_interactions_create, + gemini_interactions_create_streamed, + gemini_interactions_get, + gemini_interactions_get_streamed, + gemini_interactions_delete, + gemini_interactions_cancel, + gemini_agents_create, + gemini_agents_list, + gemini_agents_get, + gemini_agents_delete, + ] diff --git a/temporalio/contrib/google_genai/_google_genai_plugin.py b/temporalio/contrib/google_genai/_google_genai_plugin.py new file mode 100644 index 000000000..f7b65b769 --- /dev/null +++ b/temporalio/contrib/google_genai/_google_genai_plugin.py @@ -0,0 +1,158 @@ +"""Temporal plugin for Google Gemini SDK integration.""" + +from __future__ import annotations + +import dataclasses +from datetime import timedelta +from typing import TYPE_CHECKING + +import google.auth.credentials +from google.genai import Client as GeminiClient + +from temporalio.contrib.google_genai._errors import GoogleGenAIError +from temporalio.contrib.google_genai._gemini_activity import GeminiApiCaller +from temporalio.contrib.pydantic import PydanticPayloadConverter +from temporalio.converter import DataConverter, DefaultPayloadConverter +from temporalio.plugin import SimplePlugin +from temporalio.worker import WorkflowRunner +from temporalio.worker.workflow_sandbox import SandboxedWorkflowRunner + +if TYPE_CHECKING: + from temporalio.contrib.google_genai._mcp import McpSessionFactory + + +_RETRY_OPTIONS_MESSAGE = ( + "genai.Client is configured with http_options.retry_options, but Temporal " + "owns retries for durable execution. Remove retry_options from the client " + "and configure retries with the activity retry_policy instead — e.g. " + "TemporalAsyncClient(activity_config=ActivityConfig(retry_policy=...)) or " + "activity_as_tool(fn, activity_config=ActivityConfig(retry_policy=...))." +) + + +def _reject_sdk_retries(client: GeminiClient) -> None: + """Raise if the client enables the SDK's own retry loop. + + Temporal must own retries so each attempt is a separate, observable activity + attempt; an SDK-internal retry loop would hide retries inside one activity + and compound with Temporal's retry policy. + """ + http_options = getattr(client._api_client, "_http_options", None) + if http_options is not None and getattr(http_options, "retry_options", None): + raise ValueError(_RETRY_OPTIONS_MESSAGE) + + +def _data_converter(converter: DataConverter | None) -> DataConverter: + if converter is None: + return DataConverter(payload_converter_class=PydanticPayloadConverter) + elif converter.payload_converter_class is DefaultPayloadConverter: + return dataclasses.replace( + converter, payload_converter_class=PydanticPayloadConverter + ) + return converter + + +class GoogleGenAIPlugin(SimplePlugin): + """A Temporal Worker Plugin configured for the Google Gemini SDK. + + .. warning:: + This class is experimental and may change in future versions. + Use with caution in production environments. + + This plugin registers the ``gemini_api_client_async_request`` activity + using the provided ``genai.Client`` with real credentials. Workflows + construct a :class:`temporalio.contrib.google_genai.TemporalAsyncClient` + to get an ``AsyncClient`` backed by a ``TemporalApiClient`` that routes all + API calls through this activity. + + No credentials are passed to or from the workflow. Auth material never + appears in Temporal's event history. + + Example (Gemini Developer API):: + + client = genai.Client(api_key=os.environ["GOOGLE_API_KEY"]) + plugin = GoogleGenAIPlugin(client) + + Example (Vertex AI):: + + client = genai.Client( + vertexai=True, project="my-project", location="us-central1", + ) + plugin = GoogleGenAIPlugin(client) + + Example (with separate GCS credentials for file registration):: + + client = genai.Client(api_key=os.environ["GOOGLE_API_KEY"]) + gcs_creds, _ = google.auth.default() + plugin = GoogleGenAIPlugin(client, extra_credentials=gcs_creds) + """ + + def __init__( + self, + client: GeminiClient, + extra_credentials: google.auth.credentials.Credentials | None = None, + mcp_servers: dict[str, McpSessionFactory] | None = None, + mcp_connection_idle_timeout: timedelta | None = None, + ) -> None: + """Initialize the Gemini plugin. + + Args: + client: A fully configured ``genai.Client`` instance. + All credential management, HTTP client configuration, etc. + is the responsibility of the caller. + extra_credentials: Optional Google Cloud credentials used for + operations that require explicit auth (e.g. + ``files.register_files()``). If not provided, the + client's own credentials are used. + mcp_servers: MCP servers to expose to workflows, keyed by name. + Each value is a factory returning an async context manager that + yields a connected, initialized ``mcp.ClientSession``. A + workflow references a server by name with + ``TemporalMcpClientSession(name)`` in a ``generate_content`` + ``tools`` list; ``list_tools`` / ``call_tool`` then run as the + ``{name}-list-tools`` / ``{name}-call-tool`` activities against a + worker-side connection. Requires the ``mcp`` package. + mcp_connection_idle_timeout: How long a worker-process MCP + connection stays open while idle before being disconnected + (the timer resets on each reuse). Defaults to 5 minutes. + """ + _reject_sdk_retries(client) + self._api_caller = GeminiApiCaller(client, credentials=extra_credentials) + + activities = list(self._api_caller.activities()) + if mcp_servers: + # Imported lazily: ``mcp`` is an optional dependency, only needed + # when MCP servers are registered. + from temporalio.contrib.google_genai._mcp import build_mcp_activities + + activities.extend( + build_mcp_activities(mcp_servers, mcp_connection_idle_timeout) + ) + + def workflow_runner(runner: WorkflowRunner | None) -> WorkflowRunner: + if not runner: + raise ValueError("No WorkflowRunner provided to GoogleGenAIPlugin.") + if isinstance(runner, SandboxedWorkflowRunner): + return dataclasses.replace( + runner, + restrictions=runner.restrictions.with_passthrough_modules( + # The SDK's request formatting + AFC loop run in-workflow + # and validate google.genai's Pydantic models; mcp is + # imported to subclass ClientSession. pydantic itself is + # in the SDK default passthrough, but its compiled core + # and Annotated helper are not, so extend them. + "google.genai", + "mcp", + "pydantic_core", + "annotated_types", + ), + ) + return runner + + super().__init__( + name="google_genai.GoogleGenAIPlugin", + data_converter=_data_converter, + activities=activities, + workflow_runner=workflow_runner, + workflow_failure_exception_types=[GoogleGenAIError], + ) diff --git a/temporalio/contrib/google_genai/_mcp.py b/temporalio/contrib/google_genai/_mcp.py new file mode 100644 index 000000000..157ce458c --- /dev/null +++ b/temporalio/contrib/google_genai/_mcp.py @@ -0,0 +1,226 @@ +"""Worker-side MCP activities and a pooled-connection subsystem. + +The Gemini SDK's automatic-function-calling loop runs *inside* the workflow, +where it would otherwise call ``McpClientSession.list_tools`` / +``call_tool`` directly (network I/O — forbidden in a workflow). The +workflow-side ``TemporalMcpClientSession`` shim redirects those two methods to +the ``{server}-list-tools`` / ``{server}-call-tool`` activities defined here, +so the real ``mcp.ClientSession`` lives only on the worker. + +A single live session per server is held open in the worker process and reused +across activity invocations, with idle eviction — modeled on the strands +plugin's ``_temporal_mcp_client``. The MCP transport and ``ClientSession`` are +anyio context managers whose cancel scope is bound to the task that enters +them, so a dedicated owner task (``_ConnectionRecord._run``) holds them open for +the connection's lifetime while concurrent activities on the same event loop +call through the shared session. +""" + +from __future__ import annotations + +import asyncio +from collections.abc import Callable +from contextlib import AbstractAsyncContextManager +from datetime import timedelta + +from mcp import ClientSession +from mcp.types import CallToolResult, ListToolsResult + +from temporalio import activity +from temporalio.contrib.google_genai._models import _McpCallToolRequest + +# A factory yields a ready-to-use (connected and ``initialize()``-d) +# ``ClientSession`` as an async context manager. Mirrors the strands +# ``mcp_clients={name: factory}`` shape; the user writes a small +# ``@asynccontextmanager`` that enters the transport, opens the session, and +# initializes it before ``yield``. +McpSessionFactory = Callable[[], AbstractAsyncContextManager[ClientSession]] + +# Default time an idle MCP connection stays open before being disconnected. +# The timer resets on every call that reuses the connection. Override per +# worker via ``GoogleGenAIPlugin(mcp_connection_idle_timeout=...)``. +_MCP_CONNECTION_IDLE = timedelta(minutes=5) + +# Server name -> live connection held open in the activity worker process. +# Activities run in the worker process, so this module state is shared across +# activity invocations on the worker. +_CONNECTIONS: dict[str, _ConnectionRecord] = {} + + +class _ConnectionRecord: + """A single MCP session held open by a dedicated owner task. + + ``_run`` enters and exits the session's context manager in the same task + for the connection's whole lifetime; ``list_tools`` / ``call_tool`` + activities on the same event loop call through the shared session (MCP + multiplexes concurrent requests by id). + """ + + def __init__( + self, + server: str, + factory: McpSessionFactory, + idle_timeout: timedelta, + ) -> None: + loop = asyncio.get_running_loop() + self._server = server + self._idle_timeout = idle_timeout + self._stop = asyncio.Event() + self._ready: asyncio.Future[ClientSession] = loop.create_future() + self._idle_handle: asyncio.TimerHandle | None = None + self._inflight = 0 + self._owner = asyncio.create_task(self._run(factory)) + + async def _run(self, factory: McpSessionFactory) -> None: + try: + async with factory() as session: + self._ready.set_result(session) + await self._stop.wait() + except BaseException as err: + # A failed connect should not be cached; drop it so the next call + # retries instead of awaiting a permanently rejected future. + if not self._ready.done(): + self._ready.set_exception(err) + _CONNECTIONS.pop(self._server, None) + raise + + def acquire(self) -> None: + """Mark a call in flight; pause idle eviction while calls are active.""" + self._inflight += 1 + if self._idle_handle is not None: + self._idle_handle.cancel() + self._idle_handle = None + + def release(self) -> None: + """Mark a call done; arm idle eviction once no calls remain in flight.""" + self._inflight -= 1 + # Only the record still cached under this server arms a timer; a record + # already evicted or never cached must not schedule one, or it could + # later evict a different, healthy connection for the same server. + if self._inflight == 0 and _CONNECTIONS.get(self._server) is self: + loop = asyncio.get_running_loop() + self._idle_handle = loop.call_later( + self._idle_timeout.total_seconds(), self._on_idle + ) + + def _on_idle(self) -> None: + asyncio.ensure_future(self._maybe_evict()) + + async def _maybe_evict(self) -> None: + # A call may have acquired the connection between the timer firing and + # this task running; only evict if it is still idle. + if self._inflight == 0: + await _evict_connection(self._server) + + async def aclose(self) -> None: + """Signal the owner task to exit its context manager and wait for it.""" + if self._idle_handle is not None: + self._idle_handle.cancel() + self._idle_handle = None + self._stop.set() + try: + await self._owner + except BaseException: + pass + + async def session(self) -> ClientSession: + """Return the live session, or raise the connect failure.""" + return await self._ready + + +async def get_connection( + server: str, factory: McpSessionFactory, idle_timeout: timedelta +) -> tuple[ClientSession, _ConnectionRecord]: + """Return the cached session for ``server``, opening one lazily if needed. + + Concurrent first-callers dedupe onto a single connect handshake by awaiting + the same record. The returned record is acquired; the caller must + ``release()`` it once the call completes so idle eviction can resume. + """ + record = _CONNECTIONS.get(server) + if record is None: + record = _ConnectionRecord(server, factory, idle_timeout) + _CONNECTIONS[server] = record + record.acquire() + try: + session = await record.session() + except BaseException: + record.release() + raise + return session, record + + +async def _evict_connection(server: str) -> None: + record = _CONNECTIONS.pop(server, None) + if record is not None: + await record.aclose() + + +def build_list_tools_activity( + server: str, + factory: McpSessionFactory, + idle_timeout: timedelta | None = None, +) -> Callable: + """Return the per-server ``{server}-list-tools`` activity for registration. + + Reuses a lazily-opened, idle-evicted worker-process MCP session. Returns + the raw ``mcp.types.ListToolsResult`` so the workflow-side shim can hand it + to the Gemini SDK exactly as a live session would (preserving the full tool + parameter schema). + """ + idle = idle_timeout if idle_timeout is not None else _MCP_CONNECTION_IDLE + + @activity.defn(name=f"{server}-list-tools") + async def list_tools() -> ListToolsResult: + session, record = await get_connection(server, factory, idle) + try: + return await session.list_tools() + except Exception: + # The session may be broken; drop it so the next call reconnects. + await _evict_connection(server) + raise + finally: + record.release() + + return list_tools + + +def build_call_tool_activity( + server: str, + factory: McpSessionFactory, + idle_timeout: timedelta | None = None, +) -> Callable: + """Return the per-server ``{server}-call-tool`` activity for registration. + + Reuses the same lazily-opened, idle-evicted worker-process MCP session as + ``{server}-list-tools``. Returns the raw ``mcp.types.CallToolResult`` — + including tool-level error results (``isError=True``), which the model is + meant to see; only transport/protocol failures raise (and evict). + """ + idle = idle_timeout if idle_timeout is not None else _MCP_CONNECTION_IDLE + + @activity.defn(name=f"{server}-call-tool") + async def call_tool(req: _McpCallToolRequest) -> CallToolResult: + session, record = await get_connection(server, factory, idle) + try: + return await session.call_tool(name=req.name, arguments=req.arguments) + except Exception: + # The session may be broken; drop it so the next call reconnects. + await _evict_connection(server) + raise + finally: + record.release() + + return call_tool + + +def build_mcp_activities( + mcp_servers: dict[str, McpSessionFactory], + idle_timeout: timedelta | None = None, +) -> list[Callable]: + """Build the list-tools and call-tool activities for every registered server.""" + activities: list[Callable] = [] + for server, factory in mcp_servers.items(): + activities.append(build_list_tools_activity(server, factory, idle_timeout)) + activities.append(build_call_tool_activity(server, factory, idle_timeout)) + return activities diff --git a/temporalio/contrib/google_genai/_models.py b/temporalio/contrib/google_genai/_models.py new file mode 100644 index 000000000..2f70d9b4d --- /dev/null +++ b/temporalio/contrib/google_genai/_models.py @@ -0,0 +1,172 @@ +"""Serializable Pydantic models for the Gemini SDK Temporal integration. + +These models cross the activity boundary — they're constructed on the +workflow side and deserialized on the activity side (or vice versa). +""" + +from __future__ import annotations + +from typing import Any + +from google.genai import types +from pydantic import BaseModel + +__all__ = [ + "_GeminiApiRequest", + "_GeminiApiResponse", + "_GeminiApiStreamedResponse", + "_GeminiDownloadFileRequest", + "_GeminiInteractionIdRequest", + "_GeminiInteractionRequest", + "_GeminiInteractionStreamedResponse", + "_GeminiRegisterFilesRequest", + "_GeminiUploadFileRequest", + "_GeminiUploadToFileSearchStoreRequest", + "_McpCallToolRequest", + "_SerializableHttpOptions", +] + + +class _SerializableHttpOptions(BaseModel): + """Per-request HTTP options that can be serialized across the activity boundary. + + Non-serializable fields (httpx_client, httpx_async_client, aiohttp_client, + client_args, async_client_args) must be configured at GoogleGenAIPlugin init. + + ``timeout`` is excluded because Temporal owns timeouts/retries — configure + via ``ActivityConfig`` instead. + """ + + base_url: str | None = None + base_url_resource_scope: str | None = None + api_version: str | None = None + headers: dict[str, str] | None = None + extra_body: dict[str, Any] | None = None + + +# ── async_request models ────────────────────────────────────────────────── + + +class _GeminiApiRequest(BaseModel): + """Serializable activity input for a Gemini SDK API call. + + ``streaming_topic`` / ``streaming_batch_interval_ms`` are only read by the + streamed activity: when a topic is set, each streamed chunk is published to + that workflow-stream topic as it arrives (in addition to being returned + batched), so external consumers can observe the model output in real time. + """ + + http_method: str + path: str + request_dict: dict[str, object] + http_options_overrides: _SerializableHttpOptions | None = None + streaming_topic: str | None = None + streaming_batch_interval_ms: int = 100 + + +class _GeminiApiResponse(BaseModel): + """Serializable activity output for a Gemini SDK API call.""" + + headers: dict[str, str] + body: str + + +class _GeminiApiStreamedResponse(BaseModel): + """Serializable activity output for a batched streamed API call. + + The activity collects all streamed chunks and returns them as a list. + The ``TemporalApiClient`` then yields them one at a time to the SDK. + """ + + chunks: list[_GeminiApiResponse] + + +# ── files upload/download models ────────────────────────────────────────── + + +class _GeminiUploadFileRequest(BaseModel): + """Serializable activity input for a file upload. + + For file path uploads the path is resolved on the worker. For + in-memory uploads the raw bytes are sent across the activity boundary. + """ + + file_bytes: bytes | None = None + file_path: str | None = None + config: types.UploadFileConfig | None = None + + +class _GeminiDownloadFileRequest(BaseModel): + """Serializable activity input for a file download.""" + + file: str + config: types.DownloadFileConfig | None = None + + +class _GeminiRegisterFilesRequest(BaseModel): + """Serializable activity input for registering GCS files.""" + + uris: list[str] + config: types.RegisterFilesConfig | None = None + + +class _GeminiUploadToFileSearchStoreRequest(BaseModel): + """Serializable activity input for uploading a file to a file search store.""" + + file_search_store_name: str + file_bytes: bytes | None = None + file_path: str | None = None + config: types.UploadToFileSearchStoreConfig | None = None + + +# ── interactions / agents models ────────────────────────────────────────── + + +class _GeminiInteractionRequest(BaseModel): + """Serializable activity input for interactions/agents calls without an id. + + ``params`` is the caller's kwargs forwarded verbatim to the real SDK + method on the worker — ``stream`` and ``timeout`` are popped by the + workflow-side shim before dispatch (``stream`` selects the activity, + ``timeout`` maps to the activity's ``start_to_close_timeout``). + """ + + params: dict[str, Any] = {} + + +class _GeminiInteractionIdRequest(BaseModel): + """Serializable activity input for id-addressed interactions/agents calls.""" + + id: str + params: dict[str, Any] = {} + + +class _GeminiInteractionStreamedResponse(BaseModel): + """Serializable activity output for a batched streamed interaction call. + + ``events`` is the verbatim sequence of ``InteractionSSEEvent`` objects + yielded by the SDK's stream, each serialized via + ``model_dump(exclude_none=True, mode="json")``. The workflow-side shim + rehydrates each entry with ``_temporal_interactions._deserialize`` so + workflow code iterates the same typed events it would get from the SDK + directly. + """ + + events: list[dict[str, Any]] = [] + + +# ── MCP models ───────────────────────────────────────────────────────────── + + +class _McpCallToolRequest(BaseModel): + """Serializable activity input for an MCP ``call_tool`` invocation. + + Carries the tool name and arguments the Gemini SDK's AFC loop selected; + the worker-side activity forwards them to the real ``mcp.ClientSession``. + The ``mcp.types.ListToolsResult`` / ``CallToolResult`` returned by the + activities are themselves Pydantic models, so they serialize directly via + the plugin's ``PydanticPayloadConverter`` and need no wrapper here. + """ + + name: str + arguments: dict[str, Any] = {} diff --git a/temporalio/contrib/google_genai/_temporal_agents.py b/temporalio/contrib/google_genai/_temporal_agents.py new file mode 100644 index 000000000..d652033e3 --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_agents.py @@ -0,0 +1,142 @@ +"""Temporal-aware agents resource shim. + +``TemporalAsyncAgents`` exposes the same surface as google-genai's +``AsyncClient.agents`` resource, but each operation is dispatched through a +Temporal activity holding the real ``genai.Client`` on the worker. Agents are +server-side managed agent definitions (created once, then referenced by id in +``interactions.create(agent=...)``); like the Interactions API, the resource +lives in the vendored Stainless client that bypasses ``BaseApiClient``, so each +operation is routed as a whole through an activity instead. + +The shim depends only on the public ``google.genai.interactions`` surface, not +on google-genai internals. +""" + +from __future__ import annotations + +from datetime import timedelta +from typing import Any, cast + +# These types are runtime-public (in ``google.genai.interactions.__all__``) but +# pyright's stubs don't mark them re-exported; the alternative it suggests is a +# private ``_gaos`` path, so suppress the false positive. +from google.genai.interactions import ( + Agent, # pyright: ignore[reportPrivateImportUsage] + AgentDeleteResponse, # pyright: ignore[reportPrivateImportUsage] + AgentListResponse, # pyright: ignore[reportPrivateImportUsage] +) + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._models import ( + _GeminiInteractionIdRequest, + _GeminiInteractionRequest, +) +from temporalio.contrib.google_genai._temporal_interactions import ( + _deserialize, + _pop_timeout, +) +from temporalio.workflow import ActivityConfig + + +class TemporalAsyncAgents: + """Agents resource shim that routes calls through activities. + + Methods accept the same keyword arguments as the real resource and + forward them verbatim — the SDK validates them on the worker side, so + a bad argument surfaces as an activity failure (retried per the + activity's retry policy) rather than a workflow-side error. + + ``with_raw_response`` / ``with_streaming_response`` are not supported + in workflows. + """ + + def __init__( + self, + activity_config: ActivityConfig | None = None, + ) -> None: + self._activity_config = ( + ActivityConfig(start_to_close_timeout=timedelta(seconds=60)) + if activity_config is None + else activity_config + ) + + def _config(self, summary: str, params: dict[str, Any]) -> ActivityConfig: + config: ActivityConfig = {**self._activity_config} + if "summary" not in config: + config["summary"] = summary + _pop_timeout(params, config) + return config + + async def create( + self, + **kwargs: Any, + ) -> Agent: + """Create a managed agent definition via a Temporal activity.""" + params = dict(kwargs) + config = self._config("agents.create", params) + raw = await temporal_workflow.execute_activity( + "gemini_agents_create", + _GeminiInteractionRequest(params=params), + result_type=dict[str, Any], + **config, + ) + return cast(Agent, _deserialize(raw, Agent)) + + async def list( + self, + **kwargs: Any, + ) -> AgentListResponse: + """List managed agent definitions via a Temporal activity.""" + params = dict(kwargs) + config = self._config("agents.list", params) + raw = await temporal_workflow.execute_activity( + "gemini_agents_list", + _GeminiInteractionRequest(params=params), + result_type=dict[str, Any], + **config, + ) + return cast(AgentListResponse, _deserialize(raw, AgentListResponse)) + + async def get( + self, + id: str, + **kwargs: Any, + ) -> Agent: + """Get a managed agent definition via a Temporal activity.""" + params = dict(kwargs) + config = self._config("agents.get", params) + raw = await temporal_workflow.execute_activity( + "gemini_agents_get", + _GeminiInteractionIdRequest(id=id, params=params), + result_type=dict[str, Any], + **config, + ) + return cast(Agent, _deserialize(raw, Agent)) + + async def delete( + self, + id: str, + **kwargs: Any, + ) -> AgentDeleteResponse: + """Delete a managed agent definition via a Temporal activity.""" + params = dict(kwargs) + config = self._config("agents.delete", params) + raw = await temporal_workflow.execute_activity( + "gemini_agents_delete", + _GeminiInteractionIdRequest(id=id, params=params), + result_type=dict[str, Any], + **config, + ) + return cast(AgentDeleteResponse, _deserialize(raw, AgentDeleteResponse)) + + @property + def with_raw_response(self) -> Any: + """Raise — raw responses are not available in workflows.""" + raise RuntimeError("with_raw_response is not supported in Temporal workflows.") + + @property + def with_streaming_response(self) -> Any: + """Raise — streaming responses are not available in workflows.""" + raise RuntimeError( + "with_streaming_response is not supported in Temporal workflows." + ) diff --git a/temporalio/contrib/google_genai/_temporal_api_client.py b/temporalio/contrib/google_genai/_temporal_api_client.py new file mode 100644 index 000000000..0763d6890 --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_api_client.py @@ -0,0 +1,319 @@ +"""Temporal-aware BaseApiClient that routes SDK calls through activities. + +This module provides ``_TemporalApiClient``, a ``BaseApiClient`` subclass +whose HTTP methods dispatch through Temporal activities instead of making +direct calls. The real ``genai.Client`` with real credentials only exists +on the worker side inside the activity. + +This ensures: + +- No credential fetching or refreshing happens in the workflow. +- No auth material (tokens, API keys) appears in Temporal event history. +- The SDK's AFC (automatic function calling) loop runs in the workflow, + so ``activity_as_tool()`` wrappers work naturally. +""" + +from __future__ import annotations + +from datetime import timedelta +from typing import Any + +from google.genai._api_client import BaseApiClient +from google.genai.types import HttpOptions, HttpOptionsOrDict +from google.genai.types import HttpResponse as SdkHttpResponse + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._errors import GoogleGenAIError +from temporalio.contrib.google_genai._models import ( + _GeminiApiRequest, + _GeminiApiResponse, + _GeminiApiStreamedResponse, + _SerializableHttpOptions, +) +from temporalio.contrib.workflow_streams._stream import _PUBLISH_SIGNAL +from temporalio.workflow import ActivityConfig + +# Fields on HttpOptions that cannot be serialized or should not be forwarded. +_REJECTED_HTTP_OPTION_FIELDS = frozenset( + { + "httpx_client", + "httpx_async_client", + "aiohttp_client", + "client_args", + "async_client_args", + } +) + + +def _validate_http_options(http_options: HttpOptions | None) -> None: + """Raise if http_options contains non-serializable fields.""" + if http_options is None: + return + bad_fields = [ + f + for f in _REJECTED_HTTP_OPTION_FIELDS + if getattr(http_options, f, None) is not None + ] + if bad_fields: + raise ValueError( + f"http_options cannot include {bad_fields}. " + f"Configure custom HTTP clients at GoogleGenAIPlugin init instead." + ) + + +class _TemporalApiClient(BaseApiClient): # pyright: ignore[reportUnusedClass] + """A ``BaseApiClient`` that routes all API calls through Temporal activities. + + This client is used on the workflow side. It does NOT initialize HTTP + clients, load credentials, or make any network calls. It only holds the + minimal configuration needed for the SDK's request formatting logic + (e.g., choosing between Vertex AI and ML Dev parameter transformations). + + All actual HTTP calls are dispatched via ``workflow.execute_activity``. + """ + + def __init__( # pyright: ignore[reportMissingSuperCall] + self, + *, + vertexai: bool = False, + project: str | None = None, + location: str | None = None, + activity_config: ActivityConfig | None = None, + streaming_topic: str | None = None, + streaming_batch_interval: timedelta = timedelta(milliseconds=100), + ) -> None: + """Initialize without calling super (no HTTP clients needed).""" + # Do NOT call super().__init__() — it creates HTTP clients, loads + # credentials, etc. We only set the properties the SDK's request + # formatting code accesses. + self.vertexai = vertexai + self.project = project + self.location = location + self.api_key: str | None = None + self.custom_base_url: str | None = None + + self._activity_config = ( + ActivityConfig(start_to_close_timeout=timedelta(seconds=60)) + if activity_config is None + else activity_config + ) + self._streaming_topic = streaming_topic + self._streaming_batch_interval = streaming_batch_interval + + def _verify_response(self, response_model: Any) -> None: + """No-op — matches the base implementation.""" + pass + + def close(self) -> None: + """No-op — no HTTP resources to close.""" + pass + + async def aclose(self) -> None: + """No-op — no HTTP resources to close.""" + pass + + def __del__(self) -> None: + """No-op — no HTTP resources to clean up.""" + pass + + @staticmethod + def _process_http_options( + http_options: HttpOptionsOrDict | None, + config: ActivityConfig, + ) -> _SerializableHttpOptions | None: + """Validate and extract serializable per-request HTTP options. + + Rejects non-serializable fields (custom HTTP clients), maps timeout + to the Temporal activity config, and returns the remaining options + for forwarding to the activity. + + Args: + http_options: Per-request options from the SDK call. + config: Mutable activity config dict — timeout is applied here. + + Returns: + Serializable options to forward, or None if nothing to forward. + """ + if http_options is None: + return None + + if isinstance(http_options, HttpOptions): + opts = http_options + else: + opts = HttpOptions.model_validate(http_options) + + _validate_http_options(opts) + + if opts.retry_options is not None: + raise GoogleGenAIError( + "Per-request http_options.retry_options is not supported in " + "Temporal workflows. Temporal owns retries; configure them with " + "the activity retry_policy via activity_config instead." + ) + + # timeout is owned by Temporal — apply it to the activity config + # rather than forwarding to the underlying HTTP client. + if opts.timeout is not None: + config["start_to_close_timeout"] = timedelta(milliseconds=opts.timeout) + + result = _SerializableHttpOptions( + base_url=opts.base_url, + base_url_resource_scope=( + opts.base_url_resource_scope.value + if opts.base_url_resource_scope + else None + ), + api_version=opts.api_version, + headers=opts.headers, + extra_body=opts.extra_body, + ) + # Only return if there are actual values set + if not result.model_dump(exclude_none=True): + return None + return result + + # ── Async (primary path for workflows) ────────────────────────────── + + async def async_request( + self, + http_method: str, + path: str, + request_dict: dict[str, object], + http_options: HttpOptionsOrDict | None = None, + ) -> SdkHttpResponse: + """Dispatch an async API request through a Temporal activity.""" + config: ActivityConfig = {**self._activity_config} + if "summary" not in config: + # Default summary is the API path (e.g. "models/gemini-2.5-flash:generateContent"). + config["summary"] = f"{http_method.upper()} {path}" + overrides = self._process_http_options(http_options, config) + + resp = await temporal_workflow.execute_activity( + "gemini_api_client_async_request", + _GeminiApiRequest( + http_method=http_method, + path=path, + request_dict=request_dict, + http_options_overrides=overrides, + ), + result_type=_GeminiApiResponse, + **config, + ) + return SdkHttpResponse(headers=resp.headers, body=resp.body) + + # ── Sync (not expected in async workflows, but raise clearly) ─────── + + def request( + self, + http_method: str, + path: str, + request_dict: dict[str, object], + http_options: HttpOptionsOrDict | None = None, + ) -> SdkHttpResponse: + """Raise — sync requests not supported in workflows.""" + raise RuntimeError( + "Synchronous requests are not supported in Temporal workflows. " + "Use TemporalAsyncClient instead." + ) + + def request_streamed( + self, + http_method: str, + path: str, + request_dict: dict[str, object], + http_options: HttpOptionsOrDict | None = None, + ) -> Any: + """Raise — sync streaming not supported in workflows.""" + raise RuntimeError( + "Synchronous streaming is not supported in Temporal workflows. " + "Use TemporalAsyncClient instead." + ) + + async def async_request_streamed( + self, + http_method: str, + path: str, + request_dict: dict[str, object], + http_options: HttpOptionsOrDict | None = None, + ) -> Any: + """Dispatch a streamed request, batching chunks in the activity. + + When a ``streaming_topic`` is configured, the activity also publishes + each chunk to that workflow-stream topic as it arrives; the workflow + must host a ``WorkflowStream`` to receive them. + """ + config: ActivityConfig = {**self._activity_config} + if "summary" not in config: + config["summary"] = f"{http_method.upper()} {path}" + overrides = self._process_http_options(http_options, config) + + if self._streaming_topic is not None: + self._require_workflow_stream() + + resp = await temporal_workflow.execute_activity( + "gemini_api_client_async_request_streamed", + _GeminiApiRequest( + http_method=http_method, + path=path, + request_dict=request_dict, + http_options_overrides=overrides, + streaming_topic=self._streaming_topic, + streaming_batch_interval_ms=int( + self._streaming_batch_interval.total_seconds() * 1000 + ), + ), + result_type=_GeminiApiStreamedResponse, + **config, + ) + + async def _yield_chunks(): + for chunk in resp.chunks: + yield SdkHttpResponse(headers=chunk.headers, body=chunk.body) + + return _yield_chunks() + + def _require_workflow_stream(self) -> None: + """Fail fast if streaming is configured but no WorkflowStream is hosted. + + Published chunks are delivered to the workflow's ``WorkflowStream`` via + a signal; without a registered handler the signals would be silently + dropped, so surface a clear error instead. + """ + if temporal_workflow.get_signal_handler(_PUBLISH_SIGNAL) is None: + raise GoogleGenAIError( + "streaming_topic is set but this workflow has no WorkflowStream. " + "Construct WorkflowStream() in the workflow's @workflow.init " + "(from temporalio.contrib.workflow_streams).", + non_retryable=True, + ) + + # ── File upload/download ───────────────────────────────────────────── + # File operations are handled at a higher level by TemporalAsyncFiles + # (in _temporal_files.py), which dispatches the entire upload/download + # as a Temporal activity using the real client on the worker side. + # These internal BaseApiClient methods are not called in that path, + # so we raise here to catch any unexpected direct usage. + + def upload_file(self, *args: Any, **kwargs: Any) -> Any: + """Raise — use client.files.upload() instead.""" + raise NotImplementedError( + "Use client.files.upload() instead of the internal upload_file() method." + ) + + async def async_upload_file(self, *args: Any, **kwargs: Any) -> Any: + """Raise — use client.files.upload() instead.""" + raise NotImplementedError( + "Use client.files.upload() instead of the internal async_upload_file() method." + ) + + def download_file(self, *args: Any, **kwargs: Any) -> Any: + """Raise — use client.files.download() instead.""" + raise NotImplementedError( + "Use client.files.download() instead of the internal download_file() method." + ) + + async def async_download_file(self, *args: Any, **kwargs: Any) -> Any: + """Raise — use client.files.download() instead.""" + raise NotImplementedError( + "Use client.files.download() instead of the internal async_download_file() method." + ) diff --git a/temporalio/contrib/google_genai/_temporal_async_client.py b/temporalio/contrib/google_genai/_temporal_async_client.py new file mode 100644 index 000000000..c77cd5cee --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_async_client.py @@ -0,0 +1,285 @@ +"""Temporal-aware ``AsyncClient``. + +``TemporalAsyncClient`` is an ``AsyncClient`` whose every Gemini API call runs +as a Temporal activity. It builds and wraps a private ``BaseApiClient`` that +dispatches HTTP through ``workflow.execute_activity`` instead of making network +calls, so the SDK's request-formatting code (including the AFC loop) runs in +the workflow while the real ``genai.Client`` with real credentials only exists +on the worker side inside the activity. + +Construct it from within a workflow:: + + client = TemporalAsyncClient(activity_config=...) + response = await client.models.generate_content(...) + +This ensures: + +- No credential fetching or refreshing happens in the workflow. +- No auth material (tokens, API keys) appears in Temporal event history. +- The SDK's AFC (automatic function calling) loop runs in the workflow, so + ``activity_as_tool()`` wrappers work naturally. + +``AsyncFiles`` and ``AsyncFileSearchStores`` are replaced with shims that run +upload/download as activities; ``interactions`` and ``agents`` — which bypass +``BaseApiClient`` via a vendored HTTP client — are likewise replaced with +activity-backed shims; ``webhooks`` is not supported in workflows and raises. + +Replay determinism +------------------ +The SDK's request-formatting and automatic-function-calling loop run *in the +workflow*, so they must be deterministic. A survey of ``google.genai`` found no +``time``/``uuid``/``random`` use on the ``generate_content``/AFC path; the SDK's +own non-deterministic code (HTTP retry backoff, the interactions/agents vendored +client, local tokenizer temp paths) runs only inside activities on the worker. +The SDK exposes no time/id provider hooks to override, and none are needed. + +The one in-workflow exception is ``batches.create`` on Vertex AI: when +``display_name``/``dest`` are omitted the SDK auto-generates them from a +timestamp + UUID (``_common.timestamped_unique_name``), which is not +replay-safe. Pass explicit ``display_name`` and ``dest`` when creating Vertex +batch jobs from a workflow. +""" + +from __future__ import annotations + +import functools +import inspect +from collections.abc import AsyncIterator, Callable +from datetime import timedelta +from typing import Any, NoReturn, cast + +from google.genai import types +from google.genai.client import AsyncClient +from google.genai.models import AsyncModels + +from temporalio.contrib.google_genai._temporal_agents import ( + TemporalAsyncAgents, +) +from temporalio.contrib.google_genai._temporal_api_client import ( + _TemporalApiClient, +) +from temporalio.contrib.google_genai._temporal_file_search_stores import ( + TemporalAsyncFileSearchStores, +) +from temporalio.contrib.google_genai._temporal_files import ( + TemporalAsyncFiles, +) +from temporalio.contrib.google_genai._temporal_interactions import ( + TemporalAsyncInteractions, +) +from temporalio.workflow import ActivityConfig + + +def _closure_if_bound_method(tool: object) -> object: + """Return a plain-function wrapper for a bound method, else ``tool`` as-is. + + google-genai >= 2.8.0 deep-copies the request config internally + (``config.model_copy(deep=True)``). ``copy.deepcopy`` clones a bound + method's ``__self__``, so a workflow-method tool would run against a throwaway + clone of the workflow instance and its in-workflow state mutation would be + lost. ``deepcopy`` leaves plain functions untouched, so wrapping the method + in a closure keeps the tool bound to the real instance. Plain functions and + ``activity_as_tool`` wrappers are already closures and pass through unchanged. + """ + if not inspect.ismethod(tool): + return tool + method: Callable = tool + if inspect.iscoroutinefunction(method): + + @functools.wraps(method) + async def async_wrapper(*args: object, **kwargs: object) -> object: + return await method(*args, **kwargs) + + return async_wrapper + + @functools.wraps(method) + def sync_wrapper(*args: object, **kwargs: object) -> object: + return method(*args, **kwargs) + + return sync_wrapper + + +def _wrap_bound_method_tools( + config: types.GenerateContentConfigOrDict | None, +) -> types.GenerateContentConfigOrDict | None: + """Closure-wrap any bound-method tools in ``config`` (see :func:`_closure_if_bound_method`). + + Returns ``config`` unchanged when it holds no bound-method tools; otherwise + returns a shallow copy with the tools list rewritten, so the caller's config + is never mutated. + """ + if not config: + return config + if isinstance(config, dict): + tools = config.get("tools") + if not tools or not any(inspect.ismethod(t) for t in tools): + return config + updated: Any = { + **config, + "tools": [_closure_if_bound_method(t) for t in tools], + } + return cast(types.GenerateContentConfigDict, updated) + if not config.tools or not any(inspect.ismethod(t) for t in config.tools): + return config + return config.model_copy( + update={"tools": [_closure_if_bound_method(t) for t in config.tools]} + ) + + +class _TemporalAsyncModels(AsyncModels): + """``AsyncModels`` that closure-wraps bound-method tools before each call. + + This shields workflow-method tools from google-genai's internal deep-copy of + the config (>= 2.8.0), which would otherwise clone the workflow instance and + silently drop the tool's in-workflow state mutations. + """ + + async def generate_content( # type: ignore[override] + self, + *, + model: str, + contents: types.ContentListUnion | types.ContentListUnionDict, + config: types.GenerateContentConfigOrDict | None = None, + ) -> types.GenerateContentResponse: + return await super().generate_content( + model=model, + contents=contents, + config=_wrap_bound_method_tools(config), + ) + + async def generate_content_stream( # type: ignore[override] + self, + *, + model: str, + contents: types.ContentListUnion | types.ContentListUnionDict, + config: types.GenerateContentConfigOrDict | None = None, + ) -> AsyncIterator[types.GenerateContentResponse]: + return await super().generate_content_stream( + model=model, + contents=contents, + config=_wrap_bound_method_tools(config), + ) + + +class TemporalAsyncClient(AsyncClient): + """An ``AsyncClient`` whose API calls run as Temporal activities. + + .. warning:: + This API is experimental and may change in future versions. + Use with caution in production environments. + + Builds a private ``BaseApiClient`` that dispatches HTTP calls through + ``workflow.execute_activity`` and wraps it, so the SDK's request-formatting + code (including the AFC loop) runs in the workflow while only the actual + API calls cross into activities. Credentials are never fetched or stored + in the workflow — the activity worker handles authentication independently. + + ``AsyncFiles`` and ``AsyncFileSearchStores`` are replaced with shims that + run upload/download as activities; ``interactions`` and ``agents`` — which + bypass ``BaseApiClient`` via a vendored HTTP client — are likewise replaced + with activity-backed shims; ``webhooks`` is not supported in workflows and + raises. Other modules (models, tunings, caches, batches, live, tokens, + operations) are inherited unchanged and work through the private api + client's activity-backed HTTP methods. + + Construct it from within a workflow ``run`` method: + + .. code-block:: python + + @workflow.defn + class MyWorkflow: + @workflow.run + async def run(self, query: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.0-flash", + contents=query, + config=GenerateContentConfig( + tools=[ + activity_as_tool( + my_tool, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=30), + ), + ), + ], + ), + ) + return response.text + """ + + def __init__( + self, + *, + vertexai: bool = False, + project: str | None = None, + location: str | None = None, + activity_config: ActivityConfig | None = None, + streaming_topic: str | None = None, + streaming_batch_interval: timedelta = timedelta(milliseconds=100), + ) -> None: + """Initialize a Temporal-aware client. + + Args: + vertexai: Whether to use Vertex AI API endpoints. Must match the + ``GoogleGenAIPlugin`` configuration on the worker side. + Defaults to ``False`` (Gemini Developer API). + project: Google Cloud project ID. Only needed when + ``vertexai=True`` and the SDK's request formatting requires it + (e.g., cache operations). + location: Google Cloud location. Same conditions as ``project``. + activity_config: Override the default activity configuration + (timeouts, retry policy, etc.) for Gemini API call activities. + When not provided, every operation (model calls, files, + interactions, managed agents) defaults to a 60-second + ``start_to_close_timeout`` and Temporal's default retry policy. + streaming_topic: When set, ``generate_content_stream`` publishes each + streamed ``GenerateContentResponse`` to this + :class:`temporalio.contrib.workflow_streams.WorkflowStream` + topic as it arrives, so external consumers can observe the model + output in real time. The workflow must construct a + ``WorkflowStream`` in ``@workflow.init``; otherwise the call + raises. The workflow's own stream iteration is unchanged. + streaming_batch_interval: How often the streaming activity flushes + published chunks to the workflow stream. Defaults to 100ms. + """ + api_client = _TemporalApiClient( + vertexai=vertexai, + project=project, + location=location, + activity_config=activity_config, + streaming_topic=streaming_topic, + streaming_batch_interval=streaming_batch_interval, + ) + super().__init__(api_client) + # Closure-wrap bound-method tools so google-genai's internal + # config deep-copy (>= 2.8.0) can't clone the workflow instance. + self._models = _TemporalAsyncModels(api_client) + self._files = TemporalAsyncFiles(api_client, activity_config) + self._file_search_stores = TemporalAsyncFileSearchStores( + api_client, activity_config + ) + self._temporal_interactions = TemporalAsyncInteractions(activity_config) + self._temporal_agents = TemporalAsyncAgents(activity_config) + + @property + def interactions( # type: ignore[override] + self, + ) -> TemporalAsyncInteractions: # pyright: ignore[reportIncompatibleMethodOverride] + """Temporal-aware interactions resource; operations run as activities.""" + return self._temporal_interactions + + @property + def agents( # type: ignore[override] + self, + ) -> TemporalAsyncAgents: # pyright: ignore[reportIncompatibleMethodOverride] + """Temporal-aware agents resource; operations run as activities.""" + return self._temporal_agents + + @property + def webhooks(self) -> NoReturn: # pyright: ignore[reportIncompatibleMethodOverride] + """Raise — webhooks are not supported in Temporal workflows.""" + raise RuntimeError( + "client.webhooks is not supported in Temporal workflows. " + "Manage webhooks outside the workflow with a regular genai.Client." + ) diff --git a/temporalio/contrib/google_genai/_temporal_file_search_stores.py b/temporalio/contrib/google_genai/_temporal_file_search_stores.py new file mode 100644 index 000000000..7b7e3bbc8 --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_file_search_stores.py @@ -0,0 +1,109 @@ +"""Temporal-aware AsyncFileSearchStores shim. + +``TemporalAsyncFileSearchStores`` is an ``AsyncFileSearchStores`` subclass +whose ``upload_to_file_search_store`` method dispatches through a Temporal +activity so the entire upload (including filesystem access and resumable +upload negotiation) runs on the activity worker. +""" + +from __future__ import annotations + +import io +import os +from datetime import timedelta + +from google.genai import types +from google.genai.file_search_stores import AsyncFileSearchStores + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._models import ( + _GeminiUploadToFileSearchStoreRequest, +) +from temporalio.contrib.google_genai._temporal_api_client import ( + _TemporalApiClient, + _validate_http_options, +) +from temporalio.workflow import ActivityConfig + + +class TemporalAsyncFileSearchStores(AsyncFileSearchStores): + """``AsyncFileSearchStores`` subclass that routes ``upload_to_file_search_store`` through an activity. + + The entire upload operation — including filesystem access, resumable + upload negotiation, and chunked transfer — runs inside a Temporal + activity on the worker. All other methods (``create``, ``get``, + ``delete``, ``list``, ``import_file``, ``documents``) are inherited + and already work through the ``_TemporalApiClient``'s ``async_request`` + activity. + """ + + def __init__( + self, + api_client: _TemporalApiClient, + activity_config: ActivityConfig | None = None, + ) -> None: + """Initialize with activity config for upload timeouts.""" + super().__init__(api_client) + self._activity_config = ( + ActivityConfig(start_to_close_timeout=timedelta(seconds=60)) + if activity_config is None + else activity_config + ) + + async def upload_to_file_search_store( + self, + *, + file_search_store_name: str, + file: str | os.PathLike[str] | io.IOBase, + config: types.UploadToFileSearchStoreConfigOrDict | None = None, + ) -> types.UploadToFileSearchStoreOperation: + """Upload a file to a file search store via a Temporal activity. + + Accepts a file path (resolved on the worker), ``os.PathLike``, or + an ``io.IOBase`` (bytes sent across the activity boundary). + """ + act_config: ActivityConfig = {**self._activity_config} + if "summary" not in act_config: + act_config["summary"] = "file_search_stores.upload" + + upload_config = None + if config is not None: + if isinstance(config, dict): + upload_config = types.UploadToFileSearchStoreConfig.model_validate( + config + ) + else: + upload_config = config + _validate_http_options(upload_config.http_options) + + if isinstance(file, io.IOBase): + file_bytes = file.read() + if not isinstance(file_bytes, bytes): + raise TypeError( + "file must be a binary stream when passing an io.IOBase; " + f"file.read() must return bytes (got {type(file_bytes).__name__})" + ) + req = _GeminiUploadToFileSearchStoreRequest( + file_search_store_name=file_search_store_name, + file_bytes=file_bytes, + config=upload_config, + ) + elif isinstance(file, str): + req = _GeminiUploadToFileSearchStoreRequest( + file_search_store_name=file_search_store_name, + file_path=file, + config=upload_config, + ) + else: + req = _GeminiUploadToFileSearchStoreRequest( + file_search_store_name=file_search_store_name, + file_path=file.__fspath__(), + config=upload_config, + ) + + return await temporal_workflow.execute_activity( + "gemini_file_search_stores_upload", + req, + result_type=types.UploadToFileSearchStoreOperation, + **act_config, + ) diff --git a/temporalio/contrib/google_genai/_temporal_files.py b/temporalio/contrib/google_genai/_temporal_files.py new file mode 100644 index 000000000..f785c00cb --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_files.py @@ -0,0 +1,169 @@ +"""Temporal-aware AsyncFiles shim. + +``TemporalAsyncFiles`` is an ``AsyncFiles`` subclass whose ``upload`` +and ``download`` methods dispatch through Temporal activities so the +entire file operation (including filesystem access) runs on the +activity worker. +""" + +from __future__ import annotations + +import io +import os +from datetime import timedelta +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + import google.auth.credentials +from google.genai import types +from google.genai.files import AsyncFiles + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._models import ( + _GeminiDownloadFileRequest, + _GeminiRegisterFilesRequest, + _GeminiUploadFileRequest, +) +from temporalio.contrib.google_genai._temporal_api_client import ( + _TemporalApiClient, + _validate_http_options, +) +from temporalio.workflow import ActivityConfig + + +class TemporalAsyncFiles(AsyncFiles): + """``AsyncFiles`` subclass that routes ``upload`` and ``download`` through activities. + + The entire file operation — including filesystem access, resumable + upload negotiation, and chunked transfer — runs inside a Temporal + activity on the worker. ``get``, ``delete``, and ``list`` are + inherited from ``AsyncFiles`` and already work through the + ``_TemporalApiClient``'s ``async_request`` activity. + """ + + def __init__( + self, + api_client: _TemporalApiClient, + activity_config: ActivityConfig | None = None, + ) -> None: + """Initialize with activity config for file operation timeouts.""" + super().__init__(api_client) + self._activity_config = ( + ActivityConfig(start_to_close_timeout=timedelta(seconds=60)) + if activity_config is None + else activity_config + ) + + async def upload( + self, + *, + file: str | os.PathLike[str] | io.IOBase, + config: types.UploadFileConfigOrDict | None = None, + ) -> types.File: + """Upload a file via a Temporal activity. + + Accepts a file path (resolved on the worker), ``os.PathLike``, or + an ``io.IOBase`` (bytes sent across the activity boundary). + """ + act_config: ActivityConfig = {**self._activity_config} + if "summary" not in act_config: + act_config["summary"] = "files.upload" + + upload_config = None + if config is not None: + if isinstance(config, dict): + upload_config = types.UploadFileConfig.model_validate(config) + else: + upload_config = config + _validate_http_options(upload_config.http_options) + + if isinstance(file, io.IOBase): + file_bytes = file.read() + if not isinstance(file_bytes, bytes): + raise TypeError( + "file must be a binary stream when passing an io.IOBase; " + f"file.read() must return bytes (got {type(file_bytes).__name__})" + ) + req = _GeminiUploadFileRequest(file_bytes=file_bytes, config=upload_config) + elif isinstance(file, str): + req = _GeminiUploadFileRequest(file_path=file, config=upload_config) + else: + # os.PathLike — convert via __fspath__() to avoid importing os + req = _GeminiUploadFileRequest( + file_path=file.__fspath__(), config=upload_config + ) + + return await temporal_workflow.execute_activity( + "gemini_files_upload", + req, + result_type=types.File, + **act_config, + ) + + async def download( + self, + *, + file: str | types.File, + config: types.DownloadFileConfigOrDict | None = None, + ) -> bytes: + """Download a file via a Temporal activity.""" + act_config: ActivityConfig = {**self._activity_config} + if "summary" not in act_config: + act_config["summary"] = "files.download" + + download_config = None + if config is not None: + if isinstance(config, dict): + download_config = types.DownloadFileConfig.model_validate(config) + else: + download_config = config + _validate_http_options(download_config.http_options) + + if isinstance(file, types.File): + if not file.name: + raise ValueError("File object must have a name to download.") + file_name = file.name + else: + file_name = file + + return await temporal_workflow.execute_activity( + "gemini_files_download", + _GeminiDownloadFileRequest(file=file_name, config=download_config), + result_type=bytes, + **act_config, + ) + + async def register_files( + self, + *, + auth: google.auth.credentials.Credentials, + uris: list[str], + config: types.RegisterFilesConfigOrDict | None = None, + ) -> types.RegisterFilesResponse: + """Register GCS files via a Temporal activity. + + .. note:: + The ``auth`` parameter is **ignored**. The activity uses + ``credentials`` if provided to ``GoogleGenAIPlugin``, + otherwise falls back to the ``genai.Client``'s own credentials. + Either way, those credentials must have access to the GCS URIs + being registered. + """ + act_config: ActivityConfig = {**self._activity_config} + if "summary" not in act_config: + act_config["summary"] = "files.register_files" + + register_config = None + if config is not None: + if isinstance(config, dict): + register_config = types.RegisterFilesConfig.model_validate(config) + else: + register_config = config + _validate_http_options(register_config.http_options) + + return await temporal_workflow.execute_activity( + "gemini_files_register", + _GeminiRegisterFilesRequest(uris=uris, config=register_config), + result_type=types.RegisterFilesResponse, + **act_config, + ) diff --git a/temporalio/contrib/google_genai/_temporal_interactions.py b/temporalio/contrib/google_genai/_temporal_interactions.py new file mode 100644 index 000000000..5a307d6e1 --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_interactions.py @@ -0,0 +1,256 @@ +"""Temporal-aware interactions resource shim. + +``TemporalAsyncInteractions`` exposes the same surface as google-genai's +``AsyncClient.interactions`` resource, but each operation is dispatched through +a Temporal activity holding the real ``genai.Client`` on the worker. The +Interactions API does not go through ``BaseApiClient`` — it uses a vendored, +Stainless-generated HTTP client that the ``TemporalApiClient`` shim never sees — +so each operation is routed as a whole through an activity instead. + +The shim depends only on the public ``google.genai.interactions`` surface (types +plus ``client.aio.interactions`` on the worker), not on google-genai internals, +so it is unaffected by regeneration of the vendored client. +""" + +from __future__ import annotations + +from collections.abc import AsyncIterator +from datetime import timedelta +from types import TracebackType +from typing import Any, cast + +import pydantic +from google.genai.interactions import Interaction, InteractionSSEEvent + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._models import ( + _GeminiInteractionIdRequest, + _GeminiInteractionRequest, + _GeminiInteractionStreamedResponse, +) +from temporalio.workflow import ActivityConfig + +_DEFAULT_INTERACTION_TIMEOUT = timedelta(seconds=60) + +# ``InteractionSSEEvent`` is a discriminated union (on ``event_type``); a +# ``TypeAdapter`` dispatches it — including nested unions such as a +# ``step.start`` event's ``step`` — leniently. +_SSE_EVENT_ADAPTER: pydantic.TypeAdapter[Any] = pydantic.TypeAdapter( + InteractionSSEEvent +) + + +def _deserialize(value: dict[str, Any], type_: Any) -> Any: + """Rehydrate a dict returned by an activity into its public genai model. + + ``InteractionSSEEvent`` is deserialized through its ``TypeAdapter``, which + dispatches the discriminated union (and nested unions) and tolerates the + sparse nested payloads the API legitimately emits (e.g. an + ``interaction.created`` event carrying an ``Interaction`` with just ``id`` + and ``object``). Plain models use ``model_validate``, which recurses nested + models (e.g. ``AgentListResponse.agents`` into ``Agent``) and resolves + aliases; the SDK's optional fields keep it tolerant of the minimal objects + the API returns. Both paths are pure functions, safe to run in the workflow + on every replay. + """ + if type_ is InteractionSSEEvent: + return _SSE_EVENT_ADAPTER.validate_python(value) + return type_.model_validate(value) + + +def _pop_timeout(params: dict[str, Any], config: ActivityConfig) -> None: + """Pop a per-call ``timeout`` kwarg and apply it to the activity config. + + The Interactions API expresses timeouts in seconds. Temporal owns + timeouts/retries, so the value maps to ``start_to_close_timeout`` + rather than being forwarded to the underlying HTTP client. + """ + timeout = params.pop("timeout", None) + if timeout is None: + return + if not isinstance(timeout, (int, float)) or isinstance(timeout, bool): + raise ValueError( + "timeout must be numeric seconds when calling the Interactions " + "API from a workflow; configure anything more granular via " + "activity_config instead." + ) + config["start_to_close_timeout"] = timedelta(seconds=timeout) + + +class _TemporalInteractionAsyncStream: + """Async stream over interaction events already drained in an activity. + + Presents the same ``async for`` / ``async with`` / ``close()`` surface as + the SDK's streaming response, but iterates an in-memory event list drained + inside the activity (there is no httpx response or client on the workflow + side), rehydrating each event back into its typed form on iteration. + """ + + def __init__( + self, + events: list[dict[str, Any]], + ) -> None: + self._events = events + + def __aiter__(self) -> AsyncIterator[InteractionSSEEvent]: + return self._iter() + + async def _iter(self) -> AsyncIterator[InteractionSSEEvent]: + for event in self._events: + yield cast(InteractionSSEEvent, _deserialize(event, InteractionSSEEvent)) + + async def __aenter__(self) -> _TemporalInteractionAsyncStream: + return self + + async def __aexit__( + self, + exc_type: type[BaseException] | None, + exc: BaseException | None, + exc_tb: TracebackType | None, + ) -> None: + pass + + async def close(self) -> None: + """No-op — the upstream stream was drained inside the activity.""" + pass + + +class TemporalAsyncInteractions: + """Interactions resource shim that routes calls through activities. + + Methods accept the same keyword arguments as the real resource and + forward them verbatim — the SDK validates them on the worker side, so + a bad argument surfaces as an activity failure (retried per the + activity's retry policy) rather than a workflow-side error. + + ``with_raw_response`` / ``with_streaming_response`` are not supported + in workflows. + """ + + def __init__( + self, + activity_config: ActivityConfig | None = None, + ) -> None: + self._activity_config = ( + ActivityConfig(start_to_close_timeout=_DEFAULT_INTERACTION_TIMEOUT) + if activity_config is None + else activity_config + ) + + def _config(self, summary: str, params: dict[str, Any]) -> ActivityConfig: + config: ActivityConfig = {**self._activity_config} + if "summary" not in config: + config["summary"] = summary + _pop_timeout(params, config) + return config + + async def create( + self, + *, + stream: bool = False, + **kwargs: Any, + ) -> Interaction | _TemporalInteractionAsyncStream: + """Create an interaction via a Temporal activity. + + ``kwargs`` is forwarded verbatim to ``client.aio.interactions.create`` + on the worker. With ``stream=True`` the activity drains the SSE + stream and returns all events batched; the returned object supports + ``async for`` / ``async with`` like the SDK's streaming response. + """ + params = dict(kwargs) + config = self._config( + "interactions.create (stream)" if stream else "interactions.create", + params, + ) + req = _GeminiInteractionRequest(params=params) + if stream: + resp = await temporal_workflow.execute_activity( + "gemini_interactions_create_streamed", + req, + result_type=_GeminiInteractionStreamedResponse, + **config, + ) + return _TemporalInteractionAsyncStream(resp.events) + raw = await temporal_workflow.execute_activity( + "gemini_interactions_create", + req, + result_type=dict[str, Any], + **config, + ) + return cast(Interaction, _deserialize(raw, Interaction)) + + async def get( + self, + id: str, + *, + stream: bool = False, + **kwargs: Any, + ) -> Interaction | _TemporalInteractionAsyncStream: + """Get an interaction via a Temporal activity. + + Supports ``stream=True`` (with the SDK's ``last_event_id`` kwarg + for resumption); events come back batched like :meth:`create`. + """ + params = dict(kwargs) + config = self._config( + "interactions.get (stream)" if stream else "interactions.get", + params, + ) + req = _GeminiInteractionIdRequest(id=id, params=params) + if stream: + resp = await temporal_workflow.execute_activity( + "gemini_interactions_get_streamed", + req, + result_type=_GeminiInteractionStreamedResponse, + **config, + ) + return _TemporalInteractionAsyncStream(resp.events) + raw = await temporal_workflow.execute_activity( + "gemini_interactions_get", + req, + result_type=dict[str, Any], + **config, + ) + return cast(Interaction, _deserialize(raw, Interaction)) + + async def delete( + self, + id: str, + **kwargs: Any, + ) -> object: + """Delete an interaction via a Temporal activity.""" + params = dict(kwargs) + config = self._config("interactions.delete", params) + return await temporal_workflow.execute_activity( + "gemini_interactions_delete", + _GeminiInteractionIdRequest(id=id, params=params), + **config, + ) + + async def cancel( + self, + id: str, + **kwargs: Any, + ) -> Interaction: + """Cancel an interaction via a Temporal activity.""" + params = dict(kwargs) + config = self._config("interactions.cancel", params) + raw = await temporal_workflow.execute_activity( + "gemini_interactions_cancel", + _GeminiInteractionIdRequest(id=id, params=params), + result_type=dict[str, Any], + **config, + ) + return cast(Interaction, _deserialize(raw, Interaction)) + + @property + def with_raw_response(self) -> Any: + """Raise — raw responses are not available in workflows.""" + raise RuntimeError("with_raw_response is not supported in Temporal workflows.") + + @property + def with_streaming_response(self) -> Any: + """Raise — streaming responses are not available in workflows.""" + raise RuntimeError( + "with_streaming_response is not supported in Temporal workflows." + ) diff --git a/temporalio/contrib/google_genai/_temporal_mcp.py b/temporalio/contrib/google_genai/_temporal_mcp.py new file mode 100644 index 000000000..718c6aaa3 --- /dev/null +++ b/temporalio/contrib/google_genai/_temporal_mcp.py @@ -0,0 +1,116 @@ +"""Temporal-aware ``mcp.ClientSession`` shim. + +``TemporalMcpClientSession`` is an ``mcp.ClientSession`` subclass that the user +places in ``generate_content(config=GenerateContentConfig(tools=[...]))`` just +like a real MCP session. The Gemini SDK recognizes it via +``isinstance(tool, McpClientSession)`` and, inside ``generate_content`` (which +runs in the workflow), calls only two methods on it: ``list_tools()`` at tool +discovery and ``call_tool(name, arguments)`` in the automatic-function-calling +loop. Both are overridden here to dispatch to the ``{server}-list-tools`` / +``{server}-call-tool`` activities, so the real ``mcp.ClientSession`` lives only +on the worker (registered via ``GoogleGenAIPlugin(mcp_servers=...)``). + +This mirrors strands' ``TemporalMCPClient``: the handle carries only the server +name (which selects the worker-side factory) plus activity options; the +connection factory is never passed to the workflow or the root client. +""" + +from __future__ import annotations + +from datetime import timedelta +from typing import Any + +from mcp import ClientSession +from mcp.shared.session import ProgressFnT +from mcp.types import CallToolResult, ListToolsResult, PaginatedRequestParams + +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._models import _McpCallToolRequest +from temporalio.workflow import ActivityConfig + +_DEFAULT_MCP_TIMEOUT = timedelta(seconds=60) + + +class TemporalMcpClientSession(ClientSession): + """``mcp.ClientSession`` whose tool discovery and calls run as activities. + + .. warning:: + This API is experimental and may change in future versions. + + Construct inside a workflow and pass it in the ``tools`` list of a + ``generate_content`` call. The matching server name must be registered on + the worker via ``GoogleGenAIPlugin(mcp_servers={name: factory})``. + + ``cache_tools`` controls how often tools are listed. When ``False`` (the + default) the ``{server}-list-tools`` activity runs each time the SDK + discovers tools (i.e. per ``generate_content`` call), so a server whose + tools changed mid-workflow is picked up. When ``True`` the first listing is + cached on this instance and reused for its lifetime (replay-safe in-workflow + state). + + Args: + server_name: Name selecting the worker-side factory; also the activity + prefix (``{server_name}-list-tools`` / ``{server_name}-call-tool``). + cache_tools: Cache the tool listing after the first call. + activity_config: Activity configuration (timeouts, retry policy, etc.) + for the MCP activities. Defaults to a 60-second + ``start_to_close_timeout``. + """ + + def __init__( # pyright: ignore[reportMissingSuperCall] + self, + server_name: str, + *, + cache_tools: bool = False, + activity_config: ActivityConfig | None = None, + ) -> None: + """Initialize without calling super (no real streams exist here).""" + self._server_name = server_name + self._cache_tools = cache_tools + self._cached_tools: ListToolsResult | None = None + self._activity_config: ActivityConfig = ( + ActivityConfig(start_to_close_timeout=_DEFAULT_MCP_TIMEOUT) + if activity_config is None + else activity_config + ) + + def _config(self, summary: str) -> ActivityConfig: + config: ActivityConfig = {**self._activity_config} + if "summary" not in config: + config["summary"] = summary + return config + + async def list_tools( # pyright: ignore[reportIncompatibleMethodOverride] + self, + cursor: str | None = None, + *, + params: PaginatedRequestParams | None = None, + ) -> ListToolsResult: + """List the server's tools via the ``{server}-list-tools`` activity.""" + if self._cache_tools and self._cached_tools is not None: + return self._cached_tools + result = await temporal_workflow.execute_activity( + f"{self._server_name}-list-tools", + result_type=ListToolsResult, + **self._config(f"mcp.{self._server_name}.list_tools"), + ) + if self._cache_tools: + self._cached_tools = result + return result + + async def call_tool( # pyright: ignore[reportIncompatibleMethodOverride] + self, + name: str, + arguments: dict[str, Any] | None = None, + read_timeout_seconds: timedelta | None = None, + progress_callback: ProgressFnT | None = None, + *, + meta: dict[str, Any] | None = None, + ) -> CallToolResult: + """Call a tool via the ``{server}-call-tool`` activity.""" + return await temporal_workflow.execute_activity( + f"{self._server_name}-call-tool", + _McpCallToolRequest(name=name, arguments=arguments or {}), + result_type=CallToolResult, + **self._config(f"mcp.{self._server_name}.call_tool:{name}"), + ) diff --git a/temporalio/contrib/google_genai/testing.py b/temporalio/contrib/google_genai/testing.py new file mode 100644 index 000000000..d7884c636 --- /dev/null +++ b/temporalio/contrib/google_genai/testing.py @@ -0,0 +1,151 @@ +"""Testing utilities for the Google Gemini SDK Temporal integration. + +These let you exercise workflows that use +:class:`temporalio.contrib.google_genai.TemporalAsyncClient` without making +real Gemini API calls. Script the model's responses with :func:`text_response` +/ :func:`function_call_response`, build a plugin with +:class:`GeminiTestServer`, and register it on your worker like the real +:class:`temporalio.contrib.google_genai.GoogleGenAIPlugin`. + +Example:: + + server = GeminiTestServer( + [ + function_call_response("get_weather", {"city": "Tokyo"}), + text_response("It's sunny in Tokyo."), + ] + ) + async with Worker( + client, + task_queue="test", + workflows=[MyAgentWorkflow], + activities=[get_weather], + plugins=[server.plugin()], + ): + ... + assert len(server.requests) == 2 # one per model turn +""" + +from __future__ import annotations + +import json +from collections.abc import Sequence +from typing import Any + +from google.genai import Client as GeminiClient +from google.genai.types import HttpResponse as SdkHttpResponse + +from temporalio.contrib.google_genai._google_genai_plugin import GoogleGenAIPlugin + +__all__ = [ + "GeminiTestServer", + "function_call_response", + "text_response", +] + + +def text_response(text: str) -> str: + """Build a ``generate_content`` response body with a single text part.""" + return json.dumps( + { + "candidates": [ + { + "content": {"role": "model", "parts": [{"text": text}]}, + "finishReason": "STOP", + } + ], + "usageMetadata": { + "promptTokenCount": 5, + "candidatesTokenCount": 10, + }, + } + ) + + +def function_call_response(name: str, args: dict[str, Any]) -> str: + """Build a ``generate_content`` response body with a single function call. + + The Gemini SDK's automatic function calling loop will invoke the matching + tool, then request another response — so pair each function-call response + with a following :func:`text_response` (or further calls). + """ + return json.dumps( + { + "candidates": [ + { + "content": { + "role": "model", + "parts": [{"functionCall": {"name": name, "args": args}}], + }, + "finishReason": "STOP", + } + ], + "usageMetadata": { + "promptTokenCount": 10, + "candidatesTokenCount": 15, + }, + } + ) + + +class GeminiTestServer: + """Scripts Gemini model responses so workflows run without real API calls. + + Pass canned response bodies built with :func:`text_response` / + :func:`function_call_response`. Each model call — including each turn of an + automatic-function-calling loop and each ``generate_content_stream`` call — + consumes the next response in order. Build a plugin with :meth:`plugin` + and register it on your worker; inspect :attr:`requests` afterwards to + assert exactly what the integration sent. + + Only model calls (``client.models``) are scripted. File, interaction, and + agent operations are not; mock those on a ``genai.Client`` directly if a + test needs them. + """ + + def __init__(self, responses: Sequence[str]) -> None: + """Initialize with the response bodies to serve, in order.""" + self._responses = list(responses) + self._index = 0 + self.requests: list[dict[str, Any]] = [] + + def _next(self) -> str: + idx = self._index + self._index += 1 + if idx >= len(self._responses): + raise AssertionError( + f"GeminiTestServer ran out of responses (call {idx + 1}, " + f"have {len(self._responses)}); script another response." + ) + return self._responses[idx] + + def plugin(self) -> GoogleGenAIPlugin: + """Return a :class:`GoogleGenAIPlugin` whose model calls serve the script. + + The real plugin activities run; only the underlying HTTP layer is + replaced, so request formatting and the AFC loop are exercised exactly + as in production. + """ + client = GeminiClient(api_key="fake-test-key") + + async def fake_async_request(*_args: Any, **kwargs: Any) -> SdkHttpResponse: + self.requests.append(dict(kwargs.get("request_dict") or {})) + return SdkHttpResponse( + headers={"content-type": "application/json"}, + body=self._next(), + ) + + async def fake_async_request_streamed(*_args: Any, **kwargs: Any) -> Any: + self.requests.append(dict(kwargs.get("request_dict") or {})) + body = self._next() + + async def _gen() -> Any: + yield SdkHttpResponse( + headers={"content-type": "application/json"}, body=body + ) + + return _gen() + + client._api_client.async_request = fake_async_request # type: ignore[assignment] + client._api_client.async_request_streamed = fake_async_request_streamed # type: ignore[assignment] + return GoogleGenAIPlugin(client) diff --git a/temporalio/contrib/google_genai/workflow.py b/temporalio/contrib/google_genai/workflow.py new file mode 100644 index 000000000..08e40f0c5 --- /dev/null +++ b/temporalio/contrib/google_genai/workflow.py @@ -0,0 +1,111 @@ +"""Workflow utilities for Google Gemini SDK integration with Temporal. + +This module provides utilities for using the Google Gemini SDK within Temporal +workflows. The key entry points are: + +- :func:`activity_as_tool` — converts a Temporal activity into a Gemini tool + callable for use with automatic function calling (AFC). +""" + +from __future__ import annotations + +import functools +import inspect +from collections.abc import Callable +from typing import Any + +from temporalio import activity +from temporalio import workflow as temporal_workflow +from temporalio.contrib.google_genai._errors import GoogleGenAIError +from temporalio.workflow import ActivityConfig + + +def activity_as_tool( + fn: Callable, + *, + activity_config: ActivityConfig | None = None, +) -> Callable: + """Convert a Temporal activity into a Gemini-compatible async tool callable. + + .. warning:: + This API is experimental and may change in future versions. + Use with caution in production environments. + + Returns an async callable with the same name, docstring, and type signature as + ``fn``. When Gemini's automatic function calling (AFC) invokes the returned + callable from within a Temporal workflow, the call is executed as a Temporal + activity via :func:`workflow.execute_activity`. Each tool invocation therefore + appears as a separate, durable entry in the workflow event history. + + Because AFC is left **enabled**, the Gemini SDK owns the agentic loop — no + manual ``while`` loop or ``run_agent()`` helper is required. Pass the returned + callable directly to ``GenerateContentConfig(tools=[...])``. + + Args: + fn: A Temporal activity function decorated with ``@activity.defn``. + activity_config: Configuration for the activity execution (timeouts, + retry policy, etc.). Must set ``start_to_close_timeout`` or + ``schedule_to_close_timeout`` — Temporal requires one, and there is + no default; otherwise the tool call raises when the activity is + invoked. + + Returns: + An async callable suitable for use as a Gemini tool. + + Raises: + GoogleGenAIError: If ``fn`` is not decorated with ``@activity.defn`` or + has no activity name. + """ + ret = activity._Definition.from_callable(fn) + if not ret: + raise GoogleGenAIError( + "Bare function without @activity.defn decorator is not supported", + "invalid_tool", + ) + if ret.name is None: + raise GoogleGenAIError( + "Activity must have a name to be used as a Gemini tool", + "invalid_tool", + ) + + config: ActivityConfig = {**(activity_config or {})} + if "summary" not in config: + config["summary"] = "tool_call" + + # For class-based activities the first parameter is 'self'. Partially apply + # it so that Gemini inspects only the user-facing parameters when building + # the function-call schema, while the worker resolves the real instance at + # execution time. + params = list(inspect.signature(fn).parameters.keys()) + schema_fn: Callable = fn + if params and params[0] == "self": + partial = functools.partial(fn, None) + setattr(partial, "__name__", fn.__name__) + partial.__annotations__ = getattr(fn, "__annotations__", {}) + setattr( + partial, + "__temporal_activity_definition", + getattr(fn, "__temporal_activity_definition", None), + ) + partial.__doc__ = fn.__doc__ + schema_fn = partial + + activity_name: str = ret.name + + async def wrapper(*args: Any, **kwargs: Any) -> Any: + sig = inspect.signature(schema_fn) + bound = sig.bind(*args, **kwargs) + bound.apply_defaults() + activity_args = list(bound.arguments.values()) + return await temporal_workflow.execute_activity( + activity_name, + args=activity_args, + **config, + ) + + wrapper.__name__ = schema_fn.__name__ # type: ignore + wrapper.__doc__ = schema_fn.__doc__ + setattr(wrapper, "__signature__", inspect.signature(schema_fn)) + wrapper.__annotations__ = getattr(schema_fn, "__annotations__", {}) + + return wrapper diff --git a/tests/contrib/google_genai/__init__.py b/tests/contrib/google_genai/__init__.py new file mode 100644 index 000000000..26a790b56 --- /dev/null +++ b/tests/contrib/google_genai/__init__.py @@ -0,0 +1 @@ +"""Tests for the `google-genai` SDK Temporal integration.""" diff --git a/tests/contrib/google_genai/echo_mcp_server.py b/tests/contrib/google_genai/echo_mcp_server.py new file mode 100644 index 000000000..a69ac7b22 --- /dev/null +++ b/tests/contrib/google_genai/echo_mcp_server.py @@ -0,0 +1,15 @@ +"""A minimal stdio MCP server used by the google_genai MCP tests.""" + +from mcp.server.fastmcp import FastMCP + +mcp = FastMCP("echo-server") + + +@mcp.tool() +def echo(message: str) -> str: + """Return the input message unchanged.""" + return message + + +if __name__ == "__main__": + mcp.run() diff --git a/tests/contrib/google_genai/test_gemini.py b/tests/contrib/google_genai/test_gemini.py new file mode 100644 index 000000000..ab1f2d724 --- /dev/null +++ b/tests/contrib/google_genai/test_gemini.py @@ -0,0 +1,2045 @@ +"""Integration tests for the Google Gemini SDK Temporal integration. + +Tests cover: +- Basic generate_content through workflow +- Tool calling via activity_as_tool (single arg, multi arg, class method) +- Workflow method as a plain tool (runs in-workflow, not as an activity) +- Tool failure propagation +- Multiple sequential tool calls with arg verification +- Batched streaming via generate_content_stream +- Per-request http_options propagation +- File upload (str path + io.BytesIO) and download via TemporalAsyncFiles +- File search store upload via TemporalAsyncFileSearchStores +- Multi-turn chat via client.chats +- TemporalAsyncClient wiring (files, file_search_stores) +- _TemporalApiClient edge cases (sync raises) +- activity_as_tool validation and metadata preservation +- TemporalAsyncClient configuration +- Interactions API (create, batched streaming, get, cancel, delete) +- Managed agents (create, get, list, delete); webhooks unsupported +""" + +import inspect +import io +import json +import uuid +from datetime import timedelta +from typing import Any +from unittest.mock import AsyncMock, MagicMock + +import pytest +from google.genai import Client as GeminiClient +from google.genai import types +from google.genai.interactions import ( + Agent, + Interaction, + InteractionSSEEvent, +) +from google.genai.types import HttpResponse as SdkHttpResponse + +from temporalio import activity, workflow +from temporalio.client import Client, WorkflowFailureError +from temporalio.common import RetryPolicy +from temporalio.contrib.google_genai import ( + GoogleGenAIError, + GoogleGenAIPlugin, + activity_as_tool, +) +from temporalio.contrib.google_genai._models import ( + _GeminiApiRequest, + _GeminiApiResponse, + _GeminiApiStreamedResponse, + _GeminiDownloadFileRequest, + _GeminiInteractionIdRequest, + _GeminiInteractionRequest, + _GeminiInteractionStreamedResponse, + _GeminiUploadFileRequest, + _GeminiUploadToFileSearchStoreRequest, +) +from temporalio.contrib.google_genai._temporal_api_client import ( + _TemporalApiClient, +) +from temporalio.contrib.google_genai._temporal_async_client import ( + TemporalAsyncClient, + _closure_if_bound_method, + _wrap_bound_method_tools, +) +from temporalio.contrib.google_genai._temporal_file_search_stores import ( + TemporalAsyncFileSearchStores, +) +from temporalio.contrib.google_genai._temporal_files import ( + TemporalAsyncFiles, +) +from temporalio.contrib.google_genai._temporal_interactions import _deserialize +from temporalio.exceptions import ApplicationError +from temporalio.worker import Replayer +from temporalio.workflow import ActivityConfig +from tests.helpers import new_worker + +# --------------------------------------------------------------------------- +# Mock response helpers +# --------------------------------------------------------------------------- + + +def make_text_response(text: str) -> str: + """Build a JSON body string for a simple text response.""" + return json.dumps( + { + "candidates": [ + { + "content": { + "role": "model", + "parts": [{"text": text}], + }, + "finishReason": "STOP", + } + ], + "usageMetadata": { + "promptTokenCount": 5, + "candidatesTokenCount": 10, + }, + } + ) + + +def make_function_call_response(fn_name: str, args: dict) -> str: + """Build a JSON body string for a function-call response.""" + return json.dumps( + { + "candidates": [ + { + "content": { + "role": "model", + "parts": [{"functionCall": {"name": fn_name, "args": args}}], + }, + "finishReason": "STOP", + } + ], + "usageMetadata": { + "promptTokenCount": 10, + "candidatesTokenCount": 15, + }, + } + ) + + +INTERACTION_ID = "interactions/test-123" + + +def make_interaction_dict(status: str = "completed") -> dict[str, Any]: + """Build a minimal Interaction dict as the API would return it.""" + return {"id": INTERACTION_ID, "object": "interaction", "status": status} + + +def make_interaction_sse_events() -> list[dict[str, Any]]: + """Build a small SSE event sequence for a streamed interaction. + + Includes a sparse ``interaction.created`` payload (just ``id`` and + ``object``) to exercise the lenient ``_deserialize`` rehydration. + """ + return [ + { + "event_type": "interaction.created", + "interaction": {"id": INTERACTION_ID, "object": "interaction"}, + }, + { + "event_type": "step.delta", + "index": 0, + "delta": {"type": "text", "text": "Hello "}, + }, + { + "event_type": "step.delta", + "index": 0, + "delta": {"type": "text", "text": "world"}, + }, + {"event_type": "interaction.completed", "interaction": make_interaction_dict()}, + ] + + +def make_agent_dict(agent_id: str = "test-agent") -> dict[str, Any]: + """Build a minimal managed-agent dict as the API would return it.""" + return {"id": agent_id, "system_instruction": "Be helpful."} + + +# --------------------------------------------------------------------------- +# Tool call tracker — records every tool invocation for assertion +# --------------------------------------------------------------------------- + + +class ToolCallTracker: + """Tracks tool invocations across activities and workflow methods. + + Each tool appends (name, args_dict) to ``calls`` so tests can assert + exactly which tools were called, in what order, with what arguments. + """ + + def __init__(self) -> None: + self.calls: list[tuple[str, dict]] = [] + + @activity.defn + async def get_weather(self, city: str) -> str: + """Get the weather for a given city.""" + self.calls.append(("get_weather", {"city": city})) + return f"Weather in {city}: Sunny, 20C" + + @activity.defn + async def get_weather_country(self, city: str, country: str) -> str: + """Get the weather for a given city in a country.""" + self.calls.append(("get_weather_country", {"city": city, "country": country})) + return f"Weather in {city}, {country}: Rainy, 15C" + + @activity.defn + async def get_weather_failure(self, city: str) -> str: + """Activity that always fails.""" + self.calls.append(("get_weather_failure", {"city": city})) + raise ApplicationError("Weather service unavailable", non_retryable=True) + + +# --------------------------------------------------------------------------- +# Test helper: tracking gemini_api_client_async_request activity +# --------------------------------------------------------------------------- + + +class GeminiApiCallTracker: + """A test replacement for the gemini_api_client activities. + + Records every ``_GeminiApiRequest`` received and returns canned + ``_GeminiApiResponse`` bodies in order. After the workflow completes, + inspect ``requests`` to verify exactly what the integration sent. + + For streamed requests, the mock response is split into per-line chunks + to simulate multiple streamed chunks. + + The real ``GoogleGenAIPlugin`` is still used for its data converter, sandbox + passthrough, and workflow runner configuration — only its activity + registration is suppressed so this tracker can take its place. + """ + + def __init__(self, mock_responses: list[str]) -> None: + self._mock_responses = mock_responses + self.requests: list[_GeminiApiRequest] = [] + self.file_upload_requests: list[_GeminiUploadFileRequest] = [] + self.file_download_requests: list[_GeminiDownloadFileRequest] = [] + self.file_search_store_upload_requests: list[ + _GeminiUploadToFileSearchStoreRequest + ] = [] + self.interaction_requests: list[_GeminiInteractionRequest] = [] + self.interaction_id_requests: list[_GeminiInteractionIdRequest] = [] + self._call_index = 0 + + def _next_response(self, req: _GeminiApiRequest) -> str: + self.requests.append(req) + idx = self._call_index + self._call_index += 1 + if idx >= len(self._mock_responses): + raise ApplicationError( + f"No more mock responses (called {idx + 1} times, " + f"have {len(self._mock_responses)})", + non_retryable=True, + ) + return self._mock_responses[idx] + + @activity.defn + async def gemini_api_client_async_request( + self, req: _GeminiApiRequest + ) -> _GeminiApiResponse: + return _GeminiApiResponse( + headers={"content-type": "application/json"}, + body=self._next_response(req), + ) + + @activity.defn + async def gemini_api_client_async_request_streamed( + self, req: _GeminiApiRequest + ) -> _GeminiApiStreamedResponse: + body = self._next_response(req) + # Split the response text into word-level chunks so tests can + # verify that multiple chunks are yielded back to the workflow. + parsed = json.loads(body) + full_text = ( + parsed.get("candidates", [{}])[0] + .get("content", {}) + .get("parts", [{}])[0] + .get("text", "") + ) + words = full_text.split() + chunks = [] + for word in words: + chunks.append( + _GeminiApiResponse( + headers={"content-type": "application/json"}, + body=make_text_response(word), + ) + ) + return _GeminiApiStreamedResponse(chunks=chunks) + + @activity.defn + async def gemini_files_upload(self, req: _GeminiUploadFileRequest) -> types.File: + self.file_upload_requests.append(req) + return types.File( + name="files/test-uploaded-file", + uri="https://fake.uri/files/test-uploaded-file", + size_bytes=len(req.file_bytes) if req.file_bytes else 0, + ) + + @activity.defn + async def gemini_files_download(self, req: _GeminiDownloadFileRequest) -> bytes: + self.file_download_requests.append(req) + return b"fake file content" + + @activity.defn + async def gemini_file_search_stores_upload( + self, req: _GeminiUploadToFileSearchStoreRequest + ) -> types.UploadToFileSearchStoreOperation: + self.file_search_store_upload_requests.append(req) + return types.UploadToFileSearchStoreOperation.model_construct( + name="operations/test-op", + ) + + @activity.defn + async def gemini_interactions_create( + self, req: _GeminiInteractionRequest + ) -> dict[str, Any]: + self.interaction_requests.append(req) + return make_interaction_dict() + + @activity.defn + async def gemini_interactions_create_streamed( + self, req: _GeminiInteractionRequest + ) -> _GeminiInteractionStreamedResponse: + self.interaction_requests.append(req) + return _GeminiInteractionStreamedResponse(events=make_interaction_sse_events()) + + @activity.defn + async def gemini_interactions_get( + self, req: _GeminiInteractionIdRequest + ) -> dict[str, Any]: + self.interaction_id_requests.append(req) + return make_interaction_dict() + + @activity.defn + async def gemini_interactions_get_streamed( + self, req: _GeminiInteractionIdRequest + ) -> _GeminiInteractionStreamedResponse: + self.interaction_id_requests.append(req) + return _GeminiInteractionStreamedResponse(events=make_interaction_sse_events()) + + @activity.defn + async def gemini_interactions_delete(self, req: _GeminiInteractionIdRequest) -> Any: + self.interaction_id_requests.append(req) + return {"deleted": True} + + @activity.defn + async def gemini_interactions_cancel( + self, req: _GeminiInteractionIdRequest + ) -> dict[str, Any]: + self.interaction_id_requests.append(req) + return make_interaction_dict(status="cancelled") + + @activity.defn + async def gemini_agents_create( + self, req: _GeminiInteractionRequest + ) -> dict[str, Any]: + self.interaction_requests.append(req) + return make_agent_dict(req.params.get("id", "test-agent")) + + @activity.defn + async def gemini_agents_list( + self, req: _GeminiInteractionRequest + ) -> dict[str, Any]: + self.interaction_requests.append(req) + return {"agents": [make_agent_dict()], "next_page_token": "next-tok"} + + @activity.defn + async def gemini_agents_get( + self, req: _GeminiInteractionIdRequest + ) -> dict[str, Any]: + self.interaction_id_requests.append(req) + return make_agent_dict(req.id) + + @activity.defn + async def gemini_agents_delete( + self, req: _GeminiInteractionIdRequest + ) -> dict[str, Any]: + self.interaction_id_requests.append(req) + return {"id": req.id, "deleted": True} + + +def apply_plugin( + client: Client, mock_responses: list[str] +) -> tuple[Client, GeminiApiCallTracker]: + """Create a real GoogleGenAIPlugin whose activities include a tracking fake. + + Monkey-patches ``GeminiApiCaller.activities`` so that when the plugin + constructs itself, it registers our tracking activity instead of + the real ones. Everything else — data converter, sandbox passthrough, + workflow runner — is the real plugin code. + + Returns the configured Temporal client and the tracker. + """ + from temporalio.contrib.google_genai._gemini_activity import GeminiApiCaller + + tracker = GeminiApiCallTracker(mock_responses) + original_activities = GeminiApiCaller.activities + GeminiApiCaller.activities = lambda self: [ # type: ignore[method-assign] + tracker.gemini_api_client_async_request, + tracker.gemini_api_client_async_request_streamed, + tracker.gemini_files_upload, + tracker.gemini_files_download, + tracker.gemini_file_search_stores_upload, + tracker.gemini_interactions_create, + tracker.gemini_interactions_create_streamed, + tracker.gemini_interactions_get, + tracker.gemini_interactions_get_streamed, + tracker.gemini_interactions_delete, + tracker.gemini_interactions_cancel, + tracker.gemini_agents_create, + tracker.gemini_agents_list, + tracker.gemini_agents_get, + tracker.gemini_agents_delete, + ] + try: + gemini = GeminiClient(api_key="fake-test-key") + plugin = GoogleGenAIPlugin(gemini) + finally: + GeminiApiCaller.activities = original_activities # type: ignore[method-assign] + + config = client.config() + config["plugins"] = [plugin] + return Client(**config), tracker + + +# --------------------------------------------------------------------------- +# Workflows +# --------------------------------------------------------------------------- + + +@workflow.defn +class SimpleGenerateWorkflow: + """Workflow that does a simple generate_content call.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + ) + return response.text or "" + + +@workflow.defn +class SingleArgToolWorkflow: + """Workflow that uses activity_as_tool for a single-arg tool.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + ToolCallTracker.get_weather, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=10), + ), + ), + ], + ), + ) + return response.text or "" + + +@workflow.defn +class MultiArgToolWorkflow: + """Workflow with multi-arg tool.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + ToolCallTracker.get_weather_country, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=10), + ), + ), + ], + ), + ) + return response.text or "" + + +@workflow.defn +class ToolFailureWorkflow: + """Workflow with a tool that always fails.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + ToolCallTracker.get_weather_failure, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=10), + retry_policy=RetryPolicy(maximum_attempts=1), + ), + ), + ], + ), + ) + return response.text or "" + + +@workflow.defn +class MultipleToolsWorkflow: + """Workflow with multiple tools that are called in sequence.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[ + activity_as_tool( + ToolCallTracker.get_weather, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=10), + ), + ), + activity_as_tool( + ToolCallTracker.get_weather_country, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=10), + ), + ), + ], + ), + ) + return response.text or "" + + +@workflow.defn +class WorkflowMethodToolWorkflow: + """Workflow that passes a plain method as a tool (runs in-workflow, not as an activity).""" + + def __init__(self) -> None: + self.tool_calls: list[tuple[str, dict]] = [] + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + tools=[self.lookup_city], + ), + ) + return response.text or "" + + async def lookup_city(self, city: str) -> str: + """Look up info about a city.""" + self.tool_calls.append(("lookup_city", {"city": city})) + return f"{city} is a great place to visit" + + @workflow.query + def get_tool_calls(self) -> list[tuple[str, dict]]: + return self.tool_calls + + +@workflow.defn +class StreamedGenerateWorkflow: + """Workflow that uses generate_content_stream.""" + + @workflow.run + async def run(self, prompt: str) -> list[str]: + client = TemporalAsyncClient() + chunks: list[str] = [] + async for chunk in await client.models.generate_content_stream( + model="gemini-2.5-flash", + contents=prompt, + ): + if chunk.text: + chunks.append(chunk.text) + return chunks + + +@workflow.defn +class HttpOptionsWorkflow: + """Workflow that passes per-request http_options through generate_content.""" + + @workflow.run + async def run(self, prompt: str, http_options: types.HttpOptionsDict) -> str: + client = TemporalAsyncClient() + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig( + http_options=types.HttpOptions.model_validate(http_options), + ), + ) + return response.text or "" + + +@workflow.defn +class FullIntegrationWorkflow: + """Exercises every activity path in a single workflow run. + + Uses the real GoogleGenAIPlugin activities (not the tracker), so this + tests the actual activity implementations end-to-end with a mocked + genai.Client. + """ + + @workflow.run + async def run(self, prompt: str) -> dict[str, Any]: + client = TemporalAsyncClient() + results: dict[str, Any] = {} + + # 1. generate_content (async_request activity) + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + ) + results["generate"] = response.text or "" + + # 2. generate_content_stream (async_request_streamed activity) + chunks: list[str] = [] + async for chunk in await client.models.generate_content_stream( + model="gemini-2.5-flash", + contents=prompt, + ): + if chunk.text: + chunks.append(chunk.text) + results["stream_chunks"] = chunks + + # 3. files.upload (gemini_files_upload activity) + uploaded = await client.files.upload( + file="/tmp/fake.txt", + config=types.UploadFileConfig(display_name="Integration Test"), + ) + results["upload_name"] = uploaded.name or "" + + # 4. files.download (gemini_files_download activity) + data = await client.files.download(file="files/some-file") + results["download"] = data.decode() if isinstance(data, bytes) else str(data) + + # 5. file_search_stores.upload_to_file_search_store activity + store_name = "fileSearchStores/test" + op = await client.file_search_stores.upload_to_file_search_store( + file_search_store_name=store_name, + file="/tmp/doc.txt", + ) + results["fss_upload_op"] = op.name or "" + + # 6. generate_content grounded with file_search tool (RAG query) + rag_response = await client.models.generate_content( + model="gemini-2.5-flash", + contents="What does the document say?", + config=types.GenerateContentConfig( + tools=[ + types.Tool( + file_search=types.FileSearch( + file_search_store_names=[store_name], + ), + ), + ], + ), + ) + results["rag"] = rag_response.text or "" + + # 7. Clean up the file search store + await client.file_search_stores.delete( + name=store_name, + config=types.DeleteFileSearchStoreConfig(force=True), + ) + results["store_deleted"] = True + + # 8. interactions.create (gemini_interactions_create activity) + interaction = await client.interactions.create( + model="gemini-2.5-flash", + input=prompt, + ) + assert isinstance(interaction, Interaction) + results["interaction_id"] = interaction.id + + # 9. interactions.create streamed (gemini_interactions_create_streamed) + stream = await client.interactions.create( + model="gemini-2.5-flash", + input=prompt, + stream=True, + ) + assert not isinstance(stream, Interaction) + event_types: list[str] = [] + async with stream: + async for event in stream: + event_types.append(event.event_type) + results["interaction_events"] = event_types + + # 10. agents.create (gemini_agents_create activity) + agent = await client.agents.create( + id="test-agent", + system_instruction="Be helpful.", + ) + results["agent_id"] = agent.id + + return results + + +@workflow.defn +class FileUploadStrWorkflow: + """Workflow that uploads a file via str path.""" + + @workflow.run + async def run(self, file_path: str) -> str: + client = TemporalAsyncClient() + uploaded = await client.files.upload( + file=file_path, + config=types.UploadFileConfig( + display_name="Test File", + mime_type="text/plain", + ), + ) + return uploaded.name or "" + + +@workflow.defn +class FileUploadBytesWorkflow: + """Workflow that uploads a file via io.BytesIO.""" + + @workflow.run + async def run(self, data: bytes) -> str: + client = TemporalAsyncClient() + uploaded = await client.files.upload( + file=io.BytesIO(data), + config=types.UploadFileConfig( + display_name="Bytes File", + mime_type="text/plain", + ), + ) + return uploaded.name or "" + + +@workflow.defn +class FileDownloadWorkflow: + """Workflow that downloads a file by name.""" + + @workflow.run + async def run(self, file_name: str) -> bytes: + client = TemporalAsyncClient() + return await client.files.download(file=file_name) + + +@workflow.defn +class FileSearchStoreUploadWorkflow: + """Workflow that uploads to a file search store.""" + + @workflow.run + async def run(self, store_name: str, file_path: str) -> str: + client = TemporalAsyncClient() + op = await client.file_search_stores.upload_to_file_search_store( + file_search_store_name=store_name, + file=file_path, + config=types.UploadToFileSearchStoreConfig( + display_name="Test Doc", + mime_type="text/plain", + ), + ) + return op.name or "" + + +@workflow.defn +class RegisterFilesWorkflow: + """Workflow that calls files.register_files.""" + + @workflow.run + async def run(self, uris: list[str]) -> str: + client = TemporalAsyncClient() + # auth arg is ignored by TemporalAsyncFiles — the activity uses + # credentials from GoogleGenAIPlugin init. We pass a dummy here; + # can't import google.auth.credentials in the sandbox so we + # use a sentinel that satisfies the type at runtime. + resp = await client.files.register_files( + auth=None, # type: ignore[arg-type] + uris=uris, + ) + return str(len(resp.files or [])) + + +@workflow.defn +class ChatWorkflow: + """Workflow that uses client.chats for multi-turn conversation.""" + + @workflow.run + async def run(self, prompt: str) -> list[str]: + client = TemporalAsyncClient() + chat = client.chats.create( + model="gemini-2.5-flash", + ) + r1 = await chat.send_message(prompt) + r2 = await chat.send_message("Follow up question") + return [r1.text or "", r2.text or ""] + + +@workflow.defn +class InteractionCreateWorkflow: + """Workflow that creates an interaction (non-streaming).""" + + @workflow.run + async def run(self, prompt: str) -> dict[str, Any]: + client = TemporalAsyncClient() + interaction = await client.interactions.create( + model="gemini-2.5-flash", + input=prompt, + timeout=120, + ) + assert isinstance(interaction, Interaction) + return {"id": interaction.id, "status": str(interaction.status)} + + +@workflow.defn +class InteractionStreamWorkflow: + """Workflow that creates a streamed interaction and collects event types.""" + + @workflow.run + async def run(self, prompt: str) -> list[str]: + client = TemporalAsyncClient() + stream = await client.interactions.create( + model="gemini-2.5-flash", + input=prompt, + stream=True, + ) + assert not isinstance(stream, Interaction) + event_types: list[str] = [] + async with stream: + async for event in stream: + event_types.append(event.event_type) + return event_types + + +@workflow.defn +class InteractionLifecycleWorkflow: + """Workflow that gets, cancels, and deletes an interaction.""" + + @workflow.run + async def run(self, interaction_id: str) -> dict[str, Any]: + client = TemporalAsyncClient() + got = await client.interactions.get(interaction_id) + assert isinstance(got, Interaction) + cancelled = await client.interactions.cancel(interaction_id) + deleted = await client.interactions.delete(interaction_id) + return { + "got_id": got.id, + "cancel_status": str(cancelled.status), + "deleted": deleted, + } + + +@workflow.defn +class AgentsWorkflow: + """Workflow that exercises managed-agent CRUD.""" + + @workflow.run + async def run(self) -> dict[str, Any]: + client = TemporalAsyncClient() + agent = await client.agents.create( + id="test-agent", + system_instruction="Be helpful.", + ) + got = await client.agents.get("test-agent") + listing = await client.agents.list(page_size=10) + deleted = await client.agents.delete("test-agent") + return { + "created_id": agent.id, + "got_id": got.id, + "listed_ids": [a.id for a in (listing.agents or [])], + "next_page_token": listing.next_page_token, + # AgentDeleteResponse defines no fields; the API's JSON comes + # back as extras, so return the dict form. + "delete_response": deleted.model_dump(mode="json"), + } + + +@workflow.defn +class WebhooksUnsupportedWorkflow: + """Workflow that verifies client.webhooks raises a clear error.""" + + @workflow.run + async def run(self) -> str: + client = TemporalAsyncClient() + try: + _ = client.webhooks + except RuntimeError as e: + return str(e) + return "no error" + + +# =========================================================================== +# Integration tests — run workflows against a real Temporal test server +# =========================================================================== + + +async def test_simple_generate_content(client: Client): + """Basic generate_content returns text through a workflow.""" + new_client, _ = apply_plugin(client, [make_text_response("Hello from Gemini!")]) + + async with new_worker(new_client, SimpleGenerateWorkflow) as worker: + result = await new_client.execute_workflow( + SimpleGenerateWorkflow.run, + "Say hello", + id=f"gemini-simple-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert result == "Hello from Gemini!" + + +async def test_tool_call_single_arg(client: Client): + """Tool calling with a single-argument activity via AFC.""" + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("get_weather", {"city": "Tokyo"}), + make_text_response("The weather in Tokyo is sunny and 20C."), + ], + ) + + async with new_worker( + new_client, + SingleArgToolWorkflow, + activities=[tool_tracker.get_weather], + ) as worker: + result = await new_client.execute_workflow( + SingleArgToolWorkflow.run, + "What's the weather in Tokyo?", + id=f"gemini-tool-single-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert tool_tracker.calls == [("get_weather", {"city": "Tokyo"})] + assert result == "The weather in Tokyo is sunny and 20C." + + +async def test_tool_call_multi_arg(client: Client): + """Tool calling with a multi-argument activity.""" + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response( + "get_weather_country", {"city": "Paris", "country": "France"} + ), + make_text_response("Paris, France: Rainy, 15C."), + ], + ) + + async with new_worker( + new_client, + MultiArgToolWorkflow, + activities=[tool_tracker.get_weather_country], + ) as worker: + result = await new_client.execute_workflow( + MultiArgToolWorkflow.run, + "What's the weather in Paris, France?", + id=f"gemini-tool-multi-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert tool_tracker.calls == [ + ("get_weather_country", {"city": "Paris", "country": "France"}) + ] + assert result == "Paris, France: Rainy, 15C." + + +async def test_tool_failure_propagation(client: Client): + """Tool activity failure causes the workflow to fail.""" + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("get_weather_failure", {"city": "Nowhere"}), + ], + ) + + async with new_worker( + new_client, + ToolFailureWorkflow, + activities=[tool_tracker.get_weather_failure], + ) as worker: + with pytest.raises(WorkflowFailureError): + await new_client.execute_workflow( + ToolFailureWorkflow.run, + "Weather in Nowhere?", + id=f"gemini-tool-fail-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert tool_tracker.calls == [("get_weather_failure", {"city": "Nowhere"})] + + +async def test_multiple_tools_sequential(client: Client): + """Multiple tools called in sequence within one generate_content call.""" + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("get_weather", {"city": "Tokyo"}), + make_function_call_response( + "get_weather_country", {"city": "Paris", "country": "France"} + ), + make_text_response("Tokyo is sunny; Paris is rainy."), + ], + ) + + async with new_worker( + new_client, + MultipleToolsWorkflow, + activities=[ + tool_tracker.get_weather, + tool_tracker.get_weather_country, + ], + ) as worker: + result = await new_client.execute_workflow( + MultipleToolsWorkflow.run, + "Compare Tokyo and Paris weather", + id=f"gemini-multi-tools-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=15), + ) + + assert tool_tracker.calls == [ + ("get_weather", {"city": "Tokyo"}), + ("get_weather_country", {"city": "Paris", "country": "France"}), + ] + assert result == "Tokyo is sunny; Paris is rainy." + + +async def test_workflow_method_as_tool(client: Client): + """A plain workflow method (not an activity) used as a tool runs in-workflow.""" + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("lookup_city", {"city": "Berlin"}), + make_text_response("Berlin is wonderful."), + ], + ) + + async with new_worker(new_client, WorkflowMethodToolWorkflow) as worker: + handle = await new_client.start_workflow( + WorkflowMethodToolWorkflow.run, + "Tell me about Berlin", + id=f"gemini-wf-method-tool-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + result = await handle.result() + # Query must happen while worker is alive + tool_calls = await handle.query(WorkflowMethodToolWorkflow.get_tool_calls) + + assert tool_calls == [("lookup_city", {"city": "Berlin"})] + assert result == "Berlin is wonderful." + + +async def test_streamed_generate_content(client: Client): + """generate_content_stream collects batched chunks from the activity.""" + new_client, _ = apply_plugin( + client, [make_text_response("The quick brown fox jumps over the lazy dog")] + ) + + async with new_worker(new_client, StreamedGenerateWorkflow) as worker: + result = await new_client.execute_workflow( + StreamedGenerateWorkflow.run, + "Say something", + id=f"gemini-streamed-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + # The tracker splits the text into per-word chunks + assert len(result) == 9 + assert " ".join(result) == "The quick brown fox jumps over the lazy dog" + + +# =========================================================================== +# http_options propagation tests - per request overrides +# =========================================================================== + + +async def test_http_options_headers_propagate(client: Client): + """Custom headers passed via http_options arrive at the activity.""" + new_client, api_tracker = apply_plugin(client, [make_text_response("ok")]) + + async with new_worker(new_client, HttpOptionsWorkflow) as worker: + await new_client.execute_workflow( + HttpOptionsWorkflow.run, + args=["hi", {"headers": {"X-Custom": "test-value"}}], + id=f"gemini-http-headers-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 1 + opts = api_tracker.requests[0].http_options_overrides + assert opts is not None + assert opts.headers == {"X-Custom": "test-value"} + + +async def test_http_options_api_version_propagates(client: Client): + """api_version passed via http_options arrives at the activity.""" + new_client, api_tracker = apply_plugin(client, [make_text_response("ok")]) + + async with new_worker(new_client, HttpOptionsWorkflow) as worker: + await new_client.execute_workflow( + HttpOptionsWorkflow.run, + args=["hi", {"api_version": "v1"}], + id=f"gemini-http-version-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 1 + opts = api_tracker.requests[0].http_options_overrides + assert opts is not None + assert opts.api_version == "v1" + + +async def test_http_options_base_url_propagates(client: Client): + """base_url passed via http_options arrives at the activity.""" + new_client, api_tracker = apply_plugin(client, [make_text_response("ok")]) + + async with new_worker(new_client, HttpOptionsWorkflow) as worker: + await new_client.execute_workflow( + HttpOptionsWorkflow.run, + args=["hi", {"base_url": "https://custom.example.com"}], + id=f"gemini-http-base-url-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 1 + opts = api_tracker.requests[0].http_options_overrides + assert opts is not None + assert opts.base_url == "https://custom.example.com" + + +async def test_http_options_multiple_fields_propagate(client: Client): + """Multiple http_options fields propagate together to the activity.""" + new_client, api_tracker = apply_plugin(client, [make_text_response("ok")]) + + async with new_worker(new_client, HttpOptionsWorkflow) as worker: + await new_client.execute_workflow( + HttpOptionsWorkflow.run, + args=[ + "hi", + { + "api_version": "v1beta", + "headers": {"X-Foo": "bar"}, + "base_url": "https://other.example.com", + }, + ], + id=f"gemini-http-multi-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 1 + opts = api_tracker.requests[0].http_options_overrides + assert opts is not None + assert opts.api_version == "v1beta" + assert opts.headers == {"X-Foo": "bar"} + assert opts.base_url == "https://other.example.com" + + +async def test_no_http_options_passes_none(client: Client): + """When no per-request http_options are set, None reaches the activity.""" + new_client, api_tracker = apply_plugin(client, [make_text_response("ok")]) + + async with new_worker(new_client, SimpleGenerateWorkflow) as worker: + await new_client.execute_workflow( + SimpleGenerateWorkflow.run, + "hi", + id=f"gemini-http-none-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 1 + assert api_tracker.requests[0].http_options_overrides is None + + +# =========================================================================== +# File upload/download tests +# =========================================================================== + + +async def test_file_upload_str_path(client: Client): + """Upload a file via str path dispatches through the activity.""" + new_client, api_tracker = apply_plugin(client, []) + + async with new_worker(new_client, FileUploadStrWorkflow) as worker: + result = await new_client.execute_workflow( + FileUploadStrWorkflow.run, + "/tmp/test.txt", + id=f"gemini-file-upload-str-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.file_upload_requests) == 1 + req = api_tracker.file_upload_requests[0] + assert req.file_path == "/tmp/test.txt" + assert req.file_bytes is None + assert req.config is not None + assert req.config.display_name == "Test File" + assert result == "files/test-uploaded-file" + + +async def test_file_upload_bytes(client: Client): + """Upload a file via io.BytesIO sends bytes through the activity.""" + new_client, api_tracker = apply_plugin(client, []) + + async with new_worker(new_client, FileUploadBytesWorkflow) as worker: + result = await new_client.execute_workflow( + FileUploadBytesWorkflow.run, + b"hello world", + id=f"gemini-file-upload-bytes-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.file_upload_requests) == 1 + req = api_tracker.file_upload_requests[0] + assert req.file_bytes == b"hello world" + assert req.file_path is None + assert req.config is not None + assert req.config.display_name == "Bytes File" + assert result == "files/test-uploaded-file" + + +async def test_file_download(client: Client): + """Download a file dispatches through the activity and returns bytes.""" + new_client, api_tracker = apply_plugin(client, []) + + async with new_worker(new_client, FileDownloadWorkflow) as worker: + result = await new_client.execute_workflow( + FileDownloadWorkflow.run, + "files/some-file", + id=f"gemini-file-download-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.file_download_requests) == 1 + assert api_tracker.file_download_requests[0].file == "files/some-file" + assert result == b"fake file content" + + +# =========================================================================== +# File search store upload tests +# =========================================================================== + + +async def test_file_search_store_upload(client: Client): + """Upload to file search store dispatches through the activity.""" + new_client, api_tracker = apply_plugin(client, []) + + async with new_worker(new_client, FileSearchStoreUploadWorkflow) as worker: + result = await new_client.execute_workflow( + FileSearchStoreUploadWorkflow.run, + args=["fileSearchStores/my-store", "/tmp/doc.txt"], + id=f"gemini-fss-upload-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.file_search_store_upload_requests) == 1 + req = api_tracker.file_search_store_upload_requests[0] + assert req.file_search_store_name == "fileSearchStores/my-store" + assert req.file_path == "/tmp/doc.txt" + assert req.config is not None + assert req.config.display_name == "Test Doc" + assert result == "operations/test-op" + + +# =========================================================================== +# Multi-turn chat tests +# =========================================================================== + + +async def test_chat_multi_turn(client: Client): + """Multi-turn chat sends multiple requests through the activity.""" + new_client, api_tracker = apply_plugin( + client, + [ + make_text_response("First answer"), + make_text_response("Second answer"), + ], + ) + + async with new_worker(new_client, ChatWorkflow) as worker: + result = await new_client.execute_workflow( + ChatWorkflow.run, + "Hello", + id=f"gemini-chat-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert len(api_tracker.requests) == 2 + assert result == ["First answer", "Second answer"] + + +class _FakeAsyncStream: + """Minimal stand-in for the SDK's AsyncStream in mocked-client tests.""" + + def __init__(self, events: list[Any]) -> None: + self._events = events + + def __aiter__(self) -> Any: + return self._gen() + + async def _gen(self) -> Any: + for event in self._events: + yield event + + async def __aenter__(self) -> "_FakeAsyncStream": + return self + + async def __aexit__(self, *_args: Any) -> None: + pass + + +# =========================================================================== +# Full integration test — real activities, mocked client +# =========================================================================== + + +def _apply_plugin_with_mock_client(client: Client, mock_responses: list[str]) -> Client: + """Create a real GoogleGenAIPlugin with real activities but a mocked client. + + Unlike ``apply_plugin``, this does NOT replace the activities. The + real ``GeminiApiCaller.activities()`` are registered, exercising the + full activity code path. The underlying ``genai.Client`` HTTP layer + and high-level file methods are mocked so no network calls are made. + """ + gemini = GeminiClient(api_key="fake-test-key") + + call_state = {"index": 0} + + async def fake_async_request(*_args: Any, **_kwargs: Any) -> SdkHttpResponse: + idx = call_state["index"] + call_state["index"] += 1 + if idx >= len(mock_responses): + raise RuntimeError( + f"No more mock responses (called {idx + 1} times, " + f"have {len(mock_responses)})" + ) + return SdkHttpResponse( + headers={"content-type": "application/json"}, + body=mock_responses[idx], + ) + + async def fake_async_request_streamed(*_args: Any, **_kwargs: Any) -> Any: + idx = call_state["index"] + call_state["index"] += 1 + if idx >= len(mock_responses): + raise RuntimeError( + f"No more mock responses (called {idx + 1} times, " + f"have {len(mock_responses)})" + ) + + async def _gen(): + yield SdkHttpResponse( + headers={"content-type": "application/json"}, + body=mock_responses[idx], + ) + + return _gen() + + gemini._api_client.async_request = fake_async_request # type: ignore[assignment] + gemini._api_client.async_request_streamed = fake_async_request_streamed # type: ignore[assignment] + + # Mock file operations at the high-level SDK interface (these are what + # the real activities call). + gemini.aio.files.upload = AsyncMock( # type: ignore[method-assign] + return_value=types.File( + name="files/mock-uploaded", + uri="https://fake.uri/files/mock-uploaded", + size_bytes=42, + ) + ) + gemini.aio.files.download = AsyncMock(return_value=b"mock download content") # type: ignore[method-assign] + gemini.aio.file_search_stores.upload_to_file_search_store = AsyncMock( # type: ignore[method-assign] + return_value=types.UploadToFileSearchStoreOperation.model_construct( + name="operations/mock-op" + ) + ) + + # Interactions and agents go through the vendored nextgen client (not + # BaseApiClient); inject a mock instance so the real activities exercise + # their code path without network access. + interaction = _deserialize(make_interaction_dict(), Interaction) + sse_events = [ + _deserialize(e, InteractionSSEEvent) for e in make_interaction_sse_events() + ] + + async def _interactions_create(*_args: Any, **kwargs: Any) -> Any: + if kwargs.get("stream"): + return _FakeAsyncStream(sse_events) + return interaction + + mock_interactions = MagicMock() + mock_interactions.create = _interactions_create + mock_agents = MagicMock() + mock_agents.create = AsyncMock(return_value=_deserialize(make_agent_dict(), Agent)) + # The interactions/agents resources are cached lazily on the async client; + # set them so the activities' client.aio.interactions/.agents calls hit the + # mocks instead of the network. + gemini.aio._interactions = mock_interactions # type: ignore[assignment] + gemini.aio._agents = mock_agents # type: ignore[assignment] + + plugin = GoogleGenAIPlugin(gemini) + config = client.config() + config["plugins"] = [plugin] + return Client(**config) + + +async def test_full_integration_with_mock_client(client: Client): + """Run a workflow through real activities with a mocked genai.Client. + + This is the only test that exercises the actual activity implementations + in _gemini_activity.py. Every other test uses the GeminiApiCallTracker + which replaces the activities entirely. + """ + # Mock responses are consumed in order by the async_request and + # async_request_streamed mocks. Steps 3-5 (file upload, download, + # store upload) are mocked separately at the SDK level and don't + # consume from this list. + new_client = _apply_plugin_with_mock_client( + client, + [ + make_text_response("Real activity response"), # generate_content + make_text_response("Streamed via real activity"), # generate_content_stream + make_text_response("Grounded RAG answer"), # RAG query with file_search + make_text_response(""), # file_search_stores.delete + ], + ) + + async with new_worker(new_client, FullIntegrationWorkflow) as worker: + result = await new_client.execute_workflow( + FullIntegrationWorkflow.run, + "test prompt", + id=f"gemini-full-integration-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=15), + ) + + assert result["generate"] == "Real activity response" + assert len(result["stream_chunks"]) > 0 + assert "Streamed" in " ".join(result["stream_chunks"]) + assert result["upload_name"] == "files/mock-uploaded" + assert result["download"] == "mock download content" + assert result["fss_upload_op"] == "operations/mock-op" + assert result["rag"] == "Grounded RAG answer" + assert result["store_deleted"] is True + assert result["interaction_id"] == INTERACTION_ID + assert result["interaction_events"] == [ + "interaction.created", + "step.delta", + "step.delta", + "interaction.completed", + ] + assert result["agent_id"] == "test-agent" + + +async def test_register_files_without_credentials_fails(client: Client): + """register_files raises when no credentials are available.""" + # _apply_plugin_with_mock_client uses api_key auth with no + # extra_credentials, so the activity should raise ValueError. + new_client = _apply_plugin_with_mock_client(client, []) + + async with new_worker(new_client, RegisterFilesWorkflow) as worker: + with pytest.raises(WorkflowFailureError) as exc_info: + await new_client.execute_workflow( + RegisterFilesWorkflow.run, + ["gs://bucket/file.txt"], + id=f"gemini-register-no-creds-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + # The error is nested: WorkflowFailureError → ActivityError → ApplicationError + cause = exc_info.value.cause + while cause.__cause__ is not None: + cause = cause.__cause__ + assert "No credentials available for register_files" in str(cause) + + +# =========================================================================== +# TemporalAsyncClient wiring tests +# =========================================================================== + + +def test_temporal_async_client_has_temporal_files(): + """TemporalAsyncClient() returns a client with TemporalAsyncFiles.""" + client = TemporalAsyncClient() + assert isinstance(client, TemporalAsyncClient) + assert isinstance(client.files, TemporalAsyncFiles) + + +def test_temporal_async_client_has_temporal_file_search_stores(): + """TemporalAsyncClient() returns a client with TemporalAsyncFileSearchStores.""" + client = TemporalAsyncClient() + assert isinstance(client.file_search_stores, TemporalAsyncFileSearchStores) + + +# =========================================================================== +# Unit tests for _TemporalApiClient +# =========================================================================== + + +def test_sync_request_raises(): + """Synchronous request() raises RuntimeError.""" + api_client = _TemporalApiClient() + with pytest.raises(RuntimeError, match="Synchronous requests are not supported"): + api_client.request("GET", "/test", {}) + + +def test_sync_request_streamed_raises(): + """Synchronous request_streamed() raises RuntimeError.""" + api_client = _TemporalApiClient() + with pytest.raises(RuntimeError, match="Synchronous streaming is not supported"): + api_client.request_streamed("GET", "/test", {}) + + +def test_upload_file_raises(): + """Low-level upload_file() raises NotImplementedError.""" + api_client = _TemporalApiClient() + with pytest.raises(NotImplementedError, match="client.files.upload"): + api_client.upload_file() + + +def test_download_file_raises(): + """Low-level download_file() raises NotImplementedError.""" + api_client = _TemporalApiClient() + with pytest.raises(NotImplementedError, match="client.files.download"): + api_client.download_file() + + +# =========================================================================== +# Unit tests for activity_as_tool +# =========================================================================== + + +def test_activity_as_tool_bare_function_raises(): + """activity_as_tool rejects a function without @activity.defn.""" + + async def not_an_activity(x: str) -> str: + return x + + with pytest.raises(GoogleGenAIError, match="@activity.defn"): + activity_as_tool(not_an_activity) + + +def test_activity_as_tool_preserves_name(): + """Returned wrapper keeps the original function name.""" + wrapper = activity_as_tool(ToolCallTracker.get_weather) + assert wrapper.__name__ == "get_weather" + + +def test_activity_as_tool_preserves_doc(): + """Returned wrapper keeps the original docstring.""" + wrapper = activity_as_tool(ToolCallTracker.get_weather) + assert wrapper.__doc__ == "Get the weather for a given city." + + +def test_activity_as_tool_preserves_signature(): + """Returned wrapper has the correct parameter signature (self hidden).""" + wrapper = activity_as_tool(ToolCallTracker.get_weather) + sig = inspect.signature(wrapper) + params = list(sig.parameters.keys()) + assert params == ["city"] + + +def test_activity_as_tool_multi_arg_signature(): + """Multi-arg activity preserves all parameter names (self hidden).""" + wrapper = activity_as_tool(ToolCallTracker.get_weather_country) + sig = inspect.signature(wrapper) + params = list(sig.parameters.keys()) + assert params == ["city", "country"] + + +def test_activity_as_tool_is_async_callable(): + """Returned wrapper is an async callable.""" + wrapper = activity_as_tool(ToolCallTracker.get_weather) + assert inspect.iscoroutinefunction(wrapper) + + +# =========================================================================== +# Bound-method tool wrapping - shields workflow-method tools from google-genai's +# internal config deep-copy (>= 2.8.0), which would otherwise clone the workflow +# instance and drop in-workflow state mutations. Version-independent unit tests. +# =========================================================================== + + +class _StatefulTool: + def __init__(self) -> None: + self.calls: list[str] = [] + + async def lookup_city(self, city: str) -> str: + """Look up info about a city.""" + self.calls.append(city) + return f"{city} is great" + + +async def test_closure_if_bound_method_unbinds_and_mutates_original(): + """A bound method becomes a plain function that still mutates the real instance.""" + obj = _StatefulTool() + wrapped = _closure_if_bound_method(obj.lookup_city) + + # No longer a bound method (so deepcopy leaves it — and its captured self — + # intact), but name/doc/signature are preserved for AFC schema building. + assert not inspect.ismethod(wrapped) + assert wrapped.__name__ == "lookup_city" + assert wrapped.__doc__ == "Look up info about a city." + assert list(inspect.signature(wrapped).parameters) == ["city"] + + assert await wrapped("Berlin") == "Berlin is great" + assert obj.calls == ["Berlin"] + + +def test_closure_survives_deepcopy_bound_method_does_not(): + """The wrapper keeps its instance across a deep-copy; a raw bound method clones it.""" + import copy + + obj = _StatefulTool() + + # Raw bound method: deepcopy clones __self__ (the 2.8.0 failure mode). + assert copy.deepcopy(obj.lookup_city).__self__ is not obj + + # Closure: deepcopy is a no-op, so the captured instance is preserved. + wrapped = _closure_if_bound_method(obj.lookup_city) + assert copy.deepcopy(wrapped) is wrapped + + +def test_closure_if_bound_method_passes_through_non_methods(): + """Plain functions and activity_as_tool wrappers are left untouched.""" + + def plain(city: str) -> str: + return city + + assert _closure_if_bound_method(plain) is plain + activity_tool = activity_as_tool(ToolCallTracker.get_weather) + assert _closure_if_bound_method(activity_tool) is activity_tool + + +def test_wrap_bound_method_tools_config_forms(): + """Config tools are wrapped for both model and dict configs, without mutating the caller.""" + obj = _StatefulTool() + + # Model config: bound method wrapped, caller's config left as-is. + config = types.GenerateContentConfig(tools=[obj.lookup_city]) + wrapped = _wrap_bound_method_tools(config) + assert wrapped is not config + assert config.tools == [obj.lookup_city] # original untouched + assert not inspect.ismethod(wrapped.tools[0]) + + # Dict config: same, and the original dict/list are not mutated. + dict_config: dict[str, Any] = {"tools": [obj.lookup_city]} + wrapped_dict = _wrap_bound_method_tools(dict_config) + assert dict_config["tools"] == [obj.lookup_city] + assert not inspect.ismethod(wrapped_dict["tools"][0]) + + # No bound methods -> returned unchanged (no needless copy). + def plain(city: str) -> str: + return city + + plain_config = types.GenerateContentConfig(tools=[plain]) + assert _wrap_bound_method_tools(plain_config) is plain_config + assert _wrap_bound_method_tools(None) is None + + +# =========================================================================== +# Unit tests for TemporalAsyncClient +# =========================================================================== + + +def test_temporal_async_client_vertexai_config(): + """TemporalAsyncClient() forwards Vertex AI configuration to the _TemporalApiClient.""" + result = TemporalAsyncClient(vertexai=True, project="proj", location="us-central1") + assert result._api_client.vertexai is True + assert result._api_client.project == "proj" + assert result._api_client.location == "us-central1" + + +# =========================================================================== +# Unit tests for io.IOBase text-stream rejection +# =========================================================================== + + +async def test_file_upload_text_stream_raises(): + """TemporalAsyncFiles.upload rejects text streams with a clear TypeError.""" + files = TemporalAsyncFiles(_TemporalApiClient()) + with pytest.raises( + TypeError, match="file must be a binary stream when passing an io.IOBase" + ): + await files.upload(file=io.StringIO("text")) + + +async def test_file_search_store_upload_text_stream_raises(): + """TemporalAsyncFileSearchStores.upload_to_file_search_store rejects text streams.""" + stores = TemporalAsyncFileSearchStores(_TemporalApiClient()) + with pytest.raises( + TypeError, match="file must be a binary stream when passing an io.IOBase" + ): + await stores.upload_to_file_search_store( + file_search_store_name="fileSearchStores/x", + file=io.StringIO("text"), + ) + + +# =========================================================================== +# Interactions API tests +# =========================================================================== + + +async def test_interaction_create(client: Client): + """Non-streaming interactions.create returns a typed Interaction.""" + new_client, tracker = apply_plugin(client, []) + + async with new_worker(new_client, InteractionCreateWorkflow) as worker: + result = await new_client.execute_workflow( + InteractionCreateWorkflow.run, + "What's an interaction?", + id=f"gemini-interaction-create-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert result == {"id": INTERACTION_ID, "status": "completed"} + assert len(tracker.interaction_requests) == 1 + params = tracker.interaction_requests[0].params + assert params["model"] == "gemini-2.5-flash" + assert params["input"] == "What's an interaction?" + # stream selects the activity; timeout maps to start_to_close_timeout. + assert "stream" not in params + assert "timeout" not in params + + +async def test_interaction_create_stream(client: Client): + """Streamed interactions.create yields typed events in order.""" + new_client, tracker = apply_plugin(client, []) + + async with new_worker(new_client, InteractionStreamWorkflow) as worker: + result = await new_client.execute_workflow( + InteractionStreamWorkflow.run, + "Stream me", + id=f"gemini-interaction-stream-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert result == [ + "interaction.created", + "step.delta", + "step.delta", + "interaction.completed", + ] + assert len(tracker.interaction_requests) == 1 + assert "stream" not in tracker.interaction_requests[0].params + + +async def test_interaction_lifecycle(client: Client): + """interactions.get/cancel/delete forward the interaction id.""" + new_client, tracker = apply_plugin(client, []) + + async with new_worker(new_client, InteractionLifecycleWorkflow) as worker: + result = await new_client.execute_workflow( + InteractionLifecycleWorkflow.run, + "interactions/abc", + id=f"gemini-interaction-lifecycle-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert result["got_id"] == INTERACTION_ID + assert result["cancel_status"] == "cancelled" + assert result["deleted"] == {"deleted": True} + assert [r.id for r in tracker.interaction_id_requests] == ["interactions/abc"] * 3 + + +async def test_agents_crud(client: Client): + """agents.create/get/list/delete round-trip through activities.""" + new_client, tracker = apply_plugin(client, []) + + async with new_worker(new_client, AgentsWorkflow) as worker: + result = await new_client.execute_workflow( + AgentsWorkflow.run, + id=f"gemini-agents-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert result["created_id"] == "test-agent" + assert result["got_id"] == "test-agent" + assert result["listed_ids"] == ["test-agent"] + assert result["next_page_token"] == "next-tok" + assert result["delete_response"]["id"] == "test-agent" + # create + list went through the no-id request path + assert [r.params.get("page_size") for r in tracker.interaction_requests] == [ + None, + 10, + ] + + +async def test_webhooks_unsupported(client: Client): + """client.webhooks raises a clear error inside a workflow.""" + new_client, _ = apply_plugin(client, []) + + async with new_worker(new_client, WebhooksUnsupportedWorkflow) as worker: + result = await new_client.execute_workflow( + WebhooksUnsupportedWorkflow.run, + id=f"gemini-webhooks-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert "client.webhooks is not supported in Temporal workflows" in result + + +# =========================================================================== +# Unit tests for interactions helpers +# =========================================================================== + + +def test_pop_timeout_maps_to_activity_config(): + """A numeric timeout kwarg becomes the activity start_to_close_timeout.""" + from temporalio.contrib.google_genai._temporal_interactions import _pop_timeout + + config = ActivityConfig() + params: dict[str, Any] = {"model": "gemini-2.5-flash", "timeout": 120} + _pop_timeout(params, config) + assert "timeout" not in params + assert config.get("start_to_close_timeout") == timedelta(seconds=120) + + +def test_pop_timeout_rejects_non_numeric(): + """Non-numeric timeouts (e.g. httpx.Timeout) are rejected.""" + import httpx + + from temporalio.contrib.google_genai._temporal_interactions import _pop_timeout + + with pytest.raises(ValueError, match="timeout must be numeric seconds"): + _pop_timeout({"timeout": httpx.Timeout(5.0)}, ActivityConfig()) + + +# =========================================================================== +# Retry handling + error classification (Temporal owns retries) +# =========================================================================== + + +def test_plugin_rejects_client_retry_options(): + """A genai.Client with retry_options is rejected at plugin construction.""" + from google.genai.types import HttpOptions, HttpRetryOptions + + from temporalio.contrib.google_genai._google_genai_plugin import ( + _reject_sdk_retries, + ) + + client = GeminiClient( + api_key="fake-test-key", + http_options=HttpOptions(retry_options=HttpRetryOptions(attempts=3)), + ) + with pytest.raises(ValueError, match="retry_options"): + _reject_sdk_retries(client) + + +def test_plugin_allows_no_retry_options(): + """A default client (no retry_options) passes the retry check.""" + from temporalio.contrib.google_genai._google_genai_plugin import ( + _reject_sdk_retries, + ) + + _reject_sdk_retries(GeminiClient(api_key="fake-test-key")) + + +def test_process_http_options_rejects_retry_options(): + """Per-request http_options.retry_options raises in the workflow.""" + from google.genai.types import HttpOptions, HttpRetryOptions + + from temporalio.contrib.google_genai._temporal_api_client import _TemporalApiClient + + with pytest.raises(GoogleGenAIError, match="retry_options"): + _TemporalApiClient._process_http_options( + HttpOptions(retry_options=HttpRetryOptions(attempts=2)), + ActivityConfig(), + ) + + +def test_classify_api_error_retryable_vs_non_retryable(): + """Transient HTTP statuses stay retryable; client errors are non-retryable.""" + from google.genai import errors + + from temporalio.contrib.google_genai._gemini_activity import _classify_api_error + + client_err = errors.ClientError.__new__(errors.ClientError) + client_err.code = 400 + classified = _classify_api_error(client_err) + assert classified.non_retryable is True + assert classified.type == "ClientError" + + server_err = errors.ServerError.__new__(errors.ServerError) + server_err.code = 503 + assert _classify_api_error(server_err).non_retryable is False + + +def test_google_genai_error_is_application_error(): + """GoogleGenAIError is an ApplicationError so existing handling still works.""" + assert issubclass(GoogleGenAIError, ApplicationError) + + +# =========================================================================== +# Replay determinism + side-effect (activity scheduling) tests +# =========================================================================== + + +def _replay_plugin() -> GoogleGenAIPlugin: + """Build a real plugin instance for the Replayer. + + Replay never executes activities, so a fake-key client is sufficient. + What matters is that the Replayer uses the plugin's data converter, + sandbox passthrough, and workflow runner — the same configuration that + runs in production — so a history recorded by the plugin replays under + it without nondeterminism. + """ + return GoogleGenAIPlugin(GeminiClient(api_key="fake-test-key")) + + +async def test_replay_simple_generate(client: Client): + """A recorded simple generate_content history replays deterministically.""" + new_client, _ = apply_plugin(client, [make_text_response("Hello from Gemini!")]) + + async with new_worker(new_client, SimpleGenerateWorkflow) as worker: + handle = await new_client.start_workflow( + SimpleGenerateWorkflow.run, + "Say hello", + id=f"gemini-replay-simple-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + await handle.result() + history = await handle.fetch_history() + + await Replayer( + workflows=[SimpleGenerateWorkflow], + plugins=[_replay_plugin()], + ).replay_workflow(history) + + +async def test_replay_tool_loop(client: Client): + """The in-workflow AFC tool loop replays deterministically. + + The Gemini SDK's automatic-function-calling loop runs inside the + workflow, interleaving multiple activity calls with SDK-side request + formatting. That makes it the replay path most likely to surface + nondeterminism, so the recorded history is replayed under the real + plugin to prove the loop is replay-safe. + """ + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("get_weather", {"city": "Tokyo"}), + make_function_call_response( + "get_weather_country", {"city": "Paris", "country": "France"} + ), + make_text_response("Tokyo is sunny; Paris is rainy."), + ], + ) + + async with new_worker( + new_client, + MultipleToolsWorkflow, + activities=[tool_tracker.get_weather, tool_tracker.get_weather_country], + ) as worker: + handle = await new_client.start_workflow( + MultipleToolsWorkflow.run, + "Compare Tokyo and Paris weather", + id=f"gemini-replay-tools-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=15), + ) + await handle.result() + history = await handle.fetch_history() + + await Replayer( + workflows=[MultipleToolsWorkflow], + plugins=[_replay_plugin()], + ).replay_workflow(history) + + +async def test_side_effects_activity_scheduling(client: Client): + """Each Gemini API call and tool call schedules exactly one activity. + + Runs with ``max_cached_workflows=0`` so the workflow is evicted and + replayed from history between tasks — any nondeterminism in the + in-workflow AFC loop would fail the run — then asserts the exact number + of ``ActivityTaskScheduled`` events per activity type. The multi-tool + workflow issues three generate_content calls (initial + one per tool + result) and one activity per tool invocation. + """ + tool_tracker = ToolCallTracker() + new_client, _ = apply_plugin( + client, + [ + make_function_call_response("get_weather", {"city": "Tokyo"}), + make_function_call_response( + "get_weather_country", {"city": "Paris", "country": "France"} + ), + make_text_response("Tokyo is sunny; Paris is rainy."), + ], + ) + + async with new_worker( + new_client, + MultipleToolsWorkflow, + activities=[tool_tracker.get_weather, tool_tracker.get_weather_country], + max_cached_workflows=0, + ) as worker: + handle = await new_client.start_workflow( + MultipleToolsWorkflow.run, + "Compare Tokyo and Paris weather", + id=f"gemini-side-effects-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=15), + ) + await handle.result() + + scheduled: dict[str, int] = {} + async for e in handle.fetch_history_events(): + if e.HasField("activity_task_scheduled_event_attributes"): + name = e.activity_task_scheduled_event_attributes.activity_type.name + scheduled[name] = scheduled.get(name, 0) + 1 + + assert scheduled == { + "gemini_api_client_async_request": 3, + "get_weather": 1, + "get_weather_country": 1, + } diff --git a/tests/contrib/google_genai/test_gemini_mcp.py b/tests/contrib/google_genai/test_gemini_mcp.py new file mode 100644 index 000000000..3b32c28ca --- /dev/null +++ b/tests/contrib/google_genai/test_gemini_mcp.py @@ -0,0 +1,389 @@ +"""MCP integration tests for the Google Gemini SDK Temporal integration. + +Covers the client-side ``McpClientSession`` path (Gemini Developer API) routed +through ``TemporalMcpClientSession``: +- tool discovery + call through a real stdio MCP server on the worker +- worker-side connection pooling and idle eviction +- ``cache_tools`` listing frequency +- full parameter-schema propagation to the model (the MCP wire-format check) +- replay determinism and exact activity-scheduling counts + +Plus the server-side pass-through paths that need no shim code: +- Vertex AI ``Tool(mcp_servers=[McpServer(...)])`` config serialization +- Interactions API ``MCPServerToolCallStep`` / ``MCPServerToolResultStep`` rehydration +""" + +from __future__ import annotations + +import sys +from collections.abc import AsyncIterator +from contextlib import AbstractAsyncContextManager, asynccontextmanager +from datetime import timedelta +from pathlib import Path +from typing import Any +from uuid import uuid4 + +import pytest +from google.genai import types +from mcp import ClientSession, StdioServerParameters +from mcp.client.stdio import stdio_client + +from temporalio import workflow +from temporalio.client import Client +from temporalio.contrib.google_genai import ( + GoogleGenAIPlugin, + TemporalAsyncClient, + TemporalMcpClientSession, +) +from temporalio.contrib.google_genai._temporal_interactions import _deserialize +from temporalio.worker import Replayer +from temporalio.workflow import ActivityConfig +from tests.contrib.google_genai.test_gemini import ( + GeminiApiCallTracker, + make_function_call_response, + make_text_response, +) +from tests.helpers import new_worker + +_ECHO_SERVER = str(Path(__file__).parent / "echo_mcp_server.py") + + +@asynccontextmanager +async def _echo_session() -> AsyncIterator[ClientSession]: + """Yield a connected, initialized session to the stdio echo MCP server.""" + params = StdioServerParameters(command=sys.executable, args=[_ECHO_SERVER]) + async with stdio_client(params) as (read, write): + async with ClientSession(read, write) as session: + await session.initialize() + yield session + + +class _CountingFactory: + """Wraps the echo factory to count how often a connection is opened.""" + + def __init__(self) -> None: + self.opens = 0 + + def __call__(self) -> AbstractAsyncContextManager[ClientSession]: + self.opens += 1 + return _echo_session() + + +def _apply_mcp_plugin( + client: Client, + mock_responses: list[str], + mcp_servers: dict, + mcp_connection_idle_timeout: timedelta | None = None, +) -> tuple[Client, GeminiApiCallTracker]: + """Build a plugin whose API activities are faked but MCP activities are real. + + Monkeypatches ``GeminiApiCaller.activities`` (so canned generate_content + responses drive the AFC loop) while leaving the plugin's MCP activities — + built from ``mcp_servers`` — to hit the real stdio echo server. + """ + from temporalio.contrib.google_genai._gemini_activity import GeminiApiCaller + + tracker = GeminiApiCallTracker(mock_responses) + original = GeminiApiCaller.activities + GeminiApiCaller.activities = lambda self: [ # type: ignore[method-assign] + tracker.gemini_api_client_async_request, + tracker.gemini_api_client_async_request_streamed, + ] + try: + from google.genai import Client as GeminiClient + + plugin = GoogleGenAIPlugin( + GeminiClient(api_key="fake-test-key"), + mcp_servers=mcp_servers, + mcp_connection_idle_timeout=mcp_connection_idle_timeout, + ) + finally: + GeminiApiCaller.activities = original # type: ignore[method-assign] + + config = client.config() + config["plugins"] = [plugin] + return Client(**config), tracker + + +def _replay_plugin(mcp_servers: dict) -> GoogleGenAIPlugin: + from google.genai import Client as GeminiClient + + return GoogleGenAIPlugin( + GeminiClient(api_key="fake-test-key"), mcp_servers=mcp_servers + ) + + +async def _activity_names(handle: Any) -> list[str]: + names: list[str] = [] + async for e in handle.fetch_history_events(): + if e.HasField("activity_task_scheduled_event_attributes"): + names.append(e.activity_task_scheduled_event_attributes.activity_type.name) + return names + + +@pytest.fixture(autouse=True) +def _clear_mcp_connections(): # pyright: ignore[reportUnusedFunction] + """Isolate the module-global MCP connection pool between tests.""" + from temporalio.contrib.google_genai import _mcp + + _mcp._CONNECTIONS.clear() + yield + _mcp._CONNECTIONS.clear() + + +# --------------------------------------------------------------------------- +# Workflow +# --------------------------------------------------------------------------- + + +@workflow.defn +class McpToolWorkflow: + """generate_content grounded by an MCP tool, via the AFC loop. + + Takes the MCP server name as an argument so each test can use a distinct + name (the worker-side connection pool is keyed by name and shared across + activity invocations in the worker process). The number of tool calls is + driven entirely by the mocked model responses, not the workflow. + """ + + @workflow.run + async def run(self, server_name: str, prompt: str) -> str: + client = TemporalAsyncClient() + session = TemporalMcpClientSession( + server_name, + cache_tools=True, + activity_config=ActivityConfig( + start_to_close_timeout=timedelta(seconds=30) + ), + ) + response = await client.models.generate_content( + model="gemini-2.5-flash", + contents=prompt, + config=types.GenerateContentConfig(tools=[session]), + ) + return response.text or "" + + +# --------------------------------------------------------------------------- +# Client-side MCP tests +# --------------------------------------------------------------------------- + + +async def test_mcp_tool_discovery_and_call(client: Client): + """The AFC loop discovers + calls an MCP tool through activities.""" + server = "echo_basic" + new_client, _ = _apply_mcp_plugin( + client, + [ + make_function_call_response("echo", {"message": "hello"}), + make_text_response("Done!"), + ], + mcp_servers={server: _echo_session}, + ) + + async with new_worker(new_client, McpToolWorkflow) as worker: + handle = await new_client.start_workflow( + McpToolWorkflow.run, + args=[server, "echo hello"], + id=f"gemini-mcp-{uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=30), + ) + result = await handle.result() + names = await _activity_names(handle) + + assert result == "Done!" + assert names == [ + f"{server}-list-tools", + "gemini_api_client_async_request", + f"{server}-call-tool", + "gemini_api_client_async_request", + ] + + +async def test_mcp_connection_pooling(client: Client): + """Two tool calls in one workflow reuse a single worker-side connection.""" + server = "echo_pool" + factory = _CountingFactory() + new_client, _ = _apply_mcp_plugin( + client, + [ + make_function_call_response("echo", {"message": "one"}), + make_function_call_response("echo", {"message": "two"}), + make_text_response("Done!"), + ], + mcp_servers={server: factory}, + ) + + async with new_worker(new_client, McpToolWorkflow) as worker: + handle = await new_client.start_workflow( + McpToolWorkflow.run, + args=[server, "echo twice"], + id=f"gemini-mcp-pool-{uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=30), + ) + assert await handle.result() == "Done!" + names = await _activity_names(handle) + + # list-tools + two call-tools all served by one lazily-opened connection. + assert names.count(f"{server}-call-tool") == 2 + assert factory.opens == 1 + + +async def test_mcp_full_schema_propagation(client: Client): + """The model receives the MCP tool's full parameter schema, not just name.""" + server = "echo_schema" + new_client, tracker = _apply_mcp_plugin( + client, + [ + make_function_call_response("echo", {"message": "hi"}), + make_text_response("Done!"), + ], + mcp_servers={server: _echo_session}, + ) + + async with new_worker(new_client, McpToolWorkflow) as worker: + await new_client.execute_workflow( + McpToolWorkflow.run, + args=[server, "echo hi"], + id=f"gemini-mcp-schema-{uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=30), + ) + + # The first generate request carries the tool declarations the SDK built + # from the MCP list_tools result. + first = tracker.requests[0].request_dict + decls = first["tools"][0]["functionDeclarations"] # type: ignore[index] + echo_decl = next(d for d in decls if d["name"] == "echo") + assert "parameters" in echo_decl + assert "message" in echo_decl["parameters"]["properties"] + + +async def test_mcp_replay(client: Client): + """A recorded MCP tool-loop history replays deterministically.""" + server = "echo_replay" + new_client, _ = _apply_mcp_plugin( + client, + [ + make_function_call_response("echo", {"message": "hello"}), + make_text_response("Done!"), + ], + mcp_servers={server: _echo_session}, + ) + + async with new_worker(new_client, McpToolWorkflow) as worker: + handle = await new_client.start_workflow( + McpToolWorkflow.run, + args=[server, "echo hello"], + id=f"gemini-mcp-replay-{uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=30), + ) + await handle.result() + history = await handle.fetch_history() + + await Replayer( + workflows=[McpToolWorkflow], + plugins=[_replay_plugin({server: _echo_session})], + ).replay_workflow(history) + + +async def test_mcp_side_effects(client: Client): + """max_cached_workflows=0: exact ActivityTaskScheduled counts per type.""" + server = "echo_side" + new_client, _ = _apply_mcp_plugin( + client, + [ + make_function_call_response("echo", {"message": "hello"}), + make_text_response("Done!"), + ], + mcp_servers={server: _echo_session}, + ) + + async with new_worker( + new_client, McpToolWorkflow, max_cached_workflows=0 + ) as worker: + handle = await new_client.start_workflow( + McpToolWorkflow.run, + args=[server, "echo hello"], + id=f"gemini-mcp-side-effects-{uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=30), + ) + await handle.result() + names = await _activity_names(handle) + + scheduled: dict[str, int] = {} + for n in names: + scheduled[n] = scheduled.get(n, 0) + 1 + assert scheduled == { + f"{server}-list-tools": 1, + "gemini_api_client_async_request": 2, + f"{server}-call-tool": 1, + } + + +# --------------------------------------------------------------------------- +# Server-side pass-through tests (no shim code) +# --------------------------------------------------------------------------- + + +def test_vertex_mcp_server_config_serializes(): + """Vertex server-side MCP config round-trips as plain request data.""" + tool = types.Tool( + mcp_servers=[ + types.McpServer( + name="weather", + streamable_http_transport=types.StreamableHttpTransport( + url="https://example.com/mcp", + ), + ) + ] + ) + config = types.GenerateContentConfig(tools=[tool]) + dumped = config.model_dump(mode="json", exclude_none=True) + server = dumped["tools"][0]["mcp_servers"][0] + assert server["name"] == "weather" + assert server["streamable_http_transport"]["url"] == "https://example.com/mcp" + + +def test_interactions_mcp_steps_rehydrate(): + """Interactions API MCP step payloads rehydrate via _deserialize.""" + from google.genai.interactions import InteractionSSEEvent + + call_event: Any = _deserialize( + { + "event_type": "step.start", + "index": 0, + "step": { + "type": "mcp_server_tool_call", + "id": "call-1", + "name": "lookup", + "server_name": "weather", + "arguments": {"city": "Tokyo"}, + }, + }, + InteractionSSEEvent, + ) + assert call_event.step.type == "mcp_server_tool_call" + assert call_event.step.server_name == "weather" + assert call_event.step.arguments == {"city": "Tokyo"} + + result_event: Any = _deserialize( + { + "event_type": "step.start", + "index": 0, + "step": { + "type": "mcp_server_tool_result", + "call_id": "call-1", + "name": "lookup", + "server_name": "weather", + "result": "sunny", + }, + }, + InteractionSSEEvent, + ) + assert result_event.step.type == "mcp_server_tool_result" + assert result_event.step.call_id == "call-1" diff --git a/tests/contrib/google_genai/test_gemini_streaming.py b/tests/contrib/google_genai/test_gemini_streaming.py new file mode 100644 index 000000000..e7bee8747 --- /dev/null +++ b/tests/contrib/google_genai/test_gemini_streaming.py @@ -0,0 +1,122 @@ +"""Streaming tests for the Google Gemini SDK Temporal integration. + +Covers ``generate_content_stream`` publishing each chunk to a +:class:`~temporalio.contrib.workflow_streams.WorkflowStream` topic for external +consumers, and the fail-fast when ``streaming_topic`` is set without a hosted +``WorkflowStream``. +""" + +from __future__ import annotations + +import uuid +from datetime import timedelta + +import pytest +from google.genai import types + +from temporalio import workflow +from temporalio.client import Client, WorkflowFailureError +from temporalio.contrib.google_genai import TemporalAsyncClient +from temporalio.contrib.google_genai.testing import GeminiTestServer, text_response +from temporalio.contrib.workflow_streams import WorkflowStream, WorkflowStreamClient +from tests.helpers import new_worker + + +@workflow.defn +class StreamingWorkflowStreamWorkflow: + """Streams generate_content_stream chunks to a WorkflowStream topic. + + Holds the run open on a ``finish`` signal so an external subscriber can + reliably consume the published chunk before the workflow completes. + """ + + @workflow.init + def __init__(self, prompt: str) -> None: + self.stream = WorkflowStream() + self._done = False + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient(streaming_topic="gemini") + out: list[str] = [] + async for chunk in await client.models.generate_content_stream( + model="gemini-2.5-flash", + contents=prompt, + ): + out.append(chunk.text or "") + await workflow.wait_condition(lambda: self._done) + return "".join(out) + + @workflow.signal + def finish(self) -> None: + self._done = True + + +@workflow.defn +class StreamingNoStreamWorkflow: + """Sets streaming_topic but hosts no WorkflowStream — must fail fast.""" + + @workflow.run + async def run(self, prompt: str) -> str: + client = TemporalAsyncClient(streaming_topic="gemini") + async for _ in await client.models.generate_content_stream( + model="gemini-2.5-flash", + contents=prompt, + ): + pass + return "done" + + +async def test_streaming_publishes_to_workflow_stream(client: Client): + """Streamed chunks are published to the WorkflowStream for external consumers.""" + server = GeminiTestServer([text_response("Hello from Gemini stream")]) + config = client.config() + config["plugins"] = [server.plugin()] + new_client = Client(**config) + + async with new_worker(new_client, StreamingWorkflowStreamWorkflow) as worker: + wf_id = f"gemini-stream-{uuid.uuid4()}" + handle = await new_client.start_workflow( + StreamingWorkflowStreamWorkflow.run, + "say hi", + id=wf_id, + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=15), + ) + + stream = WorkflowStreamClient.create(new_client, wf_id) + received: list[types.GenerateContentResponse] = [] + async for item in stream.subscribe( + ["gemini"], + result_type=types.GenerateContentResponse, + poll_cooldown=timedelta(milliseconds=20), + ): + received.append(item.data) + break # one scripted chunk + + await handle.signal(StreamingWorkflowStreamWorkflow.finish) + result = await handle.result() + + assert result == "Hello from Gemini stream" + assert len(received) == 1 + assert received[0].text == "Hello from Gemini stream" + + +async def test_streaming_without_workflow_stream_raises(client: Client): + """streaming_topic set but no WorkflowStream hosted fails the workflow.""" + server = GeminiTestServer([text_response("unused")]) + config = client.config() + config["plugins"] = [server.plugin()] + new_client = Client(**config) + + async with new_worker(new_client, StreamingNoStreamWorkflow) as worker: + with pytest.raises(WorkflowFailureError) as exc_info: + await new_client.execute_workflow( + StreamingNoStreamWorkflow.run, + "hi", + id=f"gemini-stream-nostream-{uuid.uuid4()}", + task_queue=worker.task_queue, + execution_timeout=timedelta(seconds=10), + ) + + assert "WorkflowStream" in str(exc_info.value.cause) diff --git a/uv.lock b/uv.lock index a591392ad..0543cf0ed 100644 --- a/uv.lock +++ b/uv.lock @@ -9,10 +9,12 @@ resolution-markers = [ ] [options] -exclude-newer = "2026-06-17T16:16:53.404973Z" +exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values. exclude-newer-span = "P2W" [options.exclude-newer-package] +google-adk = false +google-genai = false openai-agents = false [[package]] @@ -237,21 +239,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/00/b7/e3bf5133d697a08128598c8d0abc5e16377b51465a33756de24fa7dee953/aiosqlite-0.22.1-py3-none-any.whl", hash = "sha256:21c002eb13823fad740196c5a2e9d8e62f6243bd9e7e4a1f87fb5e44ecb4fceb", size = 17405, upload-time = "2025-12-23T19:25:42.139Z" }, ] -[[package]] -name = "alembic" -version = "1.18.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mako" }, - { name = "sqlalchemy" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/94/13/8b084e0f2efb0275a1d534838844926f798bd766566b1375174e2448cd31/alembic-1.18.4.tar.gz", hash = "sha256:cb6e1fd84b6174ab8dbb2329f86d631ba9559dd78df550b57804d607672cedbc", size = 2056725, upload-time = "2026-02-10T16:00:47.195Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/29/6533c317b74f707ea28f8d633734dbda2119bbadfc61b2f3640ba835d0f7/alembic-1.18.4-py3-none-any.whl", hash = "sha256:a5ed4adcf6d8a4cb575f3d759f071b03cd6e5c7618eb796cb52497be25bfe19a", size = 263893, upload-time = "2026-02-10T16:00:49.997Z" }, -] - [[package]] name = "annotated-doc" version = "0.0.4" @@ -739,15 +726,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" }, ] -[[package]] -name = "cloudpickle" -version = "3.1.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, -] - [[package]] name = "colorama" version = "0.4.6" @@ -1285,47 +1263,26 @@ wheels = [ [[package]] name = "google-adk" -version = "1.35.0" +version = "2.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiosqlite" }, - { name = "anyio" }, { name = "authlib" }, { name = "click" }, { name = "fastapi" }, - { name = "google-api-python-client" }, { name = "google-auth", extra = ["pyopenssl"] }, - { name = "google-cloud-aiplatform", extra = ["agent-engines"] }, - { name = "google-cloud-bigquery" }, - { name = "google-cloud-bigquery-storage" }, - { name = "google-cloud-bigtable" }, - { name = "google-cloud-dataplex" }, - { name = "google-cloud-discoveryengine" }, - { name = "google-cloud-pubsub" }, - { name = "google-cloud-secret-manager" }, - { name = "google-cloud-spanner" }, - { name = "google-cloud-speech" }, - { name = "google-cloud-storage" }, { name = "google-genai" }, { name = "graphviz" }, { name = "httpx" }, { name = "jsonschema" }, - { name = "mcp" }, { name = "opentelemetry-api" }, - { name = "opentelemetry-exporter-gcp-logging" }, - { name = "opentelemetry-exporter-gcp-monitoring" }, - { name = "opentelemetry-exporter-gcp-trace" }, - { name = "opentelemetry-exporter-otlp-proto-http" }, - { name = "opentelemetry-resourcedetector-gcp" }, { name = "opentelemetry-sdk" }, - { name = "pyarrow" }, + { name = "packaging" }, { name = "pydantic" }, - { name = "python-dateutil" }, { name = "python-dotenv" }, + { name = "python-multipart" }, { name = "pyyaml" }, { name = "requests" }, - { name = "sqlalchemy" }, - { name = "sqlalchemy-spanner" }, { name = "starlette" }, { name = "tenacity" }, { name = "typing-extensions" }, @@ -1334,47 +1291,9 @@ dependencies = [ { name = "watchdog" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/3a/a7/8cba69e86af4f25b73f0bd4cbce9b0ca990a6a779cedee9a242264fca259/google_adk-1.35.0.tar.gz", hash = "sha256:c3f36447d29c1a3400ba45b344f232d857db9b18d1224517a00b267da1f51dff", size = 2432700, upload-time = "2026-06-10T05:32:34.778Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/65/3ff3f50b10dac3323ddecd694515e9f9ed345886e0eaf666d0e42c90748b/google_adk-2.2.0.tar.gz", hash = "sha256:04cb6318aba8829fe7c941ee1b456ccb4745253898c13595708c9eb07b4582ff", size = 3391545, upload-time = "2026-06-04T22:15:12.9Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2b/9a/dc5192a79bea70730c9261b8ca54ee4103265a260444d3bffdd2eab47876/google_adk-1.35.0-py3-none-any.whl", hash = "sha256:f4c10f86c37e4fba157868d6884d4493bbb88a53fea00004d900dc03a3347f85", size = 2877569, upload-time = "2026-06-10T05:32:37.085Z" }, -] - -[[package]] -name = "google-api-core" -version = "2.31.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-auth" }, - { name = "googleapis-common-protos" }, - { name = "proto-plus" }, - { name = "protobuf" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c6/22/155cadf1d49272a9cf48f3168c0f3874fa13397297e611a5ea00cd093880/google_api_core-2.31.0.tar.gz", hash = "sha256:2be84ee0f584c48e6bde1b36766e23348b361fb7e55e56135fc76ce1c397f9c2", size = 176492, upload-time = "2026-06-03T14:52:17.257Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/86/40/9bdbb60b03a332bd45acb8703da08bbc27d991d35286b62e42acc86d243a/google_api_core-2.31.0-py3-none-any.whl", hash = "sha256:ef79fb3784c71cbac89cbd03301ba0c8fb8ad2aa95d7f9204dd9628f7adf59ab", size = 173102, upload-time = "2026-06-03T14:51:26.729Z" }, -] - -[package.optional-dependencies] -grpc = [ - { name = "grpcio" }, - { name = "grpcio-status" }, -] - -[[package]] -name = "google-api-python-client" -version = "2.197.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core" }, - { name = "google-auth" }, - { name = "google-auth-httplib2" }, - { name = "httplib2" }, - { name = "uritemplate" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/22/09/081d66357118bd260f8f182cb1b2dd5bd32ca88e3714d7c93896cab946fc/google_api_python_client-2.197.0.tar.gz", hash = "sha256:32e03977eda4a66eafc6ae58dc9ec46426b6025636d5ef019c5703013eddd4e5", size = 14707398, upload-time = "2026-05-28T20:23:12.498Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a0/e5/e9cc221fd75230974d4ef45eb72d2261feca3c110d5554215d516bfe6534/google_api_python_client-2.197.0-py3-none-any.whl", hash = "sha256:0f8b89aa75768161dd4f5092d6bcb386c13236b32e0d9a938c02f71342094d14", size = 15287302, upload-time = "2026-05-28T20:23:09.683Z" }, + { url = "https://files.pythonhosted.org/packages/64/f5/44a3b20b17bac130497f2d1dde8b93c90cfc026983cd94f24488d540ea70/google_adk-2.2.0-py3-none-any.whl", hash = "sha256:ebdf3d931dc2b9c5b30d995358fc2ae99d59594c48a4aaf7496869ccd2c5f245", size = 3912613, upload-time = "2026-06-04T22:15:15.411Z" }, ] [[package]] @@ -1398,407 +1317,9 @@ requests = [ { name = "requests" }, ] -[[package]] -name = "google-auth-httplib2" -version = "0.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-auth" }, - { name = "httplib2" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1c/b3/f192c8bc7e41e0ebdbd95afcae4783417a34b6a6af62d22daf22c3fd38fc/google_auth_httplib2-0.4.0.tar.gz", hash = "sha256:d5b030a204b7a4b4d553ba9ca701b62481ee2b74419325580be70f7d85ffed35", size = 11161, upload-time = "2026-05-07T08:03:46.878Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/97/be/954c35a62b9e31de66b0a43c225c9b6bb9e0f98d6b1dc110a2308e3644f5/google_auth_httplib2-0.4.0-py3-none-any.whl", hash = "sha256:8e55cfafa3358cba85f6cad4a886138e88e158d71e7e5c9ee5936a5c1507fb91", size = 9529, upload-time = "2026-05-07T08:02:12.375Z" }, -] - -[[package]] -name = "google-cloud-aiplatform" -version = "1.157.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "docstring-parser" }, - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "google-cloud-bigquery" }, - { name = "google-cloud-resource-manager" }, - { name = "google-cloud-storage" }, - { name = "google-genai" }, - { name = "packaging" }, - { name = "proto-plus" }, - { name = "protobuf" }, - { name = "pydantic" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/e0/d9/e2a5f5a8535bbc8f68729796f3fc2d68d59a72818fb44f6544edbc2592e4/google_cloud_aiplatform-1.157.0.tar.gz", hash = "sha256:ce8413ed3584c4896f7656b663214c24e91c2c89426f1c91fbd1d220ffda23af", size = 11064992, upload-time = "2026-06-10T00:19:33.643Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e3/82/3ec2ba56dc1fa71ef783348a0c519721879dbc8f1e568534e6d4b4856ccd/google_cloud_aiplatform-1.157.0-py2.py3-none-any.whl", hash = "sha256:0ca499ac5648988916fc089f9e94bd99667eefba13f6936475247f4a0bf86634", size = 9200777, upload-time = "2026-06-10T00:19:30.181Z" }, -] - -[package.optional-dependencies] -agent-engines = [ - { name = "aiohttp" }, - { name = "cloudpickle" }, - { name = "google-cloud-iam" }, - { name = "google-cloud-logging" }, - { name = "google-cloud-trace" }, - { name = "opentelemetry-exporter-gcp-logging" }, - { name = "opentelemetry-exporter-gcp-trace" }, - { name = "opentelemetry-exporter-otlp-proto-http" }, - { name = "opentelemetry-sdk" }, - { name = "packaging" }, - { name = "pydantic" }, - { name = "typing-extensions" }, -] - -[[package]] -name = "google-cloud-appengine-logging" -version = "1.10.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7f/b9/fcafc8d2dc68975a65cdff74807547cff9b2a7b00e738d3f5ff0bd112867/google_cloud_appengine_logging-1.10.0.tar.gz", hash = "sha256:b5563e76010a36e6adf1cc489620c29ee4fb3b986b006d237e9a061eb0f0abb7", size = 17744, upload-time = "2026-06-03T14:52:40.298Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a5/b3/4eeb9f59c4e7e07e1f08704b6508249eea5760878810014e636026300416/google_cloud_appengine_logging-1.10.0-py3-none-any.whl", hash = "sha256:193675caaf062c41688a3e2c744b73614db82408bc7fb060353b6878d7134492", size = 18143, upload-time = "2026-06-03T14:51:55.174Z" }, -] - -[[package]] -name = "google-cloud-audit-log" -version = "0.6.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "googleapis-common-protos" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/01/46/b971191224557091cc865b47d527e61da180e33b9397904bdefdae1dcacd/google_cloud_audit_log-0.6.0.tar.gz", hash = "sha256:4dd343683c0bb31187ebef3426803f13159e950fbea3fe60a864855cfed959b8", size = 44674, upload-time = "2026-06-03T14:52:48.095Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bc/99/27c70286bfa3503e43f845578ed5c2ab30c0cc68e525c168286f05f9a51c/google_cloud_audit_log-0.6.0-py3-none-any.whl", hash = "sha256:8c5ecbc341ad3b3daf776981f6d7fd7ab5ff5a29c5dce3172c669b570e0f6717", size = 44853, upload-time = "2026-06-03T14:52:03.775Z" }, -] - -[[package]] -name = "google-cloud-bigquery" -version = "3.41.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "google-cloud-core" }, - { name = "google-resumable-media" }, - { name = "packaging" }, - { name = "python-dateutil" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ce/13/6515c7aab55a4a0cf708ffd309fb9af5bab54c13e32dc22c5acd6497193c/google_cloud_bigquery-3.41.0.tar.gz", hash = "sha256:2217e488b47ed576360c9b2cc07d59d883a54b83167c0ef37f915c26b01a06fe", size = 513434, upload-time = "2026-03-30T22:50:55.347Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/40/33/1d3902efadef9194566d499d61507e1f038454e0b55499d2d7f8ab2a4fee/google_cloud_bigquery-3.41.0-py3-none-any.whl", hash = "sha256:2a5b5a737b401cbd824a6e5eac7554100b878668d908e6548836b5d8aaa4dcaa", size = 262343, upload-time = "2026-03-30T22:48:45.444Z" }, -] - -[[package]] -name = "google-cloud-bigquery-storage" -version = "2.39.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1b/85/c998751fb4182b84872df7eafcdd2f68e325c791102b65d416975c020020/google_cloud_bigquery_storage-2.39.0.tar.gz", hash = "sha256:d5afd90ad06cf24d9167316cca70ab5b344e880fc13031d7392aa78ee76b8bb6", size = 309852, upload-time = "2026-06-03T15:13:01.874Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/eb/f6/4157466c10181907d07786fb41df5d0a9ff339c1770b9e2a15cfe483e845/google_cloud_bigquery_storage-2.39.0-py3-none-any.whl", hash = "sha256:8c192b6263804f7bdd6f57a17e763ba7f03fa4e53d7ecafca0187e0fd6467d48", size = 305958, upload-time = "2026-06-03T15:12:15.889Z" }, -] - -[[package]] -name = "google-cloud-bigtable" -version = "2.38.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "google-cloud-core" }, - { name = "google-crc32c" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f7/2c/a62b2108459518914d75b8455dd69bac838d6bf276fe902320f5f16cf9cb/google_cloud_bigtable-2.38.0.tar.gz", hash = "sha256:0ad24f0106c2eb0f38e278b1641052e65882a4da0141d1f9ad78ea691724aaa3", size = 800955, upload-time = "2026-05-07T19:32:53.737Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/46/9d/9c0a81aa9cf6c058b02d3be194d70bcd7e4bd82f631c8110560c3908dbc4/google_cloud_bigtable-2.38.0-py3-none-any.whl", hash = "sha256:9f6a4bdbefb34d0420f41c574d9805d8a63d080d10be5a176205e3b322c122a1", size = 556168, upload-time = "2026-05-07T19:32:51.48Z" }, -] - -[[package]] -name = "google-cloud-core" -version = "2.6.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core" }, - { name = "google-auth" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a8/dd/1eef226e470369b26824a505c34482c0b493bc35fe8e0c6b003b5feca21a/google_cloud_core-2.6.0.tar.gz", hash = "sha256:e76149739f90fac1fc6757c09f47eaccb3145b54adbd7759b0f7c4b235f46c83", size = 36001, upload-time = "2026-05-07T08:04:04.124Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/84/4a/98da8930ab109c73d9a5d13782a9ebb81ea8c111f6d534a567b71d23e52b/google_cloud_core-2.6.0-py3-none-any.whl", hash = "sha256:6d63ac8e5eca6d9e4319d0a1e2265fadcd7f1049904378caecfa01cf52dd869e", size = 29390, upload-time = "2026-05-07T08:02:34.672Z" }, -] - -[[package]] -name = "google-cloud-dataplex" -version = "2.20.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/96/41/695b333dad5c3bda1df09c0744b574d14ed1cc5f8d933863723d95476ea5/google_cloud_dataplex-2.20.0.tar.gz", hash = "sha256:cbdc55ec184a58c6d444f6d37fcc9070664a345a8e110f34dd7233ed37f92047", size = 894255, upload-time = "2026-06-03T15:28:01.155Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ba/9f/ca0ca400de2a1a1dbf264a5c7b1c67deb17ddf0e941598a90da759c97751/google_cloud_dataplex-2.20.0-py3-none-any.whl", hash = "sha256:920bbc466eea3ce0168f9fefc4a16fd33e6ddb70537588666ce8e6609f1e1553", size = 691436, upload-time = "2026-06-03T15:27:10.355Z" }, -] - -[[package]] -name = "google-cloud-discoveryengine" -version = "0.13.12" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/8f/cd/b33bbc4b096d937abee5ebfad3908b2bdc65acd1582191aa33beaa2b70a5/google_cloud_discoveryengine-0.13.12.tar.gz", hash = "sha256:d6b9f8fadd8ad0d2f4438231c5eb7772a317e9f59cafbcbadc19b5d54c609419", size = 3582382, upload-time = "2025-09-22T16:51:14.052Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/93/70/607f6011648f603d35e60a16c34aee68a0b39510e4268d4859f3268684f9/google_cloud_discoveryengine-0.13.12-py3-none-any.whl", hash = "sha256:295f8c6df3fb26b90fb82c2cd6fbcf4b477661addcb19a94eea16463a5c4e041", size = 3337248, upload-time = "2025-09-22T16:50:57.375Z" }, -] - -[[package]] -name = "google-cloud-iam" -version = "2.23.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0d/5f/128a1462354e0f8f0b7baff34b5a1a4e5cd7aee100d8db0eb39843b43d1d/google_cloud_iam-2.23.0.tar.gz", hash = "sha256:49246f6221026d381cff4f8d804daf1bb6416153f2504bf5ef54d4af2450b828", size = 561685, upload-time = "2026-05-07T08:04:16.253Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3f/ee/470f0c337a235b12c6a880df25809b8b11b33986510d66450cb5ef540a83/google_cloud_iam-2.23.0-py3-none-any.whl", hash = "sha256:a123ac45080a5c1735218a6b3db4c6e6ea12a1cdc86feec1c30ad1ede6c91fc6", size = 515952, upload-time = "2026-05-07T08:02:48.144Z" }, -] - -[[package]] -name = "google-cloud-logging" -version = "3.16.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "google-cloud-appengine-logging" }, - { name = "google-cloud-audit-log" }, - { name = "google-cloud-core" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "opentelemetry-api" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9b/ba/e749846f13c8d1c6c01eb6317e8b09abc130fe67b5d72081a48d1bf96971/google_cloud_logging-3.16.0.tar.gz", hash = "sha256:08a3076b8f0f724219d6f73b2a242ef69d51e8bce226133aebe41a25f23f5400", size = 293703, upload-time = "2026-06-03T15:28:23.862Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fb/d5/91035dd77e0033dfb00d52b2bcad1e4f7408eb931981f86a1584301670a8/google_cloud_logging-3.16.0-py3-none-any.whl", hash = "sha256:9e5bfbdfe7b5315ece00e1703a2ea25fe42ca35e0b4750127b019f50d069b01b", size = 234188, upload-time = "2026-06-03T15:27:37.407Z" }, -] - -[[package]] -name = "google-cloud-monitoring" -version = "2.31.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/84/9d/9522e169db3887e7f354bb9aa544a6e26c435ce19337e32432598db18c6f/google_cloud_monitoring-2.31.0.tar.gz", hash = "sha256:b4c9d3528c8643d4eb4b9d688cbb3c5914bc5f69b314ff7c5e1b47bdc073a9ae", size = 404747, upload-time = "2026-06-03T15:28:24.938Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/55/30/aa6635296da9c1c14d2e64f64e1cacd4f4debf8ab7e646c0559545f0f70d/google_cloud_monitoring-2.31.0-py3-none-any.whl", hash = "sha256:64f3d56ead48f0a0674f650cb2828c47b936582a02a27c55f2836681a86281c3", size = 391010, upload-time = "2026-06-03T15:27:39.536Z" }, -] - -[[package]] -name = "google-cloud-pubsub" -version = "2.39.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "grpcio-status" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-sdk" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/11/2b/4bf2c17e319ff65340389565b0e1b4d72696d87802b2f5f94390fbefa73c/google_cloud_pubsub-2.39.0.tar.gz", hash = "sha256:eed65e25f57f95bf3e02d96d7ee171688b23922471f9f21b5a91ed90e1282c0f", size = 402096, upload-time = "2026-06-03T15:28:26.396Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/93/20/dd0b27d4ad4577c062e77ff968ca3e2d404186cd78c8a2a53a0ef5fe5389/google_cloud_pubsub-2.39.0-py3-none-any.whl", hash = "sha256:7210d691a46d7a66559696899ebe6eb731e63de29b624964b3be4dd2d12d3e19", size = 324665, upload-time = "2026-06-03T15:27:41.119Z" }, -] - -[[package]] -name = "google-cloud-resource-manager" -version = "1.17.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b2/1a/13060cabf553d52d151d2afc26b39561e82853380d499dd525a0d422d9f0/google_cloud_resource_manager-1.17.0.tar.gz", hash = "sha256:0f486b62e2c58ff992a3a50fa0f4a96eef7750aa6c971bb373398ccb91828660", size = 464971, upload-time = "2026-03-26T22:17:29.204Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3d/f7/661d7a9023e877a226b5683429c3662f75a29ef45cb1464cf39adb689218/google_cloud_resource_manager-1.17.0-py3-none-any.whl", hash = "sha256:e479baf4b014a57f298e01b8279e3290b032e3476d69c8e5e1427af8f82739a5", size = 404403, upload-time = "2026-03-26T22:15:26.57Z" }, -] - -[[package]] -name = "google-cloud-secret-manager" -version = "2.29.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpc-google-iam-v1" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/d2/7c/5c88cdde9664f6c75fb68aa11e0af4309a92bef38dd38df0456ffb0f469b/google_cloud_secret_manager-2.29.0.tar.gz", hash = "sha256:ee64133af8fdb3780affb65ec6ccf10ab15a0113d8edeba388665f4be87ce1be", size = 278437, upload-time = "2026-06-03T16:13:43.149Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b6/c2/fc3275bc42a522757cb5141d7dae51f048b93d2f5fe4574fcee5392cef03/google_cloud_secret_manager-2.29.0-py3-none-any.whl", hash = "sha256:21bac2d0adb0bb3c13c346d7223832f197c2266534528a1bf1402774e06395a3", size = 225042, upload-time = "2026-06-03T16:12:20.162Z" }, -] - -[[package]] -name = "google-cloud-spanner" -version = "3.68.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "google-cloud-core" }, - { name = "google-cloud-monitoring" }, - { name = "grpc-google-iam-v1" }, - { name = "grpc-interceptor" }, - { name = "grpcio" }, - { name = "mmh3" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-resourcedetector-gcp" }, - { name = "opentelemetry-sdk" }, - { name = "opentelemetry-semantic-conventions" }, - { name = "proto-plus" }, - { name = "protobuf" }, - { name = "sqlparse" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a4/2d/b857929745f57bb5b90f44970c02fdfbfb1184505ce4aa6e6c32550afb5f/google_cloud_spanner-3.68.0.tar.gz", hash = "sha256:90c55751cfc35bd58554c5715eab8be544095e21e40a805eb4d0c61a2bf07091", size = 904630, upload-time = "2026-06-12T18:03:27.665Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/df/f4/02ff12ebd23bb5af763b2b165deffe0dc78f933921903eb394a6ce4e0ed3/google_cloud_spanner-3.68.0-py3-none-any.whl", hash = "sha256:ad4aaf15e718fe0c54effbf510e1d9c7259f1252194c7192107848b06d8d2af8", size = 620018, upload-time = "2026-06-12T18:03:10.159Z" }, -] - -[[package]] -name = "google-cloud-speech" -version = "2.40.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5a/c1/5dc9795314f4aefea0b01b02e9f5486a198341ecc15fe47f89a61c68df63/google_cloud_speech-2.40.0.tar.gz", hash = "sha256:e89e688e4ce0b926754038bf992d0d0f065c5f1c3503bb20e6c46d08b63658fc", size = 404366, upload-time = "2026-06-03T16:13:59.506Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/78/afeca8d597fab54bdd823f857aad15d6f9c4628ff3cb72aa237d01700721/google_cloud_speech-2.40.0-py3-none-any.whl", hash = "sha256:7cc0302b3b9ca33d2eae9669da94a44316601a240942895362ac70e765b9f39c", size = 345427, upload-time = "2026-06-03T16:12:40.909Z" }, -] - -[[package]] -name = "google-cloud-storage" -version = "3.12.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core" }, - { name = "google-auth" }, - { name = "google-cloud-core" }, - { name = "google-crc32c" }, - { name = "google-resumable-media" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/58/72/86f94e1639a8bcd9d33e8e01b49afcaa1c3a13bda7683c681717e0901e15/google_cloud_storage-3.12.0.tar.gz", hash = "sha256:03ae9847c6babb368f35f054126b8a08cbc0e3266efb990eb17b9926a45cf3be", size = 17338620, upload-time = "2026-06-12T18:03:29.215Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1b/bd/a89eaebd2f9db5f92ddcc8e4f23c266be1dbd11058bb83451d8dd029f34c/google_cloud_storage-3.12.0-py3-none-any.whl", hash = "sha256:3880773754ddf7c27567b04e2a4d193950b6b99429f37b9097d873686e95b09c", size = 340605, upload-time = "2026-06-12T18:03:12.677Z" }, -] - -[[package]] -name = "google-cloud-trace" -version = "1.19.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-api-core", extra = ["grpc"] }, - { name = "google-auth" }, - { name = "grpcio" }, - { name = "proto-plus" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/89/7b/c2a5848c4722373c92b500b65e6308ad89ca0c7c01054e0d948c58c107f2/google_cloud_trace-1.19.0.tar.gz", hash = "sha256:58293c6efcee6c74bb854ff01b008823bef66845c14f15ffa5209d545098a65d", size = 103875, upload-time = "2026-03-26T22:18:18.123Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a4/91/0090acafa7d2caf1bf0d7222d42935e118164a539f9f9a00a814afa63fa1/google_cloud_trace-1.19.0-py3-none-any.whl", hash = "sha256:59604c4c775c40af31b367df6bada0af34518cc35ac8cfedecd43898a120c51d", size = 108454, upload-time = "2026-03-26T22:14:32.631Z" }, -] - -[[package]] -name = "google-crc32c" -version = "1.8.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/03/41/4b9c02f99e4c5fb477122cd5437403b552873f014616ac1d19ac8221a58d/google_crc32c-1.8.0.tar.gz", hash = "sha256:a428e25fb7691024de47fecfbff7ff957214da51eddded0da0ae0e0f03a2cf79", size = 14192, upload-time = "2025-12-16T00:35:25.142Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/95/ac/6f7bc93886a823ab545948c2dd48143027b2355ad1944c7cf852b338dc91/google_crc32c-1.8.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:0470b8c3d73b5f4e3300165498e4cf25221c7eb37f1159e221d1825b6df8a7ff", size = 31296, upload-time = "2025-12-16T00:19:07.261Z" }, - { url = "https://files.pythonhosted.org/packages/f7/97/a5accde175dee985311d949cfcb1249dcbb290f5ec83c994ea733311948f/google_crc32c-1.8.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:119fcd90c57c89f30040b47c211acee231b25a45d225e3225294386f5d258288", size = 30870, upload-time = "2025-12-16T00:29:17.669Z" }, - { url = "https://files.pythonhosted.org/packages/3d/63/bec827e70b7a0d4094e7476f863c0dbd6b5f0f1f91d9c9b32b76dcdfeb4e/google_crc32c-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6f35aaffc8ccd81ba3162443fabb920e65b1f20ab1952a31b13173a67811467d", size = 33214, upload-time = "2025-12-16T00:40:19.618Z" }, - { url = "https://files.pythonhosted.org/packages/63/bc/11b70614df04c289128d782efc084b9035ef8466b3d0a8757c1b6f5cf7ac/google_crc32c-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:864abafe7d6e2c4c66395c1eb0fe12dc891879769b52a3d56499612ca93b6092", size = 33589, upload-time = "2025-12-16T00:40:20.7Z" }, - { url = "https://files.pythonhosted.org/packages/3e/00/a08a4bc24f1261cc5b0f47312d8aebfbe4b53c2e6307f1b595605eed246b/google_crc32c-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:db3fe8eaf0612fc8b20fa21a5f25bd785bc3cd5be69f8f3412b0ac2ffd49e733", size = 34437, upload-time = "2025-12-16T00:35:19.437Z" }, - { url = "https://files.pythonhosted.org/packages/5d/ef/21ccfaab3d5078d41efe8612e0ed0bfc9ce22475de074162a91a25f7980d/google_crc32c-1.8.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:014a7e68d623e9a4222d663931febc3033c5c7c9730785727de2a81f87d5bab8", size = 31298, upload-time = "2025-12-16T00:20:32.241Z" }, - { url = "https://files.pythonhosted.org/packages/c5/b8/f8413d3f4b676136e965e764ceedec904fe38ae8de0cdc52a12d8eb1096e/google_crc32c-1.8.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:86cfc00fe45a0ac7359e5214a1704e51a99e757d0272554874f419f79838c5f7", size = 30872, upload-time = "2025-12-16T00:33:58.785Z" }, - { url = "https://files.pythonhosted.org/packages/f6/fd/33aa4ec62b290477181c55bb1c9302c9698c58c0ce9a6ab4874abc8b0d60/google_crc32c-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:19b40d637a54cb71e0829179f6cb41835f0fbd9e8eb60552152a8b52c36cbe15", size = 33243, upload-time = "2025-12-16T00:40:21.46Z" }, - { url = "https://files.pythonhosted.org/packages/71/03/4820b3bd99c9653d1a5210cb32f9ba4da9681619b4d35b6a052432df4773/google_crc32c-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:17446feb05abddc187e5441a45971b8394ea4c1b6efd88ab0af393fd9e0a156a", size = 33608, upload-time = "2025-12-16T00:40:22.204Z" }, - { url = "https://files.pythonhosted.org/packages/7c/43/acf61476a11437bf9733fb2f70599b1ced11ec7ed9ea760fdd9a77d0c619/google_crc32c-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:71734788a88f551fbd6a97be9668a0020698e07b2bf5b3aa26a36c10cdfb27b2", size = 34439, upload-time = "2025-12-16T00:35:20.458Z" }, - { url = "https://files.pythonhosted.org/packages/e9/5f/7307325b1198b59324c0fa9807cafb551afb65e831699f2ce211ad5c8240/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:4b8286b659c1335172e39563ab0a768b8015e88e08329fa5321f774275fc3113", size = 31300, upload-time = "2025-12-16T00:21:56.723Z" }, - { url = "https://files.pythonhosted.org/packages/21/8e/58c0d5d86e2220e6a37befe7e6a94dd2f6006044b1a33edf1ff6d9f7e319/google_crc32c-1.8.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:2a3dc3318507de089c5384cc74d54318401410f82aa65b2d9cdde9d297aca7cb", size = 30867, upload-time = "2025-12-16T00:38:31.302Z" }, - { url = "https://files.pythonhosted.org/packages/ce/a9/a780cc66f86335a6019f557a8aaca8fbb970728f0efd2430d15ff1beae0e/google_crc32c-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:14f87e04d613dfa218d6135e81b78272c3b904e2a7053b841481b38a7d901411", size = 33364, upload-time = "2025-12-16T00:40:22.96Z" }, - { url = "https://files.pythonhosted.org/packages/21/3f/3457ea803db0198c9aaca2dd373750972ce28a26f00544b6b85088811939/google_crc32c-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb5c869c2923d56cb0c8e6bcdd73c009c36ae39b652dbe46a05eb4ef0ad01454", size = 33740, upload-time = "2025-12-16T00:40:23.96Z" }, - { url = "https://files.pythonhosted.org/packages/df/c0/87c2073e0c72515bb8733d4eef7b21548e8d189f094b5dad20b0ecaf64f6/google_crc32c-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:3cc0c8912038065eafa603b238abf252e204accab2a704c63b9e14837a854962", size = 34437, upload-time = "2025-12-16T00:35:21.395Z" }, - { url = "https://files.pythonhosted.org/packages/d1/db/000f15b41724589b0e7bc24bc7a8967898d8d3bc8caf64c513d91ef1f6c0/google_crc32c-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:3ebb04528e83b2634857f43f9bb8ef5b2bbe7f10f140daeb01b58f972d04736b", size = 31297, upload-time = "2025-12-16T00:23:20.709Z" }, - { url = "https://files.pythonhosted.org/packages/d7/0d/8ebed0c39c53a7e838e2a486da8abb0e52de135f1b376ae2f0b160eb4c1a/google_crc32c-1.8.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:450dc98429d3e33ed2926fc99ee81001928d63460f8538f21a5d6060912a8e27", size = 30867, upload-time = "2025-12-16T00:43:14.628Z" }, - { url = "https://files.pythonhosted.org/packages/ce/42/b468aec74a0354b34c8cbf748db20d6e350a68a2b0912e128cabee49806c/google_crc32c-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3b9776774b24ba76831609ffbabce8cdf6fa2bd5e9df37b594221c7e333a81fa", size = 33344, upload-time = "2025-12-16T00:40:24.742Z" }, - { url = "https://files.pythonhosted.org/packages/1c/e8/b33784d6fc77fb5062a8a7854e43e1e618b87d5ddf610a88025e4de6226e/google_crc32c-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:89c17d53d75562edfff86679244830599ee0a48efc216200691de8b02ab6b2b8", size = 33694, upload-time = "2025-12-16T00:40:25.505Z" }, - { url = "https://files.pythonhosted.org/packages/92/b1/d3cbd4d988afb3d8e4db94ca953df429ed6db7282ed0e700d25e6c7bfc8d/google_crc32c-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:57a50a9035b75643996fbf224d6661e386c7162d1dfdab9bc4ca790947d1007f", size = 34435, upload-time = "2025-12-16T00:35:22.107Z" }, - { url = "https://files.pythonhosted.org/packages/21/88/8ecf3c2b864a490b9e7010c84fd203ec8cf3b280651106a3a74dd1b0ca72/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:e6584b12cb06796d285d09e33f63309a09368b9d806a551d8036a4207ea43697", size = 31301, upload-time = "2025-12-16T00:24:48.527Z" }, - { url = "https://files.pythonhosted.org/packages/36/c6/f7ff6c11f5ca215d9f43d3629163727a272eabc356e5c9b2853df2bfe965/google_crc32c-1.8.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:f4b51844ef67d6cf2e9425983274da75f18b1597bb2c998e1c0a0e8d46f8f651", size = 30868, upload-time = "2025-12-16T00:48:12.163Z" }, - { url = "https://files.pythonhosted.org/packages/56/15/c25671c7aad70f8179d858c55a6ae8404902abe0cdcf32a29d581792b491/google_crc32c-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b0d1a7afc6e8e4635564ba8aa5c0548e3173e41b6384d7711a9123165f582de2", size = 33381, upload-time = "2025-12-16T00:40:26.268Z" }, - { url = "https://files.pythonhosted.org/packages/42/fa/f50f51260d7b0ef5d4898af122d8a7ec5a84e2984f676f746445f783705f/google_crc32c-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8b3f68782f3cbd1bce027e48768293072813469af6a61a86f6bb4977a4380f21", size = 33734, upload-time = "2025-12-16T00:40:27.028Z" }, - { url = "https://files.pythonhosted.org/packages/08/a5/7b059810934a09fb3ccb657e0843813c1fee1183d3bc2c8041800374aa2c/google_crc32c-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:d511b3153e7011a27ab6ee6bb3a5404a55b994dc1a7322c0b87b29606d9790e2", size = 34878, upload-time = "2025-12-16T00:35:23.142Z" }, - { url = "https://files.pythonhosted.org/packages/52/c5/c171e4d8c44fec1422d801a6d2e5d7ddabd733eeda505c79730ee9607f07/google_crc32c-1.8.0-pp311-pypy311_pp73-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:87fa445064e7db928226b2e6f0d5304ab4cd0339e664a4e9a25029f384d9bb93", size = 28615, upload-time = "2025-12-16T00:40:29.298Z" }, - { url = "https://files.pythonhosted.org/packages/9c/97/7d75fe37a7a6ed171a2cf17117177e7aab7e6e0d115858741b41e9dd4254/google_crc32c-1.8.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f639065ea2042d5c034bf258a9f085eaa7af0cd250667c0635a3118e8f92c69c", size = 28800, upload-time = "2025-12-16T00:40:30.322Z" }, -] - [[package]] name = "google-genai" -version = "1.75.0" +version = "2.10.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -1812,21 +1333,9 @@ dependencies = [ { name = "typing-extensions" }, { name = "websockets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/9d/59/3ed61240ef20b3ae6ed54e82c6f8b6d1f194947bc6679679dd6cdb037594/google_genai-1.75.0.tar.gz", hash = "sha256:56bac3991b311c93f980c0a2abcd287b672146905df1fbd71c92ed633d5a07cf", size = 539039, upload-time = "2026-05-04T22:48:54.857Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/fe/b796087493c3c55371aa58b9f264841ace5bfdf8c668cafa7afa33c44bec/google_genai-2.10.0.tar.gz", hash = "sha256:77912cd558cd7dfd5b75c25fd1c609e78d7954dde583331104022a46ea90f9ee", size = 600039, upload-time = "2026-06-24T01:33:18.157Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2d/b6/552d40e96da22921eb1fead7c14b00b5b5473a20e45959488660fab35ee2/google_genai-1.75.0-py3-none-any.whl", hash = "sha256:8dc4c096e7d6288c3087f6893f582fe52468932464781edb8193bd92b9fefb2c", size = 793726, upload-time = "2026-05-04T22:48:53.033Z" }, -] - -[[package]] -name = "google-resumable-media" -version = "2.10.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-crc32c" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/48/f8/1ca5781d6be9cb9f73f7d40f4958c4bd1226a60598e3e39e1d6aaf838c4b/google_resumable_media-2.10.0.tar.gz", hash = "sha256:e324bc9d0fdae4c52a08ae90456edc4e71ece858399e1217ac0eb3a51d6bc6ee", size = 2164570, upload-time = "2026-06-03T16:14:26.103Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/d8/00c6854ac1512bb9eaf13bd3f8f28222f7674947fc510a4ff7616f2efc80/google_resumable_media-2.10.0-py3-none-any.whl", hash = "sha256:88152884bee37b2bf36a0ab81ad8c7fd12212c9803dd981d77c1b35b02d34e7c", size = 81533, upload-time = "2026-06-03T16:13:12.51Z" }, + { url = "https://files.pythonhosted.org/packages/e0/39/00bcfd94de255d24249401efff4f48d77bf6066b46447e519fa193c0c299/google_genai-2.10.0-py3-none-any.whl", hash = "sha256:d5350311567ae660c24cbc1752aee4b3d660f89c0106d2dcd2a69978c35afe1e", size = 957974, upload-time = "2026-06-24T01:33:16.296Z" }, ] [[package]] @@ -1841,11 +1350,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/c8/e2645aa8ed02fd4c7a2f59d68783b65b1f3cbdfe39a6308e156509d1fee8/googleapis_common_protos-1.75.0-py3-none-any.whl", hash = "sha256:961ed60399c457ceb0ee8f285a84c870aabc9c6a832b9d37bb281b5bebde43ed", size = 300631, upload-time = "2026-05-07T08:03:30.345Z" }, ] -[package.optional-dependencies] -grpc = [ - { name = "grpcio" }, -] - [[package]] name = "graphql-core" version = "3.2.11" @@ -1864,76 +1368,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" }, ] -[[package]] -name = "greenlet" -version = "3.5.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/6e/802acd792aebb2256fbbee8cacf2727faaeb6f240ac11008f09eae4414bc/greenlet-3.5.1.tar.gz", hash = "sha256:5a56aeb7d5d9cc4b3a735efb5095bd4b4f6f0e4f93e5ca876d0e2315137b7829", size = 197356, upload-time = "2026-05-20T15:05:03.917Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/21/117c8710abb7f146d804a124c07eb5964a60b90d02b72452885aecc18efa/greenlet-3.5.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:7eacb17a9d41538a2bc4912eba5ef13823c83cb69e4d141d0813debe7163187f", size = 283510, upload-time = "2026-05-20T13:12:26.475Z" }, - { url = "https://files.pythonhosted.org/packages/b9/f7/6762a56fa5f6c2295c449c6524e10ce481e381c994cc44d9d03aef0700fb/greenlet-3.5.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5cc9606aa5f4e0bde0d3bd502b44f743864c3ffa5cfa1011b1e30f5aa02366f", size = 599696, upload-time = "2026-05-20T14:00:02.906Z" }, - { url = "https://files.pythonhosted.org/packages/0f/05/85a511e68ee109aff0aa00b4b497806091dd2d82ce209e49c6e801bd5d92/greenlet-3.5.1-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c3d35f87c7253b715d13d679e0783d845910144f282cb939fe1ba4ac8616269c", size = 612618, upload-time = "2026-05-20T14:05:39.202Z" }, - { url = "https://files.pythonhosted.org/packages/89/b8/8b83d18ae07c46c019617f35afd7b47aab7f9b4fbb12fc637d681e10bdd8/greenlet-3.5.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:540dae7b956209af4d70a3be35927b4055f617763771e5e84a5255bea934d2f5", size = 612947, upload-time = "2026-05-20T13:14:23.469Z" }, - { url = "https://files.pythonhosted.org/packages/5d/14/ad1f9fc9b82384c010212464a3702bd911f95dab2f1180bc6fbcfb1f958c/greenlet-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ed8cdb691169715a9a492844a83246f090182247d1a5031dc78a403f68ba1e97", size = 1571425, upload-time = "2026-05-20T14:02:22.671Z" }, - { url = "https://files.pythonhosted.org/packages/46/1c/43b8203cf10f4292c9e3d270e9e5f5ade79115a0a0ca5ea6f1be5f8915a7/greenlet-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9d59e840387076a51016777a9328b3f2c427c6f9208a6e958bad251be50a648d", size = 1638688, upload-time = "2026-05-20T13:14:30.026Z" }, - { url = "https://files.pythonhosted.org/packages/ac/6e/0344b1e99f58f71715456e46492101fd2daa408957b8186ade0a4b515da7/greenlet-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:b9152fca4a6466e114aaec745ae61cba739903a109754a9d4e1262f01e9259b1", size = 237763, upload-time = "2026-05-20T13:11:35.659Z" }, - { url = "https://files.pythonhosted.org/packages/42/3c/ff890b466eaba2b0f5e6bdfff025f8c75f41b8ffdc3dbc3d24ad261e764a/greenlet-3.5.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:73f78f9b9f0a5c06e5c946ba1e8e36f5114923b6be109ee618c54f079c3ea14f", size = 284764, upload-time = "2026-05-20T13:09:10.204Z" }, - { url = "https://files.pythonhosted.org/packages/81/0e/5e5457be3d256918f6a4756f073548a3f0190836e2cc94aa6d0d617a940b/greenlet-3.5.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0cbed8bb44e23c5b199f888f4e4ce096b45ad9f25ff74a7ad0213875e936bb2", size = 603479, upload-time = "2026-05-20T14:00:04.757Z" }, - { url = "https://files.pythonhosted.org/packages/6d/e1/f89a21d58d308298e6f275f13a1b472ed96c680b601a371b08be6a725989/greenlet-3.5.1-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a203a8bd0acb0701653d3bbb26e404854a68674139ed5cbb778830f42b09bb33", size = 615495, upload-time = "2026-05-20T14:05:40.87Z" }, - { url = "https://files.pythonhosted.org/packages/75/de/af6cef182862d2ccd6975440d21c9058a77c3f9b469abf94e322dfd2e0e3/greenlet-3.5.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a271fcd66c74615cda6a964fda3f304267a12e50a084472218a39bb0376f563", size = 614754, upload-time = "2026-05-20T13:14:24.947Z" }, - { url = "https://files.pythonhosted.org/packages/1a/c6/50e520283a9f19388a7326b05f9e8637e566003475eacaadad04f558c68d/greenlet-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ded7b068c7c31c1a8657d4fd42d886b3e051ae29f88b80c5ff9d502257b0f071", size = 1574097, upload-time = "2026-05-20T14:02:24.003Z" }, - { url = "https://files.pythonhosted.org/packages/21/1c/13abd1f4860d987fa5e1170a01930d6e6cd40d328de487a3c9fdaff0ffd0/greenlet-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d0932b81d72f552ded9d810d00021b64d89f2195a91ce115b893f943b7a4ab3c", size = 1641058, upload-time = "2026-05-20T13:14:31.83Z" }, - { url = "https://files.pythonhosted.org/packages/f5/56/5f332b7705545eac2dc01b4e9254d24a793f2656d55d5cc6b94ee59d22ae/greenlet-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:88e300d136eac057b2397aa1cfd7328b4c87c7eb66a09c7bc6a1292234db474e", size = 238089, upload-time = "2026-05-20T13:14:03.229Z" }, - { url = "https://files.pythonhosted.org/packages/d9/a9/a3c2fa886c5b94863fb0e61b3bc14610b7aa94cf4f17f8741b11708305fc/greenlet-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:cc6ab7e555c8a112ad3a76e368e86e12a2754bcae1652a5602e133ec7b635523", size = 234989, upload-time = "2026-05-20T13:08:27.715Z" }, - { url = "https://files.pythonhosted.org/packages/c4/37/4549f149c9797c21b32c2683c33522af22522099de128b2406672526d005/greenlet-3.5.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fa4f98af3a528f0c3fd592a26df7f376f93329c8f4d987f6bb979057af8bf5e2", size = 286220, upload-time = "2026-05-20T13:07:28.463Z" }, - { url = "https://files.pythonhosted.org/packages/38/ff/a4f436709716965eaab9f36ea7b906c8a927fbe32fb1372a2071d964f6b1/greenlet-3.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffea73584b216150eab159b6d12348fb253e68757974de1e2c40d8a318ac89ed", size = 601585, upload-time = "2026-05-20T14:00:06.141Z" }, - { url = "https://files.pythonhosted.org/packages/65/ad/54bc3fcee3ad368a61b19b67d88117f7a8c29727bf71fffdeda81fbd946e/greenlet-3.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1072b4f9edcc1e192d9283a66a3e68d6b84c561de33a83d7858beb9ba1effe10", size = 614215, upload-time = "2026-05-20T14:05:42.675Z" }, - { url = "https://files.pythonhosted.org/packages/40/69/b91cda0647df839483201545913514c2827ebea5e5ccdf931842763bc127/greenlet-3.5.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:add5217d68b31130f0beca584d7fef4878327d2e31642b66618a14eef312b63b", size = 611358, upload-time = "2026-05-20T13:14:26.37Z" }, - { url = "https://files.pythonhosted.org/packages/59/90/3cf77e080350cd02fa307bb2abf05df48f4482c240275bbd2c203ba8bb1c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a5ea42a752d47a145eae922b605cd1634665ac3d5ec1e72402d5048e8d60d207", size = 1570475, upload-time = "2026-05-20T14:02:25.29Z" }, - { url = "https://files.pythonhosted.org/packages/65/2c/18cece62045e74598c3c393f70dce4a63f56222015ba29a5d4eeb04f764c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5551170cf4f5ff5623e9af81323751979fee2c731e2287b61f73cd27257b823", size = 1635625, upload-time = "2026-05-20T13:14:34.027Z" }, - { url = "https://files.pythonhosted.org/packages/30/f5/310d104ddf41eb5a70f4c268d22508dfb0c3c8e86fec152be34d0d2ed819/greenlet-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c8bb982ad117d29478ef8f5533e97df21f1e2befd17a299257b0c96d1371c0b", size = 238791, upload-time = "2026-05-20T13:10:39.018Z" }, - { url = "https://files.pythonhosted.org/packages/62/90/ceca11f504cd23a8047a3dea31919adc48df9b626dd0c13f0d858734fdfd/greenlet-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:80eb4b04dadc4e67df3fae179a32c4706a3f495bc7f22fc8a81115d5f5512188", size = 235580, upload-time = "2026-05-20T13:08:45.056Z" }, - { url = "https://files.pythonhosted.org/packages/27/69/7f7e5372d998b81001899b1c0823c957aa413ba0f2662e65821611cc31e4/greenlet-3.5.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:51518ff74664078fc51bffcc6fc529b0df5ae58da192691cee765d45ce944a2b", size = 285060, upload-time = "2026-05-20T13:08:51.899Z" }, - { url = "https://files.pythonhosted.org/packages/b1/bf/387f9b6b865fd2ae0d0be09e0004827295a01b71be76ed350dd1e28a91a4/greenlet-3.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ffdb3c0bb002c99cd8f298957e046c3dbf6006b5b7cdf11a4e19194624a0a0a", size = 604370, upload-time = "2026-05-20T14:00:07.492Z" }, - { url = "https://files.pythonhosted.org/packages/32/f5/169ce3d4e4c67291bd18f8cbe0299c9f3e45102c7f1fb3c14780c93e4532/greenlet-3.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7715a5a2c3378ba602c3a440558261e13a820bb53a82693aacd7b7f6d964e283", size = 616987, upload-time = "2026-05-20T14:05:44.237Z" }, - { url = "https://files.pythonhosted.org/packages/ee/e5/7f2e41d5273be07e77560d61ea4e56485b4d6c316d2a84518c62d1364061/greenlet-3.5.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc71ff466927a201b08305acac451ebe1aedfcea002f62f1f2f2ac2ac1e6a135", size = 613911, upload-time = "2026-05-20T13:14:27.539Z" }, - { url = "https://files.pythonhosted.org/packages/c5/a4/fbdc67579b73615a1f91615e814303cc71e06128f7baaba87be79b8fb90c/greenlet-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cd443683db272ebaaca03af98c0b063ab30db70ea8a31a1559f35e3f7b744ccd", size = 1570689, upload-time = "2026-05-20T14:02:27.225Z" }, - { url = "https://files.pythonhosted.org/packages/e6/b4/77abbe35078be39718a46cd49caf16bceb35662f97a34101dca28aa98e47/greenlet-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:089fff7a6ce8d9316d1f65ebc00273a56be258c1725b32b94de90a3a979557e1", size = 1635602, upload-time = "2026-05-20T13:14:36.344Z" }, - { url = "https://files.pythonhosted.org/packages/37/f7/129f27ca700845b8ee8ca88ce7f43435a1239c2eddb7677fc938822762cf/greenlet-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:110a1ca7b49b014b097f6078272c3f4ed31af45b254de5228b79adba879f6af9", size = 238683, upload-time = "2026-05-20T13:11:50.57Z" }, - { url = "https://files.pythonhosted.org/packages/6d/5c/a485a36e87df8d8fd0632ee01511244f5156a20ed3746cc6599340326395/greenlet-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f16ba1efc0715b680a18b8123d90dad887c6112ae3555b4b5c32c149540c6b4e", size = 235499, upload-time = "2026-05-20T13:12:42.028Z" }, - { url = "https://files.pythonhosted.org/packages/8a/cb/c62454606daf5640369c94d8a9dd540599b1bfc090e2d2180cb77f4038d2/greenlet-3.5.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8ab31c9de8651a2facdd5c5bb0011f2380dd1a7af78ce2adf4b56095294fc07", size = 285579, upload-time = "2026-05-20T13:08:56.396Z" }, - { url = "https://files.pythonhosted.org/packages/ec/71/c4270398c2eba968a6071af1dfbdcaeee6ec1c24bc8b435b8cc452700da6/greenlet-3.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e300185139abc337ade480c327183adf42a875ac7181bfe66d7d4efea31fbea", size = 651106, upload-time = "2026-05-20T14:00:09.448Z" }, - { url = "https://files.pythonhosted.org/packages/1a/ab/71e34b78a44ec271fb5f550c17bc46d301ddc5953890d935f270b0dcdb5a/greenlet-3.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7ffdb990dcaa0234cf9845aead5df2e3c3a8b6507d409274dd87e0d5ab05ffc2", size = 663478, upload-time = "2026-05-20T14:05:45.88Z" }, - { url = "https://files.pythonhosted.org/packages/77/96/4efd6fa5c62c85426a0c19077a586258ebc3a2a146ff2493e4312a697a22/greenlet-3.5.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f82b3597e9d83b63408affed0b48fd0f54935edac4302237b9a837be0dae33c", size = 660800, upload-time = "2026-05-20T13:14:29.129Z" }, - { url = "https://files.pythonhosted.org/packages/7a/e0/6c71401a25cac7000261304e866a2f2cc04dc74810d40e2f118aa4799495/greenlet-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c0141e37414c10164e702b8fb1473304221ad98f71600850c6ef7ff4880feba0", size = 1617518, upload-time = "2026-05-20T14:02:28.662Z" }, - { url = "https://files.pythonhosted.org/packages/41/26/c5c06643e8c0af9e7bf18e16cb51d0ab7625155f0392e1c9015d66d556cd/greenlet-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:50ae25a67bea74ea41fb14b960bc532df73eb713417b2d61892dced82fe8d3bc", size = 1681593, upload-time = "2026-05-20T13:14:39.417Z" }, - { url = "https://files.pythonhosted.org/packages/8a/bd/e11a108317485075e68af9d23039619b86b28130c3b50d227d42edece64b/greenlet-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:8a17c42330e261299766b75ac1ea32caa437a9453c8f65d16a13140db378ecd3", size = 239800, upload-time = "2026-05-20T13:09:30.128Z" }, - { url = "https://files.pythonhosted.org/packages/47/f8/8e8e8417b7bf28639a5a56356ef934d0375e1d0c70a57e04d7701e870ffe/greenlet-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:7b5f5fae05b8ac6d176a61b60c394a8cbdc2b5b91b81793066e68745cf165e54", size = 236862, upload-time = "2026-05-20T13:09:10.498Z" }, - { url = "https://files.pythonhosted.org/packages/90/12/41bf27fde4d3605d3773ae57751eda182b8be2f5398011c041173b1d9534/greenlet-3.5.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:ea8da1e900d758d078810d4255d8c6aa572181896a31ec79d779eb79c3adc9ad", size = 293637, upload-time = "2026-05-20T13:12:35.529Z" }, - { url = "https://files.pythonhosted.org/packages/44/44/ba14b23e9757707050c2f397d305bbcae62e5d7cad122f8b6baec5ae4a1f/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a19570c52a21420dcbc94e661994bc325c0b5b11304540fed514586da5dc8f2e", size = 650840, upload-time = "2026-05-20T14:00:11.079Z" }, - { url = "https://files.pythonhosted.org/packages/a8/37/5ddc2b686a6844f91abecef43411842426da2e1573f60b49ecf2547f4ae1/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3d955c89b75eeca4723d7cc14135f393cd47c32e2a6cb4a8e4c6e760a26b0986", size = 656416, upload-time = "2026-05-20T14:05:47.118Z" }, - { url = "https://files.pythonhosted.org/packages/e1/f0/d17510297c35a2992712f0bf84de3779749999f7d3d63aa1f09db7c62dbe/greenlet-3.5.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2daaaebd1a5aa88c49045b6baf9310b3263796bd88db713edf37cf53e7bb4e", size = 654397, upload-time = "2026-05-20T13:14:30.696Z" }, - { url = "https://files.pythonhosted.org/packages/37/eb/147387705bb89092645b012586e7273cb5ed3c90ef7eaf3a69173eaf0209/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bfbd69cc349e43bf3a8ae1c85548ff0718efc887615c2db16c3833d7b0b072d", size = 1614469, upload-time = "2026-05-20T14:02:30.192Z" }, - { url = "https://files.pythonhosted.org/packages/a6/4e/37ee0da7732b7aa9896f17e15579a9df34b9fcb9dd494f0adfa749af6623/greenlet-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4378720dd888136c27215a0214d32a4d37c3852765d45bc37aad0623423cfd78", size = 1675115, upload-time = "2026-05-20T13:14:40.972Z" }, - { url = "https://files.pythonhosted.org/packages/57/f3/97dfcf4a6eb5077f8a672234216fb5923eb89f2cab7081cb10b2cf75b605/greenlet-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:45718441607f9325d948db98cbc691276059316d0358c188c246da4e1d4d23d2", size = 245246, upload-time = "2026-05-20T13:12:22.646Z" }, - { url = "https://files.pythonhosted.org/packages/5d/73/d7f72e34b582f694f4a9b248162db7b09cc458a259ba8f0c0bfa1a34ea7d/greenlet-3.5.1-cp315-cp315-macosx_11_0_universal2.whl", hash = "sha256:2baee5ca02031757ffe8cc3d69f0cc0aec7065ce362622da74f32d3bcab1c541", size = 285575, upload-time = "2026-05-20T13:12:07.043Z" }, - { url = "https://files.pythonhosted.org/packages/df/59/fa9c6e87dc8ad27a95dabe2f29f372b733d05a8a67470f6c901ed9975655/greenlet-3.5.1-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b1ec3274918a81d3ea778b9e75b56b72b33f300edb6cf7f3a7fe1dae56683de", size = 656428, upload-time = "2026-05-20T14:00:12.556Z" }, - { url = "https://files.pythonhosted.org/packages/f6/f9/e753408871eaa61dfe35e619cfc67512b036fde99893685d50eea9e07146/greenlet-3.5.1-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:111e2390ffffc47d5840b01711dd7fac07d4c09283d0283e7f3264b14e284c64", size = 667064, upload-time = "2026-05-20T14:05:48.662Z" }, - { url = "https://files.pythonhosted.org/packages/96/27/5565b5b40389f1c7753003a07e21892fda8660926787036d5bc0308b8113/greenlet-3.5.1-cp315-cp315-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e630136e905fe5ff43e86945ae41220b6d1470956a39220e708110ac48d01ea5", size = 665697, upload-time = "2026-05-20T13:14:32.943Z" }, - { url = "https://files.pythonhosted.org/packages/cf/82/e7de4178c0c2d1c9a5a3be3cc0b33e46a85b3ee4a77c071bf7ad8600e079/greenlet-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:975eac34b44a7077ca4d421348455b94f0f518246a7f14bc6d2fdcfe5b584368", size = 1621256, upload-time = "2026-05-20T14:02:31.91Z" }, - { url = "https://files.pythonhosted.org/packages/00/10/f2dddcf7dacac17dfc68691809589adad06135eb28930429cf58a6467a2f/greenlet-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:9ab3c3a0b2ae6198e67c898dad5215a49f9ae0d0081b3c3ec59f333e39eeca26", size = 1685956, upload-time = "2026-05-20T13:14:42.55Z" }, - { url = "https://files.pythonhosted.org/packages/22/17/4a232b32133230ada52f70e9d7f5b65b0caef8772f01849bd8d149e7e4ca/greenlet-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:cbfc69be86e10dcfef5b1e6269d1d6926552aa89ee39e1de3353360c1b6989ab", size = 239802, upload-time = "2026-05-20T13:13:15.481Z" }, - { url = "https://files.pythonhosted.org/packages/c2/ae/4e623a7e6d4d2a5f4cb8e4c82de4169fc637942caae68d6e676b8a128ac5/greenlet-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:92fd6d44ac5e5a887c8a5dc4a8ba0ba908527c31c12f78c6bc7dcfe8aab279f6", size = 236853, upload-time = "2026-05-20T13:15:37.301Z" }, - { url = "https://files.pythonhosted.org/packages/7a/57/816d9cff29119da3505b3d6a5e14a8af89006ac36f47f891ff293ee05af1/greenlet-3.5.1-cp315-cp315t-macosx_11_0_universal2.whl", hash = "sha256:a6fdf2433a5441ef9a95464f7c3e674775da1c8c1177fff311cee1acad4626ed", size = 293877, upload-time = "2026-05-20T13:10:19.078Z" }, - { url = "https://files.pythonhosted.org/packages/23/a1/59b0a7c7d140ff1a75626680b9a9899b79a9176cab298b394968fb023295/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7546556f0d649f99f6a361098a55f761181bb2ea12ff150bb16d26092ad88244", size = 655333, upload-time = "2026-05-20T14:00:14.758Z" }, - { url = "https://files.pythonhosted.org/packages/72/1b/5efe127597625042218939d01855109f352779050768b670b52edcc16a6c/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5ee3ea898009fa898f85f9982255d35278c477bebe185beca249cab42d4526c", size = 659443, upload-time = "2026-05-20T14:05:50.159Z" }, - { url = "https://files.pythonhosted.org/packages/6c/6d/c404246ea4d22d097a7426d0efb5b781bd7eb67715f09e79001bd552ab18/greenlet-3.5.1-cp315-cp315t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5c81f74d204d3edd136ebfd50dce53acbb776995d721a0fe801626cfc93b8cd", size = 658356, upload-time = "2026-05-20T13:14:35.091Z" }, - { url = "https://files.pythonhosted.org/packages/51/02/f8ee37fb6d2219329f350af241c27fcf12df57e723d11f6fc6d3bacdadaa/greenlet-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:2c18ef16bf6d4dd410e4dd52996888ea1497be26892fe5bbc73580aba4287b8e", size = 1619216, upload-time = "2026-05-20T14:02:33.403Z" }, - { url = "https://files.pythonhosted.org/packages/93/c5/3dc9475ace2c7a3680da12372cddd7f1ac874eb410a1ac48d3e9dab83782/greenlet-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:17d86354f0ae6b61bf9be5148d0dd34e06c3cb7c602c671f79f29ac3b150e659", size = 1678427, upload-time = "2026-05-20T13:14:43.71Z" }, - { url = "https://files.pythonhosted.org/packages/df/4e/750c15c317a41ffb36f0bf40b933e3d744a7dede61889f74443ea69690cf/greenlet-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:e7516cf6ae6b8a582c2770a0caed47b8a48373ed732c33d69a72913ae6ac923e", size = 245225, upload-time = "2026-05-20T13:13:59.366Z" }, - { url = "https://files.pythonhosted.org/packages/4f/fd/d3baea2eeb7b617efd47e87ca06e2ec2c6118d303aa9e918e0ce16eadc10/greenlet-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:5028648bf2253ec4745add746129d3904121fa7fe871a76bed23c5720573ce0a", size = 239590, upload-time = "2026-05-20T13:13:37.382Z" }, -] - [[package]] name = "griffelib" version = "2.0.2" @@ -1943,32 +1377,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/11/8c/c9138d881c79aa0ea9ed83cbd58d5ca75624378b38cee225dcf5c42cc91f/griffelib-2.0.2-py3-none-any.whl", hash = "sha256:925c857658fb1ba40c0772c37acbc2ab650bd794d9c1b9726922e36ea4117ea1", size = 142357, upload-time = "2026-03-27T11:34:46.275Z" }, ] -[[package]] -name = "grpc-google-iam-v1" -version = "0.14.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "googleapis-common-protos", extra = ["grpc"] }, - { name = "grpcio" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/44/4f/d098419ad0bfc06c9ce440575f05aa22d8973b6c276e86ac7890093d3c37/grpc_google_iam_v1-0.14.4.tar.gz", hash = "sha256:392b3796947ed6334e61171d9ab06bf7eb357f554e5fc7556ad7aab6d0e17038", size = 23706, upload-time = "2026-04-01T01:57:49.813Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/89/22/c2dd50c09bf679bd38173656cd4402d2511e563b33bc88f90009cf50613c/grpc_google_iam_v1-0.14.4-py3-none-any.whl", hash = "sha256:412facc320fcbd94034b4df3d557662051d4d8adfa86e0ddb4dca70a3f739964", size = 32675, upload-time = "2026-04-01T01:57:47.69Z" }, -] - -[[package]] -name = "grpc-interceptor" -version = "0.15.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "grpcio" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9f/28/57449d5567adf4c1d3e216aaca545913fbc21a915f2da6790d6734aac76e/grpc-interceptor-0.15.4.tar.gz", hash = "sha256:1f45c0bcb58b6f332f37c637632247c9b02bc6af0fdceb7ba7ce8d2ebbfb0926", size = 19322, upload-time = "2023-11-16T02:05:42.459Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/15/ac/8d53f230a7443401ce81791ec50a3b0e54924bf615ad287654fa4a2f5cdc/grpc_interceptor-0.15.4-py3-none-any.whl", hash = "sha256:0035f33228693ed3767ee49d937bac424318db173fef4d2d0170b3215f254d9d", size = 20848, upload-time = "2023-11-16T02:05:40.913Z" }, -] - [[package]] name = "grpcio" version = "1.81.1" @@ -2030,20 +1438,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ff/b0/4af731ff7492c68a96e4c71bfd0f4590acde92b31c6fe4894e6465c10ff6/grpcio-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:3768a5ff1b2125e6f552e561b6b2dca0e64982d8949689b4df145cf8b98d7821", size = 5070275, upload-time = "2026-06-11T12:46:48.486Z" }, ] -[[package]] -name = "grpcio-status" -version = "1.81.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "googleapis-common-protos" }, - { name = "grpcio" }, - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/32/26/0aa9168c87882381fd810d140c279a2490ed6aee655f0515d6f56c5ca404/grpcio_status-1.81.1.tar.gz", hash = "sha256:9389a03e746017b10f0630c064289201458f3ce01f5d7ef4b0bebc1ef6cf82ad", size = 13923, upload-time = "2026-06-11T12:58:48.636Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/5e/5abfec5f7e89d3b7993d57cfb025ca5f968a2c18656d7fcda2b6919440b9/grpcio_status-1.81.1-py3-none-any.whl", hash = "sha256:08072fa9995f4a95c647fc6f4f85e2411573d00087bcabdf30f260114338f232", size = 14638, upload-time = "2026-06-11T12:58:31.982Z" }, -] - [[package]] name = "grpcio-tools" version = "1.81.1" @@ -2161,18 +1555,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, ] -[[package]] -name = "httplib2" -version = "0.31.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyparsing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c1/1f/e86365613582c027dda5ddb64e1010e57a3d53e99ab8a72093fa13d565ec/httplib2-0.31.2.tar.gz", hash = "sha256:385e0869d7397484f4eab426197a4c020b606edd43372492337c0b4010ae5d24", size = 250800, upload-time = "2026-01-23T11:04:44.165Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/90/fd509079dfcab01102c0fdd87f3a9506894bc70afcf9e9785ef6b2b3aff6/httplib2-0.31.2-py3-none-any.whl", hash = "sha256:dbf0c2fa3862acf3c55c078ea9c0bc4481d7dc5117cae71be9514912cf9f8349", size = 91099, upload-time = "2026-01-23T11:04:42.78Z" }, -] - [[package]] name = "httpx" version = "0.28.1" @@ -2743,18 +2125,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6c/8b/bf975fabd26195915ebdf3e4252baa936f1863bcd9eb49598b705638f5d5/lunr-0.8.0-py3-none-any.whl", hash = "sha256:a2bc4e08dbb35b32723006bf2edbe6dc1f4f4b95955eea0d23165a184d276ce8", size = 35211, upload-time = "2025-03-08T13:31:38.657Z" }, ] -[[package]] -name = "mako" -version = "1.3.12" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "markupsafe" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/00/62/791b31e69ae182791ec67f04850f2f062716bbd205483d63a215f3e062d3/mako-1.3.12.tar.gz", hash = "sha256:9f778e93289bd410bb35daadeb4fc66d95a746f0b75777b942088b7fd7af550a", size = 400219, upload-time = "2026-04-28T19:01:08.512Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bc/b1/a0ec7a5a9db730a08daef1fdfb8090435b82465abbf758a596f0ea88727e/mako-1.3.12-py3-none-any.whl", hash = "sha256:8f61569480282dbf557145ce441e4ba888be453c30989f879f0d652e39f53ea9", size = 78521, upload-time = "2026-04-28T19:01:10.393Z" }, -] - [[package]] name = "markdown-it-py" version = "4.2.0" @@ -2923,120 +2293,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, ] -[[package]] -name = "mmh3" -version = "5.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/91/1a/edb23803a168f070ded7a3014c6d706f63b90c84ccc024f89d794a3b7a6d/mmh3-5.2.1.tar.gz", hash = "sha256:bbea5b775f0ac84945191fb83f845a6fd9a21a03ea7f2e187defac7e401616ad", size = 33775, upload-time = "2026-03-05T15:55:57.716Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/bb/88ee54afa5644b0f35ab5b435f208394feb963e5bb47c4e404deb625ffa4/mmh3-5.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5d87a3584093e1a89987e3d36d82c98d9621b2cb944e22a420aa1401e096758f", size = 56080, upload-time = "2026-03-05T15:53:40.452Z" }, - { url = "https://files.pythonhosted.org/packages/cc/bf/5404c2fd6ac84819e8ff1b7e34437b37cf55a2b11318894909e7bb88de3f/mmh3-5.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:30e4d2084df019880d55f6f7bea35328d9b464ebee090baa372c096dc77556fb", size = 40462, upload-time = "2026-03-05T15:53:41.751Z" }, - { url = "https://files.pythonhosted.org/packages/de/0b/52bffad0b52ae4ea53e222b594bd38c08ecac1fc410323220a7202e43da5/mmh3-5.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bbc17250b10d3466875a40a52520a6bac3c02334ca709207648abd3c223ed5c", size = 40077, upload-time = "2026-03-05T15:53:42.753Z" }, - { url = "https://files.pythonhosted.org/packages/a0/9e/326c93d425b9fa4cbcdc71bc32aaba520db37577d632a24d25d927594eca/mmh3-5.2.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:76219cd1eefb9bf4af7856e3ae563d15158efa145c0aab01e9933051a1954045", size = 95302, upload-time = "2026-03-05T15:53:43.867Z" }, - { url = "https://files.pythonhosted.org/packages/c6/b1/e20d5f0d19c4c0f3df213fa7dcfa0942c4fb127d38e11f398ae8ddf6cccc/mmh3-5.2.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb9d44c25244e11c8be3f12c938ca8ba8404620ef8092245d2093c6ab3df260f", size = 101174, upload-time = "2026-03-05T15:53:45.194Z" }, - { url = "https://files.pythonhosted.org/packages/7f/4a/1a9bb3e33c18b1e1cee2c249a3053c4d4d9c93ecb30738f39a62249a7e86/mmh3-5.2.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d5d542bf2abd0fd0361e8017d03f7cb5786214ceb4a40eef1539d6585d93386", size = 103979, upload-time = "2026-03-05T15:53:46.334Z" }, - { url = "https://files.pythonhosted.org/packages/ff/8d/dab9ee7545429e7acdd38d23d0104471d31de09a0c695f1b751e0ff34532/mmh3-5.2.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:08043f7cb1fb9467c3fbbbaea7896986e7fbc81f4d3fd9289a73d9110ab6207a", size = 110898, upload-time = "2026-03-05T15:53:47.443Z" }, - { url = "https://files.pythonhosted.org/packages/72/08/408f11af7fe9e76b883142bb06536007cc7f237be2a5e9ad4e837716e627/mmh3-5.2.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:add7ac388d1e0bf57259afbcf9ed05621a3bf11ce5ee337e7536f1e1aaf056b0", size = 118308, upload-time = "2026-03-05T15:53:49.1Z" }, - { url = "https://files.pythonhosted.org/packages/86/2d/0551be7fe0000736d9ad12ffa1f130d7a0c17b49193d6dc41c82bd9404c6/mmh3-5.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41105377f6282e8297f182e393a79cfffd521dde37ace52b106373bdcd9ca5cb", size = 101671, upload-time = "2026-03-05T15:53:50.317Z" }, - { url = "https://files.pythonhosted.org/packages/44/17/6e4f80c4e6ad590139fa2017c3aeca54e7cc9ef68e08aa142a0c90f40a97/mmh3-5.2.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3cb61db880ec11e984348227b333259994c2c85caa775eb7875decb3768db890", size = 96682, upload-time = "2026-03-05T15:53:51.48Z" }, - { url = "https://files.pythonhosted.org/packages/ad/a7/b82fccd38c1fa815de72e94ebe9874562964a10e21e6c1bc3b01d3f15a0e/mmh3-5.2.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:e8b5378de2b139c3a830f0209c1e91f7705919a4b3e563a10955104f5097a70a", size = 110287, upload-time = "2026-03-05T15:53:52.68Z" }, - { url = "https://files.pythonhosted.org/packages/a8/a1/2644069031c8cec0be46f0346f568a53f42fddd843f03cc890306699c1e2/mmh3-5.2.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e904f2417f0d6f6d514f3f8b836416c360f306ddaee1f84de8eef1e722d212e5", size = 111899, upload-time = "2026-03-05T15:53:53.791Z" }, - { url = "https://files.pythonhosted.org/packages/51/7b/6614f3eb8fb33f931fa7616c6d477247e48ec6c5082b02eeeee998cffa94/mmh3-5.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f1fbb0a99125b1287c6d9747f937dc66621426836d1a2d50d05aecfc81911b57", size = 100078, upload-time = "2026-03-05T15:53:55.234Z" }, - { url = "https://files.pythonhosted.org/packages/27/9a/dd4d5a5fb893e64f71b42b69ecae97dd78db35075412488b24036bc5599c/mmh3-5.2.1-cp310-cp310-win32.whl", hash = "sha256:b4cce60d0223074803c9dbe0721ad3fa51dafe7d462fee4b656a1aa01ee07518", size = 40756, upload-time = "2026-03-05T15:53:56.319Z" }, - { url = "https://files.pythonhosted.org/packages/c9/34/0b25889450f8aeffcec840aa73251e853f059c1b72ed1d1c027b956f95f5/mmh3-5.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:6f01f044112d43a20be2f13a11683666d87151542ad627fe41a18b9791d2802f", size = 41519, upload-time = "2026-03-05T15:53:57.41Z" }, - { url = "https://files.pythonhosted.org/packages/fd/31/8fd42e3c526d0bcb1db7f569c0de6729e180860a0495e387a53af33c2043/mmh3-5.2.1-cp310-cp310-win_arm64.whl", hash = "sha256:7501e9be34cb21e72fcfe672aafd0eee65c16ba2afa9dcb5500a587d3a0580f0", size = 39285, upload-time = "2026-03-05T15:53:58.697Z" }, - { url = "https://files.pythonhosted.org/packages/65/d7/3312a59df3c1cdd783f4cf0c4ee8e9decff9c5466937182e4cc7dbbfe6c5/mmh3-5.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:dae0f0bd7d30c0ad61b9a504e8e272cb8391eed3f1587edf933f4f6b33437450", size = 56082, upload-time = "2026-03-05T15:53:59.702Z" }, - { url = "https://files.pythonhosted.org/packages/61/96/6f617baa098ca0d2989bfec6d28b5719532cd8d8848782662f5b755f657f/mmh3-5.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9aeaf53eaa075dd63e81512522fd180097312fb2c9f476333309184285c49ce0", size = 40458, upload-time = "2026-03-05T15:54:01.548Z" }, - { url = "https://files.pythonhosted.org/packages/c1/b4/9cd284bd6062d711e13d26c04d4778ab3f690c1c38a4563e3c767ec8802e/mmh3-5.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0634581290e6714c068f4aa24020acf7880927d1f0084fa753d9799ae9610082", size = 40079, upload-time = "2026-03-05T15:54:02.743Z" }, - { url = "https://files.pythonhosted.org/packages/f6/09/a806334ce1d3d50bf782b95fcee8b3648e1e170327d4bb7b4bad2ad7d956/mmh3-5.2.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e080c0637aea036f35507e803a4778f119a9b436617694ae1c5c366805f1e997", size = 97242, upload-time = "2026-03-05T15:54:04.536Z" }, - { url = "https://files.pythonhosted.org/packages/ee/93/723e317dd9e041c4dc4566a2eb53b01ad94de31750e0b834f1643905e97c/mmh3-5.2.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db0562c5f71d18596dcd45e854cf2eeba27d7543e1a3acdafb7eef728f7fe85d", size = 103082, upload-time = "2026-03-05T15:54:06.387Z" }, - { url = "https://files.pythonhosted.org/packages/61/b5/f96121e69cc48696075071531cf574f112e1ffd08059f4bffb41210e6fc5/mmh3-5.2.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d9f9a3ce559a5267014b04b82956993270f63ec91765e13e9fd73daf2d2738e", size = 106054, upload-time = "2026-03-05T15:54:07.506Z" }, - { url = "https://files.pythonhosted.org/packages/82/49/192b987ec48d0b2aecf8ac285a9b11fbc00030f6b9c694664ae923458dde/mmh3-5.2.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:960b1b3efa39872ac8b6cc3a556edd6fb90ed74f08c9c45e028f1005b26aa55d", size = 112910, upload-time = "2026-03-05T15:54:09.403Z" }, - { url = "https://files.pythonhosted.org/packages/cf/a1/03e91fd334ed0144b83343a76eb11f17434cd08f746401488cfeafb2d241/mmh3-5.2.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d30b650595fdbe32366b94cb14f30bb2b625e512bd4e1df00611f99dc5c27fd4", size = 120551, upload-time = "2026-03-05T15:54:10.587Z" }, - { url = "https://files.pythonhosted.org/packages/93/b9/b89a71d2ff35c3a764d1c066c7313fc62c7cc48fa48a4b3b0304a4a0146f/mmh3-5.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:82f3802bfc4751f420d591c5c864de538b71cea117fce67e4595c2afede08a15", size = 99096, upload-time = "2026-03-05T15:54:11.76Z" }, - { url = "https://files.pythonhosted.org/packages/36/b5/613772c1c6ed5f7b63df55eb131e887cc43720fec392777b95a79d34e640/mmh3-5.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:915e7a2418f10bd1151b1953df06d896db9783c9cfdb9a8ee1f9b3a4331ab503", size = 98524, upload-time = "2026-03-05T15:54:13.122Z" }, - { url = "https://files.pythonhosted.org/packages/5e/0e/1524566fe8eaf871e4f7bc44095929fcd2620488f402822d848df19d679c/mmh3-5.2.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:fc78739b5ec6e4fb02301984a3d442a91406e7700efbe305071e7fd1c78278f2", size = 106239, upload-time = "2026-03-05T15:54:14.601Z" }, - { url = "https://files.pythonhosted.org/packages/04/94/21adfa7d90a7a697137ad6de33eeff6445420ca55e433a5d4919c79bc3b5/mmh3-5.2.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:41aac7002a749f08727cb91babff1daf8deac317c0b1f317adc69be0e6c375d1", size = 109797, upload-time = "2026-03-05T15:54:15.819Z" }, - { url = "https://files.pythonhosted.org/packages/b5/e6/1aacc3a219e1aa62fa65669995d4a3562b35be5200ec03680c7e4bec9676/mmh3-5.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9d8089d853c7963a8ce87fff93e2a67075c0bc08684a08ea6ad13577c38ffc38", size = 97228, upload-time = "2026-03-05T15:54:16.992Z" }, - { url = "https://files.pythonhosted.org/packages/f1/b9/5e4cca8dcccf298add0a27f3c357bc8cf8baf821d35cdc6165e4bd5a48b0/mmh3-5.2.1-cp311-cp311-win32.whl", hash = "sha256:baeb47635cb33375dee4924cd93d7f5dcaa786c740b08423b0209b824a1ee728", size = 40751, upload-time = "2026-03-05T15:54:18.714Z" }, - { url = "https://files.pythonhosted.org/packages/72/fc/5b11d49247f499bcda591171e9cf3b6ee422b19e70aa2cef2e0ae65ca3b9/mmh3-5.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:1e4ecee40ba19e6975e1120829796770325841c2f153c0e9aecca927194c6a2a", size = 41517, upload-time = "2026-03-05T15:54:19.764Z" }, - { url = "https://files.pythonhosted.org/packages/8a/5f/2a511ee8a1c2a527c77726d5231685b72312c5a1a1b7639ad66a9652aa84/mmh3-5.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:c302245fd6c33d96bd169c7ccf2513c20f4c1e417c07ce9dce107c8bc3f8411f", size = 39287, upload-time = "2026-03-05T15:54:20.904Z" }, - { url = "https://files.pythonhosted.org/packages/92/94/bc5c3b573b40a328c4d141c20e399039ada95e5e2a661df3425c5165fd84/mmh3-5.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0cc21533878e5586b80d74c281d7f8da7932bc8ace50b8d5f6dbf7e3935f63f1", size = 56087, upload-time = "2026-03-05T15:54:21.92Z" }, - { url = "https://files.pythonhosted.org/packages/f6/80/64a02cc3e95c3af0aaa2590849d9ed24a9f14bb93537addde688e039b7c3/mmh3-5.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4eda76074cfca2787c8cf1bec603eaebdddd8b061ad5502f85cddae998d54f00", size = 40500, upload-time = "2026-03-05T15:54:22.953Z" }, - { url = "https://files.pythonhosted.org/packages/8b/72/e6d6602ce18adf4ddcd0e48f2e13590cc92a536199e52109f46f259d3c46/mmh3-5.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:eee884572b06bbe8a2b54f424dbd996139442cf83c76478e1ec162512e0dd2c7", size = 40034, upload-time = "2026-03-05T15:54:23.943Z" }, - { url = "https://files.pythonhosted.org/packages/59/c2/bf4537a8e58e21886ef16477041238cab5095c836496e19fafc34b7445d2/mmh3-5.2.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0d0b7e803191db5f714d264044e06189c8ccd3219e936cc184f07106bd17fd7b", size = 97292, upload-time = "2026-03-05T15:54:25.335Z" }, - { url = "https://files.pythonhosted.org/packages/e5/e2/51ed62063b44d10b06d975ac87af287729eeb5e3ed9772f7584a17983e90/mmh3-5.2.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e6c219e375f6341d0959af814296372d265a8ca1af63825f65e2e87c618f006", size = 103274, upload-time = "2026-03-05T15:54:26.44Z" }, - { url = "https://files.pythonhosted.org/packages/75/ce/12a7524dca59eec92e5b31fdb13ede1e98eda277cf2b786cf73bfbc24e81/mmh3-5.2.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:26fb5b9c3946bf7f1daed7b37e0c03898a6f062149127570f8ede346390a0825", size = 106158, upload-time = "2026-03-05T15:54:28.578Z" }, - { url = "https://files.pythonhosted.org/packages/86/1f/d3ba6dd322d01ab5d44c46c8f0c38ab6bbbf9b5e20e666dfc05bf4a23604/mmh3-5.2.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3c38d142c706201db5b2345166eeef1e7740e3e2422b470b8ba5c8727a9b4c7a", size = 113005, upload-time = "2026-03-05T15:54:29.767Z" }, - { url = "https://files.pythonhosted.org/packages/b6/a9/15d6b6f913294ea41b44d901741298e3718e1cb89ee626b3694625826a43/mmh3-5.2.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50885073e2909251d4718634a191c49ae5f527e5e1736d738e365c3e8be8f22b", size = 120744, upload-time = "2026-03-05T15:54:30.931Z" }, - { url = "https://files.pythonhosted.org/packages/76/b3/70b73923fd0284c439860ff5c871b20210dfdbe9a6b9dd0ee6496d77f174/mmh3-5.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b3f99e1756fc48ad507b95e5d86f2fb21b3d495012ff13e6592ebac14033f166", size = 99111, upload-time = "2026-03-05T15:54:32.353Z" }, - { url = "https://files.pythonhosted.org/packages/dd/38/99f7f75cd27d10d8b899a1caafb9d531f3903e4d54d572220e3d8ac35e89/mmh3-5.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62815d2c67f2dd1be76a253d88af4e1da19aeaa1820146dec52cf8bee2958b16", size = 98623, upload-time = "2026-03-05T15:54:33.801Z" }, - { url = "https://files.pythonhosted.org/packages/fd/68/6e292c0853e204c44d2f03ea5f090be3317a0e2d9417ecb62c9eb27687df/mmh3-5.2.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8f767ba0911602ddef289404e33835a61168314ebd3c729833db2ed685824211", size = 106437, upload-time = "2026-03-05T15:54:35.177Z" }, - { url = "https://files.pythonhosted.org/packages/dd/c6/fedd7284c459cfb58721d461fcf5607a4c1f5d9ab195d113d51d10164d16/mmh3-5.2.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:67e41a497bac88cc1de96eeba56eeb933c39d54bc227352f8455aa87c4ca4000", size = 110002, upload-time = "2026-03-05T15:54:36.673Z" }, - { url = "https://files.pythonhosted.org/packages/3b/ac/ca8e0c19a34f5b71390171d2ff0b9f7f187550d66801a731bb68925126a4/mmh3-5.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d74a03fb57757ece25aa4b3c1c60157a1cece37a020542785f942e2f827eed5", size = 97507, upload-time = "2026-03-05T15:54:37.804Z" }, - { url = "https://files.pythonhosted.org/packages/df/94/6ebb9094cfc7ac5e7950776b9d13a66bb4a34f83814f32ba2abc9494fc68/mmh3-5.2.1-cp312-cp312-win32.whl", hash = "sha256:7374d6e3ef72afe49697ecd683f3da12f4fc06af2d75433d0580c6746d2fa025", size = 40773, upload-time = "2026-03-05T15:54:40.077Z" }, - { url = "https://files.pythonhosted.org/packages/5b/3c/cd3527198cf159495966551c84a5f36805a10ac17b294f41f67b83f6a4d6/mmh3-5.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:3a9fed49c6ce4ed7e73f13182760c65c816da006debe67f37635580dfb0fae00", size = 41560, upload-time = "2026-03-05T15:54:41.148Z" }, - { url = "https://files.pythonhosted.org/packages/15/96/6fe5ebd0f970a076e3ed5512871ce7569447b962e96c125528a2f9724470/mmh3-5.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:bbfcb95d9a744e6e2827dfc66ad10e1020e0cac255eb7f85652832d5a264c2fc", size = 39313, upload-time = "2026-03-05T15:54:42.171Z" }, - { url = "https://files.pythonhosted.org/packages/25/a5/9daa0508a1569a54130f6198d5462a92deda870043624aa3ea72721aa765/mmh3-5.2.1-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:723b2681ed4cc07d3401bbea9c201ad4f2a4ca6ba8cddaff6789f715dd2b391e", size = 40832, upload-time = "2026-03-05T15:54:43.212Z" }, - { url = "https://files.pythonhosted.org/packages/0a/6b/3230c6d80c1f4b766dedf280a92c2241e99f87c1504ff74205ec8cebe451/mmh3-5.2.1-cp313-cp313-android_21_x86_64.whl", hash = "sha256:3619473a0e0d329fd4aec8075628f8f616be2da41605300696206d6f36920c3d", size = 41964, upload-time = "2026-03-05T15:54:44.204Z" }, - { url = "https://files.pythonhosted.org/packages/62/fb/648bfddb74a872004b6ee751551bfdda783fe6d70d2e9723bad84dbe5311/mmh3-5.2.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:e48d4dbe0f88e53081da605ae68644e5182752803bbc2beb228cca7f1c4454d6", size = 39114, upload-time = "2026-03-05T15:54:45.205Z" }, - { url = "https://files.pythonhosted.org/packages/95/c2/ab7901f87af438468b496728d11264cb397b3574d41506e71b92128e0373/mmh3-5.2.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a482ac121de6973897c92c2f31defc6bafb11c83825109275cffce54bb64933f", size = 39819, upload-time = "2026-03-05T15:54:46.509Z" }, - { url = "https://files.pythonhosted.org/packages/2f/ed/6f88dda0df67de1612f2e130ffea34cf84aaee5bff5b0aff4dbff2babe34/mmh3-5.2.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:17fbb47f0885ace8327ce1235d0416dc86a211dcd8cc1e703f41523be32cfec8", size = 40330, upload-time = "2026-03-05T15:54:47.864Z" }, - { url = "https://files.pythonhosted.org/packages/3d/66/7516d23f53cdf90f43fce24ab80c28f45e6851d78b46bef8c02084edf583/mmh3-5.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d51fde50a77f81330523562e3c2734ffdca9c4c9e9d355478117905e1cfe16c6", size = 56078, upload-time = "2026-03-05T15:54:48.9Z" }, - { url = "https://files.pythonhosted.org/packages/bc/34/4d152fdf4a91a132cb226b671f11c6b796eada9ab78080fb5ce1e95adaab/mmh3-5.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:19bbd3b841174ae6ed588536ab5e1b1fe83d046e668602c20266547298d939a9", size = 40498, upload-time = "2026-03-05T15:54:49.942Z" }, - { url = "https://files.pythonhosted.org/packages/d4/4c/8e3af1b6d85a299767ec97bd923f12b06267089c1472c27c1696870d1175/mmh3-5.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be77c402d5e882b6fbacfd90823f13da8e0a69658405a39a569c6b58fdb17b03", size = 40033, upload-time = "2026-03-05T15:54:50.994Z" }, - { url = "https://files.pythonhosted.org/packages/8b/f2/966ea560e32578d453c9e9db53d602cbb1d0da27317e232afa7c38ceba11/mmh3-5.2.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fd96476f04db5ceba1cfa0f21228f67c1f7402296f0e73fee3513aa680ad237b", size = 97320, upload-time = "2026-03-05T15:54:52.072Z" }, - { url = "https://files.pythonhosted.org/packages/bb/0d/2c5f9893b38aeb6b034d1a44ecd55a010148054f6a516abe53b5e4057297/mmh3-5.2.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:707151644085dd0f20fe4f4b573d28e5130c4aaa5f587e95b60989c5926653b5", size = 103299, upload-time = "2026-03-05T15:54:53.569Z" }, - { url = "https://files.pythonhosted.org/packages/1c/fc/2ebaef4a4d4376f89761274dc274035ffd96006ab496b4ee5af9b08f21a9/mmh3-5.2.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3737303ca9ea0f7cb83028781148fcda4f1dac7821db0c47672971dabcf63593", size = 106222, upload-time = "2026-03-05T15:54:55.092Z" }, - { url = "https://files.pythonhosted.org/packages/57/09/ea7ffe126d0ba0406622602a2d05e1e1a6841cc92fc322eb576c95b27fad/mmh3-5.2.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2778fed822d7db23ac5008b181441af0c869455b2e7d001f4019636ac31b6fe4", size = 113048, upload-time = "2026-03-05T15:54:56.305Z" }, - { url = "https://files.pythonhosted.org/packages/85/57/9447032edf93a64aa9bef4d9aa596400b1756f40411890f77a284f6293ca/mmh3-5.2.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d57dea657357230cc780e13920d7fa7db059d58fe721c80020f94476da4ca0a1", size = 120742, upload-time = "2026-03-05T15:54:57.453Z" }, - { url = "https://files.pythonhosted.org/packages/53/82/a86cc87cc88c92e9e1a598fee509f0409435b57879a6129bf3b3e40513c7/mmh3-5.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:169e0d178cb59314456ab30772429a802b25d13227088085b0d49b9fe1533104", size = 99132, upload-time = "2026-03-05T15:54:58.583Z" }, - { url = "https://files.pythonhosted.org/packages/54/f7/6b16eb1b40ee89bb740698735574536bc20d6cdafc65ae702ea235578e05/mmh3-5.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7e4e1f580033335c6f76d1e0d6b56baf009d1a64d6a4816347e4271ba951f46d", size = 98686, upload-time = "2026-03-05T15:55:00.078Z" }, - { url = "https://files.pythonhosted.org/packages/e8/88/a601e9f32ad1410f438a6d0544298ea621f989bd34a0731a7190f7dec799/mmh3-5.2.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:2bd9f19f7f1fcebd74e830f4af0f28adad4975d40d80620be19ffb2b2af56c9f", size = 106479, upload-time = "2026-03-05T15:55:01.532Z" }, - { url = "https://files.pythonhosted.org/packages/d6/5c/ce29ae3dfc4feec4007a437a1b7435fb9507532a25147602cd5b52be86db/mmh3-5.2.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c88653877aeb514c089d1b3d473451677b8b9a6d1497dbddf1ae7934518b06d2", size = 110030, upload-time = "2026-03-05T15:55:02.934Z" }, - { url = "https://files.pythonhosted.org/packages/13/30/ae444ef2ff87c805d525da4fa63d27cda4fe8a48e77003a036b8461cfd5c/mmh3-5.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fceef7fe67c81e1585198215e42ad3fdba3a25644beda8fbdaf85f4d7b93175a", size = 97536, upload-time = "2026-03-05T15:55:04.135Z" }, - { url = "https://files.pythonhosted.org/packages/4b/f9/dc3787ee5c813cc27fe79f45ad4500d9b5437f23a7402435cc34e07c7718/mmh3-5.2.1-cp313-cp313-win32.whl", hash = "sha256:54b64fb2433bc71488e7a449603bf8bd31fbcf9cb56fbe1eb6d459e90b86c37b", size = 40769, upload-time = "2026-03-05T15:55:05.277Z" }, - { url = "https://files.pythonhosted.org/packages/43/67/850e0b5a1e97799822ebfc4ca0e8c6ece3ed8baf7dcdf64de817dfdda2ca/mmh3-5.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:cae6383181f1e345317742d2ddd88f9e7d2682fa4c9432e3a74e47d92dce0229", size = 41563, upload-time = "2026-03-05T15:55:06.283Z" }, - { url = "https://files.pythonhosted.org/packages/c0/cc/98c90b28e1da5458e19fbfaf4adb5289208d3bfccd45dd14eab216a2f0bb/mmh3-5.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:022aa1a528604e6c83d0a7705fdef0b5355d897a9e0fa3a8d26709ceaa06965d", size = 39310, upload-time = "2026-03-05T15:55:07.323Z" }, - { url = "https://files.pythonhosted.org/packages/63/b4/65bc1fb2bb7f83e91c30865023b1847cf89a5f237165575e8c83aa536584/mmh3-5.2.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:d771f085fcdf4035786adfb1d8db026df1eb4b41dac1c3d070d1e49512843227", size = 40794, upload-time = "2026-03-05T15:55:09.773Z" }, - { url = "https://files.pythonhosted.org/packages/c4/86/7168b3d83be8eb553897b1fac9da8bbb06568e5cfe555ffc329ebb46f59d/mmh3-5.2.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:7f196cd7910d71e9d9860da0ff7a77f64d22c1ad931f1dd18559a06e03109fc0", size = 41923, upload-time = "2026-03-05T15:55:10.924Z" }, - { url = "https://files.pythonhosted.org/packages/bf/9b/b653ab611c9060ce8ff0ba25c0226757755725e789292f3ca138a58082cd/mmh3-5.2.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b1f12bd684887a0a5d55e6363ca87056f361e45451105012d329b86ec19dbe0b", size = 39131, upload-time = "2026-03-05T15:55:11.961Z" }, - { url = "https://files.pythonhosted.org/packages/9b/b4/5a2e0d34ab4d33543f01121e832395ea510132ea8e52cdf63926d9d81754/mmh3-5.2.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d106493a60dcb4aef35a0fac85105e150a11cf8bc2b0d388f5a33272d756c966", size = 39825, upload-time = "2026-03-05T15:55:13.013Z" }, - { url = "https://files.pythonhosted.org/packages/bd/69/81699a8f39a3f8d368bec6443435c0c392df0d200ad915bf0d222b588e03/mmh3-5.2.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:44983e45310ee5b9f73397350251cdf6e63a466406a105f1d16cb5baa659270b", size = 40344, upload-time = "2026-03-05T15:55:14.026Z" }, - { url = "https://files.pythonhosted.org/packages/0c/b3/71c8c775807606e8fd8acc5c69016e1caf3200d50b50b6dd4b40ce10b76c/mmh3-5.2.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:368625fb01666655985391dbad3860dc0ba7c0d6b9125819f3121ee7292b4ac8", size = 56291, upload-time = "2026-03-05T15:55:15.137Z" }, - { url = "https://files.pythonhosted.org/packages/6f/75/2c24517d4b2ce9e4917362d24f274d3d541346af764430249ddcc4cb3a08/mmh3-5.2.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:72d1cc63bcc91e14933f77d51b3df899d6a07d184ec515ea7f56bff659e124d7", size = 40575, upload-time = "2026-03-05T15:55:16.518Z" }, - { url = "https://files.pythonhosted.org/packages/bf/b9/e4a360164365ac9f07a25f0f7928e3a66eb9ecc989384060747aa170e6aa/mmh3-5.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e8b4b5580280b9265af3e0409974fb79c64cf7523632d03fbf11df18f8b0181e", size = 40052, upload-time = "2026-03-05T15:55:17.735Z" }, - { url = "https://files.pythonhosted.org/packages/97/ca/120d92223a7546131bbbc31c9174168ee7a73b1366f5463ffe69d9e691fe/mmh3-5.2.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4cbbde66f1183db040daede83dd86c06d663c5bb2af6de1142b7c8c37923dd74", size = 97311, upload-time = "2026-03-05T15:55:18.959Z" }, - { url = "https://files.pythonhosted.org/packages/b6/71/c1a60c1652b8813ef9de6d289784847355417ee0f2980bca002fe87f4ae5/mmh3-5.2.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8ff038d52ef6aa0f309feeba00c5095c9118d0abf787e8e8454d6048db2037fc", size = 103279, upload-time = "2026-03-05T15:55:20.448Z" }, - { url = "https://files.pythonhosted.org/packages/48/29/ad97f4be1509cdcb28ae32c15593ce7c415db47ace37f8fad35b493faa9a/mmh3-5.2.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4130d0b9ce5fad6af07421b1aecc7e079519f70d6c05729ab871794eded8617", size = 106290, upload-time = "2026-03-05T15:55:21.6Z" }, - { url = "https://files.pythonhosted.org/packages/77/29/1f86d22e281bd8827ba373600a4a8b0c0eae5ca6aa55b9a8c26d2a34decc/mmh3-5.2.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6e0bfe77d238308839699944164b96a2eeccaf55f2af400f54dc20669d8d5f2", size = 113116, upload-time = "2026-03-05T15:55:22.826Z" }, - { url = "https://files.pythonhosted.org/packages/a7/7c/339971ea7ed4c12d98f421f13db3ea576a9114082ccb59d2d1a0f00ccac1/mmh3-5.2.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f963eafc0a77a6c0562397da004f5876a9bcf7265a7bcc3205e29636bc4a1312", size = 120740, upload-time = "2026-03-05T15:55:24.3Z" }, - { url = "https://files.pythonhosted.org/packages/e4/92/3c7c4bdb8e926bb3c972d1e2907d77960c1c4b250b41e8366cf20c6e4373/mmh3-5.2.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:92883836caf50d5255be03d988d75bc93e3f86ba247b7ca137347c323f731deb", size = 99143, upload-time = "2026-03-05T15:55:25.456Z" }, - { url = "https://files.pythonhosted.org/packages/df/0a/33dd8706e732458c8375eae63c981292de07a406bad4ec03e5269654aa2c/mmh3-5.2.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:57b52603e89355ff318025dd55158f6e71396c0f1f609d548e9ea9c94cc6ce0a", size = 98703, upload-time = "2026-03-05T15:55:26.723Z" }, - { url = "https://files.pythonhosted.org/packages/51/04/76bbce05df76cbc3d396f13b2ea5b1578ef02b6a5187e132c6c33f99d596/mmh3-5.2.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f40a95186a72fa0b67d15fef0f157bfcda00b4f59c8a07cbe5530d41ac35d105", size = 106484, upload-time = "2026-03-05T15:55:28.214Z" }, - { url = "https://files.pythonhosted.org/packages/d3/8f/c6e204a2c70b719c1f62ffd9da27aef2dddcba875ea9c31ca0e87b975a46/mmh3-5.2.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:58370d05d033ee97224c81263af123dea3d931025030fd34b61227a768a8858a", size = 110012, upload-time = "2026-03-05T15:55:29.532Z" }, - { url = "https://files.pythonhosted.org/packages/e3/37/7181efd8e39db386c1ebc3e6b7d1f702a09d7c1197a6f2742ed6b5c16597/mmh3-5.2.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7be6dfb49e48fd0a7d91ff758a2b51336f1cd21f9d44b20f6801f072bd080cdd", size = 97508, upload-time = "2026-03-05T15:55:31.01Z" }, - { url = "https://files.pythonhosted.org/packages/42/0f/afa7ca2615fd85e1469474bb860e381443d0b868c083b62b41cb1d7ca32f/mmh3-5.2.1-cp314-cp314-win32.whl", hash = "sha256:54fe8518abe06a4c3852754bfd498b30cc58e667f376c513eac89a244ce781a4", size = 41387, upload-time = "2026-03-05T15:55:32.403Z" }, - { url = "https://files.pythonhosted.org/packages/71/0d/46d42a260ee1357db3d486e6c7a692e303c017968e14865e00efa10d09fc/mmh3-5.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:3f796b535008708846044c43302719c6956f39ca2d93f2edda5319e79a29efbb", size = 42101, upload-time = "2026-03-05T15:55:33.646Z" }, - { url = "https://files.pythonhosted.org/packages/a4/7b/848a8378059d96501a41159fca90d6a99e89736b0afbe8e8edffeac8c74b/mmh3-5.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:cd471ede0d802dd936b6fab28188302b2d497f68436025857ca72cd3810423fe", size = 39836, upload-time = "2026-03-05T15:55:35.026Z" }, - { url = "https://files.pythonhosted.org/packages/27/61/1dabea76c011ba8547c25d30c91c0ec22544487a8750997a27a0c9e1180b/mmh3-5.2.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:5174a697ce042fa77c407e05efe41e03aa56dae9ec67388055820fb48cf4c3ba", size = 57727, upload-time = "2026-03-05T15:55:36.162Z" }, - { url = "https://files.pythonhosted.org/packages/b7/32/731185950d1cf2d5e28979cc8593016ba1619a295faba10dda664a4931b5/mmh3-5.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0a3984146e414684a6be2862d84fcb1035f4984851cb81b26d933bab6119bf00", size = 41308, upload-time = "2026-03-05T15:55:37.254Z" }, - { url = "https://files.pythonhosted.org/packages/76/aa/66c76801c24b8c9418b4edde9b5e57c75e72c94e29c48f707e3962534f18/mmh3-5.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bd6e7d363aa93bd3421b30b6af97064daf47bc96005bddba67c5ffbc6df426b8", size = 40758, upload-time = "2026-03-05T15:55:38.61Z" }, - { url = "https://files.pythonhosted.org/packages/9e/bb/79a1f638a02f0ae389f706d13891e2fbf7d8c0a22ecde67ba828951bb60a/mmh3-5.2.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:113f78e7463a36dbbcea05bfe688efd7fa759d0f0c56e73c974d60dcfec3dfcc", size = 109670, upload-time = "2026-03-05T15:55:40.13Z" }, - { url = "https://files.pythonhosted.org/packages/26/94/8cd0e187a288985bcfc79bf5144d1d712df9dee74365f59d26e3a1865be6/mmh3-5.2.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7e8ec5f606e0809426d2440e0683509fb605a8820a21ebd120dcdba61b74ef7f", size = 117399, upload-time = "2026-03-05T15:55:42.076Z" }, - { url = "https://files.pythonhosted.org/packages/42/94/dfea6059bd5c5beda565f58a4096e43f4858fb6d2862806b8bbd12cbb284/mmh3-5.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22b0f9971ec4e07e8223f2beebe96a6cfc779d940b6f27d26604040dd74d3a44", size = 120386, upload-time = "2026-03-05T15:55:43.481Z" }, - { url = "https://files.pythonhosted.org/packages/47/cb/f9c45e62aaa67220179f487772461d891bb582bb2f9783c944832c60efd9/mmh3-5.2.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:85ffc9920ffc39c5eee1e3ac9100c913a0973996fbad5111f939bbda49204bb7", size = 125924, upload-time = "2026-03-05T15:55:44.638Z" }, - { url = "https://files.pythonhosted.org/packages/a5/83/fe54a4a7c11bc9f623dfc1707decd034245602b076dfc1dcc771a4163170/mmh3-5.2.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7aec798c2b01aaa65a55f1124f3405804184373abb318a3091325aece235f67c", size = 135280, upload-time = "2026-03-05T15:55:45.866Z" }, - { url = "https://files.pythonhosted.org/packages/97/67/fe7e9e9c143daddd210cd22aef89cbc425d58ecf238d2b7d9eb0da974105/mmh3-5.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:55dbbd8ffbc40d1697d5e2d0375b08599dae8746b0b08dea05eee4ce81648fac", size = 110050, upload-time = "2026-03-05T15:55:47.074Z" }, - { url = "https://files.pythonhosted.org/packages/43/c4/6d4b09fcbef80794de447c9378e39eefc047156b290fa3dd2d5257ca8227/mmh3-5.2.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:6c85c38a279ca9295a69b9b088a2e48aa49737bb1b34e6a9dc6297c110e8d912", size = 111158, upload-time = "2026-03-05T15:55:48.239Z" }, - { url = "https://files.pythonhosted.org/packages/81/a6/ca51c864bdb30524beb055a6d8826db3906af0834ec8c41d097a6e8573d5/mmh3-5.2.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:6290289fa5fb4c70fd7f72016e03633d60388185483ff3b162912c81205ae2cf", size = 116890, upload-time = "2026-03-05T15:55:49.405Z" }, - { url = "https://files.pythonhosted.org/packages/cc/04/5a1fe2e2ad843d03e89af25238cbc4f6840a8bb6c4329a98ab694c71deda/mmh3-5.2.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:4fc6cd65dc4d2fdb2625e288939a3566e36127a84811a4913f02f3d5931da52d", size = 123121, upload-time = "2026-03-05T15:55:50.61Z" }, - { url = "https://files.pythonhosted.org/packages/af/4d/3c820c6f4897afd25905270a9f2330a23f77a207ea7356f7aadace7273c0/mmh3-5.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:623f938f6a039536cc02b7582a07a080f13fdfd48f87e63201d92d7e34d09a18", size = 110187, upload-time = "2026-03-05T15:55:52.143Z" }, - { url = "https://files.pythonhosted.org/packages/21/54/1d71cd143752361c0aebef16ad3f55926a6faf7b112d355745c1f8a25f7f/mmh3-5.2.1-cp314-cp314t-win32.whl", hash = "sha256:29bc3973676ae334412efdd367fcd11d036b7be3efc1ce2407ef8676dabfeb82", size = 41934, upload-time = "2026-03-05T15:55:53.564Z" }, - { url = "https://files.pythonhosted.org/packages/9d/e4/63a2a88f31d93dea03947cccc2a076946857e799ea4f7acdecbf43b324aa/mmh3-5.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:28cfab66577000b9505a0d068c731aee7ca85cd26d4d63881fab17857e0fe1fb", size = 43036, upload-time = "2026-03-05T15:55:55.252Z" }, - { url = "https://files.pythonhosted.org/packages/a0/0f/59204bf136d1201f8d7884cfbaf7498c5b4674e87a4c693f9bde63741ce1/mmh3-5.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:dfd51b4c56b673dfbc43d7d27ef857dd91124801e2806c69bb45585ce0fa019b", size = 40391, upload-time = "2026-03-05T15:55:56.697Z" }, -] - [[package]] name = "more-itertools" version = "11.1.0" @@ -3619,51 +2875,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/29/59/3e7118ed140f76b0982ba4321bdaed1997a0473f9720de2d10788a577033/opentelemetry_api-1.41.1-py3-none-any.whl", hash = "sha256:a22df900e75c76dc08440710e51f52f1aa6b451b429298896023e60db5b3139f", size = 69007, upload-time = "2026-04-24T13:15:15.662Z" }, ] -[[package]] -name = "opentelemetry-exporter-gcp-logging" -version = "1.12.0a0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-cloud-logging" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-resourcedetector-gcp" }, - { name = "opentelemetry-sdk" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/77/e4/95ecebaa1c5134adaa0d0374028b25e3b3c5c08535d29a66d39d372a3d11/opentelemetry_exporter_gcp_logging-1.12.0a0.tar.gz", hash = "sha256:586529dbbcae5e22b880f7c121fde3f0fe8ae997aba1bad53f13c20eeb27cb3a", size = 22521, upload-time = "2026-04-28T20:59:40.237Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/55/93/3a0a9a62db0b90029a8160774e791044c0566aa94d5160ce7bbce8abf242/opentelemetry_exporter_gcp_logging-1.12.0a0-py3-none-any.whl", hash = "sha256:2aca9b01b3248c2fa95d38d01aa71aca8e22f640c44dba36ca6b883930762971", size = 14207, upload-time = "2026-04-28T20:59:35.109Z" }, -] - -[[package]] -name = "opentelemetry-exporter-gcp-monitoring" -version = "1.12.0a0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-cloud-monitoring" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-resourcedetector-gcp" }, - { name = "opentelemetry-sdk" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ff/5d/f82b2858d00be6f91b917dc67ccf71688fa822448b2d26ace69b809f5835/opentelemetry_exporter_gcp_monitoring-1.12.0a0.tar.gz", hash = "sha256:2b285078cddd4af78a363a55b5478e89f7df6f15bba9139d3f484099e534df4c", size = 20839, upload-time = "2026-04-28T20:59:40.982Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ae/b5/1623886d049095bb5abcec0cd67a0e40c00ff1672a25f82ed9867f88c1e7/opentelemetry_exporter_gcp_monitoring-1.12.0a0-py3-none-any.whl", hash = "sha256:1a7daf8c9350d55010fa33d2c2f646655a03a81d0d8073a2ae0e066791d6177d", size = 13608, upload-time = "2026-04-28T20:59:36.315Z" }, -] - -[[package]] -name = "opentelemetry-exporter-gcp-trace" -version = "1.12.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "google-cloud-trace" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-resourcedetector-gcp" }, - { name = "opentelemetry-sdk" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/bf/55/32922e72d88421505383dfdba9c1ee6ad67253f94f2358f6e9dbc4ac3749/opentelemetry_exporter_gcp_trace-1.12.0.tar.gz", hash = "sha256:18c6e56fe123eed020d5005fdd819b196d64f651545bce1ca7e2e2cbaf9d343b", size = 18779, upload-time = "2026-04-28T20:59:41.974Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/68/c60e79992918eecb6de167e782c86946fdd5492bb163fe320f1a18959c3d/opentelemetry_exporter_gcp_trace-1.12.0-py3-none-any.whl", hash = "sha256:1538dab654bcb25e757ed34c94f27a2e30d90dc7deb3630f8d46d1111fcb3bad", size = 14013, upload-time = "2026-04-28T20:59:37.518Z" }, -] - [[package]] name = "opentelemetry-exporter-otlp-proto-common" version = "1.41.1" @@ -3694,24 +2905,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ac/f2/c54f33c92443d087703e57e52e55f22f111373a5c4c4aa349ea60efe512e/opentelemetry_exporter_otlp_proto_grpc-1.41.1-py3-none-any.whl", hash = "sha256:537926dcef951136992479af1d9cd88f25e33d56c530e9f020ed57774dca2f94", size = 20297, upload-time = "2026-04-24T13:15:20.212Z" }, ] -[[package]] -name = "opentelemetry-exporter-otlp-proto-http" -version = "1.41.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "googleapis-common-protos" }, - { name = "opentelemetry-api" }, - { name = "opentelemetry-exporter-otlp-proto-common" }, - { name = "opentelemetry-proto" }, - { name = "opentelemetry-sdk" }, - { name = "requests" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/33/5b/9d3c7f70cca10136ba82a81e738dee626c8e7fc61c6887ea9a58bf34c606/opentelemetry_exporter_otlp_proto_http-1.41.1.tar.gz", hash = "sha256:4747a9604c8550ab38c6fd6180e2fcb80de3267060bef2c306bad3cb443302bc", size = 24139, upload-time = "2026-04-24T13:15:42.977Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ba/4d/ef07ff2fc630849f2080ae0ae73a61f67257905b7ac79066640bfa0c5739/opentelemetry_exporter_otlp_proto_http-1.41.1-py3-none-any.whl", hash = "sha256:1a21e8f49c7a946d935551e90947d6c3eb39236723c6624401da0f33d68edcb4", size = 22673, upload-time = "2026-04-24T13:15:21.313Z" }, -] - [[package]] name = "opentelemetry-instrumentation" version = "0.62b1" @@ -3753,21 +2946,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e4/1e/5cd77035e3e82070e2265a63a760f715aacd3cb16dddc7efee913f297fcc/opentelemetry_proto-1.41.1-py3-none-any.whl", hash = "sha256:0496713b804d127a4147e32849fbaf5683fac8ee98550e8e7679cd706c289720", size = 72076, upload-time = "2026-04-24T13:15:32.542Z" }, ] -[[package]] -name = "opentelemetry-resourcedetector-gcp" -version = "1.12.0a0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "opentelemetry-api" }, - { name = "opentelemetry-sdk" }, - { name = "requests" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/21/ae/b62c5e986c9c7f908a15682ea173bcfcdc00403c0c85243ccbd30eca7fc2/opentelemetry_resourcedetector_gcp-1.12.0a0.tar.gz", hash = "sha256:d5e3f78283a272eb92547e00bbeff45b7332a34ae791a70ab4eba81af9bc3baf", size = 18797, upload-time = "2026-04-28T20:59:43.195Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/df/84/9db2999adbc41505af3e6717e8d958746778cbfc9e07ed9c670bf9d1e6db/opentelemetry_resourcedetector_gcp-1.12.0a0-py3-none-any.whl", hash = "sha256:e803688d14e2969fe816077be81f7b034368314d485863f12ce49daba7c81919", size = 18798, upload-time = "2026-04-28T20:59:39.257Z" }, -] - [[package]] name = "opentelemetry-sdk" version = "1.41.1" @@ -4236,18 +3414,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, ] -[[package]] -name = "proto-plus" -version = "1.28.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "protobuf" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c9/56/e647b0c675392d2da368da7b6f158f7368b18542fd6f7d7400a2f39de000/proto_plus-1.28.0.tar.gz", hash = "sha256:38e5696342835b08fc116f30a25665b29531cda9d5d5643e9b81fc312385abd9", size = 57221, upload-time = "2026-05-07T08:04:50.811Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/20/b122d4626976acb81132036d2ad1bb35a1a8775fceb837ec30964622516a/proto_plus-1.28.0-py3-none-any.whl", hash = "sha256:a630604310899e73c59ec302e5765c058d412b2f090b9c79c8822589f14955b8", size = 50410, upload-time = "2026-05-07T08:03:31.962Z" }, -] - [[package]] name = "protobuf" version = "6.33.6" @@ -4286,63 +3452,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c9/33/a7cbfccc39056a5cf8126b7aab4c8bafbedd4f0ca68ae40ecb627a2d2cd3/py_partiql_parser-0.6.3-py2.py3-none-any.whl", hash = "sha256:deb0769c3346179d2f590dcbde556f708cdb929059fb654bad75f4cf6e07f582", size = 23752, upload-time = "2025-10-18T13:56:12.256Z" }, ] -[[package]] -name = "pyarrow" -version = "24.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a5/bf/a34fee1d624152124fa8355c42f34195ad5fe5233ce5bb87946432047d52/pyarrow-24.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:7c2b98645d576a0b9616892ead22b64a83a5f043c5e2ca15ebcefcb5b70c80cb", size = 35076681, upload-time = "2026-04-21T08:51:46.845Z" }, - { url = "https://files.pythonhosted.org/packages/1d/41/64180033d7027afce12dc96d0fe1f504c6fa112190582b458acea2399530/pyarrow-24.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:644a246325b8c69c595ad1dd4b463eba4b0cdb731370e4a86137d433208d6147", size = 36684260, upload-time = "2026-04-21T08:51:53.642Z" }, - { url = "https://files.pythonhosted.org/packages/57/02/9b9320e673dd8a99411fac78690f3df92f6dd6f59754c750110bca66d64e/pyarrow-24.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:3a577bd840ca83f646f0a625dbc571dba7044c43c2d1503afc378b570954345c", size = 45698566, upload-time = "2026-04-21T10:46:02.133Z" }, - { url = "https://files.pythonhosted.org/packages/67/33/f75e91b9a64c3f33c787e263c93b871ad91b8a4a68c1d5cebddd9840e835/pyarrow-24.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:e3268e43984d0b1a185c89b4cfff282a7ead12fc93f56cfd7088bdbcbe727041", size = 48835562, upload-time = "2026-04-21T10:46:10.278Z" }, - { url = "https://files.pythonhosted.org/packages/a5/63/097510448e47e4091faa41c43ba92f97cecaab8f4535b56a3d149578f634/pyarrow-24.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2392d954fcb920f42d230284b677605e4e2fbb11f2821e823e642abd67fbb491", size = 49394997, upload-time = "2026-04-21T10:46:18.08Z" }, - { url = "https://files.pythonhosted.org/packages/60/6b/c047d6222ab279024a062742d1807e2fbaf27bba88a98637299ff47b9236/pyarrow-24.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bec9373df11544592b0ba7ec2af0e35059e5f0e7647c6183a854dedd193298f1", size = 51911424, upload-time = "2026-04-21T10:46:25.347Z" }, - { url = "https://files.pythonhosted.org/packages/3a/ba/464cc70761c2a525d97ebd84e21c31ebd47f3ef4bdcee117009f51c46f24/pyarrow-24.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:c42ab9439498270139cc63e18847a02afe5c8b3ed9c931266533cfe378bd3591", size = 27251730, upload-time = "2026-04-21T10:46:30.913Z" }, - { url = "https://files.pythonhosted.org/packages/62/c9/a47ab7ece0d86cbe6678418a0fbd1ac4bb493b9184a3891dfa0e7f287ae0/pyarrow-24.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:b0e131f880cda8d04e076cee175a46fc0e8bc8b65c99c6c09dff6669335fde74", size = 35068898, upload-time = "2026-04-21T10:46:36.599Z" }, - { url = "https://files.pythonhosted.org/packages/d1/bc/8db86617a9a58008acf8913d6fed68ea2a46acb6de928db28d724c891a68/pyarrow-24.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:1b2fe7f9a5566401a0ef2571f197eb92358925c1f0c8dba305d6e43ea0871bb3", size = 36679915, upload-time = "2026-04-21T10:46:42.602Z" }, - { url = "https://files.pythonhosted.org/packages/eb/8e/fb178720400ef69db251eb4a9c3ccf4af269bc1feb5055529b8fc87170d1/pyarrow-24.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:0b3537c00fb8d384f15ac1e79b6eb6db04a16514c8c1d22e59a9b95c8ba42868", size = 45697931, upload-time = "2026-04-21T10:46:48.403Z" }, - { url = "https://files.pythonhosted.org/packages/f3/27/99c42abe8e21b44f4917f62631f3aa31404882a2c41d8a4cd5c110e13d52/pyarrow-24.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:14e31a3c9e35f1ab6356c6378f6f72830e6d2d5f1791df3774a7b097d18a6a1e", size = 48837449, upload-time = "2026-04-21T10:46:55.329Z" }, - { url = "https://files.pythonhosted.org/packages/36/b6/333749e2666e9032891125bf9c691146e92901bece62030ac1430e2e7c88/pyarrow-24.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7d9a514e73bc42711e6a35aaccf3587c520024fe0a25d830a1a8a27c15f4f57", size = 49395949, upload-time = "2026-04-21T10:47:01.869Z" }, - { url = "https://files.pythonhosted.org/packages/17/25/c5201706a2dd374e8ba6ee3fd7a8c89fb7ffc16eed5217a91fd2bd7f7626/pyarrow-24.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b196eb3f931862af3fa84c2a253514d859c08e0d8fe020e07be12e75a5a9780c", size = 51912986, upload-time = "2026-04-21T10:47:09.872Z" }, - { url = "https://files.pythonhosted.org/packages/f8/d2/4d1bbba65320b21a49678d6fbdc6ff7c649251359fdcfc03568c4136231d/pyarrow-24.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:35405aecb474e683fb36af650618fd5340ee5471fc65a21b36076a18bbc6c981", size = 27255371, upload-time = "2026-04-21T10:47:15.943Z" }, - { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" }, - { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" }, - { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" }, - { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" }, - { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" }, - { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" }, - { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" }, - { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" }, - { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" }, - { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" }, - { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" }, - { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" }, - { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" }, - { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" }, - { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" }, - { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" }, - { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" }, - { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" }, - { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" }, - { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" }, - { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" }, - { url = "https://files.pythonhosted.org/packages/ad/80/d022a34ff05d2cbedd8ccf841fc1f532ecfa9eb5ed1711b56d0e0ea71fc9/pyarrow-24.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:1cc9057f0319e26333b357e17f3c2c022f1a83739b48a88b25bfd5fa2dc18838", size = 35007997, upload-time = "2026-04-21T10:49:48.796Z" }, - { url = "https://files.pythonhosted.org/packages/1a/ff/f01485fda6f4e5d441afb8dd5e7681e4db18826c1e271852f5d3957d6a80/pyarrow-24.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e6f1278ee4785b6db21229374a1c9e54ec7c549de5d1efc9630b6207de7e170b", size = 36678720, upload-time = "2026-04-21T10:49:55.858Z" }, - { url = "https://files.pythonhosted.org/packages/9e/c2/2d2d5fea814237923f71b36495211f20b43a1576f9a4d6da7e751a64ec6f/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:adbbedc55506cbdabb830890444fb856bfb0060c46c6f8026c6c2f2cf86ae795", size = 45741852, upload-time = "2026-04-21T10:50:04.624Z" }, - { url = "https://files.pythonhosted.org/packages/8e/3a/28ba9c1c1ebdbb5f1b94dfebb46f207e52e6a554b7fe4132540fde29a3a0/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae8a1145af31d903fa9bb166824d7abe9b4681a000b0159c9fb99c11bc11ad26", size = 48889852, upload-time = "2026-04-21T10:50:12.293Z" }, - { url = "https://files.pythonhosted.org/packages/df/51/4a389acfd31dca009f8fb82d7f510bb4130f2b3a8e18cf00194d0687d8ac/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d7027eba1df3b2069e2e8d80f644fa0918b68c46432af3d088ddd390d063ecde", size = 49445207, upload-time = "2026-04-21T10:50:20.677Z" }, - { url = "https://files.pythonhosted.org/packages/19/4b/0bab2b23d2ae901b1b9a03c0efd4b2d070256f8ce3fc43f6e58c167b2081/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56a1ffe9bf7b727432b89104cc0849c21582949dd7bdcb34f17b2001a351a76", size = 51954117, upload-time = "2026-04-21T10:50:29.14Z" }, - { url = "https://files.pythonhosted.org/packages/29/88/f4e9145da0417b3d2c12035a8492b35ff4a3dbc653e614fcfb51d9dedb38/pyarrow-24.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:38be1808cdd068605b787e6ca9119b27eb275a0234e50212c3492331680c3b1e", size = 28001155, upload-time = "2026-04-21T10:51:22.337Z" }, - { url = "https://files.pythonhosted.org/packages/79/4f/46a49a63f43526da895b1a45bbb51d5baf8e4d77159f8528fc3e5490007f/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:418e48ce50a45a6a6c73c454677203a9c75c966cb1e92ca3370959185f197a05", size = 35250387, upload-time = "2026-04-21T10:50:35.552Z" }, - { url = "https://files.pythonhosted.org/packages/a0/da/d5e0cd5ef00796922404806d5f00325cdadc3441ce2c13fe7115f2df9a64/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:2f16197705a230a78270cdd4ea8a1d57e86b2fdcbc34a1f6aebc72e65c986f9a", size = 36797102, upload-time = "2026-04-21T10:50:42.417Z" }, - { url = "https://files.pythonhosted.org/packages/34/c7/5904145b0a593a05236c882933d439b5720f0a145381179063722fbfc123/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:fb24ac194bfc5e86839d7dcd52092ee31e5fe6733fe11f5e3b06ef0812b20072", size = 45745118, upload-time = "2026-04-21T10:50:49.324Z" }, - { url = "https://files.pythonhosted.org/packages/13/d3/cca42fe166d1c6e4d5b80e530b7949104d10e17508a90ae202dac205ce2a/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9700ebd9a51f5895ce75ff4ac4b3c47a7d4b42bc618be8e713e5d56bacf5f931", size = 48844765, upload-time = "2026-04-21T10:50:55.579Z" }, - { url = "https://files.pythonhosted.org/packages/b0/49/942c3b79878ba928324d1e17c274ed84581db8c0a749b24bcf4cbdf15bd3/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d8ddd2768da81d3ee08cfea9b597f4abb4e8e1dc8ae7e204b608d23a0d3ab699", size = 49471890, upload-time = "2026-04-21T10:51:02.439Z" }, - { url = "https://files.pythonhosted.org/packages/76/97/ff71431000a75d84135a1ace5ca4ba11726a231a8007bbb320a4c54075d5/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:61a3d7eaa97a14768b542f3d284dc6400dd2470d9f080708b13cd46b6ae18136", size = 51932250, upload-time = "2026-04-21T10:51:10.576Z" }, - { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" }, -] - [[package]] name = "pyasn1" version = "0.6.3" @@ -5464,84 +4573,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/5e/f5/0c41cb68dcae6b7de4fac4188a3a9589e21fb31df21ea3a2e888db95e6c9/soupsieve-2.8.4-py3-none-any.whl", hash = "sha256:e7e6b0769c8f51ed59acab6e994b00621096cfb1c640a7509295987388fbaf65", size = 37304, upload-time = "2026-05-24T13:55:55.406Z" }, ] -[[package]] -name = "sqlalchemy" -version = "2.0.51" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/02/f1/a7a892f18d4d224e6b26f706531eafccc41e37594d37d304786969ee13cb/sqlalchemy-2.0.51.tar.gz", hash = "sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9", size = 9912201, upload-time = "2026-06-15T15:41:20.012Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/71/76/b3ea1d8842e7b62c718a88d302809003d65ed82011460ca48907dde658c4/sqlalchemy-2.0.51-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e8203d2fbd5c6254692ef0a72c740d75b2f3c7ca345404f4c1a4604813c77c0", size = 2162087, upload-time = "2026-06-15T16:05:15.795Z" }, - { url = "https://files.pythonhosted.org/packages/6c/22/f19552eb7876774d50cfd025337ef5d67acc10cd8f29adab7716cf47c352/sqlalchemy-2.0.51-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1af05726b3d0cdba1c55284bf408fd3b792e690fe2399bfb8304565551cda652", size = 3244579, upload-time = "2026-06-15T16:10:36.165Z" }, - { url = "https://files.pythonhosted.org/packages/fc/97/e4a2eb5a8ec5cd3c2a0615a2f15f0afca89ac039229599b9ed0c0ed28e5e/sqlalchemy-2.0.51-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e54ff2dd657f2e3e0fbf2b097db1182f7bfea263eca4353f00065bae2a67c3d", size = 3243515, upload-time = "2026-06-15T16:12:22.627Z" }, - { url = "https://files.pythonhosted.org/packages/74/c6/5900ec624fab3360aa2ec59b99bb2046dd79799e310bb78a0514eaa4038e/sqlalchemy-2.0.51-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1e47b1199c2e832e325eacabc8d32d2487f58c9358f97e9a00f5eb93c5680d84", size = 3195492, upload-time = "2026-06-15T16:10:38.097Z" }, - { url = "https://files.pythonhosted.org/packages/8f/41/2ee3c4e1ac4fd22309349823fe13f33febeab1a71db1d7e9d60293a07dcb/sqlalchemy-2.0.51-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c68568f3facf8f66fa76c60e0ced69b67666ffa9941d1d0a3756fda196049080", size = 3215782, upload-time = "2026-06-15T16:12:24.051Z" }, - { url = "https://files.pythonhosted.org/packages/ce/1c/3bd72c341f1cb5faed5a7457ea840228a46be51cfbaf31a9db72fc963f11/sqlalchemy-2.0.51-cp310-cp310-win32.whl", hash = "sha256:0592bdadf86ddcabfd72d9ab66ea8a5d8d2cc6be1cc51fa7e66c03868ac5eac1", size = 2122119, upload-time = "2026-06-15T16:13:26.915Z" }, - { url = "https://files.pythonhosted.org/packages/2a/63/b6dfdd646abf91c3bedb13727226a5e765e5f8365e898d43818e6672fa46/sqlalchemy-2.0.51-cp310-cp310-win_amd64.whl", hash = "sha256:740cf6f35351b1ac3d82369152acf1d51d37e3dcf85d4dc0a22ca01410eabe2a", size = 2145158, upload-time = "2026-06-15T16:13:28.386Z" }, - { url = "https://files.pythonhosted.org/packages/3a/69/a67c69e5f28fc9c99d6f7bd60bd50e91f2fed2423e3b30fb228fa00e51f3/sqlalchemy-2.0.51-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1aa10c0daee6705294d181daadaa793221e1a59ed55000a3fab1d42b088ce4ba", size = 2161838, upload-time = "2026-06-15T16:05:17.144Z" }, - { url = "https://files.pythonhosted.org/packages/9a/a4/c8c22b8438bddc0a030157c6ec0f6ef97b3c38effa444bdab2a27af04090/sqlalchemy-2.0.51-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5b2ed6d828f1f09bd812861f4f59ca3bc3803f9df871f4555187f0faf018604", size = 3319402, upload-time = "2026-06-15T16:10:40.002Z" }, - { url = "https://files.pythonhosted.org/packages/90/54/44012d32fd77d991256d2ff793ba3807c51d40cb27a85b4796224f6744df/sqlalchemy-2.0.51-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:436728ce18a80f6951a1e11cc6112c2ede9faf20766f1a26195a7c441ca12dbd", size = 3319675, upload-time = "2026-06-15T16:12:25.658Z" }, - { url = "https://files.pythonhosted.org/packages/29/a5/de0592acaf5906cd7430874392d6f7e8b4a7c8437610953ee2d1501c0b44/sqlalchemy-2.0.51-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dc261707bf5739aea8a541593f3cc1d463c2701fb05fbcbba0ce031b69a21260", size = 3270777, upload-time = "2026-06-15T16:10:42.125Z" }, - { url = "https://files.pythonhosted.org/packages/cb/14/a44c90739c780b362238e4ac3cb19dd0ca40d13e6ddc5daa112166ddab4f/sqlalchemy-2.0.51-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a6d26094615306d116dd5e4a51b0304c99dd2356fc569eed6922a80a6bd3b265", size = 3293940, upload-time = "2026-06-15T16:12:27.156Z" }, - { url = "https://files.pythonhosted.org/packages/65/eb/fbd0f206a330e66f8c602a99c37c4e731f107faed62954b41b01f16dd9d9/sqlalchemy-2.0.51-cp311-cp311-win32.whl", hash = "sha256:ca8435d13829b92f4a97362d91975154a4015db3a2634154e1754e9a915e6b86", size = 2121183, upload-time = "2026-06-15T16:13:29.905Z" }, - { url = "https://files.pythonhosted.org/packages/ad/fd/005bf80f3cf6e5c62b5dd68616280f51cd012c60840fa74781b3ed7b1623/sqlalchemy-2.0.51-cp311-cp311-win_amd64.whl", hash = "sha256:4a011ea4510683319ce4ed274b56ee05194b39b6da9d09ca7a39388f0fa84dcc", size = 2145796, upload-time = "2026-06-15T16:13:31.283Z" }, - { url = "https://files.pythonhosted.org/packages/d5/70/e868bc5412acd101a8280f25c95f10eeae0771c4eb806b02491142810ee8/sqlalchemy-2.0.51-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d78702b26ba1c18b2d0fb2ea940ba7f17a9581b42e8361ff93920ebbee1235a", size = 2160291, upload-time = "2026-06-15T16:08:48.918Z" }, - { url = "https://files.pythonhosted.org/packages/e5/1c/71ee0f8a6b9d7316a1ccd30430b4c62b6c2e36adc96017a4e3a72dce49d6/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581921d849d6e6f994d560389192955e80e2950e18fcdfe2ccea863e01158e6e", size = 3343835, upload-time = "2026-06-15T16:19:42.613Z" }, - { url = "https://files.pythonhosted.org/packages/2b/7c/7ab9f9aadc5944fdd06612484ed7918fe376ad871a5f50404dc1536e0194/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d21ce524ab86c23046e992a5b81cb54c21079c6df6e78b8fc77d77cac70a6b9", size = 3358470, upload-time = "2026-06-15T16:26:38.011Z" }, - { url = "https://files.pythonhosted.org/packages/d0/7d/ff77169fee6186de145a7f2b87006c39638391130abbab2b1f63ac6ea583/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c5d98a2709840027f5a347c3af0a7c3d5f6c1ff93af2ca1c54494e23cba8f389", size = 3289874, upload-time = "2026-06-15T16:19:45.212Z" }, - { url = "https://files.pythonhosted.org/packages/6f/3b/6c505903710d781b55bc3141ee34a062bf9745a6b5bc7333305b9ed63b33/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1181256e0f16479691b5616d36375dc2620ad8332b25978763c3d206ad3f3f1d", size = 3321692, upload-time = "2026-06-15T16:26:39.747Z" }, - { url = "https://files.pythonhosted.org/packages/3c/b7/c5ffe50aa2f4d947c9250e1519d939260329a07fe6272edfccd784b3d007/sqlalchemy-2.0.51-cp312-cp312-win32.whl", hash = "sha256:9f380393be5abeb6815f68fd39271b95127173511b6706b0a630a9995d53f8f5", size = 2119674, upload-time = "2026-06-15T16:23:09.543Z" }, - { url = "https://files.pythonhosted.org/packages/25/dc/46a65916af68a06ef6b972c6050ba4c8f97070fe3fb33097d34229d9bef6/sqlalchemy-2.0.51-cp312-cp312-win_amd64.whl", hash = "sha256:2cf39aabdf48e87c1c2c2ed6d20d33ffa0733b3071ce9c5f66357947dd009080", size = 2146670, upload-time = "2026-06-15T16:23:11.048Z" }, - { url = "https://files.pythonhosted.org/packages/54/fe/a210d52fd1a90ecfae8a78e9d8b27e18d733d60818a8bf250ff690b75120/sqlalchemy-2.0.51-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c2056838b6685b72fdb36c99996cf862753461a62f2e84f4196371d3b2d6a07", size = 2157184, upload-time = "2026-06-15T16:08:50.374Z" }, - { url = "https://files.pythonhosted.org/packages/17/6b/2dce8369b199cb855110e056032f94a9f66dacc2237d3d39c115a86eac56/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:483b11bd46bf35fc14c52faf338b04300c9e6ce554bce9b11be85bfec3bc3195", size = 3284735, upload-time = "2026-06-15T16:19:46.934Z" }, - { url = "https://files.pythonhosted.org/packages/53/ff/dbc495b8a14da840faffb353857a72d4190113cac33727906fb997047f0f/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1bed1ee8b01da6088210aa9412023326fb98a599ba502e6118308601dcbef77f", size = 3302756, upload-time = "2026-06-15T16:26:41.336Z" }, - { url = "https://files.pythonhosted.org/packages/cf/d5/fde8f4dddcf518ee15ab35a7c6a28acc32c8ba548d1d2aa451f96e6dbb0b/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:72ca54c952107ba5cd58854b67a5a6268631289d21651a1235396f3b98b47400", size = 3232055, upload-time = "2026-06-15T16:19:49.286Z" }, - { url = "https://files.pythonhosted.org/packages/67/d1/43d3a0ac955a58601c24fa23038b1c55ee3a1ec02c0f96ebb1eae2bcf614/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b3e693d15533a45cd5906f0589f9c35090bef6ef45bf1e8195c424aa0ae06a8d", size = 3269850, upload-time = "2026-06-15T16:26:43.017Z" }, - { url = "https://files.pythonhosted.org/packages/94/df/de669c7054cd47c4439ac34b1b2ee8b804a794791fbb10720e997a2c87c7/sqlalchemy-2.0.51-cp313-cp313-win32.whl", hash = "sha256:b93ab07b5292dbe7e6b8da89475275e7042744283921344b56105f3eeb0f828b", size = 2117721, upload-time = "2026-06-15T16:23:12.36Z" }, - { url = "https://files.pythonhosted.org/packages/d0/8a/403c51d064196bae20a0bc2476577f83a3f8dd299719a97417086b7f2ec5/sqlalchemy-2.0.51-cp313-cp313-win_amd64.whl", hash = "sha256:0f053118c30e53161857a953e4de667d90e274980dccbe5dd3829bbbeece72a5", size = 2143615, upload-time = "2026-06-15T16:23:13.906Z" }, - { url = "https://files.pythonhosted.org/packages/b1/49/a739be2e1d02a96a658eb71ab45d921c874249252358ad24a5bffdd02525/sqlalchemy-2.0.51-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6ea306caaae6bd5afd0a46050003c88f6bf33227377a49298c498c3cb88ff491", size = 2158999, upload-time = "2026-06-15T16:08:51.759Z" }, - { url = "https://files.pythonhosted.org/packages/23/6b/2e0e38cf75c8780eca78d9b2e78164f8bcfd70125e5caa588ff5cbb9c9f4/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c45a496d6bc05dec41dcd4c3a2b183723f47473255c159cd80b503c8f246424d", size = 3282539, upload-time = "2026-06-15T16:19:51.065Z" }, - { url = "https://files.pythonhosted.org/packages/dd/a1/e77854cb5336fd37dc3c6ae3b71de242c98caac5725120be0b526b31cbd0/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4004ada0aafe8ae1991b2cd1d99c6d9146126e123bd6f883c260d974aa012e54", size = 3287545, upload-time = "2026-06-15T16:26:44.735Z" }, - { url = "https://files.pythonhosted.org/packages/f6/ab/9e17272fd4dac8df3b83c4fbe52b998a1c9d89a843c8c35ff29b74ff7364/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0f6bcad487aee1c638d707235682fc96f741de00663619881ab235400d03289e", size = 3230929, upload-time = "2026-06-15T16:19:52.625Z" }, - { url = "https://files.pythonhosted.org/packages/02/3c/52f408ea701781caee975606beccc48845f2aee8711ac29843d612c0306c/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:39a76529db6305693d8d4affa58ad5b5e2e18edd62daea628b29b97930b3513d", size = 3252888, upload-time = "2026-06-15T16:26:46.454Z" }, - { url = "https://files.pythonhosted.org/packages/24/16/3efd2ee6bc4ca4693a30a1dd17a91b606cae15d517d2a4746611d9b73ce8/sqlalchemy-2.0.51-cp314-cp314-win32.whl", hash = "sha256:08a204d8b5638717c26a24df18fcf40af45a6b22e35b70b1d62f0113c2e278e8", size = 2120551, upload-time = "2026-06-15T16:23:15.629Z" }, - { url = "https://files.pythonhosted.org/packages/7b/78/55b12e70f45bccc40d9e483925c065027b3b98ea4cbbdf6f8c2546feaf6c/sqlalchemy-2.0.51-cp314-cp314-win_amd64.whl", hash = "sha256:96747bfbadb055466e5b46d572618170046b45ce5a4879167f50d70a5319a499", size = 2146318, upload-time = "2026-06-15T16:23:17.108Z" }, - { url = "https://files.pythonhosted.org/packages/21/db/a9574ed40fed418924b1b1a3e54f47ee3963053b3d3d325a0d36b41f2c08/sqlalchemy-2.0.51-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e5ea1a213be1fcd5e49d9904c3b9939211ded90bc2a64e93f4c01963474285de", size = 2178920, upload-time = "2026-06-15T15:59:56.285Z" }, - { url = "https://files.pythonhosted.org/packages/bf/90/a1bb5c7cbba76b7bc1fbd586d0a5479a7bc9c27b4a8298f22ec9423b2bb3/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c6b36ed71f41942bdcd2ad2522be46bfce09d5705be5640ecf19bbc7660e4b7", size = 3566534, upload-time = "2026-06-15T15:58:35.024Z" }, - { url = "https://files.pythonhosted.org/packages/15/4b/481f1fed30e0e9e8dd24aecbb49f29eb57fe7657ece5cf06ee9b84bb97d8/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0c2c62877097e1a0db401fba5cb4debee33265e5b2a55c4ccb489c02c53b4f72", size = 3535844, upload-time = "2026-06-15T16:02:43.973Z" }, - { url = "https://files.pythonhosted.org/packages/02/71/0aa64aeda645510af0a43f7d9ee70932f0d1dc4263aed34c50ee891d9df3/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0378d055e9e8cd6ce4d8dff683bdd3d7d413533c4ee51d67a2b1e0f9eacc0f23", size = 3475355, upload-time = "2026-06-15T15:58:36.592Z" }, - { url = "https://files.pythonhosted.org/packages/05/db/6061db32316446135a3abae5f308d144ab988a34234726042da3e58b1c63/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6e46fc36029eff666391e0531e5387b62ce6c4f1d8e50b3fb3099eaca1b42522", size = 3486591, upload-time = "2026-06-15T16:02:45.346Z" }, - { url = "https://files.pythonhosted.org/packages/0d/c9/f14fdf71bb8957e0c7e39db69bbdf12b5c80f4ef775fdfa127bf4e0d6760/sqlalchemy-2.0.51-cp314-cp314t-win32.whl", hash = "sha256:9161cfc9efce70d1715f47d6ff40f79c6778c00d53be4fbc09d70301e4b83ba7", size = 2151313, upload-time = "2026-06-15T16:03:39.127Z" }, - { url = "https://files.pythonhosted.org/packages/6a/c6/673e618e6f4f297e126d9b56ea2f6478708f6c1af4e3223835c22e2c3697/sqlalchemy-2.0.51-cp314-cp314t-win_amd64.whl", hash = "sha256:159bb6ba32059f57ad7375a8f50d844dd2f19d14954ecf820cd33e20debd46b2", size = 2186280, upload-time = "2026-06-15T16:03:40.569Z" }, - { url = "https://files.pythonhosted.org/packages/e2/22/dbf013a12ec759e54a34a119e9e217435b3f71b2dd5c61a7ade0a25dae87/sqlalchemy-2.0.51-py3-none-any.whl", hash = "sha256:bb024d8b621d0be75f4f44ecc7c950450026e76d66dc8f791bb5331d7fed59d5", size = 1944334, upload-time = "2026-06-15T16:09:22.418Z" }, -] - -[[package]] -name = "sqlalchemy-spanner" -version = "1.19.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "alembic" }, - { name = "google-cloud-spanner" }, - { name = "sqlalchemy" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/af/b6/ce05f1b8a9c486bbac26d7348625c78ba6e751decc25009f28880504c29d/sqlalchemy_spanner-1.19.0.tar.gz", hash = "sha256:834cec66fb418e5085a44c68cee570c594c66dd8535b67dd5e8be3571d172136", size = 82914, upload-time = "2026-06-03T16:14:49.721Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/38/8150a0022174d02956b0f6b586777006af2fc794b1baa72748a11fde039f/sqlalchemy_spanner-1.19.0-py3-none-any.whl", hash = "sha256:3367a89388d9b7106111fc48c7fac441163602c414ad157f62e18b5705cc760e", size = 31919, upload-time = "2026-06-03T16:13:39.522Z" }, -] - -[[package]] -name = "sqlparse" -version = "0.5.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/90/76/437d71068094df0726366574cf3432a4ed754217b436eb7429415cf2d480/sqlparse-0.5.5.tar.gz", hash = "sha256:e20d4a9b0b8585fdf63b10d30066c7c94c5d7a7ec47c889a2d83a3caa93ff28e", size = 120815, upload-time = "2025-12-19T07:17:45.073Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" }, -] - [[package]] name = "sse-starlette" version = "3.4.4" @@ -5557,15 +4588,15 @@ wheels = [ [[package]] name = "starlette" -version = "0.52.1" +version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, { name = "typing-extensions", marker = "python_full_version < '3.13'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bb/2799cc2ede3ed41131f8975621e7213dfc7ef4acbbaadfa440f32500c370/starlette-1.3.1-py3-none-any.whl", hash = "sha256:c7372aae11c3c3f26a42df7bd626cec2f47d03483d261d369516a615a53714c6", size = 73632, upload-time = "2026-06-12T09:23:10.017Z" }, ] [[package]] @@ -5651,6 +4682,9 @@ aioboto3 = [ google-adk = [ { name = "google-adk" }, ] +google-genai = [ + { name = "google-genai" }, +] grpc = [ { name = "grpcio" }, ] @@ -5694,6 +4728,7 @@ dev = [ { name = "langsmith" }, { name = "litellm" }, { name = "maturin" }, + { name = "mcp" }, { name = "moto", extra = ["s3", "server"] }, { name = "mypy" }, { name = "mypy-protobuf" }, @@ -5727,7 +4762,8 @@ dev = [ [package.metadata] requires-dist = [ { name = "aioboto3", marker = "extra == 'aioboto3'", specifier = ">=10.4.0" }, - { name = "google-adk", marker = "extra == 'google-adk'", specifier = ">=1.27.0,<2" }, + { name = "google-adk", marker = "extra == 'google-adk'", specifier = ">=2.2.0,<3" }, + { name = "google-genai", marker = "extra == 'google-genai'", specifier = ">=2.10.0,<3.0.0" }, { name = "grpcio", marker = "extra == 'grpc'", specifier = ">=1.48.2,<2" }, { name = "langgraph", marker = "extra == 'langgraph'", specifier = ">=1.1.0" }, { name = "langsmith", marker = "extra == 'langsmith'", specifier = ">=0.7.34,<0.9" }, @@ -5749,7 +4785,7 @@ requires-dist = [ { name = "types-protobuf", specifier = ">=3.20,<8.0.0" }, { name = "typing-extensions", specifier = ">=4.2.0,<5" }, ] -provides-extras = ["grpc", "opentelemetry", "pydantic", "openai-agents", "google-adk", "langgraph", "langsmith", "lambda-worker-otel", "aioboto3", "strands-agents"] +provides-extras = ["grpc", "opentelemetry", "pydantic", "openai-agents", "google-adk", "langgraph", "langsmith", "lambda-worker-otel", "aioboto3", "google-genai", "strands-agents"] [package.metadata.requires-dev] dev = [ @@ -5763,6 +4799,7 @@ dev = [ { name = "langsmith", specifier = ">=0.7.34,<0.9" }, { name = "litellm", specifier = ">=1.83.0" }, { name = "maturin", specifier = ">=1.8.2" }, + { name = "mcp", specifier = ">=1.9.4,<2" }, { name = "moto", extras = ["s3", "server"], specifier = ">=5" }, { name = "mypy", specifier = "==1.18.2" }, { name = "mypy-protobuf", specifier = ">=3.3.0,<4" }, @@ -6132,15 +5169,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1d/70/5771c9ecbdb7cc0c3f3bbded7e0fa7911ee8e872ce5b5dc48ce7dce21a11/tzlocal-5.4-py3-none-any.whl", hash = "sha256:024d11221ff83453eae1f608f09b145b9779e1345d08c15404ce8ff7917cf629", size = 28261, upload-time = "2026-06-15T12:06:54.914Z" }, ] -[[package]] -name = "uritemplate" -version = "4.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/60/f174043244c5306c9988380d2cb10009f91563fc4b31293d27e17201af56/uritemplate-4.2.0.tar.gz", hash = "sha256:480c2ed180878955863323eea31b0ede668795de182617fef9c6ca09e6ec9d0e", size = 33267, upload-time = "2025-06-02T15:12:06.318Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a9/99/3ae339466c9183ea5b8ae87b34c0b897eda475d2aec2307cae60e5cd4f29/uritemplate-4.2.0-py3-none-any.whl", hash = "sha256:962201ba1c4edcab02e60f9a0d3821e82dfc5d2d6662a21abd533879bdb8a686", size = 11488, upload-time = "2025-06-02T15:12:03.405Z" }, -] - [[package]] name = "urllib3" version = "2.7.0"