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

google/genai/_api_client.py

@@ -584,13 +584,9 @@ class BaseApiClient:
     # Initialize the lock. This lock will be used to protect access to the
     # credentials. This is crucial for thread safety when multiple coroutines
     # might be accessing the credentials at the same time.
-    try:
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
-    except RuntimeError:
-      asyncio.set_event_loop(asyncio.new_event_loop())
-      self._sync_auth_lock = threading.Lock()
-      self._async_auth_lock = asyncio.Lock()
+    self._sync_auth_lock = threading.Lock()
+    self._async_auth_lock: Optional[asyncio.Lock] = None
+    self._async_auth_lock_creation_lock: Optional[asyncio.Lock] = None
 
     # Handle when to use Vertex AI in express mode (api key).
     # Explicit initializer arguments are already validated above.
@@ -903,10 +899,36 @@ class BaseApiClient:
       else:
         raise RuntimeError('Could not resolve API token from the environment')
 
+  async def _get_async_auth_lock(self) -> asyncio.Lock:
+    """Lazily initializes and returns an asyncio.Lock for async authentication.
+
+    This method ensures that a single `asyncio.Lock` instance is created and
+    shared among all asynchronous operations that require authentication,
+    preventing race conditions when accessing or refreshing credentials.
+
+    The lock is created on the first call to this method. An internal async lock
+    is used to protect the creation of the main authentication lock to ensure
+    it's a singleton within the client instance.
+
+    Returns:
+        The asyncio.Lock instance for asynchronous authentication operations.
+    """
+    if self._async_auth_lock is None:
+      # Create async creation lock if needed
+      if self._async_auth_lock_creation_lock is None:
+        self._async_auth_lock_creation_lock = asyncio.Lock()
+
+      async with self._async_auth_lock_creation_lock:
+        if self._async_auth_lock is None:
+          self._async_auth_lock = asyncio.Lock()
+
+    return self._async_auth_lock
+
   async def _async_access_token(self) -> Union[str, Any]:
     """Retrieves the access token for the credentials asynchronously."""
     if not self._credentials:
-      async with self._async_auth_lock:
+      async_auth_lock = await self._get_async_auth_lock()
+      async with async_auth_lock:
         # This ensures that only one coroutine can execute the auth logic at a
         # time for thread safety.
         if not self._credentials:
@@ -920,7 +942,8 @@ class BaseApiClient:
     if self._credentials:
       if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
-        async with self._async_auth_lock:
+        async_auth_lock = await self._get_async_auth_lock()
+        async with async_auth_lock:
           if self._credentials.expired or not self._credentials.token:
             # Double check that the credentials expired before refreshing.
             await asyncio.to_thread(refresh_auth, self._credentials)

google/genai/_replay_api_client.py

@@ -471,6 +471,21 @@ class ReplayApiClient(BaseApiClient):
     expected = interaction.response.sdk_response_segments[
         self._sdk_response_index
     ]
+    # The sdk_http_response.body has format in the string, need to get rid of
+    # the format information before comparing.
+    if isinstance(expected, dict):
+      if 'sdk_http_response' in expected and isinstance(
+          expected['sdk_http_response'], dict
+      ):
+        if 'body' in expected['sdk_http_response']:
+          raw_body = expected['sdk_http_response']['body']
+          print('raw_body length: ', len(raw_body))
+          print('raw_body: ', raw_body)
+          if isinstance(raw_body, str) and raw_body != '':
+            raw_body = json.loads(raw_body)
+            raw_body = json.dumps(raw_body)
+            expected['sdk_http_response']['body'] = raw_body
+
     assert (
         actual == expected
     ), f'SDK response mismatch:\nActual: {actual}\nExpected: {expected}'

google/genai/files.py

@@ -434,6 +434,7 @@ class Files(_api_module.BaseModule):
         config, 'should_return_http_response', None
     ):
       return_value = types.CreateFileResponse(sdk_http_response=response)
+      self._api_client._verify_response(return_value)
       return return_value
 
     response_dict = '' if not response.body else json.loads(response.body)
@@ -916,6 +917,7 @@ class AsyncFiles(_api_module.BaseModule):
         config, 'should_return_http_response', None
     ):
       return_value = types.CreateFileResponse(sdk_http_response=response)
+      self._api_client._verify_response(return_value)
       return return_value
 
     response_dict = '' if not response.body else json.loads(response.body)

google/genai/models.py

@@ -1330,7 +1330,11 @@ def _GenerateVideosConfig_to_mldev(
     )
 
   if getv(from_object, ['resolution']) is not None:
-    raise ValueError('resolution parameter is not supported in Gemini API.')
+    setv(
+        parent_object,
+        ['parameters', 'resolution'],
+        getv(from_object, ['resolution']),
+    )
 
   if getv(from_object, ['person_generation']) is not None:
     setv(
@@ -5256,6 +5260,13 @@ class Models(_api_module.BaseModule):
         'post', path, request_dict, http_options
     )
 
