google-genai 1.9.0__tar.gz → 1.11.0__tar.gz

{google_genai-1.9.0/google_genai.egg-info → google_genai-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.9.0
+Version: 1.11.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0

{google_genai-1.9.0 → google_genai-1.11.0}/google/genai/_api_client.py

@@ -19,28 +19,41 @@
 The BaseApiClient is intended to be a private module and is subject to change.
 """
 
-import anyio
 import asyncio
 import copy
 from dataclasses import dataclass
 import datetime
+import http
 import io
 import json
 import logging
+import math
 import os
+import ssl
 import sys
+import time
 from typing import Any, AsyncIterator, Optional, Tuple, Union
-from urllib.parse import urlparse, urlunparse
+from urllib.parse import urlparse
+from urllib.parse import urlunparse
+
+import anyio
+import certifi
 import google.auth
 import google.auth.credentials
 from google.auth.credentials import Credentials
 from google.auth.transport.requests import Request
 import httpx
-from pydantic import BaseModel, Field, ValidationError
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import ValidationError
+
 from . import _common
 from . import errors
 from . import version
-from .types import HttpOptions, HttpOptionsDict, HttpOptionsOrDict
+from .types import HttpOptions
+from .types import HttpOptionsDict
+from .types import HttpOptionsOrDict
+
 
 logger = logging.getLogger('google_genai._api_client')
 CHUNK_SIZE = 8 * 1024 * 1024  # 8 MB chunk size
@@ -95,6 +108,14 @@ def _patch_http_options(
   return copy_option
 
 
+def _populate_server_timeout_header(
+    headers: dict[str, str], timeout_in_seconds: Optional[Union[float, int]]
+) -> None:
+  """Populates the server timeout header in the headers dict."""
+  if timeout_in_seconds and 'X-Server-Timeout' not in headers:
+    headers['X-Server-Timeout'] = str(math.ceil(timeout_in_seconds))
+
+
 def _join_url_path(base_url: str, path: str) -> str:
   parsed_base = urlparse(base_url)
   base_path = (
@@ -128,6 +149,19 @@ def _refresh_auth(credentials: Credentials) -> Credentials:
   return credentials
 
 
+def _get_timeout_in_seconds(
+    timeout: Optional[Union[float, int]],
+) -> Optional[float]:
+  """Converts the timeout to seconds."""
+  if timeout:
+    # HttpOptions.timeout is in milliseconds. But httpx.Client.request()
+    # expects seconds.
+    timeout_in_seconds = timeout / 1000.0
+  else:
+    timeout_in_seconds = None
+  return timeout_in_seconds
+
+
 @dataclass
 class HttpRequest:
   headers: dict[str, str]
@@ -390,7 +424,7 @@ class BaseApiClient:
       if not self.api_key:
         raise ValueError(
             'Missing key inputs argument! To use the Google AI API,'
-            'provide (`api_key`) arguments. To use the Google Cloud API,'
+            ' provide (`api_key`) arguments. To use the Google Cloud API,'
             ' provide (`vertexai`, `project` & `location`) arguments.'
         )
       self._http_options.base_url = 'https://generativelanguage.googleapis.com/'
@@ -408,9 +442,67 @@ class BaseApiClient:
     else:
       if self._http_options.headers is not None:
         _append_library_version_headers(self._http_options.headers)
-    # Initialize the httpx client.
-    self._httpx_client = SyncHttpxClient()
-    self._async_httpx_client = AsyncHttpxClient()
+
+    client_args, async_client_args = self._ensure_ssl_ctx(self._http_options)
+    self._httpx_client = SyncHttpxClient(**client_args)
+    self._async_httpx_client = AsyncHttpxClient(**async_client_args)
+
+  @staticmethod
+  def _ensure_ssl_ctx(options: HttpOptions) -> (
+      Tuple[dict[str, Any], dict[str, Any]]):
+    """Ensures the SSL context is present in the client args.
+
+    Creates a default SSL context if one is not provided.
+
+    Args:
+      options: The http options to check for SSL context.
+
+    Returns:
+      A tuple of sync/async httpx client args.
+    """
+
+    verify = 'verify'
+    args = options.client_args
+    async_args = options.async_client_args
+    ctx = (
+        args.get(verify) if args else None
+        or async_args.get(verify) if async_args else None
+    )
+
+    if not ctx:
+      # Initialize the SSL context for the httpx client.
+      # Unlike requests, the httpx package does not automatically pull in the
+      # environment variables SSL_CERT_FILE or SSL_CERT_DIR. They need to be
+      # enabled explicitly.
+      ctx = ssl.create_default_context(
+          cafile=os.environ.get('SSL_CERT_FILE', certifi.where()),
+          capath=os.environ.get('SSL_CERT_DIR'),
+      )
+
+    def _maybe_set(
+        args: Optional[dict[str, Any]],
+        ctx: ssl.SSLContext,
+    ) -> dict[str, Any]:
+      """Sets the SSL context in the client args if not set.
+
+      Does not override the SSL context if it is already set.
+
+      Args:
+        args: The client args to to check for SSL context.
+        ctx: The SSL context to set.
+
+      Returns:
+        The client args with the SSL context included.
+      """
+      if not args or not args.get(verify):
+        args = (args or {}).copy()
+        args[verify] = ctx
+      return args
+
+    return (
+        _maybe_set(args, ctx),
+        _maybe_set(async_args, ctx),
+    )
 
   def _websocket_base_url(self):
     url_parts = urlparse(self._http_options.base_url)
@@ -520,18 +612,13 @@ class BaseApiClient:
         versioned_path,
     )
 
-    timeout_in_seconds: Optional[Union[float, int]] = (
-        patched_http_options.timeout
-    )
-    if timeout_in_seconds:
-      # HttpOptions.timeout is in milliseconds. But httpx.Client.request()
-      # expects seconds.
-      timeout_in_seconds = timeout_in_seconds / 1000.0
-    else:
-      timeout_in_seconds = None
+    timeout_in_seconds = _get_timeout_in_seconds(patched_http_options.timeout)
 
     if patched_http_options.headers is None:
       raise ValueError('Request headers must be set.')
+    _populate_server_timeout_header(
+        patched_http_options.headers, timeout_in_seconds
+    )
     return HttpRequest(
         method=http_method,
         url=url,
@@ -712,7 +799,12 @@ class BaseApiClient:
     return async_generator()
 
   def upload_file(
-      self, file_path: Union[str, io.IOBase], upload_url: str, upload_size: int
+      self,
+      file_path: Union[str, io.IOBase],
+      upload_url: str,
+      upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ) -> HttpResponse:
     """Transfers a file to the given URL.
 
@@ -723,18 +815,28 @@ class BaseApiClient:
       upload_url: The URL to upload the file to.
       upload_size: The size of file content to be uploaded, this will have to
         match the size requested in the resumable upload request.
+      http_options: The http options to use for the request.
 
     returns:
           The HttpResponse object from the finalize request.
     """
     if isinstance(file_path, io.IOBase):
-      return self._upload_fd(file_path, upload_url, upload_size)
+      return self._upload_fd(
+          file_path, upload_url, upload_size, http_options=http_options
+      )
     else:
       with open(file_path, 'rb') as file:
-        return self._upload_fd(file, upload_url, upload_size)
+        return self._upload_fd(
+            file, upload_url, upload_size, http_options=http_options
+        )
 
   def _upload_fd(
-      self, file: io.IOBase, upload_url: str, upload_size: int
+      self,
+      file: io.IOBase,
+      upload_url: str,
+      upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ) -> HttpResponse:
     """Transfers a file to the given URL.
 
@@ -743,6 +845,7 @@ class BaseApiClient:
       upload_url: The URL to upload the file to.
       upload_size: The size of file content to be uploaded, this will have to
         match the size requested in the resumable upload request.
+      http_options: The http options to use for the request.
 
     returns:
           The HttpResponse object from the finalize request.
@@ -758,15 +861,32 @@ class BaseApiClient:
       # If last chunk, finalize the upload.
       if chunk_size + offset >= upload_size:
         upload_command += ', finalize'
+      http_options = http_options if http_options else self._http_options
+      timeout = (
+          http_options.get('timeout')
+          if isinstance(http_options, dict)
+          else http_options.timeout
+      )
+      if timeout is None:
+        # Per request timeout is not configured. Check the global timeout.
+        timeout = (
+            self._http_options.timeout
+            if isinstance(self._http_options, dict)
+            else self._http_options.timeout
+        )
+      timeout_in_seconds = _get_timeout_in_seconds(timeout)
+      upload_headers = {
+          'X-Goog-Upload-Command': upload_command,
+          'X-Goog-Upload-Offset': str(offset),
+          'Content-Length': str(chunk_size),
+      }
+      _populate_server_timeout_header(upload_headers, timeout_in_seconds)
       response = self._httpx_client.request(
           method='POST',
           url=upload_url,
-          headers={
-              'X-Goog-Upload-Command': upload_command,
-              'X-Goog-Upload-Offset': str(offset),
-              'Content-Length': str(chunk_size),
-          },
+          headers=upload_headers,
           content=file_chunk,
+          timeout=timeout_in_seconds,
       )
       offset += chunk_size
       if response.headers['x-goog-upload-status'] != 'active':
@@ -783,7 +903,12 @@ class BaseApiClient:
       )
     return HttpResponse(response.headers, response_stream=[response.text])
 
