agno 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -0,0 +1,294 @@
+import asyncio
+import csv
+import io
+from pathlib import Path
+from typing import IO, Any, List, Optional, Union
+
+try:
+    import aiofiles
+except ImportError:
+    raise ImportError("`aiofiles` not installed. Please install it with `pip install aiofiles`")
+
+from agno.knowledge.chunking.strategy import ChunkingStrategyType
+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 logger
+
+
+class FieldLabeledCSVReader(Reader):
+    """Reader for CSV files that converts each row to a field-labeled document."""
+
+    def __init__(
+        self,
+        chunk_title: Optional[Union[str, List[str]]] = None,
+        field_names: Optional[List[str]] = None,
+        format_headers: bool = True,
+        skip_empty_fields: bool = True,
+        **kwargs,
+    ):
+        super().__init__(chunk=False, chunking_strategy=None, **kwargs)
+        self.chunk_title = chunk_title
+        self.field_names = field_names or []
+        self.format_headers = format_headers
+        self.skip_empty_fields = skip_empty_fields
+
+        logger.info(f"FieldLabeledCSVReader initialized - chunk_title: {chunk_title}, field_names: {self.field_names}")
+
+    @classmethod
+    def get_supported_chunking_strategies(cls) -> List[ChunkingStrategyType]:
+        """Chunking is not supported - each row is already a logical document unit."""
+        return []
+
+    @classmethod
+    def get_supported_content_types(cls) -> List[ContentType]:
+        """Get the list of supported content types."""
+        return [ContentType.CSV, ContentType.XLSX, ContentType.XLS]
+
+    def _format_field_name(self, field_name: str) -> str:
+        """Format field name to be more readable."""
+        if not self.format_headers:
+            return field_name.strip()
+
+        # Replace underscores with spaces and title case
+        formatted = field_name.replace("_", " ").strip().title()
+        return formatted
+
+    def _get_title_for_entry(self, entry_index: int) -> Optional[str]:
+        """Get title for a specific entry."""
+        if self.chunk_title is None:
+            return None
+
+        if isinstance(self.chunk_title, str):
+            return self.chunk_title
+
+        if isinstance(self.chunk_title, list) and self.chunk_title:
+            return self.chunk_title[entry_index % len(self.chunk_title)]
+
+        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
+        """
+        lines = []
+
+        title = self._get_title_for_entry(entry_index)
+        if title:
+            lines.append(title)
+
+        for i, (header, value) in enumerate(zip(headers, row)):
+            clean_value = value.strip() if value else ""
+
+            if self.skip_empty_fields and not clean_value:
+                continue
+
+            if self.field_names and i < len(self.field_names):
+                field_name = self.field_names[i]
+            else:
+                field_name = self._format_field_name(header)
+
+            lines.append(f"{field_name}: {clean_value}")
+
+        return "\n".join(lines)
+
+    def read(
+        self, file: Union[Path, IO[Any]], delimiter: str = ",", quotechar: str = '"', name: Optional[str] = None
+    ) -> List[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")
+            else:
+                logger.info(f"Reading retrieved file: {name or file.name}")
+                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")
+            )
+
+            documents = []
+
+            with file_content as csvfile:
+                csv_reader = csv.reader(csvfile, delimiter=delimiter, quotechar=quotechar)
+
+                # Read all rows
+                rows = list(csv_reader)
+
+                if not rows:
+                    logger.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}")
+
+                data_rows = rows[1:] if len(rows) > 1 else []
+                logger.info(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)
+                    normalized_row = row[: len(headers)]  # Truncate if too long
+                    while len(normalized_row) < len(headers):  # Pad if too short
+                        normalized_row.append("")
+
+                    # Convert row to labeled text
+                    labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                    if labeled_text.strip():
+                        # Create document for this row
+                        doc_id = f"{csv_name}_row_{row_index + 1}"
+
+                        document = Document(
+                            id=doc_id,
+                            name=csv_name,
+                            meta_data={
+                                "row_index": row_index,
+                                "headers": headers,
+                                "total_rows": len(data_rows),
+                                "source": "field_labeled_csv_reader",
+                            },
+                            content=labeled_text,
+                        )
+
+                        documents.append(document)
+                        logger.debug(f"Created document for row {row_index + 1}: {len(labeled_text)} chars")
+
+            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            return documents
+
+        except Exception as e:
+            logger.error(f"Error reading: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}")
+            return []
+
+    async def async_read(
+        self,
+        file: Union[Path, IO[Any]],
+        delimiter: str = ",",
+        quotechar: str = '"',
+        page_size: int = 1000,
+        name: Optional[str] = None,
+    ) -> List[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}")
+                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)
+            else:
+                logger.info(f"Reading retrieved file async: {name or file.name}")
+                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.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")
+                return []
+
+            # First row is headers
+            headers = [header.strip() for header in rows[0]]
+            logger.info(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")
+
+            # For small files, process all at once
+            if total_rows <= 10:
+                documents = []
+                for row_index, row in enumerate(data_rows):
+                    normalized_row = row[: len(headers)]
+                    while len(normalized_row) < len(headers):
+                        normalized_row.append("")
+
+                    labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                    if labeled_text.strip():
+                        document = Document(
+                            id=f"{csv_name}_row_{row_index + 1}",
+                            name=csv_name,
+                            meta_data={
+                                "row_index": row_index,
+                                "headers": headers,
+                                "total_rows": total_rows,
+                                "source": "field_labeled_csv_reader",
+                            },
+                            content=labeled_text,
+                        )
+                        documents.append(document)
+            else:
+                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"""
+                    page_documents = []
+                    start_row_index = (page_number - 1) * page_size
+
+                    for i, row in enumerate(page_rows):
+                        row_index = start_row_index + i
+
+                        normalized_row = row[: len(headers)]
+                        while len(normalized_row) < len(headers):
+                            normalized_row.append("")
+
+                        labeled_text = self._convert_row_to_labeled_text(headers, normalized_row, row_index)
+
+                        if labeled_text.strip():
+                            document = Document(
+                                id=f"{csv_name}_row_{row_index + 1}",
+                                name=csv_name,
+                                meta_data={
+                                    "row_index": row_index,
+                                    "headers": headers,
+                                    "total_rows": total_rows,
+                                    "page": page_number,
+                                    "source": "field_labeled_csv_reader",
+                                },
+                                content=labeled_text,
+                            )
+                            page_documents.append(document)
+
+                    return page_documents
+
+                page_results = await asyncio.gather(
+                    *[_process_page(page_number, page) for page_number, page in enumerate(pages, start=1)]
+                )
+
+                documents = [doc for page_docs in page_results for doc in page_docs]
+
+            logger.info(f"Successfully created {len(documents)} labeled documents from CSV")
+            return documents
+
+        except Exception as e:
+            logger.error(
+                f"Error reading async: {getattr(file, 'name', str(file)) if isinstance(file, IO) else file}: {e}"
+            )
+            return []

