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

agno/tools/financial_datasets.py

@@ -0,0 +1,288 @@
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from agno.tools import Toolkit
+from agno.utils.log import log_error
+
+
+class FinancialDatasetsTools(Toolkit):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        **kwargs,
+    ):
+        """Initialize the Financial Datasets Tools.
+
+        Args:
+            api_key: API key for Financial Datasets API (optional, can be set via environment variable)
+        """
+
+        self.api_key: Optional[str] = api_key or getenv("FINANCIAL_DATASETS_API_KEY")
+        if not self.api_key:
+            log_error(
+                "FINANCIAL_DATASETS_API_KEY not set. Please set the FINANCIAL_DATASETS_API_KEY environment variable."
+            )
+
+        self.base_url = "https://api.financialdatasets.ai"
+
+        tools: List[Any] = [
+            # Financial statements
+            self.get_income_statements,
+            self.get_balance_sheets,
+            self.get_cash_flow_statements,
+            self.get_segmented_financials,
+            self.get_financial_metrics,
+            # Company info
+            self.get_company_info,
+            # Market data
+            self.get_stock_prices,
+            self.get_earnings,
+            # Ownership data
+            self.get_insider_trades,
+            self.get_institutional_ownership,
+            # News
+            self.get_news,
+            # SEC filings
+            self.get_sec_filings,
+            # Crypto
+            self.get_crypto_prices,
+            # Search
+            self.search_tickers,
+        ]
+
+        super().__init__(name="financial_datasets_tools", tools=tools, **kwargs)
+
+    def _make_request(self, endpoint: str, params: Dict[str, Any]) -> str:
+        """
+        Makes a request to the Financial Datasets API.
+
+        Args:
+            endpoint: API endpoint to call
+            params: Query parameters for the request
+
+        Returns:
+            JSON response from the API
+        """
+        if not self.api_key:
+            log_error("No API key provided. Cannot make request.")
+            return "API key not set"
+
+        headers = {"X-API-KEY": self.api_key}
+        url = f"{self.base_url}/{endpoint}"
+
+        try:
+            response = requests.get(url, headers=headers, params=params)
+            response.raise_for_status()
+            return response.text
+        except requests.exceptions.RequestException as e:
+            log_error(f"Error making request to {url}: {str(e)}")
+            return f"Error making request to {url}: {str(e)}"
+
+    # Financial Statements
+    def get_income_statements(self, ticker: str, period: str = "annual", limit: int = 10) -> str:
+        """
+        Get income statements for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            period: 'annual', 'quarterly', or 'ttm'
+            limit: Number of statements to return
+
+        Returns:
+            Dictionary containing income statements
+        """
+        params = {"ticker": ticker, "period": period, "limit": limit}
+        return self._make_request("financials/income-statements", params)
+
+    def get_balance_sheets(self, ticker: str, period: str = "annual", limit: int = 10) -> str:
+        """
+        Get balance sheets for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            period: 'annual', 'quarterly', or 'ttm'
+            limit: Number of statements to return
+
+        Returns:
+            Dictionary containing balance sheets
+        """
+        params = {"ticker": ticker, "period": period, "limit": limit}
+        return self._make_request("financials/balance-sheets", params)
+
+    def get_cash_flow_statements(self, ticker: str, period: str = "annual", limit: int = 10) -> str:
+        """
+        Get cash flow statements for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            period: 'annual', 'quarterly', or 'ttm'
+            limit: Number of statements to return
+
+        Returns:
+            Dictionary containing cash flow statements
+        """
+        params = {"ticker": ticker, "period": period, "limit": limit}
+        return self._make_request("financials/cash-flow-statements", params)
+
+    # Other API endpoints from the documentation
+
+    def get_company_info(self, ticker: str) -> str:
+        """
+        Get company information for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+
+        Returns:
+            Dictionary containing company information
+        """
+        params = {"ticker": ticker}
+        return self._make_request("company", params)
+
+    def get_crypto_prices(self, symbol: str, interval: str = "1d", limit: int = 100) -> str:
+        """
+        Get cryptocurrency prices.
+
+        Args:
+            symbol: Cryptocurrency symbol (e.g., 'BTC')
+            interval: Price interval (e.g., '1d', '1h')
+            limit: Number of price points to return
+
+        Returns:
+            Dictionary containing crypto prices
+        """
+        params = {"symbol": symbol, "interval": interval, "limit": limit}
+        return self._make_request("crypto/prices", params)
+
+    def get_earnings(self, ticker: str, limit: int = 10) -> str:
+        """
+        Get earnings data for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            limit: Number of earnings reports to return
+
+        Returns:
+            Dictionary containing earnings data
+        """
+        params = {"ticker": ticker, "limit": limit}
+        return self._make_request("earnings", params)
+
+    def get_financial_metrics(self, ticker: str) -> str:
+        """
+        Get financial metrics for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+
+        Returns:
+            Dictionary containing financial metrics
+        """
+        params = {"ticker": ticker}
+        return self._make_request("financials/metrics", params)
+
+    def get_insider_trades(self, ticker: str, limit: int = 50) -> str:
+        """
+        Get insider trades for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            limit: Number of trades to return
+
+        Returns:
+            Dictionary containing insider trades
+        """
+        params = {"ticker": ticker, "limit": limit}
+        return self._make_request("insider-trades", params)
+
+    def get_institutional_ownership(self, ticker: str) -> str:
+        """
+        Get institutional ownership data for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+
+        Returns:
+            Dictionary containing institutional ownership data
+        """
+        params = {"ticker": ticker}
+        return self._make_request("institutional-ownership", params)
+
+    def get_news(self, ticker: Optional[str] = None, limit: int = 50) -> str:
+        """
+        Get market news, optionally filtered by ticker.
+
+        Args:
+            ticker: Stock ticker symbol (optional)
+            limit: Number of news items to return
+
+        Returns:
+            Dictionary containing news items
+        """
+        params: Dict[str, Any] = {"limit": limit}
+        if ticker:
+            params["ticker"] = ticker
+        return self._make_request("news", params)
+
+    def get_stock_prices(self, ticker: str, interval: str = "1d", limit: int = 100) -> str:
+        """
+        Get stock prices for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            interval: Price interval (e.g., '1d', '1h')
+            limit: Number of price points to return
+
+        Returns:
+            Dictionary containing stock prices
+        """
+        params = {"ticker": ticker, "interval": interval, "limit": limit}
+        return self._make_request("prices", params)
+
+    def search_tickers(self, query: str, limit: int = 10) -> str:
+        """
+        Search for tickers based on a query.
+
+        Args:
+            query: Search query
+            limit: Maximum number of results to return
+
+        Returns:
+            Dictionary containing search results
+        """
+        params = {"query": query, "limit": limit}
+        return self._make_request("search", params)
+
+    def get_sec_filings(self, ticker: str, form_type: Optional[str] = None, limit: int = 50) -> str:
+        """
+        Get SEC filings for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            form_type: Type of SEC form (e.g., '10-K', '10-Q')
+            limit: Number of filings to return
+
+        Returns:
+            Dictionary containing SEC filings
+        """
+        params: Dict[str, Any] = {"ticker": ticker, "limit": limit}
+        if form_type:
+            params["form_type"] = form_type
+        return self._make_request("sec-filings", params)
+
+    def get_segmented_financials(self, ticker: str, period: str = "annual", limit: int = 10) -> str:
+        """
+        Get segmented financials for a ticker.
+
+        Args:
+            ticker: Stock ticker symbol
+            period: 'annual' or 'quarterly'
+            limit: Number of reports to return
+
+        Returns:
+            Dictionary containing segmented financials
+        """
+        params = {"ticker": ticker, "period": period, "limit": limit}
+        return self._make_request("financials/segmented", params)

