composio-llamaindex 0.0.1__tar.gz

composio-llamaindex-0.0.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: composio-llamaindex
+Version: 0.0.1
+Summary: Provides integrations skill with 50+ services in LlamaIndex
+Home-page: https://github.com/SamparkAI/llama-composio
+Author: Karan
+Author-email: karan@composio.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: jsonschema
+Requires-Dist: argparse
+Requires-Dist: llama_index
+Requires-Dist: nest_asyncio
+Requires-Dist: beaupy===3.7.2
+
+Composio <> Llama Indxex
+Use Composio to get an array of tools with your llamaindex agent.
+
+# Usage
+Inside your llamaindex codebase:
+```
+from composio_llama import ComposioToolset
+toolset = ComposioToolset(<token>)
+agent = OpenAIAgent.from_tools(toolset.to_tool_list(), llm=llm, verbose=True)
+...
+```
+
+

composio-llamaindex-0.0.1/README.md

@@ -0,0 +1,13 @@
+Composio <> Llama Indxex
+Use Composio to get an array of tools with your llamaindex agent.
+
+# Usage
+Inside your llamaindex codebase:
+```
+from composio_llama import ComposioToolset
+toolset = ComposioToolset(<token>)
+agent = OpenAIAgent.from_tools(toolset.to_tool_list(), llm=llm, verbose=True)
+...
+```
+
+

composio-llamaindex-0.0.1/composio-llamaindex

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+
+import argparse
+import webbrowser
+import requests
+import json
+import os
+from lib.storage import save_user_id, get_user_id
+import time
+from beaupy.spinners import Spinner, BARS
+
+COMPOSIO_TOKEN = 'ghp_1J2g3h4i5j6k7l8m9n0o33'
+BASE_URL = "https://hermes-production-6901.up.railway.app/api"
+
+def auth_tool(args):
+    user_id = get_user_id()
+    if user_id is None:
+        print("Error: No authenticated user found. Please authenticate first.")
+        return
+    print(f"Authenticating tool: {args.tool_name} for User ID: {user_id}")
+    url = f"{BASE_URL}/user/auth"
+    payload = json.dumps({
+      "endUserID": user_id,
+      "provider": {
+        "name": args.tool_name,
+        "scope": [
+          "user.email",
+          "user.profile"
+        ]
+      },
+      "redirectURIClient": "https://composio.dev/"
+    })
+    headers = {
+      'X_COMPOSIO_TOKEN': COMPOSIO_TOKEN,
+      'Content-Type': 'application/json'
+    }
+    response = requests.request("POST", url, headers=headers, data=payload)
+    if response.status_code == 200:
+        auth_url = response.json().get('providerAuthURL')
+        connReqID = response.json().get('connectionReqId')
+        print(f"Auth URL: {auth_url}")
+        print(f"Connection Request ID: {connReqID}")
+        webbrowser.open(auth_url)
+    else:
+        print("Failed to authenticate tool.")
+    spinner = Spinner(BARS, f"Authenticating you...")
+    spinner.start()
+
+    while True:  # Loop forever
+        status_check_url = f"{BASE_URL}/auth/{connReqID}/status"
+        status_payload = json.dumps({})
+        status_headers = {
+            'X_COMPOSIO_TOKEN': COMPOSIO_TOKEN,
+            'Content-Type': 'application/json',
+        }
+        response = requests.request("GET", status_check_url, headers=status_headers, data=status_payload)
+        status_data = response.json()
+        status = status_data.get('status')
+        if status == 'PENDING' or status == 'STARTED':
+            time.sleep(1)  # Wait for 5 seconds before retrying
+        else:
+            print(f"Authentication status: {status_data.get('status')}")
+            break
+
+    spinner.stop()
+
+def list_tools(args):
+    user_id = get_user_id()
+    if user_id is None:
+        print("Error: No authenticated user found. Please authenticate first.")
+        return
+    print(f"Fetching tools for User ID: {user_id}...")
+    url = f"{BASE_URL}/all_tools"
+    headers = {
+      'X_COMPOSIO_TOKEN': COMPOSIO_TOKEN,
+      'X_ENDUSER_ID': user_id
+    }
+    response = requests.post(url, headers=headers, json={
+        "skip": 0,
+        "limit": 1000,
+        "actions": True,
+        "triggers": False
+    })
+    if response.status_code == 200:
+        tools_data = response.json()
+        for tool in tools_data.get('tools', []):
+            print(f"Name: {tool['Name']}, Description: {tool['Description']}")
+            if args.auth and tool['Authentication']['isAuthenticated'] == "False":
+                print(f"Tool {tool['Name']} requires authentication.")
+    else:
+        print("Failed to fetch tools.")
+
+def auth(args):
+    if not args.email:
+        print("Error: Email ID is required for authentication.")
+        return
+    print(f"Authenticating {args.email}...")
+    url = f"{BASE_URL}/user/create/{args.email}"
+    headers = {
+      'X_COMPOSIO_TOKEN': COMPOSIO_TOKEN
+    }
+    response = requests.post(url, headers=headers)
+    if response.status_code == 200:
+        user_id = response.json().get('userId')
+        print(f"Authenticated successfully. User ID: {user_id}")
+        save_user_id(user_id)
+    else:
+        print("Authentication failed.")
+
+def main():
+    parser = argparse.ArgumentParser(description='Composio CLI')
+    subparsers = parser.add_subparsers(help='commands')
+
+    # Auth command
+    auth_parser = subparsers.add_parser('auth', help='Authenticate user')
+    auth_parser.add_argument('email', type=str, help='User email ID for authentication')
+    auth_parser.set_defaults(func=auth)
+
+    # List tools command
+    list_tools_parser = subparsers.add_parser('list_tools', help='List tools')
+    list_tools_parser.add_argument('--auth', action='store_true', help='List only authenticated tools')
+    list_tools_parser.set_defaults(func=list_tools)
+
+    # Auth tool command
+    auth_tool_parser = subparsers.add_parser('auth_tool', help='Authenticate a tool')
+    auth_tool_parser.add_argument('tool_name', type=str, help='Name of the tool to authenticate')
+    auth_tool_parser.set_defaults(func=auth_tool)
+
+    args = parser.parse_args()
+    if hasattr(args, 'func'):
+        args.func(args)
+    else:
+        parser.print_help()
+
+if __name__ == '__main__':
+    main()

