agno 2.2.13__py3-none-any.whl

agno/tools/x.py

@@ -0,0 +1,335 @@
+import json
+from os import getenv
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_info, logger
+
+try:
+    import tweepy
+except ImportError:
+    raise ImportError("`tweepy` not installed. Please install using `pip install tweepy`.")
+
+
+class XTools(Toolkit):
+    def __init__(
+        self,
+        bearer_token: Optional[str] = None,
+        consumer_key: Optional[str] = None,
+        consumer_secret: Optional[str] = None,
+        access_token: Optional[str] = None,
+        access_token_secret: Optional[str] = None,
+        include_post_metrics: bool = False,
+        wait_on_rate_limit: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize the XTools.
+
+        Args:
+            bearer_token Optional[str]: The bearer token for Twitter API.
+            consumer_key Optional[str]: The consumer key for Twitter API.
+            consumer_secret Optional[str]: The consumer secret for Twitter API.
+            access_token Optional[str]: The access token for Twitter API.
+            access_token_secret Optional[str]: The access token secret for Twitter API.
+            include_post_metrics Optional[bool]: Whether to include post metrics in the search results.
+            wait_on_rate_limit Optional[bool]: Whether to wait on rate limit.
+        """
+        self.bearer_token = bearer_token or getenv("X_BEARER_TOKEN")
+        self.consumer_key = consumer_key or getenv("X_CONSUMER_KEY")
+        self.consumer_secret = consumer_secret or getenv("X_CONSUMER_SECRET")
+        self.access_token = access_token or getenv("X_ACCESS_TOKEN")
+        self.access_token_secret = access_token_secret or getenv("X_ACCESS_TOKEN_SECRET")
+        self.wait_on_rate_limit = wait_on_rate_limit
+        self.client = tweepy.Client(
+            bearer_token=self.bearer_token,
+            consumer_key=self.consumer_key,
+            consumer_secret=self.consumer_secret,
+            access_token=self.access_token,
+            access_token_secret=self.access_token_secret,
+            wait_on_rate_limit=self.wait_on_rate_limit,
+        )
+        self.include_post_metrics = include_post_metrics
+
+        tools: List[Any] = [
+            self.create_post,
+            self.reply_to_post,
+            self.send_dm,
+            self.get_user_info,
+            self.get_home_timeline,
+            self.search_posts,
+        ]
+
+        super().__init__(name="x", tools=tools, **kwargs)
+
+    def create_post(self, text: str) -> str:
+        """
+        Create a new X post.
+
+        Args:
+            text (str): The content of the post to create.
+
+        Returns:
+            A JSON-formatted string containing the response from X API (Twitter API) with the created post details,
+            or an error message if the post creation fails.
+        """
+        log_debug(f"Attempting to create post with text: {text}")
+        try:
+            response = self.client.create_tweet(text=text)
+            post_id = response.data["id"]
+            user = self.client.get_me().data
+            post_url = f"https://x.com/{user.username}/status/{post_id}"
+
+            result = {"message": "Post successfully created!", "url": post_url}
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error creating post: {e}")
+            return json.dumps({"error": str(e)})
+
+    def reply_to_post(self, post_id: str, text: str) -> str:
+        """
+        Reply to an existing post.
+
+        Args:
+            post_id (str): The ID of the post to reply to.
+            text (str): The content of the reply post.
+
+        Returns:
+            A JSON-formatted string containing the response from Twitter API with the reply post details,
+            or an error message if the reply fails.
+        """
+        log_debug(f"Attempting to reply to {post_id} with text {text}")
+        try:
+            response = self.client.create_tweet(text=text, in_reply_to_tweet_id=post_id)
+            reply_id = response.data["id"]
+            user = self.client.get_me().data
+            reply_url = f"https://twitter.com/{user.username}/status/{reply_id}"
+            result = {"message": "Reply successfully posted!", "url": reply_url}
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error replying to post: {e}")
+            return json.dumps({"error": str(e)})
+
+    def send_dm(self, recipient: str, text: str) -> str:
+        """
+        Send a direct message to a user.
+
+        Args:
+            recipient (str): The username or user ID of the recipient.
+            text (str): The content of the direct message.
+
+        Returns:
+            A JSON-formatted string containing the response from Twitter API with the sent message details,
+            or an error message if sending the DM fails.
+        """
+        log_debug(f"Attempting to send DM to user {recipient}")
+        try:
+            # Check if recipient is a user ID (numeric) or username
+            if not recipient.isdigit():
+                # If it's not numeric, assume it's a username and get the user ID
+                user = self.client.get_user(username=recipient)
+                log_debug(f"Attempting to send DM to user's id {user}")
+                recipient_id = user.data.id
+            else:
+                recipient_id = recipient
+
+            log_debug(f"Attempting to send DM to user's id {recipient_id}")
+            response = self.client.create_direct_message(participant_id=recipient_id, text=text)
+            result = {
+                "message": "Direct message sent successfully!",
+                "dm_id": response.data["id"],
+                "recipient_id": recipient_id,
+                "recipient_username": recipient if not recipient.isdigit() else None,
+            }
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error from X while sending DM: {e}")
+            error_message = str(e)
+            if "User not found" in error_message:
+                error_message = f"User '{recipient}' not found. Please check the username or user ID."
+            elif "You cannot send messages to this user" in error_message:
+                error_message = (
+                    f"Unable to send message to '{recipient}'. The user may have restricted who can send them messages."
+                )
+            return json.dumps({"error": error_message}, indent=2)
+        except Exception as e:
+            logger.error(f"Unexpected error sending DM: {e}")
+            return json.dumps({"error": f"An unexpected error occurred: {str(e)}"}, indent=2)
+
+    def get_my_info(self) -> str:
+        """
+        Retrieve information about the authenticated user.
+
+        Returns:
+            A JSON-formatted string containing the user's profile information,
+            including id, name, username, description, and follower/following counts,
+            or an error message if fetching the information fails.
+        """
+        log_debug("Fetching information about myself")
+        try:
+            me = self.client.get_me(user_fields=["description", "public_metrics"])
+            user_info = me.data.data
+            result = {
+                "id": user_info["id"],
+                "name": user_info["name"],
+                "username": user_info["username"],
+                "description": user_info["description"],
+                "followers_count": user_info["public_metrics"]["followers_count"],
+                "following_count": user_info["public_metrics"]["following_count"],
+                "tweet_count": user_info["public_metrics"]["tweet_count"],
+            }
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error fetching user info: {e}")
+            return json.dumps({"error": str(e)})
+
+    def get_user_info(self, username: str) -> str:
+        """
+        Retrieve information about a specific user.
+
+        Args:
+            username (str): The username of the user to fetch information about.
+
+        Returns:
+            A JSON-formatted string containing the user's profile information,
+            including id, name, username, description, and follower/following counts,
+            or an error message if fetching the information fails.
+        """
+        log_debug(f"Fetching information about user {username}")
+        try:
+            user = self.client.get_user(username=username, user_fields=["description", "public_metrics"])
+            user_info = user.data.data
+            result = {
+                "id": user_info["id"],
+                "name": user_info["name"],
+                "username": user_info["username"],
+                "description": user_info["description"],
+                "followers_count": user_info["public_metrics"]["followers_count"],
+                "following_count": user_info["public_metrics"]["following_count"],
+                "tweet_count": user_info["public_metrics"]["tweet_count"],
+            }
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error fetching user info: {e}")
+            return json.dumps({"error": str(e)})
+
+    def get_home_timeline(self, max_results: int = 10) -> str:
+        """
+        Retrieve the authenticated user's home timeline.
+
+        Args:
+            max_results (int): The maximum number of tweets to retrieve. Default is 10.
+
+        Returns:
+            A JSON-formatted string containing a list of tweets from the user's home timeline,
+            including tweet id, text, creation time, and author id,
+            or an error message if fetching the timeline fails.
+        """
+        log_debug(f"Fetching home timeline, max results: {max_results}")
+        try:
+            tweets = self.client.get_home_timeline(
+                max_results=max_results, tweet_fields=["created_at", "public_metrics"]
+            )
+            timeline = []
+            for tweet in tweets.data:
+                timeline.append(
+                    {
+                        "id": tweet.id,
+                        "text": tweet.text,
+                        "created_at": tweet.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+                        "author_id": tweet.author_id,
+                    }
+                )
+            log_info(f"Successfully fetched {len(timeline)} tweets")
+            result = {"home_timeline": timeline}
+            return json.dumps(result, indent=2)
+        except tweepy.TweepyException as e:
+            logger.error(f"Error fetching home timeline: {e}")
+            return json.dumps({"error": str(e)})
+
+    def search_posts(self, query: str, max_results: int = 10) -> str:
+        """
+        Search for tweets based on a search query.
+
+        Args:
+            query (str): The search query.
+            max_results (int): The maximum number of posts to retrieve.
+
+        Returns:
+            A list of posts matching the search query
+        """
+        try:
+            max_results = max(10, min(max_results, 100))  # range 10 - 100
+
+            log_debug(f"Searching for posts with query: {query}, bounded max results: {max_results}")
+            results = self.client.search_recent_tweets(
+                query=query,
+                max_results=max_results,
+                tweet_fields=[
+                    "author_id",
+                    "created_at",
+                    "id",
+                    "public_metrics",
+                    "text",
+                ],
+                user_fields=["name", "username", "verified"],
+            )
+
+            users_data = {}
+            if hasattr(results, "includes") and "users" in results.includes:
+                for user in results.includes["users"]:
+                    users_data[user.id] = {
+                        "id": user.id,
+                        "name": user.name,
+                        "username": user.username,
+                        "verified": getattr(user, "verified", False),
+                    }
+            tweets = []
+
+            if results.data:
+                for tweet in results.data:
+                    author_info = users_data.get(
+                        tweet.author_id, {"id": tweet.author_id, "name": "Unknown", "username": "unknown"}
+                    )
+
+                    post_url = f"https://x.com/{author_info.get('username', 'unknown')}/status/{tweet.id}"
+
+                    post_data = {
+                        "id": tweet.id,
+                        "text": tweet.text,
+                        "created_at": tweet.created_at.strftime("%Y-%m-%d %H:%M:%S")
+                        if hasattr(tweet, "created_at")
+                        else None,
+                        "author": author_info,
+                        "url": post_url,
+                    }
+                    if self.include_post_metrics:
+                        post_data["metrics"] = {
+                            "retweet_count": tweet.public_metrics.get("retweet_count", 0)
+                            if hasattr(tweet, "public_metrics")
+                            else 0,
+                            "reply_count": tweet.public_metrics.get("reply_count", 0)
+                            if hasattr(tweet, "public_metrics")
+                            else 0,
+                            "like_count": tweet.public_metrics.get("like_count", 0)
+                            if hasattr(tweet, "public_metrics")
+                            else 0,
+                            "quote_count": tweet.public_metrics.get("quote_count", 0)
+                            if hasattr(tweet, "public_metrics")
+                            else 0,
+                        }
+                    tweets.append(post_data)
+
+                log_info(f"Successfully found {len(tweets)} posts for query: {query}")
+                result = {"query": query, "count": len(tweets), "posts": tweets}
+            else:
+                log_info(f"No posts found for query: {query}")
+                result = {}
+            return json.dumps(result, indent=2)
+
+        except tweepy.TweepyException as e:
+            logger.error(f"Error searching posts: {e}")
+            return json.dumps({"error": str(e), "query": query})
+        except Exception as e:
+            logger.error(f"Unexpected error searching posts: {e}")
+            return json.dumps({"error": f"An unexpected error occurred: {str(e)}", "query": query})

agno/tools/yfinance.py

@@ -0,0 +1,257 @@
+import json
+from typing import Any, List
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+try:
+    import yfinance as yf
+except ImportError:
+    raise ImportError("`yfinance` not installed. Please install using `pip install yfinance`.")
+
+
+class YFinanceTools(Toolkit):
+    """
+    YFinanceTools is a toolkit for getting financial data from Yahoo Finance.
+    Includes all available financial data tools.
+    """
+
+    def __init__(
+        self,
+        **kwargs,
+    ):
+        tools: List[Any] = [
+            self.get_current_stock_price,
+            self.get_company_info,
+            self.get_stock_fundamentals,
+            self.get_income_statements,
+            self.get_key_financial_ratios,
+            self.get_analyst_recommendations,
+            self.get_company_news,
+            self.get_technical_indicators,
+            self.get_historical_stock_prices,
+        ]
+
+        super().__init__(name="yfinance_tools", tools=tools, **kwargs)
+
+    def get_current_stock_price(self, symbol: str) -> str:
+        """
+        Use this function to get the current stock price for a given symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            str: The current stock price or error message.
+        """
+        try:
+            log_debug(f"Fetching current price for {symbol}")
+            stock = yf.Ticker(symbol)
+            # Use "regularMarketPrice" for regular market hours, or "currentPrice" for pre/post market
+            current_price = stock.info.get("regularMarketPrice", stock.info.get("currentPrice"))
+            return f"{current_price:.4f}" if current_price else f"Could not fetch current price for {symbol}"
+        except Exception as e:
+            return f"Error fetching current price for {symbol}: {e}"
+
+    def get_company_info(self, symbol: str) -> str:
+        """Use this function to get company information and overview for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            str: JSON containing company profile and overview.
+        """
+        try:
+            company_info_full = yf.Ticker(symbol).info
+            if company_info_full is None:
+                return f"Could not fetch company info for {symbol}"
+
+            log_debug(f"Fetching company info for {symbol}")
+
+            company_info_cleaned = {
+                "Name": company_info_full.get("shortName"),
+                "Symbol": company_info_full.get("symbol"),
+                "Current Stock Price": f"{company_info_full.get('regularMarketPrice', company_info_full.get('currentPrice'))} {company_info_full.get('currency', 'USD')}",
+                "Market Cap": f"{company_info_full.get('marketCap', company_info_full.get('enterpriseValue'))} {company_info_full.get('currency', 'USD')}",
+                "Sector": company_info_full.get("sector"),
+                "Industry": company_info_full.get("industry"),
+                "Address": company_info_full.get("address1"),
+                "City": company_info_full.get("city"),
+                "State": company_info_full.get("state"),
+                "Zip": company_info_full.get("zip"),
+                "Country": company_info_full.get("country"),
+                "EPS": company_info_full.get("trailingEps"),
+                "P/E Ratio": company_info_full.get("trailingPE"),
+                "52 Week Low": company_info_full.get("fiftyTwoWeekLow"),
+                "52 Week High": company_info_full.get("fiftyTwoWeekHigh"),
+                "50 Day Average": company_info_full.get("fiftyDayAverage"),
+                "200 Day Average": company_info_full.get("twoHundredDayAverage"),
+                "Website": company_info_full.get("website"),
+                "Summary": company_info_full.get("longBusinessSummary"),
+                "Analyst Recommendation": company_info_full.get("recommendationKey"),
+                "Number Of Analyst Opinions": company_info_full.get("numberOfAnalystOpinions"),
+                "Employees": company_info_full.get("fullTimeEmployees"),
+                "Total Cash": company_info_full.get("totalCash"),
+                "Free Cash flow": company_info_full.get("freeCashflow"),
+                "Operating Cash flow": company_info_full.get("operatingCashflow"),
+                "EBITDA": company_info_full.get("ebitda"),
+                "Revenue Growth": company_info_full.get("revenueGrowth"),
+                "Gross Margins": company_info_full.get("grossMargins"),
+                "Ebitda Margins": company_info_full.get("ebitdaMargins"),
+            }
+            return json.dumps(company_info_cleaned, indent=2)
+        except Exception as e:
+            return f"Error fetching company profile for {symbol}: {e}"
+
+    def get_historical_stock_prices(self, symbol: str, period: str = "1mo", interval: str = "1d") -> str:
+        """
+        Use this function to get the historical stock price for a given symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+            period (str): The period for which to retrieve historical prices. Defaults to "1mo".
+                        Valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,ytd,max
+            interval (str): The interval between data points. Defaults to "1d".
+                        Valid intervals: 1d,5d,1wk,1mo,3mo
+
+        Returns:
+          str: The current stock price or error message.
+        """
+        try:
+            log_debug(f"Fetching historical prices for {symbol}")
+            stock = yf.Ticker(symbol)
+            historical_price = stock.history(period=period, interval=interval)
+            return historical_price.to_json(orient="index")
+        except Exception as e:
+            return f"Error fetching historical prices for {symbol}: {e}"
+
+    def get_stock_fundamentals(self, symbol: str) -> str:
+        """Use this function to get fundamental data for a given stock symbol yfinance API.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            str: A JSON string containing fundamental data or an error message.
+                Keys:
+                    - 'symbol': The stock symbol.
+                    - 'company_name': The long name of the company.
+                    - 'sector': The sector to which the company belongs.
+                    - 'industry': The industry to which the company belongs.
+                    - 'market_cap': The market capitalization of the company.
+                    - 'pe_ratio': The forward price-to-earnings ratio.
+                    - 'pb_ratio': The price-to-book ratio.
+                    - 'dividend_yield': The dividend yield.
+                    - 'eps': The trailing earnings per share.
+                    - 'beta': The beta value of the stock.
+                    - '52_week_high': The 52-week high price of the stock.
+                    - '52_week_low': The 52-week low price of the stock.
+        """
+        try:
+            log_debug(f"Fetching fundamentals for {symbol}")
+            stock = yf.Ticker(symbol)
+            info = stock.info
+            fundamentals = {
+                "symbol": symbol,
+                "company_name": info.get("longName", ""),
+                "sector": info.get("sector", ""),
+                "industry": info.get("industry", ""),
+                "market_cap": info.get("marketCap", "N/A"),
+                "pe_ratio": info.get("forwardPE", "N/A"),
+                "pb_ratio": info.get("priceToBook", "N/A"),
+                "dividend_yield": info.get("dividendYield", "N/A"),
+                "eps": info.get("trailingEps", "N/A"),
+                "beta": info.get("beta", "N/A"),
+                "52_week_high": info.get("fiftyTwoWeekHigh", "N/A"),
+                "52_week_low": info.get("fiftyTwoWeekLow", "N/A"),
+            }
+            return json.dumps(fundamentals, indent=2)
+        except Exception as e:
+            return f"Error getting fundamentals for {symbol}: {e}"
+
+    def get_income_statements(self, symbol: str) -> str:
+        """Use this function to get income statements for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            dict: JSON containing income statements or an empty dictionary.
+        """
+        try:
+            log_debug(f"Fetching income statements for {symbol}")
+            stock = yf.Ticker(symbol)
+            financials = stock.financials
+            return financials.to_json(orient="index")
+        except Exception as e:
+            return f"Error fetching income statements for {symbol}: {e}"
+
+    def get_key_financial_ratios(self, symbol: str) -> str:
+        """Use this function to get key financial ratios for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            dict: JSON containing key financial ratios.
+        """
+        try:
+            log_debug(f"Fetching key financial ratios for {symbol}")
+            stock = yf.Ticker(symbol)
+            key_ratios = stock.info
+            return json.dumps(key_ratios, indent=2)
+        except Exception as e:
+            return f"Error fetching key financial ratios for {symbol}: {e}"
+
+    def get_analyst_recommendations(self, symbol: str) -> str:
+        """Use this function to get analyst recommendations for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+
+        Returns:
+            str: JSON containing analyst recommendations.
+        """
+        try:
+            log_debug(f"Fetching analyst recommendations for {symbol}")
+            stock = yf.Ticker(symbol)
+            recommendations = stock.recommendations
+            return recommendations.to_json(orient="index")
+        except Exception as e:
+            return f"Error fetching analyst recommendations for {symbol}: {e}"
+
+    def get_company_news(self, symbol: str, num_stories: int = 3) -> str:
+        """Use this function to get company news and press releases for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+            num_stories (int): The number of news stories to return. Defaults to 3.
+
+        Returns:
+            str: JSON containing company news and press releases.
+        """
+        try:
+            log_debug(f"Fetching company news for {symbol}")
+            news = yf.Ticker(symbol).news
+            return json.dumps(news[:num_stories], indent=2)
+        except Exception as e:
+            return f"Error fetching company news for {symbol}: {e}"
+
+    def get_technical_indicators(self, symbol: str, period: str = "3mo") -> str:
+        """Use this function to get technical indicators for a given stock symbol.
+
+        Args:
+            symbol (str): The stock symbol.
+            period (str): The time period for which to retrieve technical indicators.
+                Valid periods: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max. Defaults to 3mo.
+
+        Returns:
+            str: JSON containing technical indicators.
+        """
+        try:
+            log_debug(f"Fetching technical indicators for {symbol}")
+            indicators = yf.Ticker(symbol).history(period=period)
+            return indicators.to_json(orient="index")
+        except Exception as e:
+            return f"Error fetching technical indicators for {symbol}: {e}"