google-genai 1.9.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

google/genai/_transformers.py

@@ -43,7 +43,7 @@ if sys.version_info >= (3, 10):
   _UNION_TYPES = (typing.Union, builtin_types.UnionType)
   from typing import TypeGuard
 else:
-  VersionedUnionType = typing._UnionGenericAlias
+  VersionedUnionType = typing._UnionGenericAlias  # type: ignore[attr-defined]
   _UNION_TYPES = (typing.Union,)
   from typing_extensions import TypeGuard
 
@@ -657,51 +657,57 @@ def process_schema(
       )
 
   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')
+    del schema['title']
+
+  # Standardize spelling for relevant schema fields.  For example, if a dict is
+  # provided directly to response_schema, it may use `any_of` instead of `anyOf.
+  # Otherwise, model_json_schema() uses `anyOf`.
+  for from_name, to_name in [
+      ('additional_properties', 'additionalProperties'),
+      ('any_of', 'anyOf'),
+      ('prefix_items', 'prefixItems'),
+      ('property_ordering', 'propertyOrdering'),
+  ]:
+    if (value := schema.pop(from_name, None)) is not None:
+      schema[to_name] = value
 
   if defs is None:
     defs = schema.pop('$defs', {})
     for _, sub_schema in defs.items():
-      process_schema(sub_schema, client, defs)
+      # We can skip the '$ref' check, because JSON schema forbids a '$ref' from
+      # directly referencing another '$ref':
+      # https://json-schema.org/understanding-json-schema/structuring#recursion
+      process_schema(
+          sub_schema, client, defs, order_properties=order_properties
+      )
 
   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'}
-  schema_ref = schema.get('$ref', None)
-  if schema_ref is not None:
-    ref = defs[schema_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:
-    for sub_schema in any_of:
-      # $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]
+  if (ref := schema.pop('$ref', None)) is not None:
+    schema.update(defs[ref.split('defs/')[-1]])
+
+  def _recurse(sub_schema: dict[str, Any]) -> dict[str, Any]:
+    """Returns the processed `sub_schema`, resolving its '$ref' if any."""
+    if (ref := sub_schema.pop('$ref', None)) is not None:
+      sub_schema = defs[ref.split('defs/')[-1]]
+    process_schema(sub_schema, client, defs, order_properties=order_properties)
+    return sub_schema
+
+  if (any_of := schema.get('anyOf')) is not None:
+    schema['anyOf'] = [_recurse(sub_schema) for sub_schema in any_of]
     return
 
-  schema_type = schema.get('type', None)
+  schema_type = schema.get('type')
   if isinstance(schema_type, Enum):
     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)
+  const = schema.get('const')
   if const is not None:
     if schema_type == 'STRING':
       schema['enum'] = [const]
@@ -710,38 +716,25 @@ def process_schema(
       raise ValueError('Literal values must be strings.')
 
   if schema_type == 'OBJECT':
-    properties = schema.get('properties', None)
-    if properties is None:
-      return
-    for name, sub_schema in properties.items():
-      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]]
-        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
+    if (properties := schema.get('properties')) is not None:
+      for name, sub_schema in list(properties.items()):
+        properties[name] = _recurse(sub_schema)
+      if (
+          len(properties.items()) > 1
+          and order_properties
+          and 'propertyOrdering' not in schema
+      ):
+        schema['property_ordering'] = list(properties.keys())
+    if (additional := schema.get('additionalProperties')) is not None:
+      # It is legal to set 'additionalProperties' to a bool:
+      # https://json-schema.org/understanding-json-schema/reference/object#additionalproperties
+      if isinstance(additional, dict):
+        schema['additionalProperties'] = _recurse(additional)
   elif schema_type == 'ARRAY':
-    sub_schema = schema.get('items', None)
-    if sub_schema is None:
-      return
-    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]]
-      process_schema(ref, client, defs)
-      schema['items'] = ref
+    if (items := schema.get('items')) is not None:
+      schema['items'] = _recurse(items)
+    if (prefixes := schema.get('prefixItems')) is not None:
+      schema['prefixItems'] = [_recurse(prefix) for prefix in prefixes]
 
 
 def _process_enum(
@@ -861,6 +854,8 @@ def t_tool(client: _api_client.BaseApiClient, origin) -> Optional[types.Tool]:
             )
         ]
     )
+  elif isinstance(origin, dict):
+    return types.Tool.model_validate(origin)
   else:
     return origin
 
@@ -1033,3 +1028,121 @@ def t_bytes(api_client: _api_client.BaseApiClient, data: bytes) -> str:
   if not isinstance(data, bytes):
     return data
   return base64.b64encode(data).decode('ascii')
