Merge branch 'main' into twisha-core-docstring

Author: twishabansal

packages/toolbox-core/src/toolbox_core/client.py

@@ -11,7 +11,6 @@
 # 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 re
 import types
 from typing import Any, Callable, Mapping, Optional, Union
 

packages/toolbox-core/src/toolbox_core/tool.py

@@ -14,15 +14,15 @@
 
 
 import asyncio
-import copy
 import types
-from inspect import Signature
+from inspect import Parameter, Signature
 from typing import (
     Any,
     Callable,
     Iterable,
     Mapping,
     Optional,
+    Sequence,
     Union,
 )
 

packages/toolbox-core/tests/conftest.py

@@ -163,4 +163,4 @@ def toolbox_server(toolbox_version: str, tools_file_path: str) -> Generator[None
 
     # Clean up toolbox server
     toolbox_server.terminate()
-    toolbox_server.wait()
+    toolbox_server.wait(timeout=5)

packages/toolbox-core/tests/test_e2e.py

@@ -12,52 +12,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""End-to-end tests for the toolbox SDK interacting with the toolbox server.
-
-This file covers the following test cases:
-
-1. Loading a tool.
-2. Loading a specific toolset.
-3. Loading the default toolset (contains all tools).
-4. Running a tool with
-    a. Missing params.
-    b. Wrong param type.
-5. Running a tool with no required auth, with auth provided.
-6. Running a tool with required auth:
-    a. No auth provided.
-    b. Wrong auth provided: The tool requires a different authentication
-                            than the one provided.
-    c. Correct auth provided.
-7. Running a tool with a parameter that requires auth:
-    a. No auth provided.
-    b. Correct auth provided.
-    c. Auth provided does not contain the required claim.
-"""
 import pytest
 import pytest_asyncio
 
 from toolbox_core.client import ToolboxClient
 from toolbox_core.tool import ToolboxTool
 
+# --- Shared Fixtures Defined at Module Level ---
+@pytest_asyncio.fixture(scope="function")
+async def toolbox():
+    """Creates a ToolboxClient instance shared by all tests in this module."""
+    toolbox = ToolboxClient("http://localhost:5000")
+    try:
+        yield toolbox
+    finally:
+        await toolbox.close()
+
+
+@pytest_asyncio.fixture(scope="function")
+async def get_n_rows_tool(toolbox: ToolboxClient) -> ToolboxTool:
+    """Load the 'get-n-rows' tool using the shared toolbox client."""
+    tool = await toolbox.load_tool("get-n-rows")
+    assert tool.__name__ == "get-n-rows"
+    return tool
+
 
 @pytest.mark.asyncio
 @pytest.mark.usefixtures("toolbox_server")
-class TestE2EClient:
-    @pytest_asyncio.fixture(scope="function")
-    async def toolbox(self):
-        toolbox = ToolboxClient("http://localhost:5000")
-        try:
-            yield toolbox
-        finally:
-            await toolbox.close()
-
-    @pytest_asyncio.fixture(scope="function")
-    async def get_n_rows_tool(self, toolbox: ToolboxClient) -> ToolboxTool:
-        tool = await toolbox.load_tool("get-n-rows")
-        assert tool.__name__ == "get-n-rows"
-        return tool
-
-    #### Basic e2e tests
+class TestBasicE2E:
     @pytest.mark.parametrize(
         "toolset_name, expected_length, expected_tools",
         [
@@ -72,83 +54,105 @@ async def test_load_toolset_specific(
         expected_length: int,
         expected_tools: list[str],
     ):
+        """Load a specific toolset"""
         toolset = await toolbox.load_toolset(toolset_name)
         assert len(toolset) == expected_length
         tool_names = {tool.__name__ for tool in toolset}
         assert tool_names == set(expected_tools)
 
     async def test_run_tool(self, get_n_rows_tool: ToolboxTool):
+        """Invoke a tool."""
         response = await get_n_rows_tool(num_rows="2")
 
         assert isinstance(response, str)
         assert "row1" in response
         assert "row2" in response
         assert "row3" not in response
 
-    async def test_run_tool_missing_params(self, get_n_rows_tool):
+    async def test_run_tool_missing_params(self, get_n_rows_tool: ToolboxTool):
+        """Invoke a tool with missing params."""
         with pytest.raises(TypeError, match="missing a required argument: 'num_rows'"):
             await get_n_rows_tool()
 
     async def test_run_tool_wrong_param_type(self, get_n_rows_tool: ToolboxTool):
+        """Invoke a tool with wrong param type."""
         with pytest.raises(
             Exception,
             match='provided parameters were invalid: unable to parse value for "num_rows": .* not type "string"',
         ):
             await get_n_rows_tool(num_rows=2)
 
-    ##### Bind param tests
-    async def test_bind_params(self, toolbox, get_n_rows_tool):
-        new_tool = get_n_rows_tool.bind_parameters({"num_rows": lambda: "3"})
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("toolbox_server")
+class TestBindParams:
+    async def test_bind_params(
+        self, toolbox: ToolboxClient, get_n_rows_tool: ToolboxTool
+    ):
+        """Bind a param to an existing tool."""
+        new_tool = get_n_rows_tool.bind_parameters({"num_rows": "3"})
         response = await new_tool()
+        assert isinstance(response, str)
+        assert "row1" in response
+        assert "row2" in response
+        assert "row3" in response
+        assert "row4" not in response
 
+    async def test_bind_params_callable(
+        self, toolbox: ToolboxClient, get_n_rows_tool: ToolboxTool
+    ):
+        """Bind a callable param to an existing tool."""
+        new_tool = get_n_rows_tool.bind_parameters({"num_rows": lambda: "3"})
+        response = await new_tool()
         assert isinstance(response, str)
         assert "row1" in response
         assert "row2" in response
         assert "row3" in response
         assert "row4" not in response
 
-    ##### Auth tests
-    async def test_run_tool_unauth_with_auth(self, toolbox, auth_token2):
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("toolbox_server")
+class TestAuth:
+    async def test_run_tool_unauth_with_auth(
+        self, toolbox: ToolboxClient, auth_token2: str
+    ):
         """Tests running a tool that doesn't require auth, with auth provided."""
         tool = await toolbox.load_tool(
             "get-row-by-id", auth_token_getters={"my-test-auth": lambda: auth_token2}
         )
         response = await tool(id="2")
         assert "row2" in response
 
-    async def test_run_tool_no_auth(self, toolbox):
+
+    async def test_run_tool_no_auth(self, toolbox: ToolboxClient):
         """Tests running a tool requiring auth without providing auth."""
-        tool = await toolbox.load_tool(
-            "get-row-by-id-auth",
-        )
+        tool = await toolbox.load_tool("get-row-by-id-auth")
         with pytest.raises(
             Exception,
             match="tool invocation not authorized. Please make sure your specify correct auth headers",
         ):
             await tool(id="2")
 
-    async def test_run_tool_wrong_auth(self, toolbox, auth_token2):
-        """Tests running a tool with incorrect auth."""
-        tool = await toolbox.load_tool(
-            "get-row-by-id-auth",
-        )
+    async def test_run_tool_wrong_auth(self, toolbox: ToolboxClient, auth_token2: str):
+        """Tests running a tool with incorrect auth. The tool
+        requires a different authentication than the one provided."""
+        tool = await toolbox.load_tool("get-row-by-id-auth")
         auth_tool = tool.add_auth_token_getters({"my-test-auth": lambda: auth_token2})
         with pytest.raises(
             Exception,
             match="tool invocation not authorized",
         ):
             await auth_tool(id="2")
 
-    async def test_run_tool_auth(self, toolbox, auth_token1):
+    async def test_run_tool_auth(self, toolbox: ToolboxClient, auth_token1: str):
         """Tests running a tool with correct auth."""
-        tool = await toolbox.load_tool(
-            "get-row-by-id-auth",
-        )
+        tool = await toolbox.load_tool("get-row-by-id-auth")
         auth_tool = tool.add_auth_token_getters({"my-test-auth": lambda: auth_token1})
         response = await auth_tool(id="2")
         assert "row2" in response
 
-    async def test_run_tool_param_auth_no_auth(self, toolbox):
+
+    async def test_run_tool_param_auth_no_auth(self, toolbox: ToolboxClient):
         """Tests running a tool with a param requiring auth, without auth."""
         tool = await toolbox.load_tool("get-row-by-email-auth")
         with pytest.raises(
@@ -157,7 +161,8 @@ async def test_run_tool_param_auth_no_auth(self, toolbox):
         ):
             await tool()
 
-    async def test_run_tool_param_auth(self, toolbox, auth_token1):
+
+    async def test_run_tool_param_auth(self, toolbox: ToolboxClient, auth_token1: str):
         """Tests running a tool with a param requiring auth, with correct auth."""
         tool = await toolbox.load_tool(
             "get-row-by-email-auth",
@@ -168,7 +173,9 @@ async def test_run_tool_param_auth(self, toolbox, auth_token1):
         assert "row5" in response
         assert "row6" in response
 
-    async def test_run_tool_param_auth_no_field(self, toolbox, auth_token1):
+    async def test_run_tool_param_auth_no_field(
+        self, toolbox: ToolboxClient, auth_token1: str
+    ):
         """Tests running a tool with a param requiring auth, with insufficient auth."""
         tool = await toolbox.load_tool(
             "get-row-by-content-auth",

release-please-config.json

@@ -4,19 +4,20 @@
     "bump-minor-pre-major": true,
     "bump-patch-for-minor-pre-major": true,
     "separate-pull-requests": true,
-    "include-component-in-tag": true,
     "changelog-sections": [
       { "type": "feat", "section": "Features" },
       { "type": "fix", "section": "Bug Fixes" },
       { "type": "chore", "section": "Miscellaneous Chores", "hidden": false }
     ],
     "packages": {
       "packages/toolbox-core": {
+        "component": "toolbox-core",
         "extra-files": [
           "src/toolbox_core/version.py"
         ]
       },
       "packages/toolbox-langchain": {
+        "component": "toolbox-langchain",
         "extra-files": [
           "src/toolbox_langchain/version.py"
         ]