+    if config is not None and getattr(
+        config, 'should_return_http_response', None
+    ):
+      return_value = types.GenerateContentResponse(sdk_http_response=response)
+      self._api_client._verify_response(return_value)
+      return return_value
+
     response_dict = '' if not response.body else json.loads(response.body)
 
     if self._api_client.vertexai:
@@ -5455,13 +5466,7 @@ class Models(_api_module.BaseModule):
       prompt: str,
       config: Optional[types.GenerateImagesConfigOrDict] = None,
   ) -> types.GenerateImagesResponse:
-    """Generates images based on a text description and configuration.
-
-    Args:
-      model (str): The model to use.
-      prompt (str): A text description of the images to generate.
-      config (GenerateImagesConfig): Configuration for generation.
-    """
+    """Private method for generating images."""
 
     parameter_model = types._GenerateImagesParameters(
         model=model,
@@ -5534,47 +5539,7 @@ class Models(_api_module.BaseModule):
       reference_images: list[types._ReferenceImageAPIOrDict],
       config: Optional[types.EditImageConfigOrDict] = None,
   ) -> types.EditImageResponse:
-    """Edits an image based on a text description and configuration.
-
-    Args:
-      model (str): The model to use.
-      prompt (str): A text description of the edit to apply to the image.
-        reference_images (list[Union[RawReferenceImage, MaskReferenceImage,
-        ControlReferenceImage, StyleReferenceImage, SubjectReferenceImage]): The
-        reference images for editing.
-      config (EditImageConfig): Configuration for editing.
-
-    Usage:
-
-    .. code-block:: python
-
-      from google.genai.types import RawReferenceImage, MaskReferenceImage
-
-      raw_ref_image = RawReferenceImage(
-        reference_id=1,
-        reference_image=types.Image.from_file(IMAGE_FILE_PATH),
-      )
-
-      mask_ref_image = MaskReferenceImage(
-        reference_id=2,
-        config=types.MaskReferenceConfig(
-            mask_mode='MASK_MODE_FOREGROUND',
-            mask_dilation=0.06,
-        ),
-      )
-      response = client.models.edit_image(
-        model='imagen-3.0-capability-001',
-        prompt='man with dog',
-        reference_images=[raw_ref_image, mask_ref_image],
-        config=types.EditImageConfig(
-            edit_mode= "EDIT_MODE_INPAINT_INSERTION",
-            number_of_images= 1,
-            include_rai_reason= True,
-        )
-      )
-      response.generated_images[0].image.show()
-      # Shows a man with a dog instead of a cat.
-    """
+    """Private method for editing an image."""
 
     parameter_model = types._EditImageParameters(
         model=model,
@@ -5638,14 +5603,7 @@ class Models(_api_module.BaseModule):
       upscale_factor: str,
       config: Optional[types._UpscaleImageAPIConfigOrDict] = None,
   ) -> types.UpscaleImageResponse:
-    """Upscales an image.
-
-    Args:
-      model (str): The model to use.
-      image (Image): The input image for upscaling.
-      upscale_factor (str): The factor to upscale the image (x2 or x4).
-      config (_UpscaleImageAPIConfig): Configuration for upscaling.
-    """
+    """Private method for upscaling an image."""
 
     parameter_model = types._UpscaleImageAPIParameters(
         model=model,
@@ -6331,39 +6289,7 @@ class Models(_api_module.BaseModule):
       source: Optional[types.GenerateVideosSourceOrDict] = None,
       config: Optional[types.GenerateVideosConfigOrDict] = None,
   ) -> types.GenerateVideosOperation:
-    """Generates videos based on an input (text, image, or video) and configuration.
-
-    The following use cases are supported:
-    1. Text to video generation.
-    2a. Image to video generation (additional text prompt is optional).
-    2b. Image to video generation with frame interpolation (specify last_frame
-    in config).
-    3. Video extension (additional text prompt is optional)
-
-    Args:
-      model: The model to use.
-      prompt: The text prompt for generating the videos. Optional for image to
-        video and video extension use cases.
-      image: The input image for generating the videos. Optional if prompt is
-        provided.
-      video: The input video for video extension use cases. Optional if prompt
-        or image is provided.
-      config: Configuration for generation.
-
-    Usage:
-
-      ```
-      operation = client.models.generate_videos(
-          model="veo-2.0-generate-001",
-          prompt="A neon hologram of a cat driving at top speed",
-      )
-      while not operation.done:
-          time.sleep(10)
-          operation = client.operations.get(operation)
-
-      operation.result.generated_videos[0].video.uri
-      ```
-    """
+    """Private method for generating videos."""
 
     parameter_model = types._GenerateVideosParameters(
         model=model,
@@ -7081,6 +7007,13 @@ class AsyncModels(_api_module.BaseModule):
         'post', path, request_dict, http_options
     )
 
