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

parrot/tools/wikipedia.py

@@ -0,0 +1,58 @@
+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 = (
+        "Access detailed and verified information from 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 = (
+        "Fetch structured data from WikiData for precise and factual details. "
+        "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 Wikidata tool."""
+        return self.search.run(query)

parrot/tools/zipcode.py

@@ -0,0 +1,198 @@
+from typing import List, Dict, Any, Optional, Type, Union
+import httpx
+from pydantic import BaseModel, Field
+from langchain_core.callbacks import CallbackManagerForToolRun
+from langchain_core.tools import BaseToolkit
+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")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "forbid",  # Helps with compatibility
+        "json_schema_extra": {
+            "required": ["zipcode", "sku", "location_id"]
+        }
+    }
+
+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")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "forbid",  # Helps with compatibility
+        "json_schema_extra": {
+            "required": ["zipcode", "sku", "location_id"]
+        }
+    }
+
+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")
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "forbid",  # Helps with compatibility
+        "json_schema_extra": {
+            "required": ["zipcode", "sku", "location_id"]
+        }
+    }
+
+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')."
+    )
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "forbid",  # Helps with compatibility
+        "json_schema_extra": {
+            "required": ["zipcode", "sku", "location_id"]
+        }
+    }
+
+    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."
+    )
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "forbid",  # Helps with compatibility
+        "json_schema_extra": {
+            "required": ["zipcode", "sku", "location_id"]
+        }
+    }
+
+    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."
+    )
+
+    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.
+    """
+
+    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',
+)

parrot/utils/toml.py

@@ -0,0 +1,11 @@
+from .parsers import TOMLParser
+
+
+async def parse_toml_config(config_dir: str) -> dict:
+    try:
+        parser = TOMLParser()
+        return await parser.parse(config_dir)
+    except Exception as exc:
+        raise ValueError(
+            f"Error Parsing TOML Config on {config_dir}: {exc}"
+        )

parrot/utils/uv.py

@@ -0,0 +1,11 @@
+import asyncio
+
+
+def install_uvloop():
+    """install uvloop and set as default loop for asyncio."""
+    try:
+        import uvloop  # noqa # pylint: disable=import-outside-toplevel
+        asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+        uvloop.install()
+    except ImportError:
+        pass

parrot/version.py

@@ -0,0 +1,10 @@
+"""Nav Parrot Meta information."""
+
+__title__ = "ai-parrot"
+__description__ = "Live Chatbots based on Langchain chatbots and Agents \
+    Integrated into Navigator Framework or used into any aiohttp applications."
+__version__ = "0.8.3"
+__author__ = "Jesus Lara"
+__author_email__ = "jesuslarag@gmail.com"
+__license__ = "MIT"
+__copyright__ = 'Copyright (c) 2020-2024 Jesus Lara'

resources/users/__init__.py

@@ -0,0 +1,5 @@
+from .models import User, UserIdentity
+from .handlers import ADUserHandler, ADPeopleHandler
+
+
+__all__ = ('User', 'ADUserHandler', 'ADPeopleHandler', )

resources/users/handlers.py

@@ -0,0 +1,13 @@
+from datamodel import BaseModel
+from navigator.views import ModelView
+from .models import ADUser, ADPeople
+
+
+class ADUserHandler(ModelView):
+    model: BaseModel = ADUser
+    pk: str = 'people_id'
+
+
+class ADPeopleHandler(ModelView):
+    model: BaseModel = ADPeople
+    pk: str = 'people_id'

resources/users/models.py

@@ -0,0 +1,205 @@
+from typing import Optional, List
+from datetime import datetime, timedelta
+from uuid import UUID
+from datamodel.types import Text
+from asyncdb.models import Column, Model
+from navigator_auth.conf import AUTH_DB_SCHEMA, AUTH_USERS_VIEW
+
+
+class User(Model):
+    """Basic User notation."""
+
+    user_id: int = Column(
+        required=False,
+        primary_key=True,
+        db_default="auto"
+    )
+    first_name: str
+    last_name: str
+    display_name: str
+    email: str = Column(required=False, max=254)
+    alt_email: str = Column(required=False, max=254)
+    password: str = Column(required=False, max=128)
+    last_login: datetime = Column(required=False)
+    username: str = Column(required=False)
+    is_superuser: bool = Column(required=True, default=False)
+    is_active: bool = Column(required=True, default=True)
+    is_new: bool = Column(required=True, default=True)
+    is_staff: bool = Column(required=False, default=True)
+    title: str = Column(equired=False, max=90)
+    avatar: str = Column(max=512)
+    associate_id: str = Column(required=False)
+    associate_oid: str = Column(required=False)
+    department_code: str = Column(required=False)
+    job_code: str = Column(required=False)
+    position_id: str = Column(required=False)
+    group_id: list = Column(required=False)
+    groups: list = Column(required=False)
+    program_id: list = Column(required=False)
+    programs: list = Column(required=False)
+    start_date: datetime = Column(required=False)
+    birthday: str = Column(required=False)
+    worker_type: str = Column(required=False)
+    created_at: datetime = Column(required=False)
+
+    def birth_date(self):
+        if self.birthday:
+            _, month, day = self.birthday.split('-')
+            # Get the current year
+            current_year = datetime.now().year
+            # Create a new date string with the current year
+            new_date_str = f"{current_year}-{month}-{day}"
+            # Convert the new date string to a datetime object
+            return datetime.strptime(new_date_str, "%Y-%m-%d").date()
+        return None
+
+    def employment_duration(self):
+        if not self.start_date:
+            return None, None, None
+        # Get today's date
+        today = datetime.now().date()
+        # employment:
+        employment = self.start_date
+
+        # Calculate the difference in years, months, days
+        years = today.year - employment.year
+        months = today.month - employment.month
+        days = today.day - employment.day
+
+        # Adjust for cases where the current month is before the start month
+        if months < 0:
+            years -= 1
+            months += 12
+
+        # Adjust for cases where the current day
+        # is before the start day in the month
+        if days < 0:
+            # Subtract one month and calculate days based on the previous month
+            months -= 1
+            if months < 0:
+                years -= 1
+                months += 12
+            # Calculate the last day of the previous month
+            last_day_of_prev_month = (
+                today.replace(day=1) - timedelta(days=1)
+            ).day
+            days += last_day_of_prev_month
+
+        # Adjust months and years again if necessary
+        if months < 0:
+            years -= 1
+            months += 12
+
+        return years, months, days
+
+    class Meta:
+        driver = "pg"
+        name = AUTH_USERS_VIEW
+        schema = AUTH_DB_SCHEMA
+        description = 'View Model for getting Users.'
+        strict = True
+        frozen = False
+
+
+class UserIdentity(Model):
+
+    identity_id: UUID = Column(
+        required=False,
+        primary_key=True,
+        db_default="auto",
+        repr=False
+    )
+    display_name: str = Column(required=False)
+    title: str = Column(required=False)
+    nickname: str = Column(required=False)
+    email: str = Column(required=False)
+    phone: str = Column(required=False)
+    short_bio: Text = Column(required=False)
+    avatar: str = Column(required=False)
+    user_id: User = Column(required=False, repr=False)
+    auth_provider: str = Column(required=False)
+    auth_data: Optional[dict] = Column(required=False, repr=False)
+    attributes: Optional[dict] = Column(required=False, repr=False)
+    created_at: datetime = Column(
+        required=False,
+        default=datetime.now(),
+        repr=False
+    )
+
+    class Meta:
+        driver = "pg"
+        name = "user_identities"
+        description = 'Manage User Identities.'
+        schema = AUTH_DB_SCHEMA
+        strict = True
+
+class ADUser(Model):
+    """Active Directory Users."""
+    people_id: UUID = Column(
+        required=False,
+        primary_key=True,
+        db_default="auto",
+        repr=False
+    )
+    username: str = Column(required=False)
+    display_name: str = Column(required=False)
+    given_name: str = Column(required=False)
+    last_name: str = Column(required=False)
+    phones: Optional[list] = Column(required=False)
+    mobile: str = Column(required=False)
+    job_title: str = Column(required=False)
+    email: str = Column(required=False)
+    office_location: str = Column(required=False)
+    preferred_language: str = Column(required=False)
+    associate_id: str = Column(required=False)
+    associate_oid: str = Column(required=False)
+    job_code_title: str = Column(required=False)
+    position_id: str = Column(required=False)
+    zammad_created: bool = Column(required=False, default=False)
+    created_at: datetime = Column(
+        required=False,
+        default=datetime.now(),
+        repr=False
+    )
+
+    class Meta:
+        name = 'people'
+        schema = 'troc'
+        strict = True
+
+
+class ADPeople(Model):
+    """Active Directory Users."""
+    people_id: UUID = Column(
+        required=False,
+        primary_key=True,
+        db_default="auto",
+        repr=False
+    )
+    user_id: int = Column(required=True)
+    userid: UUID = Column(required=False)
+    username: str = Column(required=False)
+    display_name: str = Column(required=False)
+    given_name: str = Column(required=False)
+    last_name: str = Column(required=False)
+    phones: Optional[list] = Column(required=False)
+    mobile: str = Column(required=False)
+    job_title: str = Column(required=False)
+    email: str = Column(required=False)
+    alt_email: str = Column(required=False)
+    office_location: str = Column(required=False)
+    preferred_language: str = Column(required=False)
+    associate_id: str = Column(required=False)
+    associate_oid: str = Column(required=False)
+    job_code_title: str = Column(required=False)
+    position_id: str = Column(required=False)
+    created_at: datetime = Column(
+        required=False,
+        default=datetime.now(),
+        repr=False
+    )
+
+    class Meta:
+        name = 'vw_people'
+        schema = 'troc'
+        strict = True