composio-google 0.5.26__tar.gz

composio_google-0.5.26/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: composio_google
+Version: 0.5.26
+Summary: Use Composio to get an array of tools with your Google AI Python Gemini model.
+Home-page: https://github.com/ComposioHQ/composio
+Author: Assistant
+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.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: composio_core==0.5.26
+Requires-Dist: google-cloud-aiplatform>=1.38.0
+
+## 🚀🔗 Integrating Composio with Google AI Python
+
+Streamline the integration of Composio with Google AI Python to enhance the capabilities of Gemini models, allowing them to interact directly with external applications and expanding their operational scope.
+
+### Objective
+
+- **Automate starring a GitHub repository** using conversational instructions via Google AI Python's Function Calling feature.
+
+### Installation and Setup
+
+Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.
+
+```bash
+# Install Composio LangChain package
+pip install composio-google
+
+# Connect your GitHub account
+composio-cli add github
+
+# View available applications you can connect with
+composio-cli show-apps
+```
+
+### Usage Steps
+
+#### 1. Import Base Packages
+
+Prepare your environment by initializing necessary imports from Google AI Python and setting up your client.
+
+```python
+from vertexai.generative_models import GenerativeModel
+
+# Initialize Google AI Python client
+model = GenerativeModel("gemini-pro")
+```
+
+### Step 2: Integrating GitHub Tools with Composio
+
+This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for Google AI Python operations.
+```python
+from composio_google import App, ComposioToolset
+
+toolset = ComposioToolset()
+actions = toolset.get_tools(apps=[App.GITHUB])
+```
+
+### Step 3: Agent Execution
+
+This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Send a message to the model
+response = chat.send_message(task)
+```
+
+### Step 4: Validate Execution Response
+
+Execute the following code to validate the response, ensuring that the intended task has been successfully completed.
+
+```python
+result = composio_toolset.handle_response(response)
+print("Function call result:", result)
+```

composio_google-0.5.26/README.md

@@ -0,0 +1,66 @@
+## 🚀🔗 Integrating Composio with Google AI Python
+
+Streamline the integration of Composio with Google AI Python to enhance the capabilities of Gemini models, allowing them to interact directly with external applications and expanding their operational scope.
+
+### Objective
+
+- **Automate starring a GitHub repository** using conversational instructions via Google AI Python's Function Calling feature.
+
+### Installation and Setup
+
+Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.
+
+```bash
+# Install Composio LangChain package
+pip install composio-google
+
+# Connect your GitHub account
+composio-cli add github
+
+# View available applications you can connect with
+composio-cli show-apps
+```
+
+### Usage Steps
+
+#### 1. Import Base Packages
+
+Prepare your environment by initializing necessary imports from Google AI Python and setting up your client.
+
+```python
+from vertexai.generative_models import GenerativeModel
+
+# Initialize Google AI Python client
+model = GenerativeModel("gemini-pro")
+```
+
+### Step 2: Integrating GitHub Tools with Composio
+
+This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for Google AI Python operations.
+```python
+from composio_google import App, ComposioToolset
+
+toolset = ComposioToolset()
+actions = toolset.get_tools(apps=[App.GITHUB])
+```
+
+### Step 3: Agent Execution
+
+This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Send a message to the model
+response = chat.send_message(task)
+```
+
+### Step 4: Validate Execution Response
+
+Execute the following code to validate the response, ensuring that the intended task has been successfully completed.
+
+```python
+result = composio_toolset.handle_response(response)
+print("Function call result:", result)
+```

composio_google-0.5.26/composio_google/__init__.py

@@ -0,0 +1,13 @@
+from composio_google.toolset import ComposioToolset
+
+from composio import Action, App, Tag, Trigger, WorkspaceType
+
+
+__all__ = (
+    "Action",
+    "App",
+    "Tag",
+    "Trigger",
+    "WorkspaceType",
+    "ComposioToolset",
+)

composio_google-0.5.26/composio_google/toolset.py

