agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/{twitter.py → x.py}

@@ -1,9 +1,9 @@
 import json
-import os
-from typing import Optional
+from os import getenv
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     import tweepy
@@ -11,7 +11,7 @@ except ImportError:
     raise ImportError("`tweepy` not installed. Please install using `pip install tweepy`.")
 
 
-class TwitterTools(Toolkit):
+class XTools(Toolkit):
     def __init__(
         self,
         bearer_token: Optional[str] = None,
@@ -19,9 +19,12 @@ class TwitterTools(Toolkit):
         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 TwitterTools.
+        Initialize the XTools.
 
         Args:
             bearer_token Optional[str]: The bearer token for Twitter API.
@@ -29,76 +32,82 @@ class TwitterTools(Toolkit):
             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.
         """
-        super().__init__(name="twitter")
-
-        self.bearer_token = bearer_token or os.getenv("TWITTER_BEARER_TOKEN")
-        self.consumer_key = consumer_key or os.getenv("TWITTER_CONSUMER_KEY")
-        self.consumer_secret = consumer_secret or os.getenv("TWITTER_CONSUMER_SECRET")
-        self.access_token = access_token or os.getenv("TWITTER_ACCESS_TOKEN")
-        self.access_token_secret = access_token_secret or os.getenv("TWITTER_ACCESS_TOKEN_SECRET")
-
+        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.auth = tweepy.OAuth1UserHandler(consumer_key, consumer_secret, access_token, access_token_secret)
-        self.api = tweepy.API(self.auth)
-        self.register(self.create_tweet)
-        self.register(self.reply_to_tweet)
-        self.register(self.send_dm)
-        self.register(self.get_user_info)
-        self.register(self.get_home_timeline)
+        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_tweet(self, text: str) -> str:
+    def create_post(self, text: str) -> str:
         """
-        Create a new tweet.
+        Create a new X post.
 
         Args:
-            text (str): The content of the tweet to create.
+            text (str): The content of the post to create.
 
         Returns:
-            A JSON-formatted string containing the response from Twitter API with the created tweet details,
-            or an error message if the tweet creation fails.
+            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.
         """
-        logger.debug(f"Attempting to create tweet with text: {text}")
+        log_debug(f"Attempting to create post with text: {text}")
         try:
             response = self.client.create_tweet(text=text)
-            tweet_id = response.data["id"]
+            post_id = response.data["id"]
             user = self.client.get_me().data
-            tweet_url = f"https://twitter.com/{user.username}/status/{tweet_id}"
+            post_url = f"https://x.com/{user.username}/status/{post_id}"
 
-            result = {"message": "Tweet successfully posted!", "url": tweet_url}
+            result = {"message": "Post successfully created!", "url": post_url}
             return json.dumps(result, indent=2)
         except tweepy.TweepyException as e:
-            logger.error(f"Error creating tweet: {e}")
+            logger.error(f"Error creating post: {e}")
             return json.dumps({"error": str(e)})
 
-    def reply_to_tweet(self, tweet_id: str, text: str) -> str:
+    def reply_to_post(self, post_id: str, text: str) -> str:
         """
-        Reply to an existing tweet.
+        Reply to an existing post.
 
         Args:
-            tweet_id (str): The ID of the tweet to reply to.
-            text (str): The content of the reply tweet.
+            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 tweet details,
+            A JSON-formatted string containing the response from Twitter API with the reply post details,
             or an error message if the reply fails.
         """
-        logger.debug(f"Attempting to reply to {tweet_id} with text {text}")
+        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=tweet_id)
+            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 tweet: {e}")
+            logger.error(f"Error replying to post: {e}")
             return json.dumps({"error": str(e)})
 
     def send_dm(self, recipient: str, text: str) -> str:
@@ -113,18 +122,18 @@ class TwitterTools(Toolkit):
             A JSON-formatted string containing the response from Twitter API with the sent message details,
             or an error message if sending the DM fails.
         """
-        logger.debug(f"Attempting to send DM to user {recipient}")
+        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)
-                logger.debug(f"Attempting to send DM to user's id {user}")
+                log_debug(f"Attempting to send DM to user's id {user}")
                 recipient_id = user.data.id
             else:
                 recipient_id = recipient
 
-            logger.debug(f"Attempting to send DM to user's id {recipient_id}")
+            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!",
@@ -134,7 +143,7 @@ class TwitterTools(Toolkit):
             }
             return json.dumps(result, indent=2)
         except tweepy.TweepyException as e:
-            logger.error(f"Error sending DM: {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."
@@ -156,7 +165,7 @@ class TwitterTools(Toolkit):
             including id, name, username, description, and follower/following counts,
             or an error message if fetching the information fails.
         """
-        logger.debug("Fetching information about myself")
+        log_debug("Fetching information about myself")
         try:
             me = self.client.get_me(user_fields=["description", "public_metrics"])
             user_info = me.data.data
@@ -186,7 +195,7 @@ class TwitterTools(Toolkit):
             including id, name, username, description, and follower/following counts,
             or an error message if fetching the information fails.
         """
-        logger.debug(f"Fetching information about user {username}")
+        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
@@ -216,7 +225,7 @@ class TwitterTools(Toolkit):
             including tweet id, text, creation time, and author id,
             or an error message if fetching the timeline fails.
         """
-        logger.debug(f"Fetching home timeline, max results: {max_results}")
+        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"]
@@ -231,9 +240,96 @@ class TwitterTools(Toolkit):
                         "author_id": tweet.author_id,
                     }
                 )
-            logger.info(f"Successfully fetched {len(timeline)} tweets")
+            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

@@ -1,6 +1,8 @@
 import json
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
+from agno.utils.log import log_debug
 
 try:
     import yfinance as yf
@@ -9,39 +11,29 @@ except ImportError:
 
 
 class YFinanceTools(Toolkit):
+    """
+    YFinanceTools is a toolkit for getting financial data from Yahoo Finance.
+    Includes all available financial data tools.
+    """
+
     def __init__(
         self,
-        stock_price: bool = True,
-        company_info: bool = False,
-        stock_fundamentals: bool = False,
-        income_statements: bool = False,
-        key_financial_ratios: bool = False,
-        analyst_recommendations: bool = False,
-        company_news: bool = False,
-        technical_indicators: bool = False,
-        historical_prices: bool = False,
-        enable_all: bool = False,
+        session: Optional[Any] = None,
+        **kwargs,
     ):
-        super().__init__(name="yfinance_tools")
-
-        if stock_price or enable_all:
-            self.register(self.get_current_stock_price)
-        if company_info or enable_all:
-            self.register(self.get_company_info)
-        if stock_fundamentals or enable_all:
-            self.register(self.get_stock_fundamentals)
-        if income_statements or enable_all:
-            self.register(self.get_income_statements)
-        if key_financial_ratios or enable_all:
-            self.register(self.get_key_financial_ratios)
-        if analyst_recommendations or enable_all:
-            self.register(self.get_analyst_recommendations)
-        if company_news or enable_all:
-            self.register(self.get_company_news)
-        if technical_indicators or enable_all:
-            self.register(self.get_technical_indicators)
-        if historical_prices or enable_all:
-            self.register(self.get_historical_stock_prices)
+        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,
+        ]
+        self.session = session
+        super().__init__(name="yfinance_tools", tools=tools, **kwargs)
 
     def get_current_stock_price(self, symbol: str) -> str:
         """
@@ -54,7 +46,8 @@ class YFinanceTools(Toolkit):
             str: The current stock price or error message.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching current price for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             # 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}"
@@ -71,10 +64,12 @@ class YFinanceTools(Toolkit):
             str: JSON containing company profile and overview.
         """
         try:
-            company_info_full = yf.Ticker(symbol).info
+            company_info_full = yf.Ticker(symbol, session=self.session).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"),
@@ -125,7 +120,8 @@ class YFinanceTools(Toolkit):
           str: The current stock price or error message.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching historical prices for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             historical_price = stock.history(period=period, interval=interval)
             return historical_price.to_json(orient="index")
         except Exception as e:
@@ -154,7 +150,8 @@ class YFinanceTools(Toolkit):
                     - '52_week_low': The 52-week low price of the stock.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching fundamentals for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             info = stock.info
             fundamentals = {
                 "symbol": symbol,
@@ -184,7 +181,8 @@ class YFinanceTools(Toolkit):
             dict: JSON containing income statements or an empty dictionary.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching income statements for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             financials = stock.financials
             return financials.to_json(orient="index")
         except Exception as e:
@@ -200,7 +198,8 @@ class YFinanceTools(Toolkit):
             dict: JSON containing key financial ratios.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching key financial ratios for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             key_ratios = stock.info
             return json.dumps(key_ratios, indent=2)
         except Exception as e:
@@ -216,7 +215,8 @@ class YFinanceTools(Toolkit):
             str: JSON containing analyst recommendations.
         """
         try:
-            stock = yf.Ticker(symbol)
+            log_debug(f"Fetching analyst recommendations for {symbol}")
+            stock = yf.Ticker(symbol, session=self.session)
             recommendations = stock.recommendations
             return recommendations.to_json(orient="index")
         except Exception as e:
@@ -233,7 +233,8 @@ class YFinanceTools(Toolkit):
             str: JSON containing company news and press releases.
         """
         try:
-            news = yf.Ticker(symbol).news
+            log_debug(f"Fetching company news for {symbol}")
+            news = yf.Ticker(symbol, session=self.session).news
             return json.dumps(news[:num_stories], indent=2)
         except Exception as e:
             return f"Error fetching company news for {symbol}: {e}"
@@ -250,7 +251,8 @@ class YFinanceTools(Toolkit):
             str: JSON containing technical indicators.
         """
         try:
-            indicators = yf.Ticker(symbol).history(period=period)
+            log_debug(f"Fetching technical indicators for {symbol}")
+            indicators = yf.Ticker(symbol, session=self.session).history(period=period)
             return indicators.to_json(orient="index")
         except Exception as e:
             return f"Error fetching technical indicators for {symbol}: {e}"

agno/tools/youtube.py

@@ -4,6 +4,7 @@ from urllib.parse import parse_qs, urlencode, urlparse
 from urllib.request import urlopen
 
 from agno.tools import Toolkit
+from agno.utils.log import log_debug
 
 try:
     from youtube_transcript_api import YouTubeTranscriptApi
@@ -16,22 +17,26 @@ except ImportError:
 class YouTubeTools(Toolkit):
     def __init__(
         self,
-        get_video_captions: bool = True,
-        get_video_data: bool = True,
-        get_video_timestamps: bool = True,
+        enable_get_video_captions: bool = True,
+        enable_get_video_data: bool = True,
+        enable_get_video_timestamps: bool = True,
+        all: bool = False,
         languages: Optional[List[str]] = None,
         proxies: Optional[Dict[str, Any]] = None,
+        **kwargs,
     ):
-        super().__init__(name="youtube_tools")
-
         self.languages: Optional[List[str]] = languages
         self.proxies: Optional[Dict[str, Any]] = proxies
-        if get_video_captions:
-            self.register(self.get_youtube_video_captions)
-        if get_video_data:
-            self.register(self.get_youtube_video_data)
-        if get_video_timestamps:
-            self.register(self.get_video_timestamps)
+
+        tools: List[Any] = []
+        if all or enable_get_video_captions:
+            tools.append(self.get_youtube_video_captions)
+        if all or enable_get_video_data:
+            tools.append(self.get_youtube_video_data)
+        if all or enable_get_video_timestamps:
+            tools.append(self.get_video_timestamps)
+
+        super().__init__(name="youtube_tools", tools=tools, **kwargs)
 
     def get_youtube_video_id(self, url: str) -> Optional[str]:
         """Function to get the video ID from a YouTube URL.
@@ -70,6 +75,8 @@ class YouTubeTools(Toolkit):
         if not url:
             return "No URL provided"
 
+        log_debug(f"Getting video data for youtube video: {url}")
+
         try:
             video_id = self.get_youtube_video_id(url)
         except Exception:
@@ -112,6 +119,8 @@ class YouTubeTools(Toolkit):
         if not url:
             return "No URL provided"
 
+        log_debug(f"Getting captions for youtube video: {url}")
+
         try:
             video_id = self.get_youtube_video_id(url)
         except Exception:
@@ -124,12 +133,15 @@ class YouTubeTools(Toolkit):
                 kwargs["languages"] = self.languages or ["en"]
             if self.proxies:
                 kwargs["proxies"] = self.proxies
-            captions = YouTubeTranscriptApi.get_transcript(video_id, **kwargs)
-            # logger.debug(f"Captions for video {video_id}: {captions}")
+            if video_id is not None:
+                captions = YouTubeTranscriptApi().fetch(video_id, **kwargs)
+            else:
+                return "No video ID found"
             if captions:
-                return " ".join(line["text"] for line in captions)
+                return " ".join(line.text for line in captions)
             return "No captions found for video"
         except Exception as e:
+            # log_info(f"Error getting captions for video {video_id}: {e}")
             return f"Error getting captions for video: {e}"
 
     def get_video_timestamps(self, url: str) -> str:
@@ -144,11 +156,16 @@ class YouTubeTools(Toolkit):
         if not url:
             return "No URL provided"
 
+        log_debug(f"Getting timestamps for youtube video: {url}")
+
         try:
             video_id = self.get_youtube_video_id(url)
         except Exception:
             return "Error getting video ID from URL, please provide a valid YouTube url"
 
+        if video_id is None:
+            return "No video ID found"
+
         try:
             kwargs: Dict = {}
             if self.languages:
@@ -156,12 +173,12 @@ class YouTubeTools(Toolkit):
             if self.proxies:
                 kwargs["proxies"] = self.proxies
 
-            captions = YouTubeTranscriptApi.get_transcript(video_id, **kwargs)
+            captions = YouTubeTranscriptApi().fetch(video_id, **kwargs)
             timestamps = []
             for line in captions:
-                start = int(line["start"])
+                start = int(line.start)
                 minutes, seconds = divmod(start, 60)
-                timestamps.append(f"{minutes}:{seconds:02d} - {line['text']}")
+                timestamps.append(f"{minutes}:{seconds:02d} - {line.text}")
             return "\n".join(timestamps)
         except Exception as e:
             return f"Error generating timestamps: {e}"

agno/tools/zendesk.py

@@ -1,10 +1,10 @@
 import json
 import re
 from os import getenv
-from typing import Optional
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 try:
     import requests
@@ -23,6 +23,9 @@ class ZendeskTools(Toolkit):
         username: Optional[str] = None,
         password: Optional[str] = None,
         company_name: Optional[str] = None,
+        enable_search_zendesk: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
         """
         Initializes the ZendeskTools class with necessary authentication details
@@ -32,16 +35,21 @@ class ZendeskTools(Toolkit):
         username (str): The username for Zendesk API authentication.
         password (str): The password for Zendesk API authentication.
         company_name (str): The company name to form the base URL for API requests.
+        enable_search_zendesk (bool): Whether to enable the search functionality.
+        all (bool): Enable all functions.
         """
-        super().__init__(name="zendesk_tools")
         self.username = username or getenv("ZENDESK_USERNAME")
-        self.password = password or getenv("ZENDESK_PW")
+        self.password = password or getenv("ZENDESK_PASSWORD")
         self.company_name = company_name or getenv("ZENDESK_COMPANY_NAME")
 
         if not self.username or not self.password or not self.company_name:
             logger.error("Username, password, or company name not provided.")
 
-        self.register(self.search_zendesk)
+        tools: List[Any] = []
+        if all or enable_search_zendesk:
+            tools.append(self.search_zendesk)
+
+        super().__init__(name="zendesk_tools", tools=tools, **kwargs)
 
     def search_zendesk(self, search_string: str) -> str:
         """
@@ -60,6 +68,8 @@ class ZendeskTools(Toolkit):
         if not self.username or not self.password or not self.company_name:
             return "Username, password, or company name not provided."
 
+        log_debug(f"Searching Zendesk for: {search_string}")
+
         auth = (self.username, self.password)
         url = f"https://{self.company_name}.zendesk.com/api/v2/help_center/articles/search.json?query={search_string}"
         try: