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

agno/knowledge/reader/excel_reader.py

@@ -0,0 +1,225 @@
+import asyncio
+import io
+from pathlib import Path
+from typing import IO, Any, Iterable, List, Optional, Sequence, Tuple, Union
+
+from agno.knowledge.chunking.row import RowChunking
+from agno.knowledge.chunking.strategy import ChunkingStrategy, ChunkingStrategyType
+from agno.knowledge.document.base import Document
+from agno.knowledge.reader.base import Reader
+from agno.knowledge.reader.utils import (
+    convert_xls_cell_value,
+    excel_rows_to_documents,
+    get_workbook_name,
+    infer_file_extension,
+)
+from agno.knowledge.types import ContentType
+from agno.utils.log import log_debug, log_error
+
+
+class ExcelReader(Reader):
+    """Reader for Excel files (.xlsx and .xls)."""
+
+    def __init__(
+        self,
+        sheets: Optional[List[Union[str, int]]] = None,
+        chunking_strategy: Optional[ChunkingStrategy] = RowChunking(),
+        **kwargs,
+    ):
+        super().__init__(chunking_strategy=chunking_strategy, **kwargs)
+        self.sheets = sheets
+
+    @classmethod
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
+        """Get the list of supported chunking strategies for Excel readers."""
+        return [
+            ChunkingStrategyType.ROW_CHUNKER,
+            ChunkingStrategyType.CODE_CHUNKER,
+            ChunkingStrategyType.FIXED_SIZE_CHUNKER,
+            ChunkingStrategyType.AGENTIC_CHUNKER,
+            ChunkingStrategyType.DOCUMENT_CHUNKER,
+            ChunkingStrategyType.RECURSIVE_CHUNKER,
+        ]
+
+    @classmethod
+    def get_supported_content_types(cls) -> List[ContentType]:
+        """Get the list of supported content types."""
+        return [ContentType.XLSX, ContentType.XLS]
+
+    def _should_include_sheet(
+        self,
+        sheet_name: str,
+        sheet_index: int,
+    ) -> bool:
+        """Check if sheet passes the configured filters.
+
+        Args:
+            sheet_name: Name of the sheet
+            sheet_index: 1-based index of the sheet (matches document metadata)
+
+        Returns:
+            True if sheet should be included, False otherwise.
+
+        Note:
+            - Index filtering is 1-based to match sheet_index in document metadata
+            - Name filtering is case-insensitive
+            - Empty list or None means include all sheets
+        """
+        # None or empty list = include all sheets
+        if not self.sheets:
+            return True
+
+        for sheet_filter in self.sheets:
+            if isinstance(sheet_filter, int):
+                # 1-based indexing to match metadata
+                if sheet_index == sheet_filter:
+                    return True
+            elif isinstance(sheet_filter, str):
+                # Case-insensitive name matching
+                if sheet_name.lower() == sheet_filter.lower():
+                    return True
+
+        return False
+
+    def _read_xlsx(self, file: Union[Path, IO[Any]], *, workbook_name: str) -> List[Document]:
+        """Read .xlsx file using openpyxl."""
+        try:
+            import openpyxl
+        except ImportError as e:
+            raise ImportError("`openpyxl` not installed. Please install it via `pip install openpyxl`.") from e
+
+        if isinstance(file, Path):
+            workbook = openpyxl.load_workbook(filename=str(file), read_only=True, data_only=True)
+        else:
+            file.seek(0)
+            raw = file.read()
+            if isinstance(raw, str):
+                raw = raw.encode("utf-8", errors="replace")
+            workbook = openpyxl.load_workbook(filename=io.BytesIO(raw), read_only=True, data_only=True)
+
+        try:
+            sheets: List[Tuple[str, int, Iterable[Sequence[Any]]]] = []
+            for sheet_index, worksheet in enumerate(workbook.worksheets):
+                # Pass 1-based index to match metadata (sheet_index + 1)
+                if not self._should_include_sheet(worksheet.title, sheet_index + 1):
+                    log_debug(f"Skipping sheet '{worksheet.title}' (filtered out)")
+                    continue
+
+                sheets.append((worksheet.title, sheet_index + 1, worksheet.iter_rows(values_only=True)))
+
+            return excel_rows_to_documents(workbook_name=workbook_name, sheets=sheets)
+        finally:
+            workbook.close()
+
+    def _read_xls(self, file: Union[Path, IO[Any]], *, workbook_name: str) -> List[Document]:
+        """Read .xls file using xlrd."""
+        try:
+            import xlrd
+        except ImportError as e:
+            raise ImportError("`xlrd` not installed. Please install it via `pip install xlrd`.") from e
+
+        if isinstance(file, Path):
+            workbook = xlrd.open_workbook(filename=str(file), encoding_override=self.encoding)
+        else:
+            file.seek(0)
+            raw = file.read()
+            if isinstance(raw, str):
+                raw = raw.encode("utf-8", errors="replace")
+            workbook = xlrd.open_workbook(file_contents=raw, encoding_override=self.encoding)
+
+        sheets: List[Tuple[str, int, Iterable[Sequence[Any]]]] = []
+        for sheet_index in range(workbook.nsheets):
+            sheet = workbook.sheet_by_index(sheet_index)
+
+            # Pass 1-based index to match metadata (sheet_index + 1)
+            if not self._should_include_sheet(sheet.name, sheet_index + 1):
+                log_debug(f"Skipping sheet '{sheet.name}' (filtered out)")
+                continue
+
+            def _iter_sheet_rows(_sheet: Any = sheet, _datemode: int = workbook.datemode) -> Iterable[Sequence[Any]]:
+                for row_index in range(_sheet.nrows):
+                    yield [
+                        convert_xls_cell_value(
+                            _sheet.cell_value(row_index, col_index),
+                            _sheet.cell_type(row_index, col_index),
+                            _datemode,
+                        )
+                        for col_index in range(_sheet.ncols)
+                    ]
+
+            sheets.append((sheet.name, sheet_index + 1, _iter_sheet_rows()))
+
+        return excel_rows_to_documents(workbook_name=workbook_name, sheets=sheets)
+
+    def read(
+        self,
+        file: Union[Path, IO[Any]],
+        name: Optional[str] = None,
+    ) -> List[Document]:
+        """Read an Excel file and return documents (one per sheet)."""
+        try:
+            file_extension = infer_file_extension(file, name)
+            workbook_name = get_workbook_name(file, name)
+
+            if isinstance(file, Path) and not file.exists():
+                raise FileNotFoundError(f"Could not find file: {file}")
+
+            file_desc = str(file) if isinstance(file, Path) else getattr(file, "name", "BytesIO")
+            log_debug(f"Reading Excel file: {file_desc}")
+
+            if file_extension == ContentType.XLSX or file_extension == ".xlsx":
+                documents = self._read_xlsx(file, workbook_name=workbook_name)
+            elif file_extension == ContentType.XLS or file_extension == ".xls":
+                documents = self._read_xls(file, workbook_name=workbook_name)
+            else:
+                raise ValueError(f"Unsupported file extension: '{file_extension}'. Expected .xlsx or .xls")
+
+            if self.chunk:
+                chunked_documents = []
+                for document in documents:
+                    chunked_documents.extend(self.chunk_document(document))
+                return chunked_documents
+
+            return documents
+
+        except (FileNotFoundError, ImportError, ValueError):
+            raise
+        except Exception as e:
+            file_desc = getattr(file, "name", str(file)) if isinstance(file, IO) else file
+            log_error(f"Error reading {file_desc}: {e}")
+            return []
+
+    async def async_read(
+        self,
+        file: Union[Path, IO[Any]],
+        name: Optional[str] = None,
+    ) -> List[Document]:
+        """Async version of read()."""
+        try:
+            file_extension = infer_file_extension(file, name)
+            workbook_name = get_workbook_name(file, name)
+
+            if isinstance(file, Path) and not file.exists():
+                raise FileNotFoundError(f"Could not find file: {file}")
+
+            file_desc = str(file) if isinstance(file, Path) else getattr(file, "name", "BytesIO")
+            log_debug(f"Reading Excel file async: {file_desc}")
+
+            if file_extension == ContentType.XLSX or file_extension == ".xlsx":
+                documents = await asyncio.to_thread(self._read_xlsx, file, workbook_name=workbook_name)
+            elif file_extension == ContentType.XLS or file_extension == ".xls":
+                documents = await asyncio.to_thread(self._read_xls, file, workbook_name=workbook_name)
+            else:
+                raise ValueError(f"Unsupported file extension: '{file_extension}'. Expected .xlsx or .xls")
+
+            if self.chunk:
+                documents = await self.chunk_documents_async(documents)
+
+            return documents
+
+        except (FileNotFoundError, ImportError, ValueError):
+            raise
+        except Exception as e:
+            file_desc = getattr(file, "name", str(file)) if isinstance(file, IO) else file
+            log_error(f"Error reading {file_desc}: {e}")
+            return []

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -12,8 +12,9 @@ except ImportError:
 from agno.knowledge.chunking.strategy import ChunkingStrategyType
 from agno.knowledge.document.base import Document
 from agno.knowledge.reader.base import Reader
