composio-pydanticai 0.7.7__tar.gz

composio_pydanticai-0.7.7/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.2
+Name: composio_pydanticai
+Version: 0.7.7
+Summary: Use Composio to get array of strongly typed tools for Pydantic AI
+Home-page: https://github.com/ComposioHQ/composio
+Author: Siddharth
+Author-email: tech@composio.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: composio_core<0.8.0,>=0.7.0
+Requires-Dist: pydantic-ai
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## 🚀🔗 Leveraging Pydantic-AI with Composio
+
+Integrate Pydantic-AI agents with Composio to enable direct interaction with external applications, enhancing their capabilities through strongly-typed, validated tools.
+
+### Objective
+
+- **Automate GitHub operations** using type-safe instructions via Pydantic-AI's Tool system.
+- Demonstrate how to use Composio's tools with Pydantic-AI's strict type checking and validation.
+
+### Installation and Setup
+
+Install the necessary packages and connect your GitHub account to enable agent interactions with GitHub:
+
+```bash
+# Install Composio Pydantic-AI package
+pip install composio-pydanticai
+
+# Connect your GitHub account
+composio add github
+
+# View available applications you can connect with
+composio apps
+```
+
+### Usage Steps
+
+#### 1. Import Required Packages
+
+Set up your environment by importing the necessary components from Composio & Pydantic-AI:
+
+```python
+from dotenv import load_dotenv
+import os
+
+from composio import Action
+from composio_pydanticai import ComposioToolSet
+from pydantic_ai import Agent
+```
+
+#### 2. Initialize Tools with Composio
+
+Configure and fetch GitHub tools provided by Composio:
+
+```python
+# Initialize toolset
+composio_toolset = ComposioToolSet()
+
+# Configure max retries for specific tools
+max_retries = {
+    Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,    # More retries for starring
+    Action.GITHUB_CREATE_REPOSITORY: 2   # Fewer retries for creation
+}
+
+# Get GitHub tools with retry configuration
+tools = composio_toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+    max_retries=max_retries,
+    default_max_retries=3  # Default retries for tools not specified in max_retries
+)
+```
+
+The `max_retries` parameter lets you configure retry attempts per tool, with a default fallback for unspecified tools.
+
+#### 3. Set Up the Pydantic-AI Agent
+
+Create and configure a Pydantic-AI agent with the Composio tools:
+
+```python
+# Create an agent with the tools
+agent = Agent(
+    model="openai:gpt-4-turbo",  # Using a known model name
+    tools=tools,
+    system_prompt="""You are an AI agent that helps users interact with GitHub.
+    You can perform various GitHub operations using the available tools.
+    When given a task, analyze it and use the appropriate tool to complete it.""",
+)
+```
+
+#### 4. Execute Tasks
+
+Run your agent with specific tasks:
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Run the agent synchronously
+result = agent.run_sync(task)
+print("Result:", result.data)
+print("Trace:\n\n", result.all_messages())
+```
+
+### Key Features
+
+1. **Type Safety**: Leverages Pydantic-AI's strong type system for parameter validation
+2. **Async Support**: Built-in support for asynchronous operations
+3. **Error Handling**: Proper validation error handling with detailed feedback
+4. **Tool Context**: Automatic context injection for tool execution
+5. **Flexible Retry Configuration**: Configure retries per tool with fallback defaults
+
+### Advanced Usage
+
+The integration supports more complex scenarios:
+
+```python
+# Using multiple tools
+tools = composio_toolset.get_tools(
+    actions=[
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER,
+        Action.GITHUB_CREATE_REPOSITORY
+    ],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,
+        Action.GITHUB_CREATE_REPOSITORY: 2
+    }
+)
+
+# Filtering tools by tags
+tools = composio_toolset.get_tools(
+    tags=["github", "repository"],
+    default_max_retries=3
+)
+
+# Using app-specific tools
+tools = composio_toolset.get_tools(
+    apps=[App.GITHUB],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5
+    }
+)
+```
+
+### Best Practices
+
+1. Always use proper type hints in your code
+2. Handle validation errors appropriately
+3. Use the latest version of both Pydantic-AI and Composio
+4. Leverage async operations for better performance
+5. Keep your API keys secure using environment variables
+6. Configure retries based on the specific needs of each tool

composio_pydanticai-0.7.7/README.md

@@ -0,0 +1,140 @@
+## 🚀🔗 Leveraging Pydantic-AI with Composio
+
+Integrate Pydantic-AI agents with Composio to enable direct interaction with external applications, enhancing their capabilities through strongly-typed, validated tools.
+
+### Objective
+
+- **Automate GitHub operations** using type-safe instructions via Pydantic-AI's Tool system.
+- Demonstrate how to use Composio's tools with Pydantic-AI's strict type checking and validation.
+
+### Installation and Setup
+
+Install the necessary packages and connect your GitHub account to enable agent interactions with GitHub:
+
+```bash
+# Install Composio Pydantic-AI package
+pip install composio-pydanticai
+
+# Connect your GitHub account
+composio add github
+
+# View available applications you can connect with
+composio apps
+```
+
+### Usage Steps
+
+#### 1. Import Required Packages
+
+Set up your environment by importing the necessary components from Composio & Pydantic-AI:
+
+```python
+from dotenv import load_dotenv
+import os
+
+from composio import Action
+from composio_pydanticai import ComposioToolSet
+from pydantic_ai import Agent
+```
+
+#### 2. Initialize Tools with Composio
+
+Configure and fetch GitHub tools provided by Composio:
+
+```python
+# Initialize toolset
+composio_toolset = ComposioToolSet()
+
+# Configure max retries for specific tools
+max_retries = {
+    Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,    # More retries for starring
+    Action.GITHUB_CREATE_REPOSITORY: 2   # Fewer retries for creation
+}
+
+# Get GitHub tools with retry configuration
+tools = composio_toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+    max_retries=max_retries,
+    default_max_retries=3  # Default retries for tools not specified in max_retries
+)
+```
+
+The `max_retries` parameter lets you configure retry attempts per tool, with a default fallback for unspecified tools.
+
+#### 3. Set Up the Pydantic-AI Agent
+
+Create and configure a Pydantic-AI agent with the Composio tools:
+
+```python
+# Create an agent with the tools
+agent = Agent(
+    model="openai:gpt-4-turbo",  # Using a known model name
+    tools=tools,
+    system_prompt="""You are an AI agent that helps users interact with GitHub.
+    You can perform various GitHub operations using the available tools.
+    When given a task, analyze it and use the appropriate tool to complete it.""",
+)
+```
+
+#### 4. Execute Tasks
+
+Run your agent with specific tasks:
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Run the agent synchronously
+result = agent.run_sync(task)
+print("Result:", result.data)
+print("Trace:\n\n", result.all_messages())
+```
+
+### Key Features
+
+1. **Type Safety**: Leverages Pydantic-AI's strong type system for parameter validation
+2. **Async Support**: Built-in support for asynchronous operations
+3. **Error Handling**: Proper validation error handling with detailed feedback
+4. **Tool Context**: Automatic context injection for tool execution
+5. **Flexible Retry Configuration**: Configure retries per tool with fallback defaults
+
+### Advanced Usage
+
+The integration supports more complex scenarios:
+
+```python
+# Using multiple tools
+tools = composio_toolset.get_tools(
+    actions=[
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER,
+        Action.GITHUB_CREATE_REPOSITORY
+    ],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,
+        Action.GITHUB_CREATE_REPOSITORY: 2
+    }
+)
+
+# Filtering tools by tags
+tools = composio_toolset.get_tools(
+    tags=["github", "repository"],
+    default_max_retries=3
+)
+
+# Using app-specific tools
+tools = composio_toolset.get_tools(
+    apps=[App.GITHUB],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5
+    }
+)
+```
+
+### Best Practices
+
+1. Always use proper type hints in your code
+2. Handle validation errors appropriately
+3. Use the latest version of both Pydantic-AI and Composio
+4. Leverage async operations for better performance
+5. Keep your API keys secure using environment variables
+6. Configure retries based on the specific needs of each tool

composio_pydanticai-0.7.7/composio_pydanticai/__init__.py

@@ -0,0 +1,14 @@
+from composio_pydanticai.toolset import ComposioToolSet
+
+from composio import Action, App, Tag, Trigger, WorkspaceType, action
+
+
+__all__ = (
+    "Action",
+    "App",
+    "Tag",
+    "Trigger",
+    "WorkspaceType",
+    "action",
+    "ComposioToolSet",
+)

composio_pydanticai-0.7.7/composio_pydanticai/toolset.py

@@ -0,0 +1,199 @@
+import types
+import typing as t
+from inspect import Parameter, Signature
+
+from pydantic import ValidationError
+from pydantic_ai.tools import Tool
+
+from composio import Action, ActionType, AppType, TagType
+from composio.tools import ComposioToolSet as BaseComposioToolSet
+from composio.tools.toolset import ProcessorsType
+from composio.utils.pydantic import parse_pydantic_error
+from composio.utils.shared import get_signature_format_from_schema_params
+
+
+class ComposioToolSet(
+    BaseComposioToolSet,
+    runtime="pydantic_ai",
+    description_char_limit=1024,
+    action_name_char_limit=64,
+):
+    """
+    Composio toolset for Pydantic-AI framework.
+    Example:
+    ```python
+    from dotenv import load_dotenv  # type: ignore
+    import os
+
+    from composio import Action
+    from composio_pydanticai import ComposioToolSet
+    from pydantic_ai import Agent
+
+
+    # Load environment variables from .env
+    load_dotenv(".env")
+
+    # Initialize toolset
+    composio_toolset = ComposioToolSet()
+
+    # Configure max retries for specific tools
+    max_retries = {
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,
+        Action.GITHUB_CREATE_REPOSITORY: 2
+    }
+
+    # Get GitHub tools with retry configuration
+    tools = composio_toolset.get_tools(
+        actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+        max_retries=max_retries,
+        default_max_retries=3
+    )
+
+    # Create an agent with the tools
+    agent = Agent(
+        model="openai:gpt-4o",  # Using a known model name
+        tools=tools,
+        system_prompt="You are an AI agent that helps users interact with GitHub.
+        You can perform various GitHub operations using the available tools.
+        When given a task, analyze it and use the appropriate tool to complete it.",
+    )
+
+    # Define task
+    task = "Star a repo composiohq/composio on GitHub"
+    # Run the agent
+    result = agent.run_sync(task)
+    ```
+    """
+
+    def _wrap_action(
+        self,
+        action: str,
+        description: str,
+        schema_params: t.Dict[str, t.Any],
+        entity_id: t.Optional[str] = None,
+    ):
+        """Create a wrapper function for the Composio action."""
+
+        async def function(ctx, **kwargs):  # pylint: disable=unused-argument
+            """Wrapper function for composio action."""
+            try:
+                return self.execute_action(
+                    action=Action(value=action),
+                    params=kwargs,
+                    entity_id=entity_id or self.entity_id,
+                    _check_requested_actions=True,
+                )
+            except ValidationError as e:
+                # Return a structured error response that the agent can understand
+                return {
+                    "error": parse_pydantic_error(e),
+                    "successful": False,
+                    "data": None,
+                }
+
+        # Create function with type hints
+        action_func = types.FunctionType(
+            function.__code__,
+            globals=globals(),
+            name=action,
+            closure=function.__closure__,
+        )
+
+        # Get parameters using shared utility
+        parameters = get_signature_format_from_schema_params(schema_params)
+
+        # Add type hints
+        params = {param.name: param.annotation for param in parameters}
+        action_func.__annotations__ = {
+            "ctx": "RunContext[None]",
+            "return": t.Dict,
+            **params,
+        }
+
+        # Create signature with context parameter first
+        ctx_param = Parameter(
+            name="ctx",
+            kind=Parameter.POSITIONAL_OR_KEYWORD,
+            annotation="RunContext[None]",
+        )
+        action_func.__signature__ = Signature(parameters=[ctx_param] + parameters)  # type: ignore
+        action_func.__doc__ = description
+
+        return action_func
+
+    def _wrap_tool(
+        self,
+        schema: t.Dict[str, t.Any],
+        entity_id: t.Optional[str] = None,
+        max_retries: t.Optional[int] = None,
+    ) -> Tool:
+        """Wraps composio tool as Pydantic-AI Tool object."""
+        action = schema["name"]
+        description = schema["description"]
+        parameters = schema["parameters"]
+
+        # Create the wrapper function
+        action_func = self._wrap_action(
+            action=action,
+            description=description,
+            schema_params=parameters,
+            entity_id=entity_id,
+        )
+
+        return Tool(
+            function=action_func,
+            name=action,
+            description=description,
+            takes_ctx=True,
+            max_retries=max_retries,
+            docstring_format="auto",
+        )
+
+    def get_tools(
+        self,
+        actions: t.Optional[t.Sequence[ActionType]] = None,
+        apps: t.Optional[t.Sequence[AppType]] = None,
+        tags: t.Optional[t.List[TagType]] = None,
+        entity_id: t.Optional[str] = None,
+        *,
+        max_retries: t.Optional[t.Dict[Action, int]] = None,
+        default_max_retries: int = 3,
+        processors: t.Optional[ProcessorsType] = None,
+        check_connected_accounts: bool = True,
+    ) -> t.Sequence[Tool]:
+        """
+        Get composio tools wrapped as Pydantic-AI Tool objects.
+
+        Args:
+            actions: Optional sequence of actions to get tools for
+            apps: Optional sequence of apps to get tools for
+            tags: Optional list of tags to filter tools by
+            entity_id: Optional entity ID to use for the tools
+            max_retries: Optional dict mapping Action enum values to their max retry counts
+            default_max_retries: Default max retries for tools not specified in max_retries
+            processors: Optional processors to apply to the tools
+            check_connected_accounts: Whether to check for connected accounts
+
+        Returns:
+            Sequence of Pydantic-AI Tool objects
+        """
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        if processors is not None:
+            self._processor_helpers.merge_processors(processors)
+
+        max_retries = max_retries or {}
+
+        return [
+            self._wrap_tool(
+                schema=tool.model_dump(exclude_none=True),
+                entity_id=entity_id or self.entity_id,
+                max_retries=max_retries.get(Action(tool.name), default_max_retries),
+            )
+            for tool in self.get_action_schemas(
+                actions=actions,
+                apps=apps,
+                tags=tags,
+                check_connected_accounts=check_connected_accounts,
+                _populate_requested=True,
+            )
+        ]

