versionhq 1.1.4.4__py3-none-any.whl

versionhq/tool/composio.py

@@ -0,0 +1,102 @@
+import os
+from dotenv import load_dotenv
+from typing import Any, Callable, Type, get_args, get_origin
+from composio import ComposioToolSet, Action, App
+
+
+load_dotenv(override=True)
+DEFAULT_REDIRECT_URL = os.environ.get("DEFAULT_REDIRECT_URL")
+DEFAULT_APP_NAME = "hubspot"
+DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID")
+
+
+def connect(app_name: str = DEFAULT_APP_NAME, user_id: str = DEFAULT_USER_ID, redirect_url: str = DEFAULT_REDIRECT_URL, *args, **kwargs):
+    """
+    Connect with the data pipelines or destination services.
+    """
+
+    composio_toolset = ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"))
+
+
+    if not user_id:
+        return None
+
+    auth_scheme = "OAUTH2"
+    connection_request = composio_toolset.initiate_connection(
+        app=app_name,
+        redirect_url = redirect_url, # user comes here after oauth flow
+        entity_id=user_id,
+        auth_scheme=auth_scheme,
+    )
+
+    print(connection_request.connectedAccountId,connection_request.connectionStatus)
+    print(connection_request.redirectUrl)
+
+
+
+    # connection_request_id = "connection_request_id" # replace connection_request_id from earlier response
+    # # validate the connection is active
+    # connected_account = composio_toolset.get_connected_account(id=connection_request_id)
+    # print(connected_account.status)  # should be 
+
+
+# @action(toolname="hubspot")
+# def deploy_on_hubspot(param1: str, param2: str, execute_request: Callable) -> str:
+#     """
+#     Deploy the messaging workflow on the third-party service using Composio.
+#     List of the services: https://composio.dev/tools?category=marketing
+
+#     my custom action description which will be passed to llm
+
+#     :param param1: param1 description which will be passed to llm
+#     :param param2: param2 description which will be passed to llm
+#     :return info: return description
+#     """
+
+#     response = execute_request(
+#         "/my_action_endpoint",
+#         "GET",
+#         {} # body can be added here
+#     )    # execute requests by appending credentials to the request
+#     return str(response) # complete auth dict is available for local use if needed
+
+    
+#     toolset = ComposioToolSet(entity_id=D)
+#     tools = composio_toolset.get_tools(actions=[deploy_on_hubspot])
+
+
+# rag_tools = composio_toolset.get_tools(
+#     apps=[App.RAGTOOL],
+#     actions=[
+#         Action.FILETOOL_LIST_FILES,
+#         Action.FILETOOL_CHANGE_WORKING_DIRECTORY,
+#         Action.FILETOOL_FIND_FILE,
+#     ],
+# )
+
+# rag_query_tools = composio_toolset.get_tools(
+#     apps=[App.RAGTOOL],
+# )
+
+# # can pass multiple actions
+# tools = composio_toolset.get_tools(
+#     actions=[Action.GITHUB_CREATE_AN_ISSUE]
+# )
+
+# rag_tools = composio_toolset.get_tools(
+#     apps=[App.RAGTOOL],
+#     actions=[
+#         Action.FILETOOL_LIST_FILES,
+#         Action.FILETOOL_CHANGE_WORKING_DIRECTORY,
+#         Action.FILETOOL_FIND_FILE,
+#     ],
+# )
+
+# rag_query_tools = composio_toolset.get_tools(
+#     apps=[App.RAGTOOL],
+# )
+
+
+if __name__ == "__main__":
+    connect()
+

versionhq/tool/decorator.py

@@ -0,0 +1,40 @@
+from typing import Callable
+from pydantic import BaseModel
+from versionhq.tool.model import Tool
+
+
+def tool(*args):
+    """
+    Decorator to create a tool from a function.
+    """
+
+    def create_tool(tool_name: str) -> Callable:
+
+        def _make_tool(f: Callable) -> Tool:
+            if f.__doc__ is None:
+                raise ValueError("Function must have a docstring")
+            if f.__annotations__ is None:
+                raise ValueError("Function must have type annotations")
+
+            class_name = "".join(tool_name.split()).title()
+            args_schema = type(
+                class_name,
+                (BaseModel,),
+                {
+                    "__annotations__": {
+                        k: v for k, v in f.__annotations__.items() if k != "return"
+                    },
+                },
+            )
+            return Tool(name=tool_name, func=f, args_schema=args_schema)
+
+        return _make_tool
+
+    if len(args) == 1 and callable(args[0]):
+        return create_tool(args[0].__name__)(args[0])
+
+    elif len(args) == 1 and isinstance(args[0], str):
+        return create_tool(args[0])
+
+    else:
+        raise ValueError("Invalid arguments")

