llama-index-tools-azure-code-interpreter 0.1.0__tar.gz

llama_index_tools_azure_code_interpreter-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: llama-index-tools-azure-code-interpreter
+Version: 0.1.0
+Summary: llama-index tools azure dynamic sessions integration for code interpreter
+License: MIT
+Author: Your Name
+Author-email: you@example.com
+Maintainer: ajhofmann
+Requires-Python: >=3.8.1,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: azure-identity (>=1.16.0,<2.0.0)
+Requires-Dist: llama-index-core (>=0.10.1,<0.11.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Azure Code Interpreter Tool
+
+This tool leverages Azure Dynamic Sessions Pool to enable an Agent to run generated Python code in a secure environment with very low latency.
+
+In order to utilize the tool, you will need to have the Session Pool management endpoint first. [Learn more](https://aka.ms/aca/sessions)
+
+## Prerequisites
+
+- Make sure to create a Session Pool and note down the `poolManagementEndpoint`.
+
+- In order to have the code execution right, the correct role needs to be assigned to the current user agent. Be sure to assign `Session Pool Executor` role to the correct user agent's identity (e.g. User Email, Service Principal, Managed Identity, etc.) in Session Pool's access control panel through the Portal or CLI. [Learn more](https://aka.ms/aca/sessions)
+
+## Usage
+
+A more detailed sample is located in a Jupyter notebook [here](https://github.com/run-llama/llama_index/tree/main/docs/docs/examples/tools/azure_code_interpreter.ipynb)
+
+Here's an example usage of the `AzureCodeInterpreterToolSpec`.
+
+1. First, install the Azure Dynamic Sessions package using `pip`:
+
+```
+pip install llama-index-tools-azure-code-interpreter
+```
+
+2. Next, set up the Dynamic Sessions tool and a LLM agent:
+
+```python
+from llama_index.tools.azure_code_interpreter import (
+    AzureCodeInterpreterToolSpec,
+)
+from llama_index.core.agent import ReActAgent
+from llama_index.llms.azure_openai import AzureOpenAI
+
+llm = AzureOpenAI(
+    model="gpt-35-turbo",
+    deployment_name="gpt-35-deploy",
+    api_key=api_key,
+    azure_endpoint=azure_endpoint,
+    api_version=api_version,
+)
+
+code_interpreter_spec = AzureCodeInterpreterToolSpec(
+    pool_managment_endpoint="your-pool-management-endpoint"
+)
+
+agent = ReActAgent.from_tools(
+    code_interpreter_spec.to_tool_list(), llm=llm, verbose=True
+)
+```
+
+3. Use the tool as you need:
+
+```python
+print(agent.chat("Tell me the current time in Seattle."))
+
+"""
+Sample Return:
+Thought: To provide the current time in Seattle, I need to calculate it based on the current UTC time and adjust for Seattle's time zone, which is Pacific Daylight Time (PDT) during daylight saving time and Pacific Standard Time (PST) outside of daylight saving time. PDT is UTC-7, and PST is UTC-8. I can use the code interpreter tool to get the current UTC time and adjust it accordingly.
+Action: code_interpreter
+Action Input: {'python_code': "from datetime import datetime, timedelta; import pytz; utc_now = datetime.now(pytz.utc); seattle_time = utc_now.astimezone(pytz.timezone('America/Los_Angeles')); seattle_time.strftime('%Y-%m-%d %H:%M:%S %Z%z')"}
+Observation: {'$id': '1', 'status': 'Success', 'stdout': '', 'stderr': '', 'result': '2024-05-04 13:54:09 PDT-0700', 'executionTimeInMilliseconds': 120}
+Thought: I can answer without using any more tools. I'll use the user's language to answer.
+Answer: The current time in Seattle is 2024-05-04 13:54:09 PDT.
+The current time in Seattle is 2024-05-04 13:54:09 PDT.
+"""
+
+print(dynamic_session_tool.code_interpreter("1+1"))
+
+"""
+Sample Return:
+{'$id': '1', 'status': 'Success', 'stdout': '', 'stderr': '', 'result': 2, 'executionTimeInMilliseconds': 11}
+"""
+```
+
+## Included Tools
+
+The `AzureCodeInterpreterToolSpec` provides the following tools to the agent:
+
+`code_interpreter`: (Available to developer and LLM Agent in tool spec) Send a Python code to be executed in Azure Container Apps Dynamic Sessions and return the output in a JSON format.
+
+`list_files`: (Available to developer and LLM Agent in tool spec) List the files available in a Session under the path `/mnt/data`.
+
+`upload_file`: (Available to developer) Upload a file or a stream of data into a Session under the path `/mnt/data`.
+
+`download_file`: (Available to developer) Download a file by its path relative to the path `/mnt/data` to the tool's hosting agent.
+

llama_index_tools_azure_code_interpreter-0.1.0/README.md

@@ -0,0 +1,85 @@
+# Azure Code Interpreter Tool
+
+This tool leverages Azure Dynamic Sessions Pool to enable an Agent to run generated Python code in a secure environment with very low latency.
+
+In order to utilize the tool, you will need to have the Session Pool management endpoint first. [Learn more](https://aka.ms/aca/sessions)
+
+## Prerequisites
+
+- Make sure to create a Session Pool and note down the `poolManagementEndpoint`.
+
+- In order to have the code execution right, the correct role needs to be assigned to the current user agent. Be sure to assign `Session Pool Executor` role to the correct user agent's identity (e.g. User Email, Service Principal, Managed Identity, etc.) in Session Pool's access control panel through the Portal or CLI. [Learn more](https://aka.ms/aca/sessions)
+
+## Usage
+
+A more detailed sample is located in a Jupyter notebook [here](https://github.com/run-llama/llama_index/tree/main/docs/docs/examples/tools/azure_code_interpreter.ipynb)
+
+Here's an example usage of the `AzureCodeInterpreterToolSpec`.
+
+1. First, install the Azure Dynamic Sessions package using `pip`:
+
+```
+pip install llama-index-tools-azure-code-interpreter
+```
+
+2. Next, set up the Dynamic Sessions tool and a LLM agent:
+
+```python
+from llama_index.tools.azure_code_interpreter import (
+    AzureCodeInterpreterToolSpec,
+)
+from llama_index.core.agent import ReActAgent
+from llama_index.llms.azure_openai import AzureOpenAI
+
+llm = AzureOpenAI(
+    model="gpt-35-turbo",
+    deployment_name="gpt-35-deploy",
+    api_key=api_key,
+    azure_endpoint=azure_endpoint,
+    api_version=api_version,
+)
+
+code_interpreter_spec = AzureCodeInterpreterToolSpec(
+    pool_managment_endpoint="your-pool-management-endpoint"
+)
+
+agent = ReActAgent.from_tools(
+    code_interpreter_spec.to_tool_list(), llm=llm, verbose=True
+)
+```
+
+3. Use the tool as you need:
+
+```python
+print(agent.chat("Tell me the current time in Seattle."))
+
+"""
+Sample Return:
+Thought: To provide the current time in Seattle, I need to calculate it based on the current UTC time and adjust for Seattle's time zone, which is Pacific Daylight Time (PDT) during daylight saving time and Pacific Standard Time (PST) outside of daylight saving time. PDT is UTC-7, and PST is UTC-8. I can use the code interpreter tool to get the current UTC time and adjust it accordingly.
+Action: code_interpreter
+Action Input: {'python_code': "from datetime import datetime, timedelta; import pytz; utc_now = datetime.now(pytz.utc); seattle_time = utc_now.astimezone(pytz.timezone('America/Los_Angeles')); seattle_time.strftime('%Y-%m-%d %H:%M:%S %Z%z')"}
+Observation: {'$id': '1', 'status': 'Success', 'stdout': '', 'stderr': '', 'result': '2024-05-04 13:54:09 PDT-0700', 'executionTimeInMilliseconds': 120}
+Thought: I can answer without using any more tools. I'll use the user's language to answer.
+Answer: The current time in Seattle is 2024-05-04 13:54:09 PDT.
+The current time in Seattle is 2024-05-04 13:54:09 PDT.
+"""
+
+print(dynamic_session_tool.code_interpreter("1+1"))
+
+"""
+Sample Return:
+{'$id': '1', 'status': 'Success', 'stdout': '', 'stderr': '', 'result': 2, 'executionTimeInMilliseconds': 11}
+"""
+```
+
+## Included Tools
+
+The `AzureCodeInterpreterToolSpec` provides the following tools to the agent:
+
+`code_interpreter`: (Available to developer and LLM Agent in tool spec) Send a Python code to be executed in Azure Container Apps Dynamic Sessions and return the output in a JSON format.
+
+`list_files`: (Available to developer and LLM Agent in tool spec) List the files available in a Session under the path `/mnt/data`.
+
+`upload_file`: (Available to developer) Upload a file or a stream of data into a Session under the path `/mnt/data`.
+
+`download_file`: (Available to developer) Download a file by its path relative to the path `/mnt/data` to the tool's hosting agent.

llama_index_tools_azure_code_interpreter-0.1.0/llama_index/tools/azure_code_interpreter/__init__.py

@@ -0,0 +1,4 @@
+## init
+from llama_index.tools.azure_code_interpreter.base import AzureCodeInterpreterToolSpec
+
+__all__ = ["AzureCodeInterpreterToolSpec"]

llama_index_tools_azure_code_interpreter-0.1.0/llama_index/tools/azure_code_interpreter/base.py

@@ -0,0 +1,286 @@
+"""Azure Dynamic Sessions tool spec."""
+
+import base64
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+import importlib.metadata
+from io import BufferedReader, BytesIO
+from typing import Any, Callable, List, Optional
+import urllib
+from uuid import uuid4
+import re
+import os
+
+from azure.identity import DefaultAzureCredential
+from azure.core.credentials import AccessToken
+import requests
+
+from llama_index.core.tools.tool_spec.base import BaseToolSpec
+
+
+@dataclass
+class RemoteFileMetadata:
+    """Metadata for a file in the session."""
+
+    filename: str
+    """The filename relative to `/mnt/data`."""
+
+    size_in_bytes: int
+    """The size of the file in bytes."""
+
+    file_full_path: str
+    """The full path of the file."""
+
+    @staticmethod
+    def from_dict(data: dict) -> "RemoteFileMetadata":
+        """Create a RemoteFileMetadata object from a dictionary."""
+        filename = data["filename"]
+        if filename.startswith("/mnt/data"):
+            file_full_path = filename
+        else:
+            file_full_path = f"/mnt/data/{filename}"
+        return RemoteFileMetadata(
+            filename=filename,
+            size_in_bytes=data["size"],
+            file_full_path=file_full_path,
+        )
+
+
+def _sanitize_input(query: str) -> str:
+    """Sanitize input and remove whitespace, backtick, and markdown.
+
+    Args:
+        query: The query to sanitize
+
+    Returns:
+        str: The sanitized query
+    """
+    # Removes `, whitespace & python from start
+    query = re.sub(r"^(\s|`)*(?i:python)?\s*", "", query)
+    # Removes whitespace & ` from end
+    query = re.sub(r"(\s|`)*$", "", query)
+    # Add new line if no new line was appended at the end of the query
+    if not query.endswith("\n"):
+        query += "\n"
+    return query
+
+
+class AzureCodeInterpreterToolSpec(BaseToolSpec):
+    """Azure Code Interpreter tool spec.
+
+    Leverages Azure Dynamic Sessions to execute Python code.
+    """
+
+    spec_functions = ["code_interpreter", "list_files"]
+
+    def __init__(
+        self,
+        pool_managment_endpoint: str,
+        session_id: Optional[str] = None,
+        local_save_path: Optional[str] = None,
+        sanitize_input: bool = True,
+    ) -> None:
+        """Initialize with parameters."""
+        self.pool_management_endpoint: str = pool_managment_endpoint
+        self.access_token: Optional[AccessToken] = None
+
+        def _access_token_provider_factory() -> Callable[[], Optional[str]]:
+            def access_token_provider() -> Optional[str]:
+                """Create a function that returns an access token."""
+                if self.access_token is None or datetime.fromtimestamp(
+                    self.access_token.expires_on, timezone.utc
+                ) < (datetime.now(timezone.utc) + timedelta(minutes=5)):
+                    credential = DefaultAzureCredential()
+                    self.access_token = credential.get_token(
+                        "https://dynamicsessions.io/.default"
+                    )
+                return self.access_token.token
+
+            return access_token_provider
+
+        self.access_token_provider: Callable[
+            [], Optional[str]
+        ] = _access_token_provider_factory()
+        """A function that returns the access token to use for the session pool."""
+
+        self.session_id: str = session_id or str(uuid4())
+        """The session ID to use for the session pool. Defaults to a random UUID."""
+
+        self.sanitize_input: bool = sanitize_input
+        """Whether to sanitize input before executing it."""
+
+        if local_save_path:
+            if not os.path.exists(local_save_path):
+                raise Exception(f"Local save path {local_save_path} does not exist.")
+
+        self.local_save_path: Optional[str] = local_save_path
+        """The local path to save files generated by Python interpreter."""
+
+        try:
+            _package_version = importlib.metadata.version(
+                "llamaindex-azure-code-interpreter"
+            )
+        except importlib.metadata.PackageNotFoundError:
+            _package_version = "0.0.0"
+
+        self.user_agent = (
+            f"llamaindex-azure-code-interpreter/{_package_version} (Language=Python)"
+        )
+
+    def _build_url(self, path: str) -> str:
+        pool_management_endpoint = self.pool_management_endpoint
+        if not pool_management_endpoint:
+            raise ValueError("pool_management_endpoint is not set")
+
+        if not pool_management_endpoint.endswith("/"):
+            pool_management_endpoint += "/"
+
+        encoded_session_id = urllib.parse.quote(self.session_id)
+        query = f"identifier={encoded_session_id}&api-version=2024-02-02-preview"
+        query_separator = "&" if "?" in pool_management_endpoint else "?"
+
+        return pool_management_endpoint + path + query_separator + query
+
+    def code_interpreter(self, python_code: str) -> dict:
+        """
+        This tool is used to execute python commands when you need to perform calculations or computations in a Session.
+        Input should be a valid python command. The tool returns the result, stdout, and stderr.
+
+        Args:
+            python_code (str): Python code to be executed generated by llm.
+        """
+        if self.sanitize_input:
+            python_code = _sanitize_input(python_code)
+
+        access_token = self.access_token_provider(self)
+        api_url = self._build_url("code/execute")
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+            "User-Agent": self.user_agent,
+        }
+        body = {
+            "properties": {
+                "codeInputType": "inline",
+                "executionType": "synchronous",
+                "code": python_code,
+            }
+        }
+
+        response = requests.post(api_url, headers=headers, json=body)
+        response.raise_for_status()
+        response_json = response.json()
+        if "result" in response_json and response_json["result"]:
+            if isinstance(response_json["result"], dict):
+                if "base64_data" in response_json["result"]:
+                    base64_encoded_data = response_json["result"]["base64_data"]
+                    if self.local_save_path:
+                        file_path = f"{self.local_save_path}/{self.session_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.{response_json['result']['format']}"
+                        decoded_data = base64.b64decode(base64_encoded_data)
+                        with open(file_path, "wb") as f:
+                            f.write(decoded_data)
+                        # Check if file is written to the file path successfully. if so, update the response_json
+                        response_json["result"]["saved_to_local_path"] = response_json[
+                            "result"
+                        ].pop("base64_data")
+                        if os.path.exists(file_path):
+                            response_json["result"]["saved_to_local_path"] = True
+                        else:
+                            response_json["result"]["saved_to_local_path"] = False
+                    else:
+                        response_json["result"]["base64_data"] = ""
+        return response_json
+
+    def upload_file(
+        self,
+        data: Optional[Any] = None,
+        local_file_path: Optional[str] = None,
+    ) -> List[RemoteFileMetadata]:
+        """Upload a file to the session under the path /mnt/data.
+
+        Args:
+            data: The data to upload.
+            local_file_path: The path to the local file to upload.
+
+        Returns:
+            List[RemoteFileMetadata]: The list of metadatas for the uploaded files.
+        """
+        if data and local_file_path:
+            raise ValueError("data and local_file_path cannot be provided together")
+
+        if local_file_path:
+            remote_file_path = f"/mnt/data/{os.path.basename(local_file_path)}"
+            data = open(local_file_path, "rb")
+
+        access_token = self.access_token_provider(self)
+        if not remote_file_path.startswith("/mnt/data"):
+            remote_file_path = f"/mnt/data/{remote_file_path}"
+        api_url = self._build_url("files/upload")
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+        }
+
+        files = [("file", (remote_file_path, data, "application/octet-stream"))]
+
+        response = requests.request("POST", api_url, headers=headers, files=files)
+        response.raise_for_status()
+
+        response_json = response.json()
+        remote_files_metadatas = []
+        for entry in response_json["value"]:
+            if "properties" in entry:
+                remote_files_metadatas.append(
+                    RemoteFileMetadata.from_dict(entry["properties"])
+                )
+        return remote_files_metadatas
+
+    def download_file_to_local(
+        self, remote_file_path: str, local_file_path: Optional[str] = None
+    ) -> Optional[BufferedReader]:
+        """Download a file from the session back to your local environment.
+
+        Args:
+            remote_file_path: The path to download the file from, relative to `/mnt/data`.
+            local_file_path: The path to save the downloaded file to. If not provided, the file is returned as a BufferedReader.
+
+        Returns:
+            BufferedReader: The data of the downloaded file.
+        """
+        access_token = self.access_token_provider()
+        # In case if the file path LLM provides is absolute, remove the /mnt/data/ prefix
+        remote_file_path = remote_file_path.replace("/mnt/data/", "")
+        api_url = self._build_url(f"files/content/{remote_file_path}")
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        if local_file_path:
+            with open(local_file_path, "wb") as f:
+                f.write(response.content)
+            return None
+
+        return BytesIO(response.content)
+
+    def list_files(self) -> List[RemoteFileMetadata]:
+        """List the files in the session.
+
+        Returns:
+            List[RemoteFileMetadata]: The metadata for the files in the session
+        """
+        access_token = self.access_token_provider(self)
+        api_url = self._build_url("files")
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+        }
+
+        response = requests.get(api_url, headers=headers)
+        response.raise_for_status()
+
+        response_json = response.json()
+        return [
+            RemoteFileMetadata.from_dict(entry["properties"])
+            for entry in response_json["value"]
+        ]

llama_index_tools_azure_code_interpreter-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]
+
+[tool.codespell]
+check-filenames = true
+check-hidden = true
+skip = "*.csv,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb"
+
+[tool.llamahub]
+contains_example = false
+import_path = "llama_index.tools.azure_code_interpreter"
+
+[tool.llamahub.class_authors]
+AzureCodeInterpreterToolSpec = "harryli0108"
+
+[tool.mypy]
+disallow_untyped_defs = true
+exclude = ["_static", "build", "examples", "notebooks", "venv"]
+ignore_missing_imports = true
+python_version = "3.8"
+
+[tool.poetry]
+authors = ["Your Name <you@example.com>"]
+description = "llama-index tools azure dynamic sessions integration for code interpreter"
+exclude = ["**/BUILD"]
+license = "MIT"
+maintainers = ["ajhofmann"]
+name = "llama-index-tools-azure-code-interpreter"
+readme = "README.md"
+version = "0.1.0"
+
+[tool.poetry.dependencies]
+python = ">=3.8.1,<4.0"
+llama-index-core = "^0.10.1"
+azure-identity = "^1.16.0"
+requests = "^2.31.0"
+
+[tool.poetry.group.dev.dependencies]
+ipython = "8.10.0"
+jupyter = "^1.0.0"
+mypy = "0.991"
+pre-commit = "3.2.0"
+pylint = "2.15.10"
+pytest = "7.2.1"
+pytest-mock = "3.11.1"
+ruff = "0.0.292"
+tree-sitter-languages = "^1.8.0"
+types-Deprecated = ">=0.1.0"
+types-PyYAML = "^6.0.12.12"
+types-protobuf = "^4.24.0.4"
+types-redis = "4.5.5.0"
+types-requests = "2.28.11.8"
+types-setuptools = "67.1.0.0"
+
+[tool.poetry.group.dev.dependencies.black]
+extras = ["jupyter"]
+version = "<=23.9.1,>=23.7.0"
+
+[tool.poetry.group.dev.dependencies.codespell]
+extras = ["toml"]
+version = ">=v2.2.6"
+
+[[tool.poetry.packages]]
+include = "llama_index/"