agno 2.2.13__py3-none-any.whl → 2.3.1__py3-none-any.whl

agno/knowledge/reader/s3_reader.py

@@ -10,7 +10,7 @@ from agno.knowledge.reader.base import Reader
 from agno.knowledge.reader.pdf_reader import PDFReader
 from agno.knowledge.reader.text_reader import TextReader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, log_error
 
 try:
     from agno.aws.resource.s3.object import S3Object  # type: ignore
@@ -51,7 +51,7 @@ class S3Reader(Reader):
 
     def read(self, name: Optional[str], s3_object: S3Object) -> List[Document]:
         try:
-            log_info(f"Reading S3 file: {s3_object.uri}")
+            log_debug(f"Reading S3 file: {s3_object.uri}")
 
             # Read PDF files
             if s3_object.uri.endswith(".pdf"):
@@ -80,7 +80,7 @@ class S3Reader(Reader):
                 return documents
 
         except Exception as e:
-            logger.error(f"Error reading: {s3_object.uri}: {e}")
+            log_error(f"Error reading: {s3_object.uri}: {e}")
 
         return []
 

agno/knowledge/reader/text_reader.py

@@ -8,7 +8,7 @@ from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyT
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_info, logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 
 class TextReader(Reader):
@@ -37,12 +37,12 @@ class TextReader(Reader):
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                log_info(f"Reading: {file}")
+                log_debug(f"Reading: {file}")
                 file_name = name or file.stem
                 file_contents = file.read_text(self.encoding or "utf-8")
             else:
                 file_name = name or file.name.split(".")[0]
-                log_info(f"Reading uploaded file: {file_name}")
+                log_debug(f"Reading uploaded file: {file_name}")
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -60,7 +60,7 @@ class TextReader(Reader):
                 return chunked_documents
             return documents
         except Exception as e:
-            logger.error(f"Error reading: {file}: {e}")
+            log_error(f"Error reading: {file}: {e}")
             return []
 
     async def async_read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
@@ -69,7 +69,7 @@ class TextReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
 
-                log_info(f"Reading asynchronously: {file}")
+                log_debug(f"Reading asynchronously: {file}")
                 file_name = name or file.stem
 
                 try:
@@ -78,10 +78,10 @@ class TextReader(Reader):
                     async with aiofiles.open(file, "r", encoding=self.encoding or "utf-8") as f:
                         file_contents = await f.read()
                 except ImportError:
-                    logger.warning("aiofiles not installed, using synchronous file I/O")
+                    log_warning("aiofiles not installed, using synchronous file I/O")
                     file_contents = file.read_text(self.encoding or "utf-8")
             else:
-                log_info(f"Reading uploaded file asynchronously: {file.name}")
+                log_debug(f"Reading uploaded file asynchronously: {file.name}")
                 file_name = name or file.name.split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
@@ -96,7 +96,7 @@ class TextReader(Reader):
                 return await self._async_chunk_document(document)
             return [document]
         except Exception as e:
-            logger.error(f"Error reading asynchronously: {file}: {e}")
+            log_error(f"Error reading asynchronously: {file}: {e}")
             return []
 
     async def _async_chunk_document(self, document: Document) -> List[Document]:

agno/knowledge/reader/web_search_reader.py

@@ -37,7 +37,7 @@ class WebSearchReader(Reader):
     user_agent: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 
     # Search engine configuration
-    search_engine: Literal["duckduckgo", "google"] = "duckduckgo"
+    search_engine: Literal["duckduckgo"] = "duckduckgo"
     search_delay: float = 3.0  # Delay between search requests
     max_search_retries: int = 2  # Retries for search operations
 
@@ -121,57 +121,10 @@ class WebSearchReader(Reader):
                     return []
         return []
 
-    def _perform_google_search(self, query: str) -> List[Dict[str, str]]:
-        """Perform web search using Google (requires googlesearch-python)"""
-        log_debug(f"Performing Google search for: {query}")
-
-        try:
-            from googlesearch import search
-        except ImportError:
-            logger.error("Google search requires 'googlesearch-python'. Install with: pip install googlesearch-python")
-            return []
-
-        for attempt in range(self.max_search_retries):
-            try:
-                self._respect_rate_limits()
-
-                results = []
-                # Use the basic search function without unsupported parameters
-                # The googlesearch-python library's search function only accepts basic parameters
-                search_results = search(query)
-
-                # Convert iterator to list and limit results
-                result_list = list(search_results)[: self.max_results]
-
-                for result in result_list:
-                    # The search function returns URLs as strings
-                    results.append(
-                        {
-                            "title": "",  # Google search doesn't provide titles directly
-                            "url": result,
-                            "description": "",  # Google search doesn't provide descriptions directly
-                        }
-                    )
-
-                log_debug(f"Found {len(results)} Google search results")
-                return results
-
-            except Exception as e:
-                logger.warning(f"Google search attempt {attempt + 1} failed: {e}")
-                if attempt < self.max_search_retries - 1:
-                    time.sleep(self.search_delay)
-                else:
-                    logger.error(f"All Google search attempts failed: {e}")
-                    return []
-
-        return []
-
     def _perform_web_search(self, query: str) -> List[Dict[str, str]]:
         """Perform web search using the configured search engine"""
         if self.search_engine == "duckduckgo":
             return self._perform_duckduckgo_search(query)
-        elif self.search_engine == "google":
-            return self._perform_google_search(query)
         else:
             logger.error(f"Unsupported search engine: {self.search_engine}")
             return []

agno/knowledge/reader/website_reader.py

@@ -12,7 +12,7 @@ from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyT
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
 from agno.knowledge.types import ContentType
-from agno.utils.log import log_debug, logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 try:
     from bs4 import BeautifulSoup, Tag  # noqa: F401
@@ -229,21 +229,21 @@ class WebsiteReader(Reader):
                 # Log HTTP status errors but continue crawling other pages
                 # Skip redirect errors (3xx) as they should be handled by follow_redirects
                 if e.response.status_code >= 300 and e.response.status_code < 400:
-                    logger.debug(f"Redirect encountered for {current_url}, skipping: {e}")
+                    log_debug(f"Redirect encountered for {current_url}, skipping: {e}")
                 else:
-                    logger.warning(f"HTTP status error while crawling {current_url}: {e}")
+                    log_warning(f"HTTP status error while crawling {current_url}: {e}")
                 # For the initial URL, we should raise the error only if it's not a redirect
                 if current_url == url and not crawler_result and not (300 <= e.response.status_code < 400):
                     raise
             except httpx.RequestError as e:
                 # Log request errors but continue crawling other pages
-                logger.warning(f"Request error while crawling {current_url}: {e}")
+                log_warning(f"Request error while crawling {current_url}: {e}")
                 # For the initial URL, we should raise the error
                 if current_url == url and not crawler_result:
                     raise
             except Exception as e:
                 # Log other exceptions but continue crawling other pages
-                logger.warning(f"Failed to crawl {current_url}: {e}")
+                log_warning(f"Failed to crawl {current_url}: {e}")
                 # For the initial URL, we should raise the error
                 if current_url == url and not crawler_result:
                     # Wrap non-HTTP exceptions in a RequestError
@@ -332,19 +332,19 @@ class WebsiteReader(Reader):
 
                 except httpx.HTTPStatusError as e:
                     # Log HTTP status errors but continue crawling other pages
-                    logger.warning(f"HTTP status error while crawling asynchronously {current_url}: {e}")
+                    log_warning(f"HTTP status error while crawling asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         raise
                 except httpx.RequestError as e:
                     # Log request errors but continue crawling other pages
-                    logger.warning(f"Request error while crawling asynchronously {current_url}: {e}")
+                    log_warning(f"Request error while crawling asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         raise
                 except Exception as e:
                     # Log other exceptions but continue crawling other pages
-                    logger.warning(f"Failed to crawl asynchronously {current_url}: {e}")
+                    log_warning(f"Failed to crawl asynchronously {current_url}: {e}")
                     # For the initial URL, we should raise the error
                     if current_url == url and not crawler_result:
                         # Wrap non-HTTP exceptions in a RequestError
@@ -398,7 +398,7 @@ class WebsiteReader(Reader):
                     )
             return documents
         except (httpx.HTTPStatusError, httpx.RequestError) as e:
-            logger.error(f"Error reading website {url}: {e}")
+            log_error(f"Error reading website {url}: {e}")
             raise
 
     async def async_read(self, url: str, name: Optional[str] = None) -> List[Document]:
@@ -451,5 +451,5 @@ class WebsiteReader(Reader):
 
             return documents
         except (httpx.HTTPStatusError, httpx.RequestError) as e:
-            logger.error(f"Error reading website asynchronously {url}: {e}")
+            log_error(f"Error reading website asynchronously {url}: {e}")
             raise