agno 2.2.13__py3-none-any.whl

agno/tools/arxiv.py

@@ -0,0 +1,127 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    import arxiv
+except ImportError:
+    raise ImportError("`arxiv` not installed. Please install using `pip install arxiv`")
+
+try:
+    from pypdf import PdfReader
+except ImportError:
+    raise ImportError("`pypdf` not installed. Please install using `pip install pypdf`")
+
+
+class ArxivTools(Toolkit):
+    def __init__(
+        self,
+        enable_search_arxiv: bool = True,
+        enable_read_arxiv_papers: bool = True,
+        all: bool = False,
+        download_dir: Optional[Path] = None,
+        **kwargs,
+    ):
+        self.client: arxiv.Client = arxiv.Client()
+        self.download_dir: Path = download_dir or Path(__file__).parent.joinpath("arxiv_pdfs")
+
+        tools: List[Any] = []
+        if all or enable_search_arxiv:
+            tools.append(self.search_arxiv_and_return_articles)
+        if all or enable_read_arxiv_papers:
+            tools.append(self.read_arxiv_papers)
+
+        super().__init__(name="arxiv_tools", tools=tools, **kwargs)
+
+    def search_arxiv_and_return_articles(self, query: str, num_articles: int = 10) -> str:
+        """Use this function to search arXiv for a query and return the top articles.
+
+        Args:
+            query (str): The query to search arXiv for.
+            num_articles (int, optional): The number of articles to return. Defaults to 10.
+        Returns:
+            str: A JSON of the articles with title, id, authors, pdf_url and summary.
+        """
+
+        articles = []
+        log_debug(f"Searching arxiv for: {query}")
+        for result in self.client.results(
+            search=arxiv.Search(
+                query=query,
+                max_results=num_articles,
+                sort_by=arxiv.SortCriterion.Relevance,
+                sort_order=arxiv.SortOrder.Descending,
+            )
+        ):
+            try:
+                article = {
+                    "title": result.title,
+                    "id": result.get_short_id(),
+                    "entry_id": result.entry_id,
+                    "authors": [author.name for author in result.authors],
+                    "primary_category": result.primary_category,
+                    "categories": result.categories,
+                    "published": result.published.isoformat() if result.published else None,
+                    "pdf_url": result.pdf_url,
+                    "links": [link.href for link in result.links],
+                    "summary": result.summary,
+                    "comment": result.comment,
+                }
+                articles.append(article)
+            except Exception as e:
+                logger.error(f"Error processing article: {e}")
+        return json.dumps(articles, indent=4)
+
+    def read_arxiv_papers(self, id_list: List[str], pages_to_read: Optional[int] = None) -> str:
+        """Use this function to read a list of arxiv papers and return the content.
+
+        Args:
+            id_list (list, str): The list of `id` of the papers to add to the knowledge base.
+                    Should be of the format: ["2103.03404v1", "2103.03404v2"]
+            pages_to_read (int, optional): The number of pages to read from the paper.
+                    None means read all pages. Defaults to None.
+        Returns:
+            str: JSON of the papers.
+        """
+
+        download_dir = self.download_dir
+        download_dir.mkdir(parents=True, exist_ok=True)
+
+        articles = []
+        log_debug(f"Searching arxiv for: {id_list}")
+        for result in self.client.results(search=arxiv.Search(id_list=id_list)):
+            try:
+                article: Dict[str, Any] = {
+                    "title": result.title,
+                    "id": result.get_short_id(),
+                    "entry_id": result.entry_id,
+                    "authors": [author.name for author in result.authors],
+                    "primary_category": result.primary_category,
+                    "categories": result.categories,
+                    "published": result.published.isoformat() if result.published else None,
+                    "pdf_url": result.pdf_url,
+                    "links": [link.href for link in result.links],
+                    "summary": result.summary,
+                    "comment": result.comment,
+                }
+                if result.pdf_url:
+                    log_debug(f"Downloading: {result.pdf_url}")
+                    pdf_path = result.download_pdf(dirpath=str(download_dir))
+                    log_debug(f"To: {pdf_path}")
+                    pdf_reader = PdfReader(pdf_path)
+                    article["content"] = []
+                    for page_number, page in enumerate(pdf_reader.pages, start=1):
+                        if pages_to_read and page_number > pages_to_read:
+                            break
+                        content = {
+                            "page": page_number,
+                            "text": page.extract_text(),
+                        }
+                        article["content"].append(content)
+                articles.append(article)
+            except Exception as e:
+                logger.error(f"Error processing article: {e}")
+        return json.dumps(articles, indent=4)

