google-genai 1.33.0__py3-none-any.whl → 1.53.0__py3-none-any.whl

google/genai/_transformers.py

@@ -64,6 +64,45 @@ else:
     McpTool = None
 
 
+metric_name_sdk_api_map = {
+    'exact_match': 'exactMatchSpec',
+    'bleu': 'bleuSpec',
+    'rouge_spec': 'rougeSpec',
+}
+metric_name_api_sdk_map = {v: k for k, v in metric_name_sdk_api_map.items()}
+
+
+def _is_duck_type_of(obj: Any, cls: type[pydantic.BaseModel]) -> bool:
+  """Checks if an object has all of the fields of a Pydantic model.
+
+  This is a duck-typing alternative to `isinstance` to solve dual-import
+  problems. It returns False for dictionaries, which should be handled by
+  `isinstance(obj, dict)`.
+
+  Args:
+    obj: The object to check.
+    cls: The Pydantic model class to duck-type against.
+
+  Returns:
+    True if the object has all the fields defined in the Pydantic model, False
+    otherwise.
+  """
+  if isinstance(obj, dict) or not hasattr(cls, 'model_fields'):
+    return False
+
+  # Check if the object has all of the Pydantic model's defined fields.
+  all_matched = all(hasattr(obj, field) for field in cls.model_fields)
+  if not all_matched and isinstance(obj, pydantic.BaseModel):
+    # Check the other way around if obj is a Pydantic model.
+    # Check if the Pydantic model has all of the object's defined fields.
+    try:
+      obj_private = cls()
+      all_matched = all(hasattr(obj_private, f) for f in type(obj).model_fields)
+    except ValueError:
+      return False
+  return all_matched
+
+
 def _resource_name(
     client: _api_client.BaseApiClient,
     resource_name: str,
@@ -160,6 +199,8 @@ def _resource_name(
 def t_model(client: _api_client.BaseApiClient, model: str) -> str:
   if not model:
     raise ValueError('model is required.')
+  if '..' in model or '?' in model or '&' in model:
+    raise ValueError('invalid model parameter.')
   if client.vertexai:
     if (
         model.startswith('projects/')
@@ -276,7 +317,7 @@ def t_function_response(
     raise ValueError('function_response is required.')
   if isinstance(function_response, dict):
     return types.FunctionResponse.model_validate(function_response)
-  elif isinstance(function_response, types.FunctionResponse):
+  elif _is_duck_type_of(function_response, types.FunctionResponse):
     return function_response
   else:
     raise TypeError(
@@ -309,24 +350,25 @@ def t_blobs(
 
 
 def t_blob(blob: types.BlobImageUnionDict) -> types.Blob:
-  try:
-    import PIL.Image
-
-    PIL_Image = PIL.Image.Image
-  except ImportError:
-    PIL_Image = None
-
   if not blob:
     raise ValueError('blob is required.')
 
-  if isinstance(blob, types.Blob):
-    return blob
+  if _is_duck_type_of(blob, types.Blob):
+    return blob  # type: ignore[return-value]
 
   if isinstance(blob, dict):
     return types.Blob.model_validate(blob)
 
-  if PIL_Image is not None and isinstance(blob, PIL_Image):
-    return pil_to_blob(blob)
+  if 'image' in blob.__class__.__name__.lower():
+    try:
+      import PIL.Image
+
+      PIL_Image = PIL.Image.Image
+    except ImportError:
+      PIL_Image = None
+
+    if PIL_Image is not None and isinstance(blob, PIL_Image):
+      return pil_to_blob(blob)
 
   raise TypeError(
       f'Could not parse input as Blob. Unsupported blob type: {type(blob)}'
@@ -348,27 +390,32 @@ def t_audio_blob(blob: types.BlobOrDict) -> types.Blob:
 
 
 def t_part(part: Optional[types.PartUnionDict]) -> types.Part:
-  try:
-    import PIL.Image
-
-    PIL_Image = PIL.Image.Image
-  except ImportError:
-    PIL_Image = None
-
   if part is None:
     raise ValueError('content part is required.')
   if isinstance(part, str):
     return types.Part(text=part)
-  if PIL_Image is not None and isinstance(part, PIL_Image):
-    return types.Part(inline_data=pil_to_blob(part))
-  if isinstance(part, types.File):
-    if not part.uri or not part.mime_type:
+  if _is_duck_type_of(part, types.File):
+    if not part.uri or not part.mime_type:  # type: ignore[union-attr]
       raise ValueError('file uri and mime_type are required.')
-    return types.Part.from_uri(file_uri=part.uri, mime_type=part.mime_type)
+    return types.Part.from_uri(file_uri=part.uri, mime_type=part.mime_type)  # type: ignore[union-attr]
   if isinstance(part, dict):
-    return types.Part.model_validate(part)
-  if isinstance(part, types.Part):
-    return part
+    try:
+      return types.Part.model_validate(part)
+    except pydantic.ValidationError:
+      return types.Part(file_data=types.FileData.model_validate(part))
+  if _is_duck_type_of(part, types.Part):
+    return part  # type: ignore[return-value]
+
+  if 'image' in part.__class__.__name__.lower():
+    try:
+      import PIL.Image
+
+      PIL_Image = PIL.Image.Image
+    except ImportError:
+      PIL_Image = None
+
+    if PIL_Image is not None and isinstance(part, PIL_Image):
+      return types.Part(inline_data=pil_to_blob(part))
   raise ValueError(f'Unsupported content part type: {type(part)}')
 
 
@@ -409,29 +456,31 @@ ContentType = Union[types.Content, types.ContentDict, types.PartUnionDict]
 
 
 def t_content(
-    content: Optional[ContentType],
+    content: Union[ContentType, types.ContentDict, None],
 ) -> types.Content:
   if content is None:
     raise ValueError('content is required.')
-  if isinstance(content, types.Content):
-    return content
+  if _is_duck_type_of(content, types.Content):
+    return content  # type: ignore[return-value]
   if isinstance(content, dict):
     try:
       return types.Content.model_validate(content)
     except pydantic.ValidationError:
-      possible_part = types.Part.model_validate(content)
+      possible_part = t_part(content)  # type: ignore[arg-type]
       return (
           types.ModelContent(parts=[possible_part])
           if possible_part.function_call
           else types.UserContent(parts=[possible_part])
       )
-  if isinstance(content, types.Part):
+  if _is_duck_type_of(content, types.File):
+    return types.UserContent(parts=[t_part(content)])  # type: ignore[arg-type]
+  if _is_duck_type_of(content, types.Part):
     return (
-        types.ModelContent(parts=[content])
-        if content.function_call
-        else types.UserContent(parts=[content])
+        types.ModelContent(parts=[content])  # type: ignore[arg-type]
+        if content.function_call  # type: ignore[union-attr]
+        else types.UserContent(parts=[content])  # type: ignore[arg-type]
     )
-  return types.UserContent(parts=content)
+  return types.UserContent(parts=content)  # type: ignore[arg-type]
 
 
 def t_contents_for_embed(
@@ -470,13 +519,6 @@ def t_contents(
   if not isinstance(contents, list):
     return [t_content(contents)]
 
-  try:
-    import PIL.Image
-
-    PIL_Image = PIL.Image.Image
-  except ImportError:
-    PIL_Image = None
-
   result: list[types.Content] = []
   accumulated_parts: list[types.Part] = []
 
@@ -485,18 +527,35 @@ def t_contents(
   ) -> TypeGuard[types.PartUnionDict]:
     if (
         isinstance(part, str)
-        or isinstance(part, types.File)
-        or (PIL_Image is not None and isinstance(part, PIL_Image))
-        or isinstance(part, types.Part)
+        or _is_duck_type_of(part, types.File)
+        or _is_duck_type_of(part, types.Part)
     ):
       return True
 
     if isinstance(part, dict):
+      if not part:
+        # Empty dict should be considered as Content, not Part.
+        return False
       try:
         types.Part.model_validate(part)
         return True
       except pydantic.ValidationError:
-        return False
+        try:
+          types.FileData.model_validate(part)
+          return True
+        except pydantic.ValidationError:
+          return False
+
+    if 'image' in part.__class__.__name__.lower():
+      try:
+        import PIL.Image
+
+        PIL_Image = PIL.Image.Image
+      except ImportError:
+        PIL_Image = None
+
+      if PIL_Image is not None and isinstance(part, PIL_Image):
+        return True
 
     return False
 
@@ -539,16 +598,12 @@ def t_contents(
   #   append to result
   # if list, we only accept a list of types.PartUnion
   for content in contents:
-    if (
-        isinstance(content, types.Content)
-        # only allowed inner list is a list of types.PartUnion
-        or isinstance(content, list)
-    ):
+    if _is_duck_type_of(content, types.Content) or isinstance(content, list):
       _append_accumulated_parts_as_content(result, accumulated_parts)
       if isinstance(content, list):
         result.append(types.UserContent(parts=content))  # type: ignore[arg-type]
       else:
-        result.append(content)
+        result.append(content)  # type: ignore[arg-type]
     elif _is_part(content):
       _handle_current_part(result, accumulated_parts, content)
     elif isinstance(content, dict):
@@ -840,12 +895,12 @@ def t_schema(
     return types.Schema.model_validate(origin)
   if isinstance(origin, EnumMeta):
     return _process_enum(origin, client)
-  if isinstance(origin, types.Schema):
-    if dict(origin) == dict(types.Schema()):
+  if _is_duck_type_of(origin, types.Schema):
+    if dict(origin) == dict(types.Schema()):  # type: ignore [arg-type]
       # response_schema value was coerced to an empty Schema instance because
       # it did not adhere to the Schema field annotation
       _raise_for_unsupported_schema_type(origin)
-    schema = origin.model_dump(exclude_unset=True)
+    schema = origin.model_dump(exclude_unset=True)  # type: ignore[union-attr]
     process_schema(schema, client)
     return types.Schema.model_validate(schema)
 
@@ -882,8 +937,8 @@ def t_speech_config(
 ) -> Optional[types.SpeechConfig]:
   if not origin:
     return None
-  if isinstance(origin, types.SpeechConfig):
-    return origin
+  if _is_duck_type_of(origin, types.SpeechConfig):
+    return origin  # type: ignore[return-value]
   if isinstance(origin, str):
     return types.SpeechConfig(
         voice_config=types.VoiceConfig(
@@ -899,17 +954,17 @@ def t_speech_config(
 def t_live_speech_config(
     origin: types.SpeechConfigOrDict,
 ) -> Optional[types.SpeechConfig]:
-  if isinstance(origin, types.SpeechConfig):
+  if _is_duck_type_of(origin, types.SpeechConfig):
     speech_config = origin
   if isinstance(origin, dict):
     speech_config = types.SpeechConfig.model_validate(origin)
 
-  if speech_config.multi_speaker_voice_config is not None:
+  if speech_config.multi_speaker_voice_config is not None:  # type: ignore[union-attr]
     raise ValueError(
         'multi_speaker_voice_config is not supported in the live API.'
     )
 
-  return speech_config
+  return speech_config  # type: ignore[return-value]
 
 
 def t_tool(
@@ -925,7 +980,7 @@ def t_tool(
             )
         ]
     )
-  elif McpTool is not None and isinstance(origin, McpTool):
+  elif McpTool is not None and _is_duck_type_of(origin, McpTool):
     return mcp_to_gemini_tool(origin)
   elif isinstance(origin, dict):
     return types.Tool.model_validate(origin)
@@ -964,32 +1019,32 @@ def t_cached_content_name(client: _api_client.BaseApiClient, name: str) -> str:
 
 def t_batch_job_source(
     client: _api_client.BaseApiClient,
-    src: Union[
-        str, List[types.InlinedRequestOrDict], types.BatchJobSourceOrDict
-    ],
+    src: types.BatchJobSourceUnionDict,
 ) -> types.BatchJobSource:
   if isinstance(src, dict):
     src = types.BatchJobSource(**src)
-  if isinstance(src, types.BatchJobSource):
+  if _is_duck_type_of(src, types.BatchJobSource):
+    vertex_sources = sum(
+        [src.gcs_uri is not None, src.bigquery_uri is not None]  # type: ignore[union-attr]
+    )
+    mldev_sources = sum([
+        src.inlined_requests is not None,  # type: ignore[union-attr]
+        src.file_name is not None,  # type: ignore[union-attr]
+    ])
     if client.vertexai:
-      if src.gcs_uri and src.bigquery_uri:
-        raise ValueError(
-            'Only one of `gcs_uri` or `bigquery_uri` can be set.'
-        )
-      elif not src.gcs_uri and not src.bigquery_uri:
+      if mldev_sources or vertex_sources != 1:
         raise ValueError(
-            'One of `gcs_uri` or `bigquery_uri` must be set.'
+            'Exactly one of `gcs_uri` or `bigquery_uri` must be set, other '
+            'sources are not supported in Vertex AI.'
         )
     else:
-      if src.inlined_requests and src.file_name:
+      if vertex_sources or mldev_sources != 1:
         raise ValueError(
-            'Only one of `inlined_requests` or `file_name` can be set.'
+            'Exactly one of `inlined_requests`, `file_name`, '
+            '`inlined_embed_content_requests`, or `embed_content_file_name` '
+            'must be set, other sources are not supported in Gemini API.'
         )
-      elif not src.inlined_requests and not src.file_name:
-        raise ValueError(
-            'One of `inlined_requests` or `file_name` must be set.'
-        )
-    return src
+    return src  # type: ignore[return-value]
 
   elif isinstance(src, list):
     return types.BatchJobSource(inlined_requests=src)
@@ -1012,6 +1067,29 @@ def t_batch_job_source(
   raise ValueError(f'Unsupported source: {src}')
 
 
+def t_embedding_batch_job_source(
+    client: _api_client.BaseApiClient,
+    src: types.EmbeddingsBatchJobSourceOrDict,
+) -> types.EmbeddingsBatchJobSource:
+  if isinstance(src, dict):
+    src = types.EmbeddingsBatchJobSource(**src)
+
+  if _is_duck_type_of(src, types.EmbeddingsBatchJobSource):
+    mldev_sources = sum([
+        src.inlined_requests is not None,
+        src.file_name is not None,
+    ])
+    if mldev_sources != 1:
+      raise ValueError(
+          'Exactly one of `inlined_requests`, `file_name`, '
+          '`inlined_embed_content_requests`, or `embed_content_file_name` '
+          'must be set, other sources are not supported in Gemini API.'
+      )
+    return src
+  else:
+    raise ValueError(f'Unsupported source type: {type(src)}')
+
+
 def t_batch_job_destination(
     dest: Union[str, types.BatchJobDestinationOrDict],
 ) -> types.BatchJobDestination:
@@ -1031,12 +1109,29 @@ def t_batch_job_destination(
       )
     else:
       raise ValueError(f'Unsupported destination: {dest}')
-  elif isinstance(dest, types.BatchJobDestination):
+  elif _is_duck_type_of(dest, types.BatchJobDestination):
     return dest
   else:
     raise ValueError(f'Unsupported destination: {dest}')
 
 
+def t_recv_batch_job_destination(dest: dict[str, Any]) -> dict[str, Any]:
+  # Rename inlinedResponses if it looks like an embedding response.
+  inline_responses = dest.get('inlinedResponses', {}).get(
+      'inlinedResponses', []
+  )
+  if not inline_responses:
+    return dest
+  for response in inline_responses:
+    inner_response = response.get('response', {})
+    if not inner_response:
+      continue
+    if 'embedding' in inner_response:
+      dest['inlinedEmbedContentResponses'] = dest.pop('inlinedResponses')
+      break
+  return dest
+
+
 def t_batch_job_name(client: _api_client.BaseApiClient, name: str) -> str:
   if not client.vertexai:
     mldev_pattern = r'batches/[^/]+$'
@@ -1060,12 +1155,16 @@ def t_job_state(state: str) -> str:
     return 'JOB_STATE_UNSPECIFIED'
   elif state == 'BATCH_STATE_PENDING':
     return 'JOB_STATE_PENDING'
+  elif state == 'BATCH_STATE_RUNNING':
+    return 'JOB_STATE_RUNNING'
   elif state == 'BATCH_STATE_SUCCEEDED':
     return 'JOB_STATE_SUCCEEDED'
   elif state == 'BATCH_STATE_FAILED':
     return 'JOB_STATE_FAILED'
   elif state == 'BATCH_STATE_CANCELLED':
     return 'JOB_STATE_CANCELLED'
+  elif state == 'BATCH_STATE_EXPIRED':
+    return 'JOB_STATE_EXPIRED'
   else:
     return state
 
@@ -1110,13 +1209,13 @@ def t_file_name(
     name: Optional[Union[str, types.File, types.Video, types.GeneratedVideo]],
 ) -> str:
   # Remove the files/ prefix since it's added to the url path.
-  if isinstance(name, types.File):
-    name = name.name
-  elif isinstance(name, types.Video):
-    name = name.uri
-  elif isinstance(name, types.GeneratedVideo):
-    if name.video is not None:
-      name = name.video.uri
+  if _is_duck_type_of(name, types.File):
+    name = name.name  # type: ignore[union-attr]
+  elif _is_duck_type_of(name, types.Video):
+    name = name.uri  # type: ignore[union-attr]
+  elif _is_duck_type_of(name, types.GeneratedVideo):
+    if name.video is not None:  # type: ignore[union-attr]
+      name = name.video.uri  # type: ignore[union-attr]
     else:
       name = None
 
@@ -1159,7 +1258,7 @@ def t_tuning_job_status(status: str) -> Union[types.JobState, str]:
 def t_content_strict(content: types.ContentOrDict) -> types.Content:
   if isinstance(content, dict):
     return types.Content.model_validate(content)
-  elif isinstance(content, types.Content):
+  elif _is_duck_type_of(content, types.Content):
     return content
   else:
     raise ValueError(
@@ -1250,10 +1349,14 @@ def t_metrics(
 
       elif hasattr(metric, 'prompt_template') and metric.prompt_template:
         pointwise_spec = {'metric_prompt_template': metric.prompt_template}
-        system_instruction = getv(metric, ['judge_model_system_instruction'])
+        system_instruction = getv(
+            metric, ['judge_model_system_instruction']
+        )
         if system_instruction:
           pointwise_spec['system_instruction'] = system_instruction
-        return_raw_output = getv(metric, ['return_raw_output'])
+        return_raw_output = getv(
+            metric, ['return_raw_output']
+        )
         if return_raw_output:
           pointwise_spec['custom_output_format_config'] = {  # type: ignore[assignment]
               'return_raw_output': return_raw_output