@@ -0,0 +1,213 @@
+"""
+Google AI Python Gemini tool spec.
+"""
+
+import typing as t
+
+import typing_extensions as te
+from proto.marshal.collections.maps import MapComposite
+from vertexai.generative_models import (
+    Content,
+    FunctionDeclaration,
+    GenerationResponse,
+    Part,
+    Tool,
+)
+
+from composio import Action, ActionType, AppType, TagType
+from composio.constants import DEFAULT_ENTITY_ID
+from composio.tools import ComposioToolSet as BaseComposioToolSet
+from composio.utils.shared import json_schema_to_model
+
+
+class ComposioToolset(
+    BaseComposioToolSet,
+    runtime="google_ai",
+    description_char_limit=1024,
+):
+    """
+    Composio toolset for Google AI Python Gemini framework.
+
+    Example:
+    ```python
+        import os
+        import dotenv
+        from vertexai.generative_models import GenerativeModel
+        from composio_google import ComposioToolSet, App
+
+        # Load environment variables from .env
+        dotenv.load_dotenv()
+
+        # Initialize tools
+        composio_toolset = ComposioToolSet()
+
+        # Get GitHub tools that are pre-configured
+        tools = composio_toolset.get_tools(apps=[App.GITHUB])
+
+        # Initialize the Gemini model
+        model = GenerativeModel("gemini-pro", tools=tools)
+
+        # Start a chat
+        chat = model.start_chat()
+
+        # Define task
+        task = "Star a repo composiohq/composio on GitHub"
+
+        # Send a message to the model
+        response = chat.send_message(task)
+
+        print(response.text)
+
+        # Handle function calls if any
+        result = composio_toolset.handle_response(response)
+        if result:
+            print(result)
+    ```
+    """
+
+    def validate_entity_id(self, entity_id: str) -> str:
+        """Validate entity ID."""
+        if (
+            self.entity_id != DEFAULT_ENTITY_ID
+            and entity_id != DEFAULT_ENTITY_ID
+            and self.entity_id != entity_id
+        ):
+            raise ValueError(
+                "separate `entity_id` can not be provided during "
+                "initialization and handling tool calls"
+            )
+        if self.entity_id != DEFAULT_ENTITY_ID:
+            entity_id = self.entity_id
+        return entity_id
+
+    def _wrap_tool(
+        self,
+        schema: t.Dict[str, t.Any],
+    ) -> FunctionDeclaration:
+        """Wraps composio tool as Google AI Python Gemini FunctionDeclaration object."""
+        action = schema["name"]
+        description = schema.get("description", action)
+        parameters = json_schema_to_model(schema["parameters"])
+
+        # Clean up properties by removing 'examples' field
+        properties = parameters.schema().get("properties", {})
+        cleaned_properties = {
+            prop_name: {k: v for k, v in prop_schema.items() if k != "examples"}
+            for prop_name, prop_schema in properties.items()
+        }
+
+        # Create cleaned parameters
+        cleaned_parameters = {
+            "type": "object",
+            "properties": cleaned_properties,
+            "required": parameters.schema().get("required", []),
+        }
+
+        return FunctionDeclaration(
+            name=action,
+            description=description,
+            parameters=cleaned_parameters,
+        )
+
+    @te.deprecated("Use `ComposioToolSet.get_tools` instead")
+    def get_actions(
+        self,
+        actions: t.Sequence[ActionType],
+        entity_id: t.Optional[str] = None,
+    ) -> Tool:
+        """
+        Get composio tools wrapped as Google AI Python Gemini FunctionDeclaration objects.
+
+        :param actions: List of actions to wrap
+        :param entity_id: Entity ID for the function wrapper
+
+        :return: Composio tools wrapped as `FunctionDeclaration` objects
+        """
+        return self.get_tool(actions=actions, entity_id=entity_id)
+
+    def get_tool(
+        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,
+    ) -> Tool:
+        """
+        Get composio tools wrapped as Google AI Python Gemini FunctionDeclaration objects.
+
+        :param actions: List of actions to wrap
+        :param apps: List of apps to wrap
+        :param tags: Filter the apps by given tags
+        :param entity_id: Entity ID for the function wrapper
+
+        :return: Composio tools wrapped as `FunctionDeclaration` objects
+        """
+        entity_id = self.validate_entity_id(entity_id or self.entity_id)
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        return Tool(
+            function_declarations=[
+                self._wrap_tool(
+                    schema=tool.model_dump(
+                        exclude_none=True,
+                    ),
+                )
+                for tool in self.get_action_schemas(
+                    actions=actions, apps=apps, tags=tags
+                )
+            ]
+        )
+
+    def execute_function_call(
+        self,
+        function_call: t.Any,
+        entity_id: t.Optional[str] = DEFAULT_ENTITY_ID,
+    ) -> t.Dict:
+        """
+        Execute a function call.
+
+        :param function_call: Function call metadata from Gemini model response.
+        :param entity_id: Entity ID to use for executing the function call.
+        :return: Object containing output data from the function call.
+        """
+        entity_id = self.validate_entity_id(entity_id or self.entity_id)
+
+        def convert_map_composite(obj):
+            if isinstance(obj, MapComposite):
+                return {k: convert_map_composite(v) for k, v in obj.items()}
+            if isinstance(obj, (list, tuple)):
+                return [convert_map_composite(item) for item in obj]
+            return obj
+
+        args = convert_map_composite(function_call.args)
+
+        return self.execute_action(
+            action=Action(value=function_call.name),
+            params=args,
+            entity_id=entity_id,
+        )
+
+    def handle_response(
+        self,
+        response: GenerationResponse,
+        entity_id: t.Optional[str] = None,
+    ) -> t.List[t.Dict]:
+        """
+        Handle response from Google AI Python Gemini model.
+
+        :param response: Generation response from the Gemini model.
+        :param entity_id: Entity ID to use for executing the function call.
+        :return: A list of output objects from the function calls.
+        """
+        entity_id = self.validate_entity_id(entity_id or self.entity_id)
+        outputs = []
+        for candidate in response.candidates:
+            if isinstance(candidate.content, Content) and candidate.content.parts:
+                for part in candidate.content.parts:
+                    if isinstance(part, Part) and part.function_call:
+                        outputs.append(
+                            self.execute_function_call(
+                                function_call=part.function_call,
+                                entity_id=entity_id,
+                            )
+                        )
+        return outputs

composio_google-0.5.26/composio_google.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: composio_google
+Version: 0.5.26
+Summary: Use Composio to get an array of tools with your Google AI Python Gemini model.
+Home-page: https://github.com/ComposioHQ/composio
+Author: Assistant
+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.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: composio_core==0.5.26
+Requires-Dist: google-cloud-aiplatform>=1.38.0
+
+## 🚀🔗 Integrating Composio with Google AI Python
+
+Streamline the integration of Composio with Google AI Python to enhance the capabilities of Gemini models, allowing them to interact directly with external applications and expanding their operational scope.
+
+### Objective
+
+- **Automate starring a GitHub repository** using conversational instructions via Google AI Python's Function Calling feature.
+
+### Installation and Setup
+
+Ensure you have the necessary packages installed and connect your GitHub account to allow your agents to utilize GitHub functionalities.
+
+```bash
+# Install Composio LangChain package
+pip install composio-google
+
+# Connect your GitHub account
+composio-cli add github
+
+# View available applications you can connect with
+composio-cli show-apps
+```
+
+### Usage Steps
+
+#### 1. Import Base Packages
+
+Prepare your environment by initializing necessary imports from Google AI Python and setting up your client.
+
+```python
+from vertexai.generative_models import GenerativeModel
+
+# Initialize Google AI Python client
+model = GenerativeModel("gemini-pro")
+```
+
+### Step 2: Integrating GitHub Tools with Composio
+
+This step involves fetching and integrating GitHub tools provided by Composio, enabling enhanced functionality for Google AI Python operations.
+```python
+from composio_google import App, ComposioToolset
+
+toolset = ComposioToolset()
+actions = toolset.get_tools(apps=[App.GITHUB])
+```
+
+### Step 3: Agent Execution
+
+This step involves configuring and executing the agent to carry out actions, such as starring a GitHub repository.
+
+```python
+# Define task
+task = "Star a repo composiohq/composio on GitHub"
+
+# Send a message to the model
+response = chat.send_message(task)
+```
+
+### Step 4: Validate Execution Response
+
+Execute the following code to validate the response, ensuring that the intended task has been successfully completed.
+
+```python
+result = composio_toolset.handle_response(response)
+print("Function call result:", result)
+```

composio_google-0.5.26/composio_google.egg-info/SOURCES.txt

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

composio_google-0.5.26/composio_google.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

composio_google-0.5.26/composio_google.egg-info/requires.txt

@@ -0,0 +1,2 @@
+composio_core==0.5.26
+google-cloud-aiplatform>=1.38.0

composio_google-0.5.26/composio_google.egg-info/top_level.txt

@@ -0,0 +1 @@
+composio_google

composio_google-0.5.26/setup.cfg

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

composio_google-0.5.26/setup.py

@@ -0,0 +1,30 @@
+"""
+Setup configuration for Composio Google AI Python Gemini plugin
+"""
+
+from pathlib import Path
+
+from setuptools import setup
+
+
+setup(
+    name="composio_google",
+    version="0.5.26",
+    author="Assistant",
+    author_email="karan@composio.dev",
+    description="Use Composio to get an array of tools with your Google AI Python Gemini model.",
+    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.5.26",
+        "google-cloud-aiplatform>=1.38.0",
+    ],
+    include_package_data=True,
+)