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

agno/tools/duckdb.py

@@ -1,7 +1,8 @@
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_info, logger
 
 try:
     import duckdb
@@ -17,32 +18,31 @@ class DuckDbTools(Toolkit):
         init_commands: Optional[List] = None,
         read_only: bool = False,
         config: Optional[dict] = None,
-        run_queries: bool = True,
-        inspect_queries: bool = False,
-        create_tables: bool = True,
-        summarize_tables: bool = True,
-        export_tables: bool = False,
+        **kwargs,
     ):
-        super().__init__(name="duckdb_tools")
-
         self.db_path: Optional[str] = db_path
         self.read_only: bool = read_only
         self.config: Optional[dict] = config
         self._connection: Optional[duckdb.DuckDBPyConnection] = connection
         self.init_commands: Optional[List] = init_commands
 
-        self.register(self.show_tables)
-        self.register(self.describe_table)
-        if inspect_queries:
-            self.register(self.inspect_query)
-        if run_queries:
-            self.register(self.run_query)
-        if create_tables:
-            self.register(self.create_table_from_path)
-        if summarize_tables:
-            self.register(self.summarize_table)
-        if export_tables:
-            self.register(self.export_table_to_path)
+        tools: List[Any] = [
+            self.show_tables,
+            self.describe_table,
+            self.inspect_query,
+            self.run_query,
+            self.create_table_from_path,
+            self.summarize_table,
+            self.export_table_to_path,
+            self.load_local_path_to_table,
+            self.load_local_csv_to_table,
+            self.load_s3_path_to_table,
+            self.load_s3_csv_to_table,
+            self.create_fts_index,
+            self.full_text_search,
+        ]
+
+        super().__init__(name="duckdb_tools", tools=tools, **kwargs)
 
     @property
     def connection(self) -> duckdb.DuckDBPyConnection:
@@ -79,7 +79,7 @@ class DuckDbTools(Toolkit):
         if show_tables:
             stmt = "SHOW TABLES;"
             tables = self.run_query(stmt)
-            logger.debug(f"Tables: {tables}")
+            log_debug(f"Tables: {tables}")
             return tables
         return "No tables to show"
 
@@ -92,7 +92,7 @@ class DuckDbTools(Toolkit):
         stmt = f"DESCRIBE {table};"
         table_description = self.run_query(stmt)
 
-        logger.debug(f"Table description: {table_description}")
+        log_debug(f"Table description: {table_description}")
         return f"{table}\n{table_description}"
 
     def inspect_query(self, query: str) -> str:
@@ -104,7 +104,7 @@ class DuckDbTools(Toolkit):
         stmt = f"explain {query};"
         explain_plan = self.run_query(stmt)
 
-        logger.debug(f"Explain plan: {explain_plan}")
+        log_debug(f"Explain plan: {explain_plan}")
         return explain_plan
 
     def run_query(self, query: str) -> str:
@@ -121,7 +121,7 @@ class DuckDbTools(Toolkit):
         formatted_sql = formatted_sql.split(";")[0]
 
         try:
-            logger.info(f"Running: {formatted_sql}")
+            log_info(f"Running: {formatted_sql}")
 
             query_result = self.connection.sql(formatted_sql)
             result_output = "No output"
@@ -140,7 +140,7 @@ class DuckDbTools(Toolkit):
                 except AttributeError:
                     result_output = str(query_result)
 
-            logger.debug(f"Query result: {result_output}")
+            log_debug(f"Query result: {result_output}")
             return result_output
         except duckdb.ProgrammingError as e:
             return str(e)
@@ -159,7 +159,7 @@ class DuckDbTools(Toolkit):
         """
         table_summary = self.run_query(f"SUMMARIZE {table};")
 
-        logger.debug(f"Table description: {table_summary}")
+        log_debug(f"Table description: {table_summary}")
         return table_summary
 
     def get_table_name_from_path(self, path: str) -> str:
@@ -168,12 +168,10 @@ class DuckDbTools(Toolkit):
         :param path: Path to get the table name from
         :return: Table name
         """
