google-genai 1.7.0__tar.gz → 1.9.0__tar.gz

{google_genai-1.7.0/google_genai.egg-info → google_genai-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: google-genai
-Version: 1.7.0
+Version: 1.9.0
 Summary: GenAI Python SDK
 Author-email: Google LLC <googleapis-packages@google.com>
 License: Apache-2.0
@@ -27,6 +27,7 @@ Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: requests<3.0.0,>=2.28.1
 Requires-Dist: websockets<15.1.0,>=13.0.0
 Requires-Dist: typing-extensions<5.0.0,>=4.11.0
+Dynamic: license-file
 
 # Google Gen AI SDK
 

{google_genai-1.7.0 → google_genai-1.9.0}/google/genai/_api_client.py

@@ -68,26 +68,30 @@ def _append_library_version_headers(headers: dict[str, str]) -> None:
 
 
 def _patch_http_options(
-    options: HttpOptionsDict, patch_options: dict[str, Any]
-) -> HttpOptionsDict:
-  # use shallow copy so we don't override the original objects.
-  copy_option = HttpOptionsDict()
-  copy_option.update(options)
-  for patch_key, patch_value in patch_options.items():
-    # if both are dicts, update the copy.
-    # This is to handle cases like merging headers.
-    if isinstance(patch_value, dict) and isinstance(
-        copy_option.get(patch_key, None), dict
-    ):
-      copy_option[patch_key] = {}
-      copy_option[patch_key].update(
-          options[patch_key]
-      )  # shallow copy from original options.
-      copy_option[patch_key].update(patch_value)
-    elif patch_value is not None:  # Accept empty values.
-      copy_option[patch_key] = patch_value
-  if copy_option['headers']:
-    _append_library_version_headers(copy_option['headers'])
+    options: HttpOptions, patch_options: HttpOptions
+) -> HttpOptions:
+  copy_option = options.model_copy()
+
+  options_headers = copy_option.headers or {}
+  patch_options_headers = patch_options.headers or {}
+  copy_option.headers = {
+      **options_headers,
+      **patch_options_headers,
+  }
+
+  http_options_keys = HttpOptions.model_fields.keys()
+
+  for key in http_options_keys:
+    if key == 'headers':
+      continue
+    patch_value = getattr(patch_options, key, None)
+    if patch_value is not None:
+      setattr(copy_option, key, patch_value)
+    else:
+      setattr(copy_option, key, getattr(options, key))
+
+  if copy_option.headers is not None:
+    _append_library_version_headers(copy_option.headers)
   return copy_option
 
 
@@ -200,7 +204,7 @@ class HttpResponse:
       for chunk in self.response_stream:
         yield json.loads(chunk) if chunk else {}
     elif self.response_stream is None:
-      async for c in []:
+      async for c in []:  # type: ignore[attr-defined]
         yield c
     else:
       # Iterator of objects retrieved from the API.
@@ -216,9 +220,7 @@ class HttpResponse:
               chunk = chunk[len('data: ') :]
             yield json.loads(chunk)
       else:
-        raise ValueError(
-            'Error parsing streaming response.'
-        )
+        raise ValueError('Error parsing streaming response.')
 
   def byte_segments(self):
     if isinstance(self.byte_stream, list):
@@ -308,16 +310,14 @@ class BaseApiClient:
       )
 
     # Validate http_options if it is provided.
-    validated_http_options: dict[str, Any]
+    validated_http_options = HttpOptions()
     if isinstance(http_options, dict):
       try:
-        validated_http_options = HttpOptions.model_validate(
-            http_options
-        ).model_dump()
+        validated_http_options = HttpOptions.model_validate(http_options)
       except ValidationError as e:
         raise ValueError(f'Invalid http_options: {e}')
     elif isinstance(http_options, HttpOptions):
-      validated_http_options = http_options.model_dump()
+      validated_http_options = http_options
 
     # Retrieve implicitly set values from the environment.
     env_project = os.environ.get('GOOGLE_CLOUD_PROJECT', None)
@@ -328,11 +328,15 @@ class BaseApiClient:
     self.api_key = api_key or env_api_key
 
     self._credentials = credentials
-    self._http_options = HttpOptionsDict()
+    self._http_options = HttpOptions()
     # 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.
-    self._auth_lock = asyncio.Lock()
+    try:
+      self._auth_lock = asyncio.Lock()
+    except RuntimeError:
+      asyncio.set_event_loop(asyncio.new_event_loop())
+      self._auth_lock = asyncio.Lock()
 
     # Handle when to use Vertex AI in express mode (api key).
     # Explicit initializer arguments are already validated above.
@@ -376,12 +380,12 @@ class BaseApiClient:
             'AI API.'
         )
       if self.api_key or self.location == 'global':
-        self._http_options['base_url'] = f'https://aiplatform.googleapis.com/'
+        self._http_options.base_url = f'https://aiplatform.googleapis.com/'
       else:
-        self._http_options['base_url'] = (
+        self._http_options.base_url = (
             f'https://{self.location}-aiplatform.googleapis.com/'
         )
-      self._http_options['api_version'] = 'v1beta1'
+      self._http_options.api_version = 'v1beta1'
     else:  # Implicit initialization or missing arguments.
       if not self.api_key:
         raise ValueError(
@@ -389,27 +393,27 @@ class BaseApiClient:
             'provide (`api_key`) arguments. To use the Google Cloud API,'
             ' provide (`vertexai`, `project` & `location`) arguments.'
         )
-      self._http_options['base_url'] = (
-          'https://generativelanguage.googleapis.com/'
-      )
-      self._http_options['api_version'] = 'v1beta'
+      self._http_options.base_url = 'https://generativelanguage.googleapis.com/'
+      self._http_options.api_version = 'v1beta'
     # Default options for both clients.
-    self._http_options['headers'] = {'Content-Type': 'application/json'}
+    self._http_options.headers = {'Content-Type': 'application/json'}
     if self.api_key:
-      self._http_options['headers']['x-goog-api-key'] = self.api_key
+      if self._http_options.headers is not None:
+        self._http_options.headers['x-goog-api-key'] = self.api_key
     # Update the http options with the user provided http options.
     if http_options:
       self._http_options = _patch_http_options(
           self._http_options, validated_http_options
       )
     else:
-      _append_library_version_headers(self._http_options['headers'])
+      if self._http_options.headers is not None:
+        _append_library_version_headers(self._http_options.headers)
     # Initialize the httpx client.
     self._httpx_client = SyncHttpxClient()
     self._async_httpx_client = AsyncHttpxClient()
 
   def _websocket_base_url(self):
-    url_parts = urlparse(self._http_options['base_url'])
+    url_parts = urlparse(self._http_options.base_url)
     return url_parts._replace(scheme='wss').geturl()
 
   def _access_token(self) -> str:
@@ -420,9 +424,7 @@ class BaseApiClient:
         self.project = project
 
     if self._credentials:
-      if (
-          self._credentials.expired or not self._credentials.token
-      ):
+      if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
         _refresh_auth(self._credentials)
       if not self._credentials.token:
@@ -446,9 +448,7 @@ class BaseApiClient:
             self.project = project
 
     if self._credentials:
-      if (
-          self._credentials.expired or not self._credentials.token
-      ):
+      if self._credentials.expired or not self._credentials.token:
         # Only refresh when it needs to. Default expiration is 3600 seconds.
         async with self._auth_lock:
           if self._credentials.expired or not self._credentials.token:
@@ -477,11 +477,12 @@ class BaseApiClient:
     if http_options:
       if isinstance(http_options, HttpOptions):
         patched_http_options = _patch_http_options(
-            self._http_options, http_options.model_dump()
+            self._http_options,
+            http_options,
         )
       else:
         patched_http_options = _patch_http_options(
-            self._http_options, http_options
+            self._http_options, HttpOptions.model_validate(http_options)
         )
     else:
       patched_http_options = self._http_options
@@ -500,13 +501,27 @@ class BaseApiClient:
         and not self.api_key
     ):
       path = f'projects/{self.project}/locations/{self.location}/' + path
+
+    if patched_http_options.api_version is None:
+      versioned_path = f'/{path}'
+    else:
+      versioned_path = f'{patched_http_options.api_version}/{path}'
+
+    if (
+        patched_http_options.base_url is None
+        or not patched_http_options.base_url
+    ):
+      raise ValueError('Base URL must be set.')
+    else:
+      base_url = patched_http_options.base_url
+
     url = _join_url_path(
-        patched_http_options.get('base_url', ''),
-        patched_http_options.get('api_version', '') + '/' + path,
+        base_url,
+        versioned_path,
     )
 
-    timeout_in_seconds: Optional[Union[float, int]] = patched_http_options.get(
-        'timeout', None
+    timeout_in_seconds: Optional[Union[float, int]] = (
+        patched_http_options.timeout
     )
     if timeout_in_seconds:
       # HttpOptions.timeout is in milliseconds. But httpx.Client.request()
@@ -515,10 +530,12 @@ class BaseApiClient:
     else:
       timeout_in_seconds = None
 
+    if patched_http_options.headers is None:
+      raise ValueError('Request headers must be set.')
     return HttpRequest(
         method=http_method,
         url=url,
-        headers=patched_http_options['headers'],
+        headers=patched_http_options.headers,
         data=request_dict,
         timeout=timeout_in_seconds,
     )
@@ -530,9 +547,7 @@ class BaseApiClient:
   ) -> HttpResponse:
     data: Optional[Union[str, bytes]] = None
     if self.vertexai and not self.api_key:
-      http_request.headers['Authorization'] = (
-          f'Bearer {self._access_token()}'
-      )
+      http_request.headers['Authorization'] = f'Bearer {self._access_token()}'
       if self._credentials and self._credentials.quota_project_id:
         http_request.headers['x-goog-user-project'] = (
             self._credentials.quota_project_id
@@ -603,7 +618,7 @@ class BaseApiClient:
           httpx_request,
           stream=stream,
       )
-      errors.APIError.raise_for_response(response)
+      await errors.APIError.raise_for_async_response(response)
       return HttpResponse(
           response.headers, response if stream else [response.text]
       )
@@ -615,16 +630,16 @@ class BaseApiClient:
           content=data,
           timeout=http_request.timeout,
       )
-      errors.APIError.raise_for_response(response)
+      await errors.APIError.raise_for_async_response(response)
       return HttpResponse(
           response.headers, response if stream else [response.text]
       )
 
-  def get_read_only_http_options(self) -> HttpOptionsDict:
-    copied = HttpOptionsDict()
+  def get_read_only_http_options(self) -> dict[str, Any]:
     if isinstance(self._http_options, BaseModel):
-      self._http_options = self._http_options.model_dump()
-    copied.update(self._http_options)
+      copied = self._http_options.model_dump()
+    else:
+      copied = self._http_options
     return copied
 
   def request(
@@ -650,7 +665,7 @@ class BaseApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: Optional[HttpOptionsDict] = None,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -682,7 +697,7 @@ class BaseApiClient:
       http_method: str,
       path: str,
       request_dict: dict[str, object],
-      http_options: Optional[HttpOptionsDict] = None,
+      http_options: Optional[HttpOptionsOrDict] = None,
   ):
     http_request = self._build_request(
         http_method, path, request_dict, http_options
@@ -698,7 +713,7 @@ class BaseApiClient:
 
   def upload_file(
       self, file_path: Union[str, io.IOBase], upload_url: str, upload_size: int
-  ) -> dict[str, str]:
+  ) -> HttpResponse:
     """Transfers a file to the given URL.
 
     Args:
@@ -710,7 +725,7 @@ class BaseApiClient:
         match the size requested in the resumable upload request.
 
     returns:
-          The response json object from the finalize request.
+          The HttpResponse object from the finalize request.
     """
     if isinstance(file_path, io.IOBase):
       return self._upload_fd(file_path, upload_url, upload_size)
