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

google/genai/_api_client.py

@@ -255,7 +255,7 @@ class ApiClient:
             'Project and location or API key must be set when using the Vertex '
             'AI API.'
         )
-      if self.api_key:
+      if self.api_key or self.location == 'global':
         self._http_options['base_url'] = (
             f'https://aiplatform.googleapis.com/'
         )
@@ -273,7 +273,7 @@ class ApiClient:
       self._http_options['api_version'] = 'v1beta'
     # Default options for both clients.
     self._http_options['headers'] = {'Content-Type': 'application/json'}
-    if self.api_key and not self.vertexai:
+    if self.api_key:
       self._http_options['headers']['x-goog-api-key'] = self.api_key
     # Update the http options with the user provided http options.
     if http_options:
@@ -323,8 +323,6 @@ class ApiClient:
         and not self.api_key
     ):
       path = f'projects/{self.project}/locations/{self.location}/' + path
-    elif self.vertexai and self.api_key:
-      path = f'{path}?key={self.api_key}'
     url = _join_url_path(
         patched_http_options['base_url'],
         patched_http_options['api_version'] + '/' + path,

google/genai/_automatic_function_calling_util.py

@@ -22,9 +22,9 @@ import pydantic
 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 +45,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 +54,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 +62,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 +74,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 +133,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 +221,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(

google/genai/_common.py

@@ -21,6 +21,7 @@ import enum
 import typing
 from typing import Union
 import uuid
+import warnings
 
 import pydantic
 from pydantic import alias_generators
@@ -213,8 +214,16 @@ class CaseInSensitiveEnum(str, enum.Enum):
     except KeyError:
       try:
         return cls[value.lower()]  # Try to access directly with lowercase
-      except KeyError as e:
-        raise ValueError(f"{value} is not a valid {cls.__name__}") from e
+      except KeyError:
+        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
+          unknown_enum_val._name_ = str(value)  # pylint: disable=protected-access
+          unknown_enum_val._value_ = value  # pylint: disable=protected-access
+          return unknown_enum_val
+        except:
+          return None
 
 
 def timestamped_unique_name() -> str:

google/genai/_operations.py

@@ -0,0 +1,365 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Code generated by the Google Gen AI SDK generator DO NOT EDIT.
+
+from typing import Optional, Union
+from urllib.parse import urlencode
+from . import _api_module
+from . import _common
+from . import types
+from ._api_client import ApiClient
+from ._common import get_value_by_path as getv
+from ._common import set_value_by_path as setv
+
+
+def _GetOperationParameters_to_mldev(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'operationName'],
+        getv(from_object, ['operation_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _GetOperationParameters_to_vertex(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'operationName'],
+        getv(from_object, ['operation_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _FetchPredictOperationParameters_to_mldev(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['operation_name']) is not None:
+    raise ValueError('operation_name parameter is not supported in Gemini API.')
+
+  if getv(from_object, ['resource_name']) is not None:
+    raise ValueError('resource_name parameter is not supported in Gemini API.')
+
+  if getv(from_object, ['config']) is not None:
+    raise ValueError('config parameter is not supported in Gemini API.')
+
+  return to_object
+
+
+def _FetchPredictOperationParameters_to_vertex(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['operation_name']) is not None:
+    setv(to_object, ['operationName'], getv(from_object, ['operation_name']))
+
+  if getv(from_object, ['resource_name']) is not None:
+    setv(
+        to_object,
+        ['_url', 'resourceName'],
+        getv(from_object, ['resource_name']),
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _Operation_from_mldev(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response']) is not None:
+    setv(to_object, ['response'], getv(from_object, ['response']))
+
+  return to_object
+
+
+def _Operation_from_vertex(
+    api_client: ApiClient,
+    from_object: Union[dict, object],
+    parent_object: dict = None,
+) -> dict:
+  to_object = {}
+  if getv(from_object, ['name']) is not None:
+    setv(to_object, ['name'], getv(from_object, ['name']))
+
+  if getv(from_object, ['metadata']) is not None:
+    setv(to_object, ['metadata'], getv(from_object, ['metadata']))
+
+  if getv(from_object, ['done']) is not None:
+    setv(to_object, ['done'], getv(from_object, ['done']))
+
+  if getv(from_object, ['error']) is not None:
+    setv(to_object, ['error'], getv(from_object, ['error']))
+
+  if getv(from_object, ['response']) is not None:
+    setv(to_object, ['response'], getv(from_object, ['response']))
+
+  return to_object
+
+
+class _operations(_api_module.BaseModule):
+
+  def _get_operation(
+      self,
+      *,
+      operation_name: str,
+      config: Optional[types.GetOperationConfigOrDict] = None,
+  ) -> types.Operation:
+    parameter_model = types._GetOperationParameters(
+        operation_name=operation_name,
+        config=config,
+    )
+
+    if self._api_client.vertexai:
+      request_dict = _GetOperationParameters_to_vertex(
+          self._api_client, parameter_model
+      )
+      path = '{operationName}'.format_map(request_dict.get('_url'))
+    else:
+      request_dict = _GetOperationParameters_to_mldev(
+          self._api_client, parameter_model
+      )
+      path = '{operationName}'.format_map(request_dict.get('_url'))
+    query_params = request_dict.get('_query')
+    if query_params:
+      path = f'{path}?{urlencode(query_params)}'
+    # TODO: remove the hack that pops config.
+    request_dict.pop('config', None)
+
+    http_options = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = self._api_client.request(
+        'get', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
+
+    return_value = types.Operation._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value
+
+  def _fetch_predict_operation(
+      self,
+      *,
+      operation_name: str,
+      resource_name: str,
+      config: Optional[types.FetchPredictOperationConfigOrDict] = None,
+  ) -> types.Operation:
+    parameter_model = types._FetchPredictOperationParameters(
+        operation_name=operation_name,
+        resource_name=resource_name,
+        config=config,
+    )
+
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
+      request_dict = _FetchPredictOperationParameters_to_vertex(
+          self._api_client, parameter_model
+      )
+      path = '{resourceName}:fetchPredictOperation'.format_map(
+          request_dict.get('_url')
+      )
+
+    query_params = request_dict.get('_query')
+    if query_params:
+      path = f'{path}?{urlencode(query_params)}'
+    # TODO: remove the hack that pops config.
+    request_dict.pop('config', None)
+
+    http_options = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = self._api_client.request(
+        'post', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
+
+    return_value = types.Operation._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value
+
+
+class Async_operations(_api_module.BaseModule):
+
+  async def _get_operation(
+      self,
+      *,
+      operation_name: str,
+      config: Optional[types.GetOperationConfigOrDict] = None,
+  ) -> types.Operation:
+    parameter_model = types._GetOperationParameters(
+        operation_name=operation_name,
+        config=config,
+    )
+
+    if self._api_client.vertexai:
+      request_dict = _GetOperationParameters_to_vertex(
+          self._api_client, parameter_model
+      )
+      path = '{operationName}'.format_map(request_dict.get('_url'))
+    else:
+      request_dict = _GetOperationParameters_to_mldev(
+          self._api_client, parameter_model
+      )
+      path = '{operationName}'.format_map(request_dict.get('_url'))
+    query_params = request_dict.get('_query')
+    if query_params:
+      path = f'{path}?{urlencode(query_params)}'
+    # TODO: remove the hack that pops config.
+    request_dict.pop('config', None)
+
+    http_options = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = await self._api_client.async_request(
+        'get', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
+
+    return_value = types.Operation._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value
+
+  async def _fetch_predict_operation(
+      self,
+      *,
+      operation_name: str,
+      resource_name: str,
+      config: Optional[types.FetchPredictOperationConfigOrDict] = None,
+  ) -> types.Operation:
+    parameter_model = types._FetchPredictOperationParameters(
+        operation_name=operation_name,
+        resource_name=resource_name,
+        config=config,
+    )
+
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
+      request_dict = _FetchPredictOperationParameters_to_vertex(
+          self._api_client, parameter_model
+      )
+      path = '{resourceName}:fetchPredictOperation'.format_map(
+          request_dict.get('_url')
+      )
+
+    query_params = request_dict.get('_query')
+    if query_params:
+      path = f'{path}?{urlencode(query_params)}'
+    # TODO: remove the hack that pops config.
+    request_dict.pop('config', None)
+
+    http_options = None
+    if isinstance(config, dict):
+      http_options = config.get('http_options', None)
+    elif hasattr(config, 'http_options'):
+      http_options = config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response_dict = await self._api_client.async_request(
+        'post', path, request_dict, http_options
+    )
+
+    if self._api_client.vertexai:
+      response_dict = _Operation_from_vertex(self._api_client, response_dict)
+    else:
+      response_dict = _Operation_from_mldev(self._api_client, response_dict)
+
+    return_value = types.Operation._from_response(
+        response=response_dict, kwargs=parameter_model
+    )
+    self._api_client._verify_response(return_value)
+    return return_value

google/genai/_replay_api_client.py

@@ -78,6 +78,11 @@ def _redact_request_url(url: str) -> str:
       '{VERTEX_URL_PREFIX}/',
       result,
   )
+  result = re.sub(
+      r'.*aiplatform.googleapis.com/[^/]+/',
+      '{VERTEX_URL_PREFIX}/',
+      result,
+  )
   result = re.sub(
       r'https://generativelanguage.googleapis.com/[^/]+',
       '{MLDEV_URL_PREFIX}',

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