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

agno/tools/reddit.py

@@ -1,9 +1,9 @@
 import json
 from os import getenv
-from typing import Dict, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     import praw  # type: ignore
@@ -20,17 +20,10 @@ class RedditTools(Toolkit):
         user_agent: Optional[str] = None,
         username: Optional[str] = None,
         password: Optional[str] = None,
-        get_user_info: bool = True,
-        get_top_posts: bool = True,
-        get_subreddit_info: bool = True,
-        get_trending_subreddits: bool = True,
-        get_subreddit_stats: bool = True,
-        create_post: bool = True,
+        **kwargs,
     ):
-        super().__init__(name="reddit")
-
         if reddit_instance is not None:
-            logger.info("Using provided Reddit instance")
+            log_info("Using provided Reddit instance")
             self.reddit = reddit_instance
         else:
             # Get credentials from environment variables if not provided
@@ -45,7 +38,7 @@ class RedditTools(Toolkit):
             if all([self.client_id, self.client_secret]):
                 # Initialize with read-only access if no user credentials
                 if not all([self.username, self.password]):
-                    logger.info("Initializing Reddit client with read-only access")
+                    log_info("Initializing Reddit client with read-only access")
                     self.reddit = praw.Reddit(
                         client_id=self.client_id,
                         client_secret=self.client_secret,
@@ -53,7 +46,7 @@ class RedditTools(Toolkit):
                     )
                 # Initialize with user authentication if credentials provided
                 else:
