composio-langchain 0.1.40__tar.gz

composio_langchain-0.1.40/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: composio_langchain
+Version: 0.1.40
+Summary: Use Composio to get an array of tools with your LangChain agent.
+Home-page: https://github.com/SamparkAI/composio_sdk
+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: nest_asyncio
+Requires-Dist: langchain===0.1.0
+Requires-Dist: langchain-openai===0.0.2.post1
+Requires-Dist: langchainhub==0.1.15
+Requires-Dist: pydantic===2.6.4
+Requires-Dist: composio_core===0.1.40
+
+Composio <> LangChain
+Use Composio to get an array of tools with your LangChain agent.
+
+# Usage
+Inside your LangChain codebase:

composio_langchain-0.1.40/README.md

@@ -0,0 +1,5 @@
+Composio <> LangChain
+Use Composio to get an array of tools with your LangChain agent.
+
+# Usage
+Inside your LangChain codebase:

composio_langchain-0.1.40/composio_langchain/__init__.py

@@ -0,0 +1,2 @@
+from .composio_tool_spec import ComposioToolset, client
+from composio import Action, App

composio_langchain-0.1.40/composio_langchain/composio_tool_spec.py

@@ -0,0 +1,117 @@
+import types
+from typing import List, Annotated
+from .pydantic_utils import json_schema_to_model
+from langchain_core.tools import StructuredTool 
+from composio import ComposioCore, App, Action
+from typing import List
+from inspect import Parameter, Signature
+from pydantic import create_model, Field
+
+
+schema_type_python_type_dict = {
+    'string': str,
+    'number': float,
+    'boolean': bool,
+    'integer': int,
+}
+
+fallback_values = {
+    'string': "",
+    'number': 0.0,
+    'integer': 0.0,
+    'boolean': False,
+    'object': {},
+    'array': []
+}
+
+def pydantic_model_from_param_schema(param_schema):
+    fields = {}
+    param_title = param_schema['title'].replace(" ", "")
+    required_props = param_schema.get('required', [])
+    schema_params_object = param_schema.get('properties', {})
+    for prop_name, prop_info in schema_params_object.items():
+        prop_type = prop_info["type"]
+        prop_title = prop_info['title'].replace(" ", "")
+        prop_default = prop_info.get('default', fallback_values[prop_type])
+        if prop_type in schema_type_python_type_dict:
+            signature_prop_type = schema_type_python_type_dict[prop_type]
+        else:
+            signature_prop_type = pydantic_model_from_param_schema(prop_info)
+
+        if prop_name in required_props:
+            fields[prop_name] = (signature_prop_type, 
+                                Field(..., 
+                                    title=prop_title, 
+                                    description=prop_info.get('description', 
+                                                              prop_info.get('desc', 
+                                                                             prop_title))
+                                    ))
+        else:
+            fields[prop_name] = (signature_prop_type, 
+                                Field(title=prop_title, 
+                                    default=prop_default
+                                    ))
+    fieldModel = create_model(param_title, **fields)
+    return fieldModel
+        
+def get_signature_format_from_schema_params(
+        schema_params
+):
+    parameters = []
+    required_params = schema_params.get('required', [])
+    schema_params_object = schema_params.get('properties', {})
+    for param_name, param_schema in schema_params_object.items():
+        param_type = param_schema['type']
+        param_title = param_schema['title'].replace(" ", "")
+
+        if param_type in schema_type_python_type_dict:
+            signature_param_type = schema_type_python_type_dict[param_type]
+        else:
+            signature_param_type = pydantic_model_from_param_schema(param_schema)
+
+        param_default = param_schema.get('default', fallback_values[param_type])
+        param_annotation = Annotated[signature_param_type, param_schema.get('description', 
+                                                                            param_schema.get('desc',
+                                                                                             param_title))]
+        param = Parameter(
+            name=param_name,
+            kind=Parameter.POSITIONAL_OR_KEYWORD,
+            annotation=param_annotation,
+            default=Parameter.empty if param_name in required_params else param_default 
+        )
+        parameters.append(param)
+    return parameters
+
+    
+def ComposioTool(client : ComposioCore, action_schema: dict[str, any]) ->  StructuredTool:
+    name = action_schema["name"]
+    description = action_schema["description"]
+    parameters = json_schema_to_model(action_schema["parameters"])
+    appName = action_schema["appName"]
+    func_params = get_signature_format_from_schema_params(action_schema["parameters"])
+    action_signature = Signature(parameters=func_params)
+    placeholder_function = lambda **kwargs: client.execute_action(client.get_action_enum(name, appName), kwargs)
+    action_func = types.FunctionType(
+                                    placeholder_function.__code__, 
+                                    globals=globals(), 
+                                    name=name, 
+                                    closure=placeholder_function.__closure__
+                          )
+    action_func.__signature__ = action_signature
+    action_func.__doc__ = description
+    return StructuredTool.from_function(
+        name=name,
+        description=description,
+        args_schema=parameters,
+        return_schema=True,
+        # TODO use execute action here
+        func = action_func
+    )
+
+client = ComposioCore()
+
+def ComposioToolset(apps: List[App] = [], actions: List[Action] = []) -> List[StructuredTool]:
+    if len(apps) >0 and len(actions) > 0:
+        raise ValueError("You must provide either a list of tools or a list of actions, not both")
+    actions_list = client.sdk.get_list_of_actions(apps, actions)
+    return [ComposioTool(client, action) for action in actions_list]