+from agno.knowledge.reader.utils import stringify_cell_value
 from agno.knowledge.types import ContentType
-from agno.utils.log import logger
+from agno.utils.log import log_debug, log_error, log_warning
 
 
 class FieldLabeledCSVReader(Reader):
@@ -41,7 +42,7 @@ class FieldLabeledCSVReader(Reader):
     @classmethod
     def get_supported_content_types(cls) -> List[ContentType]:
         """Get the list of supported content types."""
-        return [ContentType.CSV, ContentType.XLSX, ContentType.XLS]
+        return [ContentType.CSV]
 
     def _format_field_name(self, field_name: str) -> str:
         """Format field name to be more readable."""
@@ -66,17 +67,7 @@ class FieldLabeledCSVReader(Reader):
         return None
 
     def _convert_row_to_labeled_text(self, headers: List[str], row: List[str], entry_index: int) -> str:
-        """
-        Convert a CSV row to field-labeled text format.
-
-        Args:
-            headers: Column headers
-            row: Data row values
-            entry_index: Index of this entry (for title rotation)
-
-        Returns:
-            Formatted text with field labels
-        """
+        """Convert a CSV row to field-labeled text format."""
         lines = []
 
         title = self._get_title_for_entry(entry_index)
@@ -84,7 +75,8 @@ class FieldLabeledCSVReader(Reader):
             lines.append(title)
 
         for i, (header, value) in enumerate(zip(headers, row)):