+
+
+def t_content_strict(content: types.ContentOrDict) -> types.Content:
+  if isinstance(content, dict):
+    return types.Content.model_validate(content)
+  elif isinstance(content, types.Content):
+    return content
+  else:
+    raise ValueError(
+        f'Could not convert input (type "{type(content)}") to '
+        '`types.Content`'
+    )
+
+
+def t_contents_strict(
+    contents: Union[Sequence[types.ContentOrDict], types.ContentOrDict],
+) -> list[types.Content]:
+  if isinstance(contents, Sequence):
+    return [t_content_strict(content) for content in contents]
+  else:
+    return [t_content_strict(contents)]
+
+
+def t_client_content(
+    turns: Optional[
+        Union[Sequence[types.ContentOrDict], types.ContentOrDict]
+    ] = None,
+    turn_complete: bool = True,
+) -> types.LiveClientContent:
+  if turns is None:
+    return types.LiveClientContent(turn_complete=turn_complete)
+
+  try:
+    return types.LiveClientContent(
+        turns=t_contents_strict(contents=turns),
+        turn_complete=turn_complete,
+    )
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(turns)}") to '
+        '`types.LiveClientContent`'
+    ) from e
+
+
+def t_realtime_input(
+    media: BlobUnion,
+) -> types.LiveClientRealtimeInput:
+  try:
+    return types.LiveClientRealtimeInput(media_chunks=[t_blob(blob=media)])
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(input)}") to '
+        '`types.LiveClientRealtimeInput`'
+    ) from e
+
+
+def t_tool_response(
+    input: Union[
+        types.FunctionResponseOrDict,
+        Sequence[types.FunctionResponseOrDict],
+    ],
+) -> types.LiveClientToolResponse:
+  if not input:
+    raise ValueError(f'A tool response is required, got: \n{input}')
+
+  try:
+    return types.LiveClientToolResponse(
+        function_responses=t_function_responses(function_responses=input)
+    )
+  except Exception as e:
+    raise ValueError(
+        f'Could not convert input (type "{type(input)}") to '
+        '`types.LiveClientToolResponse`'
+    ) from e
+
+
+def t_live_speech_config(
+    origin: Union[types.SpeechConfigUnionDict, Any],
+) -> Optional[types.SpeechConfig]:
+  if not origin:
+    return None
+  if isinstance(origin, types.SpeechConfig):
+    return origin
+  if isinstance(origin, str):
+    # There is no way to know if the string is a voice name or a language code.
+    raise ValueError(
+        f'Unsupported speechConfig type: {type(origin)}. There is no way to'
+        ' know if the string is a voice name or a language code.'
+    )
+  if isinstance(origin, dict):
+    speech_config = types.SpeechConfig()
+    if (
+        'voice_config' in origin
+        and origin['voice_config'] is not None
+        and 'prebuilt_voice_config' in origin['voice_config']
+        and origin['voice_config']['prebuilt_voice_config'] is not None
+        and 'voice_name' in origin['voice_config']['prebuilt_voice_config']
+    ):
+      speech_config.voice_config = types.VoiceConfig(
+          prebuilt_voice_config=types.PrebuiltVoiceConfig(
+              voice_name=origin['voice_config']['prebuilt_voice_config'].get(
+                  'voice_name'
+              )
+          )
+      )
+    if 'language_code' in origin and origin['language_code'] is not None:
+      speech_config.language_code = origin['language_code']
+    if (
+        speech_config.voice_config is None
+        and speech_config.language_code is None
+    ):
+      raise ValueError(
+          'Unsupported speechConfig type: {type(origin)}. At least one of'
+          ' voice_config or language_code must be set.'
+      )
+    return speech_config
+  raise ValueError(f'Unsupported speechConfig type: {type(origin)}')
+

google/genai/files.py

@@ -658,6 +658,14 @@ class Files(_api_module.BaseModule):
     http_options: types.HttpOptions
     if config_model and config_model.http_options:
       http_options = config_model.http_options
+      http_options.api_version = ''
+      http_options.headers = {
+          'Content-Type': 'application/json',
+          'X-Goog-Upload-Protocol': 'resumable',
+          'X-Goog-Upload-Command': 'start',
+          'X-Goog-Upload-Header-Content-Length': f'{file_obj.size_bytes}',
+          'X-Goog-Upload-Header-Content-Type': f'{file_obj.mime_type}',
+      }
     else:
       http_options = types.HttpOptions(
           api_version='',
@@ -685,11 +693,11 @@ class Files(_api_module.BaseModule):
 
     if isinstance(file, io.IOBase):
       return_file = self._api_client.upload_file(
-          file, upload_url, file_obj.size_bytes
+          file, upload_url, file_obj.size_bytes, http_options=http_options
       )
     else:
       return_file = self._api_client.upload_file(
-          fs_path, upload_url, file_obj.size_bytes
+          fs_path, upload_url, file_obj.size_bytes, http_options=http_options
       )
 
     return types.File._from_response(
@@ -778,7 +786,7 @@ class Files(_api_module.BaseModule):
 
     data = self._api_client.download_file(
         path,
-        http_options,
+        http_options=http_options,
     )
 
     if isinstance(file, types.Video):
@@ -1122,6 +1130,14 @@ class AsyncFiles(_api_module.BaseModule):
     http_options: types.HttpOptions
     if config_model and config_model.http_options:
       http_options = config_model.http_options
+      http_options.api_version = ''
+      http_options.headers = {
+          'Content-Type': 'application/json',
+          'X-Goog-Upload-Protocol': 'resumable',
+          'X-Goog-Upload-Command': 'start',
+          'X-Goog-Upload-Header-Content-Length': f'{file_obj.size_bytes}',
+          'X-Goog-Upload-Header-Content-Type': f'{file_obj.mime_type}',
+      }
     else:
       http_options = types.HttpOptions(
           api_version='',
@@ -1148,11 +1164,11 @@ class AsyncFiles(_api_module.BaseModule):
 
     if isinstance(file, io.IOBase):
       return_file = await self._api_client.async_upload_file(
-          file, upload_url, file_obj.size_bytes
+          file, upload_url, file_obj.size_bytes, http_options=http_options
       )
     else:
       return_file = await self._api_client.async_upload_file(
-          fs_path, upload_url, file_obj.size_bytes
+          fs_path, upload_url, file_obj.size_bytes, http_options=http_options
       )
 
     return types.File._from_response(
@@ -1231,7 +1247,7 @@ class AsyncFiles(_api_module.BaseModule):
 
     data = await self._api_client.async_download_file(
         path,
-        http_options,
+        http_options=http_options,
     )
 
     return data