ai-parrot 0.8.3__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

parrot/tools/gvoice.py

@@ -0,0 +1,301 @@
+import asyncio
+from pathlib import Path
+from typing import Optional
+import os
+import re
+from xml.sax.saxutils import escape
+from datetime import datetime
+import aiofiles
+# Use v1 for wider feature set including SSML
+from google.cloud import texttospeech_v1 as texttospeech
+from google.oauth2 import service_account
+from pydantic import BaseModel, Field
+from langchain.tools import BaseTool
+from navconfig import BASE_DIR
+from parrot.conf import GOOGLE_TTS_SERVICE
+
+class PodcastInput(BaseModel):
+    """Input for podcast generator tool."""
+    text: str = Field(description="The text content to convert to speech")
+
+class GoogleVoiceTool(BaseTool):
+    """Generate a podcast-style audio file from Text using Google Cloud Text-to-Speech."""
+    name: str = "generate_podcast_style_audio_file"
+    description: str = (
+        "Generates a podcast-style audio file from a given text script using Google Cloud Text-to-Speech."
+        " Use this tool if the user requests a podcast, an audio summary, or a narrative of the findings "
+        " First, ensure you have a clear and concise text summary of the information to be narrated. You might need to generate this summary based on your analysis or previous steps."
+        " Provide the text *as-is* without enclosing on backticks or backquotes."
+    )
+    voice_model: str = "en-US-Neural2-F"  # "en-US-Studio-O"
+    voice_gender: str = "FEMALE"
+    language_code: str = "en-US"
+    output_format: str = "OGG_OPUS"  # OGG format is more podcast-friendly
+    _key_service: Optional[str]
+
+    # Add a proper args_schema for tool-calling compatibility
+    args_schema: dict = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The text content to convert to speech"
+            }
+        },
+        "required": ["query"]
+    }
+
+    def __init__(self,
+        voice_model: str = "en-US-Neural2-F",
+        output_format: str = "OGG_OPUS",
+        output_dir: str = None,
+        name: str = "podcast_generator_tool",
+        **kwargs
+    ):
+        """Initialize the GoogleVoiceTool."""
+
+        super().__init__(**kwargs)
+
+        # Using the config from conf.py, but with additional verification
+        self._key_service = GOOGLE_TTS_SERVICE
+
+        # If not found in the config, try a default location
+        if self._key_service is None:
+            default_path = BASE_DIR / "env" / "google" / "tts-service.json"
+            if os.path.exists(default_path):
+                self._key_service = str(default_path)
+                print(f"Using default credentials path: {self._key_service}")
+            else:
+                print(f"Warning: No credentials found in config or at default path {default_path}")
+        else:
+            print(f"Using credentials from config: {self._key_service}")
+
+        if self.voice_gender == 'FEMALE':
+            self.voice_model = "en-US-Neural2-F"
+        elif self.voice_gender == 'MALE':
+            self.voice_model = "en-US-Neural2-M"
+        else:
+            self.voice_model = "en-US-Neural2-G"
+
+    def is_markdown(self, text: str) -> bool:
+        """Determine if the text appears to be Markdown formatted."""
+        if not text or not isinstance(text, str):
+            return False
+
+        # Corrección: Separar los caracteres problemáticos y el rango
+        if re.search(r"^[#*_>`\[\d-]", text.strip()[0]):  # Check if first char is a Markdown marker
+            return True
+
+        # Check for common Markdown patterns
+        if re.search(r"#{1,6}\s+", text):  # Headers
+            return True
+        if re.search(r"\*\*.*?\*\*", text):  # Bold
+            return True
+        if re.search(r"_.*?_", text):  # Italic
+            return True
+        if re.search(r"`.*?`", text):  # Code
+            return True
+        if re.search(r"\[.*?\]\(.*?\)", text):  # Links
+            return True
+        if re.search(r"^\s*[\*\-\+]\s+", text, re.MULTILINE):  # Unordered lists
+            return True
+        if re.search(r"^\s*\d+\.\s+", text, re.MULTILINE):  # Ordered lists
+            return True
+        if re.search(r"```.*?```", text, re.DOTALL):  # Code blocks
+            return True
+
+        return False
+
+
+    def text_to_ssml(self, text: str) -> str:
+        """Converts plain text to SSML."""
+        ssml = f"<speak><p>{escape(text)}</p></speak>"
+        return ssml
+
+    def markdown_to_ssml(self, markdown_text: str) -> str:
+        """Converts Markdown text to SSML, handling code blocks and ellipses."""
+
+        if markdown_text.startswith("```text"):
+            markdown_text = markdown_text[len("```text"):].strip()
+
+        ssml = "<speak>"
+        lines = markdown_text.split('\n')
+        in_code_block = False
+
+        for line in lines:
+            line = line.strip()
+
+            if line.startswith("```"):
+                in_code_block = not in_code_block
+                if in_code_block:
+                    ssml += '<prosody rate="x-slow"><p><code>'
+                else:
+                    ssml += '</code></p></prosody>'
+                continue
+
+            if in_code_block:
+                ssml += escape(line) + '<break time="100ms"/>'  # Add slight pauses within code
+                continue
+
+            if line == "...":
+                ssml += '<break time="500ms"/>'  # Keep the pause for ellipses
+                continue
+
+            # Handle Markdown headings
+            heading_match = re.match(r"^(#+)\s+(.*)", line)
+            if heading_match:
+                heading_level = len(heading_match.group(1))  # Number of '#'
+                heading_text = heading_match.group(2).strip()
+                ssml += f'<p><emphasis level="strong">{escape(heading_text)}</emphasis></p>'
+                continue
+
+            if line:
+                ssml += f'<p>{escape(line)}</p>'
+
+        ssml += "</speak>"
+        return ssml
+
+    async def _generate_podcast(self, query: str) -> dict:
+        """Main method to generate a podcast from query."""
+        try:
+            if self._key_service and Path(self._key_service).exists():
+                try:
+                    credentials = service_account.Credentials.from_service_account_file(
+                        self._key_service
+                    )
+                except Exception as cred_error:
+                    print(f"Error loading credentials: {cred_error}")
+
+            if isinstance(query, str):
+                try:
+                    # Try to parse as JSON
+                    import json
+                    query_dict = json.loads(query)
+                    if "output_file" in query_dict:
+                        print(f"Output file specified in query: {query_dict['output_file']}")
+                        print(f"Output directory exists: {os.path.isdir(os.path.dirname(query_dict['output_file']))}")
+                except json.JSONDecodeError:
+                    print("Query is plain text, not JSON")
+
+            print("1. Converting Markdown to SSML...")
+            if self.is_markdown(query):
+                ssml_text = self.markdown_to_ssml(query)
+            else:
+                ssml_text = self.text_to_ssml(query)
+            print(f"Generated SSML:\n{ssml_text}\n") # Uncomment for debugging
+            print(
+                f"2. Initializing Text-to-Speech client (Voice: {self.voice_model})..."
+            )
+            if not os.path.exists(self._key_service):
+                raise FileNotFoundError(
+                    f"Service account file not found: {self._key_service}"
+                )
+            credentials = service_account.Credentials.from_service_account_file(
+                self._key_service
+            )
+            # Initialize the Text-to-Speech client with the service account credentials
+            # Use the v1 API for wider feature set including SSML
+            client = texttospeech.TextToSpeechClient(credentials=credentials)
+            synthesis_input = texttospeech.SynthesisInput(ssml=ssml_text)
+            # Select the voice parameters
+            voice = texttospeech.VoiceSelectionParams(
+                language_code=self.language_code,
+                name=self.voice_model
+            )
+            # Select the audio format (OGG with OPUS codec)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            # Generate a unique filename based on the current timestamp
+            output_filename = f"podcast_{timestamp}.ogg"  # Default output filename
+            # default to OGG
+            encoding = texttospeech.AudioEncoding.OGG_OPUS
+            if self.output_format == "OGG_OPUS":
+                encoding = texttospeech.AudioEncoding.OGG_OPUS
+                output_filename = f"podcast_{timestamp}.ogg"
+            elif self.output_format == "MP3":
+                encoding = texttospeech.AudioEncoding.MP3
+                output_filename = f"podcast_{timestamp}.mp3"
+            elif self.output_format == "LINEAR16":
+                encoding = texttospeech.AudioEncoding.LINEAR16
+                output_filename = f"podcast_{timestamp}.wav"
+            elif self.output_format == "WEBM_OPUS":
+                encoding = texttospeech.AudioEncoding.WEBM_OPUS
+                output_filename = f"podcast_{timestamp}.webm"
+            elif self.output_format == "FLAC":
+                encoding = texttospeech.AudioEncoding.FLAC
+                output_filename = f"podcast_{timestamp}.flac"
+            elif self.output_format == "OGG_VORBIS":
+                encoding = texttospeech.AudioEncoding.OGG_VORBIS
+                output_filename = f"podcast_{timestamp}.ogg"
+
+            audio_config = texttospeech.AudioConfig(
+                audio_encoding=encoding,
+                speaking_rate=1.0,
+                pitch=0.0
+            )
+            print("3. Synthesizing speech...")
+            response = client.synthesize_speech(
+                input=synthesis_input,
+                voice=voice,
+                audio_config=audio_config
+            )
+            print("4. Speech synthesized successfully.")
+            # Get the absolute path for the output file
+            output_dir: Path = BASE_DIR.joinpath('static', 'audio', 'podcasts')
+            if output_dir.exists() is False:
+                # Create the directory if it doesn't exist
+                output_dir.mkdir(parents=True, exist_ok=True)
+            output_filepath = output_dir.joinpath(output_filename)
+            print(f"5. Saving audio content to: {output_filepath}")
+            async with aiofiles.open(output_filepath, 'wb') as audio_file:
+                await audio_file.write(response.audio_content)
+            print("6. Audio content saved successfully.")
+            return {
+                "file_path": output_filepath,
+                "output_format": self.output_format,
+                "language_code": self.language_code,
+                "voice_model": self.voice_model,
+                "timestamp": timestamp,
+                "filename": output_filename
+            }
+        except Exception as e:
+            import traceback
+            print(f"Error in _generate_podcast: {e}")
+            print(traceback.format_exc())
+            return {"error": str(e)}
+
+    async def _arun(self, query: str) -> dict:
+        """
+        Generates a podcast-style audio file from Markdown text using
+        Google Cloud Text-to-Speech.
+
+        Args:
+            markdown_summary: The input text in Markdown format.
+            output_filename: The desired name for the output audio file (e.g., "my_podcast.ogg").
+            language_code: The language code (e.g., "en-US", "es-ES").
+            voice_name: The specific voice model name. Find names here:
+                        https://cloud.google.com/text-to-speech/docs/voices
+
+        Returns:
+            A dictionary containing the absolute path to the saved audio file
+            under the key "file_path", or an error message under "error".
+        """
+        try:
+            return await self._generate_podcast(query)
+        except Exception as e:
+            import traceback
+            print(f"Error in GoogleVoiceTool._arun: {e}")
+            print(traceback.format_exc())
+            return {"error": str(e)}
+
+    def _run(self, query: str) -> dict:
+        """
+        Synchronous method to generate a podcast-style audio file from Markdown text.
+        This method is not recommended for production use due to blocking I/O.
+        """
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If the event loop is already running, use run_until_complete
+            return loop.run_until_complete(self._generate_podcast(query))
+        else:
+            # If not, use run
+            return loop.run(self._generate_podcast(query))

parrot/tools/results.py

@@ -0,0 +1,278 @@
+from typing import Dict, Any, Optional, Union
+from datetime import datetime
+import pandas as pd
+import json
+from langchain_core.tools import BaseTool
+from langchain_core.callbacks.manager import CallbackManagerForToolRun
+
+
+# Helper function to import datetime safely (for use in the tool)
+def import_time():
+    return datetime
+
+class ResultStoreTool(BaseTool):
+    """Tool for storing and retrieving intermediate results during agent execution."""
+    name: str = "store_result"
+    description: str = """
+    Store an intermediate result for later use. Use this to save important analysis outputs,
+    DataFrame snippets, calculations, or any other values you want to refer to in later steps.
+
+    Args:
+        key (str): A unique identifier for the stored result
+        value (Any): The value to store (can be a string, number, dict, list, or DataFrame info)
+        description (str, optional): A brief description of what this value represents
+
+    Returns:
+        str: Confirmation message indicating the value was stored
+    """
+
+    # Storage for results, shared across all instances
+    _storage: Dict[str, Dict[str, Any]] = {}
+
+    def _run(
+        self,
+        key: str,
+        value: Any,
+        description: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Store a result with the given key."""
+        try:
+            # Handle DataFrame serialization
+            if str(type(value)).endswith("'pandas.core.frame.DataFrame'>"):
+                # Store a serializable representation of the DataFrame
+                stored_value = {
+                    "type": "pandas_dataframe",
+                    "shape": value.shape,
+                    "columns": value.columns.tolist(),
+                    "data": value.head(10).to_dict(orient="records")  # Store first 10 rows
+                }
+            else:
+                # Try JSON serialization to check if value is serializable
+                try:
+                    json.dumps(value)
+                    stored_value = value
+                except (TypeError, OverflowError):
+                    # If not JSON serializable, convert to string representation
+                    stored_value = {
+                        "type": "non_serializable",
+                        "string_repr": str(value),
+                        "python_type": str(type(value))
+                    }
+
+            # Store the value with metadata
+            self._storage[key] = {
+                "value": stored_value,
+                "description": description,
+                "timestamp": import_time().strftime("%Y-%m-%d %H:%M:%S")
+            }
+
+            return f"Successfully stored result '{key}'"
+
+        except Exception as e:
+            return f"Error storing result: {str(e)}"
+
+    @classmethod
+    def get_result(cls, key: str) -> Union[Any, None]:
+        """Retrieve a stored result."""
+        if key in cls._storage:
+            return cls._storage[key]["value"]
+        return None
+
+    @classmethod
+    def list_results(cls) -> Dict[str, Dict[str, Any]]:
+        """List all stored results with their metadata."""
+        return {
+            k: {
+                "description": v.get("description", "No description provided"),
+                "timestamp": v.get("timestamp", "Unknown"),
+                "type": type(v["value"]).__name__
+            }
+            for k, v in cls._storage.items()
+        }
+
+    @classmethod
+    def clear_results(cls) -> None:
+        """Clear all stored results."""
+        cls._storage.clear()
+
+    @classmethod
+    def delete_result(cls, key: str) -> bool:
+        """Delete a specific stored result."""
+        if key in cls._storage:
+            del cls._storage[key]
+            return True
+        return False
+
+
+class GetResultTool(BaseTool):
+    """Tool for retrieving previously stored results."""
+    name: str = "get_result"
+    description: str = """
+    Retrieve a previously stored result by its key.
+
+    Args:
+        key (str): The unique identifier of the stored result
+
+    Returns:
+        Any: The stored value, or an error message if the key doesn't exist
+    """
+
+    def _run(
+        self,
+        key: str,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Any:
+        """Retrieve a result with the given key."""
+        result = ResultStoreTool.get_result(key)
+
+        if result is None:
+            return f"Error: No result found with key '{key}'. Available keys: {list(ResultStoreTool._storage.keys())}"
+
+        return result
+
+class ListResultsTool(BaseTool):
+    """Tool for listing all stored results."""
+    name: str = "list_results"
+    description: str = """
+    List all currently stored results with their metadata.
+
+    Returns:
+        Dict: A dictionary mapping result keys to their metadata
+    """
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> Dict[str, Dict[str, Any]]:
+        """List all stored results."""
+        results = ResultStoreTool.list_results()
+
+        if not results:
+            return "No results have been stored yet."
+
+        return results
+
+
+class DataFrameStoreTool(BaseTool):
+    """Tool specifically for storing and retrieving pandas DataFrames."""
+    name: str = "store_dataframe"
+    description: str = """
+    Store a pandas DataFrame for later use or reference.
+
+    Args:
+        key (str): A unique identifier for the stored DataFrame
+        df_variable (str): The variable name of the DataFrame to store
+        description (str, optional): A brief description of what this DataFrame contains
+
+    Returns:
+        str: Confirmation message indicating the DataFrame was stored
+    """
+
+    # Storage for DataFrames, shared across all instances
+    _df_storage: Dict[str, Dict[str, Any]] = {}
+
+    def __init__(self, df_locals: Dict[str, Any]):
+        """Initialize with access to the locals dictionary."""
+        super().__init__()
+        self.df_locals = df_locals
+
+    def _run(
+        self,
+        key: str,
+        df_variable: str,
+        description: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Store a DataFrame with the given key."""
+        try:
+            # Check if the variable exists in df_locals
+            if df_variable not in self.df_locals:
+                return f"Error: DataFrame '{df_variable}' not found in available variables."
+
+            df = self.df_locals[df_variable]
+
+            # Verify it's actually a DataFrame
+            if not str(type(df)).endswith("'pandas.core.frame.DataFrame'>"):
+                return f"Error: '{df_variable}' is not a pandas DataFrame, it's a {type(df).__name__}."
+
+            # Store the actual DataFrame (not just a representation)
+            self._df_storage[key] = {
+                "dataframe": df.copy(),  # Store a copy to avoid mutation
+                "description": description,
+                "timestamp": import_time().strftime("%Y-%m-%d %H:%M:%S"),
+                "shape": df.shape,
+                "columns": df.columns.tolist()
+            }
+
+            # Add a reference to the df_locals so it can be accessed in Python code
+            self.df_locals[f"stored_df_{key}"] = df.copy()
+
+            return f"Successfully stored DataFrame '{key}' with shape {df.shape}"
+
+        except Exception as e:
+            return f"Error storing DataFrame: {str(e)}"
+
+    @classmethod
+    def get_dataframe(cls, key: str) -> Union[pd.DataFrame, None]:
+        """Retrieve a stored DataFrame."""
+        if key in cls._df_storage:
+            return cls._df_storage[key]["dataframe"]
+        return None
+
+    @classmethod
+    def list_dataframes(cls) -> Dict[str, Dict[str, Any]]:
+        """List all stored DataFrames with their metadata."""
+        return {
+            k: {
+                "description": v.get("description", "No description provided"),
+                "timestamp": v.get("timestamp", "Unknown"),
+                "shape": v.get("shape", "Unknown"),
+                "columns": v.get("columns", [])
+            }
+            for k, v in cls._df_storage.items()
+        }
+
+class GetDataFrameTool(BaseTool):
+    """Tool for retrieving stored DataFrames."""
+    name: str = "get_dataframe"
+    description: str = """
+    Retrieve a previously stored DataFrame by its key.
+
+    Args:
+        key (str): The unique identifier of the stored DataFrame
+        target_variable (str, optional): If provided, store the retrieved DataFrame in this variable
+
+    Returns:
+        str: Information about the retrieved DataFrame
+    """
+
+    def __init__(self, df_locals: Dict[str, Any]):
+        """Initialize with access to the locals dictionary."""
+        super().__init__()
+        self.df_locals = df_locals
+
+    def _run(
+        self,
+        key: str,
+        target_variable: Optional[str] = None,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+    ) -> str:
+        """Retrieve a DataFrame with the given key."""
+        df = DataFrameStoreTool.get_dataframe(key)
+
+        if df is None:
+            available_keys = list(DataFrameStoreTool._df_storage.keys())
+            return f"Error: No DataFrame found with key '{key}'. Available DataFrame keys: {available_keys}"
+
+        # If a target variable is specified, store the DataFrame there
+        if target_variable:
+            self.df_locals[target_variable] = df
+            return f"Retrieved DataFrame '{key}' and stored in variable '{target_variable}' with shape {df.shape}"
+        else:
+            # Otherwise, use a default variable name
+            default_var = f"retrieved_df_{key}"
+            self.df_locals[default_var] = df
+            return (
+                f"Retrieved DataFrame '{key}' with shape {df.shape}. "
+            )

parrot/tools/stack.py

@@ -0,0 +1,27 @@
+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 = (
+        "Search for questions and answers on Stack Exchange. "
+        "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")