ai-parrot 0.8.3__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/tools/docx.py

@@ -0,0 +1,343 @@
+import re
+import tempfile
+import os
+from pathlib import Path
+import uuid
+import asyncio
+from typing import Optional, Dict, Any
+from urllib.parse import urlparse
+import aiohttp
+import aiofiles
+from docx import Document
+from docx.shared import Pt, Inches
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from langchain.tools import BaseTool
+from markdownify import markdownify as md
+import mammoth
+
+
+class DocxGeneratorTool(BaseTool):
+    """Microsoft Word DOCX Generator Tool."""
+    name: str = "generate_ms_word_document"
+    description: str = "Use this tool for generating DOCX, provide text in markdown format with sections, headings."
+    output_dir: str = None
+
+    def __init__(self, output_dir=None):
+        """Initialize the DOCX generator tool."""
+        super().__init__()
+        self.output_dir = output_dir
+
+    def _run(self, markdown_text: str, filename: str = None) -> dict:
+        """Generate a DOCX document from markdown text."""
+        try:
+            # Create a unique filename if not provided
+            if not filename:
+                filename = f"document_{uuid.uuid4().hex[:8]}.docx"
+            elif not filename.lower().endswith('.docx'):
+                filename = f"{filename}.docx"
+
+            # Get output directory, use current directory if not specified
+            output_dir = self.output_dir or '.'
+            os.makedirs(output_dir, exist_ok=True)
+
+            # Create full file path
+            file_path = Path(output_dir) / filename
+
+            # Process the markdown to handle any format issues
+            processed_text = self._preprocess_markdown(markdown_text)
+
+            # Convert markdown to DOCX
+            self._markdown_to_docx(processed_text, file_path)
+
+            return {
+                "filename": filename,
+                "file_path": str(file_path),
+                "content_type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                "type": "docx"
+            }
+        except Exception as e:
+            # If any error occurs, return information about the error
+            return {
+                "error": str(e),
+                "original_markdown": markdown_text
+            }
+
+    def _preprocess_markdown(self, text):
+        """Preprocess markdown to handle common issues."""
+        # Replace placeholder variables with empty strings
+        text = re.sub(r'\{[a-zA-Z0-9_]+\}', '', text)
+
+        # Handle f-strings that weren't evaluated
+        text = re.sub(r'f"""(.*?)"""', r'\1', text, flags=re.DOTALL)
+        text = re.sub(r"f'''(.*?)'''", r'\1', text, flags=re.DOTALL)
+
+        # Remove triple backticks and language indicators (common in code blocks)
+        text = re.sub(r'```[a-zA-Z]*\n', '', text)
+        text = re.sub(r'```', '', text)
+
+        # Fix any heading issues (ensure space after #)
+        text = re.sub(r'(#+)([^ \n])', r'\1 \2', text)
+
+        return text
+
+    def _markdown_to_docx(self, markdown_text, output_path):
+        """Convert markdown text to a DOCX document."""
+        # Create a new Document
+        doc = Document()
+
+        # Set document margins
+        sections = doc.sections
+        for section in sections:
+            section.top_margin = Inches(1)
+            section.bottom_margin = Inches(1)
+            section.left_margin = Inches(1)
+            section.right_margin = Inches(1)
+
+        # Split the markdown into lines for processing
+        lines = markdown_text.split('\n')
+
+        # Process each line
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+
+            # Handle headings
+            if line.startswith('#'):
+                # Count the number of # to determine heading level
+                level = 0
+                while level < len(line) and line[level] == '#':
+                    level += 1
+
+                # Get the heading text
+                heading_text = line[level:].strip()
+
+                # Add the heading with appropriate style
+                if level <= 9:  # Word supports heading levels 1-9
+                    heading = doc.add_heading(heading_text, level=level)
+                else:
+                    # If level is beyond supported, default to level 9
+                    heading = doc.add_heading(heading_text, level=9)
+
+            # Handle bullet lists
+            elif line.startswith('* ') or line.startswith('- '):
+                text = line[2:].strip()
+                p = doc.add_paragraph()
+                p.style = 'List Bullet'
+                p.add_run(text)
+
+            # Handle numbered lists
+            elif re.match(r'^\d+\.\s', line):
+                text = re.sub(r'^\d+\.\s', '', line).strip()
+                p = doc.add_paragraph()
+                p.style = 'List Number'
+                p.add_run(text)
+
+            # Handle blockquotes
+            elif line.startswith('> '):
+                text = line[2:].strip()
+                p = doc.add_paragraph()
+                p.style = 'Quote'
+                p.add_run(text)
+
+            # Handle horizontal rules
+            elif line == '---' or line == '***' or line == '___':
+                doc.add_paragraph('_' * 50)
+
+            # Handle paragraphs (including empty lines)
+            else:
+                # Skip completely empty lines
+                if not line and i + 1 < len(lines) and not lines[i+1].strip():
+                    i += 1
+                    continue
+
+                # Start a new paragraph
+                p = doc.add_paragraph()
+
+                # Add the text, handling bold and italic formatting
+                text = line
+
+                # Process basic markdown formatting
+                # Bold: **text** or __text__
+                bold_pattern = r'\*\*(.*?)\*\*|__(.*?)__'
+                # Italic: *text* or _text_
+                italic_pattern = r'\*(.*?)\*|_(.*?)_'
+
+                # Find all formatting markers
+                formatting_markers = []
+
+                # Find bold text
+                for match in re.finditer(bold_pattern, text):
+                    start, end = match.span()
+                    content = match.group(1) or match.group(2)
+                    formatting_markers.append((start, end, content, 'bold'))
+
+                # Find italic text
+                for match in re.finditer(italic_pattern, text):
+                    start, end = match.span()
+                    content = match.group(1) or match.group(2)
+                    formatting_markers.append((start, end, content, 'italic'))
+
+                # Sort markers by start position
+                formatting_markers.sort(key=lambda x: x[0])
+
+                # Apply formatting
+                if formatting_markers:
+                    # Add text with formatting
+                    current_pos = 0
+                    for start, end, content, format_type in formatting_markers:
+                        # Add text before the formatted part
+                        if start > current_pos:
+                            p.add_run(text[current_pos:start])
+
+                        # Add the formatted text
+                        run = p.add_run(content)
+                        if format_type == 'bold':
+                            run.bold = True
+                        elif format_type == 'italic':
+                            run.italic = True
+
+                        current_pos = end
+
+                    # Add any remaining text
+                    if current_pos < len(text):
+                        p.add_run(text[current_pos:])
+                else:
+                    # No formatting, add the entire line
+                    p.add_run(text)
+
+            i += 1
+
+        # Add a table if markdown contains a table-like structure
+        if '|' in markdown_text:
+            self._try_add_tables(doc, markdown_text)
+
+        # Save the document
+        doc.save(output_path)
+
+    def _try_add_tables(self, doc, markdown_text):
+        """Try to extract and add tables from markdown text."""
+        # Find potential table rows (lines containing |)
+        table_lines = [line.strip() for line in markdown_text.split('\n')
+                      if '|' in line and line.strip().startswith('|')]
+
+        if len(table_lines) >= 2:  # Need at least header and separator
+            # Add a section break before the table
+            doc.add_paragraph()
+
+            # Extract header row
+            header_cells = [cell.strip() for cell in table_lines[0].split('|')[1:-1]]
+
+            # Check for separator row (contains only -, |, :)
+            if all(all(c in '-:|' for c in cell.strip()) for cell in table_lines[1].split('|')[1:-1]):
+                data_rows = table_lines[2:]
+            else:
+                data_rows = table_lines[1:]
+
+            # Create table
+            table = doc.add_table(rows=len(data_rows)+1, cols=len(header_cells))
+            table.style = 'Table Grid'
+
+            # Add header
+            for i, cell in enumerate(header_cells):
+                table.cell(0, i).text = cell
+
+            # Add data rows
+            for row_idx, row in enumerate(data_rows):
+                cells = [cell.strip() for cell in row.split('|')[1:-1]]
+                for col_idx, cell in enumerate(cells):
+                    if col_idx < len(header_cells):  # Ensure we don't exceed columns
+                        table.cell(row_idx+1, col_idx).text = cell
+
+
+class WordToMarkdownTool(BaseTool):
+    """Converts a Word document to Markdown format by downloading it from a URL."""
+    name: str = "word_to_markdown_tool"
+    description: str = (
+        "Converts a Word document to Markdown format from a URL. "
+        "This tool downloads the Word document from the provided URL, "
+        "converts it to Markdown format, and returns the content. "
+        "Useful for processing Word documents and making them easier to analyze by LLMs."
+        "\nThe input must be the complete URL of the Word document."
+    )
+    return_direct: bool = False
+    _temp_dir: Optional[str] = None
+
+    async def _download_file(self, url: str) -> str:
+        """Downloads a file from a URL to a temporary file."""
+        # Create a temporary directory if it doesn't exist
+        if not self._temp_dir:
+            self._temp_dir = tempfile.mkdtemp()
+
+        # Get the filename from the URL
+        parsed_url = urlparse(url)
+        filename = os.path.basename(parsed_url.path)
+        if not filename.endswith(('.docx', '.doc')):
+            filename += '.docx'  # Add extension if it doesn't exist
+
+        # Complete path to the temporary file
+        file_path = os.path.join(self._temp_dir, filename)
+
+        # Download the file
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    raise Exception(f"Error downloading the file: {response.status}")
+
+                # Save the file
+                async with aiofiles.open(file_path, 'wb') as f:
+                    await f.write(await response.read())
+
+        return file_path
+
+    async def _convert_to_markdown(self, file_path: str) -> str:
+        """Converts a Word document to Markdown."""
+        # Use mammoth to convert to HTML and then to Markdown
+        with open(file_path, "rb") as docx_file:
+            result = mammoth.convert_to_html(docx_file)
+            html = result.value
+            markdown_text = md(html)
+
+            # If there are warning messages, add them as a comment at the beginning
+            if result.messages:
+                warnings = "\n".join([f"<!-- Warning: {msg} -->" for msg in result.messages])
+                markdown_text = f"{warnings}\n\n{markdown_text}"
+
+            return markdown_text
+
+    async def _process_word_document(self, url: str) -> Dict[str, Any]:
+        """Processes a Word document from a URL and converts it to Markdown."""
+        try:
+            file_path = await self._download_file(url)
+            markdown_text = await self._convert_to_markdown(file_path)
+
+            # Cleanup of temporary files
+            if os.path.exists(file_path):
+                os.remove(file_path)
+
+            return {
+                "markdown": markdown_text,
+                "source_url": url,
+                "success": True
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source_url": url,
+                "success": False
+            }
+        finally:
+            # Ensure cleanup of the temporary directory if it's empty
+            if self._temp_dir and os.path.exists(self._temp_dir) and not os.listdir(self._temp_dir):
+                os.rmdir(self._temp_dir)
+
+    async def _arun(self, url: str) -> Dict[str, Any]:
+        """Runs the tool asynchronously."""
+        return await self._process_word_document(url)
+
+    def _run(self, url: str) -> Dict[str, Any]:
+        """Runs the tool synchronously."""
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            return loop.run_until_complete(self._process_word_document(url))
+        else:
+            return asyncio.run(self._process_word_document(url))

