ai-parrot 0.3.4__cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/stores/qdrant.py

@@ -0,0 +1,153 @@
+from typing import Any
+from qdrant_client import QdrantClient  # pylint: disable=import-error
+from langchain_community.vectorstores import (  # pylint: disable=import-error, E0611
+    Qdrant
+)
+from .abstract import AbstractStore
+from ..conf import (
+    QDRANT_PROTOCOL,
+    QDRANT_HOST,
+    QDRANT_PORT,
+    QDRANT_USE_HTTPS,
+    QDRANT_CONN_TYPE,
+    QDRANT_URL
+)
+
+
+class QdrantStore(AbstractStore):
+    """QdrantStore class.
+
+
+    Args:
+        host (str): Qdrant host.
+        port (int): Qdrant port.
+        index_name (str): Qdrant index name.
+    """
+
+    def _create_qdrant_client(self, host, port, url, https, verify, qdrant_args):
+        """
+        Creates a Qdrant client based on the provided configuration.
+
+        Args:
+            host: Host of the Qdrant server (if using "server" connection).
+            port: Port of the Qdrant server (if using "server" connection).
+            url: URL of the Qdrant cloud service (if using "cloud" connection).
+            https: Whether to use HTTPS for the connection.
+            verify: Whether to verify the SSL certificate.
+            qdrant_args: Additional arguments for the Qdrant client.
+
+        Returns:
+            A QdrantClient object.
+        """
+        if url is not None:
+            return QdrantClient(
+            url=url,
+            port=None,
+            verify=verify,
+            **qdrant_args
+            )
+        else:
+            return QdrantClient(
+            host,
+            port=port,
+            https=https,
+            verify=verify,
+            **qdrant_args
+            )
+
+    def __init__(self, embeddings = None, **kwargs):
+        super().__init__(embeddings, **kwargs)
+        self.host = kwargs.get("host", QDRANT_HOST)
+        self.port = kwargs.get("port", QDRANT_PORT)
+        qdrant_args = kwargs.get("qdrant_args", {})
+        connection_type = kwargs.get("connection_type", QDRANT_CONN_TYPE)
+        url = kwargs.get("url", QDRANT_URL)
+        if connection_type == "server":
+            self.client = self._create_qdrant_client(
+                self.host, self.port, url, QDRANT_USE_HTTPS, False, qdrant_args
+            )
+        elif connection_type == "cloud":
+            if url is None:
+                raise ValueError(
+                    "A URL is required for 'cloud' connection"
+                )
+            self.client = self._create_qdrant_client(
+                None, None, url, False, False, qdrant_args
+            )
+        else:
+            raise ValueError(
+                f"Invalid connection type: {connection_type}"
+            )
+        if url is not None:
+            self.url = url
+        else:
+            self.url = f"{QDRANT_PROTOCOL}://{self.host}"
+            if self.port:
+                self.url += f":{self.port}"
+
+    def get_vectorstore(self):
+        if self._embed_ is None:
+            _embed_ = self.create_embedding(
+                model_name=self.embedding_name
+            )
+        else:
+            _embed_ = self._embed_
+        self.vector = Qdrant(
+            client=self.client,
+            collection_name=self.collection,
+            embeddings=_embed_,
+        )
+        return self.vector
+
+    async def load_documents(
+        self,
+        documents: list,
+        collection: str = None
+    ):
+        if collection is None:
+            collection = self.collection
+
+        docstore = Qdrant.from_documents(
+            documents,
+            self._embed_,
+            url=self.url,
+            # location=":memory:",  # Local mode with in-memory storage only
+            collection_name=collection,
+            force_recreate=False,
+        )
+        return docstore
+
+    def upsert(self, payload: dict, collection: str = None) -> None:
+        if collection is None:
+            collection = self.collection
+        self.client.upsert(
+            collection_name=collection,
+            points=self._embed_,
+            payload=payload
+        )
+
+    def search(self, payload: dict, collection: str = None) -> dict:
+        pass
+
+    async def delete_collection(self, collection: str = None) -> dict:
+        self.client.delete_collection(
+            collection_name=collection
+        )
+
+    async def create_collection(
+        self,
+        collection_name: str,
+        document: Any,
+        dimension: int = 768,
+        **kwargs
+    ) -> dict:
+        # Here using drop_old=True to force recreate based on the first document
+        docstore = Qdrant.from_documents(
+            [document],
+            self._embed_,
+            url=self.url,
+            # location=":memory:",  # Local mode with in-memory storage only
+            collection_name=collection_name,
+            force_recreate=True,
+        )
+        return docstore

parrot/tools/__init__.py

@@ -0,0 +1,12 @@
+from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
+from langchain_community.tools import YouTubeSearchTool
+from langchain_community.agent_toolkits import O365Toolkit
+from navconfig import config
+from .wikipedia import WikipediaTool, WikidataTool
+from .asknews import AskNewsTool
+from .duck import DuckDuckGoSearchTool, DuckDuckGoRelevantSearch
+from .weather import OpenWeather, OpenWeatherMapTool
+from .google import GoogleLocationFinder, GoogleSiteSearchTool, GoogleSearchTool
+from .zipcode import ZipcodeAPIToolkit
+from .bing import BingSearchTool
+from .stack import StackExchangeTool

parrot/tools/abstract.py

@@ -0,0 +1,53 @@
+from typing import Optional, Dict, Any, Type
+from abc import abstractmethod
+from langchain_core.pydantic_v1 import BaseModel, Field, Extra
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseTool
+
+class AbstractToolArgsSchema(BaseModel):
+    """Schema for the arguments to the AbstractTool."""
+
+    # This Field allows any number of arguments to be passed in.
+    args: list = Field(description="A list of arguments to the tool")
+
+
+class AbstractTool(BaseTool):
+    """Abstract class for tools."""
+
+    args_schema: Type[BaseModel] = AbstractToolArgsSchema
+
+    class Config:
+        """Configuration for this pydantic object."""
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    @abstractmethod
+    def _search(self, query: str) -> str:
+        """Run the tool."""
+
+    async def _asearch(self, *args, **kwargs):
+        """Run the tool asynchronously."""
+        return self._search(*args, **kwargs)
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> Dict[str, Any]:
+        args = [a.strip() for a in query.split(',')]
+        try:
+            return self._search(*args)
+        except Exception as e:
+            raise ValueError(f"Error running tool: {e}") from e
+
+    async def _arun(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None
+    ) -> Dict[str, Any]:
+        """Use the tool asynchronously."""
+        args = [a.strip() for a in query.split(',')]
+        try:
+            return await self._asearch(*args)
+        except Exception as e:
+            raise ValueError(f"Error running tool: {e}") from e

parrot/tools/asknews.py

@@ -0,0 +1,32 @@
+from typing import Any
+import os
+from navconfig import config
+from langchain_community.tools.asknews import AskNewsSearch
+from langchain.tools import BaseTool
+
+class AskNewsTool(BaseTool):
+    """Tool that searches the AskNews API."""
+    name: str = "asknews_search"
+    description: str = (
+        "This tool allows you to perform a search on up-to-date news and historical "
+        "news. If you needs news from more than 48 hours ago, you can estimate the "
+        "number of hours back to search."
+    )
+    search: Any = None
+
+    def __init__(self, max_results: int = 5, **kwargs):
+        super().__init__(**kwargs)
+        os.environ["ASKNEWS_CLIENT_ID"] = config.get('ASKNEWS_CLIENT_ID')
+        os.environ["ASKNEWS_CLIENT_SECRET"] = config.get('ASKNEWS_CLIENT_SECRET')
+        self.search = AskNewsSearch(max_results=5)
+
+    def _run(
+        self,
+        query: str
+    ) -> str:
+        """Use the Wikipedia tool."""
+        return self.search.invoke(
+            {
+                "query": query,
+            }
+        )

parrot/tools/bing.py

@@ -0,0 +1,13 @@
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from langchain.tools import BaseTool
+
+
+class BingSearchTool(BaseTool):
+    """Microsoft Bing Search Tool."""
+    name: str = "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/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 Web Search"
+    description: str = "Search the web using DuckDuckGo Search API"
+    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 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/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 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(  # 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):
+    """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/tools/stack.py

@@ -0,0 +1,26 @@
+from langchain.tools import Tool
+from langchain.tools import BaseTool
+from langchain_community.utilities import StackExchangeAPIWrapper
+
+class StackExchangeTool(BaseTool):
+    """Tool that searches the StackExchangeTool API."""
+    name: str = "StackExchangeSearch"
+    description: str = (
+        "A wrapper around StackExchange API. Stack Exchange is a network of question-and-answer (Q&A) websites on topics in diverse fields, each site covering a specific topic."
+        "Useful for when you need to answer general questions about different topics when user requested."
+    )
+    search: Tool = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.search = StackExchangeAPIWrapper(
+            query_type='title',
+            max_results=5
+        )
+
+    def _run(
+        self,
+        query: dict,
+    ) -> dict:
+        """Use the StackExchangeSearch tool."""
+        return self.search.run(query)

parrot/tools/weather.py

@@ -0,0 +1,70 @@
+import requests
+from langchain.tools import BaseTool
+from langchain.tools import Tool
+from langchain_community.utilities import OpenWeatherMapAPIWrapper
+from navconfig import config
+import orjson
+
+class OpenWeatherMapTool(BaseTool):
+    """Tool that searches the OpenWeatherMap API."""
+    name: str = "OpenWeatherMap"
+    description: str = (
+        "A wrapper around OpenWeatherMap. "
+        "Useful for when you need to answer general questions about "
+        "weather, temperature, humidity, wind speed, or other weather-related information. "
+    )
+    search: Tool = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.search = OpenWeatherMapAPIWrapper(
+            openweathermap_api_key=config.get('OPENWEATHER_APPID')
+        )
+
+    def _run(
+        self,
+        query: dict,
+    ) -> dict:
+        """Use the OpenWeatherMap tool."""
+        return self.search.run(query)
+
+
+class OpenWeather(BaseTool):
+    """
+    Tool to get weather information about a location.
+    """
+    name: str = 'openweather_tool'
+    description: str = (
+        "Get weather information about a location, use this tool to answer questions about weather or weather forecast."
+        " Input should be the latitude and longitude of the location you want weather information about."
+    )
+    base_url: str = 'http://api.openweathermap.org/'
+    units: str = 'metric'
+    days: int = 3
+    appid: str = None
+    request: str = 'weather'
+    country: str = 'us'
+
+
+    def __init__(self, request: str = 'weather', country: str = 'us', **kwargs):
+        super().__init__(**kwargs)
+        self.request = request
+        self.country = country
+        self.appid = config.get('OPENWEATHER_APPID')
+
+    def _run(self, query: dict) -> dict:
+        q = orjson.loads(query)  # pylint: disable=no-member
+        if 'latitude' in q and 'longitude' in q:
+            lat = q['latitude']
+            lon = q['longitude']
+            if self.request == 'weather':
+                url = f"{self.base_url}data/2.5/weather?lat={lat}&lon={lon}&units={self.units}&appid={self.appid}"
+            elif self.request == 'forecast':
+                url = f"{self.base_url}data/2.5/forecast?lat={lat}&lon={lon}&units={self.units}&cnt={self.days}&appid={self.appid}"
+        else:
+            return {'error': 'Latitude and longitude are required'}
+        response = requests.get(url)
+        return response.json()
+
+    async def _arun(self, query: dict) -> dict:
+        raise NotImplementedError("Async method not implemented yet")

parrot/tools/wikipedia.py

@@ -0,0 +1,59 @@
+from typing import Optional, Any
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain_community.tools.wikidata.tool import WikidataAPIWrapper, WikidataQueryRun
+from langchain.tools import BaseTool
+
+
+class WikipediaTool(BaseTool):
+    """Tool that searches the Wikipedia API."""
+    name = "Wikipedia"
+    description: str = (
+        "A wrapper around Wikipedia. "
+        "Useful for searching Wikipedia for general information. "
+        "Useful for when you need to answer general questions about "
+        "people, places, companies, facts, historical events, or other subjects. "
+        "Input should be a search query."
+    )
+    search: Any = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.search = WikipediaQueryRun(
+            api_wrapper=WikipediaAPIWrapper()
+        )
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Use the Wikipedia tool."""
+        return self.search.run(query)
+
+class WikidataTool(BaseTool):
+    """Tool that searches the Wikidata API."""
+    name: str = "Wikidata"
+    description: str = (
+        "A wrapper around Wikidata. "
+        "Useful for when you need to answer general questions about "
+        "people, places, companies, facts, historical events, or other subjects. "
+        "Input should be the exact name of the item you want information about "
+        "or a Wikidata QID."
+    )
+    search: Any = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.search = WikidataQueryRun(
+            api_wrapper=WikidataAPIWrapper()
+        )
+
+    def _run(
+        self,
+        query: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Use the Wikipedia tool."""
+        return self.search.run(query)