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

agno/knowledge/reader/utils/spreadsheet.py

@@ -0,0 +1,114 @@
+from datetime import date, datetime
+from pathlib import Path
+from typing import IO, Any, Iterable, List, Optional, Sequence, Tuple, Union
+from uuid import uuid4
+
+from agno.knowledge.document.base import Document
+from agno.utils.log import log_debug
+
+
+def stringify_cell_value(value: Any) -> str:
+    """Convert cell value to string, normalizing dates and line endings."""
+    if value is None:
+        return ""
+
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, date):
+        return value.isoformat()
+
+    if isinstance(value, float) and value.is_integer():
+        return str(int(value))
+
+    result = str(value)
+    # Normalize all line endings to space to preserve row integrity in CSV-like output
+    # Must handle CRLF first before individual CR/LF to avoid double-spacing
+    result = result.replace("\r\n", " ")  # Windows (CRLF)
+    result = result.replace("\r", " ")  # Old Mac (CR)
+    result = result.replace("\n", " ")  # Unix (LF)
+    return result
+
+
+def get_workbook_name(file: Union[Path, IO[Any]], name: Optional[str]) -> str:
+    """Extract workbook name from file path or name parameter."""
+    if name:
+        return Path(name).stem
+    if isinstance(file, Path):
+        return file.stem
+    # getattr returns None when attribute exists but is None, so check explicitly
+    file_name = getattr(file, "name", None)
+    if file_name:
+        return Path(file_name).stem
+    return "workbook"
+
+
+def infer_file_extension(file: Union[Path, IO[Any]], name: Optional[str]) -> str:
+    """Infer file extension from Path, IO object, or explicit name."""
+    if isinstance(file, Path):
+        return file.suffix.lower()
+
+    file_name = getattr(file, "name", None)
+    if isinstance(file_name, str) and file_name:
+        return Path(file_name).suffix.lower()
+
+    if name:
+        return Path(name).suffix.lower()
+
+    return ""
+
+
+def convert_xls_cell_value(cell_value: Any, cell_type: int, datemode: int) -> Any:
+    """Convert xlrd cell value to Python type (dates and booleans need conversion)."""
+    try:
+        import xlrd
+    except ImportError:
+        return cell_value
+
+    if cell_type == xlrd.XL_CELL_DATE:
+        try:
+            date_tuple = xlrd.xldate_as_tuple(cell_value, datemode)
+            return datetime(*date_tuple)
+        except Exception:
+            return cell_value
+    if cell_type == xlrd.XL_CELL_BOOLEAN:
+        return bool(cell_value)
+    return cell_value
+
+
+def row_to_csv_line(row_values: Sequence[Any]) -> str:
+    """Convert row values to CSV-like string, trimming trailing empty cells."""
+    values = [stringify_cell_value(v) for v in row_values]
+    while values and values[-1] == "":
+        values.pop()
+
+    return ", ".join(values)
+
+
+def excel_rows_to_documents(
+    *,
+    workbook_name: str,
+    sheets: Iterable[Tuple[str, int, Iterable[Sequence[Any]]]],
+) -> List[Document]:
+    """Convert Excel sheet rows to Documents (one per sheet)."""
+    documents = []
+    for sheet_name, sheet_index, rows in sheets:
+        lines = []
+        for row in rows:
+            line = row_to_csv_line(row)
+            if line:
+                lines.append(line)
+
+        if not lines:
+            log_debug(f"Sheet '{sheet_name}' is empty, skipping")
+            continue
+
+        documents.append(
+            Document(
+                name=workbook_name,
+                id=str(uuid4()),
+                meta_data={"sheet_name": sheet_name, "sheet_index": sheet_index},
+                content="\n".join(lines),
+            )
+        )
+
+    return documents

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
 
@@ -53,9 +53,10 @@ class WebSearchReader(Reader):
     chunking_strategy: Optional[ChunkingStrategy] = SemanticChunking()
 
     @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 Web Search readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
             ChunkingStrategyType.RECURSIVE_CHUNKER,
@@ -64,7 +65,7 @@ class WebSearchReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TOPIC]
 
     def _respect_rate_limits(self):
@@ -121,57 +122,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 []
@@ -310,21 +264,17 @@ class WebSearchReader(Reader):
 
         log_debug(f"Starting async web search reader for query: {query}")
 
-        # Perform web search (synchronous operation)
         search_results = self._perform_web_search(query)
         if not search_results:
             logger.warning(f"No search results found for query: {query}")
             return []
 
-        # Create tasks for fetching content from each URL
         async def fetch_url_async(result: Dict[str, str]) -> Optional[Document]:
             url = result.get("url", "")
 
-            # Skip if URL is invalid or already visited
             if not self._is_valid_url(url):
                 return None
 
-            # Mark URL as visited
             self._visited_urls.add(url)
 
             try:
@@ -339,32 +289,25 @@ class WebSearchReader(Reader):
                     else:
                         content = response.text
 
-                    document = self._create_document_from_url(url, content, result)
-                    return document
+                    return self._create_document_from_url(url, content, result)
 
             except Exception as e:
                 logger.warning(f"Error fetching {url}: {e}")
                 return None
 