-            clean_value = value.strip() if value else ""
+            # Normalize line endings before stripping to handle embedded newlines
+            clean_value = stringify_cell_value(value).strip() if value else ""
 
             if self.skip_empty_fields and not clean_value:
                 continue
@@ -101,22 +93,21 @@ class FieldLabeledCSVReader(Reader):
     def read(
         self, file: Union[Path, IO[Any]], delimiter: str = ",", quotechar: str = '"', name: Optional[str] = None
     ) -> List[Document]:
+        """Read a CSV file and convert each row to a field-labeled document."""
         try:
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading: {file}")
-                file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
+                log_debug(f"Reading: {file}")
+                csv_name = name or file.stem
+                file_content: Union[io.TextIOWrapper, io.StringIO] = file.open(
+                    newline="", mode="r", encoding=self.encoding or "utf-8"
+                )
             else:
-                logger.info(f"Reading retrieved file: {name or file.name}")
+                log_debug(f"Reading retrieved file: {getattr(file, 'name', 'BytesIO')}")
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
-
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
+                file_content = io.StringIO(file.read().decode(self.encoding or "utf-8"))
 
             documents = []
 
@@ -127,15 +118,15 @@ class FieldLabeledCSVReader(Reader):
                 rows = list(csv_reader)
 
                 if not rows:
-                    logger.warning("CSV file is empty")
+                    log_warning("CSV file is empty")
                     return []
 
                 # First row is headers
                 headers = [header.strip() for header in rows[0]]
-                logger.info(f"Found {len(headers)} headers: {headers}")
+                log_debug(f"Found {len(headers)} headers: {headers}")
 
                 data_rows = rows[1:] if len(rows) > 1 else []
-                logger.info(f"Processing {len(data_rows)} data rows")
+                log_debug(f"Processing {len(data_rows)} data rows")
 
                 for row_index, row in enumerate(data_rows):
                     # Ensure row has same length as headers (pad or truncate)
@@ -163,13 +154,15 @@ class FieldLabeledCSVReader(Reader):
                         )
 
                         documents.append(document)
-                        logger.debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
+                        log_debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
 
-            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            log_debug(f"Successfully created {len(documents)} labeled documents from CSV")
             return documents
 
+        except FileNotFoundError:
+            raise
         except Exception as e:
-            logger.error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
+            log_error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []
 
     async def async_read(
@@ -180,42 +173,38 @@ class FieldLabeledCSVReader(Reader):
         page_size: int = 1000,
         name: Optional[str] = None,
     ) -> List[Document]:
+        """Read a CSV file asynchronously and convert each row to a field-labeled document."""
         try:
-            # Handle file input
             if isinstance(file, Path):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
-                logger.info(f"Reading async: {file}")
+                log_debug(f"Reading async: {file}")
                 async with aiofiles.open(file, mode="r", encoding=self.encoding or "utf-8", newline="") as file_content:
                     content = await file_content.read()
                     file_content_io = io.StringIO(content)
+                csv_name = name or file.stem
             else:
-                logger.info(f"Reading retrieved file async: {name or file.name}")
+                log_debug(f"Reading retrieved file async: {getattr(file, 'name', 'BytesIO')}")
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content_io = io.StringIO(file.read().decode("utf-8"))  # type: ignore
-
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
+                file_content_io = io.StringIO(file.read().decode(self.encoding or "utf-8"))
 
             file_content_io.seek(0)
             csv_reader = csv.reader(file_content_io, delimiter=delimiter, quotechar=quotechar)
             rows = list(csv_reader)
 
             if not rows:
-                logger.warning("CSV file is empty")
+                log_warning("CSV file is empty")
                 return []
 
             # First row is headers
             headers = [header.strip() for header in rows[0]]
-            logger.info(f"Found {len(headers)} headers: {headers}")
+            log_debug(f"Found {len(headers)} headers: {headers}")
 
             # Process data rows
             data_rows = rows[1:] if len(rows) > 1 else []
             total_rows = len(data_rows)
-            logger.info(f"Processing {total_rows} data rows")
+            log_debug(f"Processing {total_rows} data rows")
 
             # For small files, process all at once
             if total_rows <= 10:
@@ -241,12 +230,13 @@ class FieldLabeledCSVReader(Reader):
                         )
                         documents.append(document)
             else:
+                # Large files: paginate and process in parallel
                 pages = []
                 for i in range(0, total_rows, page_size):
                     pages.append(data_rows[i : i + page_size])
 
                 async def _process_page(page_number: int, page_rows: List[List[str]]) -> List[Document]:
-                    """Process a page of rows into documents"""
+                    """Process a page of rows into documents."""
                     page_documents = []
                     start_row_index = (page_number - 1) * page_size
 
@@ -282,11 +272,11 @@ class FieldLabeledCSVReader(Reader):
 
                 documents = [doc for page_docs in page_results for doc in page_docs]
 
-            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            log_debug(f"Successfully created {len(documents)} labeled documents from CSV")
             return documents
 
+        except FileNotFoundError:
+            raise
         except Exception as e:
-            logger.error(
-                f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}"
-            )
+            log_error(f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
             return []

agno/knowledge/reader/firecrawl_reader.py

@@ -43,9 +43,10 @@ class FirecrawlReader(Reader):
         self.mode = mode
 
     @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 Firecrawl readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.SEMANTIC_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
@@ -54,7 +55,7 @@ class FirecrawlReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def scrape(self, url: str, name: Optional[str] = None) -> List[Document]:

agno/knowledge/reader/json_reader.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-from io import BytesIO
 from pathlib import Path
 from typing import IO, Any, List, Optional, Union
 from uuid import uuid4
@@ -10,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_info
+from agno.utils.log import log_debug, log_error
 
 
 class JSONReader(Reader):
@@ -22,9 +21,10 @@ class JSONReader(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 JSON readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -33,7 +33,7 @@ class JSONReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.JSON]
 
     def read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
@@ -41,18 +41,16 @@ class JSONReader(Reader):
             if isinstance(path, Path):
                 if not path.exists():
                     raise FileNotFoundError(f"Could not find file: {path}")
-                log_info(f"Reading: {path}")
-                json_name = name or path.name.split(".")[0]
-                json_contents = json.loads(path.read_text(self.encoding or "utf-8"))
-
-            elif isinstance(path, BytesIO):
-                json_name = name or path.name.split(".")[0]
-                log_info(f"Reading uploaded file: {json_name}")
+                log_debug(f"Reading: {path}")
+                json_name = name or path.stem
+                json_contents = json.loads(path.read_text(encoding=self.encoding or "utf-8"))
+            elif hasattr(path, "seek") and hasattr(path, "read"):
+                log_debug(f"Reading uploaded file: {getattr(path, 'name', 'BytesIO')}")
+                json_name = name or getattr(path, "name", "json_file").split(".")[0]
                 path.seek(0)
                 json_contents = json.load(path)
-
             else:
-                raise ValueError("Unsupported file type. Must be Path or BytesIO.")
+                raise ValueError("Unsupported file type. Must be Path or file-like object.")
 
             if isinstance(json_contents, dict):
                 json_contents = [json_contents]
@@ -72,16 +70,12 @@ class JSONReader(Reader):
                     chunked_documents.extend(self.chunk_document(document))
                 return chunked_documents
             return documents
-        except Exception:
+        except (FileNotFoundError, ValueError, json.JSONDecodeError):
+            raise
+        except Exception as e:
+            log_error(f"Error reading: {path}: {e}")
             raise
 
     async def async_read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
-        """Asynchronously read JSON files.
-
-        Args:
-            path (Union[Path, IO[Any]]): Path to a JSON file or a file-like object
-
-        Returns:
-            List[Document]: List of documents from the JSON file
-        """
+        """Asynchronously read JSON files."""
         return await asyncio.to_thread(self.read, path, name)

agno/knowledge/reader/markdown_reader.py

@@ -7,7 +7,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
 
 DEFAULT_CHUNKER_STRATEGY: ChunkingStrategy
 
@@ -28,9 +28,10 @@ class MarkdownReader(Reader):
     """Reader for Markdown files"""
 
     @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 Markdown readers."""
         strategies = [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.RECURSIVE_CHUNKER,
@@ -45,7 +46,7 @@ class MarkdownReader(Reader):
         return strategies
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.MARKDOWN]
 
     def __init__(
@@ -65,12 +66,12 @@ class MarkdownReader(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(encoding=self.encoding or "utf-8")
             else:
-                log_info(f"Reading uploaded file: {file.name}")
-                file_name = name or file.name.split(".")[0]
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -82,7 +83,7 @@ class MarkdownReader(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]:
@@ -91,7 +92,7 @@ class MarkdownReader(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:
@@ -100,17 +101,17 @@ class MarkdownReader(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", "file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
             document = Document(
                 name=file_name,
-                id=str(uuid.uuid4()),  # Fixed an issue with the id creation
+                id=str(uuid.uuid4()),
                 content=file_contents,
             )
 
@@ -118,7 +119,7 @@ class MarkdownReader(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]: