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

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)})

agno/tools/brandfetch.py

@@ -0,0 +1,213 @@
+"""
+Going to contribute this to agno toolkits.
+"""
+
+from os import getenv
+from typing import Any, Optional
+
+try:
+    import httpx
+except ImportError:
+    raise ImportError("`httpx` not installed.")
+
+from agno.tools import Toolkit
+
+
+class BrandfetchTools(Toolkit):
+    """
+    Brandfetch API toolkit for retrieving brand data and searching brands.
+
+    Supports both Brand API (retrieve comprehensive brand data) and
+    Brand Search API (find and search brands by name).
+
+    -- Brand API
+
+    api_key: str - your Brandfetch API key
+
+    -- Brand Search API
+
+    client_id: str - your Brandfetch Client ID
+
+    all: bool - if True, will use all tools
+    enable_search_by_identifier: bool - if True, will use search by identifier
+    enable_search_by_brand: bool - if True, will use search by brand
+    enable_asearch_by_identifier: bool - if True, will use async search by identifier
+    enable_asearch_by_brand: bool - if True, will use async search by brand
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        client_id: Optional[str] = None,
+        base_url: str = "https://api.brandfetch.io/v2",
+        timeout: Optional[float] = 20.0,
+        enable_search_by_identifier: bool = True,
+        enable_search_by_brand: bool = False,
+        all: bool = False,
+        async_tools: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("BRANDFETCH_API_KEY")
+        self.client_id = client_id or getenv("BRANDFETCH_CLIENT_ID")
+        self.base_url = base_url
+        self.timeout = httpx.Timeout(timeout)
+        self.search_url = f"{self.base_url}/search"
+        self.brand_url = f"{self.base_url}/brands"
+
+        tools: list[Any] = []
+        # Backward-compat mapping: prefer new enable_* flags, but honor legacy toggles
+        if async_tools:
+            if all or enable_search_by_identifier:
+                tools.append(self.asearch_by_identifier)
+            if all or enable_search_by_brand:
+                tools.append(self.asearch_by_brand)
+        else:
+            if all or enable_search_by_identifier:
+                tools.append(self.search_by_identifier)
+            if all or enable_search_by_brand:
+                tools.append(self.search_by_brand)
+        name = kwargs.pop("name", "brandfetch_tools")
+        super().__init__(name=name, tools=tools, **kwargs)
+
+    async def asearch_by_identifier(self, identifier: str) -> dict[str, Any]:
+        """
+        Search for brand data by identifier (domain, brand id, isin, stock ticker).
+
+        Args:
+            identifier: Options are you can use: Domain (nike.com), Brand ID (id_0dwKPKT), ISIN (US6541061031), Stock Ticker (NKE)
+        Returns:
+            Dict containing brand data including logos, colors, fonts, and other brand assets
+
+        Raises:
+            ValueError: If no API key is provided
+        """
+        if not self.api_key:
+            raise ValueError("API key is required for brand search by identifier")
+
+        url = f"{self.brand_url}/{identifier}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, headers=headers)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"Brand not found for identifier: {identifier}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid API key"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    def search_by_identifier(self, identifier: str) -> dict[str, Any]:
+        """
+        Search for brand data by identifier (domain, brand id, isin, stock ticker).
+
+        Args:
+            identifier: Options are you can use: Domain (nike.com), Brand ID (id_0dwKPKT), ISIN (US6541061031), Stock Ticker (NKE)
+
+        Returns:
+            Dict containing brand data including logos, colors, fonts, and other brand assets
+
+        Raises:
+            ValueError: If no API key is provided
+        """
+        if not self.api_key:
+            raise ValueError("API key is required for brand search by identifier")
+
+        url = f"{self.brand_url}/{identifier}"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                response = client.get(url, headers=headers)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"Brand not found for identifier: {identifier}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid API key"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    async def asearch_by_brand(self, name: str) -> dict[str, Any]:
+        """
+        Search for brands by name using the Brand Search API - can give you the right brand id to use for the brand api.
+
+        Args:
+            name: Brand name to search for (e.g., 'Google', 'Apple')
+
+        Returns:
+            Dict containing search results with brand matches
+
+        Raises:
+            ValueError: If no client ID is provided
+        """
+        if not self.client_id:
+            raise ValueError("Client ID is required for brand search by name")
+
+        url = f"{self.search_url}/{name}"
+        params = {"c": self.client_id}
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"No brands found for name: {name}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid client ID"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}
+
+    def search_by_brand(self, name: str) -> dict[str, Any]:
+        """
+        Search for brands by name using the Brand Search API - can give you the right brand id to use for the brand api.
+
+        Args:
+            name: Brand name to search for (e.g., 'Google', 'Apple')
+
+        Returns:
+            Dict containing search results with brand matches
+
+        Raises:
+            ValueError: If no client ID is provided
+        """
+        if not self.client_id:
+            raise ValueError("Client ID is required for brand search by name")
+
+        url = f"{self.search_url}/{name}"
+        params = {"c": self.client_id}
+
+        try:
+            with httpx.Client(timeout=self.timeout) as client:
+                response = client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                return {"error": f"No brands found for name: {name}"}
+            elif e.response.status_code == 401:
+                return {"error": "Invalid client ID"}
+            elif e.response.status_code == 429:
+                return {"error": "Rate limit exceeded"}
+            else:
+                return {"error": f"API error: {e.response.status_code}"}
+        except httpx.RequestError as e:
+            return {"error": f"Request failed: {str(e)}"}

agno/tools/bravesearch.py

@@ -0,0 +1,106 @@
+import json
+from os import getenv
+from typing import Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_info
+
+try:
+    from brave import Brave
+except ImportError:
+    raise ImportError("`brave-search` not installed. Please install using `pip install brave-search`")
+
+
+class BraveSearchTools(Toolkit):
+    """
+    BraveSearch is a toolkit for searching Brave easily.
+
+    Args:
+        api_key (str, optional): Brave API key. If not provided, will use BRAVE_API_KEY environment variable.
+        fixed_max_results (Optional[int]): A fixed number of maximum results.
+        fixed_language (Optional[str]): A fixed language for the search results.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        fixed_max_results: Optional[int] = None,
+        fixed_language: Optional[str] = None,
+        enable_brave_search: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("BRAVE_API_KEY")
+        if not self.api_key:
+            raise ValueError("BRAVE_API_KEY is required. Please set the BRAVE_API_KEY environment variable.")
+
+        self.fixed_max_results = fixed_max_results
+        self.fixed_language = fixed_language
+
+        self.brave_client = Brave(api_key=self.api_key)
+
+        tools = []
+        if all or enable_brave_search:
+            tools.append(self.brave_search)
+
+        super().__init__(
+            name="brave_search",
+            tools=tools,
+            **kwargs,
+        )
+
+    def brave_search(
+        self,
+        query: str,
+        max_results: int = 5,
+        country: str = "US",
+        search_lang: str = "en",
+    ) -> str:
+        """
+        Search Brave for the specified query and return the results.
+
+        Args:
+            query (str): The query to search for.
+            max_results (int, optional): The maximum number of results to return. Default is 5.
+            country (str, optional): The country code for search results. Default is "US".
+            search_lang (str, optional): The language of the search results. Default is "en".
+        Returns:
+            str: A JSON formatted string containing the search results.
+        """
+        final_max_results = self.fixed_max_results if self.fixed_max_results is not None else max_results
+        final_search_lang = self.fixed_language if self.fixed_language is not None else search_lang
+
+        if not query:
+            return json.dumps({"error": "Please provide a query to search for"})
+
+        log_info(f"Searching Brave for: {query}")
+
+        search_params = {
+            "q": query,
+            "count": final_max_results,
+            "country": country,
+            "search_lang": final_search_lang,
+            "result_filter": "web",
+        }
+
+        search_results = self.brave_client.search(**search_params)
+
+        filtered_results = {
+            "web_results": [],
+            "query": query,
+            "total_results": 0,
+        }
+
+        if hasattr(search_results, "web") and search_results.web:
+            web_results = []
+            for result in search_results.web.results:
+                web_result = {
+                    "title": result.title,
+                    "url": str(result.url),
+                    "description": result.description,
+                }
+                web_results.append(web_result)
+            filtered_results["web_results"] = web_results
+            filtered_results["total_results"] = len(web_results)
+
+        return json.dumps(filtered_results, indent=2)