google-genai 1.10.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

google/genai/_replay_api_client.py

@@ -30,11 +30,10 @@ from requests.exceptions import HTTPError
 
 from . import errors
 from ._api_client import BaseApiClient
-from ._api_client import HttpOptions
 from ._api_client import HttpRequest
 from ._api_client import HttpResponse
 from ._common import BaseModel
-from .types import HttpOptionsOrDict
+from .types import HttpOptions, HttpOptionsOrDict
 from .types import GenerateVideosOperation
 
 
@@ -48,7 +47,7 @@ def _redact_language_label(language_label: str) -> str:
   return re.sub(r'gl-python/', '{LANGUAGE_LABEL}/', language_label)
 
 
-def _redact_request_headers(headers):
+def _redact_request_headers(headers: dict[str, str]) -> dict[str, str]:
   """Redacts headers that should not be recorded."""
   redacted_headers = {}
   for header_name, header_value in headers.items():
@@ -111,29 +110,36 @@ def _redact_project_location_path(path: str) -> str:
     return path
 
 
-def _redact_request_body(body: dict[str, object]):
+def _redact_request_body(body: dict[str, object]) -> None:
   """Redacts fields in the request body in place."""
   for key, value in body.items():
     if isinstance(value, str):
       body[key] = _redact_project_location_path(value)
 
 
-def redact_http_request(http_request: HttpRequest):
+def redact_http_request(http_request: HttpRequest) -> None:
   http_request.headers = _redact_request_headers(http_request.headers)
   http_request.url = _redact_request_url(http_request.url)
   if not isinstance(http_request.data, bytes):
     _redact_request_body(http_request.data)
 
 
-def _current_file_path_and_line():
+def _current_file_path_and_line() -> str:
   """Prints the current file path and line number."""
-  frame = inspect.currentframe().f_back.f_back
-  filepath = inspect.getfile(frame)
-  lineno = frame.f_lineno
-  return f'File: {filepath}, Line: {lineno}'
+  current_frame = inspect.currentframe()
+  if (
+      current_frame is not None
+      and current_frame.f_back is not None
+      and current_frame.f_back.f_back is not None
+  ):
+    frame = current_frame.f_back.f_back
+    filepath = inspect.getfile(frame)
+    lineno = frame.f_lineno
+    return f'File: {filepath}, Line: {lineno}'
+  return ''
 
 
-def _debug_print(message: str):
+def _debug_print(message: str) -> None:
   print(
       'DEBUG (test',
       os.environ.get('PYTEST_CURRENT_TEST'),
@@ -212,33 +218,33 @@ class ReplayApiClient(BaseApiClient):
           'GOOGLE_GENAI_REPLAYS_DIRECTORY', None
       )
     # Valid replay modes are replay-only or record-and-replay.
-    self.replay_session = None
+    self.replay_session: Union[ReplayFile, None] = None
     self._mode = mode
     self._replay_id = replay_id
 
-  def initialize_replay_session(self, replay_id: str):
+  def initialize_replay_session(self, replay_id: str) -> None:
     self._replay_id = replay_id
     self._initialize_replay_session()
 
-  def _get_replay_file_path(self):
+  def _get_replay_file_path(self) -> str:
     return self._generate_file_path_from_replay_id(
         self.replays_directory, self._replay_id
     )
 
-  def _should_call_api(self):
+  def _should_call_api(self) -> bool:
     return self._mode in ['record', 'api'] or (
         self._mode == 'auto'
         and not os.path.isfile(self._get_replay_file_path())
     )
 
-  def _should_update_replay(self):
+  def _should_update_replay(self) -> bool:
     return self._should_call_api() and self._mode != 'api'
 
-  def _initialize_replay_session_if_not_loaded(self):
+  def _initialize_replay_session_if_not_loaded(self) -> None:
     if not self.replay_session:
       self._initialize_replay_session()
 
-  def _initialize_replay_session(self):
+  def _initialize_replay_session(self) -> None:
     _debug_print('Test is using replay id: ' + self._replay_id)
     self._replay_index = 0
     self._sdk_response_index = 0
@@ -259,7 +265,7 @@ class ReplayApiClient(BaseApiClient):
           replay_id=self._replay_id, interactions=[]
       )
 
-  def _generate_file_path_from_replay_id(self, replay_directory, replay_id):
+  def _generate_file_path_from_replay_id(self, replay_directory: Optional[str], replay_id: str) -> str:
     session_parts = replay_id.split('/')
     if len(session_parts) < 3:
       raise ValueError(
@@ -273,7 +279,7 @@ class ReplayApiClient(BaseApiClient):
     path_parts.extend(session_parts)
     return os.path.join(*path_parts) + '.json'
 
-  def close(self):
+  def close(self) -> None:
     if not self._should_update_replay() or not self.replay_session:
       return
     replay_file_path = self._get_replay_file_path()
@@ -286,7 +292,7 @@ class ReplayApiClient(BaseApiClient):
       self,
       http_request: HttpRequest,
       http_response: Union[HttpResponse, errors.APIError, bytes],
-  ):
+  ) -> None:
     if not self._should_update_replay():
       return
     redact_http_request(http_request)
@@ -334,7 +340,7 @@ class ReplayApiClient(BaseApiClient):
       self,
       http_request: HttpRequest,
       interaction: ReplayInteraction,
-  ):
+  ) -> None:
     assert http_request.url == interaction.request.url
     assert http_request.headers == interaction.request.headers, (
         'Request headers mismatch:\n'
@@ -378,7 +384,7 @@ class ReplayApiClient(BaseApiClient):
         byte_stream=interaction.response.byte_segments,
     )
 
-  def _verify_response(self, response_model: BaseModel):
+  def _verify_response(self, response_model: BaseModel) -> None:
     if self._mode == 'api':
       return
     if not self.replay_session:
@@ -389,7 +395,7 @@ class ReplayApiClient(BaseApiClient):
       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)
+        response_model.http_headers.pop('Date', None)  # type: ignore[attr-defined]
       interaction.response.sdk_response_segments.append(
           response_model.model_dump(exclude_none=True)
       )
@@ -548,7 +554,7 @@ class ReplayApiClient(BaseApiClient):
 
   def download_file(
       self, path: str, *, http_options: Optional[HttpOptionsOrDict] = None
-  ):
+  ) -> Union[HttpResponse, bytes, Any]:
     self._initialize_replay_session_if_not_loaded()
     request = self._build_request(
         'get', path=path, request_dict={}, http_options=http_options
@@ -569,7 +575,7 @@ class ReplayApiClient(BaseApiClient):
 
   async def async_download_file(
       self, path: str, *, http_options: Optional[HttpOptionsOrDict] = None
-  ):
+  ) -> Any:
     self._initialize_replay_session_if_not_loaded()
     request = self._build_request(
         'get', path=path, request_dict={}, http_options=http_options

google/genai/_transformers.py

@@ -53,7 +53,7 @@ def _resource_name(
     *,
     collection_identifier: str,
     collection_hierarchy_depth: int = 2,
-):
+) -> str:
   # pylint: disable=line-too-long
   """Prepends resource name with project, location, collection_identifier if needed.
 
@@ -140,7 +140,7 @@ def _resource_name(
       return resource_name
 
 
-def t_model(client: _api_client.BaseApiClient, model: str):
+def t_model(client: _api_client.BaseApiClient, model: str) -> str:
   if not model:
     raise ValueError('model is required.')
   if client.vertexai:
@@ -211,7 +211,7 @@ def t_extract_models(
     return []
 
 
-def t_caches_model(api_client: _api_client.BaseApiClient, model: str):
+def t_caches_model(api_client: _api_client.BaseApiClient, model: str) -> Optional[str]:
   model = t_model(api_client, model)
   if not model:
     return None
@@ -226,7 +226,7 @@ def t_caches_model(api_client: _api_client.BaseApiClient, model: str):
     return model
 
 
-def pil_to_blob(img) -> types.Blob:
+def pil_to_blob(img: Any) -> types.Blob:
   PngImagePlugin: Optional[builtin_types.ModuleType]
   try:
     import PIL.PngImagePlugin
@@ -280,9 +280,19 @@ def t_function_responses(
     return [t_function_response(function_responses)]
 
 
-BlobUnion = Union[types.Blob, types.BlobDict, 'PIL.Image.Image']
+def t_blobs(
+    api_client: _api_client.BaseApiClient,
+    blobs: Union[types.BlobImageUnionDict, list[types.BlobImageUnionDict]],
+) -> list[types.Blob]:
+  if isinstance(blobs, list):
+    return [t_blob(api_client, blob) for blob in blobs]
+  else:
+    return [t_blob(api_client, blobs)]
+
 
-def t_blob(blob: BlobUnion) -> types.Blob:
+def t_blob(
+    api_client: _api_client.BaseApiClient, blob: types.BlobImageUnionDict
+) -> types.Blob:
   try:
     import PIL.Image
 
@@ -307,6 +317,24 @@ def t_blob(blob: BlobUnion) -> types.Blob:
   )
 
 
+def t_image_blob(
+    api_client: _api_client.BaseApiClient, blob: types.BlobImageUnionDict
+) -> types.Blob:
+  blob = t_blob(api_client, blob)
+  if blob.mime_type and blob.mime_type.startswith('image/'):
+    return blob
+  raise ValueError(f'Unsupported mime type: {blob.mime_type!r}')
+
+
+def t_audio_blob(
+    api_client: _api_client.BaseApiClient, blob: types.BlobOrDict
+) -> types.Blob:
+  blob = t_blob(api_client, blob)
+  if blob.mime_type and blob.mime_type.startswith('audio/'):
+    return blob
+  raise ValueError(f'Unsupported mime type: {blob.mime_type!r}')
+
+
 def t_part(part: Optional[types.PartUnionDict]) -> types.Part:
   try:
     import PIL.Image
@@ -470,7 +498,7 @@ def t_contents(
   def _append_accumulated_parts_as_content(
       result: list[types.Content],
       accumulated_parts: list[types.Part],
-  ):
+  ) -> None:
     if not accumulated_parts:
       return
     result.append(
@@ -484,7 +512,7 @@ def t_contents(
       result: list[types.Content],
       accumulated_parts: list[types.Part],
       current_part: types.PartUnionDict,
-  ):
+  ) -> None:
     current_part = t_part(current_part)
     if _is_user_part(current_part) == _are_user_parts(accumulated_parts):
       accumulated_parts.append(current_part)
@@ -523,7 +551,7 @@ def t_contents(
   return result
 
 
-def handle_null_fields(schema: dict[str, Any]):
+def handle_null_fields(schema: dict[str, Any]) -> None:
   """Process null fields in the schema so it is compatible with OpenAPI.
 
   The OpenAPI spec does not support 'type: 'null' in the schema. This function
