google-genai 1.0.0rc0__py3-none-any.whl → 1.1.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,10 +17,14 @@ 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):
   VersionedUnionType = builtin_types.UnionType
 else:
@@ -58,8 +62,8 @@ def _raise_for_default_if_mldev(schema: types.Schema):
     )
 
 
-def _raise_if_schema_unsupported(client, schema: types.Schema):
-  if not client.vertexai:
+def _raise_if_schema_unsupported(api_option: Literal['VERTEX_AI', 'GEMINI_API'], schema: types.Schema):
+  if api_option == 'GEMINI_API':
     _raise_for_any_of_if_mldev(schema)
     _raise_for_default_if_mldev(schema)
 
@@ -110,7 +114,7 @@ def _is_default_value_compatible(
 
 
 def _parse_schema_from_parameter(
-    client,
+    api_option: Literal['VERTEX_AI', 'GEMINI_API'],
     param: inspect.Parameter,
     func_name: str,
 ) -> types.Schema:
@@ -130,7 +134,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(api_option, schema)
     return schema
   if (
       isinstance(param.annotation, VersionedUnionType)
@@ -149,7 +153,7 @@ def _parse_schema_from_parameter(
         schema.nullable = True
         continue
       schema_in_any_of = _parse_schema_from_parameter(
-          client,
+          api_option,
           inspect.Parameter(
               'item', inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=arg
           ),
@@ -171,7 +175,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(api_option, schema)
     return schema
   if isinstance(param.annotation, _GenericAlias) or isinstance(
       param.annotation, builtin_types.GenericAlias
@@ -184,7 +188,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(api_option, schema)
       return schema
     if origin is Literal:
       if not all(isinstance(arg, str) for arg in args):
@@ -197,12 +201,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(api_option, schema)
       return schema
     if origin is list:
       schema.type = 'ARRAY'
       schema.items = _parse_schema_from_parameter(
-          client,
+          api_option,
           inspect.Parameter(
               'item',
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -214,7 +218,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(api_option, schema)
       return schema
     if origin is Union:
       schema.any_of = []
@@ -229,7 +233,7 @@ def _parse_schema_from_parameter(
           schema.nullable = True
           continue
         schema_in_any_of = _parse_schema_from_parameter(
-            client,
+            api_option,
             inspect.Parameter(
                 'item',
                 inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -264,13 +268,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(api_option, schema)
       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
@@ -281,7 +284,7 @@ def _parse_schema_from_parameter(
     schema.properties = {}
     for field_name, field_info in param.annotation.model_fields.items():
       schema.properties[field_name] = _parse_schema_from_parameter(
-          client,
+          api_option,
           inspect.Parameter(
               field_name,
               inspect.Parameter.POSITIONAL_OR_KEYWORD,
@@ -289,9 +292,9 @@ def _parse_schema_from_parameter(
           ),
           func_name,
       )
-    if client.vertexai:
+    if api_option == 'VERTEX_AI':
       schema.required = _get_required_fields(schema)
-    _raise_if_schema_unsupported(client, schema)
+    _raise_if_schema_unsupported(api_option, schema)
     return schema
   raise ValueError(
       f'Failed to parse the parameter {param} of function {func_name} for'

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):
@@ -218,7 +220,8 @@ class CaseInSensitiveEnum(str, enum.Enum):
         warnings.warn(f"{value} is not a valid {cls.__name__}")
         try:
           # Creating a enum instance based on the value
-          unknown_enum_val = cls._new_member_(cls)  # pylint: disable=protected-access,attribute-error
+          # We need to use super() to avoid infinite recursion.
+          unknown_enum_val = super().__new__(cls, value)
           unknown_enum_val._name_ = str(value)  # pylint: disable=protected-access
           unknown_enum_val._value_ = value  # pylint: disable=protected-access
           return unknown_enum_val
@@ -273,3 +276,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(
@@ -265,8 +271,8 @@ def should_disable_afc(
       and int(config_model.automatic_function_calling.maximum_remote_calls) > 0
   ):
     logging.warning(
-        '`automatic_function_calling.disable` is set to `True`. But'
-        ' `automatic_function_calling.maximum_remote_calls` is set to be a'
+        '`automatic_function_calling.disable` is set to `True`. And'
+        ' `automatic_function_calling.maximum_remote_calls` is a'
         ' positive number'
         f' {config_model.automatic_function_calling.maximum_remote_calls}.'
         ' Disabling automatic function calling. If you want to enable'

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

@@ -374,8 +374,8 @@ def handle_null_fields(schema: dict[str, Any]):
         schema['anyOf'].remove({'type': 'null'})
         if len(schema['anyOf']) == 1:
           # If there is only one type left after removing null, remove the anyOf field.
-          field_type = schema['anyOf'][0]['type']
-          schema['type'] = field_type
+          for key,val in schema['anyOf'][0].items():
+            schema[key] = val
           del schema['anyOf']
 
 
@@ -446,9 +446,17 @@ def process_schema(
 
     if schema.get('default') is not None:
       raise ValueError(
-          'Default value is not supported in the response schema for the Gemmini API.'
+          'Default value is not supported in the response schema for the Gemini API.'
       )
 
+  if schema.get('title') == 'PlaceholderLiteralEnum':
+    schema.pop('title', None)
+
+  # If a dict is provided directly to response_schema, it may use `any_of`
+  # instead of `anyOf`. Otherwise model_json_schema() uses `anyOf`
+  if schema.get('any_of', None) is not None:
+    schema['anyOf'] = schema.pop('any_of')
+
   if defs is None:
     defs = schema.pop('$defs', {})
     for _, sub_schema in defs.items():
@@ -456,6 +464,15 @@ def process_schema(
 
   handle_null_fields(schema)
 
+  # After removing null fields, Optional fields with only one possible type
+  # will have a $ref key that needs to be flattened
+  # For example: {'default': None, 'description': 'Name of the person', 'nullable': True, '$ref': '#/$defs/TestPerson'}
+  if schema.get('$ref', None):
+    ref = defs[schema.get('$ref').split('defs/')[-1]]
+    for schema_key in list(ref.keys()):
+      schema[schema_key] = ref[schema_key]
+    del schema['$ref']
+
   any_of = schema.get('anyOf', None)
   if any_of is not None:
     if not client.vertexai:
@@ -478,6 +495,16 @@ def process_schema(
     schema_type = schema_type.value
   schema_type = schema_type.upper()
 
+  # model_json_schema() returns a schema with a 'const' field when a Literal with one value is provided as a pydantic field
+  # For example `genre: Literal['action']` becomes: {'const': 'action', 'title': 'Genre', 'type': 'string'}
+  const = schema.get('const', None)
+  if const is not None:
+    if schema_type == 'STRING':
+      schema['enum'] = [const]
+      del schema['const']
+    else:
+      raise ValueError('Literal values must be strings.')
+
   if schema_type == 'OBJECT':
     properties = schema.get('properties', None)
     if properties is None:
@@ -502,6 +529,7 @@ def process_schema(
       process_schema(ref, client, defs)
       schema['items'] = ref
 
+
 def _process_enum(
     enum: EnumMeta, client: Optional[_api_client.ApiClient] = None
 ) -> types.Schema:

google/genai/chats.py

@@ -57,12 +57,16 @@ class Chat(_BaseChat):
   """Chat session."""
 
   def send_message(
-      self, message: Union[list[PartUnionDict], PartUnionDict]
+      self,
+      message: Union[list[PartUnionDict], PartUnionDict],
+      config: Optional[GenerateContentConfigOrDict] = None,
   ) -> GenerateContentResponse:
     """Sends the conversation history with the additional message and returns the model's response.
 
     Args:
       message: The message to send to the model.
+      config:  Optional config to override the default Chat config for this
+        request.
 
     Returns:
       The model's response.
@@ -79,7 +83,7 @@ class Chat(_BaseChat):
     response = self._modules.generate_content(
         model=self._model,
         contents=self._curated_history + [input_content],
-        config=self._config,
+        config=config if config else self._config,
     )
     if _validate_response(response):
       if response.automatic_function_calling_history:
@@ -92,12 +96,16 @@ class Chat(_BaseChat):
     return response
 
   def send_message_stream(
-      self, message: Union[list[PartUnionDict], PartUnionDict]
+      self,
+      message: Union[list[PartUnionDict], PartUnionDict],
+      config: Optional[GenerateContentConfigOrDict] = None,
   ):
     """Sends the conversation history with the additional message and yields the model's response in chunks.
 
     Args:
       message: The message to send to the model.
+      config: Optional config to override the default Chat config for this
+        request.
 
     Yields:
       The model's response in chunks.
@@ -117,7 +125,7 @@ class Chat(_BaseChat):
     for chunk in self._modules.generate_content_stream(
         model=self._model,
         contents=self._curated_history + [input_content],
-        config=self._config,
+        config=config if config else self._config,
     ):
       if _validate_response(chunk):
         output_contents.append(chunk.candidates[0].content)
@@ -164,12 +172,16 @@ class AsyncChat(_BaseChat):
   """Async chat session."""
 
   async def send_message(
-      self, message: Union[list[PartUnionDict], PartUnionDict]
+      self,
+      message: Union[list[PartUnionDict], PartUnionDict],
+      config: Optional[GenerateContentConfigOrDict] = None,
   ) -> GenerateContentResponse:
     """Sends the conversation history with the additional message and returns model's response.
 
     Args:
       message: The message to send to the model.
+      config: Optional config to override the default Chat config for this
+        request.
 
     Returns:
       The model's response.
@@ -186,7 +198,7 @@ class AsyncChat(_BaseChat):
     response = await self._modules.generate_content(
         model=self._model,
         contents=self._curated_history + [input_content],
-        config=self._config,
+        config=config if config else self._config,
     )
     if _validate_response(response):
       if response.automatic_function_calling_history:
@@ -199,12 +211,16 @@ class AsyncChat(_BaseChat):
     return response
 
   async def send_message_stream(
-      self, message: Union[list[PartUnionDict], PartUnionDict]
+      self,
+      message: Union[list[PartUnionDict], PartUnionDict],
+      config: Optional[GenerateContentConfigOrDict] = None,
   ) -> Awaitable[AsyncIterator[GenerateContentResponse]]:
     """Sends the conversation history with the additional message and yields the model's response in chunks.
 
     Args:
       message: The message to send to the model.
+      config: Optional config to override the default Chat config for this
+        request.
 
     Yields:
       The model's response in chunks.
@@ -225,7 +241,7 @@ class AsyncChat(_BaseChat):
       async for chunk in await self._modules.generate_content_stream(
           model=self._model,
           contents=self._curated_history + [input_content],
-          config=self._config,
+          config=config if config else self._config,
       ):
         if _validate_response(chunk):
           output_contents.append(chunk.candidates[0].content)

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

@@ -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,