versionhq/tool/model.py

@@ -0,0 +1,220 @@
+from abc import ABC
+from inspect import signature
+from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
+from pydantic import (
+    InstanceOf,
+    BaseModel,
+    ConfigDict,
+    Field,
+    create_model,
+    field_validator,
+    model_validator,
+)
+
+from versionhq._utils.cache_handler import CacheHandler
+
+
+class Tool(ABC, BaseModel):
+    """
+    The function that will be executed when the tool is called.
+    """
+
+    class ArgsSchema(BaseModel):
+        pass
+
+    model_config = ConfigDict()
+    name: str = Field(default=None)
+    func: Callable = Field(default=None)
+    cache_function: Callable = lambda _args=None, _result=None: True
+    args_schema: Type[BaseModel] = Field(default_factory=ArgsSchema)
+    tool_handler: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="store tool_handler to record the usage of this tool. to avoid circular import, set as Dict format",
+    )
+
+    @property
+    def description(self):
+        args_schema = {
+            name: {
+                "description": field.description,
+                "type": Tool._get_arg_annotations(field.annotation),
+            }
+            for name, field in self.args_schema.model_fields.items()
+        }
+        return f"Tool Name: {self.name}\nTool Arguments: {args_schema}\nTool Description: {self.description}"
+
+    @field_validator("args_schema", mode="before")
+    @classmethod
+    def _default_args_schema(cls, v: Type[BaseModel]) -> Type[BaseModel]:
+        if not isinstance(v, cls.ArgsSchema):
+            return v
+
+        return type(
+            f"{cls.__name__}Schema",
+            (BaseModel,),
+            {
+                "__annotations__": {
+                    k: v for k, v in cls._run.__annotations__.items() if k != "return"
+                },
+            },
+        )
+
+    @model_validator(mode="after")
+    def set_up_tool_handler_instance(self):
+        from versionhq.tool.tool_handler import ToolHandler
+
+        if self.tool_handler:
+            ToolHandler(**self.tool_handler)
+
+        return self
+
+    @staticmethod
+    def _get_arg_annotations(annotation: type[Any] | None) -> str:
+        if annotation is None:
+            return "None"
+
+        origin = get_origin(annotation)
+        args = get_args(annotation)
+
+        if origin is None:
+            return (
+                annotation.__name__
+                if hasattr(annotation, "__name__")
+                else str(annotation)
+            )
+
+        if args:
+            args_str = ", ".join(Tool._get_arg_annotations(arg) for arg in args)
+            return f"{origin.__name__}[{args_str}]"
+
+        return origin.__name__
+
+    def _set_args_schema(self):
+        if self.args_schema is None:
+            class_name = f"{self.__class__.__name__}Schema"
+
+            self.args_schema = type(
+                class_name,
+                (BaseModel,),
+                {
+                    "__annotations__": {
+                        k: v
+                        for k, v in self._run.__annotations__.items()
+                        if k != "return"
+                    },
+                },
+            )
+
+    @classmethod
+    def from_composio(
+        cls, func: Callable = None, tool_name: str = "Composio tool"
+    ) -> "Tool":
+        """
+        Create a Pydantic BaseModel instance from Composio tools, ensuring the Tool instance has a func to be executed.
+        Refer to the `args_schema` from the func signature if any. Else, create an `args_schema`.
+        """
+
+        if not func:
+            raise ValueError("Params must have a callable 'func' attribute.")
+
+        # args_schema = getattr(tool, "args_schema", None)
+        args_fields = {}
+        func_signature = signature(func)
+        annotations = func_signature.parameters
+        for name, param in annotations.items():
+            if name != "self":
+                param_annotation = (
+                    param.annotation if param.annotation != param.empty else Any
+                )
+                field_info = Field(default=..., description="")
+                args_fields[name] = (param_annotation, field_info)
+
+        args_schema = (
+            create_model(f"{tool_name}Input", **args_fields)
+            if args_fields
+            else create_model(f"{tool_name}Input", __base__=BaseModel)
+        )
+
+        return cls(name=tool_name, func=func, args_schema=args_schema)
+
+    def run(self, *args, **kwargs) -> Any:
+        """
+        Use the tool.
+        When the tool has a func, execute the func and return any response from the func.
+        Else,
+
+        The response will be cascaded to the Task and stored in the TaskOutput.
+        """
+
+        print(f"Using the tool: {self.name}")
+        result = None
+
+        if self.func is not None:
+            result = self.func(
+                *args, **kwargs
+            )  #! REFINEME - format - json dict, pydantic, raw
+
+        else:
+            acceptable_args = self.args_schema.model_json_schema()["properties"].keys()
+            arguments = {k: v for k, v in kwargs.items() if k in acceptable_args}
+            tool_called = ToolCalled(tool=self, arguments=arguments)
+
+            if self.tool_handler:
+                if self.tool_handler.has_called_before(tool_called):
+                    self.tool_handler.error = "Agent execution error."
+
+                elif self.tool_handler.cache:
+                    result = self.tools_handler.cache.read(
+                        tool=tool_called.tool.name, input=tool_called.arguments
+                    )
+                    # from_cache = result is not None
+                    if result is None:
+                        result = self.invoke(input=arguments)
+
+            else:
+                from versionhq.tool.tool_handler import ToolHandler
+
+                tool_handler = ToolHandler(
+                    last_used_tool=tool_called, cache=CacheHandler()
+                )
+                self.tool_handler = tool_handler
+                result = self.invoke(input=arguments)
+
+        return result
+
+
+class ToolCalled(BaseModel):
+    """
+    Store the tool called and any kwargs used.
+    """
+
+    tool: InstanceOf[Tool] = Field(
+        ..., description="store the tool instance to be called."
+    )
+    arguments: Optional[Dict[str, Any]] = Field(
+        ..., description="kwargs passed to the tool"
+    )
+
+
+class InstructorToolCalled(BaseModel):
+    tool: InstanceOf[Tool] = Field(
+        ..., description="store the tool instance to be called."
+    )
+    arguments: Optional[Dict[str, Any]] = Field(
+        ..., description="kwargs passed to the tool"
+    )
+
+
+class CacheTool(BaseModel):
+    """
+    Default tools to hit the cache.
+    """
+
+    name: str = "Hit Cache"
+    cache_handler: CacheHandler = Field(default_factory=CacheHandler)
+
+    def hit_cache(self, key):
+        split = key.split("tool:")
+        tool = split[1].split("|input:")[0].strip()
+        tool_input = split[1].split("|input:")[1].strip()
+        return self.cache_handler.read(tool, tool_input)

versionhq/tool/tool_handler.py

@@ -0,0 +1,47 @@
+from typing import Any, Optional, Union
+from versionhq.tool.model import ToolCalled, InstructorToolCalled, CacheTool
+from versionhq._utils.cache_handler import CacheHandler
+
+
+class ToolHandler:
+    """
+    Record the tool usage by ToolCalled instance with cache and error recording.
+    Use as a callback function.
+    """
+
+    last_used_tool: ToolCalled = {}
+    cache: Optional[CacheHandler]
+    error: Optional[str]
+
+    def __init__(self, cache_handler: Optional[CacheHandler] = None):
+        """
+        Initialize the callback handler.
+        """
+
+        self.cache = cache_handler
+        self.last_used_tool = {}
+
+    def record_last_tool_used(
+        self,
+        last_used_tool: Union[ToolCalled, InstructorToolCalled],
+        output: str,
+        should_cache: bool = True,
+    ) -> Any:
+        self.last_used_tool = last_used_tool
+
+        if self.cache and should_cache and last_used_tool.tool_name != CacheTool().name:
+            self.cache.add(
+                last_used_tool.tool_name,
+                input.last_used_tool.arguments,
+                output=output,
+            )
+
+    def has_called_before(self, tool_called: ToolCalled = None) -> bool:
+        if tool_called is None or not self.last_used_tool:
+            return False
+
+        if tool_called := self.last_used_tool:
+            return bool(
+                (tool_called.tool.name == self.last_used_tool.tool.name)
+                and (tool_called.arguments == self.last_used_tool.arguments)
+            )

versionhq-1.1.4.4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Version IO Sdn. Bhd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.