-  def download_file(self, path: str, http_options):
+  def download_file(
+      self,
+      path: str,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
+  ):
     """Downloads the file data.
 
     Args:
@@ -822,6 +947,8 @@ class BaseApiClient:
       file_path: Union[str, io.IOBase],
       upload_url: str,
       upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ) -> HttpResponse:
     """Transfers a file asynchronously to the given URL.
 
@@ -831,23 +958,30 @@ class BaseApiClient:
       upload_url: The URL to upload the file to.
       upload_size: The size of file content to be uploaded, this will have to
         match the size requested in the resumable upload request.
+      http_options: The http options to use for the request.
 
     returns:
           The HttpResponse object from the finalize request.
     """
     if isinstance(file_path, io.IOBase):
-      return await self._async_upload_fd(file_path, upload_url, upload_size)
+      return await self._async_upload_fd(
+          file_path, upload_url, upload_size, http_options=http_options
+      )
     else:
       file = anyio.Path(file_path)
       fd = await file.open('rb')
       async with fd:
-        return await self._async_upload_fd(fd, upload_url, upload_size)
+        return await self._async_upload_fd(
+            fd, upload_url, upload_size, http_options=http_options
+        )
 
   async def _async_upload_fd(
       self,
       file: Union[io.IOBase, anyio.AsyncFile],
       upload_url: str,
       upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ) -> HttpResponse:
     """Transfers a file asynchronously to the given URL.
 
@@ -856,6 +990,7 @@ class BaseApiClient:
       upload_url: The URL to upload the file to.
       upload_size: The size of file content to be uploaded, this will have to
         match the size requested in the resumable upload request.
+      http_options: The http options to use for the request.
 
     returns:
           The HttpResponse object from the finalized request.
@@ -874,15 +1009,32 @@ class BaseApiClient:
       # If last chunk, finalize the upload.
       if chunk_size + offset >= upload_size:
         upload_command += ', finalize'
+      http_options = http_options if http_options else self._http_options
+      timeout = (
+          http_options.get('timeout')
+          if isinstance(http_options, dict)
+          else http_options.timeout
+      )
+      if timeout is None:
+        # Per request timeout is not configured. Check the global timeout.
+        timeout = (
+            self._http_options.timeout
+            if isinstance(self._http_options, dict)
+            else self._http_options.timeout
+        )
+      timeout_in_seconds = _get_timeout_in_seconds(timeout)
+      upload_headers = {
+          'X-Goog-Upload-Command': upload_command,
+          'X-Goog-Upload-Offset': str(offset),
+          'Content-Length': str(chunk_size),
+      }
+      _populate_server_timeout_header(upload_headers, timeout_in_seconds)
       response = await self._async_httpx_client.request(
           method='POST',
           url=upload_url,
           content=file_chunk,
-          headers={
-              'X-Goog-Upload-Command': upload_command,
-              'X-Goog-Upload-Offset': str(offset),
-              'Content-Length': str(chunk_size),
-          },
+          headers=upload_headers,
+          timeout=timeout_in_seconds,
       )
       offset += chunk_size
       if response.headers.get('x-goog-upload-status') != 'active':
@@ -899,7 +1051,12 @@ class BaseApiClient:
       )
     return HttpResponse(response.headers, response_stream=[response.text])
 
