google-genai 1.0.0rc0__py3-none-any.whl → 1.2.0__py3-none-any.whl

google/genai/_api_client.py

@@ -85,7 +85,11 @@ def _patch_http_options(
 
 def _join_url_path(base_url: str, path: str) -> str:
   parsed_base = urlparse(base_url)
-  base_path = parsed_base.path[:-1] if parsed_base.path.endswith('/') else parsed_base.path
+  base_path = (
+      parsed_base.path[:-1]
+      if parsed_base.path.endswith('/')
+      else parsed_base.path
+  )
   path = path[1:] if path.startswith('/') else path
   return urlunparse(parsed_base._replace(path=base_path + '/' + path))
 
@@ -99,6 +103,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__(
@@ -188,12 +205,14 @@ class ApiClient:
     if (project or location) and api_key:
       # API cannot consume both project/location and api_key.
       raise ValueError(
-          'Project/location and API key are mutually exclusive in the client initializer.'
+          'Project/location and API key are mutually exclusive in the client'
+          ' initializer.'
       )
     elif credentials and api_key:
       # API cannot consume both credentials and api_key.
       raise ValueError(
-          'Credentials and API key are mutually exclusive in the client initializer.'
+          'Credentials and API key are mutually exclusive in the client'
+          ' initializer.'
       )
 
     # Validate http_options if a dict is provided.
@@ -202,7 +221,7 @@ class ApiClient:
         HttpOptions.model_validate(http_options)
       except ValidationError as e:
         raise ValueError(f'Invalid http_options: {e}')
-    elif(isinstance(http_options, HttpOptions)):
+    elif isinstance(http_options, HttpOptions):
       http_options = http_options.model_dump()
 
     # Retrieve implicitly set values from the environment.
@@ -256,17 +275,19 @@ class ApiClient:
             'AI API.'
         )
       if self.api_key or self.location == 'global':
-        self._http_options['base_url'] = (
-            f'https://aiplatform.googleapis.com/'
-        )
+        self._http_options['base_url'] = f'https://aiplatform.googleapis.com/'
       else:
         self._http_options['base_url'] = (
             f'https://{self.location}-aiplatform.googleapis.com/'
         )
       self._http_options['api_version'] = 'v1beta1'
-    else:  # ML Dev API
+    else:  # Implicit initialization or missing arguments.
       if not self.api_key:
-        raise ValueError('API key must be set when using the Google AI API.')
+        raise ValueError(
+            'Missing key inputs argument! To use the Google AI 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/'
       )
@@ -350,7 +371,7 @@ class ApiClient:
     if self.vertexai and not self.api_key:
       if not self._credentials:
         self._credentials, _ = google.auth.default(
-            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            scopes=['https://www.googleapis.com/auth/cloud-platform'],
         )
       authed_session = AuthorizedSession(self._credentials)
       authed_session.stream = stream
@@ -358,9 +379,7 @@ class ApiClient:
           http_request.method.upper(),
           http_request.url,
           headers=http_request.headers,
-          data=json.dumps(http_request.data)
-          if http_request.data
-          else None,
+          data=json.dumps(http_request.data) if http_request.data else None,
           timeout=http_request.timeout,
       )
       errors.APIError.raise_for_response(response)
@@ -402,7 +421,7 @@ class ApiClient:
     if self.vertexai:
       if not self._credentials:
         self._credentials, _ = google.auth.default(
-            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            scopes=['https://www.googleapis.com/auth/cloud-platform'],
         )
       return await asyncio.to_thread(
           self._request,
@@ -434,18 +453,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 +472,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 +487,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,11 +506,10 @@ 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
+
     return async_generator()
 
   def upload_file(

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

@@ -21,10 +21,10 @@ from enum import Enum, EnumMeta
 import inspect
 import io
 import re
+import sys
 import time
 import typing
 from typing import Any, GenericAlias, Optional, Union
-import sys
 
 if typing.TYPE_CHECKING:
   import PIL.Image
@@ -205,12 +205,17 @@ def t_caches_model(api_client: _api_client.ApiClient, model: str):
 def pil_to_blob(img) -> types.Blob:
   try:
     import PIL.PngImagePlugin
+
     PngImagePlugin = PIL.PngImagePlugin
   except ImportError:
     PngImagePlugin = None
 
   bytesio = io.BytesIO()
-  if PngImagePlugin is not None and isinstance(img, PngImagePlugin.PngImageFile) or img.mode == 'RGBA':
+  if (
+      PngImagePlugin is not None
+      and isinstance(img, PngImagePlugin.PngImageFile)
+      or img.mode == 'RGBA'
+  ):
     img.save(bytesio, format='PNG')
     mime_type = 'image/png'
   else:
@@ -374,15 +379,18 @@ 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']
 
 
 def process_schema(
     schema: dict[str, Any],
     client: Optional[_api_client.ApiClient] = None,
-    defs: Optional[dict[str, Any]]=None):
+    defs: Optional[dict[str, Any]] = None,
+    *,
+    order_properties: bool = True,
+):
   """Updates the schema and each sub-schema inplace to be API-compatible.
 
   - Removes the `title` field from the schema if the client is not vertexai.
@@ -446,9 +454,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 +472,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 +503,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:
@@ -490,6 +525,16 @@ def process_schema(
         ref = defs[ref_key.split('defs/')[-1]]
         process_schema(ref, client, defs)
         properties[name] = ref
+    if (
+        len(properties.items()) > 1
+        and order_properties
+        and all(
+            ordering_key not in schema
+            for ordering_key in ['property_ordering', 'propertyOrdering']
+        )
+    ):
+      property_names = list(properties.keys())
+      schema['property_ordering'] = property_names
   elif schema_type == 'ARRAY':
     sub_schema = schema.get('items', None)
     if sub_schema is None:
@@ -502,6 +547,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:
@@ -511,6 +557,7 @@ def _process_enum(
           f'Enum member {member.name} value must be a string, got'
           f' {type(member.value)}'
       )
+
   class Placeholder(pydantic.BaseModel):
     placeholder: enum
 
@@ -526,7 +573,7 @@ def t_schema(
   if not origin:
     return None
   if isinstance(origin, dict):
-    process_schema(origin, client)
+    process_schema(origin, client, order_properties=False)
     return types.Schema.model_validate(origin)
   if isinstance(origin, EnumMeta):
     return _process_enum(origin, client)
@@ -535,15 +582,15 @@ def t_schema(
       # response_schema value was coerced to an empty Schema instance because it did not adhere to the Schema field annotation
       raise ValueError(f'Unsupported schema type.')
     schema = origin.model_dump(exclude_unset=True)
-    process_schema(schema, client)
+    process_schema(schema, client, order_properties=False)
     return types.Schema.model_validate(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
-      issubclass(origin, pydantic.BaseModel)
+      not isinstance(origin, GenericAlias)
+      and isinstance(origin, type)
+      and issubclass(origin, pydantic.BaseModel)
   ):
     schema = origin.model_json_schema()
     process_schema(schema, client)
@@ -554,6 +601,7 @@ def t_schema(
       or isinstance(origin, VersionedUnionType)
       or typing.get_origin(origin) in _UNION_TYPES
   ):
+
     class Placeholder(pydantic.BaseModel):
       placeholder: origin
 

google/genai/caches.py

@@ -172,8 +172,10 @@ def _Schema_to_mldev(
     raise ValueError('example parameter is not supported in Gemini API.')
 
   if getv(from_object, ['property_ordering']) is not None:
-    raise ValueError(
-        'property_ordering parameter is not supported in Gemini API.'
+    setv(
+        to_object,
+        ['propertyOrdering'],
+        getv(from_object, ['property_ordering']),
     )
 
   if getv(from_object, ['pattern']) is not None: