google-genai 1.35.0__tar.gz → 1.37.0__tar.gz

{google_genai-1.35.0/google_genai.egg-info → google_genai-1.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.35.0
+Version: 1.37.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -58,6 +58,12 @@ APIs.
 pip install google-genai
 ```
 
+<small>With `uv`:</small>
+
+```sh
+uv pip install google-genai
+```
+
 ## Imports
 
 ```python

{google_genai-1.35.0 → google_genai-1.37.0}/README.md

@@ -21,6 +21,12 @@ APIs.
 pip install google-genai
 ```
 
+<small>With `uv`:</small>
+
+```sh
+uv pip install google-genai
+```
+
 ## Imports
 
 ```python

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/_api_client.py

@@ -229,7 +229,6 @@ class HttpResponse:
       headers: Union[dict[str, str], httpx.Headers, 'CIMultiDictProxy[str]'],
       response_stream: Union[Any, str] = None,
       byte_stream: Union[Any, bytes] = None,
-      session: Optional['aiohttp.ClientSession'] = None,
   ):
     if isinstance(headers, dict):
       self.headers = headers
@@ -245,7 +244,6 @@ class HttpResponse:
     self.status_code: int = 200
     self.response_stream = response_stream
     self.byte_stream = byte_stream
-    self._session = session
 
   # Async iterator for async streaming.
   def __aiter__(self) -> 'HttpResponse':
@@ -360,69 +358,76 @@ class HttpResponse:
     balance = 0
     # httpx.Response has a dedicated async line iterator.
     if isinstance(self.response_stream, httpx.Response):
-      async for line in self.response_stream.aiter_lines():
-        if not line:
-          continue
-        # In streaming mode, the response of JSON is prefixed with "data: "
-        # which we must strip before parsing.
-        if line.startswith('data: '):
-          yield line[len('data: '):]
-          continue
-
-        # When API returns an error message, it comes line by line. So we buffer
-        # the lines until a complete JSON string is read. A complete JSON string
-        # is found when the balance is 0.
-        for c in line:
-          if c == '{':
-            balance += 1
-          elif c == '}':
-            balance -= 1
-
-        chunk += line
-        if balance == 0:
+      try:
+        async for line in self.response_stream.aiter_lines():
+          if not line:
+            continue
+          # In streaming mode, the response of JSON is prefixed with "data: "
+          # which we must strip before parsing.
+          if line.startswith('data: '):
+            yield line[len('data: '):]
+            continue
+
+          # When API returns an error message, it comes line by line. So we buffer
+          # the lines until a complete JSON string is read. A complete JSON string
+          # is found when the balance is 0.
+          for c in line:
+            if c == '{':
+              balance += 1
+            elif c == '}':
+              balance -= 1
+
+          chunk += line
+          if balance == 0:
+            yield chunk
+            chunk = ''
+        # If there is any remaining chunk, yield it.
+        if chunk:
           yield chunk
-          chunk = ''
+      finally:
+        # Close the response and release the connection.
+        await self.response_stream.aclose()
 
     # aiohttp.ClientResponse uses a content stream that we read line by line.
     elif has_aiohttp and isinstance(
         self.response_stream, aiohttp.ClientResponse
     ):
-      while True:
-        # Read a line from the stream. This returns bytes.
-        line_bytes = await self.response_stream.content.readline()
-        if not line_bytes:
-          break
-        # Decode the bytes and remove trailing whitespace and newlines.
-        line = line_bytes.decode('utf-8').rstrip()
-        if not line:
-          continue
-
-        # In streaming mode, the response of JSON is prefixed with "data: "
-        # which we must strip before parsing.
-        if line.startswith('data: '):
-          yield line[len('data: '):]
-          continue
-
-        # When API returns an error message, it comes line by line. So we buffer
-        # the lines until a complete JSON string is read. A complete JSON string
-        # is found when the balance is 0.
-        for c in line:
-          if c == '{':
-            balance += 1
-          elif c == '}':
-            balance -= 1
-
-        chunk += line
-        if balance == 0:
+      try:
+        while True:
+          # Read a line from the stream. This returns bytes.
+          line_bytes = await self.response_stream.content.readline()
+          if not line_bytes:
+            break
+          # Decode the bytes and remove trailing whitespace and newlines.
+          line = line_bytes.decode('utf-8').rstrip()
+          if not line:
+            continue
+
+          # In streaming mode, the response of JSON is prefixed with "data: "
+          # which we must strip before parsing.
+          if line.startswith('data: '):
+            yield line[len('data: '):]
+            continue
+
+          # When API returns an error message, it comes line by line. So we
+          # buffer the lines until a complete JSON string is read. A complete
+          # JSON strings found when the balance is 0.
+          for c in line:
+            if c == '{':
+              balance += 1
+            elif c == '}':
+              balance -= 1
+
+          chunk += line
+          if balance == 0:
+            yield chunk
+            chunk = ''
+        # If there is any remaining chunk, yield it.
+        if chunk:
           yield chunk