agno/knowledge/reader/pdf_reader.py

@@ -218,6 +218,19 @@ class BasePDFReader(Reader):
             chunked_documents.extend(self.chunk_document(document))
         return chunked_documents
 
+    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"
+
     def _decrypt_pdf(self, doc_reader: DocumentReader, doc_name: str, password: Optional[str] = None) -> bool:
         if not doc_reader.is_encrypted:
             return True
@@ -332,30 +345,7 @@ class PDFReader(BasePDFReader):
     def read(
         self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
     ) -> List[Document]:
-        try:
-            if name:
-                doc_name = name
-            elif isinstance(pdf, str):
-                doc_name = pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
-        try:
-            DocumentReader(pdf)
-        except PdfStreamError as e:
-            logger.error(f"Error reading PDF: {e}")
-            return []
-
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = name or pdf.name.split(".")[0]
-        except Exception:
-            doc_name = name or "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
 
         try:
@@ -363,7 +353,6 @@ class PDFReader(BasePDFReader):
         except PdfStreamError as e:
             logger.error(f"Error reading PDF: {e}")
             return []
-
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
             return []
@@ -380,15 +369,7 @@ class PDFReader(BasePDFReader):
         if pdf is None:
             log_error("No pdf provided")
             return []
-
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = name or "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
 
         try:
@@ -414,16 +395,13 @@ class PDFImageReader(BasePDFReader):
         if not pdf:
             raise ValueError("No pdf provided")
 
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
-        pdf_reader = DocumentReader(pdf)
+        try:
+            pdf_reader = DocumentReader(pdf)
+        except PdfStreamError as e:
+            logger.error(f"Error reading PDF: {e}")
+            return []
 
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):
@@ -438,16 +416,14 @@ class PDFImageReader(BasePDFReader):
         if not pdf:
             raise ValueError("No pdf provided")
 