parrot/tools/duck.py

@@ -0,0 +1,62 @@
+from typing import Any
+from pydantic import PrivateAttr
+from langchain_community.tools.ddg_search.tool import (
+    DuckDuckGoSearchResults,
+    DuckDuckGoSearchAPIWrapper
+)
+from duckduckgo_search import DDGS
+from langchain.tools import BaseTool
+
+
+class DuckDuckGoSearchTool(BaseTool):
+    """Web Search tool using Duck Duck Go API."""
+    name: str = "duckduckgo_search"
+    description: str = "Search the web using DuckDuckGo Search."
+    source: Any = None
+    max_results: int = 5
+    region: str = None
+
+    def __init__(self, source: str = "news", results: int = 5, region: str = 'wt-wt', **kwargs: Any):
+        super().__init__(**kwargs)
+        self.source = source
+        self.max_results = results
+        self.region = region
+
+    def _run(self, query: str) -> dict:
+        """Run the DuckDuckGo Search Tool."""
+        wrapper = DuckDuckGoSearchAPIWrapper(
+            region=self.region,
+            time="y",
+            max_results=self.max_results
+        )
+        search = DuckDuckGoSearchResults(
+            api_wrapper=wrapper,
+            source=self.source
+        )
+        return search.run(query)
+
+class DuckDuckGoRelevantSearch(BaseTool):
+    """Web Search tool using Duck Duck Go API."""
+    name: str = "duckduckgo_relevant_search"
+    description: str = "Search the web and extract most relevant information based on DuckDuckGo Search API"
+    _max_results: PrivateAttr
+    _region: PrivateAttr
+
+    def __init__(self, results: int = 5, region: str = 'wt-wt', **kwargs: Any):
+        super().__init__(**kwargs)
+        self._max_results = results
+        self._region = region
+
+    def _run(
+		self,
+        query: str,
+		**kwargs: Any,
+	) -> Any:
+        """Search Internet for relevant information based on a query."""
+        search = DDGS()
+        return search.text(
+            keywords=query,
+            region=self._region,
+            safesearch='moderate',
+            max_results=self._max_results
+        )

