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

agno/tools/apify.py

@@ -1,121 +1,314 @@
+import json
+import string
 from os import getenv
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import requests
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_info, logger
 
 try:
     from apify_client import ApifyClient
 except ImportError:
-    raise ImportError("`apify_client` not installed. Please install using `pip install apify-client`")
+    raise ImportError("`apify-client` not installed. Please install using `pip install apify-client`")
 
 
 class ApifyTools(Toolkit):
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        website_content_crawler: bool = True,
-        web_scraper: bool = False,
-    ):
-        super().__init__(name="apify_tools")
-
-        self.api_key = api_key or getenv("MY_APIFY_TOKEN")
-        if not self.api_key:
-            logger.error("No Apify API key provided")
-
-        if website_content_crawler:
-            self.register(self.website_content_crawler)
-        if web_scraper:
-            self.register(self.web_scrapper)
-
-    def website_content_crawler(self, urls: List[str], timeout: Optional[int] = 60) -> str:
+    def __init__(self, actors: Optional[Union[str, List[str]]] = None, apify_api_token: Optional[str] = None):
+        """Initialize ApifyTools with specific Actors.
+
+        Args:
+            actors (Optional[Union[str, List[str]]]): Single Actor ID as string or list of Actor IDs to register as individual tools
+            apify_api_token (Optional[str]): Apify API token (defaults to APIFY_API_TOKEN env variable)
         """
-        Crawls a website using Apify's website-content-crawler actor.
+        # Get API token from args or environment
+        self.apify_api_token = apify_api_token or getenv("APIFY_API_TOKEN")
+        if not self.apify_api_token:
+            raise ValueError("APIFY_API_TOKEN environment variable or apify_api_token parameter must be set")
+
+        self.client = create_apify_client(self.apify_api_token)
+
+        tools: List[Any] = []
+        if actors:
+            actor_list = [actors] if isinstance(actors, str) else actors
+            for actor_id in actor_list:
+                tools.append(actor_id)
+
+        super().__init__(name="ApifyTools", tools=[], auto_register=False)
+
+        for actor_id in tools:
+            self.register_actor(actor_id)
 
-        :param urls: The URLs to crawl.
-        :param timeout: The timeout for the crawling.
+    def register_actor(self, actor_id: str) -> None:
+        """Register an Apify Actor as a function in the toolkit.
 
-        :return: The results of the crawling.
+        Args:
+            actor_id (str): ID of the Apify Actor to register (e.g., 'apify/web-scraper')
         """
-        if self.api_key is None:
-            return "No API key provided"
+        try:
+            # Get actor metadata
+            build = get_actor_latest_build(self.client, actor_id)
+            tool_name = actor_id_to_tool_name(actor_id)
+
+            # Get actor description
+            actor_description = build.get("actorDefinition", {}).get("description", "")
+            if len(actor_description) > MAX_DESCRIPTION_LEN:
+                actor_description = actor_description[:MAX_DESCRIPTION_LEN] + "...(TRUNCATED, TOO LONG)"
+
+            # Get input schema
+            actor_input = build.get("actorDefinition", {}).get("input")
+            if not actor_input:
+                raise ValueError(f"Input schema not found in the Actor build for Actor: {actor_id}")
+
+            properties, required = prune_actor_input_schema(actor_input)
+
+            # Create a wrapper function that calls the Actor
+            def actor_function(**kwargs) -> str:
+                """Actor function wrapper."""
+                try:
+                    # Params are nested under 'kwargs' key
+                    if len(kwargs) == 1 and "kwargs" in kwargs:
+                        kwargs = kwargs["kwargs"]
+
+                    log_info(f"Running Apify Actor {actor_id} with parameters: {kwargs}")
+
+                    # Run the Actor directly with the client
+                    details = self.client.actor(actor_id=actor_id).call(run_input=kwargs)
+                    if details is None:
+                        error_msg = (
+                            f"Actor: {actor_id} was not started properly and details about the run were not returned"
+                        )
+                        raise ValueError(error_msg)
+
+                    run_id = details.get("id")
+                    if run_id is None:
+                        error_msg = f"Run ID not found in the run details for Actor: {actor_id}"
+                        raise ValueError(error_msg)
+
+                    # Get the results
+                    run = self.client.run(run_id=run_id)
+                    results = run.dataset().list_items(clean=True).items
+
+                    return json.dumps(results)
+
+                except Exception as e:
+                    error_msg = f"Error running Apify Actor {actor_id}: {str(e)}"
+                    logger.error(error_msg)
+                    return json.dumps([{"error": error_msg}])
+
+            docstring = f"{actor_description}\n\nArgs:\n"
+
+            for param_name, param_info in properties.items():
+                param_type = param_info.get("type", "any")
+                param_desc = param_info.get("description", "No description available")
+                required_marker = "(required)" if param_name in required else "(optional)"
+                docstring += f"    {param_name} ({param_type}): {required_marker} {param_desc}\n"
+
+            docstring += """
+Returns:
+    str: JSON string containing the Actor's output dataset
+"""
+
+            # Update function metadata
+            actor_function.__name__ = tool_name
+            actor_function.__doc__ = docstring
+
+            # Register the function with the toolkit
+            self.register(actor_function)
+            # Fix params schema
+            self.functions[tool_name].parameters = props_to_json_schema(properties, required)
+            log_info(f"Registered Apify Actor '{actor_id}' as function '{tool_name}'")
+
+        except Exception as e:
+            logger.error(f"Failed to register Apify Actor '{actor_id}': {str(e)}")
+
+
+# Constants
+MAX_DESCRIPTION_LEN = 350
+REQUESTS_TIMEOUT_SECS = 300
+APIFY_API_ENDPOINT_GET_DEFAULT_BUILD = "https://api.apify.com/v2/acts/{actor_id}/builds/default"
+
+
+# Utility functions
+def props_to_json_schema(input_dict, required_fields=None):
+    schema: Dict[str, Any] = {"type": "object", "properties": {}, "required": required_fields or []}
+
+    def infer_array_item_type(prop):
+        type_map = {
+            "string": "string",
+            "int": "number",
+            "float": "number",
+            "dict": "object",
+            "list": "array",
+            "bool": "boolean",
+            "none": "null",
+        }
+        if prop.get("items", {}).get("type"):
+            return prop["items"]["type"]
+        if "prefill" in prop and prop["prefill"] and len(prop["prefill"]) > 0:
+            return type_map.get(type(prop["prefill"][0]).__name__.lower(), "string")
+        if "default" in prop and prop["default"] and len(prop["default"]) > 0:
+            return type_map.get(type(prop["default"][0]).__name__.lower(), "string")
+        return "string"  # Fallback for arrays like searchStringsArray
+
+    for key, value in input_dict.items():
+        prop_schema: Dict[str, Any] = {}
+        prop_type = value.get("type")
+
+        if "enum" in value:
+            prop_schema["enum"] = value["enum"]
+
+        if "default" in value:
+            prop_schema["default"] = value["default"]
+        elif "prefill" in value:
+            prop_schema["default"] = value["prefill"]
+
+        if "description" in value:
+            prop_schema["description"] = value["description"]
+
+        # Handle Apify special types first
+        if prop_type == "object" and value.get("editor") == "proxy":
+            prop_schema["type"] = "object"
+            prop_schema["properties"] = {
+                "useApifyProxy": {
+                    "title": "Use Apify Proxy",
+                    "type": "boolean",
+                    "description": "Whether to use Apify Proxy - ALWAYS SET TO TRUE.",
+                    "default": True,
+                    "examples": [True],
+                }
+            }
+            prop_schema["required"] = ["useApifyProxy"]
+            if "default" in value:
+                prop_schema["default"] = value["default"]
+
+        elif prop_type == "array" and value.get("editor") == "requestListSources":
+            prop_schema["type"] = "array"
+            prop_schema["items"] = {
+                "type": "object",
+                "title": "Request list source",
+                "description": "Request list source",
+                "properties": {
+                    "url": {"title": "URL", "type": "string", "description": "URL of the request list source"}
+                },
+            }
 
-        if urls is None:
-            return "No URLs provided"
+        elif prop_type == "array":
+            prop_schema["type"] = "array"
+            prop_schema["items"] = {
+                "type": infer_array_item_type(value),
+                "title": value.get("title", "Item"),
+                "description": "Item",
+            }
 
-        client = ApifyClient(self.api_key)
+        elif prop_type == "object":
+            prop_schema["type"] = "object"
+            if "default" in value:
+                prop_schema["default"] = value["default"]
+                prop_schema["properties"] = {}
+                for k, v in value.get("properties", value["default"]).items():
+                    prop_type = v["type"] if isinstance(v, dict) else type(v).__name__.lower()
+                    if prop_type == "bool":
+                        prop_type = "boolean"
+                    prop_schema["properties"][k] = {"type": prop_type}
 
-        logger.debug(f"Crawling URLs: {urls}")
+        else:
+            prop_schema["type"] = prop_type
 
