agno 2.2.13__py3-none-any.whl

agno/tools/moviepy_video.py

@@ -0,0 +1,349 @@
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_info, logger
+
+try:
+    from moviepy import ColorClip, CompositeVideoClip, TextClip, VideoFileClip  # type: ignore
+except ImportError:
+    raise ImportError("`moviepy` not installed. Please install using `pip install moviepy ffmpeg`")
+
+
+class MoviePyVideoTools(Toolkit):
+    """Tool for processing video files, extracting audio, transcribing and adding captions"""
+
+    def __init__(
+        self,
+        enable_process_video: bool = True,
+        enable_generate_captions: bool = True,
+        enable_embed_captions: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools: List[Any] = []
+        if enable_process_video or all:
+            tools.append(self.extract_audio)
+        if enable_generate_captions or all:
+            tools.append(self.create_srt)
+        if enable_embed_captions or all:
+            tools.append(self.embed_captions)
+
+        super().__init__(name="video_tools", tools=tools, **kwargs)
+
+    def split_text_into_lines(self, words: List[Dict]) -> List[Dict]:
+        """Split transcribed words into lines based on duration and length constraints
+        Args:
+            words: List of dictionaries containing word data with 'word', 'start', and 'end' keys
+        Returns:
+            List[Dict]: List of subtitle lines, each containing word, start time, end time, and text contents
+        """
+        MAX_CHARS = 30
+        MAX_DURATION = 2.5
+        MAX_GAP = 1.5
+
+        subtitles = []
+        line = []
+        line_duration = 0
+
+        for idx, word_data in enumerate(words):
+            line.append(word_data)
+            line_duration += word_data["end"] - word_data["start"]
+
+            temp = " ".join(item["word"] for item in line)
+
+            duration_exceeded = line_duration > MAX_DURATION
+            chars_exceeded = len(temp) > MAX_CHARS
+            maxgap_exceeded = idx > 0 and word_data["start"] - words[idx - 1]["end"] > MAX_GAP
+
+            if duration_exceeded or chars_exceeded or maxgap_exceeded:
+                if line:
+                    subtitle_line = {
+                        "word": " ".join(item["word"] for item in line),
+                        "start": line[0]["start"],
+                        "end": line[-1]["end"],
+                        "textcontents": line,
+                    }
+                    subtitles.append(subtitle_line)
+                    line = []
+                    line_duration = 0
+
+        if line:
+            subtitle_line = {
+                "word": " ".join(item["word"] for item in line),
+                "start": line[0]["start"],
+                "end": line[-1]["end"],
+                "textcontents": line,
+            }
+            subtitles.append(subtitle_line)
+
+        return subtitles
+
+    def create_caption_clips(
+        self,
+        text_json: Dict,
+        frame_size: tuple,
+        font="Arial",
+        color="white",
+        highlight_color="yellow",
+        stroke_color="black",
+        stroke_width=1.5,
+    ) -> List[TextClip]:
+        """Create word-level caption clips with highlighting effects
+        Args:
+            text_json: Dictionary containing text and timing information
+            frame_size: Tuple of (width, height) for the video frame
+            font: Font family to use for captions
+            color: Base text color
+            highlight_color: Color for highlighted words
+            stroke_color: Color for text outline
+            stroke_width: Width of text outline
+        Returns:
+            List[TextClip]: List of MoviePy TextClip objects for each word and highlight
+        """
+        word_clips = []
+        x_pos = 0
+        y_pos = 0
+        line_width = 0
+
+        frame_width, frame_height = frame_size
+        x_buffer = frame_width * 0.1
+        max_line_width = frame_width - (2 * x_buffer)
+        fontsize = int(frame_height * 0.30)
+
+        full_duration = text_json["end"] - text_json["start"]
+
+        for word_data in text_json["textcontents"]:
+            duration = word_data["end"] - word_data["start"]
+
+            # Create base word clip using official TextClip parameters
+            word_clip = (
+                TextClip(
+                    text=word_data["word"],
+                    font=font,
+                    font_size=int(fontsize),
+                    color=color,
+                    stroke_color=stroke_color,
+                    stroke_width=int(stroke_width),
+                    method="label",
+                )
+                .with_start(text_json["start"])
+                .with_duration(full_duration)
+            )
+
+            # Create space clip
+            space_clip = (
+                TextClip(text=" ", font=font, font_size=int(fontsize), color=color, method="label")
+                .with_start(text_json["start"])
+                .with_duration(full_duration)
+            )
+
+            word_width, word_height = word_clip.size
+            space_width = space_clip.size[0]
+
+            # Handle line wrapping
+            if line_width + word_width + space_width <= max_line_width:
+                word_clip = word_clip.with_position((x_pos + x_buffer, y_pos))
+                space_clip = space_clip.with_position((x_pos + word_width + x_buffer, y_pos))
+                x_pos += word_width + space_width
+                line_width += word_width + space_width
+            else:
+                x_pos = 0
+                y_pos += word_height + 10
+                line_width = word_width + space_width
+                word_clip = word_clip.with_position((x_buffer, y_pos))
+                space_clip = space_clip.with_position((word_width + x_buffer, y_pos))
+
+            word_clips.append(word_clip)
+            word_clips.append(space_clip)
+
+            # Create highlighted version
+            highlight_clip = (
+                TextClip(
+                    text=word_data["word"],
+                    font=font,
+                    font_size=int(fontsize),
+                    color=highlight_color,
+                    stroke_color=stroke_color,
+                    stroke_width=int(stroke_width),
+                    method="label",
+                )
+                .with_start(word_data["start"])
+                .with_duration(duration)
+                .with_position(word_clip.pos)
+            )
+
+            word_clips.append(highlight_clip)
+
+        return word_clips
+
+    def parse_srt(self, srt_content: str) -> List[Dict]:
+        """Convert SRT formatted content into word-level timing data
+        Args:
+            srt_content: String containing SRT formatted subtitles
+        Returns:
+            List[Dict]: List of words with their timing information
+        """
+        words = []
+        lines = srt_content.strip().split("\n\n")
+
+        for block in lines:
+            if not block.strip():
+                continue
+
+            parts = block.split("\n")
+            if len(parts) < 3:
+                continue
+
+            # Parse timestamp line
+            timestamp = parts[1]
+            start_time, end_time = timestamp.split(" --> ")
+
+            # Convert timestamp to seconds
+            def time_to_seconds(time_str):
+                h, m, s = time_str.replace(",", ".").split(":")
+                return float(h) * 3600 + float(m) * 60 + float(s)
+
+            start = time_to_seconds(start_time)
+            end = time_to_seconds(end_time)
+
+            # Get text content (could be multiple lines)
+            text = " ".join(parts[2:])
+
+            # Split text into words and distribute timing
+            text_words = text.split()
+            if text_words:
+                time_per_word = (end - start) / len(text_words)
+
+                for i, word in enumerate(text_words):
+                    word_start = start + (i * time_per_word)
+                    word_end = word_start + time_per_word
+                    words.append({"word": word, "start": word_start, "end": word_end})
+
+        return words
+
+    def extract_audio(self, video_path: str, output_path: str) -> str:
+        """Converts video to audio using MoviePy
+        Args:
+            video_path: Path to the video file
+            output_path: Path where the audio will be saved
+        Returns:
+            str: Path to the extracted audio file
+        """
+        try:
+            log_debug(f"Extracting audio from {video_path}")
+            video = VideoFileClip(video_path)
+            video.audio.write_audiofile(output_path)
+            log_info(f"Audio extracted to {output_path}")
+            return output_path
+        except Exception as e:
+            logger.error(f"Failed to extract audio: {str(e)}")
+            return f"Failed to extract audio: {str(e)}"
+
+    def create_srt(self, transcription: str, output_path: str) -> str:
+        """Save transcription text to SRT formatted file
+        Args:
+            transcription: Text transcription in SRT format
+            output_path: Path where the SRT file will be saved
+        Returns:
+            str: Path to the created SRT file, or error message if failed
+        """
+        try:
+            log_debug(f"Creating SRT file at {output_path}")
+            # Since we're getting SRT format from Whisper API now,
+            # we can just write it directly to file
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write(transcription)
+            return output_path
+        except Exception as e:
+            logger.error(f"Failed to create SRT file: {str(e)}")
+            return f"Failed to create SRT file: {str(e)}"
+
+    def embed_captions(
+        self,
+        video_path: str,
+        srt_path: str,
+        output_path: Optional[str] = None,
+        font_size: int = 24,
+        font_color: str = "white",
+        stroke_color: str = "black",
+        stroke_width: int = 1,
+    ) -> str:
+        """Create a new video with embedded scrolling captions and word-level highlighting
+        Args:
+            video_path: Path to the input video file
+            srt_path: Path to the SRT caption file
+            output_path: Path for the output video (optional)
+            font_size: Size of caption text
+            font_color: Color of caption text
+            stroke_color: Color of text outline
+            stroke_width: Width of text outline
+        Returns:
+            str: Path to the captioned video file, or error message if failed
+        """
+        try:
+            # If no output path provided, create one based on input video
+            if output_path is None:
+                output_path = video_path.rsplit(".", 1)[0] + "_captioned.mp4"
+
+            # Load video
+            video = VideoFileClip(video_path)
+
+            # Read caption file and parse SRT
+            with open(srt_path, "r", encoding="utf-8") as f:
+                srt_content = f.read()
+
+            # Parse SRT and get word timing
+            words = self.parse_srt(srt_content)
+
+            # Split into lines
+            subtitle_lines = self.split_text_into_lines(words)
+
+            all_caption_clips = []
+
+            # Create caption clips for each line
+            for line in subtitle_lines:
+                # Increase background height to accommodate larger text
+                bg_height = int(video.h * 0.15)
+                bg_clip = ColorClip(
+                    size=(video.w, bg_height), color=(0, 0, 0), duration=line["end"] - line["start"]
+                ).with_opacity(0.6)
+
+                # Position background even closer to bottom (90% instead of 85%)
+                bg_position = ("center", int(video.h * 0.90))
+                bg_clip = bg_clip.with_start(line["start"]).with_position(bg_position)
+
+                # Create word clips
+                word_clips = self.create_caption_clips(line, (video.w, bg_height))
+
+                # Combine background and words
+                caption_composite = CompositeVideoClip([bg_clip] + word_clips, size=bg_clip.size).with_position(
+                    bg_position
+                )
+
+                all_caption_clips.append(caption_composite)
+
+            # Combine video with all captions
+            final_video = CompositeVideoClip([video] + all_caption_clips, size=video.size)
+
+            # Write output with optimized settings
+            final_video.write_videofile(
+                output_path,
+                codec="libx264",
+                audio_codec="aac",
+                fps=video.fps,
+                preset="medium",
+                threads=4,
+                # Disable default progress bar
+            )
+
+            # Cleanup
+            video.close()
+            final_video.close()
+            for clip in all_caption_clips:
+                clip.close()
+
+            return output_path
+
+        except Exception as e:
+            logger.error(f"Failed to embed captions: {str(e)}")
+            return f"Failed to embed captions: {str(e)}"

agno/tools/neo4j.py

@@ -0,0 +1,134 @@
+import os
+from typing import Any, List, Optional
+
+try:
+    from neo4j import GraphDatabase
+except ImportError:
+    raise ImportError("`neo4j` not installed. Please install using `pip install neo4j`")
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class Neo4jTools(Toolkit):
+    def __init__(
+        self,
+        uri: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        # Enable flags for <6 functions
+        enable_list_labels: bool = True,
+        enable_list_relationships: bool = True,
+        enable_get_schema: bool = True,
+        enable_run_cypher: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize the Neo4jTools toolkit.
+        Connection parameters (uri/user/password or host/port) can be provided.
+        If not provided, falls back to NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD env vars.
+
+        Args:
+            uri (Optional[str]): The Neo4j URI.
+            user (Optional[str]): The Neo4j username.
+            password (Optional[str]): The Neo4j password.
+            host (Optional[str]): The Neo4j host.
+            port (Optional[int]): The Neo4j port.
+            database (Optional[str]): The Neo4j database.
+            list_labels (bool): Whether to list node labels.
+            list_relationships (bool): Whether to list relationship types.
+            get_schema (bool): Whether to get the schema.
+            run_cypher (bool): Whether to run Cypher queries.
+            **kwargs: Additional keyword arguments.
+        """
+        # Determine the connection URI and credentials
+        uri = uri or os.getenv("NEO4J_URI", "bolt://localhost:7687")
+        user = user or os.getenv("NEO4J_USERNAME")
+        password = password or os.getenv("NEO4J_PASSWORD")
+
+        if user is None or password is None:
+            raise ValueError("Username or password for Neo4j not provided")
+
+        # Create the Neo4j driver
+        try:
+            self.driver = GraphDatabase.driver(uri, auth=(user, password))  # type: ignore
+            self.driver.verify_connectivity()
+            log_debug("Connected to Neo4j database")
+        except Exception as e:
+            logger.error(f"Failed to connect to Neo4j: {e}")
+            raise
+
+        self.database = database or "neo4j"
+
+        # Register toolkit methods as tools
+        tools: List[Any] = []
+        if all or enable_list_labels:
+            tools.append(self.list_labels)
+        if all or enable_list_relationships:
+            tools.append(self.list_relationship_types)
+        if all or enable_get_schema:
+            tools.append(self.get_schema)
+        if all or enable_run_cypher:
+            tools.append(self.run_cypher_query)
+        super().__init__(name="neo4j_tools", tools=tools, **kwargs)
+
+    def list_labels(self) -> list:
+        """
+        Retrieve all node labels present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing node labels in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.labels()")
+                labels = [record["label"] for record in result]
+            return labels
+        except Exception as e:
+            logger.error(f"Error listing labels: {e}")
+            return []
+
+    def list_relationship_types(self) -> list:
+        """
+        Retrieve all relationship types present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing relationship types in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.relationshipTypes()")
+                types = [record["relationshipType"] for record in result]
+            return types
+        except Exception as e:
+            logger.error(f"Error listing relationship types: {e}")
+            return []
+
+    def get_schema(self) -> list:
+        """
+        Retrieve a visualization of the database schema, including nodes and relationships.
+        """
+        try:
+            log_debug("Retrieving Neo4j schema visualization")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.schema.visualization()")
+                schema_data = result.data()
+            return schema_data
+        except Exception as e:
+            logger.error(f"Error getting Neo4j schema: {e}")
+            return []
+
+    def run_cypher_query(self, query: str) -> list:
+        """
+        Execute an arbitrary Cypher query against the connected Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to execute.
+        """
+        try:
+            log_debug(f"Running Cypher query: {query}")
+            with self.driver.session(database=self.database) as session:
+                result = session.run(query)  # type: ignore[arg-type]
+                data = result.data()
+            return data
+        except Exception as e:
+            logger.error(f"Error running Cypher query: {e}")
+            return []

agno/tools/newspaper.py

@@ -0,0 +1,46 @@
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+try:
+    from newspaper import Article
+except ImportError:
+    raise ImportError("`newspaper3k` not installed. Please run `pip install newspaper3k lxml_html_clean`.")
+
+
+class NewspaperTools(Toolkit):
+    """
+    Newspaper is a tool for getting the text of an article from a URL.
+    Args:
+        get_article_text (bool): Whether to get the text of an article from a URL.
+    """
+
+    def __init__(
+        self,
+        enable_get_article_text: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools = []
+        if all or enable_get_article_text:
+            tools.append(self.get_article_text)
+
+        super().__init__(name="newspaper_toolkit", tools=tools, **kwargs)
+
+    def get_article_text(self, url: str) -> str:
+        """Get the text of an article from a URL.
+
+        Args:
+            url (str): The URL of the article.
+
+        Returns:
+            str: The text of the article.
+        """
+
+        try:
+            log_debug(f"Reading news: {url}")
+            article = Article(url)
+            article.download()
+            article.parse()
+            return article.text
+        except Exception as e:
+            return f"Error getting article text from {url}: {e}"

agno/tools/newspaper4k.py

@@ -0,0 +1,93 @@
+import json
+from typing import Any, Dict, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    import newspaper
+except ImportError:
+    raise ImportError("`newspaper4k` not installed. Please run `pip install newspaper4k lxml_html_clean`.")
+
+
+class Newspaper4kTools(Toolkit):
+    """
+    Newspaper4kTools is a toolkit for getting the text of an article from a URL.
+    Args:
+        enable_read_article (bool): Whether to read an article from a URL.
+        include_summary (bool): Whether to include the summary of an article.
+        article_length (Optional[int]): The length of the article to read.
+    """
+
+    def __init__(
+        self,
+        include_summary: bool = False,
+        article_length: Optional[int] = None,
+        enable_read_article: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.include_summary: bool = include_summary
+        self.article_length: Optional[int] = article_length
+
+        tools = []
+        if all or enable_read_article:
+            tools.append(self.read_article)
+
+        super().__init__(name="newspaper4k_tools", tools=tools, **kwargs)
+
+    def get_article_data(self, url: str) -> Optional[Dict[str, Any]]:
+        """Read and get article data from a URL.
+
+        Args:
+            url (str): The URL of the article.
+
+        Returns:
+            Dict[str, Any]: The article data.
+        """
+
+        try:
+            article = newspaper.article(url)
+            article_data = {}
+            if article.title:
+                article_data["title"] = article.title
+            if article.authors:
+                article_data["authors"] = article.authors
+            if article.text:
+                article_data["text"] = article.text
+            if self.include_summary and article.summary:
+                article_data["summary"] = article.summary
+
+            try:
+                if article.publish_date:
+                    article_data["publish_date"] = article.publish_date.isoformat() if article.publish_date else None
+            except Exception:
+                pass
+
+            return article_data
+        except Exception as e:
+            logger.warning(f"Error reading article from {url}: {e}")
+            return None
+
+    def read_article(self, url: str) -> str:
+        """Use this function to read an article from a URL.
+
+        Args:
+            url (str): The URL of the article.
+
+        Returns:
+            str: JSON containing the article author, publish date, and text.
+        """
+
+        try:
+            log_debug(f"Reading news: {url}")
+            article_data = self.get_article_data(url)
+            if not article_data:
+                return f"Error reading article from {url}: No data found."
+
+            if self.article_length and "text" in article_data:
+                article_data["text"] = article_data["text"][: self.article_length]
+
+            return json.dumps(article_data, indent=2)
+        except Exception as e:
+            return f"Error reading article from {url}: {e}"