chore: Rename internal member variable names to be more concise

Author: anubhav756

packages/toolbox-langchain/src/toolbox_langchain/client.py

@@ -34,7 +34,7 @@ def __init__(
         Args:
             url: The base URL of the Toolbox service.
         """
-        self.__core_sync_client = ToolboxCoreSyncClient(url=url)
+        self.__core_client = ToolboxCoreSyncClient(url=url)
 
     async def aload_tool(
         self,
@@ -85,30 +85,30 @@ async def aload_tool(
                 )
                 auth_token_getters = auth_headers
 
-        coro = self.__core_sync_client._async_client.load_tool(
+        coro = self.__core_client._async_client.load_tool(
             name=tool_name,
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,
         )
 
-        if not self.__core_sync_client._loop:
+        if not self.__core_client._loop:
             # If a loop has not been provided, attempt to run in current thread.
             core_tool = await coro
         else:
             # Otherwise, run in the background thread.
             core_tool = await asyncio.wrap_future(
-                asyncio.run_coroutine_threadsafe(coro, self.__core_sync_client._loop)
+                asyncio.run_coroutine_threadsafe(coro, self.__core_client._loop)
             )
 
-        if not self.__core_sync_client._loop or not self.__core_sync_client._thread:
+        if not self.__core_client._loop or not self.__core_client._thread:
             raise ValueError("Background loop or thread cannot be None.")
 
         core_sync_tool = ToolboxSyncTool(
             core_tool,
-            self.__core_sync_client._loop,
-            self.__core_sync_client._thread,
+            self.__core_client._loop,
+            self.__core_client._thread,
         )
-        return ToolboxTool(core_sync_tool=core_sync_tool)
+        return ToolboxTool(core_tool=core_sync_tool)
 
     async def aload_toolset(
         self,
@@ -167,36 +167,36 @@ async def aload_toolset(
                 )
                 auth_token_getters = auth_headers
 
-        coro = self.__core_sync_client._async_client.load_toolset(
+        coro = self.__core_client._async_client.load_toolset(
             name=toolset_name,
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,
             strict=strict,
         )
 
-        if not self.__core_sync_client._loop:
+        if not self.__core_client._loop:
             # If a loop has not been provided, attempt to run in current thread.
             core_tools = await coro
         else:
             # Otherwise, run in the background thread.
             core_tools = await asyncio.wrap_future(
-                asyncio.run_coroutine_threadsafe(coro, self.__core_sync_client._loop)
+                asyncio.run_coroutine_threadsafe(coro, self.__core_client._loop)
             )
 
-        if not self.__core_sync_client._loop or not self.__core_sync_client._thread:
+        if not self.__core_client._loop or not self.__core_client._thread:
             raise ValueError("Background loop or thread cannot be None.")
 
         core_sync_tools = [
             ToolboxSyncTool(
                 core_tool,
-                self.__core_sync_client._loop,
-                self.__core_sync_client._thread,
+                self.__core_client._loop,
+                self.__core_client._thread,
             )
             for core_tool in core_tools
         ]
         tools = []
         for core_sync_tool in core_sync_tools:
-            tools.append(ToolboxTool(core_sync_tool=core_sync_tool))
+            tools.append(ToolboxTool(core_tool=core_sync_tool))
         return tools
 
     def load_tool(
@@ -248,12 +248,12 @@ def load_tool(
                 )
                 auth_token_getters = auth_headers
 
-        core_sync_tool = self.__core_sync_client.load_tool(
+        core_sync_tool = self.__core_client.load_tool(
             name=tool_name,
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,
         )
-        return ToolboxTool(core_sync_tool=core_sync_tool)
+        return ToolboxTool(core_tool=core_sync_tool)
 
     def load_toolset(
         self,
@@ -312,7 +312,7 @@ def load_toolset(
                 )
                 auth_token_getters = auth_headers
 
-        core_sync_tools = self.__core_sync_client.load_toolset(
+        core_sync_tools = self.__core_client.load_toolset(
             name=toolset_name,
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,
@@ -321,5 +321,5 @@ def load_toolset(
 
         tools = []
         for core_sync_tool in core_sync_tools:
-            tools.append(ToolboxTool(core_sync_tool=core_sync_tool))
+            tools.append(ToolboxTool(core_tool=core_sync_tool))
         return tools

packages/toolbox-langchain/src/toolbox_langchain/tools.py

@@ -27,37 +27,37 @@ class ToolboxTool(BaseTool):
 
     def __init__(
         self,
-        core_sync_tool: ToolboxCoreSyncTool,
+        core_tool: ToolboxCoreSyncTool,
     ) -> None:
         """
         Initializes a ToolboxTool instance.
 
         Args:
-            core_sync_tool: The underlying core sync ToolboxTool instance.
+            core_tool: The underlying core sync ToolboxTool instance.
         """
 
         # Due to how pydantic works, we must initialize the underlying
         # BaseTool class before assigning values to member variables.
         super().__init__(
-            name=core_sync_tool.__name__,
-            description=core_sync_tool.__doc__,
-            args_schema=core_sync_tool._async_tool._pydantic_model,
+            name=core_tool.__name__,
+            description=core_tool.__doc__,
+            args_schema=core_tool._async_tool._pydantic_model,
         )
-        self.__core_sync_tool = core_sync_tool
+        self.__core_tool = core_tool
 
     def _run(self, **kwargs: Any) -> str:
-        return self.__core_sync_tool(**kwargs)
+        return self.__core_tool(**kwargs)
 
     async def _arun(self, **kwargs: Any) -> str:
-        coro = self.__core_sync_tool._async_tool(**kwargs)
+        coro = self.__core_tool._async_tool(**kwargs)
 
         # If a loop has not been provided, attempt to run in current thread.
-        if not self.__core_sync_tool._loop:
+        if not self.__core_tool._loop:
             return await coro
 
         # Otherwise, run in the background thread.
         return await asyncio.wrap_future(
-            asyncio.run_coroutine_threadsafe(coro, self.__core_sync_tool._loop)
+            asyncio.run_coroutine_threadsafe(coro, self.__core_tool._loop)
         )
 
     def add_auth_token_getters(
@@ -79,10 +79,10 @@ def add_auth_token_getters(
             ValueError: If any of the provided auth parameters is already
                 registered.
         """
-        new_core_sync_tool = self.__core_sync_tool.add_auth_token_getters(
+        new_core_tool = self.__core_tool.add_auth_token_getters(
             auth_token_getters
         )
-        return ToolboxTool(core_sync_tool=new_core_sync_tool)
+        return ToolboxTool(core_tool=new_core_tool)
 
     def add_auth_token_getter(
         self, auth_source: str, get_id_token: Callable[[], str]
@@ -123,8 +123,8 @@ def bind_params(
         Raises:
             ValueError: If any of the provided bound params is already bound.
         """
-        new_core_sync_tool = self.__core_sync_tool.bind_params(bound_params)
-        return ToolboxTool(core_sync_tool=new_core_sync_tool)
+        new_core_tool = self.__core_tool.bind_params(bound_params)
+        return ToolboxTool(core_tool=new_core_tool)
 
     def bind_param(
         self,

packages/toolbox-langchain/tests/test_client.py

@@ -30,35 +30,35 @@ class TestToolboxClient:
     def toolbox_client(self):
         client = ToolboxClient(URL)
         assert isinstance(client, ToolboxClient)
-        assert client._ToolboxClient__core_sync_client is not None
-        assert client._ToolboxClient__core_sync_client._async_client is not None
-        assert client._ToolboxClient__core_sync_client._loop is not None
-        assert client._ToolboxClient__core_sync_client._loop.is_running()
-        assert client._ToolboxClient__core_sync_client._thread is not None
-        assert client._ToolboxClient__core_sync_client._thread.is_alive()
+        assert client._ToolboxClient__core_client is not None
+        assert client._ToolboxClient__core_client._async_client is not None
+        assert client._ToolboxClient__core_client._loop is not None
+        assert client._ToolboxClient__core_client._loop.is_running()
+        assert client._ToolboxClient__core_client._thread is not None
+        assert client._ToolboxClient__core_client._thread.is_alive()
         return client
 
     @patch("toolbox_core.sync_client.ToolboxSyncClient.load_tool")
     def test_load_tool(self, mock_core_load_tool, toolbox_client):
-        mock_core_sync_tool_instance = Mock(
+        mock_core_tool_instance = Mock(
             spec=ToolboxCoreSyncTool
         )  # Spec with Core Sync Tool
-        mock_core_sync_tool_instance.__name__ = "mock-core-sync-tool"
-        mock_core_sync_tool_instance.__doc__ = "mock core sync description"
+        mock_core_tool_instance.__name__ = "mock-core-sync-tool"
+        mock_core_tool_instance.__doc__ = "mock core sync description"
 
         mock_underlying_async_tool = Mock(
             spec=ToolboxCoreTool
         )  # Core Async Tool for pydantic model
         mock_underlying_async_tool._pydantic_model = BaseModel
-        mock_core_sync_tool_instance._async_tool = mock_underlying_async_tool
+        mock_core_tool_instance._async_tool = mock_underlying_async_tool
 
-        mock_core_load_tool.return_value = mock_core_sync_tool_instance
+        mock_core_load_tool.return_value = mock_core_tool_instance
 
         langchain_tool = toolbox_client.load_tool("test_tool")
 
         assert isinstance(langchain_tool, ToolboxTool)
-        assert langchain_tool.name == mock_core_sync_tool_instance.__name__
-        assert langchain_tool.description == mock_core_sync_tool_instance.__doc__
+        assert langchain_tool.name == mock_core_tool_instance.__name__
+        assert langchain_tool.description == mock_core_tool_instance.__doc__
         assert langchain_tool.args_schema == mock_underlying_async_tool._pydantic_model
 
         mock_core_load_tool.assert_called_once_with(
@@ -67,23 +67,23 @@ def test_load_tool(self, mock_core_load_tool, toolbox_client):
 
     @patch("toolbox_core.sync_client.ToolboxSyncClient.load_toolset")
     def test_load_toolset(self, mock_core_load_toolset, toolbox_client):
-        mock_core_sync_tool_instance1 = Mock(spec=ToolboxCoreSyncTool)
-        mock_core_sync_tool_instance1.__name__ = "mock-core-sync-tool-0"
-        mock_core_sync_tool_instance1.__doc__ = "desc 0"
+        mock_core_tool_instance1 = Mock(spec=ToolboxCoreSyncTool)
+        mock_core_tool_instance1.__name__ = "mock-core-sync-tool-0"
+        mock_core_tool_instance1.__doc__ = "desc 0"
         mock_async_tool0 = Mock(spec=ToolboxCoreTool)
         mock_async_tool0._pydantic_model = BaseModel
-        mock_core_sync_tool_instance1._async_tool = mock_async_tool0
+        mock_core_tool_instance1._async_tool = mock_async_tool0
 
-        mock_core_sync_tool_instance2 = Mock(spec=ToolboxCoreSyncTool)
-        mock_core_sync_tool_instance2.__name__ = "mock-core-sync-tool-1"
-        mock_core_sync_tool_instance2.__doc__ = "desc 1"
+        mock_core_tool_instance2 = Mock(spec=ToolboxCoreSyncTool)
+        mock_core_tool_instance2.__name__ = "mock-core-sync-tool-1"
+        mock_core_tool_instance2.__doc__ = "desc 1"
         mock_async_tool1 = Mock(spec=ToolboxCoreTool)
         mock_async_tool1._pydantic_model = BaseModel
-        mock_core_sync_tool_instance2._async_tool = mock_async_tool1
+        mock_core_tool_instance2._async_tool = mock_async_tool1
 
         mock_core_load_toolset.return_value = [
-            mock_core_sync_tool_instance1,
-            mock_core_sync_tool_instance2,
+            mock_core_tool_instance1,
+            mock_core_tool_instance2,
         ]
 
         langchain_tools = toolbox_client.load_toolset()
@@ -114,7 +114,7 @@ async def test_aload_tool(self, mock_core_aload_tool, toolbox_client):
         assert langchain_tool.name == mock_core_tool_instance.__name__
         assert langchain_tool.description == mock_core_tool_instance.__doc__
 
-        toolbox_client._ToolboxClient__core_sync_client._async_client.load_tool.assert_called_once_with(
+        toolbox_client._ToolboxClient__core_client._async_client.load_tool.assert_called_once_with(
             name="test_tool", auth_token_getters={}, bound_params={}
         )
 
@@ -145,18 +145,18 @@ async def test_aload_toolset(self, mock_core_aload_toolset, toolbox_client):
         assert isinstance(langchain_tools[0], ToolboxTool)
         assert isinstance(langchain_tools[1], ToolboxTool)
 
-        toolbox_client._ToolboxClient__core_sync_client._async_client.load_toolset.assert_called_once_with(
+        toolbox_client._ToolboxClient__core_client._async_client.load_toolset.assert_called_once_with(
             name=None, auth_token_getters={}, bound_params={}, strict=False
         )
 
     @patch("toolbox_core.sync_client.ToolboxSyncClient.load_tool")
     def test_load_tool_with_args(self, mock_core_load_tool, toolbox_client):
-        mock_core_sync_tool_instance = Mock(spec=ToolboxCoreSyncTool)
-        mock_core_sync_tool_instance.__name__ = "mock-tool"
+        mock_core_tool_instance = Mock(spec=ToolboxCoreSyncTool)
+        mock_core_tool_instance.__name__ = "mock-tool"
         mock_async_tool = Mock(spec=ToolboxCoreTool)
         mock_async_tool._pydantic_model = BaseModel
-        mock_core_sync_tool_instance._async_tool = mock_async_tool
-        mock_core_load_tool.return_value = mock_core_sync_tool_instance
+        mock_core_tool_instance._async_tool = mock_async_tool
+        mock_core_load_tool.return_value = mock_core_tool_instance
 
         auth_token_getters = {"token_getter1": lambda: "value1"}
         auth_tokens_deprecated = {"token_deprecated": lambda: "value_dep"}
@@ -216,12 +216,12 @@ def test_load_tool_with_args(self, mock_core_load_tool, toolbox_client):
 
     @patch("toolbox_core.sync_client.ToolboxSyncClient.load_toolset")
     def test_load_toolset_with_args(self, mock_core_load_toolset, toolbox_client):
-        mock_core_sync_tool_instance = Mock(spec=ToolboxCoreSyncTool)
-        mock_core_sync_tool_instance.__name__ = "mock-tool-0"
+        mock_core_tool_instance = Mock(spec=ToolboxCoreSyncTool)
+        mock_core_tool_instance.__name__ = "mock-tool-0"
         mock_async_tool = Mock(spec=ToolboxCoreTool)
         mock_async_tool._pydantic_model = BaseModel
-        mock_core_sync_tool_instance._async_tool = mock_async_tool
-        mock_core_load_toolset.return_value = [mock_core_sync_tool_instance]
+        mock_core_tool_instance._async_tool = mock_async_tool
+        mock_core_load_toolset.return_value = [mock_core_tool_instance]
 
         auth_token_getters = {"token_getter1": lambda: "value1"}
         auth_tokens_deprecated = {"token_deprecated": lambda: "value_dep"}
@@ -277,7 +277,7 @@ async def test_aload_tool_with_args(self, mock_core_aload_tool, toolbox_client):
         assert any("auth_headers` is deprecated" in m for m in messages)
 
         assert isinstance(tool, ToolboxTool)
-        toolbox_client._ToolboxClient__core_sync_client._async_client.load_tool.assert_called_with(
+        toolbox_client._ToolboxClient__core_client._async_client.load_tool.assert_called_with(
             name="test_tool",
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,
@@ -313,7 +313,7 @@ async def test_aload_toolset_with_args(
         assert any("auth_headers` is deprecated" in m for m in messages)
 
         assert len(tools) == 1
-        toolbox_client._ToolboxClient__core_sync_client._async_client.load_toolset.assert_called_with(
+        toolbox_client._ToolboxClient__core_client._async_client.load_toolset.assert_called_with(
             name="my_toolset",
             auth_token_getters=auth_token_getters,
             bound_params=bound_params,

packages/toolbox-langchain/tests/test_e2e.py

@@ -53,7 +53,7 @@ def toolbox(self):
     @pytest_asyncio.fixture(scope="function")
     async def get_n_rows_tool(self, toolbox):
         tool = await toolbox.aload_tool("get-n-rows")
-        assert tool._ToolboxTool__core_sync_tool.__name__ == "get-n-rows"
+        assert tool._ToolboxTool__core_tool.__name__ == "get-n-rows"
         return tool
 
     #### Basic e2e tests
@@ -70,7 +70,7 @@ async def test_aload_toolset_specific(
         toolset = await toolbox.aload_toolset(toolset_name)
         assert len(toolset) == expected_length
         for tool in toolset:
-            name = tool._ToolboxTool__core_sync_tool.__name__
+            name = tool._ToolboxTool__core_tool.__name__
             assert name in expected_tools
 
     async def test_aload_toolset_all(self, toolbox):
@@ -84,7 +84,7 @@ async def test_aload_toolset_all(self, toolbox):
             "get-row-by-content-auth",
         ]
         for tool in toolset:
-            name = tool._ToolboxTool__core_sync_tool.__name__
+            name = tool._ToolboxTool__core_tool.__name__
             assert name in tool_names
 
     async def test_run_tool_async(self, get_n_rows_tool):
@@ -198,7 +198,7 @@ def toolbox(self):
     @pytest.fixture(scope="function")
     def get_n_rows_tool(self, toolbox):
         tool = toolbox.load_tool("get-n-rows")
-        assert tool._ToolboxTool__core_sync_tool.__name__ == "get-n-rows"
+        assert tool._ToolboxTool__core_tool.__name__ == "get-n-rows"
         return tool
 
     #### Basic e2e tests
@@ -215,7 +215,7 @@ def test_load_toolset_specific(
         toolset = toolbox.load_toolset(toolset_name)
         assert len(toolset) == expected_length
         for tool in toolset:
-            name = tool._ToolboxTool__core_sync_tool.__name__
+            name = tool._ToolboxTool__core_tool.__name__
             assert name in expected_tools
 
     def test_aload_toolset_all(self, toolbox):
@@ -229,7 +229,7 @@ def test_aload_toolset_all(self, toolbox):
             "get-row-by-content-auth",
         ]
         for tool in toolset:
-            name = tool._ToolboxTool__core_sync_tool.__name__
+            name = tool._ToolboxTool__core_tool.__name__
             assert name in tool_names
 
     @pytest.mark.asyncio