composio-llamaindex-0.0.1/composio_llamaindex.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: composio-llamaindex
+Version: 0.0.1
+Summary: Provides integrations skill with 50+ services in LlamaIndex
+Home-page: https://github.com/SamparkAI/llama-composio
+Author: Karan
+Author-email: karan@composio.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: jsonschema
+Requires-Dist: argparse
+Requires-Dist: llama_index
+Requires-Dist: nest_asyncio
+Requires-Dist: beaupy===3.7.2
+
+Composio <> Llama Indxex
+Use Composio to get an array of tools with your llamaindex agent.
+
+# Usage
+Inside your llamaindex codebase:
+```
+from composio_llama import ComposioToolset
+toolset = ComposioToolset(<token>)
+agent = OpenAIAgent.from_tools(toolset.to_tool_list(), llm=llm, verbose=True)
+...
+```
+
+

composio-llamaindex-0.0.1/composio_llamaindex.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+composio-llamaindex
+pyproject.toml
+setup.py
+composio_llamaindex.egg-info/PKG-INFO
+composio_llamaindex.egg-info/SOURCES.txt
+composio_llamaindex.egg-info/dependency_links.txt
+composio_llamaindex.egg-info/requires.txt
+composio_llamaindex.egg-info/top_level.txt
+lib/__init__.py
+lib/composio_tool_spec.py
+lib/composio_toolset.py
+lib/openapi_tool_spec.py
+lib/storage.py
+lib/test_composio_tool_spec.py

composio-llamaindex-0.0.1/composio_llamaindex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

composio-llamaindex-0.0.1/composio_llamaindex.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests
+jsonschema
+argparse
+llama_index
+nest_asyncio
+beaupy===3.7.2

composio-llamaindex-0.0.1/composio_llamaindex.egg-info/top_level.txt

@@ -0,0 +1 @@
+lib

composio-llamaindex-0.0.1/lib/__init__.py

@@ -0,0 +1,3 @@
+from .composio_tool_spec import ComposioToolSpec
+from .composio_toolset import ComposioToolset
+from .openapi_tool_spec import APIToolSpec

composio-llamaindex-0.0.1/lib/composio_tool_spec.py

@@ -0,0 +1,86 @@
+import json
+from typing import Dict, Any, List, Union, Type
+import logging
+import requests
+from inspect import Parameter, Signature
+import types
+
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+
+logger = logging.getLogger(__name__)
+
+BASE_URL = "https://hermes-production-6901.up.railway.app/api"
+
+def map_composio_type_to_python(type_spec) -> Type:
+    if isinstance(type_spec, dict):
+        type_str = type_spec.get('type')
+        if type_str == 'string':
+            return str
+        elif type_str == 'number':
+            return float if '.' in str(type_spec.get('example', '')) else int
+        elif type_str == 'boolean':
+            return bool
+        # elif type_str == 'object':
+        #     properties = type_spec.get('properties', {})
+        #     required = type_spec.get('required', [])
+        #     return Dict[str, Union[*tuple(map_composio_type_to_python(prop) for prop in properties.values()), Any]] if properties else Dict[str, Any]
+        # elif type_str == 'array':
+        #     items_spec = type_spec.get('items', {})
+        #     return List[map_composio_type_to_python(items_spec)] if items_spec else List[Any]
+        # Add more mappings as necessary
+    # Fallback or default type
+    return Any  # Using Any for unspecified or complex types
+
+class ComposioToolSpec(BaseToolSpec):
+    """Generic tool spec based on composio_tool.json schema."""
+
+    def __init__(self, tool_schema: str, composio_token: str, user_id: str) -> None:
+        """Initialize with composio tool schema."""
+        self.tool_schema = json.loads(tool_schema)
+        self.spec_functions = self._generate_spec_functions()
+
+    def _generate_spec_functions(self) -> List[str]:
+        """Generate spec functions based on the tools actions."""
+        spec_functions = []
+        for tool in self.tool_schema.get("tools", []):
+            for action in tool.get("Actions", []):
+                function_name = tool["Name"] + "_" + action["Id"]
+                spec_functions.append(function_name)
+                input_params = action["Signature"]["Input"]["properties"]
+                print("input_params:", input_params)
+                setattr(self, function_name, self._create_function(tool["Name"], action["Id"], function_name, action["Description"], input_params, action["Signature"]["Input"].get("required", [])))
+        return spec_functions
+
+    def _create_function(self, tool_name: str, action_id: str, function_name: str, description: str, input_params: Dict[str, Any], required_params: List[str] = []):
+        """Create a function for the given action with typed arguments."""
+
+        # Function template that uses **kwargs to accept any arguments and performs an actual API call.
+        def template_function(**kwargs) -> Dict[str, Any]:
+            missing_params = [param for param in input_params if param not in kwargs and param in required_params]
+            if missing_params:
+                return {"error": f"Missing required params: {missing_params}"}
+            params = {param: kwargs[param] for param in input_params if param in kwargs}
+            logger.info(f"Executing action {action_id} with {params}")
+            
+            request_body = json.dumps(params)
+            response = requests.post(f"{BASE_URL}/{tool_name}/{action_id}", data=request_body, headers={'Content-Type': 'application/json'})
+            return response.json()
+
+        parameters = [
+            Parameter(
+                name=param, 
+                kind=Parameter.POSITIONAL_OR_KEYWORD, 
+                annotation=map_composio_type_to_python(input_params[param]), 
+                # default=Parameter.empty if param in required_params else Parameter.default
+            )
+            for param in input_params
+        ]
+        new_sig = Signature(parameters, return_annotation=Dict[str, Any])
+
+        func = types.FunctionType(template_function.__code__, globals(), name=function_name, closure=template_function.__closure__)
+
+        # Assign the new signature to the function.
+        func.__signature__ = new_sig
+        func.__doc__ = description
+
+        return func

composio-llamaindex-0.0.1/lib/composio_toolset.py

@@ -0,0 +1,43 @@
+import json
+import requests
+from .composio_tool_spec import ComposioToolSpec
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+from .storage import get_user_id
+from .composio_tool_spec import BASE_URL
+
+COMPOSIO_TOKEN = "ghp_1J2g3h4i5j6k7l8m9n0o33"
+
+class ComposioToolset(ComposioToolSpec):
+    def __init__(self):
+        self.user_id = get_user_id()
+        print(f"User ID: {self.user_id}")        
+        self.authenticated_tools = self.get_authenticated_tools(self.user_id)
+        tools_schema = json.dumps({"tools": self.authenticated_tools})  # Combine all tools into a single schema
+        super().__init__(tools_schema, COMPOSIO_TOKEN, self.user_id)
+
+    def get_authenticated_tools(self, user_id: str):
+        print("Fetching tools...")
+        if user_id is None:
+            raise Exception("No authenticated user found. Please authenticate first.")
+
+        url = f"{BASE_URL}/all_tools"
+        headers = {
+            'X_COMPOSIO_TOKEN': COMPOSIO_TOKEN,
+            'X_ENDUSER_ID': user_id
+        }
+        response = requests.post(url, headers=headers, json={
+            "skip": 0,
+            "limit": 1000,
+            "actions": True,
+            "triggers": False
+        })
+        if response.status_code == 200:
+            tools_data = response.json()
+            authenticated_tools = [
+                tool for tool in tools_data.get('tools', []) 
+                # if tool['Authentication']['isAuthenticated'] == "True"
+                ]
+            print("Authenticated tools:", authenticated_tools)
+            return authenticated_tools
+        else:
+            raise Exception("Failed to fetch tools.")

composio-llamaindex-0.0.1/lib/openapi_tool_spec.py

@@ -0,0 +1,99 @@
+import os
+import yaml
+import requests
+from inspect import Parameter, Signature
+from typing import List, Dict, Any
+import types
+import logging
+import nest_asyncio
+
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+
+nest_asyncio.apply()
+
+os.environ["OPENAI_API_KEY"] = "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"
+
+logger = logging.getLogger(__name__)
+
+def map_openapi_type_to_python(type_spec):
+    if isinstance(type_spec, dict):
+        type_str = type_spec.get('type')
+        if type_str == 'string':
+            return str
+        # Add more mappings as necessary
+    # Fallback or default type
+    return str  # or any other default type
+
+class APIToolSpec(BaseToolSpec):
+    """Generic API tool spec based on OpenAPI schema."""
+
+    def __init__(self, api_schema: str) -> None:
+        """Initialize with OpenAPI schema."""
+        self.api_schema = yaml.safe_load(api_schema)
+        self.spec_functions = self._generate_spec_functions()
+
+    def _generate_spec_functions(self) -> List[str]:
+        """Generate spec functions based on the OpenAPI paths."""
+        spec_functions = []
+        for path, methods in self.api_schema.get("paths", {}).items():
+            for method, details in methods.items():
+                print("details:", details)
+                function_name = self._generate_function_name(path, method)
+                spec_functions.append(function_name)
+                request_body_params = self._extract_request_body_params(details)
+                setattr(self, function_name, self._create_function(path, method, details.get("summary", ""), request_body_params))
+        return spec_functions
+
+    @staticmethod
+    def _generate_function_name(path: str, method: str) -> str:
+        """Generate a function name based on the path and method."""
+        clean_path = path.strip("/").replace("/", "_")
+        return f"{method}_{clean_path}"
+
+    @staticmethod
+    def _extract_request_body_params(details: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract request body parameters from the OpenAPI details."""
+        try:
+            return details['requestBody']['content']['application/json']['schema']['properties']
+        except KeyError:
+            return {}
+
+    def _create_function(self, path: str, method: str, description: str, request_body_params: Dict[str, Any]):
+        """Create a function for the given path and method with typed arguments."""
+
+        # Function template that uses **kwargs to accept any arguments and performs an actual API call.
+        def template_function(**kwargs) -> Dict[str, Any]:
+            missing_params = [param for param in request_body_params if param not in kwargs]
+            if missing_params:
+                return {"error": f"Missing required params: {missing_params}"}
+            params = {param: kwargs[param] for param in request_body_params}
+            logger.info(f"Executing {method.upper()} request to {path} with {params}")
+            
+            # Actual API call
+            full_url = f"{self.api_schema['servers'][0]['url']}{path}"
+            headers = {'Content-Type': 'application/json'}
+            if method.lower() == 'post':
+                response = requests.post(full_url, json=params, headers=headers)
+            elif method.lower() == 'get':
+                response = requests.get(full_url, params=params, headers=headers)
+            else:
+                return {"error": f"Method {method.upper()} not supported"}
+            return response.json()
+
+        # Create parameters with types for the new function's signature.
+        parameters = [
+            Parameter(name=param, kind=Parameter.POSITIONAL_OR_KEYWORD, annotation=map_openapi_type_to_python(type_))
+            for param, type_ in request_body_params.items()
+        ]
+
+        # Create a new signature from the parameters including the return annotation.
+        new_sig = Signature(parameters, return_annotation=Dict[str, Any])
+
+        # Use types.FunctionType to create a new function with the desired signature.
+        func = types.FunctionType(template_function.__code__, globals(), "function", closure=template_function.__closure__)
+        
+        # Assign the new signature to the function.
+        func.__signature__ = new_sig
+        func.__doc__ = description
+
+        return func

composio-llamaindex-0.0.1/lib/storage.py

@@ -0,0 +1,15 @@
+import json
+import os
+
+
+def save_user_id(user_id):
+    user_data = {'user_id': user_id}
+    with open('user_data.json', 'w') as outfile:
+        json.dump(user_data, outfile)
+
+def get_user_id():
+    if os.path.exists('user_data.json'):
+        with open('user_data.json', 'r') as infile:
+            user_data = json.load(infile)
+            return user_data.get('user_id')
+    return None

composio-llamaindex-0.0.1/lib/test_composio_tool_spec.py

@@ -0,0 +1,64 @@
+import unittest
+from .composio_tool_spec import ComposioToolSpec
+from inspect import signature
+from llama_index.agent.openai import OpenAIAgent
+from llama_index.llms.openai import OpenAI
+
+
+class TestComposioToolSpec(unittest.TestCase):
+    def setUp(self):
+        with open("lib/data/composio_tool.json", "r") as file:
+            self.tool_spec_json = file.read()
+        self.composio_tool_spec = ComposioToolSpec(self.tool_spec_json, "composio_token", "user_id")
+
+    def test_spec_functions_generation(self):
+        """Test if spec functions are generated correctly based on the tool schema."""
+        expected_functions = [
+            "Clickup_CreateFolderView",
+            "Slack_SendMessage",
+            "Slack_UpdateMessage",
+            "Slack_DeleteMessage",
+            "Github_CreateIssue"
+        ]
+        self.assertEqual(sorted(self.composio_tool_spec.spec_functions), sorted(expected_functions))
+
+    def test_function_signature(self):
+        """Test if a specific function has the correct signature based on the tool schema."""
+        send_message_func = getattr(self.composio_tool_spec, "Slack_SendMessage", None)
+        self.assertIsNotNone(send_message_func)
+        sign = send_message_func.__signature__
+        expected_params = ['channel', 'text']
+        actual_params = list(sign.parameters.keys())
+        self.assertEqual(expected_params, actual_params)
+        sig = signature(send_message_func)
+        expected_sig = "(channel: str, text: str) -> Dict[str, Any]"
+        self.assertEqual(str(sig), expected_sig)
+        description = send_message_func.__doc__
+        expected_desc = "Send a message to a channel or user"
+        self.assertEqual(description, expected_desc)
+
+    def test_missing_required_params(self):
+        """Test if the function correctly handles missing required parameters."""
+        send_message_func = getattr(self.composio_tool_spec, "Slack_SendMessage", None)
+        self.assertIsNotNone(send_message_func)
+        response = send_message_func(text="Hello, World!")
+        self.assertIn("error", response)
+        self.assertIn("Missing required params", response["error"])
+    
+    def test_nested_request_signature(self):
+        """Test if the function correctly handles nested request body parameters."""
+        create_issue_func = getattr(self.composio_tool_spec, "Clickup_CreateFolderView", None)
+        self.assertIsNotNone(create_issue_func)
+        sig = signature(create_issue_func)
+        print("sig:", sig)
+
+    def test_agent(self):
+        """Test the agent vy spec."""
+        llm = OpenAI(model="gpt-4-turbo-preview")
+        agent = OpenAIAgent.from_tools(self.composio_tool_spec.to_tool_list(), llm=llm, verbose=True)
+        agent.chat("Hello, World!")
+
+
+
+if __name__ == '__main__':
+    unittest.main()

composio-llamaindex-0.0.1/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+dynamic = ["classifiers", "version", "readme", "authors", "requires-python", "description"]
+dependencies = [
+    "requests",
+    "jsonschema",
+    "argparse",
+    "llama_index",
+    "nest_asyncio",
+    "beaupy===3.7.2"
+]
+name = "composio-llamaindex"
+
+[build-system]
+requires = [ "setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

composio-llamaindex-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

composio-llamaindex-0.0.1/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup
+import os 
+
+def get_current_dir():
+    return os.path.dirname(os.path.realpath(__file__))
+
+def resolve_paths(*paths):
+    return os.path.join(*paths)
+
+readme_path = resolve_paths(get_current_dir(), 'README.md')
+
+setup(
+    name = 'composio-llamaindex',
+    version = '0.0.1',
+    author = 'Karan',
+    author_email = 'karan@composio.dev',
+    description = 'Provides integrations skill with 50+ services in LlamaIndex',
+    long_description = open(readme_path).read(),
+    long_description_content_type = 'text/markdown',
+    url = 'https://github.com/SamparkAI/llama-composio',
+    classifiers = [
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: OS Independent'
+    ],
+    python_requires = '>=3.7',
+    include_package_data = True,
+    scripts = ['composio-llamaindex'],
+)