-                    logger.info(f"Initializing Reddit client with user authentication for u/{self.username}")
+                    log_info(f"Initializing Reddit client with user authentication for u/{self.username}")
                     self.reddit = praw.Reddit(
                         client_id=self.client_id,
                         client_secret=self.client_secret,
@@ -64,18 +57,18 @@ class RedditTools(Toolkit):
             else:
                 logger.warning("Missing Reddit API credentials")
 
-        if get_user_info:
-            self.register(self.get_user_info)
-        if get_top_posts:
-            self.register(self.get_top_posts)
-        if get_subreddit_info:
-            self.register(self.get_subreddit_info)
-        if get_trending_subreddits:
-            self.register(self.get_trending_subreddits)
-        if get_subreddit_stats:
-            self.register(self.get_subreddit_stats)
-        if create_post:
-            self.register(self.create_post)
+        tools: List[Callable] = [
+            self.get_user_info,
+            self.get_top_posts,
+            self.get_subreddit_info,
+            self.get_trending_subreddits,
+            self.get_subreddit_stats,
+            self.create_post,
+            self.reply_to_post,
+            self.reply_to_comment,
+        ]
+
+        super().__init__(name="reddit", tools=tools, **kwargs)
 
     def _check_user_auth(self) -> bool:
         """
@@ -105,7 +98,7 @@ class RedditTools(Toolkit):
             return "Please provide Reddit API credentials"
 
         try:
-            logger.info(f"Getting info for u/{username}")
+            log_info(f"Getting info for u/{username}")
 
             user = self.reddit.redditor(username)
             info: Dict[str, Union[str, int, bool, float]] = {
@@ -137,14 +130,20 @@ class RedditTools(Toolkit):
             return "Please provide Reddit API credentials"
 
         try:
+            log_debug(f"Getting top posts from r/{subreddit}")
             posts = self.reddit.subreddit(subreddit).top(time_filter=time_filter, limit=limit)
             top_posts: List[Dict[str, Union[str, int, float]]] = [
                 {
+                    "id": post.id,
                     "title": post.title,
                     "score": post.score,
                     "url": post.url,
+                    "selftext": post.selftext,
                     "author": str(post.author),
+                    "permalink": post.permalink,
                     "created_utc": post.created_utc,
+                    "subreddit": str(post.subreddit),
+                    "subreddit_name_prefixed": post.subreddit_name_prefixed,
                 }
                 for post in posts
             ]
@@ -164,7 +163,7 @@ class RedditTools(Toolkit):
             return "Please provide Reddit API credentials"
 
         try:
-            logger.info(f"Getting info for r/{subreddit_name}")
+            log_info(f"Getting info for r/{subreddit_name}")
 
             subreddit = self.reddit.subreddit(subreddit_name)
             flairs = [flair["text"] for flair in subreddit.flair.link_templates]
@@ -191,6 +190,7 @@ class RedditTools(Toolkit):
             return "Please provide Reddit API credentials"
 
         try:
+            log_debug("Getting trending subreddits")
             popular_subreddits = self.reddit.subreddits.popular(limit=5)
             trending: List[str] = [subreddit.display_name for subreddit in popular_subreddits]
             return json.dumps({"trending_subreddits": trending})
@@ -209,6 +209,7 @@ class RedditTools(Toolkit):
             return "Please provide Reddit API credentials"
 
         try:
+            log_debug(f"Getting stats for r/{subreddit}")
             sub = self.reddit.subreddit(subreddit)
             stats: Dict[str, Union[str, int, bool, float]] = {
                 "display_name": sub.display_name,
@@ -250,7 +251,7 @@ class RedditTools(Toolkit):
             return "User authentication required for posting. Please provide username and password."
 
         try:
-            logger.info(f"Creating post in r/{subreddit}")
+            log_info(f"Creating post in r/{subreddit}")
 
             subreddit_obj = self.reddit.subreddit(subreddit)
 
@@ -271,7 +272,7 @@ class RedditTools(Toolkit):
                     url=content,
                     flair_id=flair,
                 )
-            logger.info(f"Post created: {submission.permalink}")
+            log_info(f"Post created: {submission.permalink}")
 
             post_info: Dict[str, Union[str, int, float]] = {
                 "id": submission.id,
@@ -287,3 +288,180 @@ class RedditTools(Toolkit):
 
         except Exception as e:
             return f"Error creating post: {e}"
+
+    def reply_to_post(self, post_id: str, content: str, subreddit: Optional[str] = None) -> str:
+        """
+        Post a reply to an existing Reddit post or comment.
+
+        Args:
+            post_id (str): The ID of the post or comment to reply to.
+                          Can be a full URL, permalink, or just the ID.
+            content (str): The content of the reply.
+            subreddit (Optional[str]): The subreddit name if known.
+                                     This helps with error handling and validation.
+
+        Returns:
+            str: JSON string containing information about the created reply.
+        """
+        if not self.reddit:
+            logger.error("Reddit instance not initialized")
+            return "Please provide Reddit API credentials"
+
+        if not self._check_user_auth():
+            logger.error("User authentication failed")
+            return "User authentication required for posting replies. Please provide username and password."
+
+        try:
+            log_debug(f"Creating reply to post {post_id}")
+
+            # Clean up the post_id if it's a full URL or permalink
+            if "/" in post_id:
+                # Extract the actual ID from the URL/permalink
+                original_id = post_id
+                post_id = post_id.split("/")[-1]
+                log_debug(f"Extracted post ID {post_id} from {original_id}")
+
+            # Verify post exists
+            if not self._check_post_exists(post_id):
+                error_msg = f"Post with ID {post_id} does not exist or is not accessible"
+                logger.error(error_msg)
+                return error_msg
+
+            # Get the submission object
+            submission = self.reddit.submission(id=post_id)
+
+            log_debug(
+                f"Post details: Title: {submission.title}, Author: {submission.author}, Subreddit: {submission.subreddit.display_name}"
+            )
+
+            # If subreddit was provided, verify we're in the right place
+            if subreddit and submission.subreddit.display_name.lower() != subreddit.lower():
+                error_msg = f"Error: Post ID belongs to r/{submission.subreddit.display_name}, not r/{subreddit}"
+                logger.error(error_msg)
+                return error_msg
+
+            # Create the reply
+            log_debug(f"Attempting to post reply with content length: {len(content)}")
+            reply = submission.reply(body=content)
+
+            # Prepare the response information
+            reply_info: Dict[str, Union[str, int, float]] = {
+                "id": reply.id,
+                "body": reply.body,
+                "score": reply.score,
+                "permalink": reply.permalink,
+                "created_utc": reply.created_utc,
+                "author": str(reply.author),
+                "parent_id": reply.parent_id,
+                "submission_id": submission.id,
+                "subreddit": str(reply.subreddit),
+            }
+
+            log_debug(f"Reply created successfully: {reply.permalink}")
+            return json.dumps({"reply": reply_info})
+
+        except praw.exceptions.RedditAPIException as api_error:
+            # Handle specific Reddit API errors
+            error_messages = [f"{error.error_type}: {error.message}" for error in api_error.items]
+            error_msg = f"Reddit API Error: {'; '.join(error_messages)}"
+            logger.error(error_msg)
+            return error_msg
+
+        except Exception as e:
+            error_msg = f"Error creating reply: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
+
+    def reply_to_comment(self, comment_id: str, content: str, subreddit: Optional[str] = None) -> str:
+        """
+        Post a reply to an existing Reddit comment.
+
+        Args:
+            comment_id (str): The ID of the comment to reply to.
+                            Can be a full URL, permalink, or just the ID.
+            content (str): The content of the reply.
+            subreddit (Optional[str]): The subreddit name if known.
+                                     This helps with error handling and validation.
+
+        Returns:
+            str: JSON string containing information about the created reply.
+        """
+        if not self.reddit:
+            logger.error("Reddit instance not initialized")
+            return "Please provide Reddit API credentials"
+
+        if not self._check_user_auth():
+            logger.error("User authentication failed")
+            return "User authentication required for posting replies. Please provide username and password."
+
+        try:
+            log_debug(f"Creating reply to comment {comment_id}")
+
+            # Clean up the comment_id if it's a full URL or permalink
+            if "/" in comment_id:
+                original_id = comment_id
+                comment_id = comment_id.split("/")[-1]
+                log_info(f"Extracted comment ID {comment_id} from {original_id}")
+
+            # Get the comment object
+            comment = self.reddit.comment(id=comment_id)
+
+            log_debug(f"Comment details: Author: {comment.author}, Subreddit: {comment.subreddit.display_name}")
+
+            # If subreddit was provided, verify we're in the right place
+            if subreddit and comment.subreddit.display_name.lower() != subreddit.lower():
+                error_msg = f"Error: Comment ID belongs to r/{comment.subreddit.display_name}, not r/{subreddit}"
+                logger.error(error_msg)
+                return error_msg
+
+            # Create the reply
+            log_debug(f"Attempting to post reply with content length: {len(content)}")
+            reply = comment.reply(body=content)
+
+            # Prepare the response information
+            reply_info: Dict[str, Union[str, int, float]] = {
+                "id": reply.id,
+                "body": reply.body,
+                "score": reply.score,
+                "permalink": reply.permalink,
+                "created_utc": reply.created_utc,
+                "author": str(reply.author),
+                "parent_id": reply.parent_id,
+                "submission_id": comment.submission.id,
+                "subreddit": str(reply.subreddit),
+            }
+
+            log_debug(f"Reply created successfully: {reply.permalink}")
+            return json.dumps({"reply": reply_info})
+
+        except praw.exceptions.RedditAPIException as api_error:
+            # Handle specific Reddit API errors
+            error_messages = [f"{error.error_type}: {error.message}" for error in api_error.items]
+            error_msg = f"Reddit API Error: {'; '.join(error_messages)}"
+            logger.error(error_msg)
+            return error_msg
+
+        except Exception as e:
+            error_msg = f"Error creating reply: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
+
+    def _check_post_exists(self, post_id: str) -> bool:
+        """
+        Verify that a post exists and is accessible.
+
+        Args:
+            post_id (str): The ID of the post to check
+
+        Returns:
+            bool: True if post exists and is accessible, False otherwise
+        """
+        try:
+            submission = self.reddit.submission(id=post_id)
+            # Try to access some attributes to verify the post exists
+            _ = submission.title
+            _ = submission.author
+            return True
+        except Exception as e:
+            logger.error(f"Error checking post existence: {str(e)}")
+            return False