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

agno/tools/__init__.py

@@ -1,3 +1,10 @@
 from agno.tools.decorator import tool
 from agno.tools.function import Function, FunctionCall
 from agno.tools.toolkit import Toolkit
+
+__all__ = [
+    "tool",
+    "Function",
+    "FunctionCall",
+    "Toolkit",
+]

agno/tools/agentql.py

@@ -0,0 +1,120 @@
+from os import getenv
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_info
+
+try:
+    import agentql
+    from playwright.sync_api import sync_playwright
+except ImportError:
+    raise ImportError("`agentql` not installed. Please install using `pip install agentql`")
+
+
+class AgentQLTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        enable_scrape_website: bool = True,
+        enable_custom_scrape_website: bool = False,
+        all: bool = False,
+        agentql_query: str = "",
+        **kwargs,
+    ):
+        self.api_key = api_key or getenv("AGENTQL_API_KEY")
+        if not self.api_key:
+            raise ValueError("AGENTQL_API_KEY not set. Please set the AGENTQL_API_KEY environment variable.")
+
+        self.agentql_query = agentql_query
+
+        tools: List[Any] = []
+        if all or enable_scrape_website:
+            tools.append(self.scrape_website)
+        if all or enable_custom_scrape_website or (agentql_query and not all and not enable_custom_scrape_website):
+            if agentql_query:
+                log_info("Custom AgentQL query provided. Registering custom scrape function.")
+                tools.append(self.custom_scrape_website)
+
+        super().__init__(name="agentql_tools", tools=tools, **kwargs)
+
+    def scrape_website(self, url: str) -> str:
+        """
+        Scrape all text content from a website using AgentQL.
+
+        Args:
+            url (str): The URL of the website to scrape
+
+        Returns:
+            str: Extracted text content or error message
+        """
+        if not url:
+            return "No URL provided"
+
+        TEXT_SEARCH_QUERY = """
+        {
+            text_content[]
+        }
+        """
+
+        try:
+            with sync_playwright() as playwright, playwright.chromium.launch(headless=False) as browser:
+                page = agentql.wrap(browser.new_page())
+                page.goto(url)
+
+                try:
+                    # Get response from AgentQL query
+                    response = page.query_data(TEXT_SEARCH_QUERY)
+
+                    # Extract text based on response format
+                    if isinstance(response, dict) and "text_content" in response:
+                        text_items = [item for item in response["text_content"] if item and item.strip()]
+
+                        deduplicated = list(set(text_items))
+                        return " ".join(deduplicated)
+
+                except Exception as e:
+                    return f"Error extracting text: {e}"
+        except Exception as e:
+            return f"Error launching browser: {e}"
+
+        return "No text content found"
+
+    def custom_scrape_website(self, url: str) -> str:
+        """
+        Scrape a website using a custom AgentQL query.
+
+        Args:
+            url (str): The URL of the website to scrape
+
+        Returns:
+            str: Extracted text content or error message
+        """
+        if not url:
+            return "No URL provided"
+
+        if self.agentql_query == "":
+            return "Custom AgentQL query not provided. Please provide a custom AgentQL query."
+
+        try:
+            with sync_playwright() as playwright, playwright.chromium.launch(headless=False) as browser:
+                page = agentql.wrap(browser.new_page())
+                page.goto(url)
+
+                try:
+                    # Get response from AgentQL query
+                    response = page.query_data(self.agentql_query)
+
+                    # Extract text based on response format
+                    if isinstance(response, dict):
+                        items = [item for item in response]
+                        text_items = [text_item for text_item in items if text_item]
+
+                        deduplicated = list(set(text_items))
+                        return " ".join(deduplicated)
+
+                except Exception as e:
+                    return f"Error extracting text: {e}"
+        except Exception as e:
+            return f"Error launching browser: {e}"
+
+        return "No text content found"

agno/tools/airflow.py

@@ -1,16 +1,22 @@
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, List, Optional, Union
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_info, logger
 
 
 class AirflowTools(Toolkit):
-    def __init__(self, dags_dir: Optional[Union[Path, str]] = None, save_dag: bool = True, read_dag: bool = True):
+    def __init__(
+        self,
+        dags_dir: Optional[Union[Path, str]] = None,
+        enable_save_dag_file: bool = True,
+        enable_read_dag_file: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
         """
         quick start to work with airflow : https://airflow.apache.org/docs/apache-airflow/stable/start.html
         """
-        super().__init__(name="AirflowTools")
 
         _dags_dir: Optional[Path] = None
         if dags_dir is not None:
@@ -19,10 +25,14 @@ class AirflowTools(Toolkit):
             else:
                 _dags_dir = dags_dir
         self.dags_dir: Path = _dags_dir or Path.cwd()
-        if save_dag:
-            self.register(self.save_dag_file, sanitize_arguments=False)
-        if read_dag:
-            self.register(self.read_dag_file)
+
+        tools: List[Any] = []
+        if all or enable_save_dag_file:
+            tools.append(self.save_dag_file)
+        if all or enable_read_dag_file:
+            tools.append(self.read_dag_file)
+
+        super().__init__(name="AirflowTools", tools=tools, **kwargs)
 
     def save_dag_file(self, contents: str, dag_file: str) -> str:
         """Saves python code for an Airflow DAG to a file called `dag_file` and returns the file path if successful.
@@ -33,12 +43,12 @@ class AirflowTools(Toolkit):
         """
         try:
             file_path = self.dags_dir.joinpath(dag_file)
-            logger.debug(f"Saving contents to {file_path}")
+            log_debug(f"Saving contents to {file_path}")
             if not file_path.parent.exists():
                 file_path.parent.mkdir(parents=True, exist_ok=True)
             file_path.write_text(contents)
-            logger.info(f"Saved: {file_path}")
-            return str(str(file_path))
+            log_info(f"Saved: {file_path}")
+            return str(file_path)
         except Exception as e:
             logger.error(f"Error saving to file: {e}")
             return f"Error saving to file: {e}"
@@ -50,7 +60,7 @@ class AirflowTools(Toolkit):
         :return: The contents of the file if successful, otherwise returns an error message.
         """
         try:
-            logger.info(f"Reading file: {dag_file}")
+            log_info(f"Reading file: {dag_file}")
             file_path = self.dags_dir.joinpath(dag_file)
             contents = file_path.read_text()
             return str(contents)

agno/tools/api.py

@@ -0,0 +1,122 @@
+import json
+from typing import Any, Dict, List, Literal, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+try:
+    import requests
+    from requests.auth import HTTPBasicAuth
+except ImportError:
+    raise ImportError("`requests` not installed. Please install using `pip install requests`")
+
+
+class CustomApiTools(Toolkit):
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        api_key: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+        verify_ssl: bool = True,
+        timeout: int = 30,
+        enable_make_request: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.base_url = base_url
+        self.username = username
+        self.password = password
+        self.api_key = api_key
+        self.default_headers = headers or {}
+        self.verify_ssl = verify_ssl
+        self.timeout = timeout
+
+        tools: List[Any] = []
+        if all or enable_make_request:
+            tools.append(self.make_request)
+
+        super().__init__(name="api_tools", tools=tools, **kwargs)
+
+    def _get_auth(self) -> Optional[HTTPBasicAuth]:
+        """Get authentication object if credentials are provided."""
+        if self.username and self.password:
+            return HTTPBasicAuth(self.username, self.password)
+        return None
+
+    def _get_headers(self, additional_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """Combine default headers with additional headers."""
+        headers = self.default_headers.copy()
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if additional_headers:
+            headers.update(additional_headers)
+        return headers
+
+    def make_request(
+        self,
+        endpoint: str,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = "GET",
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Make an HTTP request to the API.
+
+        Args:
+            method (str): HTTP method (GET, POST, PUT, DELETE, PATCH)
+            endpoint (str): API endpoint (will be combined with base_url if set)
+            params (Optional[Dict[str, Any]]): Query parameters
+            data (Optional[Dict[str, Any]]): Form data to send
+            headers (Optional[Dict[str, str]]): Additional headers
+            json_data (Optional[Dict[str, Any]]): JSON data to send
+
+        Returns:
+            str: JSON string containing response data or error message
+        """
+        try:
+            if self.base_url:
+                url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+            else:
+                url = endpoint
+            log_debug(f"Making {method} request to {url}")
+
+            response = requests.request(
+                method=method,
+                url=url,
+                params=params,
+                data=data,
+                json=json_data,
+                headers=self._get_headers(headers),
+                auth=self._get_auth(),
+                verify=self.verify_ssl,
+                timeout=self.timeout,
+            )
+
+            try:
+                response_data = response.json()
+            except json.JSONDecodeError:
+                response_data = {"text": response.text}
+
+            result = {
+                "status_code": response.status_code,
+                "headers": dict(response.headers),
+                "data": response_data,
+            }
+
+            if not response.ok:
+                logger.error(f"Request failed with status {response.status_code}: {response.text}")
+                result["error"] = "Request failed"
+
+            return json.dumps(result, indent=2)
+
+        except requests.exceptions.RequestException as e:
+            error_message = f"Request failed: {str(e)}"
+            logger.error(error_message)
+            return json.dumps({"error": error_message}, indent=2)
+        except Exception as e:
+            error_message = f"Unexpected error: {str(e)}"
+            logger.error(error_message)
+            return json.dumps({"error": error_message}, indent=2)