google-genai 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

google/genai/__init__.py

@@ -16,7 +16,8 @@
 """Google Gen AI SDK"""
 
 from .client import Client
+from . import  version
 
-__version__ = '0.2.2'
+__version__ = version.__version__
 
 __all__ = ['Client']

google/genai/_api_client.py

@@ -23,35 +23,66 @@ import datetime
 import json
 import os
 import sys
-from typing import Any, Optional, TypedDict, Union
+from typing import Any, Optional, Tuple, TypedDict, Union
 from urllib.parse import urlparse, urlunparse
 
 import google.auth
 import google.auth.credentials
 from google.auth.transport.requests import AuthorizedSession
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
 import requests
 
 from . import errors
+from . import version
 
 
-class HttpOptions(TypedDict):
+class HttpOptions(BaseModel):
+  """HTTP options for the api client."""
+  model_config = ConfigDict(extra='forbid')
+
+  base_url: Optional[str] = Field(
+      default=None,
+      description="""The base URL for the AI platform service endpoint.""",
+  )
+  api_version: Optional[str] = Field(
+      default=None,
+      description="""Specifies the version of the API to use.""",
+  )
+  headers: Optional[dict[str, str]] = Field(
+      default=None,
+      description="""Additional HTTP headers to be sent with the request.""",
+  )
+  response_payload: Optional[dict] = Field(
+      default=None,
+      description="""If set, the response payload will be returned int the supplied dict.""",
+  )
+  timeout: Optional[Union[float, Tuple[float, float]]] = Field(
+      default=None,
+      description="""Timeout for the request in seconds.""",
+  )
+
+
+class HttpOptionsDict(TypedDict):
   """HTTP options for the api client."""
 
-  base_url: str = None
+  base_url: Optional[str] = None
   """The base URL for the AI platform service endpoint."""
-  api_version: str = None
+  api_version: Optional[str] = None
   """Specifies the version of the API to use."""
-  headers: dict[str, dict] = None
+  headers: Optional[dict[str, Union[str, list[str]]]] = None
   """Additional HTTP headers to be sent with the request."""
-  response_payload: dict = None
+  response_payload: Optional[dict] = None
   """If set, the response payload will be returned int the supplied dict."""
+  timeout: Optional[Union[float, Tuple[float, float]]] = None
+  """Timeout for the request in seconds."""
+
+
+HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
 
 def _append_library_version_headers(headers: dict[str, str]) -> None:
   """Appends the telemetry header to the headers dict."""
-  # TODO: Automate revisions to the SDK library version.
-  library_label = f'google-genai-sdk/0.2.2'
+  library_label = f'google-genai-sdk/{version.__version__}'
   language_label = 'gl-python/' + sys.version.split()[0]
   version_header_value = f'{library_label} {language_label}'
   if (
@@ -71,20 +102,24 @@ def _append_library_version_headers(headers: dict[str, str]) -> None:
 
 
 def _patch_http_options(
-    options: HttpOptions, patch_options: HttpOptions
-) -> HttpOptions:
+    options: HttpOptionsDict, patch_options: HttpOptionsDict
+) -> HttpOptionsDict:
   # use shallow copy so we don't override the original objects.
-  copy_option = HttpOptions()
+  copy_option = HttpOptionsDict()
   copy_option.update(options)
-  for k, v in patch_options.items():
+  for patch_key, patch_value in patch_options.items():
     # if both are dicts, update the copy.
     # This is to handle cases like merging headers.
-    if isinstance(v, dict) and isinstance(copy_option.get(k, None), dict):
-      copy_option[k] = {}
-      copy_option[k].update(options[k])  # shallow copy from original options.
-      copy_option[k].update(v)
-    elif v is not None:  # Accept empty values.
-      copy_option[k] = v
+    if isinstance(patch_value, dict) and isinstance(
+        copy_option.get(patch_key, None), dict
+    ):
+      copy_option[patch_key] = {}
+      copy_option[patch_key].update(
+          options[patch_key]
+      )  # shallow copy from original options.
+      copy_option[patch_key].update(patch_value)
+    elif patch_value is not None:  # Accept empty values.
+      copy_option[patch_key] = patch_value
   _append_library_version_headers(copy_option['headers'])
   return copy_option
 
@@ -98,10 +133,11 @@ def _join_url_path(base_url: str, path: str) -> str:
 
 @dataclass
 class HttpRequest:
-  headers: dict[str, str]
+  headers: dict[str, Union[str, list[str]]]
   url: str
   method: str
   data: Union[dict[str, object], bytes]
+  timeout: Optional[Union[float, Tuple[float, float]]] = None
 
 
 class HttpResponse:
@@ -147,7 +183,7 @@ class ApiClient:
       credentials: google.auth.credentials.Credentials = None,
       project: Union[str, None] = None,
       location: Union[str, None] = None,
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsOrDict = None,
   ):
     self.vertexai = vertexai
     if self.vertexai is None:
@@ -163,11 +199,20 @@ class ApiClient:
           'Project/location and API key are mutually exclusive in the client initializer.'
       )
 
+    # Validate http_options if a dict is provided.
+    if isinstance(http_options, dict):
+      try:
+        HttpOptions.model_validate(http_options)
+      except ValidationError as e:
+        raise ValueError(f'Invalid http_options: {e}')
+    elif(isinstance(http_options, HttpOptions)):
+      http_options = http_options.model_dump()
+
     self.api_key: Optional[str] = None
     self.project = project or os.environ.get('GOOGLE_CLOUD_PROJECT', None)
     self.location = location or os.environ.get('GOOGLE_CLOUD_LOCATION', None)
     self._credentials = credentials
-    self._http_options = HttpOptions()
+    self._http_options = HttpOptionsDict()
 
     if self.vertexai:
       if not self.project:
@@ -208,7 +253,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ) -> HttpRequest:
     # Remove all special dict keys such as _url and _query.
     keys_to_delete = [key for key in request_dict.keys() if key.startswith('_')]
@@ -232,6 +277,7 @@ class ApiClient:
         url=url,
         headers=patched_http_options['headers'],
         data=request_dict,
+        timeout=patched_http_options.get('timeout', None),
     )
 
   def _request(
@@ -241,17 +287,19 @@ class ApiClient:
   ) -> HttpResponse:
     if self.vertexai:
       if not self._credentials:
-        self._credentials, _ = google.auth.default()
+        self._credentials, _ = google.auth.default(
+            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+        )
       authed_session = AuthorizedSession(self._credentials)
       authed_session.stream = stream
       response = authed_session.request(
           http_request.method.upper(),
           http_request.url,
           headers=http_request.headers,
-          data=json.dumps(http_request.data, cls=RequestJsonEncoder) if http_request.data else None,
-          # TODO: support timeout in RequestOptions so it can be configured
-          # per methods.
-          timeout=None,
+          data=json.dumps(http_request.data, cls=RequestJsonEncoder)
+          if http_request.data
+          else None,
+          timeout=http_request.timeout,
       )
       errors.APIError.raise_for_response(response)
       return HttpResponse(
@@ -273,13 +321,14 @@ class ApiClient:
         data = http_request.data
 
     http_session = requests.Session()
-    request = requests.Request(
+    response = http_session.request(
         method=http_request.method,
         url=http_request.url,
         headers=http_request.headers,
         data=data,
-    ).prepare()
-    response = http_session.send(request, stream=stream)
+        timeout=http_request.timeout,
+        stream=stream,
+    )
     errors.APIError.raise_for_response(response)
     return HttpResponse(
         response.headers, response if stream else [response.text]
@@ -290,7 +339,9 @@ class ApiClient:
   ):
     if self.vertexai:
       if not self._credentials:
-        self._credentials, _ = google.auth.default()
+        self._credentials, _ = google.auth.default(
+            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+        )
       return await asyncio.to_thread(
           self._request,
           http_request,
@@ -303,8 +354,10 @@ class ApiClient:
           stream=stream,
       )
 
-  def get_read_only_http_options(self) -> HttpOptions:
-    copied = HttpOptions()
+  def get_read_only_http_options(self) -> HttpOptionsDict:
+    copied = HttpOptionsDict()
+    if isinstance(self._http_options, BaseModel):
+      self._http_options = self._http_options.model_dump()
     copied.update(self._http_options)
     return copied
 
@@ -313,7 +366,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -328,7 +381,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -345,7 +398,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ) -> dict[str, object]:
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -361,7 +414,7 @@ class ApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: HttpOptions = None,
+      http_options: HttpOptionsDict = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options

google/genai/_automatic_function_calling_util.py

@@ -58,8 +58,8 @@ def _raise_for_nullable_if_mldev(schema: types.Schema):
     )
 
 
-def _raise_if_schema_unsupported(client, schema: types.Schema):
-  if not client.vertexai:
+def _raise_if_schema_unsupported(variant: str, schema: types.Schema):
+  if not variant == 'VERTEX_AI':
     _raise_for_any_of_if_mldev(schema)
     _raise_for_default_if_mldev(schema)
     _raise_for_nullable_if_mldev(schema)
@@ -112,7 +112,7 @@ def _is_default_value_compatible(
 
 
 def _parse_schema_from_parameter(
-    client, param: inspect.Parameter, func_name: str
+    variant: str, param: inspect.Parameter, func_name: str
 ) -> types.Schema:
   """parse schema from parameter.
 
@@ -130,7 +130,7 @@ def _parse_schema_from_parameter(
         raise ValueError(default_value_error_msg)
       schema.default = param.default
     schema.type = _py_builtin_type_to_schema_type[param.annotation]
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   if (
       isinstance(param.annotation, typing_types.UnionType)
@@ -149,7 +149,7 @@ def _parse_schema_from_parameter(
         schema.nullable = True
         continue
       schema_in_any_of = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               'item', inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=arg
           ),
@@ -170,9 +170,8 @@ def _parse_schema_from_parameter(
     ):
       if not _is_default_value_compatible(param.default, param.annotation):
         raise ValueError(default_value_error_msg)
-      # TODO: b/379715133 - handle pydantic model default value
       schema.default = param.default
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   if isinstance(param.annotation, _GenericAlias) or isinstance(
       param.annotation, typing_types.GenericAlias
@@ -185,7 +184,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is Literal:
       if not all(isinstance(arg, str) for arg in args):
@@ -198,12 +197,12 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is list:
       schema.type = 'ARRAY'
       schema.items = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               'item',
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -215,7 +214,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
     if origin is Union:
       schema.any_of = []
@@ -226,7 +225,7 @@ def _parse_schema_from_parameter(
           schema.nullable = True
           continue
         schema_in_any_of = _parse_schema_from_parameter(
-            client,
+            variant,
             inspect.Parameter(
                 'item',
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -250,7 +249,7 @@ def _parse_schema_from_parameter(
         if not _is_default_value_compatible(param.default, param.annotation):
           raise ValueError(default_value_error_msg)
         schema.default = param.default
-      _raise_if_schema_unsupported(client, schema)
+      _raise_if_schema_unsupported(variant, schema)
       return schema
       # all other generic alias will be invoked in raise branch
   if (
@@ -258,17 +257,16 @@ def _parse_schema_from_parameter(
       # for user defined class, we only support pydantic model
       and issubclass(param.annotation, pydantic.BaseModel)
   ):
-    if param.default is not inspect.Parameter.empty:
-      # TODO: b/379715133 - handle pydantic model default value
-      raise ValueError(
-          f'Default value {param.default} of Pydantic model{param} of function'
-          f' {func_name} is not supported.'
-      )
+    if (
+        param.default is not inspect.Parameter.empty
+        and param.default is not None
+    ):
+      schema.default = param.default
     schema.type = 'OBJECT'
     schema.properties = {}
     for field_name, field_info in param.annotation.model_fields.items():
       schema.properties[field_name] = _parse_schema_from_parameter(
-          client,
+          variant,
           inspect.Parameter(
               field_name,
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -276,7 +274,7 @@ def _parse_schema_from_parameter(
           ),
           func_name,
       )
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(variant, schema)
     return schema
   raise ValueError(
       f'Failed to parse the parameter {param} of function {func_name} for'
@@ -294,4 +292,3 @@ def _get_required_fields(schema: types.Schema) -> list[str]:
       for field_name, field_schema in schema.properties.items()
       if not field_schema.nullable and field_schema.default is None
   ]
-

google/genai/_replay_api_client.py

@@ -15,6 +15,7 @@
 
 """Replay API client."""
 
+import base64
 import copy
 import inspect
 import json
@@ -105,28 +106,6 @@ def redact_http_request(http_request: HttpRequest):
   _redact_request_body(http_request.data)
 
 
-def process_bytes_fields(data: dict[str, object]):
-  """Converts bytes fields to strings.
-
-  This function doesn't modify the content of data dict.
-  """
-  if not isinstance(data, dict):
-    return data
-  for key, value in data.items():
-    if isinstance(value, bytes):
-      data[key] = value.decode()
-    elif isinstance(value, dict):
-      process_bytes_fields(value)
-    elif isinstance(value, list):
-      if all(isinstance(v, bytes) for v in value):
-        data[key] = [v.decode() for v in value]
-      else:
-        data[key] = [process_bytes_fields(v) for v in value]
-    else:
-      data[key] = value
-  return data
-
-
 def _current_file_path_and_line():
   """Prints the current file path and line number."""
   frame = inspect.currentframe().f_back.f_back
@@ -185,7 +164,7 @@ class ReplayFile(BaseModel):
 
 
 class ReplayApiClient(ApiClient):
-  """For integration testing, send recorded responese or records a response."""
+  """For integration testing, send recorded response or records a response."""
 
   def __init__(
       self,
@@ -280,9 +259,18 @@ class ReplayApiClient(ApiClient):
     replay_file_path = self._get_replay_file_path()
     os.makedirs(os.path.dirname(replay_file_path), exist_ok=True)
     with open(replay_file_path, 'w') as f:
+      replay_session_dict = self.replay_session.model_dump()
+      # Use for non-utf-8 bytes in image/video... output.
+      for interaction in replay_session_dict['interactions']:
+        segments = []
+        for response in interaction['response']['sdk_response_segments']:
+          segments.append(json.loads(json.dumps(
+              response, cls=ResponseJsonEncoder
+          )))
+        interaction['response']['sdk_response_segments'] = segments
       f.write(
           json.dumps(
-              self.replay_session.model_dump(), indent=2, cls=RequestJsonEncoder
+              replay_session_dict, indent=2, cls=RequestJsonEncoder
           )
       )
     self.replay_session = None
@@ -463,10 +451,16 @@ class ResponseJsonEncoder(json.JSONEncoder):
   """
   def default(self, o):
     if isinstance(o, bytes):
-      # use error replace because response need to be serialized with bytes
-      # string, not base64 string. Otherwise, we cannot tell the response is
-      # already decoded from base64 or not from the replay file.
-      return o.decode(encoding='utf-8', errors='replace')
+      # Use base64.b64encode() to encode bytes to string so that the media bytes
+      # fields are serializable.
+      # o.decode(encoding='utf-8', errors='replace') doesn't work because it
+      # uses a fixed error string `\ufffd` for all non-utf-8 characters,
+      # which cannot be converted back to original bytes. And other languages
+      # only have the original bytes to compare with.
+      # Since we use base64.b64encoding() in replay test, a change that breaks
+      # native bytes can be captured by
+      # test_compute_tokens.py::test_token_bytes_deserialization.
+      return base64.b64encode(o).decode(encoding='utf-8')
     elif isinstance(o, datetime.datetime):
       # dt.isoformat() prints "2024-11-15T23:27:45.624657+00:00"
       # but replay files want "2024-11-15T23:27:45.624657Z"

google/genai/_transformers.py

@@ -24,6 +24,7 @@ import time
 from typing import Any, Optional, Union
 
 import PIL.Image
+import PIL.PngImagePlugin
 
 from . import _api_client
 from . import types
@@ -298,6 +299,20 @@ def t_speech_config(
             prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=origin)
         )
     )
+  if (
+      isinstance(origin, dict)
+      and 'voice_config' in origin
+      and 'prebuilt_voice_config' in origin['voice_config']
+  ):
+    return types.SpeechConfig(
+        voice_config=types.VoiceConfig(
+            prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                voice_name=origin['voice_config']['prebuilt_voice_config'].get(
+                    'voice_name'
+                )
+            )
+        )
+    )
   raise ValueError(f'Unsupported speechConfig type: {type(origin)}')
 
 

google/genai/batches.py

@@ -31,13 +31,13 @@ def _BatchJobSource_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['format']):
+  if getv(from_object, ['format']) is not None:
     raise ValueError('format parameter is not supported in Google AI.')
 
-  if getv(from_object, ['gcs_uri']):
+  if getv(from_object, ['gcs_uri']) is not None:
     raise ValueError('gcs_uri parameter is not supported in Google AI.')
 
-  if getv(from_object, ['bigquery_uri']):
+  if getv(from_object, ['bigquery_uri']) is not None:
     raise ValueError('bigquery_uri parameter is not supported in Google AI.')
 
   return to_object
@@ -71,13 +71,13 @@ def _BatchJobDestination_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['format']):
+  if getv(from_object, ['format']) is not None:
     raise ValueError('format parameter is not supported in Google AI.')
 
-  if getv(from_object, ['gcs_uri']):
+  if getv(from_object, ['gcs_uri']) is not None:
     raise ValueError('gcs_uri parameter is not supported in Google AI.')
 
-  if getv(from_object, ['bigquery_uri']):
+  if getv(from_object, ['bigquery_uri']) is not None:
     raise ValueError('bigquery_uri parameter is not supported in Google AI.')
 
   return to_object
@@ -121,7 +121,7 @@ def _CreateBatchJobConfig_to_mldev(
   if getv(from_object, ['display_name']) is not None:
     setv(parent_object, ['displayName'], getv(from_object, ['display_name']))
 
-  if getv(from_object, ['dest']):
+  if getv(from_object, ['dest']) is not None:
     raise ValueError('dest parameter is not supported in Google AI.')
 
   return to_object
@@ -159,10 +159,10 @@ def _CreateBatchJobParameters_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['model']):
+  if getv(from_object, ['model']) is not None:
     raise ValueError('model parameter is not supported in Google AI.')
 
-  if getv(from_object, ['src']):
+  if getv(from_object, ['src']) is not None:
     raise ValueError('src parameter is not supported in Google AI.')
 
   if getv(from_object, ['config']) is not None:
@@ -243,7 +243,7 @@ def _GetBatchJobParameters_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['name']):
+  if getv(from_object, ['name']) is not None:
     raise ValueError('name parameter is not supported in Google AI.')
 
   if getv(from_object, ['config']) is not None:
@@ -313,7 +313,7 @@ def _CancelBatchJobParameters_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['name']):
+  if getv(from_object, ['name']) is not None:
     raise ValueError('name parameter is not supported in Google AI.')
 
   if getv(from_object, ['config']) is not None:
@@ -374,7 +374,7 @@ def _ListBatchJobConfig_to_mldev(
         getv(from_object, ['page_token']),
     )
 
-  if getv(from_object, ['filter']):
+  if getv(from_object, ['filter']) is not None:
     raise ValueError('filter parameter is not supported in Google AI.')
 
   return to_object
@@ -413,7 +413,7 @@ def _ListBatchJobParameters_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['config']):
+  if getv(from_object, ['config']) is not None:
     raise ValueError('config parameter is not supported in Google AI.')
 
   return to_object
@@ -443,7 +443,7 @@ def _DeleteBatchJobParameters_to_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
-  if getv(from_object, ['name']):
+  if getv(from_object, ['name']) is not None:
     raise ValueError('name parameter is not supported in Google AI.')
 
   return to_object
@@ -947,7 +947,7 @@ class Batches(_common.BaseModule):
     Args:
       model (str): The model to use for the batch job.
       src (str): The source of the batch job. Currently supports GCS URI(-s) or
-        Bigquery URI. Example: "gs://path/to/input/data" or
+        BigQuery URI. Example: "gs://path/to/input/data" or
         "bq://projectId.bqDatasetId.bqTableId".
       config (CreateBatchJobConfig): Optional configuration for the batch job.
 
@@ -1243,7 +1243,7 @@ class AsyncBatches(_common.BaseModule):
     Args:
       model (str): The model to use for the batch job.
       src (str): The source of the batch job. Currently supports GCS URI(-s) or
-        Bigquery URI. Example: "gs://path/to/input/data" or
+        BigQuery URI. Example: "gs://path/to/input/data" or
         "bq://projectId.bqDatasetId.bqTableId".
       config (CreateBatchJobConfig): Optional configuration for the batch job.