+    if config is not None and getattr(
+        config, 'should_return_http_response', None
+    ):
+      return_value = types.GenerateContentResponse(sdk_http_response=response)
+      self._api_client._verify_response(return_value)
+      return return_value
+
     response_dict = '' if not response.body else json.loads(response.body)
 
     if self._api_client.vertexai:
@@ -7285,13 +7218,7 @@ class AsyncModels(_api_module.BaseModule):
       prompt: str,
       config: Optional[types.GenerateImagesConfigOrDict] = None,
   ) -> types.GenerateImagesResponse:
-    """Generates images based on a text description and configuration.
-
-    Args:
-      model (str): The model to use.
-      prompt (str): A text description of the images to generate.
-      config (GenerateImagesConfig): Configuration for generation.
-    """
+    """Private method for generating images asynchronously."""
 
     parameter_model = types._GenerateImagesParameters(
         model=model,
@@ -7364,47 +7291,7 @@ class AsyncModels(_api_module.BaseModule):
       reference_images: list[types._ReferenceImageAPIOrDict],
       config: Optional[types.EditImageConfigOrDict] = None,
   ) -> types.EditImageResponse:
-    """Edits an image based on a text description and configuration.
-
-    Args:
-      model (str): The model to use.
-      prompt (str): A text description of the edit to apply to the image.
-        reference_images (list[Union[RawReferenceImage, MaskReferenceImage,
-        ControlReferenceImage, StyleReferenceImage, SubjectReferenceImage]): The
-        reference images for editing.
-      config (EditImageConfig): Configuration for editing.
-
-    Usage:
-
-    .. code-block:: python
-
-      from google.genai.types import RawReferenceImage, MaskReferenceImage
-
-      raw_ref_image = RawReferenceImage(
-        reference_id=1,
-        reference_image=types.Image.from_file(IMAGE_FILE_PATH),
-      )
-
-      mask_ref_image = MaskReferenceImage(
-        reference_id=2,
-        config=types.MaskReferenceConfig(
-            mask_mode='MASK_MODE_FOREGROUND',
-            mask_dilation=0.06,
-        ),
-      )
-      response = await client.aio.models.edit_image(
-        model='imagen-3.0-capability-001',
-        prompt='man with dog',
-        reference_images=[raw_ref_image, mask_ref_image],
-        config=types.EditImageConfig(
-            edit_mode= "EDIT_MODE_INPAINT_INSERTION",
-            number_of_images= 1,
-            include_rai_reason= True,
-        )
-      )
-      response.generated_images[0].image.show()
-      # Shows a man with a dog instead of a cat.
-    """
+    """Private method for editing an image asynchronously."""
 
     parameter_model = types._EditImageParameters(
         model=model,
@@ -7468,14 +7355,7 @@ class AsyncModels(_api_module.BaseModule):
       upscale_factor: str,
       config: Optional[types._UpscaleImageAPIConfigOrDict] = None,
   ) -> types.UpscaleImageResponse:
-    """Upscales an image.
-
-    Args:
-      model (str): The model to use.
-      image (Image): The input image for upscaling.
-      upscale_factor (str): The factor to upscale the image (x2 or x4).
-      config (_UpscaleImageAPIConfig): Configuration for upscaling.
-    """
+    """Private method for upscaling an image asynchronously."""
 
     parameter_model = types._UpscaleImageAPIParameters(
         model=model,
@@ -8167,39 +8047,7 @@ class AsyncModels(_api_module.BaseModule):
       source: Optional[types.GenerateVideosSourceOrDict] = None,
       config: Optional[types.GenerateVideosConfigOrDict] = None,
   ) -> types.GenerateVideosOperation:
-    """Generates videos based on an input (text, image, or video) and configuration.
-
-    The following use cases are supported:
-    1. Text to video generation.
-    2a. Image to video generation (additional text prompt is optional).
-    2b. Image to video generation with frame interpolation (specify last_frame
-    in config).
-    3. Video extension (additional text prompt is optional)
-
-    Args:
-      model: The model to use.
-      prompt: The text prompt for generating the videos. Optional for image to
-        video and video extension use cases.
-      image: The input image for generating the videos. Optional if prompt is
-        provided.
-      video: The input video for video extension use cases. Optional if prompt
-        or image is provided.
-      config: Configuration for generation.
-
-    Usage:
-
-      ```
-      operation = client.models.generate_videos(
-          model="veo-2.0-generate-001",
-          prompt="A neon hologram of a cat driving at top speed",
-      )
-      while not operation.done:
-          time.sleep(10)
-          operation = client.operations.get(operation)
-
-      operation.result.generated_videos[0].video.uri
-      ```
-    """
+    """Private method for generating videos asynchronously."""
 
     parameter_model = types._GenerateVideosParameters(
         model=model,