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

parrot/crew/__init__.py

@@ -0,0 +1,3 @@
+"""
+NAV Crew is using CrewAI to manage the crew members and their roles.
+"""

parrot/crew/tools/__init__.py

@@ -0,0 +1,22 @@
+"""
+A Directory for adding more Tools to CrewAI
+"""
+from .duckgo import DuckDuckGoRelevantSearch, DuckDuckGoSearchTool
+from .rag import RagSearchTool
+from .file import SaveFile
+from .bing import BingSearchTool
+from .md2pdf import MarkdownToPDFTool
+from .google import GoogleSearchTool, GoogleSiteSearchTool, GoogleLocationFinder
+
+
+__all__ = [
+    'GoogleSearchTool',
+    'GoogleSiteSearchTool',
+    'BingSearchTool',
+    'DuckDuckGoRelevantSearch',
+    'DuckDuckGoSearchTool',
+    'RagSearchTool',
+    'SaveFile',
+    'MarkdownToPDFTool',
+    'GoogleLocationFinder',
+]

parrot/crew/tools/bing.py

@@ -0,0 +1,13 @@
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from crewai_tools import BaseTool
+
+
+class BingSearchTool(BaseTool):
+    """Microsoft Bing Search Tool."""
+    name: str = "Microsoft Bing Search"
+    description: str = "Search the web using Microsoft Bing Search API"
+
+    def _run(self, query: str) -> dict:
+        """Run the Bing Search Tool."""
+        bing = BingSearchAPIWrapper(k=5)
+        return bing.results(query=query, num_results=5)

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

parrot/handlers/bots.py

@@ -0,0 +1,196 @@
+from asyncdb import AsyncDB
+from navigator.views import (
+    ModelView,
+    BaseView,
+    FormModel
+)
+from parrot.conf import (
+    BIGQUERY_CREDENTIALS,
+    BIGQUERY_PROJECT_ID,
+)
+from ..models import (
+    ChatbotModel,
+    ChatbotUsage,
+    PromptLibrary,
+    ChatbotFeedback,
+    FeedbackType
+)
+
+
+class PromptLibraryManagement(ModelView):
+    """
+    PromptLibraryManagement.
+    description: PromptLibraryManagement for Parrot Application.
+    """
+
+    model = PromptLibrary
+    name: str = "Prompt Library Management"
+    path: str = '/api/v1/prompt_library'
+    pk: str = 'prompt_id'
+
+    async def _set_created_by(self, value, column, data):
+        if not value:
+            return await self.get_userid(session=self._session)
+        return value
+
+
+class ChatbotUsageHandler(ModelView):
+    """
+    ChatbotUsageHandler.
+    description: ChatbotUsageHandler for Parrot Application.
+    """
+
+    model = ChatbotUsage
+    driver: str = 'scylladb'
+    credentials: dict = {
+        "credentials": BIGQUERY_CREDENTIALS,
+        "project_id": BIGQUERY_PROJECT_ID,
+    }
+    name: str = "Chatbot Usage"
+    path: str = '/api/v1/chatbots/usage'
+    pk: str = 'sid'
+
+
+class ChatbotSharingQuestion(BaseView):
+    """
+    ChatbotSharingQuestion.
+    description: ChatbotSharingQuestion for Parrot Application.
+    """
+
+    def get_connection(self):
+        params = {
+            "credentials": BIGQUERY_CREDENTIALS,
+            "project_id": BIGQUERY_PROJECT_ID,
+        }
+        return AsyncDB(
+            'bigquery',
+            params=params
+        )
+
+    async def get(self):
+        qs = self.get_arguments(self.request)
+        sid = qs.get('sid', None)
+        if not sid:
+            return self.error(
+                response={
+                    "message": "You need to Provided a ID of Question"
+                },
+                status=400
+            )
+        db = self.get_connection()
+        try:
+            async with await db.connection() as conn:  #pylint: disable=E1101
+                ChatbotUsage.Meta.connection = conn
+                # Getting a SID from sid
+                question = await ChatbotUsage.get(sid=sid)
+                if not question:
+                    return self.error(
+                        response={
+                            "message": "Question not found"
+                        },
+                        status=404
+                    )
+                return self.json_response(
+                    {
+                        "chatbot": question.chatbot_id,
+                        "question": question.question,
+                        "answer": question.response,
+                        "at": question.used_at
+                    }
+                )
+        except Exception as e:
+            return self.error(
+                response={
+                    "message": f"Error on Chatbot Sharing Question: {e}"
+                },
+                status=400
+            )
+
+
+
+class FeedbackTypeHandler(BaseView):
+    """
+    FeedbackTypeHandler.
+    description: FeedbackTypeHandler for Parrot Application.
+    """
+
+    async def get(self):
+        qs = self.get_arguments(self.request)
+        category = qs.get('feedback_type', 'good').capitalize()
+        feedback_list = FeedbackType.list_feedback(category)
+        return self.json_response({
+            "feedback": feedback_list
+        })
+
+# Manage Feedback:
+class ChatbotFeedbackHandler(FormModel):
+    """
+    ChatbotFeedbackHandler.
+    description: ChatbotFeedbackHandler for Parrot Application.
+    """
+    model = ChatbotFeedback
+    path: str = '/api/v1/bot_feedback'
+
+    def get_connection(self):
+        params = {
+            "credentials": BIGQUERY_CREDENTIALS,
+            "project_id": BIGQUERY_PROJECT_ID,
+        }
+        return AsyncDB(
+            'bigquery',
+            params=params,
+            force_closing=False
+        )
+
+    async def post(self):
+        feedback = await self.validate_payload()
+        if not feedback:
+            return self.error(
+                response={
+                    "message": "Error on Bot Feedback"
+                },
+                status=400
+            )
+        db = self.get_connection()
+        try:
+            async with await db.connection() as conn:  #pylint: disable=E1101
+                data = feedback.to_dict()
+                # convert to string (bigquery uses json.dumps to convert to string)
+                data['sid'] = str(data['sid'])
+                data['chatbot_id'] = str(data['chatbot_id'])
+                data['expiration_timestamp'] = str(data['expiration_timestamp'])
+                data['feedback_type'] = feedback.feedback_type.value
+                # writing directly to bigquery
+                await conn.write(
+                    [data],
+                    table_id=ChatbotFeedback.Meta.name,
+                    dataset_id=ChatbotFeedback.Meta.schema,
+                    use_streams=False,
+                    use_pandas=False
+                )
+                return self.json_response({
+                    "message": "Bot Feedback Submitted, Thank you for your feedback!.",
+                    "question": f"Question of ID: {feedback.sid} for bot {feedback.chatbot_id}"
+                }, status=201)
+        except Exception as e:
+            return self.error(
+                response={
+                    "message": f"Error on Bot Feedback: {e}"
+                },
+                status=400
+            )
+
+
+class ChatbotHandler(ModelView):
+    """
+    ChatbotHandler.
+    description: ChatbotHandler for Parrot Application.
+    """
+
+    model = ChatbotModel
+    name: str = "Chatbot Management"
+    pk: str = 'chatbot_id'
+
+
+    async def _set_created_by(self, value, column, data):
+        return await self.get_userid(session=self._session)