-        import os
-
         # Get the file name from the path
-        file_name = path.split("/")[-1]
+        path_obj = Path(path)
         # Get the file name without extension from the path
-        table, extension = os.path.splitext(file_name)
+        table = path_obj.stem
         # If the table isn't a valid SQL identifier, we'll need to use something else
         table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
@@ -191,14 +189,19 @@ class DuckDbTools(Toolkit):
         if table is None:
             table = self.get_table_name_from_path(path)
 
-        logger.debug(f"Creating table {table} from {path}")
+        log_debug(f"Creating table {table} from {path}")
         create_statement = "CREATE TABLE IF NOT EXISTS"
         if replace:
             create_statement = "CREATE OR REPLACE TABLE"
 
-        create_statement += f" '{table}' AS SELECT * FROM '{path}';"
+        # Check if the file is a CSV
+        if path.lower().endswith(".csv"):
+            create_statement += f" {table} AS SELECT * FROM read_csv('{path}', ignore_errors=false, auto_detect=true);"
+        else:
+            create_statement += f" {table} AS SELECT * FROM '{path}';"
+
         self.run_query(create_statement)
-        logger.debug(f"Created table {table} from {path}")
+        log_debug(f"Created table {table} from {path}")
         return table
 
     def export_table_to_path(self, table: str, format: Optional[str] = "PARQUET", path: Optional[str] = None) -> str:
@@ -215,14 +218,14 @@ class DuckDbTools(Toolkit):
         if format is None:
             format = "PARQUET"
 
-        logger.debug(f"Exporting Table {table} as {format.upper()} to path {path}")
+        log_debug(f"Exporting Table {table} as {format.upper()} to path {path}")
         if path is None:
             path = f"{table}.{format}"
         else:
             path = f"{path}/{table}.{format}"
         export_statement = f"COPY (SELECT * FROM {table}) TO '{path}' (FORMAT {format.upper()});"
         result = self.run_query(export_statement)
-        logger.debug(f"Exported {table} to {path}/{table}")
+        log_debug(f"Exported {table} to {path}/{table}")
         return result
 
     def load_local_path_to_table(self, path: str, table: Optional[str] = None) -> Tuple[str, str]:
@@ -232,22 +235,20 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
-        logger.debug(f"Loading {path} into duckdb")
+        log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
-        create_statement = f"CREATE OR REPLACE TABLE '{table}' AS SELECT * FROM '{path}';"
+        create_statement = f"CREATE OR REPLACE TABLE {table} AS SELECT * FROM '{path}';"
         self.run_query(create_statement)
 