-          chunk = ''
-
-    # If there is any remaining chunk, yield it.
-    if chunk:
-      yield chunk
-
-    if hasattr(self, '_session') and self._session:
-      await self._session.close()
+      finally:
+        # Release the connection back to the pool for potential reuse.
+        self.response_stream.release()
 
   @classmethod
   def _load_json_from_response(cls, response: Any) -> Any:
@@ -683,12 +688,25 @@ class BaseApiClient:
       self._async_client_session_request_args = self._ensure_aiohttp_ssl_ctx(
           self._http_options
       )
-    self._websocket_ssl_ctx = self._ensure_websocket_ssl_ctx(self._http_options)
+    # Initialize the aiohttp client session.
+    self._aiohttp_session: Optional[aiohttp.ClientSession] = None
 
     retry_kwargs = retry_args(self._http_options.retry_options)
+    self._websocket_ssl_ctx = self._ensure_websocket_ssl_ctx(self._http_options)
     self._retry = tenacity.Retrying(**retry_kwargs)
     self._async_retry = tenacity.AsyncRetrying(**retry_kwargs)
 
+  async def _get_aiohttp_session(self) -> 'aiohttp.ClientSession':
+    """Returns the aiohttp client session."""
+    if self._aiohttp_session is None or self._aiohttp_session.closed:
+      # Initialize the aiohttp client session if it's not set up or closed.
+      self._aiohttp_session = aiohttp.ClientSession(
+          connector=aiohttp.TCPConnector(limit=0),
+          trust_env=True,
+          read_bufsize=READ_BUFFER_SIZE,
+      )
+    return self._aiohttp_session
+
   @staticmethod
   def _ensure_httpx_ssl_ctx(
       options: HttpOptions,
@@ -767,7 +785,6 @@ class BaseApiClient:
     Returns:
       An async aiohttp ClientSession._request args.
     """
-
     verify = 'ssl'  # keep it consistent with httpx.
     async_args = options.async_client_args
     ctx = async_args.get(verify) if async_args else None
@@ -1132,13 +1149,9 @@ class BaseApiClient:
 
     if stream:
       if self._use_aiohttp():
-        session = aiohttp.ClientSession(
-            headers=http_request.headers,
-            trust_env=True,
-            read_bufsize=READ_BUFFER_SIZE,
-        )
+        self._aiohttp_session = await self._get_aiohttp_session()
         try:
-          response = await session.request(
+          response = await self._aiohttp_session.request(
               method=http_request.method,
               url=http_request.url,
               headers=http_request.headers,
@@ -1159,12 +1172,8 @@ class BaseApiClient:
               self._ensure_aiohttp_ssl_ctx(self._http_options)
           )
           # Instantiate a new session with the updated SSL context.
-          session = aiohttp.ClientSession(
-              headers=http_request.headers,
-              trust_env=True,
-              read_bufsize=READ_BUFFER_SIZE,
-          )
-          response = await session.request(
+          self._aiohttp_session = await self._get_aiohttp_session()
+          response = await self._aiohttp_session.request(
               method=http_request.method,
               url=http_request.url,
               headers=http_request.headers,
@@ -1174,7 +1183,7 @@ class BaseApiClient:
           )
 
         await errors.APIError.raise_for_async_response(response)
-        return HttpResponse(response.headers, response, session=session)
+        return HttpResponse(response.headers, response)
       else:
         # aiohttp is not available. Fall back to httpx.
         httpx_request = self._async_httpx_client.build_request(
@@ -1192,22 +1201,18 @@ class BaseApiClient:
         return HttpResponse(client_response.headers, client_response)
     else:
       if self._use_aiohttp():
+        self._aiohttp_session = await self._get_aiohttp_session()
         try:
-          async with aiohttp.ClientSession(
+          response = await self._aiohttp_session.request(
+              method=http_request.method,
+              url=http_request.url,
               headers=http_request.headers,
-              trust_env=True,
-              read_bufsize=READ_BUFFER_SIZE,
-          ) as session:
-            response = await session.request(
-                method=http_request.method,
-                url=http_request.url,
-                headers=http_request.headers,
-                data=data,
-                timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
-                **self._async_client_session_request_args,
-            )
-            await errors.APIError.raise_for_async_response(response)
-            return HttpResponse(response.headers, [await response.text()])
+              data=data,
+              timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+              **self._async_client_session_request_args,
+          )
+          await errors.APIError.raise_for_async_response(response)
+          return HttpResponse(response.headers, [await response.text()])
         except (
             aiohttp.ClientConnectorError,
             aiohttp.ClientConnectorDNSError,
@@ -1221,21 +1226,17 @@ class BaseApiClient:
               self._ensure_aiohttp_ssl_ctx(self._http_options)
           )
           # Instantiate a new session with the updated SSL context.
-          async with aiohttp.ClientSession(
+          self._aiohttp_session = await self._get_aiohttp_session()
+          response = await self._aiohttp_session.request(
+              method=http_request.method,
+              url=http_request.url,
               headers=http_request.headers,
-              trust_env=True,
-              read_bufsize=READ_BUFFER_SIZE,
-          ) as session:
-            response = await session.request(
-                method=http_request.method,
-                url=http_request.url,
-                headers=http_request.headers,
-                data=data,
-                timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
-                **self._async_client_session_request_args,
-            )
-            await errors.APIError.raise_for_async_response(response)
-            return HttpResponse(response.headers, [await response.text()])
+              data=data,
+              timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+              **self._async_client_session_request_args,
+          )
+          await errors.APIError.raise_for_async_response(response)
+          return HttpResponse(response.headers, [await response.text()])
       else:
         # aiohttp is not available. Fall back to httpx.
         client_response = await self._async_httpx_client.request(
@@ -1551,85 +1552,79 @@ class BaseApiClient:
     offset = 0
     # Upload the file in chunks
     if self._use_aiohttp():  # pylint: disable=g-import-not-at-top
-      async with aiohttp.ClientSession(
-          headers=self._http_options.headers,
-          trust_env=True,
-          read_bufsize=READ_BUFFER_SIZE,
-      ) as session:
-        while True:
-          if isinstance(file, io.IOBase):
-            file_chunk = file.read(CHUNK_SIZE)
-          else:
-            file_chunk = await file.read(CHUNK_SIZE)
-          chunk_size = 0
-          if file_chunk:
-            chunk_size = len(file_chunk)
-          upload_command = 'upload'
-          # If last chunk, finalize the upload.
-          if chunk_size + offset >= upload_size:
-            upload_command += ', finalize'
-          http_options = http_options if http_options else self._http_options
+      self._aiohttp_session = await self._get_aiohttp_session()
+      while True:
+        if isinstance(file, io.IOBase):
+          file_chunk = file.read(CHUNK_SIZE)
+        else:
+          file_chunk = await file.read(CHUNK_SIZE)
+        chunk_size = 0
+        if file_chunk:
+          chunk_size = len(file_chunk)
+        upload_command = 'upload'
+        # If last chunk, finalize the upload.
+        if chunk_size + offset >= upload_size:
+          upload_command += ', finalize'
+        http_options = http_options if http_options else self._http_options
+        timeout = (
+            http_options.get('timeout')
+             if isinstance(http_options, dict)
+             else http_options.timeout
+        )
+        if timeout is None:
+          # Per request timeout is not configured. Check the global timeout.
           timeout = (
-              http_options.get('timeout')
-              if isinstance(http_options, dict)
-              else http_options.timeout
+              self._http_options.timeout
+              if isinstance(self._http_options, dict)
+              else self._http_options.timeout
+          )
+        timeout_in_seconds = get_timeout_in_seconds(timeout)
+        upload_headers = {
+            'X-Goog-Upload-Command': upload_command,
+             'X-Goog-Upload-Offset': str(offset),
+            'Content-Length': str(chunk_size),
+        }
+        populate_server_timeout_header(upload_headers, timeout_in_seconds)
+
+        retry_count = 0
+        response = None
+        while retry_count < MAX_RETRY_COUNT:
+          response = await self._aiohttp_session.request(
+              method='POST',
+              url=upload_url,
+              data=file_chunk,
+              headers=upload_headers,
+              timeout=aiohttp.ClientTimeout(connect=timeout_in_seconds),
           )
-          if timeout is None:
-            # Per request timeout is not configured. Check the global timeout.
-            timeout = (
-                self._http_options.timeout
-                if isinstance(self._http_options, dict)
-                else self._http_options.timeout
-            )
-          timeout_in_seconds = get_timeout_in_seconds(timeout)
-          upload_headers = {
-              'X-Goog-Upload-Command': upload_command,
-              'X-Goog-Upload-Offset': str(offset),
-              'Content-Length': str(chunk_size),
-          }
-          populate_server_timeout_header(upload_headers, timeout_in_seconds)
-
-          retry_count = 0
-          response = None
-          while retry_count < MAX_RETRY_COUNT:
-            response = await session.request(
-                method='POST',
-                url=upload_url,
-                data=file_chunk,
-                headers=upload_headers,
-                timeout=aiohttp.ClientTimeout(connect=timeout_in_seconds),
-            )
-
-            if response.headers.get('X-Goog-Upload-Status'):
-              break
-            delay_seconds = INITIAL_RETRY_DELAY * (
-                DELAY_MULTIPLIER**retry_count
-            )
-            retry_count += 1
-            time.sleep(delay_seconds)
-
-          offset += chunk_size
-          if (
-              response is not None
-              and response.headers.get('X-Goog-Upload-Status') != 'active'
-          ):
-            break  # upload is complete or it has been interrupted.
 
-          if upload_size <= offset:  # Status is not finalized.
-            raise ValueError(
-                f'All content has been uploaded, but the upload status is not'
-                f' finalized.'
-            )
+          if response.headers.get('X-Goog-Upload-Status'):
+            break
+          delay_seconds = INITIAL_RETRY_DELAY * (DELAY_MULTIPLIER**retry_count)
+          retry_count += 1
+          await asyncio.sleep(delay_seconds)
+
+        offset += chunk_size
         if (
             response is not None
-            and response.headers.get('X-Goog-Upload-Status') != 'final'
+            and response.headers.get('X-Goog-Upload-Status') != 'active'
         ):
+          break  # upload is complete or it has been interrupted.
+
+        if upload_size <= offset:  # Status is not finalized.
           raise ValueError(
-              'Failed to upload file: Upload status is not finalized.'
+              f'All content has been uploaded, but the upload status is not'
+              f' finalized.'
           )
-        return HttpResponse(
-            response.headers, response_stream=[await response.text()]
+      if (
+          response is not None
+          and response.headers.get('X-Goog-Upload-Status') != 'final'
+      ):
+        raise ValueError(
+            'Failed to upload file: Upload status is not finalized.'
         )
+      return HttpResponse(
+          response.headers, response_stream=[await response.text()]
+      )
     else:
       # aiohttp is not available. Fall back to httpx.
       while True:
@@ -1735,23 +1730,19 @@ class BaseApiClient:
         data = http_request.data
 
     if self._use_aiohttp():
-      async with aiohttp.ClientSession(
+      self._aiohttp_session = await self._get_aiohttp_session()
+      response = await self._aiohttp_session.request(
+          method=http_request.method,
+          url=http_request.url,
           headers=http_request.headers,
-          trust_env=True,
-          read_bufsize=READ_BUFFER_SIZE,
-      ) as session:
-        response = await session.request(
-            method=http_request.method,
-            url=http_request.url,
-            headers=http_request.headers,
-            data=data,
-            timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
-        )
-        await errors.APIError.raise_for_async_response(response)
+          data=data,
+          timeout=aiohttp.ClientTimeout(connect=http_request.timeout),
+      )
+      await errors.APIError.raise_for_async_response(response)
 
-        return HttpResponse(
-            response.headers, byte_stream=[await response.read()]
-        ).byte_stream[0]
+      return HttpResponse(
+          response.headers, byte_stream=[await response.read()]
+      ).byte_stream[0]
     else:
       # aiohttp is not available. Fall back to httpx.
       client_response = await self._async_httpx_client.request(

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/_replay_api_client.py

@@ -35,7 +35,6 @@ from ._api_client import HttpRequest
 from ._api_client import HttpResponse
 from ._common import BaseModel
 from .types import HttpOptions, HttpOptionsOrDict
-from .types import GenerateVideosOperation
 
 
 def to_snake_case(name: str) -> str:

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/_transformers.py

@@ -1290,10 +1290,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

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/errors.py

@@ -42,6 +42,9 @@ class APIError(Exception):
           Union['ReplayResponse', httpx.Response, 'aiohttp.ClientResponse']
       ] = None,
   ):
+    if isinstance(response_json, list) and len(response_json) == 1:
+      response_json = response_json[0]
+
     self.response = response
     self.details = response_json
     self.message = self._get_message(response_json)

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/operations.py

@@ -87,6 +87,42 @@ def _FetchPredictOperationParameters_to_vertex(
   return to_object
 
 
+def _GetProjectOperationParameters_to_vertex(
+    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, ['operation_id']) is not None:
+    setv(
+        to_object, ['_url', 'operation_id'], getv(from_object, ['operation_id'])
+    )
+
+  if getv(from_object, ['config']) is not None:
+    setv(to_object, ['config'], getv(from_object, ['config']))
+
+  return to_object
+
+
+def _ProjectOperation_from_vertex(
+    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']))
+
+  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']))
+
+  return to_object
+
+
 class Operations(_api_module.BaseModule):
 
   def _get_videos_operation(
@@ -188,6 +224,58 @@ class Operations(_api_module.BaseModule):
 
     return response_dict
 
+  def _get(
+      self,
+      *,
+      operation_id: str,
+      config: Optional[types.GetOperationConfigOrDict] = None,
+  ) -> types.ProjectOperation:
+    parameter_model = types._GetProjectOperationParameters(
+        operation_id=operation_id,
+        config=config,
+    )
+
+    request_url_dict: Optional[dict[str, str]]
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
+      request_dict = _GetProjectOperationParameters_to_vertex(parameter_model)
+      request_url_dict = request_dict.get('_url')
+      if request_url_dict:
+        path = 'operations/{operation_id}'.format_map(request_url_dict)
+      else:
+        path = 'operations/{operation_id}'
+
+    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: Optional[types.HttpOptions] = None
+    if (
+        parameter_model.config is not None
+        and parameter_model.config.http_options is not None
+    ):
+      http_options = parameter_model.config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response = self._api_client.request('get', path, request_dict, http_options)
+
+    response_dict = '' if not response.body else json.loads(response.body)
+
+    if self._api_client.vertexai:
+      response_dict = _ProjectOperation_from_vertex(response_dict)
+
+    return_value = types.ProjectOperation._from_response(
+        response=response_dict, kwargs=parameter_model.model_dump()
+    )
+
+    self._api_client._verify_response(return_value)
+    return return_value
+
   T = TypeVar('T', bound=types.Operation)
 
   def get(
@@ -344,6 +432,60 @@ class AsyncOperations(_api_module.BaseModule):
 
     return response_dict
 
+  async def _get(
+      self,
+      *,
+      operation_id: str,
+      config: Optional[types.GetOperationConfigOrDict] = None,
+  ) -> types.ProjectOperation:
+    parameter_model = types._GetProjectOperationParameters(
+        operation_id=operation_id,
+        config=config,
+    )
+
+    request_url_dict: Optional[dict[str, str]]
+    if not self._api_client.vertexai:
+      raise ValueError('This method is only supported in the Vertex AI client.')
+    else:
+      request_dict = _GetProjectOperationParameters_to_vertex(parameter_model)
+      request_url_dict = request_dict.get('_url')
+      if request_url_dict:
+        path = 'operations/{operation_id}'.format_map(request_url_dict)
+      else:
+        path = 'operations/{operation_id}'
+
+    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: Optional[types.HttpOptions] = None
+    if (
+        parameter_model.config is not None
+        and parameter_model.config.http_options is not None
+    ):
+      http_options = parameter_model.config.http_options
+
+    request_dict = _common.convert_to_dict(request_dict)
+    request_dict = _common.encode_unserializable_types(request_dict)
+
+    response = await self._api_client.async_request(
+        'get', path, request_dict, http_options
+    )
+
+    response_dict = '' if not response.body else json.loads(response.body)
+
+    if self._api_client.vertexai:
+      response_dict = _ProjectOperation_from_vertex(response_dict)
+
+    return_value = types.ProjectOperation._from_response(
+        response=response_dict, kwargs=parameter_model.model_dump()
+    )
+
+    self._api_client._verify_response(return_value)
+    return return_value
+
   T = TypeVar('T', bound=types.Operation)
 
   async def get(

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/tunings.py

@@ -209,6 +209,9 @@ def _CreateTuningJobConfig_to_mldev(
         'evaluation_config parameter is not supported in Gemini API.'
     )
 
+  if getv(from_object, ['labels']) is not None:
+    raise ValueError('labels parameter is not supported in Gemini API.')
+
   return to_object
 
 
@@ -507,6 +510,9 @@ def _CreateTuningJobConfig_to_vertex(
         ),
     )
 
+  if getv(from_object, ['labels']) is not None:
+    setv(parent_object, ['labels'], getv(from_object, ['labels']))
+
   return to_object
 
 

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/types.py

@@ -609,6 +609,26 @@ class VideoGenerationReferenceType(_common.CaseInSensitiveEnum):
       such as 'anime', 'photography', 'origami', etc."""
 
 
+class VideoGenerationMaskMode(_common.CaseInSensitiveEnum):
+  """Enum for the mask mode of a video generation mask."""
+
+  INSERT = 'INSERT'
+  """The image mask contains a masked rectangular region which is
+      applied on the first frame of the input video. The object described in
+      the prompt is inserted into this region and will appear in subsequent
+      frames."""
+  REMOVE = 'REMOVE'
+  """The image mask is used to determine an object in the
+      first video frame to track. This object is removed from the video."""
+  REMOVE_STATIC = 'REMOVE_STATIC'
+  """The image mask is used to determine a region in the
+      video. Objects in this region will be removed."""
+  OUTPAINT = 'OUTPAINT'
+  """The image mask contains a masked rectangular region where
+      the input video will go. The remaining area will be generated. Video
+      masks are not supported."""
+
+
 class VideoCompressionQuality(_common.CaseInSensitiveEnum):
   """Enum that controls the compression quality of the generated videos."""
 
@@ -8422,7 +8442,7 @@ class VideoGenerationMask(_common.BaseModel):
       default=None,
       description="""The image mask to use for generating videos.""",
   )
-  mask_mode: Optional[str] = Field(
+  mask_mode: Optional[VideoGenerationMaskMode] = Field(
       default=None,
       description="""Describes how the mask will be used. Inpainting masks must
       match the aspect ratio of the input video. Outpainting masks can be
@@ -8436,7 +8456,7 @@ class VideoGenerationMaskDict(TypedDict, total=False):
   image: Optional[ImageDict]
   """The image mask to use for generating videos."""
 
-  mask_mode: Optional[str]
+  mask_mode: Optional[VideoGenerationMaskMode]
   """Describes how the mask will be used. Inpainting masks must
       match the aspect ratio of the input video. Outpainting masks can be
       either 9:16 or 16:9."""
@@ -10410,6 +10430,10 @@ class CreateTuningJobConfig(_common.BaseModel):
   evaluation_config: Optional[EvaluationConfig] = Field(
       default=None, description="""Evaluation config for the tuning job."""
   )
+  labels: Optional[dict[str, str]] = Field(
+      default=None,
+      description="""Optional. The labels with user-defined metadata to organize TuningJob and generated resources such as Model and Endpoint. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels.""",
+  )
 
 
 class CreateTuningJobConfigDict(TypedDict, total=False):
@@ -10451,6 +10475,9 @@ class CreateTuningJobConfigDict(TypedDict, total=False):
   evaluation_config: Optional[EvaluationConfigDict]
   """Evaluation config for the tuning job."""
 
+  labels: Optional[dict[str, str]]
+  """Optional. The labels with user-defined metadata to organize TuningJob and generated resources such as Model and Endpoint. Label keys and values can be no longer than 64 characters (Unicode codepoints), can only contain lowercase letters, numeric characters, underscores and dashes. International characters are allowed. See https://goo.gl/xmQnxf for more information and examples of labels."""
+
 
 CreateTuningJobConfigOrDict = Union[
     CreateTuningJobConfig, CreateTuningJobConfigDict
@@ -12331,6 +12358,78 @@ _FetchPredictOperationParametersOrDict = Union[
 ]
 
 
+class _GetProjectOperationParameters(_common.BaseModel):
+  """Parameters for the getProjectOperation method."""
+
+  operation_id: Optional[str] = Field(
+      default=None,
+      description="""The ID of the project-level Vertex operation to get. For example if the operation resource name is
+      projects/123/locations/us-central1/operations/456, the operation_id is
+      456.""",
+  )
+  config: Optional[GetOperationConfig] = Field(
+      default=None,
+      description="""Used to override the default configuration.""",
+  )
+
+
+class _GetProjectOperationParametersDict(TypedDict, total=False):
+  """Parameters for the getProjectOperation method."""
+
+  operation_id: Optional[str]
+  """The ID of the project-level Vertex operation to get. For example if the operation resource name is
+      projects/123/locations/us-central1/operations/456, the operation_id is
+      456."""
+
+  config: Optional[GetOperationConfigDict]
+  """Used to override the default configuration."""
+
+
+_GetProjectOperationParametersOrDict = Union[
+    _GetProjectOperationParameters, _GetProjectOperationParametersDict
+]
+
+
+class ProjectOperation(_common.BaseModel):
+  """A project-level operation in Vertex."""
+
+  name: Optional[str] = Field(
+      default=None,
+      description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""",
+  )
+  metadata: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any.""",
+  )
+  done: Optional[bool] = Field(
+      default=None,
+      description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""",
+  )
+  error: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""The error result of the operation in case of failure or cancellation.""",
+  )
+
+
+class ProjectOperationDict(TypedDict, total=False):
+  """A project-level operation in Vertex."""
+
+  name: Optional[str]
+  """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`."""
+
+  metadata: Optional[dict[str, Any]]
+  """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any."""
+
+  done: Optional[bool]
+  """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available."""
+
+  error: Optional[dict[str, Any]]
+  """The error result of the operation in case of failure or cancellation."""
+
+
+ProjectOperationOrDict = Union[ProjectOperation, ProjectOperationDict]
+
+
 class TestTableItem(_common.BaseModel):
 
   name: Optional[str] = Field(

{google_genai-1.35.0 → google_genai-1.37.0}/google/genai/version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 #
 
-__version__ = '1.35.0' # x-release-please-version
+__version__ = '1.37.0' # x-release-please-version

{google_genai-1.35.0 → google_genai-1.37.0/google_genai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-genai
-Version: 1.35.0
+Version: 1.37.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -58,6 +58,12 @@ APIs.
 pip install google-genai
 ```
 
+<small>With `uv`:</small>
+
+```sh
+uv pip install google-genai
+```
+
 ## Imports
 
 ```python

{google_genai-1.35.0 → google_genai-1.37.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel", "twine>=6.1.0", "packaging>=24.2", "pkginfo>=
 
 [project]
 name = "google-genai"
-version = "1.35.0"
+version = "1.37.0"
 description = "GenAI Python SDK"
 readme = "README.md"
 license = {text = "Apache-2.0"}