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

google/genai/tests/afc/test_invoke_function_from_dict_args.py

@@ -0,0 +1,241 @@
+# 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.
+#
+
+
+"""Test invoke_function_from_dict_args."""
+
+from typing import Union
+import pydantic
+import pytest
+import sys
+from ... import errors
+from ..._extra_utils import invoke_function_from_dict_args
+
+
+def test_builtin_primitive_types():
+  def func_under_test(x: int, y: float, z: str, w: bool):
+    return {
+        'x': x + 1,
+        'y': y + 1.0,
+        'z': z + '1.0',
+        'w': not w,
+    }
+
+  original_args = {
+      'x': 1,
+      'y': 1.0,
+      'z': '1.0',
+      'w': True,
+  }
+  expected_response = {
+      'x': 2,
+      'y': 2.0,
+      'z': '1.01.0',
+      'w': False,
+  }
+
+  actual_response = invoke_function_from_dict_args(
+      original_args, func_under_test
+  )
+
+  assert actual_response == expected_response
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 10),
+    reason='| is only supported in Python 3.9 and above.',
+)
+def test_builtin_compound_types():
+  def func_under_test(x: list[int], y: dict[str, float]):
+    return {
+        'new_x': x + [3],
+        'new_y': y | {'key3': 3.0},
+    }
+
+  original_args = {
+      'x': [1, 2],
+      'y': {'key1': 1.0, 'key2': 2.0},
+  }
+  expected_response = {
+      'new_x': [1, 2, 3],
+      'new_y': {'key1': 1.0, 'key2': 2.0, 'key3': 3.0},
+  }
+
+  actual_response = invoke_function_from_dict_args(
+      original_args, func_under_test
+  )
+
+  assert actual_response == expected_response
+
+
+def test_nested_pydantic_model():
+  class SimpleModel(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  class ComplexModel(pydantic.BaseModel):
+    key1_complex: SimpleModel
+    key2_complex: list[SimpleModel]
+    key3_complex: dict[str, SimpleModel]
+
+  def func_under_test(x: ComplexModel):
+    y = x.model_copy()
+    y.key1_complex.key1_simple += 1
+    y.key1_complex.key2_simple += 1.0
+    for simple_model in y.key2_complex:
+      simple_model.key1_simple += 1
+      simple_model.key2_simple += 1.0
+    for simple_model in y.key3_complex.values():
+      simple_model.key1_simple += 1
+      simple_model.key2_simple += 1.0
+    return y
+
+  original_args = {
+      'x': {
+          'key1_complex': {'key1_simple': 1, 'key2_simple': 1.0},
+          'key2_complex': [
+              {'key1_simple': 2, 'key2_simple': 2.0},
+              {'key1_simple': 3, 'key2_simple': 3.0},
+          ],
+          'key3_complex': {
+              'key1_simple': {'key1_simple': 4, 'key2_simple': 4.0},
+              'key2_simple': {'key1_simple': 5, 'key2_simple': 5.0},
+          },
+      }
+  }
+  expected_response = {
+      'key1_complex': {'key1_simple': 2, 'key2_simple': 2.0},
+      'key2_complex': [
+          {'key1_simple': 3, 'key2_simple': 3.0},
+          {'key1_simple': 4, 'key2_simple': 4.0},
+      ],
+      'key3_complex': {
+          'key1_simple': {'key1_simple': 5, 'key2_simple': 5.0},
+          'key2_simple': {'key1_simple': 6, 'key2_simple': 6.0},
+      },
+  }
+
+  actual_response = invoke_function_from_dict_args(
+      original_args, func_under_test
+  )
+
+  assert isinstance(actual_response, ComplexModel)
+  assert isinstance(actual_response.key1_complex, SimpleModel)
+  assert isinstance(actual_response.key2_complex[0], SimpleModel)
+  assert isinstance(actual_response.key2_complex[1], SimpleModel)
+  assert isinstance(actual_response.key3_complex['key1_simple'], SimpleModel)
+  assert isinstance(actual_response.key3_complex['key2_simple'], SimpleModel)
+  assert actual_response.model_dump() == expected_response
+
+
+def test_pydantic_model_in_list_union_type():
+  class SimpleModel(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def func_under_test(x: list[Union[int, SimpleModel]]):
+    result = []
+    for item in x:
+      if isinstance(item, int):
+        result.append(item + 1)
+      elif isinstance(item, SimpleModel):
+        result.append(item.model_copy())
+        result[-1].key1_simple += 1
+        result[-1].key2_simple += 1.0
+      else:
+        raise ValueError('Unsupported type: %s' % type(item))
+    return result
+
+  expected_response = [2, {'key1_simple': 2, 'key2_simple': 2.0}]
+  original_args = {'x': [1, {'key1_simple': 1, 'key2_simple': 1.0}]}
+  actual_response = invoke_function_from_dict_args(
+      original_args, func_under_test
+  )
+  assert isinstance(actual_response, list)
+  assert len(actual_response) == 2
+  assert isinstance(actual_response[0], int)
+  assert isinstance(actual_response[1], SimpleModel)
+  assert actual_response[0] == expected_response[0]
+  assert actual_response[1].model_dump() == expected_response[1]
+
+
+def test_unknown_pydantic_model_argument():
+  class SimpleModel(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def func_under_test(x: SimpleModel):
+    return x.model_copy()
+
+  original_args = {'x': {'key3_simple': 1, 'key2_simple': 1.0}}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args(original_args, func_under_test)
+
+
+def test_unknown_pydantic_model_argument_with_union_type():
+  class SimpleModel1(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  class SimpleModel2(pydantic.BaseModel):
+    key3_simple: str
+    key4_simple: float
+
+  def func_under_test(x: Union[SimpleModel1, SimpleModel2]):
+    return x.model_copy()
+
+  original_args = {'x': {'key5_simple': 1, 'key4_simple': 1.0}}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args(original_args, func_under_test)
+
+
+def test_unknown_pydantic_model_argument_with_union_type_and_builtin_type():
+  class SimpleModel1(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def func_under_test(x: Union[SimpleModel1, int]):
+    return x.model_copy()
+
+  original_args = {'x': {'key5_simple': 1, 'key4_simple': 1.0}}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args(original_args, func_under_test)
+
+
+def test_incompatible_value_and_annotation():
+  def func_under_test(x: int):
+    return x + 1
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args({'x': {'k': 'v'}}, func_under_test)
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args({'x': 'a'}, func_under_test)
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args({'x': []}, func_under_test)
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args({'x': 1.0}, func_under_test)
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    invoke_function_from_dict_args({'x': {}}, func_under_test)
+
+
+def test_function_invocation_error():
+  def func_under_test(x: int):
+    return x / 0
+
+  with pytest.raises(errors.FunctionInvocationError):
+    invoke_function_from_dict_args({'x': 1}, func_under_test)

google/genai/tests/afc/test_raise_error_for_afc_incompatible_config.py

@@ -0,0 +1,159 @@
+# 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 raise_error_for_afc_incompatible_config."""
+
+import pytest
+from ... import types
+from ..._extra_utils import raise_error_for_afc_incompatible_config
+
+
+def test_config_is_none():
+  assert raise_error_for_afc_incompatible_config(None) is None
+
+
+def test_tool_config_config_unset():
+  assert (
+      raise_error_for_afc_incompatible_config(types.GenerateContentConfig(
+          automatic_function_calling=types.AutomaticFunctionCallingConfig(
+              disable=False,
+              maximum_remote_calls=1,
+          ),
+      ))
+      is None
+  )
+
+
+def test_function_calling_config_unset():
+  assert (
+      raise_error_for_afc_incompatible_config(types.GenerateContentConfig(
+          automatic_function_calling=types.AutomaticFunctionCallingConfig(
+              disable=False,
+              maximum_remote_calls=1,
+          ),
+          tool_config=types.ToolConfig(),
+      ))
+      is None
+  )
+
+
+
+def test_compatible_config_afc_disabled():
+  assert (
+      raise_error_for_afc_incompatible_config(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+              ),
+              tool_config=types.ToolConfig(
+                  function_calling_config=types.FunctionCallingConfig(
+                      stream_function_call_arguments=False,
+                  ),
+              ),
+          )
+      )
+      is None
+  )
+
+
+def test_compatible_config_stream_function_call_arguments_unset_afc_unset():
+  assert (
+      raise_error_for_afc_incompatible_config(
+          types.GenerateContentConfig(
+              tool_config=types.ToolConfig(
+                  function_calling_config=types.FunctionCallingConfig(
+                  ),
+              ),
+          )
+      )
+      is None
+  )
+
+
+def test_compatible_config_stream_function_call_arguments_unset_no_disable_afc():
+  assert (
+      raise_error_for_afc_incompatible_config(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+              ),
+              tool_config=types.ToolConfig(
+                  function_calling_config=types.FunctionCallingConfig(
+                  ),
+              ),
+          )
+      )
+      is None
+  )
+
+
+def test_compatible_config_stream_function_call_arguments_unset_disable_afc_true():
+  assert (
+      raise_error_for_afc_incompatible_config(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+              ),
+              tool_config=types.ToolConfig(
+                  function_calling_config=types.FunctionCallingConfig(
+                  ),
+              ),
+          )
+      )
+      is None
+  )
+
+
+def test_incompatible_config_stream_function_call_arguments_set_enable_afc():
+  with pytest.raises(ValueError):
+    raise_error_for_afc_incompatible_config(
+        types.GenerateContentConfig(
+            automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                disable=False,
+            ),
+            tool_config=types.ToolConfig(
+                function_calling_config=types.FunctionCallingConfig(
+                    stream_function_call_arguments=True,
+                ),
+            ),
+        )
+    )
+
+
+def test_incompatible_config_stream_function_call_arguments_set_no_afc_config():
+  with pytest.raises(ValueError):
+    raise_error_for_afc_incompatible_config(
+        types.GenerateContentConfig(
+            tool_config=types.ToolConfig(
+                function_calling_config=types.FunctionCallingConfig(
+                    stream_function_call_arguments=True,
+                ),
+            ),
+        )
+    )
+
+
+def test_incompatible_config_stream_function_call_arguments_set_no_disable_afc():
+  with pytest.raises(ValueError):
+    raise_error_for_afc_incompatible_config(
+        types.GenerateContentConfig(
+            automatic_function_calling=types.AutomaticFunctionCallingConfig(),
+            tool_config=types.ToolConfig(
+                function_calling_config=types.FunctionCallingConfig(
+                    stream_function_call_arguments=True,
+                ),
+            ),
+        )
+    )

google/genai/tests/afc/test_should_append_afc_history.py

@@ -0,0 +1,53 @@
+# 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 _extra_utils.should_append_afc_history."""
+
+from ... import types
+from ..._extra_utils import should_append_afc_history
+
+
+def test_should_append_afc_history_with_default_config():
+  config = types.GenerateContentConfig()
+
+  assert should_append_afc_history(config) == True
+
+
+def test_should_append_afc_history_with_empty_afc_config():
+  config = types.GenerateContentConfig(
+      automatic_function_calling=types.AutomaticFunctionCallingConfig()
+  )
+
+  assert should_append_afc_history(config) == True
+
+
+def test_should_append_afc_history_with_ignore_call_history_true():
+  config = types.GenerateContentConfig(
+      automatic_function_calling=types.AutomaticFunctionCallingConfig(
+          ignore_call_history=True
+      )
+  )
+
+  assert should_append_afc_history(config) == False
+
+
+def test_should_append_afc_history_with_ignore_call_history_false():
+  config = types.GenerateContentConfig(
+      automatic_function_calling=types.AutomaticFunctionCallingConfig(
+          ignore_call_history=False
+      )
+  )
+
+  assert should_append_afc_history(config) == True

google/genai/tests/afc/test_should_disable_afc.py

@@ -0,0 +1,214 @@
+# 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 should_disable_afc."""
+
+import pytest
+from ... import types
+from ..._extra_utils import should_disable_afc
+
+
+def test_config_is_none():
+  assert should_disable_afc(None) is False
+
+
+def test_afc_config_unset():
+  assert should_disable_afc(types.GenerateContentConfig()) is False
+
+
+def test_afc_enable_unset_max_0():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  maximum_remote_calls=0,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_unset_max_negative():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  maximum_remote_calls=-1,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_unset_max_0_0():
+  assert (
+      should_disable_afc(
+          {'automatic_function_calling': {'maximum_remote_calls': 0.0}}
+      )
+      is True
+  )
+
+
+def test_afc_enable_unset_max_1():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  maximum_remote_calls=1,
+              ),
+          )
+      )
+      is False
+  )
+
+
+def test_afc_enable_unset_max_1_0():
+  assert (
+      should_disable_afc(
+          {'automatic_function_calling': {'maximum_remote_calls': 1.0}}
+      )
+      is False
+  )
+
+
+def test_afc_enable_false_max_unset():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_false_max_0():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+                  maximum_remote_calls=0,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_false_max_negative():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+                  maximum_remote_calls=-1,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_false_max_0_0():
+  assert (
+      should_disable_afc(
+          {'automatic_function_calling': {'maximum_remote_calls': 0.0}}
+      )
+      is True
+  )
+
+
+def test_afc_enable_false_max_1():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=True,
+                  maximum_remote_calls=1,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_true_max_unset():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+              ),
+          )
+      )
+      is False
+  )
+
+
+def test_afc_enable_true_max_0():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+                  maximum_remote_calls=0,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_true_max_negative():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+                  maximum_remote_calls=-1,
+              ),
+          )
+      )
+      is True
+  )
+
+
+def test_afc_enable_true_max_0_0():
+  assert (
+      should_disable_afc(
+          {'automatic_function_calling': {'maximum_remote_calls': 0.0}}
+      )
+      is True
+  )
+
+
+def test_afc_enable_true_max_1():
+  assert (
+      should_disable_afc(
+          types.GenerateContentConfig(
+              automatic_function_calling=types.AutomaticFunctionCallingConfig(
+                  disable=False,
+                  maximum_remote_calls=1,
+              ),
+          )
+      )
+      is False
+  )

google/genai/tests/batches/__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 batches module."""