agno 1.8.1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

agno/knowledge/remote_content/remote_content.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from agno.cloud.aws.s3.bucket import S3Bucket
+from agno.cloud.aws.s3.object import S3Object
+
+
+@dataclass
+class S3Content:
+    def __init__(
+        self,
+        bucket_name: Optional[str] = None,
+        bucket: Optional[S3Bucket] = None,
+        key: Optional[str] = None,
+        object: Optional[S3Object] = None,
+        prefix: Optional[str] = None,
+    ):
+        self.bucket_name = bucket_name
+        self.bucket = bucket
+        self.key = key
+        self.object = object
+        self.prefix = prefix
+
+        if bucket_name is None and bucket is None:
+            raise ValueError("Either bucket_name or bucket must be provided")
+        if key is None and object is None:
+            raise ValueError("Either key or object must be provided")
+        if bucket_name is not None and bucket is not None:
+            raise ValueError("Either bucket_name or bucket must be provided, not both")
+        if key is not None and object is not None:
+            raise ValueError("Either key or object must be provided, not both")
+
+        if self.bucket_name is not None:
+            self.bucket = S3Bucket(name=self.bucket_name)
+
+    def get_config(self):
+        return {
+            "bucket_name": self.bucket_name,
+            "bucket": self.bucket,
+            "key": self.key,
+            "object": self.object,
+            "prefix": self.prefix,
+        }
+
+
+@dataclass
+class GCSContent:
+    def __init__(
+        self,
+        bucket=None,  # Type hint removed to avoid import issues
+        bucket_name: Optional[str] = None,
+        blob_name: Optional[str] = None,
+        prefix: Optional[str] = None,
+    ):
+        # Import Google Cloud Storage only when actually needed
+        try:
+            from google.cloud import storage  # type: ignore
+        except ImportError:
+            raise ImportError(
+                "The `google-cloud-storage` package is not installed. Please install it via `pip install google-cloud-storage`."
+            )
+
+        self.bucket = bucket
+        self.bucket_name = bucket_name
+        self.blob_name = blob_name
+        self.prefix = prefix
+
+        if self.bucket is None and self.bucket_name is None:
+            raise ValueError("No bucket or bucket_name provided")
+        if self.bucket is not None and self.bucket_name is not None:
+            raise ValueError("Provide either bucket or bucket_name")
+        if self.blob_name is None and self.prefix is None:
+            raise ValueError("Either blob_name or prefix must be provided")
+
+        if self.bucket is None:
+            client = storage.Client()
+            self.bucket = client.bucket(self.bucket_name)
+
+    def get_config(self):
+        return {
+            "bucket": self.bucket,
+            "bucket_name": self.bucket_name,
+            "blob_name": self.blob_name,
+            "prefix": self.prefix,
+        }
+
+
+RemoteContent = Union[S3Content, GCSContent]

agno/{reranker → knowledge/reranker}/base.py

@@ -2,7 +2,7 @@ from typing import List
 
 from pydantic import BaseModel, ConfigDict
 
-from agno.document import Document
+from agno.knowledge.document import Document
 
 
 class Reranker(BaseModel):

agno/{reranker → knowledge/reranker}/cohere.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List, Optional
 
-from agno.document import Document
-from agno.reranker.base import Reranker
+from agno.knowledge.document import Document
+from agno.knowledge.reranker.base import Reranker
 from agno.utils.log import logger
 
 try:

agno/{reranker → knowledge/reranker}/infinity.py

@@ -1,8 +1,8 @@
 from typing import Any, List, Optional
 from urllib.parse import urlparse
 
-from agno.document import Document
-from agno.reranker.base import Reranker
+from agno.knowledge.document import Document
+from agno.knowledge.reranker.base import Reranker
 from agno.utils.log import logger
 
 try:

agno/{reranker → knowledge/reranker}/sentence_transformer.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List, Optional
 
-from agno.document import Document
-from agno.reranker.base import Reranker
+from agno.knowledge.document import Document
+from agno.knowledge.reranker.base import Reranker
 from agno.utils.log import logger
 
 try:

agno/knowledge/types.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class ContentType(str, Enum):
+    """Enum for content types supported by knowledge readers."""
+
+    # Generic types
+    FILE = "file"
+    URL = "url"
+    TEXT = "text"
+    TOPIC = "topic"
+    YOUTUBE = "youtube"
+
+    # Document file extensions
+    PDF = ".pdf"
+    TXT = ".txt"
+    MARKDOWN = ".md"
+    DOCX = ".docx"
+    DOC = ".doc"
+    JSON = ".json"
+
+    # Spreadsheet file extensions
+    CSV = ".csv"
+    XLSX = ".xlsx"
+    XLS = ".xls"
+
+
+def get_content_type_enum(content_type_str: str) -> ContentType:
+    """Convert a content type string to ContentType enum."""
+    return ContentType(content_type_str)

agno/knowledge/utils.py

@@ -0,0 +1,169 @@
+from typing import Dict, List
+
+from agno.knowledge.reader.reader_factory import ReaderFactory
+from agno.knowledge.types import ContentType
+from agno.utils.log import log_debug
+
+
+def _get_chunker_class(strategy_type):
+    """Get the chunker class for a given strategy type without instantiation."""
+    from agno.knowledge.chunking.strategy import ChunkingStrategyType
+
+    # Map strategy types to their corresponding classes
+    strategy_class_mapping = {
+        ChunkingStrategyType.AGENTIC_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.agentic", "AgenticChunking"
+        ),
+        ChunkingStrategyType.DOCUMENT_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.document", "DocumentChunking"
+        ),
+        ChunkingStrategyType.RECURSIVE_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.recursive", "RecursiveChunking"
+        ),
+        ChunkingStrategyType.SEMANTIC_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.semantic", "SemanticChunking"
+        ),
+        ChunkingStrategyType.FIXED_SIZE_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.fixed", "FixedSizeChunking"
+        ),
+        ChunkingStrategyType.ROW_CHUNKING: lambda: _import_class("agno.knowledge.chunking.row", "RowChunking"),
+        ChunkingStrategyType.MARKDOWN_CHUNKING: lambda: _import_class(
+            "agno.knowledge.chunking.markdown", "MarkdownChunking"
+        ),
+    }
+
+    if strategy_type not in strategy_class_mapping:
+        raise ValueError(f"Unknown strategy type: {strategy_type}")
+
+    return strategy_class_mapping[strategy_type]()
+
+
+def _import_class(module_name: str, class_name: str):
+    """Dynamically import a class from a module."""
+    import importlib
+
+    module = importlib.import_module(module_name)
+    return getattr(module, class_name)
+
+
+def get_reader_info(reader_key: str) -> Dict:
+    """Get information about a reader without instantiating it."""
+    # Try to create the reader to get its info, but don't cache it
+    try:
+        reader_factory_method = ReaderFactory._get_reader_method(reader_key)
+
+        # Create an instance to get the class, then call class methods
+        reader_instance = reader_factory_method()
+        reader_class = reader_instance.__class__
+
+        supported_strategies = reader_class.get_supported_chunking_strategies()
+        supported_content_types = reader_class.get_supported_content_types()
+
+        return {
+            "id": reader_key,
+            "name": reader_key.replace("_", " ").title() + " Reader",
+            "description": f"Reads {reader_key} files",
+            "chunking_strategies": [
+                strategy.value for strategy in supported_strategies
+            ],  # Convert enums to string values
+            "content_types": [ct.value for ct in supported_content_types],  # Convert enums to string values
+        }
+    except ImportError as e:
+        # Skip readers with missing dependencies
+        raise ValueError(f"Reader '{reader_key}' has missing dependencies: {str(e)}")
+    except Exception as e:
+        raise ValueError(f"Unknown reader: {reader_key}. Error: {str(e)}")
+
+
+def get_all_readers_info() -> List[Dict]:
+    """Get information about all available readers."""
+    readers_info = []
+    keys = ReaderFactory.get_all_reader_keys()
+    for key in keys:
+        try:
+            reader_info = get_reader_info(key)
+            readers_info.append(reader_info)
+        except ValueError as e:
+            # Skip readers with missing dependencies or other issues
+            # Log the error but don't fail the entire request
+            log_debug(f"Skipping reader '{key}': {e}")
+            continue
+    return readers_info
+
+
+def get_content_types_to_readers_mapping() -> Dict[str, List[str]]:
+    """Get mapping of content types to list of reader IDs that support them.
+
+    Returns:
+        Dictionary mapping content type strings (ContentType enum values) to list of reader IDs.
+    """
+    content_type_mapping: Dict[str, List[str]] = {}
+    readers_info = get_all_readers_info()
+
+    for reader_info in readers_info:
+        reader_id = reader_info["id"]
+        content_types = reader_info.get("content_types", [])
+
+        for content_type in content_types:
+            if content_type not in content_type_mapping:
+                content_type_mapping[content_type] = []
+            content_type_mapping[content_type].append(reader_id)
+
+    return content_type_mapping
+
+
+def get_chunker_info(chunker_key: str) -> Dict:
+    """Get information about a chunker without instantiating it."""
+    try:
+        # Use chunking strategies directly
+        from agno.knowledge.chunking.strategy import ChunkingStrategyType
+
+        try:
+            # Use the chunker key directly as the strategy type value
+            strategy_type = ChunkingStrategyType.from_string(chunker_key)
+
+            # Get class directly without instantiation
+            chunker_class = _get_chunker_class(strategy_type)
+
+            # Extract class information
+            class_name = chunker_class.__name__
+            docstring = chunker_class.__doc__ or f"{class_name} chunking strategy"
+
+            return {
+                "key": chunker_key,
+                "class_name": class_name,
+                "name": class_name.replace("Chunking", "").replace("Strategy", ""),
+                "description": docstring.strip(),
+                "strategy_type": strategy_type.value,
+            }
+        except ValueError:
+            raise ValueError(f"Unknown chunker key: {chunker_key}")
+
+    except ImportError as e:
+        # Skip chunkers with missing dependencies
+        raise ValueError(f"Chunker '{chunker_key}' has missing dependencies: {str(e)}")
+    except Exception as e:
+        raise ValueError(f"Unknown chunker: {chunker_key}. Error: {str(e)}")
+
+
+def get_all_content_types() -> List[ContentType]:
+    """Get all available content types as ContentType enums."""
+    return list(ContentType)
+
+
+def get_all_chunkers_info() -> List[Dict]:
+    """Get information about all available chunkers."""
+    chunkers_info = []
+
+    from agno.knowledge.chunking.strategy import ChunkingStrategyType
+
+    keys = [strategy_type.value for strategy_type in ChunkingStrategyType]
+
+    for key in keys:
+        try:
+            chunker_info = get_chunker_info(key)
+            chunkers_info.append(chunker_info)
+        except ValueError as e:
+            log_debug(f"Skipping chunker '{key}': {e}")
+            continue
+    return chunkers_info

agno/memory/__init__.py

@@ -1,11 +1,3 @@
-from agno.memory.agent import AgentMemory
-from agno.memory.memory import Memory
-from agno.memory.row import MemoryRow
-from agno.memory.team import TeamMemory
+from agno.memory.manager import MemoryManager, UserMemory
 
-__all__ = [
-    "AgentMemory",
-    "Memory",
-    "MemoryRow",
-    "TeamMemory",
-]
+__all__ = ["MemoryManager", "UserMemory"]