agno/tools/firecrawl.py

@@ -1,57 +1,94 @@
 import json
+from os import getenv
 from typing import Any, Dict, List, Optional
 
 from agno.tools import Toolkit
+from agno.utils.log import log_error
 
 try:
-    from firecrawl import FirecrawlApp
+    from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
+    from firecrawl.types import ScrapeOptions
 except ImportError:
     raise ImportError("`firecrawl-py` not installed. Please install using `pip install firecrawl-py`")
 
 
+class CustomJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles non-serializable types by converting them to strings."""
+
+    def default(self, obj):
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)
+
+
 class FirecrawlTools(Toolkit):
+    """
+    Firecrawl is a tool for scraping and crawling websites.
+
+    Args:
+        api_key (Optional[str]): The API key to use for the Firecrawl app.
+        enable_scrape (bool): Enable website scraping functionality. Default is True.
+        enable_crawl (bool): Enable website crawling functionality. Default is False.
+        enable_mapping (bool): Enable website mapping functionality. Default is False.
+        enable_search (bool): Enable web search functionality. Default is False.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        formats (Optional[List[str]]): The formats to use for the Firecrawl app.
+        limit (int): The maximum number of pages to crawl.
+        poll_interval (int): Polling interval for crawl operations.
+        search_params (Optional[Dict[str, Any]]): Parameters for search operations.
+        api_url (Optional[str]): The API URL to use for the Firecrawl app.
+    """
+
     def __init__(
         self,
         api_key: Optional[str] = None,
+        enable_scrape: bool = True,
+        enable_crawl: bool = False,
+        enable_mapping: bool = False,
+        enable_search: bool = False,
+        all: bool = False,
         formats: Optional[List[str]] = None,
         limit: int = 10,
-        scrape: bool = True,
-        crawl: bool = False,
+        poll_interval: int = 30,
+        search_params: Optional[Dict[str, Any]] = None,
+        api_url: Optional[str] = "https://api.firecrawl.dev",
+        **kwargs,
     ):
-        super().__init__(name="firecrawl_tools")
+        self.api_key: Optional[str] = api_key or getenv("FIRECRAWL_API_KEY")
+        if not self.api_key:
+            log_error("FIRECRAWL_API_KEY not set. Please set the FIRECRAWL_API_KEY environment variable.")
 
-        self.api_key: Optional[str] = api_key
         self.formats: Optional[List[str]] = formats
         self.limit: int = limit
-        self.app: FirecrawlApp = FirecrawlApp(api_key=self.api_key)
-
-        # Start with scrape by default. But if crawl is set, then set scrape to False.
-        if crawl:
-            scrape = False
-        elif not scrape:
-            crawl = True
-
-        self.register(self.scrape_website)
-        self.register(self.crawl_website)
+        self.poll_interval: int = poll_interval
+        self.app: FirecrawlApp = FirecrawlApp(api_key=self.api_key, api_url=api_url)
+        self.search_params = search_params
+
+        tools: List[Any] = []
+        if all or enable_scrape:
+            tools.append(self.scrape_website)
+        if all or enable_crawl:
+            tools.append(self.crawl_website)
+        if all or enable_mapping:
+            tools.append(self.map_website)
+        if all or enable_search:
+            tools.append(self.search_web)
+
+        super().__init__(name="firecrawl_tools", tools=tools, **kwargs)
 
     def scrape_website(self, url: str) -> str:
-        """Use this function to Scrapes a website using Firecrawl.
+        """Use this function to scrape a website using Firecrawl.
 
         Args:
             url (str): The URL to scrape.
-
-        Returns:
-            The results of the scraping.
         """
-        if url is None:
-            return "No URL provided"
-
         params = {}
         if self.formats:
             params["formats"] = self.formats
 
-        scrape_result = self.app.scrape_url(url, params=params)
-        return json.dumps(scrape_result)
+        scrape_result = self.app.scrape(url, **params)
+        return json.dumps(scrape_result.model_dump(), cls=CustomJSONEncoder)
 
     def crawl_website(self, url: str, limit: Optional[int] = None) -> str:
         """Use this function to Crawls a website using Firecrawl.
@@ -63,14 +100,52 @@ class FirecrawlTools(Toolkit):
         Returns:
             The results of the crawling.
         """
-        if url is None:
-            return "No URL provided"
-
         params: Dict[str, Any] = {}
-        if self.limit or limit:
-            params["limit"] = self.limit or limit
-            if self.formats:
-                params["scrapeOptions"] = {"formats": self.formats}
+        if self.limit is not None:
+            params["limit"] = self.limit
+        elif limit is not None:
+            params["limit"] = limit
+        if self.formats:
+            params["scrape_options"] = ScrapeOptions(formats=self.formats)  # type: ignore
+
+        params["poll_interval"] = self.poll_interval
 
-        crawl_result = self.app.crawl_url(url, params=params, poll_interval=30)
-        return json.dumps(crawl_result)
+        crawl_result = self.app.crawl(url, **params)
+        return json.dumps(crawl_result.model_dump(), cls=CustomJSONEncoder)
+
+    def map_website(self, url: str) -> str:
+        """Use this function to Map a website using Firecrawl.
+
+        Args:
+            url (str): The URL to map.
+
+        """
+        map_result = self.app.map(url)
+        return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
+
+    def search_web(self, query: str, limit: Optional[int] = None):
+        """Use this function to search for the web using Firecrawl.
+
+        Args:
+            query (str): The query to search for.
+            limit (int): The maximum number of results to return.
+        """
+        params: Dict[str, Any] = {}
+        if self.limit is not None:
+            params["limit"] = self.limit
+        elif limit is not None:
+            params["limit"] = limit
+        if self.formats:
+            params["scrape_options"] = ScrapeOptions(formats=self.formats)  # type: ignore
+        if self.search_params:
+            params.update(self.search_params)
+
+        search_result = self.app.search(query, **params)
+
+        if hasattr(search_result, "success"):
+            if search_result.success:
+                return json.dumps(search_result.data, cls=CustomJSONEncoder)
+            else:
+                return f"Error searching with the Firecrawl tool: {search_result.error}"
+        else:
+            return json.dumps(search_result.model_dump(), cls=CustomJSONEncoder)