ai-parrot 0.1.0__cp311-cp311-manylinux_2_28_x86_64.whl

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)

parrot/tools/zipcode.py

@@ -0,0 +1,179 @@
+from typing import List, Dict, Any, Optional, Type, Union
+import httpx
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseToolkit
+from langchain_core.pydantic_v1 import BaseModel, Field, Extra
+from langchain_core.tools import BaseTool
+from navconfig import config
+from .abstract import AbstractTool
+
+
+class ZipcodeDistanceInput(BaseModel):
+    """Input for the Zipcode Distance Tool."""
+    zipcode1: Union[str, int] = Field(description="The first zipcode.")
+    zipcode2: Union[str, int] = Field(description="The second zipcode.")
+    unit: Optional[str] = Field(description="The unit of the distance.", default="mile")
+
+
+class ZipcodeRadiusInput(BaseModel):
+    """Input for the Zipcode Radius Tool."""
+    zipcode: Union[str, int] = Field(description="The zipcode.")
+    radius: int = Field(description="The radius in miles.", default=5)
+    unit: Optional[str] = Field(description="The unit of the distance.", default="mile")
+
+
+class ZipcodeLocationInput(BaseModel):
+    """Input for the Zipcode Location Tool."""
+    zipcode: Union[str, int] = Field(description="The zipcode.")
+    unit: Optional[str] = Field(description="The unit of the distance.", default="degrees")
+
+
+class ZipcodeDistance(AbstractTool):
+    """Tool for calculating the distance between two zipcodes."""
+
+    name: str = "zipcode_distance"
+    verbose: bool = True
+    args_schema: Type[BaseModel] = ZipcodeDistanceInput
+    description: str = (
+        "Use this tool to calculate the distance between two zipcodes."
+        " Zipcodes must be provided as a couple of strings (e.g., '33066')."
+    )
+
+    class Config:
+        """Configuration for this pydantic object."""
+        # extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    def _search(
+        self,
+        zipcode1: str,
+        zipcode2: str,
+        unit: Optional[str] = 'mile',
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Dict[str, Any]:  # Changed to Dict
+        api_key = config.get('ZIPCODE_API_KEY')
+        url = f"https://www.zipcodeapi.com/rest/{api_key}/distance.json/{zipcode1}/{zipcode2}/{unit}"
+
+        try:
+            response = httpx.get(url)
+            response.raise_for_status()  # Check for API errors
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(f"Error fetching zipcode distance: {e}") from e
+
+    async def _asearch(
+        self,
+        zipcode1: str,
+        zipcode2: str,
+        unit: Optional[str] = 'mile',
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Dict[str, Any]:
+        api_key = config.get('ZIPCODE_API_KEY')
+        url = f"https://www.zipcodeapi.com/rest/{api_key}/distance.json/{zipcode1}/{zipcode2}/{unit}"
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()  # Check for API errors
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(f"Error fetching zipcode distance: {e}") from e
+
+
+class ZipcodeRadius(AbstractTool):
+    """Tool for calculating the distance between two zipcodes."""
+
+    name: str = "zipcodes_by_radius"
+    verbose: bool = True
+    args_schema: Type[BaseModel] = ZipcodeRadiusInput
+    description: str = (
+        "Use this Tool to find all US zip codes within a given radius of a zip code."
+        " Provides a Zipcode and a radius."
+    )
+
+    class Config:
+        """Configuration for this pydantic object."""
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    def _search(
+        self,
+        zipcode: Union[str, int],
+        radius: int = 5,
+        unit: Optional[str] = 'mile',
+    ) -> Dict[str, Any]:  # Changed to Dict
+        api_key = config.get('ZIPCODE_API_KEY')
+        url = f"https://www.zipcodeapi.com/rest/{api_key}/radius.json/{zipcode}/{radius}/{unit}"
+        try:
+            response = httpx.get(url)
+            response.raise_for_status()  # Check for API errors
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(f"Error fetching zipcode distance: {e}") from e
+
+    async def _asearch(
+        self,
+        zipcode: str,
+        radius: int,
+        unit: Optional[str] = 'mile'
+    ) -> Dict[str, Any]:
+        api_key = config.get('ZIPCODE_API_KEY')
+        url = f"https://www.zipcodeapi.com/rest/{api_key}/radius.json/{zipcode}/{radius}/{unit}"
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()  # Check for API errors
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(f"Error fetching zipcode distance: {e}") from e
+
+
+
+class ZipcodeLocation(AbstractTool):
+    """Tool for calculating Geographical information about a Zipcode."""
+
+    name: str = "zipcode_location"
+    verbose: bool = True
+    args_schema: Type[BaseModel] = ZipcodeLocationInput
+    description: str = (
+        "Use this Tool to find out the city, state, latitude, longitude, and time zone information for a US zip code."
+        " Use this tool to find geographical information about a zipcode. "
+        " Provides only a Zipcode as string."
+    )
+
+    class Config:
+        """Configuration for this pydantic object."""
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    def _search(
+        self,
+        zipcode: str,
+        unit: Optional[str] = 'degrees'
+    ) -> Dict[str, Any]:  # Changed to Dict
+        api_key = config.get('ZIPCODE_API_KEY')
+        url = f"https://www.zipcodeapi.com/rest/{api_key}/info.json/{zipcode}/{unit}"
+
+        try:
+            response = httpx.get(url)
+            response.raise_for_status()  # Check for API errors
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(f"Error fetching zipcode distance: {e}") from e
+
+
+class ZipcodeAPIToolkit(BaseToolkit):
+    """Toolkit for interacting with ZipcodeAPI.
+    """
+    class Config:
+        """Pydantic config."""
+        arbitrary_types_allowed = True
+
+    def get_tools(self) -> List[BaseTool]:
+        """Get the tools in the toolkit."""
+        return [
+            ZipcodeLocation(),
+            ZipcodeRadius(),
+            ZipcodeDistance()
+        ]

parrot/utils/__init__.py

@@ -0,0 +1,2 @@
+from .types import SafeDict  # pylint: disable=no-name-in-module
+from .toml import parse_toml_config

parrot/utils/parsers/__init__.py

@@ -0,0 +1,5 @@
+from .toml import TOMLParser
+
+__all__ = (
+    'TOMLParser',
+)