@@ -720,7 +735,7 @@ class BaseApiClient:
 
   def _upload_fd(
       self, file: io.IOBase, upload_url: str, upload_size: int
-  ) -> dict[str, str]:
+  ) -> HttpResponse:
     """Transfers a file to the given URL.
 
     Args:
@@ -730,7 +745,7 @@ class BaseApiClient:
         match the size requested in the resumable upload request.
 
     returns:
-          The response json object from the finalize request.
+          The HttpResponse object from the finalize request.
     """
     offset = 0
     # Upload the file in chunks
@@ -758,7 +773,7 @@ class BaseApiClient:
         break  # upload is complete or it has been interrupted.
       if upload_size <= offset:  # Status is not finalized.
         raise ValueError(
-            'All content has been uploaded, but the upload status is not'
+            f'All content has been uploaded, but the upload status is not'
             f' finalized.'
         )
 
@@ -766,7 +781,7 @@ class BaseApiClient:
       raise ValueError(
           'Failed to upload file: Upload status is not finalized.'
       )
-    return response.json()
+    return HttpResponse(response.headers, response_stream=[response.text])
 
   def download_file(self, path: str, http_options):
     """Downloads the file data.
@@ -807,7 +822,7 @@ class BaseApiClient:
       file_path: Union[str, io.IOBase],
       upload_url: str,
       upload_size: int,
-  ) -> dict[str, str]:
+  ) -> HttpResponse:
     """Transfers a file asynchronously to the given URL.
 
     Args:
@@ -818,7 +833,7 @@ class BaseApiClient:
         match the size requested in the resumable upload request.
 
     returns:
-          The response json object from the finalize request.
+          The HttpResponse object from the finalize request.
     """
     if isinstance(file_path, io.IOBase):
       return await self._async_upload_fd(file_path, upload_url, upload_size)
@@ -833,7 +848,7 @@ class BaseApiClient:
       file: Union[io.IOBase, anyio.AsyncFile],
       upload_url: str,
       upload_size: int,
-  ) -> dict[str, str]:
+  ) -> HttpResponse:
     """Transfers a file asynchronously to the given URL.
 
     Args:
@@ -843,7 +858,7 @@ class BaseApiClient:
         match the size requested in the resumable upload request.
 
     returns:
-          The response json object from the finalize request.
+          The HttpResponse object from the finalized request.
     """
     offset = 0
     # Upload the file in chunks
@@ -882,7 +897,7 @@ class BaseApiClient:
       raise ValueError(
           'Failed to upload file: Upload status is not finalized.'
       )
-    return response.json()
+    return HttpResponse(response.headers, response_stream=[response.text])
 
   async def async_download_file(self, path: str, http_options):
     """Downloads the file data.
@@ -912,7 +927,7 @@ class BaseApiClient:
         content=data,
         timeout=http_request.timeout,
     )
-    errors.APIError.raise_for_response(response)
+    await errors.APIError.raise_for_async_response(response)
 
     return HttpResponse(
         response.headers, byte_stream=[response.read()]

{google_genai-1.7.0 → google_genai-1.9.0}/google/genai/_replay_api_client.py

@@ -119,7 +119,8 @@ def _redact_request_body(body: dict[str, object]):
 def redact_http_request(http_request: HttpRequest):
   http_request.headers = _redact_request_headers(http_request.headers)
   http_request.url = _redact_request_url(http_request.url)
-  _redact_request_body(http_request.data)
+  if not isinstance(http_request.data, bytes):
+    _redact_request_body(http_request.data)
 
 
 def _current_file_path_and_line():
@@ -321,6 +322,8 @@ class ReplayApiClient(BaseApiClient):
       raise ValueError(
           'Unsupported http_response type: ' + str(type(http_response))
       )
+    if self.replay_session is None:
+      raise ValueError('No replay session found.')
     self.replay_session.interactions.append(
         ReplayInteraction(request=request, response=response)
     )
@@ -342,7 +345,8 @@ class ReplayApiClient(BaseApiClient):
     request_data_copy = copy.deepcopy(http_request.data)
     # Both the request and recorded request must be redacted before comparing
     # so that the comparison is fair.
-    _redact_request_body(request_data_copy)
+    if not isinstance(request_data_copy, bytes):
+      _redact_request_body(request_data_copy)
 
     actual_request_body = [request_data_copy]
     expected_request_body = interaction.request.body_segments
@@ -352,9 +356,11 @@ class ReplayApiClient(BaseApiClient):
         f'Expected: {expected_request_body}'
     )
 
-  def _build_response_from_replay(self, http_request: HttpRequest):
+  def _build_response_from_replay(self, http_request: HttpRequest) -> HttpResponse:
     redact_http_request(http_request)
 
+    if self.replay_session is None:
+      raise ValueError('No replay session found.')
     interaction = self.replay_session.interactions[self._replay_index]
     # Replay is on the right side of the assert so the diff makes more sense.
     self._match_request(http_request, interaction)
@@ -373,6 +379,8 @@ class ReplayApiClient(BaseApiClient):
   def _verify_response(self, response_model: BaseModel):
     if self._mode == 'api':
       return
+    if not self.replay_session:
+      raise ValueError('No replay session found.')
     # replay_index is advanced in _build_response_from_replay, so we need to -1.
     interaction = self.replay_session.interactions[self._replay_index - 1]
     if self._should_update_replay():
@@ -453,7 +461,7 @@ class ReplayApiClient(BaseApiClient):
     else:
       return self._build_response_from_replay(http_request)
 
-  def upload_file(self, file_path: Union[str, io.IOBase], upload_url: str, upload_size: int):
+  def upload_file(self, file_path: Union[str, io.IOBase], upload_url: str, upload_size: int) -> HttpResponse:
     if isinstance(file_path, io.IOBase):
       offset = file_path.tell()
       content = file_path.read()
@@ -474,21 +482,21 @@ class ReplayApiClient(BaseApiClient):
         result = super().upload_file(file_path, upload_url, upload_size)
       except HTTPError as e:
         result = HttpResponse(
-            e.response.headers, [json.dumps({'reason': e.response.reason})]
+            dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
         )
         result.status_code = e.response.status_code
         raise e
-      self._record_interaction(request, HttpResponse({}, [json.dumps(result)]))
+      self._record_interaction(request, result)
       return result
     else:
-      return self._build_response_from_replay(request).json
+      return self._build_response_from_replay(request)
 
   async def async_upload_file(
       self,
       file_path: Union[str, io.IOBase],
       upload_url: str,
       upload_size: int,
-  ) -> str:
+  ) -> HttpResponse:
     if isinstance(file_path, io.IOBase):
       offset = file_path.tell()
       content = file_path.read()
@@ -504,21 +512,21 @@ class ReplayApiClient(BaseApiClient):
           method='POST', url='', data={'file_path': file_path}, headers={}
       )
     if self._should_call_api():
-      result: Union[str, HttpResponse]
+      result: HttpResponse
       try:
         result = await super().async_upload_file(
             file_path, upload_url, upload_size
         )
       except HTTPError as e:
         result = HttpResponse(
-            e.response.headers, [json.dumps({'reason': e.response.reason})]
+            dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
         )
         result.status_code = e.response.status_code
         raise e
-      self._record_interaction(request, HttpResponse({}, [json.dumps(result)]))
+      self._record_interaction(request, result)
       return result
     else:
-      return self._build_response_from_replay(request).json
+      return self._build_response_from_replay(request)
 
   def download_file(self, path: str, http_options: HttpOptions):
     self._initialize_replay_session_if_not_loaded()
@@ -530,7 +538,7 @@ class ReplayApiClient(BaseApiClient):
         result = super().download_file(path, http_options)
       except HTTPError as e:
         result = HttpResponse(
-            e.response.headers, [json.dumps({'reason': e.response.reason})]
+            dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
         )
         result.status_code = e.response.status_code
         raise e
@@ -549,7 +557,7 @@ class ReplayApiClient(BaseApiClient):
         result = await super().async_download_file(path, http_options)
       except HTTPError as e:
         result = HttpResponse(
-            e.response.headers, [json.dumps({'reason': e.response.reason})]
+            dict(e.response.headers), [json.dumps({'reason': e.response.reason})]
         )
         result.status_code = e.response.status_code
         raise e