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

agno/knowledge/reader/pdf_reader.py

@@ -9,7 +9,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_error, log_info, logger
+from agno.utils.log import log_debug, log_error
 
 try:
     from pypdf import PdfReader as DocumentReader  # noqa: F401
@@ -200,10 +200,11 @@ class BasePDFReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for PDF readers."""
         return [
             ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.SEMANTIC_CHUNKER,
@@ -218,31 +219,29 @@ class BasePDFReader(Reader):
 
     def _get_doc_name(self, pdf_source: Union[str, Path, IO[Any]], name: Optional[str] = None) -> str:
         """Determines the document name from the source or a provided name."""
-        try:
-            if name:
-                return name
-            if isinstance(pdf_source, str):
-                return pdf_source.split("/")[-1].split(".")[0].replace(" ", "_")
-            # Assumes a file-like object with a .name attribute
-            return pdf_source.name.split(".")[0]
-        except Exception:
-            # The original code had a bug here, it should check `name` first.
-            return name or "pdf"
+        if name:
+            return name
+        if isinstance(pdf_source, str):
+            return Path(pdf_source).stem.replace(" ", "_")
+        if isinstance(pdf_source, Path):
+            return pdf_source.stem.replace(" ", "_")
+        return getattr(pdf_source, "name", "pdf_file").split(".")[0].replace(" ", "_")
 
     def _decrypt_pdf(self, doc_reader: DocumentReader, doc_name: str, password: Optional[str] = None) -> bool:
         if not doc_reader.is_encrypted:
             return True
 
         # Use provided password or fall back to instance password
-        pdf_password = password or self.password
-        if not pdf_password:
-            logger.error(f'PDF file "{doc_name}" is password protected but no password provided')
+        # Note: Empty string "" is a valid password for PDFs with blank user password
+        pdf_password = self.password if password is None else password
+        if pdf_password is None:
+            log_error(f'PDF file "{doc_name}" is password protected but no password provided')
             return False
 
         try:
             decrypted_pdf = doc_reader.decrypt(pdf_password)
             if decrypted_pdf:
-                log_info(f'Successfully decrypted PDF file "{doc_name}" with user password')
+                log_debug(f'Successfully decrypted PDF file "{doc_name}" with user password')
                 return True
             else:
                 log_error(f'Failed to decrypt PDF file "{doc_name}": incorrect password')
@@ -337,19 +336,25 @@ class PDFReader(BasePDFReader):
     """Reader for PDF files"""
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.PDF]
 
     def read(
-        self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
+        self,
+        pdf: Optional[Union[str, Path, IO[Any]]] = None,
+        name: Optional[str] = None,
+        password: Optional[str] = None,
     ) -> List[Document]:
+        if pdf is None:
+            log_error("No pdf provided")
+            return []
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
@@ -368,12 +373,12 @@ class PDFReader(BasePDFReader):
             log_error("No pdf provided")
             return []
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption
@@ -394,11 +399,11 @@ class PDFImageReader(BasePDFReader):
             raise ValueError("No pdf provided")
 
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption
@@ -406,7 +411,7 @@ class PDFImageReader(BasePDFReader):
             return []
 
         # Read and chunk.
-        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=True)
 
     async def async_read(
         self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
@@ -415,12 +420,12 @@ class PDFImageReader(BasePDFReader):
             raise ValueError("No pdf provided")
 
         doc_name = self._get_doc_name(pdf, name)
-        log_info(f"Reading: {doc_name}")
+        log_debug(f"Reading: {doc_name}")
 
         try:
             pdf_reader = DocumentReader(pdf)
         except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
+            log_error(f"Error reading PDF: {e}")
             return []
 
         # Handle PDF decryption
@@ -428,4 +433,4 @@ class PDFImageReader(BasePDFReader):
             return []
 
         # Read and chunk.
-        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=True)

agno/knowledge/reader/pptx_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
 
 try:
     from pptx import Presentation  # type: ignore
@@ -23,10 +23,11 @@ class PPTXReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for PPTX readers."""
         return [
             ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.SEMANTIC_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
@@ -34,7 +35,7 @@ class PPTXReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.PPTX]
 
     def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
@@ -43,15 +44,13 @@ class PPTXReader(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}")
                 presentation = Presentation(str(file))
                 doc_name = name or file.stem
             else:
-                log_info(f"Reading uploaded file: {getattr(file, 'name', 'pptx_file')}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
                 presentation = Presentation(file)
-                doc_name = name or (
-                    getattr(file, "name", "pptx_file").split(".")[0] if hasattr(file, "name") else "pptx_file"
-                )
+                doc_name = name or getattr(file, "name", "pptx_file").split(".")[0]
 
             # Extract text from all slides
             slide_texts = []
@@ -89,7 +88,7 @@ class PPTXReader(Reader):
             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]:
@@ -97,5 +96,5 @@ class PPTXReader(Reader):
         try:
             return await asyncio.to_thread(self.read, file, name)
         except Exception as e:
-            logger.error(f"Error reading file asynchronously: {e}")
+            log_error(f"Error reading file asynchronously: {e}")
             return []

agno/knowledge/reader/reader_factory.py

@@ -10,6 +10,74 @@ class ReaderFactory:
     # Cache for instantiated readers
     _reader_cache: Dict[str, Reader] = {}
 
+    # Static metadata for readers - avoids instantiation just to get metadata
+    READER_METADATA: Dict[str, Dict[str, str]] = {
+        "pdf": {
+            "name": "PdfReader",
+            "description": "Processes PDF documents with OCR support for images and text extraction",
+        },
+        "csv": {
+            "name": "CsvReader",
+            "description": "Parses CSV files with custom delimiter support",
+        },
+        "excel": {
+            "name": "ExcelReader",
+            "description": "Processes Excel workbooks (.xlsx and .xls) with sheet filtering and row-based chunking",
+        },
+        "field_labeled_csv": {
+            "name": "FieldLabeledCsvReader",
+            "description": "Converts CSV rows to field-labeled text format for enhanced readability and context",
+        },
+        "docx": {
+            "name": "DocxReader",
+            "description": "Extracts text content from Microsoft Word documents (.docx and .doc formats)",
+        },
+        "pptx": {
+            "name": "PptxReader",
+            "description": "Extracts text content from Microsoft PowerPoint presentations (.pptx format)",
+        },
+        "json": {
+            "name": "JsonReader",
+            "description": "Processes JSON data structures and API responses with nested object handling",
+        },
+        "markdown": {
+            "name": "MarkdownReader",
+            "description": "Processes Markdown documentation with header-aware chunking and formatting preservation",
+        },
+        "text": {
+            "name": "TextReader",
+            "description": "Handles plain text files with customizable chunking strategies and encoding detection",
+        },
+        "website": {
+            "name": "WebsiteReader",
+            "description": "Scrapes and extracts content from web pages with HTML parsing and text cleaning",
+        },
+        "firecrawl": {
+            "name": "FirecrawlReader",
+            "description": "Advanced web scraping and crawling with JavaScript rendering and structured data extraction",
+        },
+        "tavily": {
+            "name": "TavilyReader",
+            "description": "Extracts content from URLs using Tavily's Extract API with markdown or text output",
+        },
+        "youtube": {
+            "name": "YouTubeReader",
+            "description": "Extracts transcripts and metadata from YouTube videos and playlists",
+        },
+        "arxiv": {
+            "name": "ArxivReader",
+            "description": "Downloads and processes academic papers from ArXiv with PDF parsing and metadata extraction",
+        },
+        "wikipedia": {
+            "name": "WikipediaReader",
+            "description": "Fetches and processes Wikipedia articles with section-aware chunking and link resolution",
+        },
+        "web_search": {
+            "name": "WebSearchReader",
+            "description": "Executes web searches and processes results with relevance ranking and content extraction",
+        },
+    }
+
     @classmethod
     def _get_pdf_reader(cls, **kwargs) -> Reader:
         """Get PDF reader instance."""
@@ -29,11 +97,23 @@ class ReaderFactory:
 
         config: Dict[str, Any] = {
             "name": "CSV Reader",
-            "description": "Parses CSV, XLSX, and XLS files with custom delimiter support",
+            "description": "Parses CSV files with custom delimiter support",
         }
         config.update(kwargs)
         return CSVReader(**config)
 
+    @classmethod
+    def _get_excel_reader(cls, **kwargs) -> Reader:
+        """Get Excel reader instance."""
+        from agno.knowledge.reader.excel_reader import ExcelReader
+
+        config: Dict[str, Any] = {
+            "name": "Excel Reader",
+            "description": "Processes Excel workbooks (.xlsx and .xls) with sheet filtering and row-based chunking",
+        }
+        config.update(kwargs)
+        return ExcelReader(**config)
+
     @classmethod
     def _get_field_labeled_csv_reader(cls, **kwargs) -> Reader:
         """Get Field Labeled CSV reader instance."""
@@ -203,6 +283,53 @@ class ReaderFactory:
             raise ValueError(f"Unknown reader: {reader_key}")
         return getattr(cls, method_name)
 
+    @classmethod
+    def get_reader_class(cls, reader_key: str) -> type:
+        """Get the reader CLASS without instantiation.
+
+        This is useful for accessing class methods like get_supported_chunking_strategies()
+        without the overhead of creating an instance.
+
+        Args:
+            reader_key: The reader key (e.g., 'pdf', 'csv', 'markdown')
+
+        Returns:
+            The reader class (not an instance)
+
+        Raises:
+            ValueError: If the reader key is unknown
+            ImportError: If the reader's dependencies are not installed
+        """
+        # Map reader keys to their import paths
+        reader_class_map: Dict[str, tuple] = {
+            "pdf": ("agno.knowledge.reader.pdf_reader", "PDFReader"),
+            "csv": ("agno.knowledge.reader.csv_reader", "CSVReader"),
+            "excel": ("agno.knowledge.reader.excel_reader", "ExcelReader"),
+            "field_labeled_csv": ("agno.knowledge.reader.field_labeled_csv_reader", "FieldLabeledCSVReader"),
+            "docx": ("agno.knowledge.reader.docx_reader", "DocxReader"),
+            "pptx": ("agno.knowledge.reader.pptx_reader", "PPTXReader"),
+            "json": ("agno.knowledge.reader.json_reader", "JSONReader"),
+            "markdown": ("agno.knowledge.reader.markdown_reader", "MarkdownReader"),
+            "text": ("agno.knowledge.reader.text_reader", "TextReader"),
+            "website": ("agno.knowledge.reader.website_reader", "WebsiteReader"),
+            "firecrawl": ("agno.knowledge.reader.firecrawl_reader", "FirecrawlReader"),
+            "tavily": ("agno.knowledge.reader.tavily_reader", "TavilyReader"),
+            "youtube": ("agno.knowledge.reader.youtube_reader", "YouTubeReader"),
+            "arxiv": ("agno.knowledge.reader.arxiv_reader", "ArxivReader"),
+            "wikipedia": ("agno.knowledge.reader.wikipedia_reader", "WikipediaReader"),
+            "web_search": ("agno.knowledge.reader.web_search_reader", "WebSearchReader"),
+        }
+
+        if reader_key not in reader_class_map:
+            raise ValueError(f"Unknown reader: {reader_key}")
+
+        module_path, class_name = reader_class_map[reader_key]
+
+        import importlib
+
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+
     @classmethod
     def create_reader(cls, reader_key: str, **kwargs) -> Reader:
         """Create a reader instance with the given key and optional overrides."""
@@ -227,6 +354,13 @@ class ReaderFactory:
             return cls.create_reader("pdf")
         elif extension in [".csv", "text/csv"]:
             return cls.create_reader("csv")
+        elif extension in [
+            ".xlsx",
+            ".xls",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "application/vnd.ms-excel",
+        ]:
+            return cls.create_reader("excel")
         elif extension in [".docx", ".doc", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"]:
             return cls.create_reader("docx")
         elif extension == ".pptx":

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
@@ -35,9 +35,10 @@ class S3Reader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for S3 readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -46,41 +47,32 @@ class S3Reader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.FILE, ContentType.URL, ContentType.TEXT]
 
     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}")
+
+            doc_name = name or s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
 
             # Read PDF files
             if s3_object.uri.endswith(".pdf"):
                 object_resource = s3_object.get_resource()
                 object_body = object_resource.get()["Body"]
-                doc_name = (
-                    s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-                    if name is None
-                    else name
-                )
                 return PDFReader().read(pdf=BytesIO(object_body.read()), name=doc_name)
 
             # Read text files
             else:
-                doc_name = (
-                    s3_object.name.split("/")[-1].split(".")[0].replace("/", "_").replace(" ", "_")
-                    if name is None
-                    else name
-                )
                 obj_name = s3_object.name.split("/")[-1]
                 temporary_file = Path("storage").joinpath(obj_name)
                 s3_object.download(temporary_file)
                 documents = TextReader().read(file=temporary_file, name=doc_name)
-
                 temporary_file.unlink()
                 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/tavily_reader.py

@@ -62,9 +62,10 @@ class TavilyReader(Reader):
         self.extract_depth = extract_depth
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Tavily readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.SEMANTIC_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
@@ -73,7 +74,7 @@ class TavilyReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def _extract(self, url: str, name: Optional[str] = None) -> List[Document]:
@@ -140,7 +141,6 @@ class TavilyReader(Reader):
                 documents.extend(self.chunk_document(Document(name=name or url, id=url, content=content)))
             else:
                 documents.append(Document(name=name or url, id=url, content=content))
-
             return documents
 
         except Exception as e:

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):
@@ -18,9 +18,10 @@ class TextReader(Reader):
         super().__init__(chunking_strategy=chunking_strategy, **kwargs)
 
     @classmethod
-    def get_supported_chunking_strategies(self) -> List[ChunkingStrategyType]:
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
         """Get the list of supported chunking strategies for Text readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -29,7 +30,7 @@ class TextReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TXT]
 
     def read(self, file: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
@@ -37,12 +38,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")
+                file_contents = file.read_text(encoding=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: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "text_file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -60,7 +61,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 +70,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,11 +79,11 @@ 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")
-                    file_contents = file.read_text(self.encoding or "utf-8")
+                    log_warning("aiofiles not installed, using synchronous file I/O")
+                    file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
-                log_info(f"Reading uploaded file asynchronously: {file.name}")
-                file_name = name or file.name.split(".")[0]
+                log_debug(f"Reading uploaded file asynchronously: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "text_file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -96,7 +97,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/utils/__init__.py

@@ -0,0 +1,17 @@
+from agno.knowledge.reader.utils.spreadsheet import (
+    convert_xls_cell_value,
+    excel_rows_to_documents,
+    get_workbook_name,
+    infer_file_extension,
+    row_to_csv_line,
+    stringify_cell_value,
+)
+
+__all__ = [
+    "convert_xls_cell_value",
+    "excel_rows_to_documents",
+    "get_workbook_name",
+    "infer_file_extension",
+    "row_to_csv_line",
+    "stringify_cell_value",
+]