ai-parrot 0.8.3__cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/crew/tools/config.py

@@ -0,0 +1,43 @@
+
+def agent_config(
+    provider: str = 'vertexai',
+    model: str = 'gemini-pro',
+    temperature: float = 0.4,
+    top_p: int = 0.5,
+    stream: bool = True
+    ) -> dict:
+    agent_config ={
+        # "llm": {
+        #     "provider": provider,
+        #     "config": {
+        #         "model": model,
+        #         "temperature": temperature,
+        #         "top_p": top_p,
+        #         "stream": stream
+        #     }
+        # },
+        "embedder": {
+            "provider": "huggingface",
+            "config": {
+                "model": "sentence-transformers/sentence-t5-large",
+            }
+        }
+    }
+    return agent_config
+
+
+def agent_embedder(
+    provider: str = 'huggingface',
+    model: str = 'sentence-transformers/sentence-t5-large',
+    **kwargs
+    ) -> dict:
+    agent_config ={
+        "embedder": {
+            "provider": "huggingface",
+            "config": {
+                "model": "sentence-transformers/sentence-t5-large",
+                **kwargs
+            }
+        }
+    }
+    return agent_config

parrot/crew/tools/duckgo.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 crewai_tools import BaseTool
+
+
+class DuckDuckGoSearchTool(BaseTool):
+    """Web Search tool using Duck Duck Go API."""
+    name: str = "DuckDuckGo Web Search"
+    description: str = "Search the web using DuckDuckGo Search API"
+    _source: PrivateAttr
+    _max_results: PrivateAttr
+    _region: PrivateAttr
+
+    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 using 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/crew/tools/file.py

@@ -0,0 +1,24 @@
+from typing import Union
+from pathlib import Path, PurePath
+from pydantic import PrivateAttr
+from crewai_tools import BaseTool
+
+
+class SaveFile(BaseTool):
+    """Save a file to a directory."""
+    name: str = "Save File"
+    description: str = "Save a file to a directory."
+    _directory: PrivateAttr
+
+    def __init__(self, directory: Union[str, PurePath], **kwargs):
+        super().__init__(**kwargs)
+        if isinstance(directory, str):
+            self._directory = Path(directory).resolve()
+        self._directory = directory
+
+    def _run(self, file: str, **kwargs) -> dict:
+        """Run the Save File Tool."""
+        filename = self._directory.joinpath(file)
+        with open(filename, "w") as f:
+            f.write(kwargs.get("content", ""))
+        return {"file": file}

parrot/crew/tools/google.py

@@ -0,0 +1,168 @@
+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 langchain.tools import Tool
+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."
+    source: str = 'news'
+    max_results: int = 5
+    region: str = ''
+    # 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(
+            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 Web Search"
+    description: str = "Search the web 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(
+            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):
+    """Web Search under a site using Google 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'

parrot/crew/tools/gtrends.py

@@ -0,0 +1,16 @@
+from langchain_community.tools.google_trends import GoogleTrendsQueryRun
+from langchain_community.utilities.google_trends import GoogleTrendsAPIWrapper
+from crewai_tools import BaseTool
+
+
+class GoogleTrendsTool(BaseTool):
+    """Google Trends Tool."""
+    name: str = "Google Trends"
+    description: str = "Search the web using Google Trends API"
+
+    def _run(self, query: str) -> dict:
+        """Run the Google Trends Tool."""
+        google_trends = GoogleTrendsQueryRun(
+            api_wrapper=GoogleTrendsAPIWrapper()
+        )
+        return google_trends.run(query)

parrot/crew/tools/md2pdf.py

@@ -0,0 +1,25 @@
+from navconfig import BASE_DIR
+from crewai_tools import BaseTool
+import markdown2
+from weasyprint import HTML
+
+
+class MarkdownToPDFTool(BaseTool):
+    """Markdown to PDF Tool."""
+    name: str = "MarkdownToPDFTool"
+    description: str = "Converts markdown documents to PDF format."
+
+    def _run(self, markdown_content: str) -> str:
+        # Convert Markdown to HTML
+        html_content = markdown2.markdown(markdown_content)
+        # Convert HTML to PDF (assuming it's a simple conversion without advanced styling)
+        pdf = HTML(string=html_content).write_pdf()
+
+        # Save PDF to a temporary file and return file path
+        pdf_file_path = BASE_DIR.joinpath('docs', 'report.pdf')
+        with open(str(pdf_file_path), 'wb') as f:
+            f.write(pdf)
+        return pdf_file_path
+
+    def __call__(self, markdown_content: str) -> str:
+        return self._run(markdown_content)

parrot/crew/tools/rag.py

@@ -0,0 +1,42 @@
+from typing import Union
+from pathlib import Path
+from pydantic import PrivateAttr
+from crewai_tools import BaseTool, RagTool
+
+class RagSearchTool(BaseTool):
+    """RagTool is designed to answer questions by leveraging the power of RAG by leveraging (EmbedChain)."""
+    name: str = "RAG Tool"
+    description: str = "enables users to dynamically query a knowledge base"
+    _directory: PrivateAttr
+
+    def __init__(self, directory: Union[Path, str] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._directory = directory
+
+    def get_rag(self):
+        """Return the RAG Tool."""
+        return RagTool(
+            config={
+                "llm": {
+                    "provider": "vertexai",
+                    "config": {
+                        "model": "gemini-pro",
+                        "temperature": 0.4,
+                        "top_p": 1,
+                        "stream": True
+                    }
+                },
+                "embedder": {
+                    "provider": "vertexai",
+                    "config": {
+                        "model": "embedding-001"
+                    }
+                }
+            }
+        )
+
+    def _run(self, query: str, **kwargs) -> dict:
+        """Query Several sources of information for knowledge base."""
+        rag = self.get_rag()
+        if self._directory:
+            return rag.from_directory(self._directory)

parrot/crew/tools/search.py

@@ -0,0 +1,32 @@
+from crewai_tools import WebsiteSearchTool
+from crewai_tools import BaseTool
+
+
+class WebSearchTool(BaseTool):
+    """Search on any Website using WebSiteSearch."""
+    name: str = "WebSite Search"
+    description: str = "Search on a website using WebsiteSearchTool"
+
+    def _run(self, query: str, **kwargs) -> dict:
+        """Run the Google Trends Tool."""
+        search = WebsiteSearchTool(
+            config={
+                "llm": {
+                    "provider": "google",
+                    "config": {
+                        "model": "models/gemini-pro",
+                        "temperature": 0.4,
+                        "top_p": 1,
+                        "stream": True
+                    }
+                },
+                "embedder": {
+                    "provider": "google",
+                    "config": {
+                        "model": "models/embedding-001",
+                        "task_type": "retrieval_document",
+                    }
+                }
+            }
+        )
+        return search.run(query, **kwargs)

parrot/crew/tools/url.py

@@ -0,0 +1,21 @@
+import requests
+from crewai_tools import BaseTool
+
+
+class ValidateURLsTool(BaseTool):
+    """Validate URLs Tool."""
+    name: str = "Validate URLs"
+    description: str = "Validate URLs for status code and response time."
+
+    def _run(self, urls: list) -> dict:
+        """Run the Validate URLs Tool."""
+        valid_urls = []
+        for url in urls:
+            try:
+                response = requests.head(url, allow_redirects=True)
+                if response.status_code == 200:
+                    valid_urls.append(url)
+            except requests.RequestException:
+                # Handle exceptions or log errors here
+                continue
+        return valid_urls

parrot/handlers/__init__.py

@@ -0,0 +1,4 @@
+"""
+Parrot basic Handlers.
+"""
+from .bots import ChatbotHandler