@@ -588,7 +616,7 @@ def process_schema(
     defs: Optional[dict[str, Any]] = None,
     *,
     order_properties: bool = True,
-):
+) -> None:
   """Updates the schema and each sub-schema inplace to be API-compatible.
 
   - Inlines the $defs.
@@ -649,13 +677,6 @@ def process_schema(
         'type': 'array'
     }
   """
-  if not client.vertexai:
-    if schema.get('default') is not None:
-      raise ValueError(
-          'Default value is not supported in the response schema for the Gemini'
-          ' API.'
-      )
-
   if schema.get('title') == 'PlaceholderLiteralEnum':
     del schema['title']
 
@@ -663,7 +684,9 @@ def process_schema(
   # 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:
@@ -723,9 +746,16 @@ def process_schema(
           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':
     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(
@@ -834,7 +864,7 @@ def t_speech_config(
   raise ValueError(f'Unsupported speechConfig type: {type(origin)}')
 
 
-def t_tool(client: _api_client.BaseApiClient, origin) -> Optional[types.Tool]:
+def t_tool(client: _api_client.BaseApiClient, origin: Any) -> Optional[Union[types.Tool, Any]]:
   if not origin:
     return None
   if inspect.isfunction(origin) or inspect.ismethod(origin):
@@ -845,6 +875,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
 
@@ -875,11 +907,11 @@ def t_tools(
   return tools
 
 
-def t_cached_content_name(client: _api_client.BaseApiClient, name: str):
+def t_cached_content_name(client: _api_client.BaseApiClient, name: str) -> str:
   return _resource_name(client, name, collection_identifier='cachedContents')
 
 
-def t_batch_job_source(client: _api_client.BaseApiClient, src: str):
+def t_batch_job_source(client: _api_client.BaseApiClient, src: str) -> types.BatchJobSource:
   if src.startswith('gs://'):
     return types.BatchJobSource(
         format='jsonl',
@@ -894,7 +926,7 @@ def t_batch_job_source(client: _api_client.BaseApiClient, src: str):
     raise ValueError(f'Unsupported source: {src}')
 
 
-def t_batch_job_destination(client: _api_client.BaseApiClient, dest: str):
+def t_batch_job_destination(client: _api_client.BaseApiClient, dest: str) -> types.BatchJobDestination:
   if dest.startswith('gs://'):
     return types.BatchJobDestination(
         format='jsonl',
@@ -909,7 +941,7 @@ def t_batch_job_destination(client: _api_client.BaseApiClient, dest: str):
     raise ValueError(f'Unsupported destination: {dest}')
 
 
-def t_batch_job_name(client: _api_client.BaseApiClient, name: str):
+def t_batch_job_name(client: _api_client.BaseApiClient, name: str) -> str:
   if not client.vertexai:
     return name
 
@@ -928,7 +960,7 @@ LRO_POLLING_TIMEOUT_SECONDS = 900.0
 LRO_POLLING_MULTIPLIER = 1.5
 
 
-def t_resolve_operation(api_client: _api_client.BaseApiClient, struct: dict):
+def t_resolve_operation(api_client: _api_client.BaseApiClient, struct: dict[str, Any]) -> Any:
   if (name := struct.get('name')) and '/operations/' in name:
     operation: dict[str, Any] = struct
     total_seconds = 0.0
@@ -937,7 +969,7 @@ def t_resolve_operation(api_client: _api_client.BaseApiClient, struct: dict):
       if total_seconds > LRO_POLLING_TIMEOUT_SECONDS:
         raise RuntimeError(f'Operation {name} timed out.\n{operation}')
       # TODO(b/374433890): Replace with LRO module once it's available.
-      operation = api_client.request(
+      operation = api_client.request(  # type: ignore[assignment]
           http_method='GET', path=name, request_dict={}
       )
       time.sleep(delay_seconds)
@@ -959,7 +991,7 @@ def t_resolve_operation(api_client: _api_client.BaseApiClient, struct: dict):
 def t_file_name(
     api_client: _api_client.BaseApiClient,
     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
@@ -1017,3 +1049,65 @@ 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_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

google/genai/batches.py

@@ -33,9 +33,9 @@ logger = logging.getLogger('google_genai.batches')
 
 def _BatchJobSource_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['format']) is not None:
     setv(to_object, ['instancesFormat'], getv(from_object, ['format']))
@@ -55,9 +55,9 @@ def _BatchJobSource_to_vertex(
 
 def _BatchJobDestination_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['format']) is not None:
     setv(to_object, ['predictionsFormat'], getv(from_object, ['format']))
@@ -81,9 +81,9 @@ def _BatchJobDestination_to_vertex(
 
 def _CreateBatchJobConfig_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
 
   if getv(from_object, ['display_name']) is not None:
@@ -105,9 +105,9 @@ def _CreateBatchJobConfig_to_vertex(
 
 def _CreateBatchJobParameters_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['model']) is not None:
     setv(
@@ -141,9 +141,9 @@ def _CreateBatchJobParameters_to_vertex(
 
 def _GetBatchJobParameters_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['name']) is not None:
     setv(
@@ -160,9 +160,9 @@ def _GetBatchJobParameters_to_vertex(
 
 def _CancelBatchJobParameters_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['name']) is not None:
     setv(
@@ -179,9 +179,9 @@ def _CancelBatchJobParameters_to_vertex(
 
 def _ListBatchJobsConfig_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
 
   if getv(from_object, ['page_size']) is not None:
@@ -204,9 +204,9 @@ def _ListBatchJobsConfig_to_vertex(
 
 def _ListBatchJobsParameters_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['config']) is not None:
     setv(
@@ -222,9 +222,9 @@ def _ListBatchJobsParameters_to_vertex(
 
 def _DeleteBatchJobParameters_to_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['name']) is not None:
     setv(
@@ -241,9 +241,9 @@ def _DeleteBatchJobParameters_to_vertex(
 
 def _JobError_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['details']) is not None:
     setv(to_object, ['details'], getv(from_object, ['details']))
@@ -259,9 +259,9 @@ def _JobError_from_vertex(
 
 def _BatchJobSource_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['instancesFormat']) is not None:
     setv(to_object, ['format'], getv(from_object, ['instancesFormat']))
@@ -281,9 +281,9 @@ def _BatchJobSource_from_vertex(
 
 def _BatchJobDestination_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['predictionsFormat']) is not None:
     setv(to_object, ['format'], getv(from_object, ['predictionsFormat']))
@@ -307,9 +307,9 @@ def _BatchJobDestination_from_vertex(
 
 def _BatchJob_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['name']) is not None:
     setv(to_object, ['name'], getv(from_object, ['name']))
@@ -367,9 +367,9 @@ def _BatchJob_from_vertex(
 
 def _ListBatchJobsResponse_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['nextPageToken']) is not None:
     setv(to_object, ['next_page_token'], getv(from_object, ['nextPageToken']))
@@ -389,9 +389,9 @@ def _ListBatchJobsResponse_from_vertex(
 
 def _DeleteResourceJob_from_vertex(
     api_client: BaseApiClient,
-    from_object: Union[dict, object],
-    parent_object: Optional[dict] = None,
-) -> dict:
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
   to_object: dict[str, Any] = {}
   if getv(from_object, ['name']) is not None:
     setv(to_object, ['name'], getv(from_object, ['name']))