agno/tools/aws_lambda.py

@@ -0,0 +1,53 @@
+from typing import Any, List
+
+from agno.tools import Toolkit
+
+try:
+    import boto3
+except ImportError:
+    raise ImportError("boto3 is required for AWSLambdaTool. Please install it using `pip install boto3`.")
+
+
+class AWSLambdaTools(Toolkit):
+    def __init__(
+        self,
+        region_name: str = "us-east-1",
+        enable_list_functions: bool = True,
+        enable_invoke_function: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.client = boto3.client("lambda", region_name=region_name)
+
+        tools: List[Any] = []
+        if all or enable_list_functions:
+            tools.append(self.list_functions)
+        if all or enable_invoke_function:
+            tools.append(self.invoke_function)
+
+        super().__init__(name="aws-lambda", tools=tools, **kwargs)
+
+    def list_functions(self) -> str:
+        """
+        List all AWS Lambda functions in the configured AWS account.
+        """
+        try:
+            response = self.client.list_functions()
+            functions = [func["FunctionName"] for func in response["Functions"]]
+            return f"Available Lambda functions: {', '.join(functions)}"
+        except Exception as e:
+            return f"Error listing functions: {str(e)}"
+
+    def invoke_function(self, function_name: str, payload: str = "{}") -> str:
+        """
+        Invoke a specific AWS Lambda function with an optional JSON payload.
+
+        Args:
+            function_name (str): The name of the Lambda function to invoke.
+            payload (str): The JSON payload to send to the function. Defaults to "{}".
+        """
+        try:
+            response = self.client.invoke(FunctionName=function_name, Payload=payload)
+            return f"Function invoked successfully. Status code: {response['StatusCode']}, Payload: {response['Payload'].read().decode('utf-8')}"
+        except Exception as e:
+            return f"Error invoking function: {str(e)}"

agno/tools/aws_ses.py

@@ -0,0 +1,66 @@
+from typing import Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+try:
+    import boto3
+except ImportError:
+    raise ImportError("boto3 is required for AWSSESTool. Please install it using `pip install boto3`.")
+
+
+class AWSSESTool(Toolkit):
+    def __init__(
+        self,
+        sender_email: Optional[str] = None,
+        sender_name: Optional[str] = None,
+        region_name: str = "us-east-1",
+        enable_send_email: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools = []
+        if all or enable_send_email:
+            tools.append(self.send_email)
+        super().__init__(name="aws_ses_tool", tools=tools, **kwargs)
+        self.client = boto3.client("ses", region_name=region_name)
+        self.sender_email = sender_email
+        self.sender_name = sender_name
+
+    def send_email(self, subject: str, body: str, receiver_email: str) -> str:
+        """
+        Use this tool to send an email using AWS SES.
+
+        Args: subject: The subject of the email
+                body: The body of the email
+                receiver_email: The email address of the receiver
+        """
+        if not self.client:
+            raise Exception("AWS SES client not initialized. Please check the configuration.")
+        if not subject:
+            return "Email subject cannot be empty."
+        if not body:
+            return "Email body cannot be empty."
+        try:
+            response = self.client.send_email(
+                Source=f"{self.sender_name} <{self.sender_email}>",
+                Destination={
+                    "ToAddresses": [receiver_email],
+                },
+                Message={
+                    "Body": {
+                        "Text": {
+                            "Charset": "UTF-8",
+                            "Data": body,
+                        },
+                    },
+                    "Subject": {
+                        "Charset": "UTF-8",
+                        "Data": subject,
+                    },
+                },
+            )
+            log_debug(f"Email sent with message ID: {response['MessageId']}")
+            return "Email sent successfully!"
+        except Exception as e:
+            raise Exception(f"Failed to send email: {e}")

agno/tools/baidusearch.py

@@ -0,0 +1,89 @@
+import json
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+try:
+    from baidusearch.baidusearch import search  # type: ignore
+except ImportError:
+    raise ImportError("`baidusearch` not installed. Please install using `pip install baidusearch`")
+
+try:
+    from pycountry import pycountry
+except ImportError:
+    raise ImportError("`pycountry` not installed. Please install using `pip install pycountry`")
+
+
+class BaiduSearchTools(Toolkit):
+    """
+    BaiduSearch is a toolkit for searching Baidu easily.
+
+    Args:
+        fixed_max_results (Optional[int]): A fixed number of maximum results.
+        fixed_language (Optional[str]): A fixed language for the search results.
+        headers (Optional[Any]): Headers to be used in the search request.
+        proxy (Optional[str]): Proxy to be used in the search request.
+        debug (Optional[bool]): Enable debug output.
+    """
+
+    def __init__(
+        self,
+        fixed_max_results: Optional[int] = None,
+        fixed_language: Optional[str] = None,
+        headers: Optional[Any] = None,
+        proxy: Optional[str] = None,
+        timeout: Optional[int] = 10,
+        debug: Optional[bool] = False,
+        enable_baidu_search: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.fixed_max_results = fixed_max_results
+        self.fixed_language = fixed_language
+        self.headers = headers
+        self.proxy = proxy
+        self.timeout = timeout
+        self.debug = debug
+
+        tools = []
+        if all or enable_baidu_search:
+            tools.append(self.baidu_search)
+
+        super().__init__(name="baidusearch", tools=tools, **kwargs)
+
+    def baidu_search(self, query: str, max_results: int = 5, language: str = "zh") -> str:
+        """Execute Baidu search and return results
+
+        Args:
+            query (str): Search keyword
+            max_results (int, optional): Maximum number of results to return, default 5
+            language (str, optional): Search language, default Chinese
+
+        Returns:
+            str: A JSON formatted string containing the search results.
+        """
+        max_results = self.fixed_max_results or max_results
+        language = self.fixed_language or language
+
+        if len(language) != 2:
+            try:
+                language = pycountry.languages.lookup(language).alpha_2
+            except LookupError:
+                language = "zh"
+
+        log_debug(f"Searching Baidu [{language}] for: {query}")
+
+        results = search(keyword=query, num_results=max_results)
+
+        res: List[Dict[str, str]] = []
+        for idx, item in enumerate(results, 1):
+            res.append(
+                {
+                    "title": item.get("title", ""),
+                    "url": item.get("url", ""),
+                    "abstract": item.get("abstract", ""),
+                    "rank": str(idx),
+                }
+            )
+        return json.dumps(res, indent=2)

agno/tools/bitbucket.py

@@ -0,0 +1,292 @@
+import base64
+import json
+from os import getenv
+from typing import Any, Dict, Optional, Union
+
+import requests
+
+from agno.tools import Toolkit
+from agno.utils.log import logger
+
+
+class BitbucketTools(Toolkit):
+    def __init__(
+        self,
+        server_url: str = "api.bitbucket.org",
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        token: Optional[str] = None,
+        workspace: Optional[str] = None,
+        repo_slug: Optional[str] = None,
+        api_version: str = "2.0",
+        **kwargs,
+    ):
+        self.username = username or getenv("BITBUCKET_USERNAME")
+        self.password = password or getenv("BITBUCKET_PASSWORD")
+        self.token = token or getenv("BITBUCKET_TOKEN")
+        self.auth_password = self.token or self.password
+        self.server_url = server_url or "api.bitbucket.org"
+        self.api_version = api_version or "2.0"
+        self.base_url = (
+            f"https://{self.server_url}/{api_version}"
+            if not self.server_url.startswith(("http://", "https://"))
+            else f"{self.server_url}/{api_version}"
+        )
+        self.workspace = workspace
+        self.repo_slug = repo_slug
+
+        if not (self.username and self.auth_password):
+            raise ValueError("Username and password or token are required")
+
+        if not self.workspace:
+            raise ValueError("Workspace is required")
+        if not self.repo_slug:
+            raise ValueError("Repo slug is required")
+
+        self.headers = {"Accept": "application/json", "Authorization": f"Basic {self._generate_access_token()}"}
+
+        super().__init__(
+            name="bitbucket",
+            tools=[
+                self.list_repositories,
+                self.get_repository_details,
+                self.create_repository,
+                self.list_repository_commits,
+                self.list_all_pull_requests,
+                self.get_pull_request_details,
+                self.get_pull_request_changes,
+                self.list_issues,
+            ],
+            **kwargs,
+        )
+
+    def _generate_access_token(self) -> str:
+        auth_str = f"{self.username}:{self.auth_password}"
+        auth_bytes = auth_str.encode("ascii")
+        auth_base64 = base64.b64encode(auth_bytes).decode("ascii")
+        return auth_base64
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+    ) -> Union[str, Dict[str, Any]]:
+        url = f"{self.base_url}{endpoint}"
+        response = requests.request(method, url, headers=self.headers, json=data, params=params)
+        response.raise_for_status()
+        encoding_type = response.headers.get("Content-Type", "application/json")
+        if encoding_type.startswith("application/json"):
+            return response.json() if response.text else {}
+        elif encoding_type == "text/plain":
+            return response.text
+
+        logger.warning(f"Unsupported content type: {encoding_type}")
+        return {}
+
+    def list_repositories(self, count: int = 10) -> str:
+        """
+        Get all repositories in the workspace.
+        Args:
+            count (int, optional): The number of repositories to retrieve
+
+        Returns:
+            str: A JSON string containing repository list.
+        """
+        try:
+            # Limit count to maximum of 50
+            count = min(count, 50)
+
+            # Use count directly as pagelen for simplicity, max out at 50 per our limit
+            pagelen = min(count, 50)
+            params = {"page": 1, "pagelen": pagelen}
+
+            repo = self._make_request("GET", f"/repositories/{self.workspace}", params=params)
+
+            return json.dumps(repo, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving repository list for workspace {self.workspace}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_repository_details(self) -> str:
+        """
+        Retrieves repository information.
+        API Docs: https://developer.atlassian.com/cloud/bitbucket/rest/api-group-repositories/#api-repositories-workspace-repo-slug-get
+
+        Returns:
+            str: A JSON string containing repository information.
+        """
+        try:
+            repo = self._make_request("GET", f"/repositories/{self.workspace}/{self.repo_slug}")
+            return json.dumps(repo, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving repository information for {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def create_repository(
+        self,
+        name: str,
+        project: Optional[str] = None,
+        is_private: bool = False,
+        description: Optional[str] = None,
+        language: Optional[str] = None,
+        has_issues: bool = False,
+        has_wiki: bool = False,
+    ) -> str:
+        """
+        Creates a new repository in Bitbucket for the given workspace.
+
+        Args:
+            name (str): The name of the new repository.
+            project (str, optional): The key of the project to create the repository in.
+            is_private (bool, optional): Whether the repository is private.
+            description (str, optional): A short description of the repository.
+            language (str, optional): The primary language of the repository
+            has_issues (bool, optional): Whether the repository has issues enabled.
+            has_wiki (bool, optional): Whether the repository has a wiki enabled.
+
+        Returns:
+            str: A JSON string containing repository information.
+        """
+        try:
+            payload: Dict[str, Any] = {
+                "name": name,
+                "scm": "git",
+                "is_private": is_private,
+                "description": description,
+                "language": language,
+                "has_issues": has_issues,
+                "has_wiki": has_wiki,
+            }
+            if project:
+                payload["project"] = {"key": project}
+            repo = self._make_request("POST", f"/repositories/{self.workspace}/{self.repo_slug}", data=payload)
+            return json.dumps(repo, indent=2)
+        except Exception as e:
+            logger.error(f"Error creating repository {self.repo_slug} for {self.workspace}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def list_repository_commits(self, count: int = 10) -> str:
+        """
+        Retrieves all commits in a repository.
+
+        Args:
+            count (int, optional): The number of commits to retrieve. Defaults to 10. Maximum 50.
+
+        Returns:
+            str: A JSON string containing all commits.
+        """
+        try:
+            count = min(count, 50)
+            params = {"pagelen": count}
+
+            commits = self._make_request(
+                "GET", f"/repositories/{self.workspace}/{self.repo_slug}/commits", params=params
+            )
+
+            if isinstance(commits, dict) and commits.get("next"):
+                collected_commits = commits.get("values", [])
+
+                while len(collected_commits) < count and isinstance(commits, dict) and commits.get("next"):
+                    next_url = commits["next"]  # type: ignore
+                    query_param = next_url.split("?")[1] if "?" in next_url else ""
+                    commits = self._make_request(
+                        "GET", f"/repositories/{self.workspace}/{self.repo_slug}/commits?{query_param}"
+                    )
+                    if isinstance(commits, dict):
+                        collected_commits.extend(commits.get("values", []))
+
+                if isinstance(commits, dict):
+                    commits["values"] = collected_commits[:count]
+
+            return json.dumps(commits, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving commits for {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def list_all_pull_requests(self, state: str = "OPEN") -> str:
+        """
+        Retrieves all pull requests for a repository.
+
+        Args:
+            state (str, optional): The state of the pull requests to retrieve.
+
+        Returns:
+            str: A JSON string containing all pull requests.
+        """
+        try:
+            if state not in ["OPEN", "MERGED", "DECLINED", "SUPERSEDED"]:
+                logger.debug(f"Invalid pull request state: {state}. Defaulting to OPEN")
+                state = "OPEN"
+
+            params = {"state": state}
+
+            pull_requests = self._make_request(
+                "GET", f"/repositories/{self.workspace}/{self.repo_slug}/pullrequests", params=params
+            )
+
+            return json.dumps(pull_requests, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving pull requests for {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_pull_request_details(self, pull_request_id: int) -> str:
+        """
+        Retrieves a pull request for a repository.
+        Args:
+            pull_request_id (int): The ID of the pull request to retrieve.
+
+        Returns:
+            str: A JSON string containing the pull request.
+        """
+        try:
+            pull_request = self._make_request(
+                "GET", f"/repositories/{self.workspace}/{self.repo_slug}/pullrequests/{pull_request_id}"
+            )
+            return json.dumps(pull_request, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving pull requests for {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def get_pull_request_changes(self, pull_request_id: int) -> str:
+        """
+        Retrieves changes for a pull request in a repository.
+
+        Args:
+            pull_request_id (int): The ID of the pull request to retrieve.
+
+        Returns:
+            str: A markdown string containing the pull request diff.
+        """
+        try:
+            diff = self._make_request(
+                "GET", f"/repositories/{self.workspace}/{self.repo_slug}/pullrequests/{pull_request_id}/diff"
+            )
+            if isinstance(diff, dict):
+                return json.dumps(diff, indent=2)
+            return diff
+        except Exception as e:
+            logger.error(f"Error retrieving changes for pull request {pull_request_id} in {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})
+
+    def list_issues(self, count: int = 10) -> str:
+        """
+        Retrieves all issues for a repository.
+
+        Args:
+            count (int, optional): The number of issues to retrieve. Defaults to 10. Maximum 50.
+
+        Returns:
+            str: A JSON string containing all issues.
+        """
+        try:
+            count = min(count, 50)
+            params = {"pagelen": count}
+
+            issues = self._make_request("GET", f"/repositories/{self.workspace}/{self.repo_slug}/issues", params=params)
+
+            return json.dumps(issues, indent=2)
+        except Exception as e:
+            logger.error(f"Error retrieving issues for {self.repo_slug}: {str(e)}")
+            return json.dumps({"error": str(e)})