agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/tools/wikipedia.py

@@ -1,18 +1,24 @@
 import json
 from typing import List, Optional
 
-from agno.document import Document
-from agno.knowledge.wikipedia import WikipediaKnowledgeBase
+from agno.knowledge.document import Document
+from agno.knowledge.knowledge import Knowledge
+from agno.knowledge.reader.wikipedia_reader import WikipediaReader
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_info
 
 
 class WikipediaTools(Toolkit):
-    def __init__(self, knowledge_base: Optional[WikipediaKnowledgeBase] = None, **kwargs):
+    def __init__(
+        self,
+        knowledge: Optional[Knowledge] = None,
+        all: bool = False,
+        **kwargs,
+    ):
         tools = []
 
-        self.knowledge_base: Optional[WikipediaKnowledgeBase] = knowledge_base
-        if self.knowledge_base is not None and isinstance(self.knowledge_base, WikipediaKnowledgeBase):
+        self.knowledge: Optional[Knowledge] = knowledge
+        if self.knowledge is not None and isinstance(self.knowledge, Knowledge):
             tools.append(self.search_wikipedia_and_update_knowledge_base)
         else:
             tools.append(self.search_wikipedia)  # type: ignore
@@ -28,15 +34,16 @@ class WikipediaTools(Toolkit):
         :return: Relevant documents from Wikipedia knowledge base.
         """
 
-        if self.knowledge_base is None:
-            return "Knowledge base not provided"
+        if self.knowledge is None:
+            return "Knowledge not provided"
 
-        log_debug(f"Adding to knowledge base: {topic}")
-        self.knowledge_base.topics.append(topic)
-        log_debug("Loading knowledge base.")
-        self.knowledge_base.load(recreate=False)
-        log_debug(f"Searching knowledge base: {topic}")
-        relevant_docs: List[Document] = self.knowledge_base.search(query=topic)
+        log_debug(f"Adding to knowledge: {topic}")
+        self.knowledge.add_content(
+            topics=[topic],
+            reader=WikipediaReader(),
+        )
+        log_debug(f"Searching knowledge: {topic}")
+        relevant_docs: List[Document] = self.knowledge.search(query=topic)
         return json.dumps([doc.to_dict() for doc in relevant_docs])
 
     def search_wikipedia(self, query: str) -> str:

agno/tools/x.py

@@ -1,5 +1,5 @@
 import json
-import os
+from os import getenv
 from typing import Any, List, Optional
 
 from agno.tools import Toolkit
@@ -35,11 +35,11 @@ class XTools(Toolkit):
             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 os.getenv("X_BEARER_TOKEN")
-        self.consumer_key = consumer_key or os.getenv("X_CONSUMER_KEY")
-        self.consumer_secret = consumer_secret or os.getenv("X_CONSUMER_SECRET")
-        self.access_token = access_token or os.getenv("X_ACCESS_TOKEN")
-        self.access_token_secret = access_token_secret or os.getenv("X_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,
@@ -51,13 +51,14 @@ class XTools(Toolkit):
         )
         self.include_post_metrics = include_post_metrics
 
-        tools: List[Any] = []
-        tools.append(self.create_post)
-        tools.append(self.reply_to_post)
-        tools.append(self.send_dm)
-        tools.append(self.get_user_info)
-        tools.append(self.get_home_timeline)
-        tools.append(self.search_posts)
+        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)
 

agno/tools/yfinance.py

@@ -1,4 +1,5 @@
 import json
+from typing import Any, List
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug
@@ -12,52 +13,24 @@ except ImportError:
 class YFinanceTools(Toolkit):
     """
     YFinanceTools is a toolkit for getting financial data from Yahoo Finance.
-    Args:
-        stock_price (bool): Whether to get the current stock price.
-        company_info (bool): Whether to get company information.
-        stock_fundamentals (bool): Whether to get stock fundamentals.
-        income_statements (bool): Whether to get income statements.
-        key_financial_ratios (bool): Whether to get key financial ratios.
-        analyst_recommendations (bool): Whether to get analyst recommendations.
-        company_news (bool): Whether to get company news.
-        technical_indicators (bool): Whether to get technical indicators.
-        historical_prices (bool): Whether to get historical prices.
-        enable_all (bool): Whether to enable all tools.
+    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,
         **kwargs,
     ):
-        tools = []
-        if stock_price or enable_all:
-            tools.append(self.get_current_stock_price)
-        if company_info or enable_all:
-            tools.append(self.get_company_info)
-        if stock_fundamentals or enable_all:
-            tools.append(self.get_stock_fundamentals)
-        if income_statements or enable_all:
-            tools.append(self.get_income_statements)
-        if key_financial_ratios or enable_all:
-            tools.append(self.get_key_financial_ratios)
-        if analyst_recommendations or enable_all:
-            tools.append(self.get_analyst_recommendations)
-        if company_news or enable_all:
-            tools.append(self.get_company_news)
-        if technical_indicators or enable_all:
-            tools.append(self.get_technical_indicators)
-        if historical_prices or enable_all:
-            tools.append(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,
+        ]
 
         super().__init__(name="yfinance_tools", tools=tools, **kwargs)
 

agno/tools/youtube.py

@@ -17,9 +17,10 @@ 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,
@@ -28,11 +29,11 @@ class YouTubeTools(Toolkit):
         self.proxies: Optional[Dict[str, Any]] = proxies
 
         tools: List[Any] = []
-        if get_video_captions:
+        if all or enable_get_video_captions:
             tools.append(self.get_youtube_video_captions)
-        if get_video_data:
+        if all or enable_get_video_data:
             tools.append(self.get_youtube_video_data)
-        if get_video_timestamps:
+        if all or enable_get_video_timestamps:
             tools.append(self.get_video_timestamps)
 
         super().__init__(name="youtube_tools", tools=tools, **kwargs)
@@ -126,17 +127,19 @@ class YouTubeTools(Toolkit):
             return "Error getting video ID from URL, please provide a valid YouTube url"
 
         try:
-            ytt_api = YouTubeTranscriptApi()
-            captions_data = ytt_api.fetch(video_id)
-
-            # log_info(f"Captions for video {video_id}: {captions_data}")
-
-            transcript_text = ""
-
-            for segment in captions_data:
-                transcript_text += f"{segment.text} "
-
-            return transcript_text.strip() if transcript_text else "No captions found for video"
+            captions = None
+            kwargs: Dict = {}
+            if self.languages:
+                kwargs["languages"] = self.languages or ["en"]
+            if self.proxies:
+                kwargs["proxies"] = self.proxies
+            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 "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}"
@@ -160,6 +163,9 @@ class YouTubeTools(Toolkit):
         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:
@@ -167,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

@@ -23,6 +23,8 @@ 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,
     ):
         """
@@ -33,16 +35,19 @@ 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.
         """
         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.")
 
         tools: List[Any] = []
-        tools.append(self.search_zendesk)
+        if all or enable_search_zendesk:
+            tools.append(self.search_zendesk)
 
         super().__init__(name="zendesk_tools", tools=tools, **kwargs)
 

agno/tools/zep.py

@@ -40,11 +40,12 @@ class ZepTools(Toolkit):
         user_id: Optional[str] = None,
         api_key: Optional[str] = None,
         ignore_assistant_messages: bool = False,
-        add_zep_message: bool = True,
-        get_zep_memory: bool = True,
-        search_zep_memory: bool = True,
+        enable_add_zep_message: bool = True,
+        enable_get_zep_memory: bool = True,
+        enable_search_zep_memory: bool = True,
         instructions: Optional[str] = None,
         add_instructions: bool = False,
+        all: bool = False,
         **kwargs,
     ):
         self._api_key = api_key or getenv("ZEP_API_KEY")
@@ -71,11 +72,11 @@ class ZepTools(Toolkit):
         self.initialize()
 
         tools: List[Any] = []
-        if add_zep_message:
+        if enable_add_zep_message or all:
             tools.append(self.add_zep_message)
-        if get_zep_memory:
+        if enable_get_zep_memory or all:
             tools.append(self.get_zep_memory)
-        if search_zep_memory:
+        if enable_search_zep_memory or all:
             tools.append(self.search_zep_memory)
 
         super().__init__(
@@ -118,7 +119,7 @@ class ZepTools(Toolkit):
 
             # Create session associated with the user
             try:
-                self.zep_client.thread.create(thread_id=self.session_id, user_id=self.user_id)
+                self.zep_client.thread.create(thread_id=self.session_id, user_id=self.user_id)  # type: ignore
                 log_debug(f"Created session {self.session_id} for user {self.user_id}")
             except Exception as e:
                 log_debug(f"Session may already exist: {e}")
@@ -150,6 +151,7 @@ class ZepTools(Toolkit):
             zep_message = ZepMessage(
                 role=role,
                 content=content,
+                role_type=role,
             )
 
             # Prepare ignore_roles if needed
@@ -358,6 +360,7 @@ class ZepAsyncTools(Toolkit):
             zep_message = ZepMessage(
                 role=role,
                 content=content,
+                role_type=role,
             )
 
             # Prepare ignore_roles if needed

agno/tools/zoom.py

@@ -6,7 +6,7 @@ from typing import Any, List, Optional
 
 import requests
 
-from agno.tools.toolkit import Toolkit
+from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_info, logger
 
 
@@ -39,14 +39,15 @@ class ZoomTools(Toolkit):
                 "ZOOM_ACCOUNT_ID, ZOOM_CLIENT_ID, and ZOOM_CLIENT_SECRET must be set either through parameters or environment variables."
             )
 
-        tools: List[Any] = []
-
-        tools.append(self.schedule_meeting)
-        tools.append(self.get_upcoming_meetings)
-        tools.append(self.list_meetings)
-        tools.append(self.get_meeting_recordings)
-        tools.append(self.delete_meeting)
-        tools.append(self.get_meeting)
+        tools: List[Any] = [
+            self.get_access_token,
+            self.schedule_meeting,
+            self.get_upcoming_meetings,
+            self.list_meetings,
+            self.get_meeting_recordings,
+            self.delete_meeting,
+            self.get_meeting,
+        ]
 
         super().__init__(name="zoom_tool", tools=tools, **kwargs)
 

agno/utils/common.py

@@ -10,24 +10,6 @@ def isinstanceany(obj: Any, class_list: List[Type]) -> bool:
     return False
 
 
-def str_to_int(inp: Optional[str]) -> Optional[int]:
-    """
-    Safely converts a string value to integer.
-    Args:
-        inp: input string
-
-    Returns: input string as int if possible, None if not
-    """
-    if inp is None:
-        return None
-
-    try:
-        val = int(inp)
-        return val
-    except Exception:
-        return None
-
-
 def is_empty(val: Any) -> bool:
     """Returns True if val is None or empty"""
     if val is None or len(val) == 0 or val == "":
@@ -43,7 +25,7 @@ def dataclass_to_dict(dataclass_object, exclude: Optional[set[str]] = None, excl
     final_dict = asdict(dataclass_object)
     if exclude:
         for key in exclude:
-            final_dict.pop(key)
+            final_dict.pop(key, None)
     if exclude_none:
         final_dict = {k: v for k, v in final_dict.items() if v is not None}
     return final_dict