google-adk 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

google/adk/tests/unittests/tools/test_build_function_declaration.py

@@ -1,277 +0,0 @@
-# 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.
-
-from typing import Dict
-from typing import List
-
-from google.adk.tools import _automatic_function_calling_util
-from google.adk.tools.agent_tool import ToolContext
-from google.adk.tools.langchain_tool import LangchainTool
-# TODO: crewai requires python 3.10 as minimum
-# from crewai_tools import FileReadTool
-from langchain_community.tools import ShellTool
-from pydantic import BaseModel
-import pytest
-
-
-def test_unsupported_variant():
-  def simple_function(input_str: str) -> str:
-    return {'result': input_str}
-
-  with pytest.raises(ValueError):
-    _automatic_function_calling_util.build_function_declaration(
-        func=simple_function, variant='Unsupported'
-    )
-
-
-def test_string_input():
-  def simple_function(input_str: str) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'STRING'
-
-
-def test_int_input():
-  def simple_function(input_str: int) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'INTEGER'
-
-
-def test_float_input():
-  def simple_function(input_str: float) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'NUMBER'
-
-
-def test_bool_input():
-  def simple_function(input_str: bool) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'BOOLEAN'
-
-
-def test_array_input():
-  def simple_function(input_str: List[str]) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'ARRAY'
-
-
-def test_dict_input():
-  def simple_function(input_str: Dict[str, str]) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'OBJECT'
-
-
-def test_basemodel_input():
-  class CustomInput(BaseModel):
-    input_str: str
-
-  def simple_function(input: CustomInput) -> str:
-    return {'result': input}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input'].type == 'OBJECT'
-  assert (
-      function_decl.parameters.properties['input'].properties['input_str'].type
-      == 'STRING'
-  )
-
-
-def test_toolcontext_ignored():
-  def simple_function(input_str: str, tool_context: ToolContext) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function, ignore_params=['tool_context']
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'STRING'
-  assert 'tool_context' not in function_decl.parameters.properties
-
-
-def test_basemodel():
-  class SimpleFunction(BaseModel):
-    input_str: str
-    custom_input: int
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=SimpleFunction, ignore_params=['custom_input']
-  )
-
-  assert function_decl.name == 'SimpleFunction'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'STRING'
-  assert 'custom_input' not in function_decl.parameters.properties
-
-
-def test_nested_basemodel_input():
-  class ChildInput(BaseModel):
-    input_str: str
-
-  class CustomInput(BaseModel):
-    child: ChildInput
-
-  def simple_function(input: CustomInput) -> str:
-    return {'result': input}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input'].type == 'OBJECT'
-  assert (
-      function_decl.parameters.properties['input'].properties['child'].type
-      == 'OBJECT'
-  )
-  assert (
-      function_decl.parameters.properties['input']
-      .properties['child']
-      .properties['input_str']
-      .type
-      == 'STRING'
-  )
-
-
-def test_basemodel_with_nested_basemodel():
-  class ChildInput(BaseModel):
-    input_str: str
-
-  class CustomInput(BaseModel):
-    child: ChildInput
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=CustomInput, ignore_params=['custom_input']
-  )
-
-  assert function_decl.name == 'CustomInput'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['child'].type == 'OBJECT'
-  assert (
-      function_decl.parameters.properties['child'].properties['input_str'].type
-      == 'STRING'
-  )
-  assert 'custom_input' not in function_decl.parameters.properties
-
-
-def test_list():
-  def simple_function(
-      input_str: List[str], input_dir: List[Dict[str, str]]
-  ) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'ARRAY'
-  assert function_decl.parameters.properties['input_str'].items.type == 'STRING'
-  assert function_decl.parameters.properties['input_dir'].type == 'ARRAY'
-  assert function_decl.parameters.properties['input_dir'].items.type == 'OBJECT'
-
-
-def test_basemodel_list():
-  class ChildInput(BaseModel):
-    input_str: str
-
-  class CustomInput(BaseModel):
-    child: ChildInput
-
-  def simple_function(input_str: List[CustomInput]) -> str:
-    return {'result': input_str}
-
-  function_decl = _automatic_function_calling_util.build_function_declaration(
-      func=simple_function
-  )
-
-  assert function_decl.name == 'simple_function'
-  assert function_decl.parameters.type == 'OBJECT'
-  assert function_decl.parameters.properties['input_str'].type == 'ARRAY'
-  assert function_decl.parameters.properties['input_str'].items.type == 'OBJECT'
-  assert (
-      function_decl.parameters.properties['input_str']
-      .items.properties['child']
-      .type
-      == 'OBJECT'
-  )
-  assert (
-      function_decl.parameters.properties['input_str']
-      .items.properties['child']
-      .properties['input_str']
-      .type
-      == 'STRING'
-  )
-
-
-# TODO: comment out this test for now as crewai requires python 3.10 as minimum
-# def test_crewai_tool():
-#   docs_tool = CrewaiTool(
-#       name='direcotry_read_tool',
-#       description='use this to find files for you.',
-#       tool=FileReadTool(),
-#   )
-#   function_decl = docs_tool.get_declaration()
-#   assert function_decl.name == 'direcotry_read_tool'
-#   assert function_decl.parameters.type == 'OBJECT'
-#   assert function_decl.parameters.properties['file_path'].type == 'STRING'

google/adk/tests/unittests/utils.py

@@ -1,304 +0,0 @@
-# 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.
-
-import asyncio
-import contextlib
-from typing import AsyncGenerator
-from typing import Generator
-from typing import Union
-
-from google.adk.agents.invocation_context import InvocationContext
-from google.adk.agents.live_request_queue import LiveRequestQueue
-from google.adk.agents.llm_agent import Agent
-from google.adk.agents.llm_agent import LlmAgent
-from google.adk.agents.run_config import RunConfig
-from google.adk.artifacts import InMemoryArtifactService
-from google.adk.events.event import Event
-from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
-from google.adk.models.base_llm import BaseLlm
-from google.adk.models.base_llm_connection import BaseLlmConnection
-from google.adk.models.llm_request import LlmRequest
-from google.adk.models.llm_response import LlmResponse
-from google.adk.runners import InMemoryRunner as AfInMemoryRunner
-from google.adk.runners import Runner
-from google.adk.sessions.in_memory_session_service import InMemorySessionService
-from google.adk.sessions.session import Session
-from google.genai import types
-from google.genai.types import Part
-from typing_extensions import override
-
-
-class UserContent(types.Content):
-
-  def __init__(self, text_or_part: str):
-    parts = [
-        types.Part.from_text(text=text_or_part)
-        if isinstance(text_or_part, str)
-        else text_or_part
-    ]
-    super().__init__(role='user', parts=parts)
-
-
-class ModelContent(types.Content):
-
-  def __init__(self, parts: list[types.Part]):
-    super().__init__(role='model', parts=parts)
-
-
-def create_invocation_context(agent: Agent, user_content: str = ''):
-  invocation_id = 'test_id'
-  artifact_service = InMemoryArtifactService()
-  session_service = InMemorySessionService()
-  memory_service = InMemoryMemoryService()
-  invocation_context = InvocationContext(
-      artifact_service=artifact_service,
-      session_service=session_service,
-      memory_service=memory_service,
-      invocation_id=invocation_id,
-      agent=agent,
-      session=session_service.create_session(
-          app_name='test_app', user_id='test_user'
-      ),
-      user_content=types.Content(
-          role='user', parts=[types.Part.from_text(text=user_content)]
-      ),
-      run_config=RunConfig(),
-  )
-  if user_content:
-    append_user_content(
-        invocation_context, [types.Part.from_text(text=user_content)]
-    )
-  return invocation_context
-
-
-def append_user_content(
-    invocation_context: InvocationContext, parts: list[types.Part]
-) -> Event:
-  session = invocation_context.session
-  event = Event(
-      invocation_id=invocation_context.invocation_id,
-      author='user',
-      content=types.Content(role='user', parts=parts),
-  )
-  session.events.append(event)
-  return event
-
-
-# Extracts the contents from the events and transform them into a list of
-# (author, simplified_content) tuples.
-def simplify_events(events: list[Event]) -> list[(str, types.Part)]:
-  return [(event.author, simplify_content(event.content)) for event in events]
-
-
-# Simplifies the contents into a list of (author, simplified_content) tuples.
-def simplify_contents(contents: list[types.Content]) -> list[(str, types.Part)]:
-  return [(content.role, simplify_content(content)) for content in contents]
-
-
-# Simplifies the content so it's easier to assert.
-# - If there is only one part, return part
-# - If the only part is pure text, return stripped_text
-# - If there are multiple parts, return parts
-# - remove function_call_id if it exists
-def simplify_content(
-    content: types.Content,
-) -> Union[str, types.Part, list[types.Part]]:
-  for part in content.parts:
-    if part.function_call and part.function_call.id:
-      part.function_call.id = None
-    if part.function_response and part.function_response.id:
-      part.function_response.id = None
-  if len(content.parts) == 1:
-    if content.parts[0].text:
-      return content.parts[0].text.strip()
-    else:
-      return content.parts[0]
-  return content.parts
-
-
-def get_user_content(message: types.ContentUnion) -> types.Content:
-  return message if isinstance(message, types.Content) else UserContent(message)
-
-
-class TestInMemoryRunner(AfInMemoryRunner):
-  """InMemoryRunner that is tailored for tests, features async run method.
-
-  app_name is hardcoded as InMemoryRunner in the parent class.
-  """
-
-  async def run_async_with_new_session(
-      self, new_message: types.ContentUnion
-  ) -> list[Event]:
-
-    session = self.session_service.create_session(
-        app_name='InMemoryRunner', user_id='test_user'
-    )
-    collected_events = []
-
-    async for event in self.run_async(
-        user_id=session.user_id,
-        session_id=session.id,
-        new_message=get_user_content(new_message),
-    ):
-      collected_events.append(event)
-
-    return collected_events
-
-
-class InMemoryRunner:
-  """InMemoryRunner that is tailored for tests."""
-
-  def __init__(
-      self,
-      root_agent: Union[Agent, LlmAgent],
-      response_modalities: list[str] = None,
-  ):
-    self.root_agent = root_agent
-    self.runner = Runner(
-        app_name='test_app',
-        agent=root_agent,
-        artifact_service=InMemoryArtifactService(),
-        session_service=InMemorySessionService(),
-        memory_service=InMemoryMemoryService(),
-    )
-    self.session_id = self.runner.session_service.create_session(
-        app_name='test_app', user_id='test_user'
-    ).id
-
-  @property
-  def session(self) -> Session:
-    return self.runner.session_service.get_session(
-        app_name='test_app', user_id='test_user', session_id=self.session_id
-    )
-
-  def run(self, new_message: types.ContentUnion) -> list[Event]:
-    return list(
-        self.runner.run(
-            user_id=self.session.user_id,
-            session_id=self.session.id,
-            new_message=get_user_content(new_message),
-        )
-    )
-
-  def run_live(self, live_request_queue: LiveRequestQueue) -> list[Event]:
-    collected_responses = []
-
-    async def consume_responses():
-      run_res = self.runner.run_live(
-          session=self.session,
-          live_request_queue=live_request_queue,
-      )
-
-      async for response in run_res:
-        collected_responses.append(response)
-        # When we have enough response, we should return
-        if len(collected_responses) >= 1:
-          return
-
-    try:
-      asyncio.run(consume_responses())
-    except asyncio.TimeoutError:
-      print('Returning any partial results collected so far.')
-
-    return collected_responses
-
-
-class MockModel(BaseLlm):
-  model: str = 'mock'
-
-  requests: list[LlmRequest] = []
-  responses: list[LlmResponse]
-  response_index: int = -1
-
-  @classmethod
-  def create(
-      cls,
-      responses: Union[
-          list[types.Part], list[LlmResponse], list[str], list[list[types.Part]]
-      ],
-  ):
-    if not responses:
-      return cls(responses=[])
-    elif isinstance(responses[0], LlmResponse):
-      # reponses is list[LlmResponse]
-      return cls(responses=responses)
-    else:
-      responses = [
-          LlmResponse(content=ModelContent(item))
-          if isinstance(item, list) and isinstance(item[0], types.Part)
-          # responses is list[list[Part]]
-          else LlmResponse(
-              content=ModelContent(
-                  # responses is list[str] or list[Part]
-                  [Part(text=item) if isinstance(item, str) else item]
-              )
-          )
-          for item in responses
-          if item
-      ]
-
-      return cls(responses=responses)
-
-  @staticmethod
-  def supported_models() -> list[str]:
-    return ['mock']
-
-  def generate_content(
-      self, llm_request: LlmRequest, stream: bool = False
-  ) -> Generator[LlmResponse, None, None]:
-    # Increasement of the index has to happen before the yield.
-    self.response_index += 1
-    self.requests.append(llm_request)
-    # yield LlmResponse(content=self.responses[self.response_index])
-    yield self.responses[self.response_index]
-
-  @override
-  async def generate_content_async(
-      self, llm_request: LlmRequest, stream: bool = False
-  ) -> AsyncGenerator[LlmResponse, None]:
-    # Increasement of the index has to happen before the yield.
-    self.response_index += 1
-    self.requests.append(llm_request)
-    yield self.responses[self.response_index]
-
-  @contextlib.asynccontextmanager
-  async def connect(self, llm_request: LlmRequest) -> BaseLlmConnection:
-    """Creates a live connection to the LLM."""
-    yield MockLlmConnection(self.responses)
-
-
-class MockLlmConnection(BaseLlmConnection):
-
-  def __init__(self, llm_responses: list[LlmResponse]):
-    self.llm_responses = llm_responses
-
-  async def send_history(self, history: list[types.Content]):
-    pass
-
-  async def send_content(self, content: types.Content):
-    pass
-
-  async def send(self, data):
-    pass
-
-  async def send_realtime(self, blob: types.Blob):
-    pass
-
-  async def receive(self) -> AsyncGenerator[LlmResponse, None]:
-    """Yield each of the pre-defined LlmResponses."""
-    for response in self.llm_responses:
-      yield response
-
-  async def close(self):
-    pass