parrot/tools/execute.py

@@ -0,0 +1,56 @@
+"""
+Executable Python REPL Tool.
+"""
+import io
+import base64
+import json
+import matplotlib.pyplot as plt
+from langchain_experimental.tools.python.tool import PythonAstREPLTool
+
+
+class ExecutablePythonREPLTool(PythonAstREPLTool):
+    """
+    Executable Python REPL Tool.
+    """
+    def execute_code(self, code: str) -> str:
+        """
+        Execute the provided Python code and return the output.
+
+        Args:
+            code (str): The Python code to execute.
+
+        Returns:
+            str: The output of the executed code.
+        """
+        try:
+            # Set up a namespace for execution
+            namespace = {}
+            exec(code, namespace)
+
+            # Check if a plot was created
+            if 'plt' in namespace:
+                buf = io.BytesIO()
+                plt.savefig(buf, format='png')
+                plt.close()
+                buf.seek(0)
+                # Encode the image in base64
+                # Encode the image in base64
+                img_str = base64.b64encode(buf.read()).decode('utf-8')
+
+                # Prepare the JSON output
+                result = {
+                    "image": {
+                        "format": "png",
+                        "base64": img_str
+                    }
+                }
+                # Return both the code and the JSON result
+                return f"**Code Executed**:\n```python\n{code}\n```\n\n**Result**:\n{json.dumps(result)}"
+            else:
+                return f"**Code Executed**:\n```python\n{code}\n```\n\n"
+
+        except Exception as e:
+            return f"Error executing code: {e}"
+
+    def __call__(self, code: str) -> str:
+        return self.execute_code(code)

parrot/tools/gamma.py

@@ -0,0 +1,28 @@
+import urllib.parse
+from langchain.tools import BaseTool
+
+
+class GammaLink(BaseTool):
+    """Generate a link to Gamma.app with the provided text."""
+    name: str = "gamma_link"
+    description: str = (
+        "Generate a Link to Gamma.App to be used as presentation."
+        " This tool is useful for creating URLs for presentations in Gamma.app."
+    )
+
+    def _run(self, query: str) -> dict:
+        """
+        Generate a link to Gamma.app with the provided text.
+
+        Args:
+            text (str): The text to be included in the Gamma link.
+
+        Returns:
+            str: The Gamma link containing the provided text.
+        """
+        base_url = "https://gamma.app"
+        encoded_text = urllib.parse.quote(query)
+        return {
+            "url": f"{base_url}/create?content={encoded_text}",
+            "text": query
+        }

parrot/tools/google.py

@@ -0,0 +1,170 @@
+from typing import Optional
+import requests
+from googleapiclient.discovery import build
+from pydantic import PrivateAttr
+# from crewai_tools import BaseTool
+from langchain.tools import BaseTool
+from navconfig import config
+from ..conf import GOOGLE_API_KEY
+
+
+class GoogleSearchTool(BaseTool):
+    """Web Search tool using Google API."""
+    name: str = "Google Web Search"
+    description: str = (
+        "Search the web using Google Search API, useful when you need to answer questions about current events.",
+        " Use this tool more than the Wikipedia tool if you are asked about current events, recent information, or news"
+    )
+    source: str = 'news'
+    max_results: int = 5
+    region: str = 'US'
+    # Fields populated during init (not required for validation)
+    cse_id: Optional[str] = None
+    search_key: Optional[str] = None
+    kwargs: Optional[dict] = None
+
+    def __init__(self, source: str = "news", results: int = 5, **kwargs):
+        super().__init__(**kwargs)
+        self.source = source
+        self.max_results = results
+        self.cse_id = config.get('GOOGLE_SEARCH_ENGINE_ID')
+        self.search_key = config.get('GOOGLE_SEARCH_API_KEY')
+        self.kwargs = kwargs
+
+    def _run(self, query: str) -> list:
+        """Run the Google Search Tool."""
+        service = build("customsearch", "v1", developerKey=self.search_key)
+        res = service.cse().list(  # pylint: disable=no-member
+            q=query,
+            cx=self.cse_id,
+            num=self.max_results,
+            **self.kwargs
+        ).execute()
+        results = []
+        for item in res['items']:
+            results.append(
+                {
+                    'snippet': item['snippet'],
+                    'title': item['title'],
+                    'link': item['link'],
+                    'description': item['snippet']
+                }
+            )
+        return results
+
+
+class GoogleSiteSearchTool(BaseTool):
+    """Web Search under a site using Google API."""
+    name: str = "Google Site Search"
+    description: str = "Search under a Site using Google Search API"
+    source: str = 'news'
+    max_results: int = 5
+    region: str = ''
+
+    def __init__(self, site: str = "news", results: int = 5, **kwargs):
+        super().__init__(**kwargs)
+        self.source = site
+        self.max_results = results
+        self._cse_id = config.get('GOOGLE_SEARCH_ENGINE_ID')
+        self._search_key = config.get('GOOGLE_SEARCH_API_KEY')
+        self._kwargs = kwargs
+
+    def _run(self, query: str) -> dict:
+        """Run the Google Search Tool."""
+        service = build("customsearch", "v1", developerKey=self._search_key)
+        qs = f'{query} site:{self.source}'
+        res = service.cse().list(  # pylint: disable=no-member
+            q=qs,
+            cx=self._cse_id,
+            num=self.max_results,
+            **self._kwargs
+        ).execute()
+        results = []
+        for item in res['items']:
+            results.append(
+                {
+                    'snippet': item['snippet'],
+                    'title': item['title'],
+                    'link': item['link'],
+                    'description': item['snippet']
+                }
+            )
+        return results
+
+
+class GoogleLocationFinder(BaseTool):
+    """ LocationFinder class for finding locations."""
+    name: str = "google_maps_location_finder"
+    description: str = (
+        "Search for location information, use this tool to find latitude, longitude and other geographical information from locations."
+        " Provide the complete address to this tool to receive location information"
+    )
+    google_key: str = None
+    base_url: str = "https://maps.googleapis.com/maps/api/geocode/json"
+    kwargs: Optional[dict] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.google_key = kwargs.get('api_key', GOOGLE_API_KEY)
+        self.kwargs = kwargs
+
+    def extract_location(self, data):
+        city = state = state_code = zipcode = None
+        try:
+            for component in data['address_components']:
+                if 'locality' in component['types']:
+                    city = component['long_name']
+                elif 'administrative_area_level_1' in component['types']:
+                    state_code = component['short_name']
+                    state = component['long_name']
+                elif 'postal_code' in component['types']:
+                    zipcode = component['long_name']
+        except Exception:
+            pass
+        return city, state, state_code, zipcode
+
+    def _run(self, query: str) -> dict:
+        """Find Location."""
+        params = {
+            "address": query,
+            "key": self.google_key
+        }
+        response = requests.get(
+            self.base_url,
+            params=params
+        )
+        if response.status_code == 200:
+            result = response.json()
+            if result['status'] == 'OK':
+                location = result['results'][0]
+                city, state, state_code, zipcode = self.extract_location(
+                    location
+                )
+                return  {
+                    "latitude": location['geometry']['location']['lat'],
+                    "longitude": location['geometry']['location']['lng'],
+                    "address": location['formatted_address'],
+                    "place_id": location['place_id'],
+                    "zipcode": zipcode,
+                    "city": city,
+                    "state": state,
+                    "state_code": state_code
+                }
+            return None
+        else:
+            return None
+
+class GoogleRouteSearch(BaseTool):
+    """Route Search tool using Google Maps API."""
+    name: str = "google_maps_route_search"
+    description: str = "Search for a Route to a location using Google Maps, using this tool if answers questions about how to reach a location."
+    google_key: str = None
+    base_url: str = 'https://maps.googleapis.com/maps/api/directions/json'
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._key_ = kwargs.get('api_key', GOOGLE_API_KEY)
+        self._kwargs = kwargs
+
+    def _run(self, query: str) -> dict:
+        departure_time = 'now'