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

google/genai/tests/errors/test_api_error.py

@@ -0,0 +1,417 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+"""Unit Tests for the APIError class.
+
+End to end tests should be in models/test_generate_content.py.
+"""
+
+import pickle
+
+import httpx
+import pytest
+
+from ... import errors
+
+
+def test_constructor_code_none_error_in_json_code_in_error():
+
+  actual_error = errors.APIError(
+      None,
+      {
+          'error': {
+              'code': 400,
+              'message': 'error message',
+              'status': 'INVALID_ARGUMENT',
+          }
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'error': {
+          'code': 400,
+          'message': 'error message',
+          'status': 'INVALID_ARGUMENT',
+      }
+  }
+
+
+def test_constructor_code_none_error_in_json_code_outside_error():
+
+  actual_error = errors.APIError(
+      None,
+      {
+          'code': 400,
+          'error': {
+              'code': 500,
+              'message': 'error message',
+              'status': 'INVALID_ARGUMENT',
+          },
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'code': 400,
+      'error': {
+          'code': 500,
+          'message': 'error message',
+          'status': 'INVALID_ARGUMENT',
+      },
+  }
+
+
+def test_constructor_code_not_present():
+
+  actual_error = errors.APIError(
+      None,
+      {
+          'error': {
+              'message': 'error message',
+              'status': 'INVALID_ARGUMENT',
+          }
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code is None
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'error': {
+          'message': 'error message',
+          'status': 'INVALID_ARGUMENT',
+      }
+  }
+
+
+def test_constructor_code_exist_error_in_json():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'error': {
+              'code': 400,
+              'message': 'error message',
+              'status': 'INVALID_ARGUMENT',
+          }
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'error': {
+          'code': 400,
+          'message': 'error message',
+          'status': 'INVALID_ARGUMENT',
+      }
+  }
+
+
+def test_constructor_error_not_in_json():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'message': 'error message',
+          'status': 'INVALID_ARGUMENT',
+          'code': 400,
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'message': 'error message',
+      'status': 'INVALID_ARGUMENT',
+      'code': 400,
+  }
+
+
+def test_constructor_error_in_json_status_outside_error():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'status': 'OUTER_INVALID_ARGUMENT_STATUS',
+          'error': {
+              'code': 400,
+              'message': 'error message',
+              'status': 'INNER_INVALID_ARGUMENT_STATUS',
+          },
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == 'OUTER_INVALID_ARGUMENT_STATUS'
+  assert actual_error.details == {
+      'status': 'OUTER_INVALID_ARGUMENT_STATUS',
+      'error': {
+          'code': 400,
+          'message': 'error message',
+          'status': 'INNER_INVALID_ARGUMENT_STATUS',
+      },
+  }
+
+
+def test_constructor_status_not_present():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'error': {
+              'code': 400,
+              'message': 'error message',
+          }
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'error message'
+  assert actual_error.status == None
+  assert actual_error.details == {
+      'error': {
+          'code': 400,
+          'message': 'error message',
+      }
+  }
+
+
+def test_constructor_error_in_json_message_outside_error():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'message': 'OUTER_ERROR_MESSAGE',
+          'error': {
+              'code': 400,
+              'message': 'INNER_ERROR_MESSAGE',
+              'status': 'INVALID_ARGUMENT',
+          },
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message == 'OUTER_ERROR_MESSAGE'
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'message': 'OUTER_ERROR_MESSAGE',
+      'error': {
+          'code': 400,
+          'message': 'INNER_ERROR_MESSAGE',
+          'status': 'INVALID_ARGUMENT',
+      },
+  }
+
+
+def test_constructor_message_not_present():
+
+  actual_error = errors.APIError(
+      400,
+      {
+          'error': {
+              'code': 400,
+              'status': 'INVALID_ARGUMENT',
+          }
+      },
+      httpx.Response(status_code=400),
+  )
+
+  assert actual_error.code == 400
+  assert actual_error.message is None
+  assert actual_error.status == 'INVALID_ARGUMENT'
+  assert actual_error.details == {
+      'error': {
+          'code': 400,
+          'status': 'INVALID_ARGUMENT',
+      }
+  }
+
+
+def test_raise_for_response_code_exist_json_decoder_error():
+  class FakeResponse(httpx.Response):
+
+    def read(self) -> bytes:
+      self._content = b'{"data": {"key1": "value1", "key2"}'
+      return self._content
+
+  try:
+    errors.APIError.raise_for_response(
+        FakeResponse(
+            status_code=503,
+            extensions={'reason_phrase': b'Service Unavailable'},
+        )
+    )
+  except errors.ServerError as actual_error:
+    assert actual_error.code == 503
+    assert actual_error.message == '{"data": {"key1": "value1", "key2"}'
+    assert actual_error.status == 'Service Unavailable'
+    assert actual_error.details == {
+        'message': '{"data": {"key1": "value1", "key2"}',
+        'status': 'Service Unavailable',
+    }
+
+
+def test_raise_for_response_client_error():
+  class FakeResponse(httpx.Response):
+
+    def read(self) -> bytes:
+      self._content = (
+          b'{"error": {"code": 400, "message": "error message", "status":'
+          b' "INVALID_ARGUMENT"}}'
+      )
+      return self._content
+
+  try:
+    errors.APIError.raise_for_response(FakeResponse(status_code=400))
+  except errors.ClientError as actual_error:
+    assert actual_error.code == 400
+    assert actual_error.message == 'error message'
+    assert actual_error.status == 'INVALID_ARGUMENT'
+    assert actual_error.details == {
+        'error': {
+            'code': 400,
+            'message': 'error message',
+            'status': 'INVALID_ARGUMENT',
+        }
+    }
+
+
+def test_raise_for_response_server_error():
+  class FakeResponse(httpx.Response):
+
+    def read(self) -> bytes:
+      self._content = (
+          b'{"error": {"code": 500, "message": "error message", "status":'
+          b' "SERVER_INTERNAL ERROR"}}'
+      )
+      return self._content
+
+  try:
+    errors.APIError.raise_for_response(FakeResponse(status_code=500))
+  except errors.ServerError as actual_error:
+    assert actual_error.code == 500
+    assert actual_error.message == 'error message'
+    assert actual_error.status == 'SERVER_INTERNAL ERROR'
+    assert actual_error.details == {
+        'error': {
+            'code': 500,
+            'message': 'error message',
+            'status': 'SERVER_INTERNAL ERROR',
+        }
+    }
+
+
+def test_api_error_is_picklable():
+  pickled_error = pickle.loads(pickle.dumps(errors.APIError(1, {})))
+  assert isinstance(pickled_error, errors.APIError)
+
+
+@pytest.mark.asyncio
+async def test_raise_for_async_response_client_error():
+  class FakeResponse(httpx.Response):
+
+    async def aread(self) -> bytes:
+      self._content = (
+          b'{"error": {"code": 400, "message": "error message", "status":'
+          b' "INVALID_ARGUMENT"}}'
+      )
+      return self._content
+
+  try:
+    await errors.APIError.raise_for_async_response(
+        FakeResponse(status_code=400)
+    )
+  except errors.ClientError as actual_error:
+    assert actual_error.code == 400
+    assert actual_error.message == 'error message'
+    assert actual_error.status == 'INVALID_ARGUMENT'
+    assert actual_error.details == {
+        'error': {
+            'code': 400,
+            'message': 'error message',
+            'status': 'INVALID_ARGUMENT',
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_raise_for_async_response_server_error():
+  class FakeResponse(httpx.Response):
+
+    async def aread(self) -> bytes:
+      self._content = (
+          b'{"error": {"code": 500, "message": "error message", "status":'
+          b' "SERVER_INTERNAL ERROR"}}'
+      )
+      return self._content
+
+  try:
+    await errors.APIError.raise_for_async_response(
+        FakeResponse(status_code=500)
+    )
+  except errors.ServerError as actual_error:
+    assert actual_error.code == 500
+    assert actual_error.message == 'error message'
+    assert actual_error.status == 'SERVER_INTERNAL ERROR'
+    assert actual_error.details == {
+        'error': {
+            'code': 500,
+            'message': 'error message',
+            'status': 'SERVER_INTERNAL ERROR',
+        }
+    }
+
+
+@pytest.mark.asyncio
+async def test_raise_for_async_response_code_exist_json_decoder_error():
+  class FakeResponse(httpx.Response):
+
+    async def aread(self) -> bytes:
+      self._content = b'{"data": {"key1": "value1", "key2"}'
+      return self._content
+
+  try:
+    await errors.APIError.raise_for_async_response(
+        FakeResponse(
+            status_code=503,
+            extensions={'reason_phrase': b'Service Unavailable'},
+        )
+    )
+  except errors.ServerError as actual_error:
+    assert actual_error.code == 503
+    assert actual_error.message == '{"data": {"key1": "value1", "key2"}'
+    assert actual_error.status == 'Service Unavailable'
+    assert actual_error.details == {
+        'message': '{"data": {"key1": "value1", "key2"}',
+        'status': 'Service Unavailable',
+    }

google/genai/tests/file_search_stores/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+"""Tests for the Google GenAI SDK's file search stores module."""

google/genai/tests/file_search_stores/test_create.py

@@ -0,0 +1,66 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+"""Tests for file_search_stores.create()."""
+
+import pytest
+
+from ... import types
+from .. import pytest_helper
+
+# All tests will be run for both Vertex and MLDev.
+test_table: list[pytest_helper.TestTableItem] = [
+    pytest_helper.TestTableItem(
+        name="test_display_name",
+        parameters=types._CreateFileSearchStoreParameters(
+            config=types.CreateFileSearchStoreConfig(
+                display_name="My File Search Store"
+            )
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+    ),
+    pytest_helper.TestTableItem(
+        name="test_basic",
+        parameters=types._CreateFileSearchStoreParameters(),
+        exception_if_vertex="only supported in the Gemini Developer client",
+    ),
+]
+
+pytestmark = [
+    pytest.mark.usefixtures("mock_timestamped_unique_name"),
+    pytest_helper.setup(
+        file=__file__,
+        globals_for_file=globals(),
+        test_method="file_search_stores.create",
+        test_table=test_table,
+    ),
+]
+
+
+@pytest.mark.asyncio
+async def test_async_display_name(client):
+  with pytest_helper.exception_if_vertex(client, ValueError):
+    file_search_store = await client.aio.file_search_stores.create(
+        config=types.CreateFileSearchStoreConfig(
+            display_name="My File Search Store"
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_async_basic(client):
+  with pytest_helper.exception_if_vertex(client, ValueError):
+    file_search_store = await client.aio.file_search_stores.create()

google/genai/tests/file_search_stores/test_delete.py

@@ -0,0 +1,64 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Tests for file_search_stores.delete()."""
+
+import pytest
+
+from ... import types
+from .. import pytest_helper
+
+# All tests will be run for both Vertex and MLDev.
+test_table: list[pytest_helper.TestTableItem] = [
+    pytest_helper.TestTableItem(
+        name="test_delete_with_name",
+        parameters=types._DeleteFileSearchStoreParameters(
+            name="fileSearchStores/acxjj7m366ln-aw6xyp94icll",
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+    ),
+    pytest_helper.TestTableItem(
+        name="test_delete_with_name_and_force",
+        parameters=types._DeleteFileSearchStoreParameters(
+            name="fileSearchStores/7igesc9r2zw9-0mpxpsqubv7s",
+            config=types.DeleteFileSearchStoreConfig(force=True),
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+    ),
+]
+
+pytestmark = pytest_helper.setup(
+    file=__file__,
+    globals_for_file=globals(),
+    test_method="file_search_stores.delete",
+    test_table=test_table,
+)
+
+
+@pytest.mark.asyncio
+async def test_async_delete(client):
+  with pytest_helper.exception_if_vertex(client, ValueError):
+    await client.aio.file_search_stores.delete(
+        name="fileSearchStores/my-file-search-store-l65kcyel9lkz"
+    )
+
+
+@pytest.mark.asyncio
+async def test_async_force_delete(client):
+  with pytest_helper.exception_if_vertex(client, ValueError):
+    await client.aio.file_search_stores.delete(
+        name="fileSearchStores/my-file-search-store-vjtrjw6re8oz",
+        config=types.DeleteFileSearchStoreConfig(force=True),
+    )

google/genai/tests/file_search_stores/test_get.py

@@ -0,0 +1,94 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+"""Tests for file_search_stores.get()."""
+
+import pytest
+
+from ... import types
+from .. import pytest_helper
+
+# A FileSearchStore name known to exist in the test environment.
+# Replace with a real one from your test setup.
+_EXISTING_FILE_SEARCH_STORE_NAME = "fileSearchStores/5en07ei3kojo-yo8sjqgvx2xf"
+_NON_EXISTENT_FILE_SEARCH_STORE_NAME = (
+    "fileSearchStores/non-existent-file-search-store"
+)
+_INVALID_FILE_SEARCH_STORE_NAME = (
+    "fileSearchStores/_invalid_file_search_store_name"
+)
+_NOT_A_FILE_SEARCH_STORE_NAME = "genai-test-file-search-store"
+
+# All tests will be run for both Vertex and MLDev.
+test_table: list[pytest_helper.TestTableItem] = [
+    pytest_helper.TestTableItem(
+        name="test_get_success",
+        parameters=types._GetFileSearchStoreParameters(
+            name=_EXISTING_FILE_SEARCH_STORE_NAME
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+    ),
+    pytest_helper.TestTableItem(
+        name="test_get_not_found",
+        parameters=types._GetFileSearchStoreParameters(
+            name=_NON_EXISTENT_FILE_SEARCH_STORE_NAME
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+        # Expect an exception to be raised by the mock
+        exception_if_mldev="PERMISSION_DENIED",
+    ),
+    pytest_helper.TestTableItem(
+        name="test_get_invalid_name",
+        parameters=types._GetFileSearchStoreParameters(
+            name=_INVALID_FILE_SEARCH_STORE_NAME
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+        # Validation should catch this before the API call
+        exception_if_mldev="INVALID_ARGUMENT",
+    ),
+    pytest_helper.TestTableItem(
+        name="test_get_not_a_file_search_store_name",
+        parameters=types._GetFileSearchStoreParameters(
+            name=_NOT_A_FILE_SEARCH_STORE_NAME
+        ),
+        exception_if_vertex="only supported in the Gemini Developer client",
+        exception_if_mldev="Not Found",
+    ),
+]
+
+pytestmark = pytest_helper.setup(
+    file=__file__,
+    globals_for_file=globals(),
+    test_method="file_search_stores.get",
+    test_table=test_table,
+)
+
+
+@pytest.mark.asyncio
+async def test_async_get(client):
+  with pytest_helper.exception_if_vertex(client, ValueError):
+    # This test relies on the mocking/replays set up by pytest_helper
+    # For a success case:
+    try:
+      file_search_store = await client.aio.file_search_stores.get(
+          name=_EXISTING_FILE_SEARCH_STORE_NAME
+      )
+      assert file_search_store is not None
+      assert file_search_store.name == _EXISTING_FILE_SEARCH_STORE_NAME
+    except Exception as e:
+      # Depending on the mock setup, errors might be raised directly
+      print(f"Async get failed: {e}")
+      raise