-  async def async_download_file(self, path: str, http_options):
+  async def async_download_file(
+      self,
+      path: str,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
+  ):
     """Downloads the file data.
 
     Args:

{google_genai-1.9.0 → google_genai-1.11.0}/google/genai/_automatic_function_calling_util.py

@@ -28,7 +28,7 @@ from . import types
 if sys.version_info >= (3, 10):
   VersionedUnionType = builtin_types.UnionType
 else:
-  VersionedUnionType = typing._UnionGenericAlias
+  VersionedUnionType = typing._UnionGenericAlias  # type: ignore[attr-defined]
 
 _py_builtin_type_to_schema_type = {
     str: types.Type.STRING,

{google_genai-1.9.0 → google_genai-1.11.0}/google/genai/_extra_utils.py

@@ -30,7 +30,7 @@ from . import types
 if sys.version_info >= (3, 10):
   from types import UnionType
 else:
-  UnionType = typing._UnionGenericAlias
+  UnionType = typing._UnionGenericAlias  # type: ignore[attr-defined]
 
 _DEFAULT_MAX_REMOTE_CALLS_AFC = 10
 
@@ -78,6 +78,7 @@ def format_destination(
 
 def get_function_map(
     config: Optional[types.GenerateContentConfigOrDict] = None,
+    is_caller_method_async: bool = False,
 ) -> dict[str, Callable]:
   """Returns a function map from the config."""
   function_map: dict[str, Callable] = {}
@@ -87,7 +88,7 @@ def get_function_map(
   if config_model.tools:
     for tool in config_model.tools:
       if callable(tool):
-        if inspect.iscoroutinefunction(tool):
+        if inspect.iscoroutinefunction(tool) and not is_caller_method_async:
           raise errors.UnsupportedFunctionError(
               f'Function {tool.__name__} is a coroutine function, which is not'
               ' supported for automatic function calling. Please manually'
@@ -199,11 +200,11 @@ def convert_if_exist_pydantic_model(
   return value
 
 
-def invoke_function_from_dict_args(
-    args: Dict[str, Any], function_to_invoke: Callable
-) -> Any:
-  signature = inspect.signature(function_to_invoke)
-  func_name = function_to_invoke.__name__
+def convert_argument_from_function(
+    args: dict[str, Any], function: Callable
+) -> dict[str, Any]:
+  signature = inspect.signature(function)
+  func_name = function.__name__
   converted_args = {}
   for param_name, param in signature.parameters.items():
     if param_name in args:
@@ -213,13 +214,34 @@ def invoke_function_from_dict_args(
           param_name,
           func_name,
       )
+  return converted_args
+
+
+def invoke_function_from_dict_args(
+    args: Dict[str, Any], function_to_invoke: Callable
+) -> Any:
+  converted_args = convert_argument_from_function(args, function_to_invoke)
   try:
     return function_to_invoke(**converted_args)
   except Exception as e:
     raise errors.FunctionInvocationError(
-        f'Failed to invoke function {func_name} with converted arguments'
-        f' {converted_args} from model returned function call argument'
-        f' {args} because of error {e}'
+        f'Failed to invoke function {function_to_invoke.__name__} with'
+        f' converted arguments {converted_args} from model returned function'
+        f' call argument {args} because of error {e}'
+    )
+
+
+async def invoke_function_from_dict_args_async(
+    args: Dict[str, Any], function_to_invoke: Callable
+) -> Any:
+  converted_args = convert_argument_from_function(args, function_to_invoke)
+  try:
+    return await function_to_invoke(**converted_args)
+  except Exception as e:
+    raise errors.FunctionInvocationError(
+        f'Failed to invoke function {function_to_invoke.__name__} with'
+        f' converted arguments {converted_args} from model returned function'
+        f' call argument {args} because of error {e}'
     )
 
 
@@ -256,6 +278,44 @@ def get_function_response_parts(
         func_response_parts.append(func_response_part)
   return func_response_parts
 
+async def get_function_response_parts_async(
+    response: types.GenerateContentResponse,
+    function_map: dict[str, Callable],
+) -> list[types.Part]:
+  """Returns the function response parts from the response."""
+  func_response_parts = []
+  if (
+      response.candidates is not None
+      and isinstance(response.candidates[0].content, types.Content)
+      and response.candidates[0].content.parts is not None
+  ):
+    for part in response.candidates[0].content.parts:
+      if not part.function_call:
+        continue
+      func_name = part.function_call.name
+      if func_name is not None and part.function_call.args is not None:
+        func = function_map[func_name]
+        args = convert_number_values_for_dict_function_call_args(
+            part.function_call.args
+        )
+        func_response: dict[str, Any]
+        try:
+          if inspect.iscoroutinefunction(func):
+            func_response = {
+                'result': await invoke_function_from_dict_args_async(args, func)
+            }
+          else:
+            func_response = {
+                'result': invoke_function_from_dict_args(args, func)
+            }
+        except Exception as e:  # pylint: disable=broad-except
+          func_response = {'error': str(e)}
+        func_response_part = types.Part.from_function_response(
+            name=func_name, response=func_response
+        )
+        func_response_parts.append(func_response_part)
+  return func_response_parts
+
 
 def should_disable_afc(
     config: Optional[types.GenerateContentConfigOrDict] = None,

{google_genai-1.9.0 → google_genai-1.11.0}/google/genai/_replay_api_client.py

@@ -34,6 +34,8 @@ from ._api_client import HttpOptions
 from ._api_client import HttpRequest
 from ._api_client import HttpResponse
 from ._common import BaseModel
+from .types import HttpOptionsOrDict
+from .types import GenerateVideosOperation
 
 
 def _redact_version_numbers(version_string: str) -> str:
@@ -396,7 +398,12 @@ class ReplayApiClient(BaseApiClient):
     if isinstance(response_model, list):
       response_model = response_model[0]
     print('response_model: ', response_model.model_dump(exclude_none=True))
-    actual = response_model.model_dump(exclude_none=True, mode='json')
+    if isinstance(response_model, GenerateVideosOperation):
+      actual = response_model.model_dump(
+          exclude={'result'}, exclude_none=True, mode='json'
+      )
+    else:
+      actual = response_model.model_dump(exclude_none=True, mode='json')
     expected = interaction.response.sdk_response_segments[
         self._sdk_response_index
     ]
@@ -461,7 +468,14 @@ class ReplayApiClient(BaseApiClient):
     else:
       return self._build_response_from_replay(http_request)
 
-  def upload_file(self, file_path: Union[str, io.IOBase], upload_url: str, upload_size: int) -> HttpResponse:
+  def upload_file(
+      self,
+      file_path: Union[str, io.IOBase],
+      upload_url: str,
+      upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
+  ) -> HttpResponse:
     if isinstance(file_path, io.IOBase):
       offset = file_path.tell()
       content = file_path.read()
@@ -479,7 +493,9 @@ class ReplayApiClient(BaseApiClient):
     if self._should_call_api():
       result: Union[str, HttpResponse]
       try:
-        result = super().upload_file(file_path, upload_url, upload_size)
+        result = super().upload_file(
+            file_path, upload_url, upload_size, http_options=http_options
+        )
       except HTTPError as e:
         result = HttpResponse(
             dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
@@ -496,6 +512,8 @@ class ReplayApiClient(BaseApiClient):
       file_path: Union[str, io.IOBase],
       upload_url: str,
       upload_size: int,
+      *,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ) -> HttpResponse:
     if isinstance(file_path, io.IOBase):
       offset = file_path.tell()
@@ -515,7 +533,7 @@ class ReplayApiClient(BaseApiClient):
       result: HttpResponse
       try:
         result = await super().async_upload_file(
-            file_path, upload_url, upload_size
+            file_path, upload_url, upload_size, http_options=http_options
         )
       except HTTPError as e:
         result = HttpResponse(
@@ -528,14 +546,16 @@ class ReplayApiClient(BaseApiClient):
     else:
       return self._build_response_from_replay(request)
 
-  def download_file(self, path: str, http_options: HttpOptions):
+  def download_file(
+      self, path: str, *, http_options: Optional[HttpOptionsOrDict] = None
+  ):
     self._initialize_replay_session_if_not_loaded()
     request = self._build_request(
         'get', path=path, request_dict={}, http_options=http_options
     )
     if self._should_call_api():
       try:
-        result = super().download_file(path, http_options)
+        result = super().download_file(path, http_options=http_options)
       except HTTPError as e:
         result = HttpResponse(
             dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
@@ -547,14 +567,18 @@ class ReplayApiClient(BaseApiClient):
     else:
       return self._build_response_from_replay(request).byte_stream[0]
 
-  async def async_download_file(self, path: str, http_options):
+  async def async_download_file(
+      self, path: str, *, http_options: Optional[HttpOptionsOrDict] = None
+  ):
     self._initialize_replay_session_if_not_loaded()
     request = self._build_request(
         'get', path=path, request_dict={}, http_options=http_options
     )
     if self._should_call_api():
       try:
-        result = await super().async_download_file(path, http_options)
+        result = await super().async_download_file(
+            path, http_options=http_options
+        )
       except HTTPError as e:
         result = HttpResponse(
             dict(e.response.headers), [json.dumps({'reason': e.response.reason})]