revert package files

Author: twishabansal

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

@@ -11,13 +11,14 @@
 # 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, Optional
+from typing import Any, Callable, Mapping, Optional, Union
 
 from aiohttp import ClientSession
 
 from .protocol import ManifestSchema, ToolSchema
-from .tool import ToolboxTool, filter_required_authn_params
+from .tool import ToolboxTool, identify_required_authn_params
 
 
 class ToolboxClient:
@@ -58,7 +59,7 @@ def __parse_tool(
         name: str,
         schema: ToolSchema,
         auth_token_getters: dict[str, Callable[[], str]],
-        all_bound_params: dict[str, Callable[[], str]],
+        all_bound_params: Mapping[str, Union[Callable[[], Any], Any]],
     ) -> ToolboxTool:
         """Internal helper to create a callable tool from its schema."""
         # sort into reg, authn, and bound params
@@ -75,14 +76,17 @@ def __parse_tool(
             else:  # regular parameter
                 params.append(p)
 
-        authn_params = filter_required_authn_params(authn_params, auth_sources)
+        authn_params = identify_required_authn_params(
+            authn_params, auth_token_getters.keys()
+        )
 
         tool = ToolboxTool(
             session=self.__session,
             base_url=self.__base_url,
             name=name,
             desc=schema.description,
             params=[p.to_param() for p in params],
+            # create a read-only values for the maps to prevent mutation
             required_authn_params=types.MappingProxyType(authn_params),
             auth_service_token_getters=types.MappingProxyType(auth_token_getters),
             bound_params=types.MappingProxyType(bound_params),
@@ -125,7 +129,7 @@ async def load_tool(
         self,
         name: str,
         auth_token_getters: dict[str, Callable[[], str]] = {},
-        bound_params: dict[str, Callable[[], str]] = {},
+        bound_params: Mapping[str, Union[Callable[[], Any], Any]] = {},
     ) -> ToolboxTool:
         """
         Asynchronously loads a tool from the server.
@@ -138,6 +142,10 @@ async def load_tool(
             name: The unique name or identifier of the tool to load.
             auth_token_getters: A mapping of authentication service names to
                 callables that return the corresponding authentication token.
+            bound_params: A mapping of parameter names to bind to specific values or
+                callables that are called to produce values as needed.
+
+
 
         Returns:
             ToolboxTool: A callable object representing the loaded tool, ready
@@ -166,7 +174,7 @@ async def load_toolset(
         self,
         name: str,
         auth_token_getters: dict[str, Callable[[], str]] = {},
-        bound_params: dict[str, Callable[[], str]] = {},
+        bound_params: Mapping[str, Union[Callable[[], Any], Any]] = {},
     ) -> list[ToolboxTool]:
         """
         Asynchronously fetches a toolset and loads all tools defined within it.
@@ -175,6 +183,8 @@ async def load_toolset(
             name: Name of the toolset to load tools.
             auth_token_getters: A mapping of authentication service names to
                 callables that return the corresponding authentication token.
+            bound_params: A mapping of parameter names to bind to specific values or
+                callables that are called to produce values as needed.
 
 
 
@@ -193,4 +203,4 @@ async def load_toolset(
             self.__parse_tool(n, s, auth_token_getters, bound_params)
             for n, s in manifest.tools.items()
         ]
-        return tools
+        return tools

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

@@ -54,7 +54,7 @@ def __init__(
         params: Sequence[Parameter],
         required_authn_params: Mapping[str, list[str]],
         auth_service_token_getters: Mapping[str, Callable[[], str]],
-        bound_params: Mapping[str, Union[Callable[[], Any], Any]] = {},
+        bound_params: Mapping[str, Union[Callable[[], Any], Any]],
     ):
         """
         Initializes a callable that will trigger the tool invocation through the
@@ -67,10 +67,13 @@ def __init__(
             desc: The description of the remote tool (used as its docstring).
             params: A list of `inspect.Parameter` objects defining the tool's
                 arguments and their types/defaults.
-            required_authn_params: A dict of required authenticated parameters that
-                need a auth_service_token_getter set for them yet.
-            auth_service_tokens: A dict of authService -> token (or callables that
+            required_authn_params: A dict of required authenticated parameters to a list
+                of services that provide values for them.
+            auth_service_token_getters: A dict of authService -> token (or callables that
                 produce a token)
+            bound_params: A mapping of parameter names to bind to specific values or
+                callables that are called to produce values as needed.
+
         """
 
         # used to invoke the toolbox API
@@ -92,7 +95,7 @@ def __init__(
         self.__required_authn_params = required_authn_params
         # map of authService -> token_getter
         self.__auth_service_token_getters = auth_service_token_getters
-        # map of parameter name to value or Callable
+        # map of parameter name to value (or callable that produces that value)
         self.__bound_parameters = bound_params
 
     def __copy(
@@ -120,18 +123,24 @@ def __copy(
                 a auth_service_token_getter set for them yet.
             auth_service_token_getters: A dict of authService -> token (or callables
                 that produce a token)
+            bound_params: A mapping of parameter names to bind to specific values or
+                callables that are called to produce values as needed.
 
         """
+        check = lambda val, default: val if val is not None else default
         return ToolboxTool(
-            session=session or self.__session,
-            base_url=base_url or self.__base_url,
-            name=name or self.__name__,
-            desc=desc or self.__desc,
-            params=params or self.__params,
-            required_authn_params=required_authn_params or self.__required_authn_params,
-            auth_service_token_getters=auth_service_token_getters
-            or self.__auth_service_token_getters,
-            bound_params=bound_params or self.__bound_parameters,
+            session=check(session, self.__session),
+            base_url=check(base_url, self.__base_url),
+            name=check(name, self.__name__),
+            desc=check(desc, self.__desc),
+            params=check(params, self.__params),
+            required_authn_params=check(
+                required_authn_params, self.__required_authn_params
+            ),
+            auth_service_token_getters=check(
+                auth_service_token_getters, self.__auth_service_token_getters
+            ),
+            bound_params=check(bound_params, self.__bound_parameters),
         )
 
     async def __call__(self, *args: Any, **kwargs: Any) -> str:
@@ -151,9 +160,12 @@ async def __call__(self, *args: Any, **kwargs: Any) -> str:
 
         # check if any auth services need to be specified yet
         if len(self.__required_authn_params) > 0:
-            req_auth_services = set(l for l in self.__required_authn_params.keys())
+            # Gather all the required auth services into a set
+            req_auth_services = set()
+            for s in self.__required_authn_params.values():
+                req_auth_services.update(s)
             raise Exception(
-                f"One of more of the following authn services are required to invoke this tool: {','.join(req_auth_services)}"
+                f"One or more of the following authn services are required to invoke this tool: {','.join(req_auth_services)}"
             )
 
         # validate inputs to this call using the signature
@@ -190,7 +202,7 @@ def add_auth_token_getters(
         auth_token_getters: Mapping[str, Callable[[], str]],
     ) -> "ToolboxTool":
         """
-        Registers a auth token getter function that is used for AuthServices when tools
+        Registers an auth token getter function that is used for AuthServices when tools
         are invoked.
 
         Args:
@@ -203,10 +215,12 @@ def add_auth_token_getters(
         """
 
         # throw an error if the authentication source is already registered
-        dupes = auth_token_getters.keys() & self.__auth_service_token_getters.keys()
-        if dupes:
+        existing_services = self.__auth_service_token_getters.keys()
+        incoming_services = auth_token_getters.keys()
+        duplicates = existing_services & incoming_services
+        if duplicates:
             raise ValueError(
-                f"Authentication source(s) `{', '.join(dupes)}` already registered in tool `{self.__name__}`."
+                f"Authentication source(s) `{', '.join(duplicates)}` already registered in tool `{self.__name__}`."
             )
 
         # create a read-only updated value for new_getters
@@ -215,7 +229,7 @@ def add_auth_token_getters(
         )
         # create a read-only updated for params that are still required
         new_req_authn_params = types.MappingProxyType(
-            filter_required_authn_params(
+            identify_required_authn_params(
                 self.__required_authn_params, auth_token_getters.keys()
             )
         )
@@ -226,7 +240,7 @@ def add_auth_token_getters(
         )
 
     def bind_parameters(
-        self, bound_params: Mapping[str, Callable[[], str]]
+        self, bound_params: Mapping[str, Union[Callable[[], Any], Any]]
     ) -> "ToolboxTool":
         """
         Binds parameters to values or callables that produce values.
@@ -238,9 +252,9 @@ def bind_parameters(
          Returns:
              A new ToolboxTool instance with the specified parameters bound.
         """
-        all_params = set(p.name for p in self.__params)
+        param_names = set(p.name for p in self.__params)
         for name in bound_params.keys():
-            if name not in all_params:
+            if name not in param_names:
                 raise Exception(f"unable to bind parameters: no parameter named {name}")
 
         new_params = []
@@ -254,27 +268,28 @@ def bind_parameters(
         )
 
 
-def filter_required_authn_params(
-    req_authn_params: Mapping[str, list[str]], auth_services: Iterable[str]
+def identify_required_authn_params(
+    req_authn_params: Mapping[str, list[str]], auth_service_names: Iterable[str]
 ) -> dict[str, list[str]]:
     """
-    Utility function for reducing 'req_authn_params' to a subset of parameters that
-    aren't supplied by a least one service in auth_services.
+    Identifies authentication parameters that are still required; because they
+        not covered by the provided `auth_service_names`.
 
-    Args:
-        req_authn_params: A mapping of parameter names to sets of required
-            authentication services.
-        auth_services: An iterable of authentication service names for which
-            token getters are available.
+        Args:
+            req_authn_params: A mapping of parameter names to sets of required
+                authentication services.
+            auth_service_names: An iterable of authentication service names for which
+                token getters are available.
 
     Returns:
         A new dictionary representing the subset of required authentication parameters
         that are not covered by the provided `auth_services`.
     """
-    req_params = {}
+    required_params = {}  # params that are still required with provided auth_services
     for param, services in req_authn_params.items():
-        # if we don't have a token_getter for any of the services required by the param, the param is still required
-        required = not any(s in services for s in auth_services)
+        # if we don't have a token_getter for any of the services required by the param,
+        # the param is still required
+        required = not any(s in services for s in auth_service_names)
         if required:
-            req_params[param] = services
-    return req_params
+            required_params[param] = services
+    return required_params