-        logger.debug(f"Loaded {path} into duckdb as {table}")
+        log_debug(f"Loaded {path} into duckdb as {table}")
         return table, create_statement
 
     def load_local_csv_to_table(
@@ -260,28 +261,26 @@ class DuckDbTools(Toolkit):
         :param delimiter: Optional delimiter to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
-        logger.debug(f"Loading {path} into duckdb")
+        log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
-        select_statement = f"SELECT * FROM read_csv('{path}'"
+        select_statement = f"SELECT * FROM read_csv('{path}', ignore_errors=false, auto_detect=true"
         if delimiter is not None:
             select_statement += f", delim='{delimiter}')"
         else:
             select_statement += ")"
 
-        create_statement = f"CREATE OR REPLACE TABLE '{table}' AS {select_statement};"
+        create_statement = f"CREATE OR REPLACE TABLE {table} AS {select_statement};"
         self.run_query(create_statement)
 
-        logger.debug(f"Loaded CSV {path} into duckdb as {table}")
+        log_debug(f"Loaded CSV {path} into duckdb as {table}")
         return table, create_statement
 
     def load_s3_path_to_table(self, path: str, table: Optional[str] = None) -> Tuple[str, str]:
@@ -291,22 +290,20 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
-        logger.debug(f"Loading {path} into duckdb")
+        log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
-        create_statement = f"CREATE OR REPLACE TABLE '{table}' AS SELECT * FROM '{path}';"
+        create_statement = f"CREATE OR REPLACE TABLE {table} AS SELECT * FROM '{path}';"
         self.run_query(create_statement)
 
-        logger.debug(f"Loaded {path} into duckdb as {table}")
+        log_debug(f"Loaded {path} into duckdb as {table}")
         return table, create_statement
 
     def load_s3_csv_to_table(
@@ -318,28 +315,26 @@ class DuckDbTools(Toolkit):
         :param table: Optional table name to use
         :return: Table name, SQL statement used to load the file
         """
-        import os
-
-        logger.debug(f"Loading {path} into duckdb")
+        log_debug(f"Loading {path} into duckdb")
 
         if table is None:
-            # Get the file name from the s3 path
-            file_name = path.split("/")[-1]
-            # Get the file name without extension from the s3 path
-            table, extension = os.path.splitext(file_name)
+            # Get the file name from the path
+            path_obj = Path(path)
+            # Get the file name without extension from the path
+            table = path_obj.stem
             # If the table isn't a valid SQL identifier, we'll need to use something else
             table = table.replace("-", "_").replace(".", "_").replace(" ", "_").replace("/", "_")
 
-        select_statement = f"SELECT * FROM read_csv('{path}'"
+        select_statement = f"SELECT * FROM read_csv('{path}', ignore_errors=false, auto_detect=true"
         if delimiter is not None:
             select_statement += f", delim='{delimiter}')"
         else:
             select_statement += ")"
 
-        create_statement = f"CREATE OR REPLACE TABLE '{table}' AS {select_statement};"
+        create_statement = f"CREATE OR REPLACE TABLE {table} AS {select_statement};"
         self.run_query(create_statement)
 
-        logger.debug(f"Loaded CSV {path} into duckdb as {table}")
+        log_debug(f"Loaded CSV {path} into duckdb as {table}")
         return table, create_statement
 
     def create_fts_index(self, table: str, unique_key: str, input_values: list[str]) -> str:
@@ -350,16 +345,16 @@ class DuckDbTools(Toolkit):
         :param input_values: Values to index
         :return: None
         """
-        logger.debug(f"Creating FTS index on {table} for {input_values}")
+        log_debug(f"Creating FTS index on {table} for {input_values}")
         self.run_query("INSTALL fts;")
-        logger.debug("Installed FTS extension")
+        log_debug("Installed FTS extension")
         self.run_query("LOAD fts;")
-        logger.debug("Loaded FTS extension")
+        log_debug("Loaded FTS extension")
 
         create_fts_index_statement = f"PRAGMA create_fts_index('{table}', '{unique_key}', '{input_values}');"
-        logger.debug(f"Running {create_fts_index_statement}")
+        log_debug(f"Running {create_fts_index_statement}")
         result = self.run_query(create_fts_index_statement)
-        logger.debug(f"Created FTS index on {table} for {input_values}")
+        log_debug(f"Created FTS index on {table} for {input_values}")
 
         return result
 
@@ -371,14 +366,14 @@ class DuckDbTools(Toolkit):
         :param search_text: Text to search
         :return: None
         """
-        logger.debug(f"Running full_text_search for {search_text} in {table}")
+        log_debug(f"Running full_text_search for {search_text} in {table}")
         search_text_statement = f"""SELECT fts_main_corpus.match_bm25({unique_key}, '{search_text}') AS score,*
                                         FROM {table}
                                         WHERE score IS NOT NULL
                                         ORDER BY score;"""
 
-        logger.debug(f"Running {search_text_statement}")
+        log_debug(f"Running {search_text_statement}")
         result = self.run_query(search_text_statement)
-        logger.debug(f"Search results for {search_text} in {table}")
+        log_debug(f"Search results for {search_text} in {table}")
 
         return result

agno/tools/duckduckgo.py

@@ -1,88 +1,91 @@
 import json
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
-from agno.utils.log import logger
+from agno.utils.log import log_debug
 
 try:
-    from duckduckgo_search import DDGS
+    from ddgs import DDGS
 except ImportError:
-    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install duckduckgo-search`")
+    raise ImportError("`ddgs` not installed. Please install using `pip install ddgs`")
 
 
 class DuckDuckGoTools(Toolkit):
     """
-    DuckDuckGo is a toolkit for searching DuckDuckGo easily.
+    DuckDuckGo is a toolkit for searching using DuckDuckGo easily.
+    It uses the meta-search library DDGS, so it also has access to other backends.
     Args:
-        search (bool): Enable DuckDuckGo search function.
-        news (bool): Enable DuckDuckGo news function.
+        enable_search (bool): Enable DDGS search function.
+        enable_news (bool): Enable DDGS news function.
+        modifier (Optional[str]): A modifier to be used in the search request.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
-        headers (Optional[Any]): Headers to be used in the search request.
         proxy (Optional[str]): Proxy to be used in the search request.
-        proxies (Optional[Any]): A list of proxies to be used in the search request.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
+        backend (Optional[str]): The backend to be used in the search request.
+
     """
 
     def __init__(
         self,
-        search: bool = True,
-        news: bool = True,
+        enable_search: bool = True,
+        enable_news: bool = True,
+        all: bool = False,
+        backend: str = "duckduckgo",
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
-        headers: Optional[Any] = None,
         proxy: Optional[str] = None,
-        proxies: Optional[Any] = None,
         timeout: Optional[int] = 10,
         verify_ssl: bool = True,
+        **kwargs,
     ):
-        super().__init__(name="duckduckgo")
-
-        self.headers: Optional[Any] = headers
         self.proxy: Optional[str] = proxy
-        self.proxies: Optional[Any] = proxies
         self.timeout: Optional[int] = timeout
         self.fixed_max_results: Optional[int] = fixed_max_results
         self.modifier: Optional[str] = modifier
         self.verify_ssl: bool = verify_ssl
+        self.backend: str = backend
 
-        if search:
-            self.register(self.duckduckgo_search)
-        if news:
-            self.register(self.duckduckgo_news)
+        tools: List[Any] = []
+        if all or enable_search:
+            tools.append(self.duckduckgo_search)
+        if all or enable_news:
+            tools.append(self.duckduckgo_news)
+
+        super().__init__(name="duckduckgo", tools=tools, **kwargs)
 
     def duckduckgo_search(self, query: str, max_results: int = 5) -> str:
-        """Use this function to search DuckDuckGo for a query.
+        """Use this function to search DDGS for a query.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The result from DuckDuckGo.
+            The result from DDGS.
         """
-        logger.debug(f"Searching DDG for: {query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
-        if not self.modifier:
-            return json.dumps(ddgs.text(keywords=query, max_results=(self.fixed_max_results or max_results)), indent=2)
-        return json.dumps(
-            ddgs.text(keywords=self.modifier + " " + query, max_results=(self.fixed_max_results or max_results)),
-            indent=2,
-        )
+        actual_max_results = self.fixed_max_results or max_results
+        search_query = f"{self.modifier} {query}" if self.modifier else query
+
+        log_debug(f"Searching DDG for: {search_query} using backend: {self.backend}")
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.text(query=search_query, max_results=actual_max_results, backend=self.backend)
+
+        return json.dumps(results, indent=2)
 
     def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
-        """Use this function to get the latest news from DuckDuckGo.
+        """Use this function to get the latest news from DDGS.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The latest news from DuckDuckGo.
+            The latest news from DDGS.
         """
-        logger.debug(f"Searching DDG news for: {query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
-        return json.dumps(ddgs.news(keywords=query, max_results=(self.fixed_max_results or max_results)), indent=2)
+        actual_max_results = self.fixed_max_results or max_results
+
+        log_debug(f"Searching DDG news for: {query} using backend: {self.backend}")
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.news(query=query, max_results=actual_max_results, backend=self.backend)
+
+        return json.dumps(results, indent=2)