-        formatted_urls = [{"url": url} for url in urls]
+        schema["properties"][key] = prop_schema
 
-        run_input = {"startUrls": formatted_urls}
+    return schema
 
-        run = client.actor("apify/website-content-crawler").call(run_input=run_input, timeout_secs=timeout)
 
-        results: str = ""
+def create_apify_client(token: str) -> ApifyClient:
+    """Create an Apify client instance with a custom user-agent.
 
-        for item in client.dataset(run["defaultDatasetId"]).iterate_items():
-            results += "Results for URL: " + item.get("url") + "\n"
-            results += item.get("text") + "\n"
+    Args:
+        token (str): API token
 
-        return results
+    Returns:
+        ApifyClient: Apify client instance
 
-    def web_scrapper(self, urls: List[str], timeout: Optional[int] = 60) -> str:
-        """
-        Scrapes a website using Apify's web-scraper actor.
+    Raises:
+        ValueError: If the API token is not provided
+    """
+    if not token:
+        raise ValueError("API token is required to create an Apify client.")
 
-        :param urls: The URLs to scrape.
-        :param timeout: The timeout for the scraping.
+    client = ApifyClient(token)
+    if http_client := getattr(client.http_client, "httpx_client", None):
+        http_client.headers["user-agent"] += "; Origin/agno"
+    return client
 
-        :return: The results of the scraping.
-        """
-        if self.api_key is None:
-            return "No API key provided"
 
-        if urls is None:
-            return "No URLs provided"
+def actor_id_to_tool_name(actor_id: str) -> str:
+    """Turn actor_id into a valid tool name.
 
-        client = ApifyClient(self.api_key)
+    Args:
+        actor_id (str): Actor ID from Apify store
 
-        logger.debug(f"Scrapping URLs: {urls}")
+    Returns:
+        str: A valid tool name
+    """
+    valid_chars = string.ascii_letters + string.digits + "_-"
+    return "apify_actor_" + "".join(char if char in valid_chars else "_" for char in actor_id)
 
-        formatted_urls = [{"url": url} for url in urls]
 
-        page_function_string = """
-            async function pageFunction(context) {
-                const $ = context.jQuery;
-                const pageTitle = $('title').first().text();
-                const h1 = $('h1').first().text();
-                const first_h2 = $('h2').first().text();
-                const random_text_from_the_page = $('p').first().text();
+def get_actor_latest_build(apify_client: ApifyClient, actor_id: str) -> Dict[str, Any]:
+    """Get the latest build of an Actor from the default build tag.
 
-                context.log.info(`URL: ${context.request.url}, TITLE: ${pageTitle}`);
+    Args:
+        apify_client (ApifyClient): An instance of the ApifyClient class
+        actor_id (str): Actor name from Apify store to run
 
-                return {
-                    url: context.request.url,
-                    pageTitle,
-                    h1,
-                    first_h2,
-                    random_text_from_the_page
-                };
-            }
-        """
+    Returns:
+        Dict[str, Any]: The latest build of the Actor
 
-        run_input = {
-            "pageFunction": page_function_string,
-            "startUrls": formatted_urls,
-        }
+    Raises:
+        ValueError: If the Actor is not found or the build data is not found
+        TypeError: If the build is not a dictionary
+    """
+    if not (actor := apify_client.actor(actor_id).get()):
+        raise ValueError(f"Actor {actor_id} not found.")
+
+    if not (actor_obj_id := actor.get("id")):
+        raise ValueError(f"Failed to get the Actor object ID for {actor_id}.")
+
+    url = APIFY_API_ENDPOINT_GET_DEFAULT_BUILD.format(actor_id=actor_obj_id)
+    response = requests.request("GET", url, timeout=REQUESTS_TIMEOUT_SECS)
+
+    build = response.json()
+    if not isinstance(build, dict):
+        raise TypeError(f"Failed to get the latest build of the Actor {actor_id}.")
+
+    if (data := build.get("data")) is None:
+        raise ValueError(f"Failed to get the latest build data of the Actor {actor_id}.")
+
+    return data
+
+
+def prune_actor_input_schema(input_schema: Dict[str, Any]) -> Tuple[Dict[str, Any], List[str]]:
+    """Get the input schema from the Actor build and trim descriptions.
 
-        run = client.actor("apify/web-scraper").call(run_input=run_input, timeout_secs=timeout)
+    Args:
+        input_schema (Dict[str, Any]): The input schema from the Actor build
 
-        results: str = ""
+    Returns:
+        Tuple[Dict[str, Any], List[str]]: A tuple containing the pruned properties and required fields
+    """
+    properties = input_schema.get("properties", {})
+    required = input_schema.get("required", [])
 
-        for item in client.dataset(run["defaultDatasetId"]).iterate_items():
-            results += "Results for URL: " + item.get("url") + "\n"
-            results += item.get("pageTitle") + "\n"
-            results += item.get("h1") + "\n"
-            results += item.get("first_h2") + "\n"
-            results += item.get("random_text_from_the_page") + "\n"
+    properties_out: Dict[str, Any] = {}
+    for item, meta in properties.items():
+        properties_out[item] = {}
+        if desc := meta.get("description"):
+            properties_out[item]["description"] = (
+                desc[:MAX_DESCRIPTION_LEN] + "..." if len(desc) > MAX_DESCRIPTION_LEN else desc
+            )
+        for key_name in ("type", "default", "prefill", "enum"):
+            if value := meta.get(key_name):
+                properties_out[item][key_name] = value
 
-        return results
+    return properties_out, required

agno/tools/{arxiv_toolkit.py → arxiv.py}

@@ -3,7 +3,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, logger
 
 try:
     import arxiv
@@ -17,16 +17,24 @@ except ImportError:
 
 
 class ArxivTools(Toolkit):
-    def __init__(self, search_arxiv: bool = True, read_arxiv_papers: bool = True, download_dir: Optional[Path] = None):
-        super().__init__(name="arxiv_tools")
-
+    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")
 
-        if search_arxiv:
-            self.register(self.search_arxiv_and_return_articles)
-        if read_arxiv_papers:
-            self.register(self.read_arxiv_papers)
+        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.
@@ -39,7 +47,7 @@ class ArxivTools(Toolkit):
         """
 
         articles = []
-        logger.info(f"Searching arxiv for: {query}")
+        log_debug(f"Searching arxiv for: {query}")
         for result in self.client.results(
             search=arxiv.Search(
                 query=query,
@@ -83,7 +91,7 @@ class ArxivTools(Toolkit):
         download_dir.mkdir(parents=True, exist_ok=True)
 
         articles = []
-        logger.info(f"Searching arxiv for: {id_list}")
+        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] = {
@@ -100,9 +108,9 @@ class ArxivTools(Toolkit):
                     "comment": result.comment,
                 }
                 if result.pdf_url:
-                    logger.info(f"Downloading: {result.pdf_url}")
+                    log_debug(f"Downloading: {result.pdf_url}")
                     pdf_path = result.download_pdf(dirpath=str(download_dir))
-                    logger.info(f"To: {pdf_path}")
+                    log_debug(f"To: {pdf_path}")
                     pdf_reader = PdfReader(pdf_path)
                     article["content"] = []
                     for page_number, page in enumerate(pdf_reader.pages, start=1):

agno/tools/aws_lambda.py

@@ -1,3 +1,5 @@
+from typing import Any, List
+
 from agno.tools import Toolkit
 
 try:
@@ -7,16 +9,28 @@ except ImportError:
 
 
 class AWSLambdaTools(Toolkit):
-    name: str = "AWSLambdaTool"
-    description: str = "A tool for interacting with AWS Lambda functions"
-
-    def __init__(self, region_name: str = "us-east-1"):
-        super().__init__()
+    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)
-        self.register(self.list_functions)
-        self.register(self.invoke_function)
+
+        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"]]
@@ -25,6 +39,13 @@ class AWSLambdaTools(Toolkit):
             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')}"

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

@@ -2,7 +2,7 @@ import json
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug
 
 try:
     from baidusearch.baidusearch import search  # type: ignore
@@ -35,15 +35,22 @@ class BaiduSearchTools(Toolkit):
         proxy: Optional[str] = None,
         timeout: Optional[int] = 10,
         debug: Optional[bool] = False,
+        enable_baidu_search: bool = True,
+        all: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="baidusearch")
         self.fixed_max_results = fixed_max_results
         self.fixed_language = fixed_language
         self.headers = headers
         self.proxy = proxy
         self.timeout = timeout
         self.debug = debug
-        self.register(self.baidu_search)
+
+        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
@@ -65,7 +72,7 @@ class BaiduSearchTools(Toolkit):
             except LookupError:
                 language = "zh"
 
-        logger.debug(f"Searching Baidu [{language}] for: {query}")
+        log_debug(f"Searching Baidu [{language}] for: {query}")
 
         results = search(keyword=query, num_results=max_results)