agno 2.2.13__py3-none-any.whl

agno/tools/youtube.py

@@ -0,0 +1,184 @@
+import json
+from typing import Any, Dict, List, Optional
+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
+except ImportError:
+    raise ImportError(
+        "`youtube_transcript_api` not installed. Please install using `pip install youtube_transcript_api`"
+    )
+
+
+class YouTubeTools(Toolkit):
+    def __init__(
+        self,
+        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,
+    ):
+        self.languages: Optional[List[str]] = languages
+        self.proxies: Optional[Dict[str, Any]] = proxies
+
+        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.
+
+        Args:
+            url: The URL of the YouTube video.
+
+        Returns:
+            str: The video ID of the YouTube video.
+        """
+        parsed_url = urlparse(url)
+        hostname = parsed_url.hostname
+
+        if hostname == "youtu.be":
+            return parsed_url.path[1:]
+        if hostname in ("www.youtube.com", "youtube.com"):
+            if parsed_url.path == "/watch":
+                query_params = parse_qs(parsed_url.query)
+                return query_params.get("v", [None])[0]
+            if parsed_url.path.startswith("/embed/"):
+                return parsed_url.path.split("/")[2]
+            if parsed_url.path.startswith("/v/"):
+                return parsed_url.path.split("/")[2]
+        return None
+
+    def get_youtube_video_data(self, url: str) -> str:
+        """Function to get video data from a YouTube URL.
+        Data returned includes {title, author_name, author_url, type, height, width, version, provider_name, provider_url, thumbnail_url}
+
+        Args:
+            url: The URL of the YouTube video.
+
+        Returns:
+            str: JSON data of the YouTube video.
+        """
+        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:
+            return "Error getting video ID from URL, please provide a valid YouTube url"
+
+        try:
+            params = {"format": "json", "url": f"https://www.youtube.com/watch?v={video_id}"}
+            url = "https://www.youtube.com/oembed"
+            query_string = urlencode(params)
+            url = url + "?" + query_string
+
+            with urlopen(url) as response:
+                response_text = response.read()
+                video_data = json.loads(response_text.decode())
+                clean_data = {
+                    "title": video_data.get("title"),
+                    "author_name": video_data.get("author_name"),
+                    "author_url": video_data.get("author_url"),
+                    "type": video_data.get("type"),
+                    "height": video_data.get("height"),
+                    "width": video_data.get("width"),
+                    "version": video_data.get("version"),
+                    "provider_name": video_data.get("provider_name"),
+                    "provider_url": video_data.get("provider_url"),
+                    "thumbnail_url": video_data.get("thumbnail_url"),
+                }
+                return json.dumps(clean_data, indent=4)
+        except Exception as e:
+            return f"Error getting video data: {e}"
+
+    def get_youtube_video_captions(self, url: str) -> str:
+        """Use this function to get captions from a YouTube video.
+
+        Args:
+            url: The URL of the YouTube video.
+
+        Returns:
+            str: The captions of the YouTube video.
+        """
+        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:
+            return "Error getting video ID from URL, please provide a valid YouTube url"
+
+        try:
+            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}"
+
+    def get_video_timestamps(self, url: str) -> str:
+        """Generate timestamps for a YouTube video based on captions.
+
+        Args:
+            url: The URL of the YouTube video.
+
+        Returns:
+            str: Timestamps and summaries for the video.
+        """
+        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:
+                kwargs["languages"] = self.languages or ["en"]
+            if self.proxies:
+                kwargs["proxies"] = self.proxies
+
+            captions = YouTubeTranscriptApi().fetch(video_id, **kwargs)
+            timestamps = []
+            for line in captions:
+                start = int(line.start)
+                minutes, seconds = divmod(start, 60)
+                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

@@ -0,0 +1,82 @@
+import json
+import re
+from os import getenv
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    import requests
+except ImportError:
+    raise ImportError("`requests` not installed. Please install using `pip install requests`.")
+
+
+class ZendeskTools(Toolkit):
+    """
+    A toolkit class for interacting with the Zendesk API to search articles.
+    It requires authentication details and the company name to configure the API access.
+    """
+
+    def __init__(
+        self,
+        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
+        and registers the search_zendesk method.
+
+        Parameters:
+        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_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] = []
+        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:
+        """
+        Searches for articles in Zendesk Help Center that match the given search string.
+
+        Parameters:
+        search_string (str): The search query to look for in Zendesk articles.
+
+        Returns:
+        str: A JSON-formatted string containing the list of articles without HTML tags.
+
+        Raises:
+        ConnectionError: If the API request fails due to connection-related issues.
+        """
+
+        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:
+            response = requests.get(url, auth=auth)
+            response.raise_for_status()
+            clean = re.compile("<.*?>")
+            articles = [re.sub(clean, "", article["body"]) for article in response.json()["results"]]
+            return json.dumps(articles)
+        except requests.RequestException as e:
+            raise ConnectionError(f"API request failed: {e}")