composio_langchain-0.1.40/composio_langchain/pydantic_utils.py

@@ -0,0 +1,91 @@
+from langchain.pydantic_v1 import BaseModel, Field, create_model
+from typing import Any, Dict, List, Optional, Type
+
+def json_schema_to_model(json_schema: Dict[str, Any]) -> Type[BaseModel]:
+    """
+    Converts a JSON schema to a Pydantic BaseModel class.
+
+    Args:
+        json_schema: The JSON schema to convert.
+
+    Returns:
+        A Pydantic BaseModel class.
+    """
+
+    # Extract the model name from the schema title.
+    model_name = json_schema.get('title')
+
+    # Extract the field definitions from the schema properties.
+    field_definitions = {
+        name: json_schema_to_pydantic_field(name, prop, json_schema.get('required', []) )
+        for name, prop in json_schema.get('properties', {}).items()
+    }
+
+    # Create the BaseModel class using create_model().
+    return create_model(model_name, **field_definitions)
+
+def json_schema_to_pydantic_field(name: str, json_schema: Dict[str, Any], required: List[str]) -> Any:
+    """
+    Converts a JSON schema property to a Pydantic field definition.
+
+    Args:
+        name: The field name.
+        json_schema: The JSON schema property.
+
+    Returns:
+        A Pydantic field definition.
+    """
+
+    # Get the field type.
+    type_ = json_schema_to_pydantic_type(json_schema)
+
+    # Get the field description.
+    description = json_schema.get('description')
+
+    # Get the field examples.
+    examples = json_schema.get('examples', [])
+
+    # Create a Field object with the type, description, and examples.
+    # The 'required' flag will be set later when creating the model.
+    return (type_, Field(description=description, examples=examples, default=... if name in required else None))
+
+def json_schema_to_pydantic_type(json_schema: Dict[str, Any]) -> Any:
+    """
+    Converts a JSON schema type to a Pydantic type.
+
+    Args:
+        json_schema: The JSON schema to convert.
+
+    Returns:
+        A Pydantic type.
+    """
+
+    type_ = json_schema.get('type')
+
+    if type_ == 'string':
+        return str
+    elif type_ == 'integer':
+        return int
+    elif type_ == 'number':
+        return float
+    elif type_ == 'boolean':
+        return bool
+    elif type_ == 'array':
+        items_schema = json_schema.get('items')
+        if items_schema:
+            item_type = json_schema_to_pydantic_type(items_schema)
+            return List[item_type]
+        else:
+            return List
+    elif type_ == 'object':
+        # Handle nested models.
+        properties = json_schema.get('properties')
+        if properties:
+            nested_model = json_schema_to_model(json_schema)
+            return nested_model
+        else:
+            return Dict
+    elif type_ == 'null':
+        return Optional[Any]  # Use Optional[Any] for nullable fields
+    else:
+        raise ValueError(f'Unsupported JSON schema type: {type_}')

composio_langchain-0.1.40/composio_langchain.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: composio_langchain
+Version: 0.1.40
+Summary: Use Composio to get an array of tools with your LangChain agent.
+Home-page: https://github.com/SamparkAI/composio_sdk
+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: nest_asyncio
+Requires-Dist: langchain===0.1.0
+Requires-Dist: langchain-openai===0.0.2.post1
+Requires-Dist: langchainhub==0.1.15
+Requires-Dist: pydantic===2.6.4
+Requires-Dist: composio_core===0.1.40
+
+Composio <> LangChain
+Use Composio to get an array of tools with your LangChain agent.
+
+# Usage
+Inside your LangChain codebase:

composio_langchain-0.1.40/composio_langchain.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+composio_langchain/__init__.py
+composio_langchain/composio_tool_spec.py
+composio_langchain/pydantic_utils.py
+composio_langchain.egg-info/PKG-INFO
+composio_langchain.egg-info/SOURCES.txt
+composio_langchain.egg-info/dependency_links.txt
+composio_langchain.egg-info/requires.txt
+composio_langchain.egg-info/top_level.txt

composio_langchain-0.1.40/composio_langchain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

composio_langchain-0.1.40/composio_langchain.egg-info/requires.txt

@@ -0,0 +1,9 @@
+requests
+jsonschema
+argparse
+nest_asyncio
+langchain===0.1.0
+langchain-openai===0.0.2.post1
+langchainhub==0.1.15
+pydantic===2.6.4
+composio_core===0.1.40

composio_langchain-0.1.40/composio_langchain.egg-info/top_level.txt

@@ -0,0 +1 @@
+composio_langchain

composio_langchain-0.1.40/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+dynamic = ["classifiers", "version", "readme", "authors", "requires-python", "description"]
+dependencies = [
+    "requests",
+    "jsonschema",
+    "argparse",
+    "nest_asyncio",
+    "langchain===0.1.0",
+    "langchain-openai===0.0.2.post1",
+    "langchainhub==0.1.15",
+    "pydantic===2.6.4",
+    "composio_core===0.1.40"
+]
+name = "composio_langchain"
+
+[build-system]
+requires = [ "setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

composio_langchain-0.1.40/setup.cfg

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

composio_langchain-0.1.40/setup.py

@@ -0,0 +1,31 @@
+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_langchain",
+    version="0.1.40",
+    author="Karan",
+    author_email="karan@composio.dev",
+    description="Use Composio to get an array of tools with your LangChain agent.",
+    long_description=open(readme_path).read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/SamparkAI/composio_sdk",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+    include_package_data=True,
+)