-        try:
-            if isinstance(pdf, str):
-                doc_name = name or pdf.split("/")[-1].split(".")[0].replace(" ", "_")
-            else:
-                doc_name = pdf.name.split(".")[0]
-        except Exception:
-            doc_name = "pdf"
-
+        doc_name = self._get_doc_name(pdf, name)
         log_info(f"Reading: {doc_name}")
-        pdf_reader = DocumentReader(pdf)
+
+        try:
+            pdf_reader = DocumentReader(pdf)
+        except PdfStreamError as e:
+            logger.error(f"Error reading PDF: {e}")
+            return []
 
         # Handle PDF decryption
         if not self._decrypt_pdf(pdf_reader, doc_name, password):

agno/knowledge/reader/reader_factory.py

@@ -35,6 +35,18 @@ class ReaderFactory:
         config.update(kwargs)
         return CSVReader(**config)
 
+    @classmethod
+    def _get_field_labeled_csv_reader(cls, **kwargs) -> Reader:
+        """Get Field Labeled CSV reader instance."""
+        from agno.knowledge.reader.field_labeled_csv_reader import FieldLabeledCSVReader
+
+        config: Dict[str, Any] = {
+            "name": "Field Labeled CSV Reader",
+            "description": "Converts CSV rows to field-labeled text format for enhanced readability and context",
+        }
+        config.update(kwargs)
+        return FieldLabeledCSVReader(**config)
+
     @classmethod
     def _get_docx_reader(cls, **kwargs) -> Reader:
         """Get Docx reader instance."""

agno/memory/manager.py

@@ -236,8 +236,11 @@ class MemoryManager:
             memory_id (str): The id of the memory to delete
             user_id (Optional[str]): The user id to delete the memory from. If not provided, the memory is deleted from the "default" user.
         """
+        if user_id is None:
+            user_id = "default"
+
         if self.db:
-            self._delete_db_memory(memory_id=memory_id)
+            self._delete_db_memory(memory_id=memory_id, user_id=user_id)
         else:
             log_warning("Memory DB not provided.")
             return None
@@ -420,12 +423,16 @@ class MemoryManager:
             log_warning(f"Error storing memory in db: {e}")
             return f"Error adding memory: {e}"
 
-    def _delete_db_memory(self, memory_id: str) -> str:
+    def _delete_db_memory(self, memory_id: str, user_id: Optional[str] = None) -> str:
         """Use this function to delete a memory from the database."""
         try:
             if not self.db:
                 raise ValueError("Memory db not initialized")
-            self.db.delete_user_memory(memory_id=memory_id)
+
+            if user_id is None:
+                user_id = "default"
+
+            self.db.delete_user_memory(memory_id=memory_id, user_id=user_id)
             return "Memory deleted successfully"
         except Exception as e:
             log_warning(f"Error deleting memory in db: {e}")
@@ -1027,6 +1034,7 @@ class MemoryManager:
                         memory_id=memory_id,
                         memory=memory,
                         topics=topics,
+                        user_id=user_id,
                         input=input_string,
                     )
                 )
@@ -1044,7 +1052,7 @@ class MemoryManager:
                 str: A message indicating if the memory was deleted successfully or not.
             """
             try:
-                db.delete_user_memory(memory_id=memory_id)
+                db.delete_user_memory(memory_id=memory_id, user_id=user_id)
                 log_debug("Memory deleted")
                 return "Memory deleted successfully"
             except Exception as e:

agno/models/anthropic/claude.py

@@ -59,7 +59,7 @@ class Claude(Model):
     For more information, see: https://docs.anthropic.com/en/api/messages
     """
 
-    id: str = "claude-3-5-sonnet-20241022"
+    id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
 
@@ -78,6 +78,7 @@ class Claude(Model):
     # Client parameters
     api_key: Optional[str] = None
     default_headers: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # Anthropic clients
@@ -93,6 +94,8 @@ class Claude(Model):
 
         # Add API key to client parameters
         client_params["api_key"] = self.api_key
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
 
         # Add additional client parameters
         if self.client_params is not None: