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

agno/embedder/openai.py

@@ -1,78 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-
-from typing_extensions import Literal
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from openai import OpenAI as OpenAIClient
-    from openai.types.create_embedding_response import CreateEmbeddingResponse
-except ImportError:
-    raise ImportError("`openai` not installed")
-
-
-@dataclass
-class OpenAIEmbedder(Embedder):
-    id: str = "text-embedding-3-small"
-    dimensions: Optional[int] = None
-    encoding_format: Literal["float", "base64"] = "float"
-    user: Optional[str] = None
-    api_key: Optional[str] = None
-    organization: Optional[str] = None
-    base_url: Optional[str] = None
-    request_params: Optional[Dict[str, Any]] = None
-    client_params: Optional[Dict[str, Any]] = None
-    openai_client: Optional[OpenAIClient] = None
-
-    def __post_init__(self):
-        if self.dimensions is None:
-            self.dimensions = 3072 if self.id == "text-embedding-3-large" else 1536
-
-    @property
-    def client(self) -> OpenAIClient:
-        if self.openai_client:
-            return self.openai_client
-
-        _client_params: Dict[str, Any] = {
-            "api_key": self.api_key,
-            "organization": self.organization,
-            "base_url": self.base_url,
-        }
-        _client_params = {k: v for k, v in _client_params.items() if v is not None}
-        if self.client_params:
-            _client_params.update(self.client_params)
-        self.openai_client = OpenAIClient(**_client_params)
-        return self.openai_client
-
-    def response(self, text: str) -> CreateEmbeddingResponse:
-        _request_params: Dict[str, Any] = {
-            "input": text,
-            "model": self.id,
-            "encoding_format": self.encoding_format,
-        }
-        if self.user is not None:
-            _request_params["user"] = self.user
-        if self.id.startswith("text-embedding-3"):
-            _request_params["dimensions"] = self.dimensions
-        if self.request_params:
-            _request_params.update(self.request_params)
-        return self.client.embeddings.create(**_request_params)
-
-    def get_embedding(self, text: str) -> List[float]:
-        response: CreateEmbeddingResponse = self.response(text=text)
-        try:
-            return response.data[0].embedding
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        response: CreateEmbeddingResponse = self.response(text=text)
-
-        embedding = response.data[0].embedding
-        usage = response.usage
-        if usage:
-            return embedding, usage.model_dump()
-        return embedding, None

agno/file/__init__.py

@@ -1,5 +0,0 @@
-from agno.file.file import File
-
-__all__ = [
-    "File",
-]

agno/file/file.py

@@ -1,16 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, List, Optional
-
-from agno.utils.common import dataclass_to_dict
-
-
-@dataclass
-class File:
-    name: Optional[str] = None
-    description: Optional[str] = None
-    columns: Optional[List[str]] = None
-    path: Optional[str] = None
-    type: str = "FILE"
-
-    def get_metadata(self) -> dict[str, Any]:
-        return dataclass_to_dict(self, exclude_none=True)

agno/file/local/csv.py

@@ -1,32 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from agno.file import File
-from agno.utils.common import dataclass_to_dict
-from agno.utils.log import log_debug
-
-
-@dataclass
-class CsvFile(File):
-    path: str = ""  # type: ignore
-    type: str = "CSV"
-
-    def get_metadata(self) -> dict[str, Any]:
-        if self.name is None:
-            from pathlib import Path
-
-            self.name = Path(self.path).name
-
-        if self.columns is None:
-            try:
-                # Get the columns from the file
-                import csv
-
-                with open(self.path) as csvfile:
-                    dict_reader = csv.DictReader(csvfile)
-                    if dict_reader.fieldnames is not None:
-                        self.columns = list(dict_reader.fieldnames)
-            except Exception as e:
-                log_debug(f"Error getting columns from file: {e}")
-
-        return dataclass_to_dict(self, exclude_none=True)

agno/file/local/txt.py

@@ -1,19 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from agno.file import File
-from agno.utils.common import dataclass_to_dict
-
-
-@dataclass
-class TextFile(File):
-    path: str = ""  # type: ignore
-    type: str = "TEXT"
-
-    def get_metadata(self) -> dict[str, Any]:
-        if self.name is None:
-            from pathlib import Path
-
-            self.name = Path(self.path).name
-
-        return dataclass_to_dict(self, exclude_none=True)

agno/infra/app.py

@@ -1,240 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-
-from pydantic import Field, field_validator
-from pydantic_core.core_schema import ValidationInfo
-
-from agno.infra.base import InfraBase
-from agno.infra.context import ContainerContext
-from agno.infra.resource import InfraResource
-from agno.utils.log import logger
-
-
-class InfraApp(InfraBase):
-    """Base class for Infrastructure Apps."""
-
-    # -*- App Name (required)
-    name: str
-
-    # -*- Image Configuration
-    # Image can be provided as a DockerImage object
-    image: Optional[Any] = None
-    # OR as image_name:image_tag str
-    image_str: Optional[str] = None
-    # OR as image_name and image_tag
-    image_name: Optional[str] = None
-    image_tag: Optional[str] = None
-    # Entrypoint for the container
-    entrypoint: Optional[Union[str, List[str]]] = None
-    # Command for the container
-    command: Optional[Union[str, List[str]]] = None
-
-    # -*- Python Configuration
-    # Install python dependencies using a requirements.txt file
-    install_requirements: bool = False
-    # Path to the requirements.txt file relative to the workspace_root
-    requirements_file: str = "requirements.txt"
-    # Set the PYTHONPATH env var
-    set_python_path: bool = True
-    # Manually provide the PYTHONPATH.
-    # If None, PYTHONPATH is set to workspace_root
-    python_path: Optional[str] = None
-    # Add paths to the PYTHONPATH env var
-    # If python_path is provided, this value is ignored
-    add_python_paths: Optional[List[str]] = None
-
-    # -*- App Ports
-    # Open a container port if open_port=True
-    open_port: bool = False
-    # If open_port=True, port_number is used to set the
-    # container_port if container_port is None and host_port if host_port is None
-    port_number: int = 80
-    # Port number on the Container to open
-    # Preferred over port_number if both are set
-    container_port: Optional[int] = Field(None, validate_default=True)
-    # Port name for the opened port
-    container_port_name: str = "http"
-    # Port number on the Host to map to the Container port
-    # Preferred over port_number if both are set
-    host_port: Optional[int] = Field(None, validate_default=True)
-
-    # -*- Extra Resources created "before" the App resources
-    resources: Optional[List[InfraResource]] = None
-
-    #  -*- Other args
-    print_env_on_load: bool = False
-
-    # -*- App specific args. Not to be set by the user.
-    # Container Environment that can be set by subclasses
-    # which is used as a starting point for building the container_env
-    # Any variables set in container_env will be overridden by values
-    # in the env_vars dict or env_file
-    container_env: Optional[Dict[str, Any]] = None
-    # Variable used to cache the container context
-    container_context: Optional[ContainerContext] = None
-
-    # -*- Cached Data
-    cached_resources: Optional[List[Any]] = None
-
-    @field_validator("container_port", mode="before")
-    def set_container_port(cls, v, info: ValidationInfo):
-        port_number = info.data.get("port_number")
-        if v is None and port_number is not None:
-            v = port_number
-        return v
-
-    @field_validator("host_port", mode="before")
-    def set_host_port(cls, v, info: ValidationInfo):
-        port_number = info.data.get("port_number")
-        if v is None and port_number is not None:
-            v = port_number
-        return v
-
-    def get_app_name(self) -> str:
-        return self.name
-
-    def get_image_str(self) -> str:
-        if self.image:
-            return f"{self.image.name}:{self.image.tag}"
-        elif self.image_str:
-            return self.image_str
-        elif self.image_name and self.image_tag:
-            return f"{self.image_name}:{self.image_tag}"
-        elif self.image_name:
-            return f"{self.image_name}:latest"
-        else:
-            return ""
-
-    def build_resources(self, build_context: Any) -> Optional[Any]:
-        logger.debug(f"@build_resource_group not defined for {self.get_app_name()}")
-        return None
-
-    def get_dependencies(self) -> Optional[List[InfraResource]]:
-        return (
-            [dep for dep in self.depends_on if isinstance(dep, InfraResource)] if self.depends_on is not None else None
-        )
-
-    def add_app_properties_to_resources(self, resources: List[InfraResource]) -> List[InfraResource]:
-        updated_resources = []
-        app_properties = self.model_dump(exclude_defaults=True)
-        app_group = self.get_group_name()
-        app_output_dir = self.get_app_name()
-
-        app_skip_create = app_properties.get("skip_create")
-        app_skip_read = app_properties.get("skip_read")
-        app_skip_update = app_properties.get("skip_update")
-        app_skip_delete = app_properties.get("skip_delete")
-        app_recreate_on_update = app_properties.get("recreate_on_update")
-        app_use_cache = app_properties.get("use_cache")
-        app_force = app_properties.get("force")
-        app_debug_mode = app_properties.get("debug_mode")
-        app_wait_for_create = app_properties.get("wait_for_create")
-        app_wait_for_update = app_properties.get("wait_for_update")
-        app_wait_for_delete = app_properties.get("wait_for_delete")
-        app_save_output = app_properties.get("save_output")
-
-        for resource in resources:
-            resource_properties = resource.model_dump(exclude_defaults=True)
-            resource_skip_create = resource_properties.get("skip_create")
-            resource_skip_read = resource_properties.get("skip_read")
-            resource_skip_update = resource_properties.get("skip_update")
-            resource_skip_delete = resource_properties.get("skip_delete")
-            resource_recreate_on_update = resource_properties.get("recreate_on_update")
-            resource_use_cache = resource_properties.get("use_cache")
-            resource_force = resource_properties.get("force")
-            resource_debug_mode = resource_properties.get("debug_mode")
-            resource_wait_for_create = resource_properties.get("wait_for_create")
-            resource_wait_for_update = resource_properties.get("wait_for_update")
-            resource_wait_for_delete = resource_properties.get("wait_for_delete")
-            resource_save_output = resource_properties.get("save_output")
-
-            # If skip_create on resource is not set, use app level skip_create (if set on app)
-            if resource_skip_create is None and app_skip_create is not None:
-                resource.skip_create = app_skip_create
-            # If skip_read on resource is not set, use app level skip_read (if set on app)
-            if resource_skip_read is None and app_skip_read is not None:
-                resource.skip_read = app_skip_read
-            # If skip_update on resource is not set, use app level skip_update (if set on app)
-            if resource_skip_update is None and app_skip_update is not None:
-                resource.skip_update = app_skip_update
-            # If skip_delete on resource is not set, use app level skip_delete (if set on app)
-            if resource_skip_delete is None and app_skip_delete is not None:
-                resource.skip_delete = app_skip_delete
-            # If recreate_on_update on resource is not set, use app level recreate_on_update (if set on app)
-            if resource_recreate_on_update is None and app_recreate_on_update is not None:
-                resource.recreate_on_update = app_recreate_on_update
-            # If use_cache on resource is not set, use app level use_cache (if set on app)
-            if resource_use_cache is None and app_use_cache is not None:
-                resource.use_cache = app_use_cache
-            # If force on resource is not set, use app level force (if set on app)
-            if resource_force is None and app_force is not None:
-                resource.force = app_force
-            # If debug_mode on resource is not set, use app level debug_mode (if set on app)
-            if resource_debug_mode is None and app_debug_mode is not None:
-                resource.debug_mode = app_debug_mode
-            # If wait_for_create on resource is not set, use app level wait_for_create (if set on app)
-            if resource_wait_for_create is None and app_wait_for_create is not None:
-                resource.wait_for_create = app_wait_for_create
-            # If wait_for_update on resource is not set, use app level wait_for_update (if set on app)
-            if resource_wait_for_update is None and app_wait_for_update is not None:
-                resource.wait_for_update = app_wait_for_update
-            # If wait_for_delete on resource is not set, use app level wait_for_delete (if set on app)
-            if resource_wait_for_delete is None and app_wait_for_delete is not None:
-                resource.wait_for_delete = app_wait_for_delete
-            # If save_output on resource is not set, use app level save_output (if set on app)
-            if resource_save_output is None and app_save_output is not None:
-                resource.save_output = app_save_output
-            # If workspace_settings on resource is not set, use app level workspace_settings (if set on app)
-            if resource.workspace_settings is None and self.workspace_settings is not None:
-                resource.set_workspace_settings(self.workspace_settings)
-            # If group on resource is not set, use app level group (if set on app)
-            if resource.group is None and app_group is not None:
-                resource.group = app_group
-
-            # Always set output_dir on resource to app level output_dir
-            resource.output_dir = app_output_dir
-
-            app_dependencies = self.get_dependencies()
-            if app_dependencies is not None:
-                if resource.depends_on is None:
-                    resource.depends_on = app_dependencies
-                else:
-                    resource.depends_on.extend(app_dependencies)
-
-            updated_resources.append(resource)
-        return updated_resources
-
-    def get_resources(self, build_context: Any) -> List[InfraResource]:
-        if self.cached_resources is not None and len(self.cached_resources) > 0:
-            return self.cached_resources
-
-        base_resources = self.resources or []
-        app_resources = self.build_resources(build_context)
-        if app_resources is not None:
-            base_resources.extend(app_resources)
-
-        self.cached_resources = self.add_app_properties_to_resources(base_resources)
-        # logger.debug(f"Resources: {self.cached_resources}")
-        return self.cached_resources
-
-    def matches_filters(self, group_filter: Optional[str] = None) -> bool:
-        if group_filter is not None:
-            group_name = self.get_group_name()
-            logger.debug(f"{self.get_app_name()}: Checking {group_filter} in {group_name}")
-            if group_name is None or group_filter not in group_name:
-                return False
-        return True
-
-    def should_create(self, group_filter: Optional[str] = None) -> bool:
-        if not self.enabled or self.skip_create:
-            return False
-        return self.matches_filters(group_filter)
-
-    def should_delete(self, group_filter: Optional[str] = None) -> bool:
-        if not self.enabled or self.skip_delete:
-            return False
-        return self.matches_filters(group_filter)
-
-    def should_update(self, group_filter: Optional[str] = None) -> bool:
-        if not self.enabled or self.skip_update:
-            return False
-        return self.matches_filters(group_filter)

agno/infra/base.py

@@ -1,144 +0,0 @@
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from agno.workspace.settings import WorkspaceSettings
-
-
-class InfraBase(BaseModel):
-    """Base class for all InfraResource, InfraApp and InfraResources objects."""
-
-    # Name of the infrastructure resource
-    name: Optional[str] = None
-    # Group for the infrastructure resource
-    # Used for filtering infrastructure resources by group
-    group: Optional[str] = None
-    # Environment filter for this resource
-    env: Optional[str] = None
-    # Infrastructure filter for this resource
-    infra: Optional[str] = None
-    # Whether this resource is enabled
-    enabled: bool = True
-
-    # Resource Control
-    skip_create: bool = False
-    skip_read: bool = False
-    skip_update: bool = False
-    skip_delete: bool = False
-    recreate_on_update: bool = False
-    # Skip create if resource with the same name is active
-    use_cache: bool = True
-    # Force create/update/delete even if a resource with the same name is active
-    force: Optional[bool] = None
-
-    # Wait for resource to be created, updated or deleted
-    wait_for_create: bool = True
-    wait_for_update: bool = True
-    wait_for_delete: bool = True
-    waiter_delay: int = 30
-    waiter_max_attempts: int = 50
-
-    # Environment Variables for the resource (if applicable)
-    # Add env variables to resource where applicable
-    env_vars: Optional[Dict[str, Any]] = None
-    # Read env from a file in yaml format
-    env_file: Optional[Path] = None
-    # Add secret variables to resource where applicable
-    # secrets_dict: Optional[Dict[str, Any]] = None
-    # Read secrets from a file in yaml format
-    secrets_file: Optional[Path] = None
-    # Read secret variables from AWS Secrets
-    aws_secrets: Optional[Any] = None
-
-    # Debug Mode
-    debug_mode: bool = False
-
-    # Store resource to output directory
-    # If True, save resource output to json files
-    save_output: bool = False
-    # The directory for the input files in the workspace directory
-    input_dir: Optional[str] = None
-    # The directory for the output files in the workspace directory
-    output_dir: Optional[str] = None
-
-    # Dependencies for the resource
-    depends_on: Optional[List[Any]] = None
-
-    # Workspace Settings
-    workspace_settings: Optional[WorkspaceSettings] = None
-
-    # Cached Data
-    cached_workspace_dir: Optional[Path] = None
-    cached_env_file_data: Optional[Dict[str, Any]] = None
-    cached_secret_file_data: Optional[Dict[str, Any]] = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    def get_group_name(self) -> Optional[str]:
-        return self.group or self.name
-
-    @property
-    def workspace_root(self) -> Optional[Path]:
-        return self.workspace_settings.ws_root if self.workspace_settings is not None else None
-
-    @property
-    def workspace_name(self) -> Optional[str]:
-        return self.workspace_settings.ws_name if self.workspace_settings is not None else None
-
-    @property
-    def workspace_dir(self) -> Optional[Path]:
-        if self.cached_workspace_dir is not None:
-            return self.cached_workspace_dir
-
-        if self.workspace_root is not None:
-            from agno.workspace.helpers import get_workspace_dir_path
-
-            workspace_dir = get_workspace_dir_path(self.workspace_root)
-            if workspace_dir is not None:
-                self.cached_workspace_dir = workspace_dir
-                return workspace_dir
-        return None
-
-    def set_workspace_settings(self, workspace_settings: Optional[WorkspaceSettings] = None) -> None:
-        if workspace_settings is not None:
-            self.workspace_settings = workspace_settings
-
-    def get_env_file_data(self) -> Optional[Dict[str, Any]]:
-        if self.cached_env_file_data is None:
-            from agno.utils.yaml_io import read_yaml_file
-
-            self.cached_env_file_data = read_yaml_file(file_path=self.env_file)
-        return self.cached_env_file_data
-
-    def get_secret_file_data(self) -> Optional[Dict[str, Any]]:
-        if self.cached_secret_file_data is None:
-            from agno.utils.yaml_io import read_yaml_file
-
-            self.cached_secret_file_data = read_yaml_file(file_path=self.secrets_file)
-        return self.cached_secret_file_data
-
-    def get_secret_from_file(self, secret_name: str) -> Optional[str]:
-        secret_file_data = self.get_secret_file_data()
-        if secret_file_data is not None:
-            return secret_file_data.get(secret_name)
-        return None
-
-    def get_infra_resources(self) -> Optional[Any]:
-        """This method returns an InfraResources object for this resource"""
-        raise NotImplementedError("get_infra_resources method not implemented")
-
-    def set_aws_env_vars(self, env_dict: Dict[str, str], aws_region: Optional[str] = None) -> None:
-        from agno.constants import (
-            AWS_DEFAULT_REGION_ENV_VAR,
-            AWS_REGION_ENV_VAR,
-        )
-
-        if aws_region is not None:
-            # logger.debug(f"Setting AWS Region to {aws_region}")
-            env_dict[AWS_REGION_ENV_VAR] = aws_region
-            env_dict[AWS_DEFAULT_REGION_ENV_VAR] = aws_region
-        elif self.workspace_settings is not None and self.workspace_settings.aws_region is not None:
-            # logger.debug(f"Setting AWS Region to {aws_region} using workspace_settings")
-            env_dict[AWS_REGION_ENV_VAR] = self.workspace_settings.aws_region
-            env_dict[AWS_DEFAULT_REGION_ENV_VAR] = self.workspace_settings.aws_region

agno/infra/context.py

@@ -1,20 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-
-from agno.api.schemas.workspace import WorkspaceSchema
-
-
-class ContainerContext(BaseModel):
-    """ContainerContext is a context object passed when creating containers."""
-
-    # Workspace name
-    workspace_name: str
-    # Workspace schema from the API
-    workspace_schema: Optional[WorkspaceSchema] = None
-    # Path to the workspace directory inside the container
-    workspace_root: str
-    # Path to the workspace parent directory inside the container
-    workspace_parent: str
-    # Path to the requirements.txt file relative to the workspace_root
-    requirements_file: Optional[str] = None

agno/infra/db_app.py

@@ -1,52 +0,0 @@
-from typing import Optional
-
-from agno.infra.app import ContainerContext, InfraApp, InfraResource  # noqa: F401
-
-
-class DbApp(InfraApp):
-    db_user: Optional[str] = None
-    db_password: Optional[str] = None
-    db_database: Optional[str] = None
-    db_driver: Optional[str] = None
-
-    def get_db_user(self) -> Optional[str]:
-        return self.db_user or self.get_secret_from_file("DB_USER")
-
-    def get_db_password(self) -> Optional[str]:
-        return self.db_password or self.get_secret_from_file("DB_PASSWORD")
-
-    def get_db_database(self) -> Optional[str]:
-        return self.db_database or self.get_secret_from_file("DB_DATABASE")
-
-    def get_db_driver(self) -> Optional[str]:
-        return self.db_driver or self.get_secret_from_file("DB_DRIVER")
-
-    def get_db_host(self) -> Optional[str]:
-        raise NotImplementedError
-
-    def get_db_port(self) -> Optional[int]:
-        raise NotImplementedError
-
-    def get_db_connection(self) -> Optional[str]:
-        user = self.get_db_user()
-        password = self.get_db_password()
-        database = self.get_db_database()
-        driver = self.get_db_driver()
-        host = self.get_db_host()
-        port = self.get_db_port()
-        return f"{driver}://{user}:{password}@{host}:{port}/{database}"
-
-    def get_db_host_local(self) -> Optional[str]:
-        return "localhost"
-
-    def get_db_port_local(self) -> Optional[int]:
-        return self.host_port
-
-    def get_db_connection_local(self) -> Optional[str]:
-        user = self.get_db_user()
-        password = self.get_db_password()
-        database = self.get_db_database()
-        driver = self.get_db_driver()
-        host = self.get_db_host_local()
-        port = self.get_db_port_local()
-        return f"{driver}://{user}:{password}@{host}:{port}/{database}"