composio_pydanticai-0.7.7/composio_pydanticai.egg-info/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.2
+Name: composio_pydanticai
+Version: 0.7.7
+Summary: Use Composio to get array of strongly typed tools for Pydantic AI
+Home-page: https://github.com/ComposioHQ/composio
+Author: Siddharth
+Author-email: tech@composio.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: composio_core<0.8.0,>=0.7.0
+Requires-Dist: pydantic-ai
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## 🚀🔗 Leveraging Pydantic-AI with Composio
+
+Integrate Pydantic-AI agents with Composio to enable direct interaction with external applications, enhancing their capabilities through strongly-typed, validated tools.
+
+### Objective
+
+- **Automate GitHub operations** using type-safe instructions via Pydantic-AI's Tool system.
+- Demonstrate how to use Composio's tools with Pydantic-AI's strict type checking and validation.
+
+### Installation and Setup
+
+Install the necessary packages and connect your GitHub account to enable agent interactions with GitHub:
+
+```bash
+# Install Composio Pydantic-AI package
+pip install composio-pydanticai
+
+# Connect your GitHub account
+composio add github
+
+# View available applications you can connect with
+composio apps
+```
+
+### Usage Steps
+
+#### 1. Import Required Packages
+
+Set up your environment by importing the necessary components from Composio & Pydantic-AI:
+
+```python
+from dotenv import load_dotenv
+import os
+
+from composio import Action
+from composio_pydanticai import ComposioToolSet
+from pydantic_ai import Agent
+```
+
+#### 2. Initialize Tools with Composio
+
+Configure and fetch GitHub tools provided by Composio:
+
+```python
+# Initialize toolset
+composio_toolset = ComposioToolSet()
+
+# Configure max retries for specific tools
+max_retries = {
+    Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,    # More retries for starring
+    Action.GITHUB_CREATE_REPOSITORY: 2   # Fewer retries for creation
+}
+
+# Get GitHub tools with retry configuration
+tools = composio_toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+    max_retries=max_retries,
+    default_max_retries=3  # Default retries for tools not specified in max_retries
+)
+```
+
+The `max_retries` parameter lets you configure retry attempts per tool, with a default fallback for unspecified tools.
+
+#### 3. Set Up the Pydantic-AI Agent
+
+Create and configure a Pydantic-AI agent with the Composio tools:
+
+```python
+# Create an agent with the tools
+agent = Agent(
+    model="openai:gpt-4-turbo",  # Using a known model name
+    tools=tools,
+    system_prompt="""You are an AI agent that helps users interact with GitHub.
+    You can perform various GitHub operations using the available tools.
+    When given a task, analyze it and use the appropriate tool to complete it.""",
+)
+```
+
+#### 4. Execute Tasks
+
+Run your agent with specific tasks:
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Run the agent synchronously
+result = agent.run_sync(task)
+print("Result:", result.data)
+print("Trace:\n\n", result.all_messages())
+```
+
+### Key Features
+
+1. **Type Safety**: Leverages Pydantic-AI's strong type system for parameter validation
+2. **Async Support**: Built-in support for asynchronous operations
+3. **Error Handling**: Proper validation error handling with detailed feedback
+4. **Tool Context**: Automatic context injection for tool execution
+5. **Flexible Retry Configuration**: Configure retries per tool with fallback defaults
+
+### Advanced Usage
+
+The integration supports more complex scenarios:
+
+```python
+# Using multiple tools
+tools = composio_toolset.get_tools(
+    actions=[
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER,
+        Action.GITHUB_CREATE_REPOSITORY
+    ],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5,
+        Action.GITHUB_CREATE_REPOSITORY: 2
+    }
+)
+
+# Filtering tools by tags
+tools = composio_toolset.get_tools(
+    tags=["github", "repository"],
+    default_max_retries=3
+)
+
+# Using app-specific tools
+tools = composio_toolset.get_tools(
+    apps=[App.GITHUB],
+    max_retries={
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: 5
+    }
+)
+```
+
+### Best Practices
+
+1. Always use proper type hints in your code
+2. Handle validation errors appropriately
+3. Use the latest version of both Pydantic-AI and Composio
+4. Leverage async operations for better performance
+5. Keep your API keys secure using environment variables
+6. Configure retries based on the specific needs of each tool

composio_pydanticai-0.7.7/composio_pydanticai.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+composio_pydanticai/__init__.py
+composio_pydanticai/toolset.py
+composio_pydanticai.egg-info/PKG-INFO
+composio_pydanticai.egg-info/SOURCES.txt
+composio_pydanticai.egg-info/dependency_links.txt
+composio_pydanticai.egg-info/requires.txt
+composio_pydanticai.egg-info/top_level.txt

composio_pydanticai-0.7.7/composio_pydanticai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

composio_pydanticai-0.7.7/composio_pydanticai.egg-info/requires.txt

@@ -0,0 +1,2 @@
+composio_core<0.8.0,>=0.7.0
+pydantic-ai

composio_pydanticai-0.7.7/composio_pydanticai.egg-info/top_level.txt

@@ -0,0 +1 @@
+composio_pydanticai

composio_pydanticai-0.7.7/setup.cfg

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

composio_pydanticai-0.7.7/setup.py

@@ -0,0 +1,30 @@
+"""
+Setup configuration for Composio Pydantic AI plugin
+"""
+
+from pathlib import Path
+
+from setuptools import setup
+
+
+setup(
+    name="composio_pydanticai",
+    version="0.7.7",
+    author="Siddharth",
+    author_email="tech@composio.dev",
+    description="Use Composio to get array of strongly typed tools for Pydantic AI",
+    long_description=(Path(__file__).parent / "README.md").read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    url="https://github.com/ComposioHQ/composio",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.9,<4",
+    install_requires=[
+        "composio_core>=0.7.0,<0.8.0",
+        "pydantic-ai",
+    ],
+    include_package_data=True,
+)