-        # Create tasks for all URLs
-        tasks = [fetch_url_async(result) for result in search_results]
-
-        # Execute all tasks concurrently with delays
         documents = []
-        for i, task in enumerate(tasks):
-            if i > 0:  # Add delay between requests (except for the first one)
+        for i, result in enumerate(search_results):
+            if i > 0:
                 await asyncio.sleep(self.delay_between_requests)
 
-            doc = await task
+            doc = await fetch_url_async(result)
             if doc is not None:
-                # Apply chunking if enabled
                 if self.chunk:
                     chunked_docs = await self.chunk_documents_async([doc])
                     documents.extend(chunked_docs)
                 else:
                     documents.append(doc)
 
-                # Stop if we've reached max_results
                 if len(documents) >= self.max_results:
                     break
 

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
@@ -49,9 +49,10 @@ class WebsiteReader(Reader):
         self._urls_to_crawl = []
 
     @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 Website readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
             ChunkingStrategyType.RECURSIVE_CHUNKER,
@@ -60,7 +61,7 @@ class WebsiteReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.URL]
 
     def delay(self, min_seconds=1, max_seconds=3):
@@ -229,21 +230,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 +333,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 +399,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]:
@@ -427,7 +428,8 @@ class WebsiteReader(Reader):
                         meta_data={"url": str(crawled_url)},
                         content=crawled_content,
                     )
-                    return self.chunk_document(doc)
+                    chunks = self.chunk_document(doc)
+                    return chunks
                 else:
                     return [
                         Document(
@@ -443,6 +445,7 @@ class WebsiteReader(Reader):
                 process_document(crawled_url, crawled_content)
                 for crawled_url, crawled_content in crawler_result.items()
             ]
+
             results = await asyncio.gather(*tasks)
 
             # Flatten the results
@@ -451,5 +454,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

agno/knowledge/reader/wikipedia_reader.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import List, Optional
 
 from agno.knowledge.chunking.fixed import FixedSizeChunking
@@ -23,9 +24,10 @@ class WikipediaReader(Reader):
         self.auto_suggest = auto_suggest
 
     @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 Wikipedia readers."""
         return [
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.FIXED_SIZE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
@@ -34,7 +36,7 @@ class WikipediaReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.TOPIC]
 
     def read(self, topic: str) -> List[Document]:
@@ -45,7 +47,38 @@ class WikipediaReader(Reader):
 
         except wikipedia.exceptions.PageError:
             summary = None
-            log_info("PageError: Page not found.")
+            log_info("Wikipedia Error: Page not found.")
+
+        # Only create Document if we successfully got a summary
+        if summary:
+            return [
+                Document(
+                    name=topic,
+                    meta_data={"topic": topic},
+                    content=summary,
+                )
+            ]
+        return []
+
+    async def async_read(self, topic: str) -> List[Document]:
+        """
+        Asynchronously read content from Wikipedia.
+
+        Args:
+            topic: The Wikipedia topic to read
+
+        Returns:
+            A list of documents containing the Wikipedia summary
+        """
+        log_debug(f"Async reading Wikipedia topic: {topic}")
+        summary = None
+        try:
+            # Run the synchronous wikipedia API call in a thread pool
+            summary = await asyncio.to_thread(wikipedia.summary, topic, auto_suggest=self.auto_suggest)
+
+        except wikipedia.exceptions.PageError:
+            summary = None
+            log_info("Wikipedia Error: Page not found.")
 
         # Only create Document if we successfully got a summary
         if summary:

agno/knowledge/reader/youtube_reader.py

@@ -23,10 +23,11 @@ class YouTubeReader(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 YouTube readers."""
         return [
             ChunkingStrategyType.RECURSIVE_CHUNKER,
+            ChunkingStrategyType.CODE_CHUNKER,
             ChunkingStrategyType.AGENTIC_CHUNKER,
             ChunkingStrategyType.DOCUMENT_CHUNKER,
             ChunkingStrategyType.SEMANTIC_CHUNKER,
@@ -34,7 +35,7 @@ class YouTubeReader(Reader):
         ]
 
     @classmethod
-    def get_supported_content_types(self) -> List[ContentType]:
+    def get_supported_content_types(cls) -> List[ContentType]:
         return [ContentType.YOUTUBE]
 
     def read(self, url: str, name: Optional[str] = None) -> List[Document]:

agno/knowledge/remote_content/__init__.py

@@ -0,0 +1,33 @@
+from agno.knowledge.remote_content.config import (
+    AzureBlobConfig,
+    GcsConfig,
+    GitHubConfig,
+    RemoteContentConfig,
+    S3Config,
+    SharePointConfig,
+)
+from agno.knowledge.remote_content.remote_content import (
+    AzureBlobContent,
+    GCSContent,
+    GitHubContent,
+    RemoteContent,
+    S3Content,
+    SharePointContent,
+)
+
+__all__ = [
+    # Config classes
+    "RemoteContentConfig",
+    "S3Config",
+    "GcsConfig",
+    "SharePointConfig",
+    "GitHubConfig",
+    "AzureBlobConfig",
+    # Content classes
+    "RemoteContent",
+    "S3Content",
+    "GCSContent",
+    "SharePointContent",
+    "GitHubContent",
+    "AzureBlobContent",
+]