google-genai 1.56.0__py3-none-any.whl → 1.58.0__py3-none-any.whl

google/genai/tests/afc/test_convert_if_exist_pydantic_model.py

@@ -0,0 +1,309 @@
+# 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 convert_if_exist_pydantic_model."""
+
+import inspect
+from typing import Optional, Union
+import pydantic
+import pytest
+import sys
+from ... import errors
+from ..._extra_utils import convert_if_exist_pydantic_model
+
+
+def test_builtin_types():
+  assert convert_if_exist_pydantic_model(1, int, 'param_name', 'func_name') == 1
+  assert (
+      convert_if_exist_pydantic_model(1.0, float, 'param_name', 'func_name')
+      == 1.0
+  )
+  assert (
+      convert_if_exist_pydantic_model('1.0', str, 'param_name', 'func_name')
+      == '1.0'
+  )
+  assert (
+      convert_if_exist_pydantic_model(True, bool, 'param_name', 'func_name')
+      is True
+  )
+  assert convert_if_exist_pydantic_model(
+      [1], list, 'param_name', 'func_name'
+  ) == [1]
+  assert convert_if_exist_pydantic_model(
+      {'key1': 1}, dict, 'param_name', 'func_name'
+  ) == {'key1': 1}
+  assert convert_if_exist_pydantic_model(
+      {'key1': 1, 'key2': 2}, dict[str, int], 'param_name', 'func_name'
+  ) == {'key1': 1, 'key2': 2}
+
+
+def test_value_int_annotation_float():
+  assert (
+      convert_if_exist_pydantic_model(1, float, 'param_name', 'func_name')
+      == 1.0
+  )
+
+
+def test_union_types():
+  assert (
+      convert_if_exist_pydantic_model(
+          1, Union[int, float], 'param_name', 'func_name'
+      )
+      == 1
+  )
+  assert (
+      convert_if_exist_pydantic_model(
+          1.0, Union[int, float], 'param_name', 'func_name'
+      )
+      == 1.0
+  )
+  assert (
+      convert_if_exist_pydantic_model(
+          '1.0', Union[str, float], 'param_name', 'func_name'
+      )
+      == '1.0'
+  )
+  assert (
+      convert_if_exist_pydantic_model(
+          True, Union[bool, str], 'param_name', 'func_name'
+      )
+      is True
+  )
+
+  # | in 3.10+
+  if sys.version_info >= (3, 10):
+    assert (
+        convert_if_exist_pydantic_model(1, int | float, 'param_name', 'func_name')
+        == 1
+    )
+
+
+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 foo(_: ComplexModel):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = {
+      '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},
+      },
+  }
+
+  converted_args = convert_if_exist_pydantic_model(
+      original_args, annotation, 'param_name', 'func_name'
+  )
+  assert isinstance(converted_args, ComplexModel)
+  assert isinstance(converted_args.key1_complex, SimpleModel)
+  assert isinstance(converted_args.key2_complex[0], SimpleModel)
+  assert isinstance(converted_args.key2_complex[1], SimpleModel)
+  assert isinstance(converted_args.key3_complex['key1_simple'], SimpleModel)
+  assert isinstance(converted_args.key3_complex['key2_simple'], SimpleModel)
+  assert converted_args.model_dump() == original_args
+
+
+def test_pydantic_model_in_list_union_type():
+  class SimpleModel(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def foo(_: list[Union[int, SimpleModel]]):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = [1, {'key1_simple': 1, 'key2_simple': 1.0}]
+
+  converted_args = convert_if_exist_pydantic_model(
+      original_args, annotation, 'param_name', 'func_name'
+  )
+
+  assert isinstance(converted_args, list)
+  assert len(converted_args) == 2
+  assert isinstance(converted_args[0], int)
+  assert isinstance(converted_args[1], SimpleModel)
+  assert converted_args[0] == original_args[0]
+  assert converted_args[1].model_dump() == original_args[1]
+
+
+def test_generic_list_type():
+  def foo(_: Optional[list[Union[int, float]]]):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = [1, 1.5]
+
+  converted_args = convert_if_exist_pydantic_model(
+      original_args, annotation, 'param_name', 'func_name'
+  )
+
+  assert isinstance(converted_args, list)
+  assert len(converted_args) == 2
+  assert isinstance(converted_args[0], int)
+  assert isinstance(converted_args[1], float)
+  assert converted_args[0] == original_args[0]
+
+
+@pytest.mark.skipif(sys.version_info < (3, 10), reason='need python 3.10+')
+def test_pydantic_model_with_union_and_generic_type():
+  class Model1(pydantic.BaseModel):
+    arg1: Union[int, float]
+    arg2: list[str]
+    arg3: int | float  # python 3.9+
+    arg4: Union[list[str], str]
+
+  def foo(_: Optional[list[Union[int, Model1]]]):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = [1, {'arg1': 1, 'arg2': ['a'], 'arg3': 1.0, 'arg4': '1.0'}]
+
+  converted_args = convert_if_exist_pydantic_model(
+      original_args, annotation, 'param_name', 'func_name'
+  )
+
+  assert isinstance(converted_args, list)
+  assert len(converted_args) == 2
+  assert isinstance(converted_args[0], int)
+  assert isinstance(converted_args[1], Model1)
+  assert converted_args[0] == original_args[0]
+
+
+def test_unknown_pydantic_model_argument_error():
+  class SimpleModel(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def foo(_: SimpleModel):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = {'key3_simple': 1, 'key2_simple': 1.0}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        original_args, annotation, 'param_name', 'func_name'
+    )
+
+
+def test_unknown_pydantic_model_argument_error_with_union_type():
+  class SimpleModel1(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  class SimpleModel2(pydantic.BaseModel):
+    key3_simple: str
+    key4_simple: float
+
+  def foo(_: Union[SimpleModel1, SimpleModel2]):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = {'key5_simple': 1, 'key4_simple': 1.0}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        original_args, annotation, 'param_name', 'func_name'
+    )
+
+
+def test_unknown_pydantic_model_argument_error_with_union_type_and_builtin_type():
+  class SimpleModel1(pydantic.BaseModel):
+    key1_simple: int
+    key2_simple: float
+
+  def foo(_: Union[SimpleModel1, int]):
+    pass
+
+  annotation = inspect.signature(foo).parameters['_'].annotation
+  original_args = {'key5_simple': 1, 'key4_simple': 1.0}
+
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        original_args, annotation, 'param_name', 'func_name'
+    )
+
+
+def test_incompatible_value_and_annotation():
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        {'key1_simple': 1, 'key2_simple': 1.0},
+        int,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        {'key1_simple': 1, 'key2_simple': 1.0},
+        float,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        1,
+        str,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        1.0,
+        str,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        True,
+        str,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        [1],
+        str,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        {'key1': 1},
+        str,
+        'param_name',
+        'func_name',
+    )
+  with pytest.raises(errors.UnknownFunctionCallArgumentError):
+    convert_if_exist_pydantic_model(
+        {'key1': 1, 'key2': 2},
+        str,
+        'param_name',
+        'func_name',
+    )

google/genai/tests/afc/test_convert_number_values_for_function_call_args.py

@@ -0,0 +1,63 @@
+# 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 convert_number_values_for_function_call_args."""
+
+from ..._extra_utils import convert_number_values_for_function_call_args
+
+
+def test_integer_value():
+  assert convert_number_values_for_function_call_args(1) == 1
+
+
+def test_float_value():
+  assert convert_number_values_for_function_call_args(1.0) == 1
+
+
+def test_string_value():
+  assert convert_number_values_for_function_call_args('1.0') == '1.0'
+
+
+def test_boolean_value():
+  assert convert_number_values_for_function_call_args(True) is True
+
+
+def test_none_value():
+  assert convert_number_values_for_function_call_args(None) is None
+
+
+def test_float_value_with_decimal():
+  assert convert_number_values_for_function_call_args(1.1) == 1.1
+
+
+def test_dict_value():
+  assert convert_number_values_for_function_call_args(
+      {'key1': 1.0, 'key2': 1.1}
+  ) == {'key1': 1, 'key2': 1.1}
+
+
+def test_list_value():
+  assert convert_number_values_for_function_call_args([1.0, 1.1, 1.2]) == [
+      1,
+      1.1,
+      1.2,
+  ]
+
+
+def test_nested_value():
+  assert convert_number_values_for_function_call_args(
+      {'key1': 1.0, 'key2': {'key3': 1.0, 'key4': [1.2, 2.0]}}
+  ) == {'key1': 1, 'key2': {'key3': 1, 'key4': [1.2, 2]}}

google/genai/tests/afc/test_find_afc_incompatible_tool_indexes.py

@@ -0,0 +1,240 @@
+# 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 find_afc_incompatible_tool_indexes."""
+
+from typing import Any
+import pytest
+from ... import types
+from ..._extra_utils import find_afc_incompatible_tool_indexes
+
+try:
+  from mcp import types as mcp_types
+  from mcp import ClientSession as McpClientSession
+  from ..._adapters import McpToGenAiToolAdapter
+except ImportError as e:
+  import sys
+
+  if sys.version_info < (3, 10):
+    raise ImportError(
+        'MCP Tool requires Python 3.10 or above. Please upgrade your Python'
+        ' version.'
+    ) from e
+  else:
+    raise e
+
+
+def get_weather_tool(city: str) -> str:
+  """Get the weather in a city."""
+  return f'The weather in {city} is sunny and 100 degrees.'
+
+
+class MockMcpClientSession(McpClientSession):
+
+  def __init__(self):
+    self._read_stream = None
+    self._write_stream = None
+
+  async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+    return mcp_types.CallToolResult(
+        content=[mcp_types.TextContent(type='text', text='1.01')]
+    )
+
+mcp_to_genai_tool_adapter = McpToGenAiToolAdapter(
+    session=MockMcpClientSession(),
+    list_tools_result=mcp_types.ListToolsResult(tools=[]),
+)
+
+
+def test_no_config_returns_empty_list():
+    """Verifies that an empty list is returned if the input config is None.
+    """
+    result = find_afc_incompatible_tool_indexes(config=None)
+    assert result == []
+
+def test_config_with_no_tools_returns_empty_list():
+    """Verifies an empty list is returned if the config has no 'tools' attribute.
+    """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig()
+    )
+    assert result == []
+
+def test_empty_tools_list_returns_empty_list():
+    """Verifies that an empty list is returned if the 'tools' list is empty."""
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(tools=[])
+    )
+
+    assert result == []
+
+def test_all_compatible_tools_returns_empty_list_with_empty_fd():
+    """Verifies that an empty list is returned when all tools are compatible.
+    A tool is compatible if it's not a `types.Tool` or if its
+    `function_declarations` attribute is empty or None from config.
+    """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(
+            tools=[
+                types.Tool(
+                    google_search_retrieval=types.GoogleSearchRetrieval()
+                ),
+                types.Tool(retrieval=types.Retrieval()),
+                types.Tool(google_search=types.GoogleSearch()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(google_maps=types.GoogleMaps()),
+                types.Tool(url_context=types.UrlContext()),
+                types.Tool(computer_use=types.ComputerUse()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(function_declarations=[]),
+                mcp_types.Tool(
+                    name='get_weather',
+                    description='Get the weather in a city.',
+                    inputSchema={
+                        'type': 'object',
+                        'properties': {'location': {'type': 'string'}},
+                    },
+                ),
+                get_weather_tool,
+                mcp_to_genai_tool_adapter,
+            ]
+        )
+    )
+
+    assert result == []
+
+def test_all_compatible_tools_returns_empty_list_with_none_fd():
+    """Verifies that an empty list is returned when all tools are compatible.
+    A tool is compatible if it's not a `types.Tool` or if its
+    `function_declarations` attribute is empty or None from config.
+    """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(
+            tools=[
+                types.Tool(
+                    google_search_retrieval=types.GoogleSearchRetrieval()
+                ),
+                types.Tool(retrieval=types.Retrieval()),
+                types.Tool(google_search=types.GoogleSearch()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(google_maps=types.GoogleMaps()),
+                types.Tool(url_context=types.UrlContext()),
+                types.Tool(computer_use=types.ComputerUse()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(function_declarations=None),
+                mcp_types.Tool(
+                    name='get_weather',
+                    description='Get the weather in a city.',
+                    inputSchema={
+                        'type': 'object',
+                        'properties': {'location': {'type': 'string'}},
+                    },
+                ),
+                get_weather_tool,
+                mcp_to_genai_tool_adapter,
+            ]
+        )
+    )
+
+    assert result == []
+
+def test_all_compatible_tools_returns_empty_list():
+    """Verifies that an empty list is returned when all tools are compatible.
+    A tool is compatible if it's not a `types.Tool` or if its
+    `function_declarations` attribute is empty or None from config.
+    """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(
+            tools=[
+                types.Tool(
+                    google_search_retrieval=types.GoogleSearchRetrieval()
+                ),
+                types.Tool(retrieval=types.Retrieval()),
+                types.Tool(google_search=types.GoogleSearch()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(google_maps=types.GoogleMaps()),
+                types.Tool(url_context=types.UrlContext()),
+                types.Tool(computer_use=types.ComputerUse()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(function_declarations=[]),
+                mcp_types.Tool(
+                    name='get_weather',
+                    description='Get the weather in a city.',
+                    inputSchema={
+                        'type': 'object',
+                        'properties': {'location': {'type': 'string'}},
+                    },
+                ),
+                get_weather_tool,
+                mcp_to_genai_tool_adapter,
+            ]
+        )
+    )
+
+    assert result == []
+
+def test_single_incompatible_tool():
+    """Verifies that the correct index is returned for a single incompatible
+    tool.
+    """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(
+            tools=[
+                types.Tool(
+                    google_search_retrieval=types.GoogleSearchRetrieval()
+                ),
+                types.Tool(retrieval=types.Retrieval()),
+                types.Tool(
+                    function_declarations=[
+                        types.FunctionDeclaration(name='test_function')
+                    ]
+                ),
+                get_weather_tool,
+                mcp_to_genai_tool_adapter,
+            ]
+        )
+    )
+    assert result == [2]
+
+
+def test_multiple_incompatible_tools():
+    """Verifies that all correct indexes are returned for multiple incompatible
+    tools. """
+    result = find_afc_incompatible_tool_indexes(
+        config=types.GenerateContentConfig(
+            tools=[
+                types.Tool(
+                    google_search_retrieval=types.GoogleSearchRetrieval()
+                ),
+                types.Tool(retrieval=types.Retrieval()),
+                types.Tool(
+                    function_declarations=[
+                        types.FunctionDeclaration(name='test_function')
+                    ]
+                ),
+                types.Tool(computer_use=types.ComputerUse()),
+                types.Tool(code_execution=types.ToolCodeExecution()),
+                types.Tool(
+                    function_declarations=[
+                        types.FunctionDeclaration(name='test_function_2')
+                    ]
+                ),
+                get_weather_tool,
+                mcp_to_genai_tool_adapter,
+            ]
+        )
+    )
+    assert result == [2, 5]