google-genai 0.8.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

google/genai/_api_client.py

@@ -99,6 +99,19 @@ class HttpRequest:
   timeout: Optional[float] = None
 
 
+# TODO(b/394358912): Update this class to use a SDKResponse class that can be
+# generated and used for all languages.
+@dataclass
+class BaseResponse:
+  http_headers: dict[str, str]
+
+  @property
+  def dict(self) -> dict[str, Any]:
+    if isinstance(self, dict):
+      return self
+    return {'httpHeaders': self.http_headers}
+
+
 class HttpResponse:
 
   def __init__(
@@ -434,18 +447,12 @@ class ApiClient:
         http_method, path, request_dict, http_options
     )
     response = self._request(http_request, stream=False)
-    if http_options:
-      if (
-          isinstance(http_options, HttpOptions)
-          and http_options.deprecated_response_payload is not None
-      ):
-        response._copy_to_dict(http_options.deprecated_response_payload)
-      elif (
-          isinstance(http_options, dict)
-          and 'deprecated_response_payload' in http_options
-      ):
-        response._copy_to_dict(http_options['deprecated_response_payload'])
-    return response.json
+    json_response = response.json
+    if not json_response:
+      base_response = BaseResponse(response.headers).dict
+      return base_response
+
+    return json_response
 
   def request_streamed(
       self,
@@ -459,10 +466,6 @@ class ApiClient:
     )
 
     session_response = self._request(http_request, stream=True)
-    if http_options and 'deprecated_response_payload' in http_options:
-      session_response._copy_to_dict(
-          http_options['deprecated_response_payload']
-      )
     for chunk in session_response.segments():
       yield chunk
 
@@ -478,9 +481,11 @@ class ApiClient:
     )
 
     result = await self._async_request(http_request=http_request, stream=False)
-    if http_options and 'deprecated_response_payload' in http_options:
-      result._copy_to_dict(http_options['deprecated_response_payload'])
-    return result.json
+    json_response = result.json
+    if not json_response:
+      base_response = BaseResponse(result.headers).dict
+      return base_response
+    return json_response
 
   async def async_request_streamed(
       self,
@@ -495,8 +500,6 @@ class ApiClient:
 
     response = await self._async_request(http_request=http_request, stream=True)
 
-    if http_options and 'deprecated_response_payload' in http_options:
-      response._copy_to_dict(http_options['deprecated_response_payload'])
     async def async_generator():
       async for chunk in response:
         yield chunk

google/genai/_automatic_function_calling_util.py

@@ -17,14 +17,18 @@ import inspect
 import sys
 import types as builtin_types
 import typing
-from typing import Any, Callable, Literal, Union, _GenericAlias, get_args, get_origin
+from typing import _GenericAlias, Any, Callable, get_args, get_origin, Literal, Union
+
 import pydantic
+
+from . import _extra_utils
 from . import types
 
+
 if sys.version_info >= (3, 10):
-  UnionType = builtin_types.UnionType
+  VersionedUnionType = builtin_types.UnionType
 else:
-  UnionType = typing._UnionGenericAlias
+  VersionedUnionType = typing._UnionGenericAlias
 
 _py_builtin_type_to_schema_type = {
     str: 'STRING',
@@ -45,7 +49,8 @@ def _is_builtin_primitive_or_compound(
 def _raise_for_any_of_if_mldev(schema: types.Schema):
   if schema.any_of:
     raise ValueError(
-        'AnyOf is not supported in function declaration schema for Google AI.'
+        'AnyOf is not supported in function declaration schema for'
+        ' the Gemini API.'
     )
 
 
@@ -53,15 +58,7 @@ def _raise_for_default_if_mldev(schema: types.Schema):
   if schema.default is not None:
     raise ValueError(
         'Default value is not supported in function declaration schema for'
-        ' Google AI.'
-    )
-
-
-def _raise_for_nullable_if_mldev(schema: types.Schema):
-  if schema.nullable:
-    raise ValueError(
-        'Nullable is not supported in function declaration schema for'
-        ' Google AI.'
+        ' the Gemini API.'
     )
 
 
@@ -69,7 +66,6 @@ def _raise_if_schema_unsupported(client, schema: types.Schema):
   if not client.vertexai:
     _raise_for_any_of_if_mldev(schema)
     _raise_for_default_if_mldev(schema)
-    _raise_for_nullable_if_mldev(schema)
 
 
 def _is_default_value_compatible(
@@ -82,10 +78,10 @@ def _is_default_value_compatible(
   if (
       isinstance(annotation, _GenericAlias)
       or isinstance(annotation, builtin_types.GenericAlias)
-      or isinstance(annotation, UnionType)
+      or isinstance(annotation, VersionedUnionType)
   ):
     origin = get_origin(annotation)
-    if origin in (Union, UnionType):
+    if origin in (Union, VersionedUnionType):
       return any(
           _is_default_value_compatible(default_value, arg)
           for arg in get_args(annotation)
@@ -141,7 +137,7 @@ def _parse_schema_from_parameter(
     _raise_if_schema_unsupported(client, schema)
     return schema
   if (
-      isinstance(param.annotation, UnionType)
+      isinstance(param.annotation, VersionedUnionType)
       # only parse simple UnionType, example int | str | float | bool
       # complex UnionType will be invoked in raise branch
       and all(
@@ -229,7 +225,11 @@ def _parse_schema_from_parameter(
       schema.type = 'OBJECT'
       unique_types = set()
       for arg in args:
-        if arg.__name__ == 'NoneType':  # Optional type
+        # The first check is for NoneType in Python 3.9, since the __name__
+        # attribute is not available in Python 3.9
+        if type(arg) is type(None) or (
+            hasattr(arg, '__name__') and arg.__name__ == 'NoneType'
+        ):  # Optional type
           schema.nullable = True
           continue
         schema_in_any_of = _parse_schema_from_parameter(
@@ -272,9 +272,8 @@ def _parse_schema_from_parameter(
       return schema
       # all other generic alias will be invoked in raise branch
   if (
-      inspect.isclass(param.annotation)
       # for user defined class, we only support pydantic model
-      and issubclass(param.annotation, pydantic.BaseModel)
+      _extra_utils.is_annotation_pydantic_model(param.annotation)
   ):
     if (
         param.default is not inspect.Parameter.empty

google/genai/_common.py

@@ -18,6 +18,7 @@
 import base64
 import datetime
 import enum
+import functools
 import typing
 from typing import Union
 import uuid
@@ -27,6 +28,7 @@ import pydantic
 from pydantic import alias_generators
 
 from . import _api_client
+from . import errors
 
 
 def set_value_by_path(data, keys, value):
@@ -273,3 +275,23 @@ def encode_unserializable_types(data: dict[str, object]) -> dict[str, object]:
     else:
       processed_data[key] = value
   return processed_data
+
+
+def experimental_warning(message: str):
+  """Experimental warning, only warns once."""
+  def decorator(func):
+    warning_done = False
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+      nonlocal warning_done
+      if not warning_done:
+        warning_done = True
+        warnings.warn(
+            message=message,
+            category=errors.ExperimentalWarning,
+            stacklevel=2,
+        )
+      return func(*args, **kwargs)
+    return wrapper
+  return decorator
+

google/genai/_extra_utils.py

@@ -108,16 +108,22 @@ def convert_number_values_for_function_call_args(
   return args
 
 
-def _is_annotation_pydantic_model(annotation: Any) -> bool:
-  return inspect.isclass(annotation) and issubclass(
-      annotation, pydantic.BaseModel
-  )
+def is_annotation_pydantic_model(annotation: Any) -> bool:
+  try:
+    return inspect.isclass(annotation) and issubclass(
+        annotation, pydantic.BaseModel
+    )
+  # for python 3.10 and below, inspect.isclass(annotation) has inconsistent
+  # results with versions above. for example, inspect.isclass(dict[str, int]) is
+  # True in 3.10 and below but False in 3.11 and above.
+  except TypeError:
+    return False
 
 
 def convert_if_exist_pydantic_model(
     value: Any, annotation: Any, param_name: str, func_name: str
 ) -> Any:
-  if isinstance(value, dict) and _is_annotation_pydantic_model(annotation):
+  if isinstance(value, dict) and is_annotation_pydantic_model(annotation):
     try:
       return annotation(**value)
     except pydantic.ValidationError as e:
@@ -146,7 +152,7 @@ def convert_if_exist_pydantic_model(
       if (
           (get_args(arg) and get_origin(arg) is list)
           or isinstance(value, arg)
-          or (isinstance(value, dict) and _is_annotation_pydantic_model(arg))
+          or (isinstance(value, dict) and is_annotation_pydantic_model(arg))
       ):
         try:
           return convert_if_exist_pydantic_model(

google/genai/_replay_api_client.py

@@ -362,6 +362,8 @@ class ReplayApiClient(ApiClient):
     if self._should_update_replay():
       if isinstance(response_model, list):
         response_model = response_model[0]
+      if response_model and 'http_headers' in response_model.model_fields:
+        response_model.http_headers.pop('Date', None)
       interaction.response.sdk_response_segments.append(
           response_model.model_dump(exclude_none=True)
       )

google/genai/_transformers.py

@@ -34,10 +34,12 @@ import pydantic
 from . import _api_client
 from . import types
 
-if sys.version_info >= (3, 11):
-  from types import UnionType
+if sys.version_info >= (3, 10):
+  VersionedUnionType = typing.types.UnionType
+  _UNION_TYPES = (typing.Union, typing.types.UnionType)
 else:
-  UnionType = typing._UnionGenericAlias
+  VersionedUnionType = typing._UnionGenericAlias
+  _UNION_TYPES = (typing.Union,)
 
 
 def _resource_name(
@@ -225,6 +227,7 @@ PartType = Union[types.Part, types.PartDict, str, 'PIL.Image.Image']
 def t_part(client: _api_client.ApiClient, part: PartType) -> types.Part:
   try:
     import PIL.Image
+
     PIL_Image = PIL.Image.Image
   except ImportError:
     PIL_Image = None
@@ -342,7 +345,7 @@ def handle_null_fields(schema: dict[str, Any]):
               "type": "null"
             }
           ],
-          "default": null,
+          "default": None,
           "title": "Total Area Sq Mi"
         }
       }
@@ -356,16 +359,12 @@ def handle_null_fields(schema: dict[str, Any]):
         "total_area_sq_mi": {
           "type": "integer",
           "nullable": true,
-          "default": null,
+          "default": None,
           "title": "Total Area Sq Mi"
         }
       }
   """
-  if (
-      isinstance(schema, dict)
-      and 'type' in schema
-      and schema['type'] == 'null'
-  ):
+  if schema.get('type', None) == 'null':
     schema['nullable'] = True
     del schema['type']
   elif 'anyOf' in schema:
@@ -445,6 +444,11 @@ def process_schema(
   if client and not client.vertexai:
     schema.pop('title', None)
 
+    if schema.get('default') is not None:
+      raise ValueError(
+          'Default value is not supported in the response schema for the Gemmini API.'
+      )
+
   if defs is None:
     defs = schema.pop('$defs', {})
     for _, sub_schema in defs.items():
@@ -454,8 +458,19 @@ def process_schema(
 
   any_of = schema.get('anyOf', None)
   if any_of is not None:
+    if not client.vertexai:
+      raise ValueError(
+          'AnyOf is not supported in the response schema for the Gemini API.'
+      )
     for sub_schema in any_of:
-      process_schema(sub_schema, client, defs)
+      # $ref is present in any_of if the schema is a union of Pydantic classes
+      ref_key = sub_schema.get('$ref', None)
+      if ref_key is None:
+        process_schema(sub_schema, client, defs)
+      else:
+        ref = defs[ref_key.split('defs/')[-1]]
+        any_of.append(ref)
+    schema['anyOf'] = [item for item in any_of if '$ref' not in item]
     return
 
   schema_type = schema.get('type', None)
@@ -526,15 +541,18 @@ def t_schema(
   if (
       # in Python 3.9 Generic alias list[int] counts as a type,
       # and breaks issubclass because it's not a class.
-      not isinstance(origin, GenericAlias) and 
-      isinstance(origin, type) and 
+      not isinstance(origin, GenericAlias) and
+      isinstance(origin, type) and
       issubclass(origin, pydantic.BaseModel)
   ):
     schema = origin.model_json_schema()
     process_schema(schema, client)
     return types.Schema.model_validate(schema)
   elif (
-        isinstance(origin, GenericAlias) or isinstance(origin, type) or isinstance(origin, UnionType)
+      isinstance(origin, GenericAlias)
+      or isinstance(origin, type)
+      or isinstance(origin, VersionedUnionType)
+      or typing.get_origin(origin) in _UNION_TYPES
   ):
     class Placeholder(pydantic.BaseModel):
       placeholder: origin

google/genai/errors.py

@@ -128,3 +128,7 @@ class FunctionInvocationError(ValueError):
   """Raised when the function cannot be invoked with the given arguments."""
 
   pass
+
+
+class ExperimentalWarning(Warning):
+  """Warning for experimental features."""

google/genai/files.py

@@ -19,7 +19,7 @@ import io
 import mimetypes
 import os
 import pathlib
-from typing import Optional, Union
+from typing import Any, Optional, Union
 from urllib.parse import urlencode
 from . import _api_module
 from . import _common
@@ -351,12 +351,12 @@ def _DeleteFileParameters_to_vertex(
   return to_object
 
 
-def _FileState_to_vertex_enum_validate(enum_value: any):
+def _FileState_to_vertex_enum_validate(enum_value: Any):
   if enum_value in set(['STATE_UNSPECIFIED', 'PROCESSING', 'ACTIVE', 'FAILED']):
     raise ValueError(f'{enum_value} enum value is not supported in Vertex AI.')
 
 
-def _FileSource_to_vertex_enum_validate(enum_value: any):
+def _FileSource_to_vertex_enum_validate(enum_value: Any):
   if enum_value in set(['SOURCE_UNSPECIFIED', 'UPLOADED', 'GENERATED']):
     raise ValueError(f'{enum_value} enum value is not supported in Vertex AI.')
 
@@ -494,6 +494,8 @@ def _CreateFileResponse_from_mldev(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
+  if getv(from_object, ['httpHeaders']) is not None:
+    setv(to_object, ['http_headers'], getv(from_object, ['httpHeaders']))
 
   return to_object
 
@@ -504,6 +506,8 @@ def _CreateFileResponse_from_vertex(
     parent_object: dict = None,
 ) -> dict:
   to_object = {}
+  if getv(from_object, ['httpHeaders']) is not None:
+    setv(to_object, ['http_headers'], getv(from_object, ['httpHeaders']))
 
   return to_object
 
@@ -840,7 +844,7 @@ class Files(_api_module.BaseModule):
             'Unknown mime type: Could not determine the mimetype for your'
             ' file\n    please set the `mime_type` argument'
         )
-    response = {}
+
     if config_model and config_model.http_options:
       http_options = config_model.http_options
     else:
@@ -853,19 +857,20 @@ class Files(_api_module.BaseModule):
               'X-Goog-Upload-Header-Content-Length': f'{file_obj.size_bytes}',
               'X-Goog-Upload-Header-Content-Type': f'{file_obj.mime_type}',
           },
-          'deprecated_response_payload': response,
       }
-    self._create(file=file_obj, config={'http_options': http_options})
+    response = self._create(
+        file=file_obj, config={'http_options': http_options}
+    )
 
     if (
-        'headers' not in response
-        or 'X-Goog-Upload-URL' not in response['headers']
+        response.http_headers is None
+        or 'X-Goog-Upload-URL' not in response.http_headers
     ):
       raise KeyError(
           'Failed to create file. Upload URL did not returned from the create'
           ' file request.'
       )
-    upload_url = response['headers']['X-Goog-Upload-URL']
+    upload_url = response.http_headers['X-Goog-Upload-URL']
 
     if isinstance(file, io.IOBase):
       return_file = self._api_client.upload_file(
@@ -1272,7 +1277,6 @@ class AsyncFiles(_api_module.BaseModule):
             ' file\n    please set the `mime_type` argument'
         )
 
-    response = {}
     if config_model and config_model.http_options:
       http_options = config_model.http_options
     else:
@@ -1285,18 +1289,20 @@ class AsyncFiles(_api_module.BaseModule):
               'X-Goog-Upload-Header-Content-Length': f'{file_obj.size_bytes}',
               'X-Goog-Upload-Header-Content-Type': f'{file_obj.mime_type}',
           },
-          'deprecated_response_payload': response,
       }
-    await self._create(file=file_obj, config={'http_options': http_options})
+    response = await self._create(
+        file=file_obj, config={'http_options': http_options}
+    )
+
     if (
-        'headers' not in response
-        or 'X-Goog-Upload-URL' not in response['headers']
+        response.http_headers is None
+        or 'X-Goog-Upload-URL' not in response.http_headers
     ):
       raise KeyError(
           'Failed to create file. Upload URL did not returned from the create'
           ' file request.'
       )
-    upload_url = response['headers']['X-Goog-Upload-URL']
+    upload_url = response.http_headers['X-Goog-Upload-URL']
 
     if isinstance(file, io.IOBase):
       return_file = await self._api_client.async_upload_file(

google/genai/live.py

@@ -29,8 +29,10 @@ from . import _api_module
 from . import _common
 from . import _transformers as t
 from . import client
+from . import errors
 from . import types
 from ._api_client import ApiClient
+from ._common import experimental_warning
 from ._common import get_value_by_path as getv
 from ._common import set_value_by_path as setv
 from .models import _Content_from_mldev
@@ -633,6 +635,9 @@ class AsyncLive(_api_module.BaseModule):
     return_value['setup'].update(to_object)
     return return_value
 
+  @experimental_warning(
+      "The live API is experimental and may change in future versions.",
+  )
   @contextlib.asynccontextmanager
   async def connect(
       self,