agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/vectordb/singlestore/s2vectordb2.py

@@ -1,355 +0,0 @@
-import json
-from hashlib import md5
-from typing import Any, Dict, List, Optional
-
-try:
-    from sqlalchemy.dialects import mysql
-    from sqlalchemy.engine import Engine, create_engine
-    from sqlalchemy.inspection import inspect
-    from sqlalchemy.orm import Session, sessionmaker
-    from sqlalchemy.schema import Column, MetaData, Table
-    from sqlalchemy.sql.expression import func, select, text
-    from sqlalchemy.types import DateTime
-except ImportError:
-    raise ImportError("`sqlalchemy` not installed")
-
-
-from agno.document import Document
-from agno.embedder import Embedder
-from agno.embedder.openai import OpenAIEmbedder
-from agno.reranker.base import Reranker
-from agno.utils.log import logger
-from agno.vectordb.base import VectorDb
-from agno.vectordb.distance import Distance
-
-
-class S2VectorDb(VectorDb):
-    def __init__(
-        self,
-        collection: str,
-        schema: Optional[str] = "ai",
-        db_url: Optional[str] = None,
-        db_engine: Optional[Engine] = None,
-        embedder: Embedder = OpenAIEmbedder(),
-        distance: Distance = Distance.cosine,
-        reranker: Optional[Reranker] = None,
-    ):
-        _engine: Optional[Engine] = db_engine
-        if _engine is None and db_url is not None:
-            _engine = create_engine(db_url)
-
-        if _engine is None:
-            raise ValueError("Must provide either db_url or db_engine")
-
-        self.collection: str = collection
-        self.schema: Optional[str] = schema
-        self.db_url: Optional[str] = db_url
-        self.db_engine: Engine = _engine
-        self.metadata: MetaData = MetaData(schema=self.schema)
-        self.embedder: Embedder = embedder
-        self.dimensions: Optional[int] = self.embedder.dimensions
-        self.distance: Distance = distance
-        self.Session: sessionmaker[Session] = sessionmaker(bind=self.db_engine)
-        self.table: Table = self.get_table()
-        self.reranker: Optional[Reranker] = reranker
-
-    def get_table(self) -> Table:
-        """
-        Define the table structure.
-
-        Returns:
-            Table: SQLAlchemy Table object.
-        """
-        return Table(
-            self.collection,
-            self.metadata,
-            Column("id", mysql.TEXT),
-            Column("name", mysql.TEXT),
-            Column("meta_data", mysql.TEXT),
-            Column("content", mysql.TEXT),
-            Column("embedding", mysql.BLOB),  # Use BLOB for storing vector embeddings
-            Column("usage", mysql.TEXT),
-            Column("created_at", DateTime(timezone=True), server_default=text("now()")),
-            Column("updated_at", DateTime(timezone=True), onupdate=text("now()")),
-            Column("content_hash", mysql.TEXT),
-            extend_existing=True,
-        )
-
-    def table_exists(self) -> bool:
-        """
-        Check if the table exists.
-
-        Returns:
-            bool: True if the table exists, False otherwise.
-        """
-        logger.debug(f"Checking if table exists: {self.table.name}")
-        try:
-            return inspect(self.db_engine).has_table(self.table.name, schema=self.schema)
-        except Exception as e:
-            logger.error(e)
-            return False
-
-    def create(self) -> None:
-        """
-        Create the table if it does not exist.
-        """
-        if not self.table_exists():
-            # with self.Session() as sess:
-            #     with sess.begin():
-            #         if self.schema is not None:
-            #             logger.debug(f"Creating schema: {self.schema}")
-            #             sess.execute(text(f"CREATE DATABASE IF NOT EXISTS {self.schema};"))
-            logger.info(f"Creating table: {self.collection}")
-            self.table.create(self.db_engine)
-
-    def doc_exists(self, document: Document) -> bool:
-        """
-        Validating if the document exists or not
-
-        Args:
-            document (Document): Document to validate
-        """
-        columns = [self.table.c.name, self.table.c.content_hash]
-        with self.Session.begin() as sess:
-            cleaned_content = document.content.replace("\x00", "\ufffd")
-            stmt = select(*columns).where(self.table.c.content_hash == md5(cleaned_content.encode()).hexdigest())
-            result = sess.execute(stmt).first()
-            return result is not None
-
-    def name_exists(self, name: str) -> bool:
-        """
-        Validate if a row with this name exists or not
-
-        Args:
-            name (str): Name to check
-        """
-        with self.Session.begin() as sess:
-            stmt = select(self.table.c.name).where(self.table.c.name == name)
-            result = sess.execute(stmt).first()
-            return result is not None
-
-    def id_exists(self, id: str) -> bool:
-        """
-        Validate if a row with this id exists or not
-
-        Args:
-            id (str): Id to check
-        """
-        with self.Session.begin() as sess:
-            stmt = select(self.table.c.id).where(self.table.c.id == id)
-            result = sess.execute(stmt).first()
-            return result is not None
-
-    def insert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None, batch_size: int = 10) -> None:
-        """
-        Insert documents into the table.
-
-        Args:
-            documents (List[Document]): List of documents to insert.
-            filters (Optional[Dict[str, Any]]): Optional filters for the insert.
-            batch_size (int): Number of documents to insert in each batch.
-        """
-        with self.Session.begin() as sess:
-            counter = 0
-            for document in documents:
-                document.embed(embedder=self.embedder)
-                cleaned_content = document.content.replace("\x00", "\ufffd")
-                content_hash = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or content_hash
-
-                meta_data_json = json.dumps(document.meta_data)
-                usage_json = json.dumps(document.usage)
-                embedding_json = json.dumps(document.embedding)
-                json_array_pack = text("JSON_ARRAY_PACK(:embedding)").bindparams(embedding=embedding_json)
-
-                stmt = mysql.insert(self.table).values(
-                    id=_id,
-                    name=document.name,
-                    meta_data=meta_data_json,
-                    content=cleaned_content,
-                    embedding=json_array_pack,
-                    usage=usage_json,
-                    content_hash=content_hash,
-                )
-                sess.execute(stmt)
-                counter += 1
-                logger.debug(f"Inserted document: {document.name} ({document.meta_data})")
-
-            # Commit all documents
-            sess.commit()
-            logger.debug(f"Committed {counter} documents")
-
-    def upsert_available(self) -> bool:
-        return False
-
-    def upsert(self, documents: List[Document], filters: Optional[Dict[str, Any]] = None, batch_size: int = 20) -> None:
-        """
-        Upsert documents into the database.
-
-        Args:
-            documents (List[Document]): List of documents to upsert
-            filters (Optional[Dict[str, Any]]): Optional filters for upserting documents
-            batch_size (int): Batch size for upserting documents
-        """
-        with self.Session.begin() as sess:
-            counter = 0
-            for document in documents:
-                document.embed(embedder=self.embedder)
-                cleaned_content = document.content.replace("\x00", "\ufffd")
-                content_hash = md5(cleaned_content.encode()).hexdigest()
-                _id = document.id or content_hash
-
-                meta_data_json = json.dumps(document.meta_data)
-                usage_json = json.dumps(document.usage)
-                embedding_json = json.dumps(document.embedding)
-                json_array_pack = text("JSON_ARRAY_PACK(:embedding)").bindparams(embedding=embedding_json)
-
-                stmt = mysql.insert(self.table).values(
-                    id=_id,
-                    name=document.name,
-                    meta_data=meta_data_json,
-                    content=cleaned_content,
-                    embedding=json_array_pack,
-                    usage=usage_json,
-                    content_hash=content_hash,
-                )
-                sess.execute(stmt)
-                counter += 1
-                logger.debug(f"Inserted document: {document.id} | {document.name} | {document.meta_data}")
-
-            # Commit all remaining documents
-            sess.commit()
-            logger.debug(f"Committed {counter} documents")
-
-    def search(self, query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
-        """
-        Search for documents based on a query and optional filters.
-
-        Args:
-            query (str): The search query.
-            limit (int): The maximum number of results to return.
-            filters (Optional[Dict[str, Any]]): Optional filters for the search.
-
-        Returns:
-            List[Document]: List of documents that match the query.
-        """
-        query_embedding = self.embedder.get_embedding(query)
-        if query_embedding is None:
-            logger.error(f"Error getting embedding for Query: {query}")
-            return []
-
-        columns = [
-            self.table.c.name,
-            self.table.c.meta_data,
-            self.table.c.content,
-            func.json_array_unpack(self.table.c.embedding).label(
-                "embedding"
-            ),  # Unpack embedding here # self.table.c.embedding,
-            self.table.c.usage,
-        ]
-
-        stmt = select(*columns)
-
-        if filters is not None:
-            for key, value in filters.items():
-                if hasattr(self.table.c, key):
-                    stmt = stmt.where(getattr(self.table.c, key) == value)
-
-        if self.distance == Distance.l2:
-            stmt = stmt.order_by(self.table.c.embedding.max_inner_product(query_embedding))
-        if self.distance == Distance.cosine:
-            embedding_json = json.dumps(query_embedding)
-            dot_product_expr = func.dot_product(self.table.c.embedding, text("JSON_ARRAY_PACK(:embedding)"))
-            stmt = stmt.order_by(dot_product_expr.desc())
-            stmt = stmt.params(embedding=embedding_json)
-            # stmt = stmt.order_by(self.table.c.embedding.cosine_distance(query_embedding))
-        if self.distance == Distance.max_inner_product:
-            stmt = stmt.order_by(self.table.c.embedding.max_inner_product(query_embedding))
-
-        stmt = stmt.limit(limit=limit)
-        logger.debug(f"Query: {stmt}")
-
-        # Get neighbors
-        # This will only work if embedding column is created with `vector` data type.
-        with self.Session.begin() as sess:
-            neighbors = sess.execute(stmt).fetchall() or []
-            #         if self.index is not None:
-            #             if isinstance(self.index, Ivfflat):
-            #                 # Assuming 'nprobe' is a relevant parameter to be set for the session
-            #                 # Update the session settings based on the Ivfflat index configuration
-            #                 sess.execute(text(f"SET SESSION nprobe = {self.index.nprobe}"))
-            #             elif isinstance(self.index, HNSWFlat):
-            #                 # Assuming 'ef_search' is a relevant parameter to be set for the session
-            #                 # Update the session settings based on the HNSW index configuration
-            #                 sess.execute(text(f"SET SESSION ef_search = {self.index.ef_search}"))
-
-        # Build search results
-        search_results: List[Document] = []
-        for neighbor in neighbors:
-            meta_data_dict = json.loads(neighbor.meta_data) if neighbor.meta_data else {}
-            usage_dict = json.loads(neighbor.usage) if neighbor.usage else {}
-            # Convert the embedding mysql.TEXT back into a list
-            embedding_list = json.loads(neighbor.embedding) if neighbor.embedding else []
-
-            search_results.append(
-                Document(
-                    name=neighbor.name,
-                    meta_data=meta_data_dict,
-                    content=neighbor.content,
-                    embedder=self.embedder,
-                    embedding=embedding_list,
-                    usage=usage_dict,
-                )
-            )
-
-        if self.reranker:
-            search_results = self.reranker.rerank(query=query, documents=search_results)
-
-        return search_results
-
-    def drop(self) -> None:
-        """
-        Delete the table.
-        """
-        if self.table_exists():
-            logger.debug(f"Deleting table: {self.collection}")
-            self.table.drop(self.db_engine)
-
-    def exists(self) -> bool:
-        """
-        Check if the table exists.
-
-        Returns:
-            bool: True if the table exists, False otherwise.
-        """
-        return self.table_exists()
-
-    def get_count(self) -> int:
-        """
-        Get the count of rows in the table.
-
-        Returns:
-            int: The count of rows.
-        """
-        with self.Session.begin() as sess:
-            stmt = select(func.count(self.table.c.name)).select_from(self.table)
-            result = sess.execute(stmt).scalar()
-            if result is not None:
-                return int(result)
-            return 0
-
-    def optimize(self) -> None:
-        pass
-
-    def delete(self) -> bool:
-        """
-        Clear all rows from the table.
-
-        Returns:
-            bool: True if the table was cleared, False otherwise.
-        """
-        logger.info(f"Deleting table: {self.collection}")
-        with self.Session.begin() as sess:
-            stmt = self.table.delete()
-            sess.execute(stmt)
-            return True

agno/workspace/config.py

@@ -1,325 +0,0 @@
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from agno.api.schemas.team import TeamSchema
-from agno.api.schemas.workspace import WorkspaceSchema
-from agno.infra.base import InfraBase
-from agno.infra.resources import InfraResources
-from agno.utils.log import logger
-from agno.workspace.settings import WorkspaceSettings
-
-# List of directories to ignore when loading the workspace
-ignored_dirs = ["ignore", "test", "tests", "config"]
-
-
-class WorkspaceConfig(BaseModel):
-    """The WorkspaceConfig holds the configuration for an Agno workspace."""
-
-    # Root directory of the workspace.
-    ws_root_path: Path
-    # WorkspaceSchema: This field indicates that the workspace is synced with the api
-    ws_schema: Optional[WorkspaceSchema] = None
-    # The Team for this workspace
-    ws_team: Optional[TeamSchema] = None
-    # The API key for this workspace
-    ws_api_key: Optional[str] = None
-
-    # Path to the "workspace" directory inside the workspace root
-    _workspace_dir_path: Optional[Path] = None
-    # WorkspaceSettings
-    _workspace_settings: Optional[WorkspaceSettings] = None
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def to_dict(self) -> dict:
-        return self.model_dump(include={"ws_root_path", "ws_schema", "ws_team", "ws_api_key"})
-
-    @property
-    def workspace_dir_path(self) -> Optional[Path]:
-        if self._workspace_dir_path is None:
-            if self.ws_root_path is not None:
-                from agno.workspace.helpers import get_workspace_dir_path
-
-                self._workspace_dir_path = get_workspace_dir_path(self.ws_root_path)
-        return self._workspace_dir_path
-
-    def validate_workspace_settings(self, obj: Any) -> bool:
-        if not isinstance(obj, WorkspaceSettings):
-            raise Exception("WorkspaceSettings must be of type WorkspaceSettings")
-
-        if self.ws_root_path is not None and obj.ws_root is not None:
-            if obj.ws_root != self.ws_root_path:
-                raise Exception(f"WorkspaceSettings.ws_root ({obj.ws_root}) must match {self.ws_root_path}")
-        return True
-
-    @property
-    def workspace_settings(self) -> Optional[WorkspaceSettings]:
-        if self._workspace_settings is not None:
-            return self._workspace_settings
-
-        ws_settings_file: Optional[Path] = None
-        if self.workspace_dir_path is not None:
-            _ws_settings_file = self.workspace_dir_path.joinpath("settings.py")
-            if _ws_settings_file.exists() and _ws_settings_file.is_file():
-                ws_settings_file = _ws_settings_file
-        if ws_settings_file is None:
-            logger.debug("workspace_settings file not found")
-            return None
-
-        logger.debug(f"Loading workspace_settings from {ws_settings_file}")
-        try:
-            from agno.utils.py_io import get_python_objects_from_module
-
-            python_objects = get_python_objects_from_module(ws_settings_file)
-            for obj_name, obj in python_objects.items():
-                if isinstance(obj, WorkspaceSettings):
-                    if self.validate_workspace_settings(obj):
-                        self._workspace_settings = obj
-                        if self.ws_schema is not None and self._workspace_settings is not None:
-                            self._workspace_settings.ws_schema = self.ws_schema
-                            logger.debug("Added WorkspaceSchema to WorkspaceSettings")
-        except Exception:
-            logger.warning(f"Error in {ws_settings_file}")
-            raise
-        return self._workspace_settings
-
-    def set_local_env(self) -> None:
-        from os import environ
-
-        from agno.constants import (
-            AWS_REGION_ENV_VAR,
-            WORKSPACE_DIR_ENV_VAR,
-            WORKSPACE_ID_ENV_VAR,
-            WORKSPACE_NAME_ENV_VAR,
-            WORKSPACE_ROOT_ENV_VAR,
-        )
-
-        if self.ws_root_path is not None:
-            environ[WORKSPACE_ROOT_ENV_VAR] = str(self.ws_root_path)
-
-            workspace_dir_path: Optional[Path] = self.workspace_dir_path
-            if workspace_dir_path is not None:
-                environ[WORKSPACE_DIR_ENV_VAR] = str(workspace_dir_path)
-
-            if self.workspace_settings is not None:
-                environ[WORKSPACE_NAME_ENV_VAR] = str(self.workspace_settings.ws_name)
-
-        if self.ws_schema is not None and self.ws_schema.id_workspace is not None:
-            environ[WORKSPACE_ID_ENV_VAR] = str(self.ws_schema.id_workspace)
-
-        if (
-            environ.get(AWS_REGION_ENV_VAR) is None
-            and self.workspace_settings is not None
-            and self.workspace_settings.aws_region is not None
-        ):
-            environ[AWS_REGION_ENV_VAR] = self.workspace_settings.aws_region
-
-    def get_resources(
-        self,
-        env: Optional[str] = None,
-        infra: Optional[str] = None,
-        order: str = "create",
-    ) -> List[InfraResources]:
-        if self.ws_root_path is None:
-            logger.warning("WorkspaceConfig.ws_root_path is None")
-            return []
-
-        from sys import path as sys_path
-
-        from agno.utils.load_env import load_env
-        from agno.utils.py_io import get_python_objects_from_module
-
-        logger.debug("**--> Loading WorkspaceConfig")
-        logger.debug(f"Loading .env from {self.ws_root_path}")
-        load_env(dotenv_dir=self.ws_root_path)
-
-        # NOTE: When loading a workspace, relative imports or package imports do not work.
-        # This is a known problem in python
-        #     eg: https://stackoverflow.com/questions/6323860/sibling-package-imports/50193944#50193944
-        # To make them work, we add workspace_root to sys.path so is treated as a module
-        logger.debug(f"Adding {self.ws_root_path} to path")
-        sys_path.insert(0, str(self.ws_root_path))
-
-        workspace_dir_path: Optional[Path] = self.workspace_dir_path
-        if workspace_dir_path is not None:
-            logger.debug(f"--^^-- Loading workspace from: {workspace_dir_path}")
-            # Create a dict of objects in the workspace directory
-            workspace_objects: Dict[str, InfraResources] = {}
-            resource_files = workspace_dir_path.rglob("*.py")
-            for resource_file in resource_files:
-                if resource_file.name == "__init__.py":
-                    continue
-
-                resource_file_parts = resource_file.parts
-                workspace_dir_path_parts = workspace_dir_path.parts
-                resource_file_parts_after_ws = resource_file_parts[len(workspace_dir_path_parts) :]
-                # Check if file in ignored directory
-                if any([ignored_dir in resource_file_parts_after_ws for ignored_dir in ignored_dirs]):
-                    logger.debug(f"Skipping file in ignored directory: {resource_file}")
-                    continue
-                logger.debug(f"Reading file: {resource_file}")
-                try:
-                    python_objects = get_python_objects_from_module(resource_file)
-                    # logger.debug(f"python_objects: {python_objects}")
-                    for obj_name, obj in python_objects.items():
-                        if isinstance(obj, WorkspaceSettings):
-                            logger.debug(f"Found: {obj.__class__.__module__}: {obj_name}")
-                            if self.validate_workspace_settings(obj):
-                                self._workspace_settings = obj
-                                if self.ws_schema is not None and self._workspace_settings is not None:
-                                    self._workspace_settings.ws_schema = self.ws_schema
-                                    logger.debug("Added WorkspaceSchema to WorkspaceSettings")
-                        elif isinstance(obj, InfraResources):
-                            logger.debug(f"Found: {obj.__class__.__module__}: {obj_name}")
-                            if not obj.enabled:
-                                logger.debug(f"Skipping {obj_name}: disabled")
-                                continue
-                            workspace_objects[obj_name] = obj
-                except Exception:
-                    logger.warning(f"Error in {resource_file}")
-                    raise
-            logger.debug(f"workspace_objects: {workspace_objects}")
-        logger.debug("**--> WorkspaceConfig loaded")
-        logger.debug(f"Removing {self.ws_root_path} from path")
-        sys_path.remove(str(self.ws_root_path))
-
-        # Filter resources by infra
-        filtered_ws_objects_by_infra_type: Dict[str, InfraResources] = {}
-        logger.debug(f"Filtering resources for env: {env} | infra: {infra} | order: {order}")
-        if infra is None:
-            filtered_ws_objects_by_infra_type = workspace_objects
-        else:
-            for resource_name, resource in workspace_objects.items():
-                if resource.infra == infra:
-                    filtered_ws_objects_by_infra_type[resource_name] = resource
-
-        # Filter resources by env
-        filtered_infra_objects_by_env: Dict[str, InfraResources] = {}
-        if env is None:
-            filtered_infra_objects_by_env = filtered_ws_objects_by_infra_type
-        else:
-            for resource_name, resource in filtered_ws_objects_by_infra_type.items():
-                if resource.env == env:
-                    filtered_infra_objects_by_env[resource_name] = resource
-
-        # Updated resources with the workspace settings
-        # Create a temporary workspace settings object if it does not exist
-        if self._workspace_settings is None:
-            self._workspace_settings = WorkspaceSettings(
-                ws_root=self.ws_root_path,
-                ws_name=self.ws_root_path.stem,
-            )
-            logger.debug(f"Created WorkspaceSettings: {self._workspace_settings}")
-        # Update the resources with the workspace settings
-        if self._workspace_settings is not None:
-            for resource_name, resource in filtered_infra_objects_by_env.items():
-                logger.debug(f"Setting workspace settings for {resource.__class__.__name__}")
-                resource.set_workspace_settings(self._workspace_settings)
-
-        # Create a list of InfraResources from the filtered resources
-        infra_resources_list: List[InfraResources] = []
-        for resource_name, resource in filtered_infra_objects_by_env.items():
-            # If the resource is an InfraResources object, add it to the list
-            if isinstance(resource, InfraResources):
-                infra_resources_list.append(resource)
-
-        return infra_resources_list
-
-    @staticmethod
-    def get_resources_from_file(
-        resource_file: Path,
-        env: Optional[str] = None,
-        infra: Optional[str] = None,
-        order: str = "create",
-    ) -> List[InfraResources]:
-        if not resource_file.exists():
-            raise FileNotFoundError(f"File {resource_file} does not exist")
-        if not resource_file.is_file():
-            raise ValueError(f"Path {resource_file} is not a file")
-        if not resource_file.suffix == ".py":
-            raise ValueError(f"File {resource_file} is not a python file")
-
-        from sys import path as sys_path
-
-        from agno.utils.load_env import load_env
-        from agno.utils.py_io import get_python_objects_from_module
-
-        resource_file_parent_dir = resource_file.parent.resolve()
-        logger.debug(f"Loading .env from {resource_file_parent_dir}")
-        load_env(dotenv_dir=resource_file_parent_dir)
-
-        temporary_ws_config = WorkspaceConfig(ws_root_path=resource_file_parent_dir)
-
-        # NOTE: When loading a directory, relative imports or package imports do not work.
-        # This is a known problem in python
-        #     eg: https://stackoverflow.com/questions/6323860/sibling-package-imports/50193944#50193944
-        # To make them work, we add the resource_file_parent_dir to sys.path so it can be treated as a module
-        logger.debug(f"Adding {resource_file_parent_dir} to path")
-        sys_path.insert(0, str(resource_file_parent_dir))
-
-        logger.debug(f"**--> Reading Infra resources from {resource_file}")
-
-        # Get all infra resources from the file
-        infra_objects: Dict[str, InfraBase] = {}
-        try:
-            # Get all python objects from the file
-            python_objects = get_python_objects_from_module(resource_file)
-            # Filter out the objects that are subclasses of InfraBase
-            for obj_name, obj in python_objects.items():
-                if isinstance(obj, InfraBase):
-                    logger.debug(f"Found: {obj.__class__.__module__}: {obj_name}")
-                    if not obj.enabled:
-                        logger.debug(f"Skipping {obj_name}: disabled")
-                        continue
-                    infra_objects[obj_name] = obj
-        except Exception:
-            logger.error(f"Error reading: {resource_file}")
-            raise
-
-        # Filter resources by infra
-        filtered_infra_objects_by_infra_type: Dict[str, InfraBase] = {}
-        logger.debug(f"Filtering resources for env: {env} | infra: {infra} | order: {order}")
-        if infra is None:
-            filtered_infra_objects_by_infra_type = infra_objects
-        else:
-            for resource_name, resource in infra_objects.items():
-                if resource.infra == infra:
-                    filtered_infra_objects_by_infra_type[resource_name] = resource
-
-        # Filter resources by env
-        filtered_infra_objects_by_env: Dict[str, InfraBase] = {}
-        if env is None:
-            filtered_infra_objects_by_env = filtered_infra_objects_by_infra_type
-        else:
-            for resource_name, resource in filtered_infra_objects_by_infra_type.items():
-                if resource.env == env:
-                    filtered_infra_objects_by_env[resource_name] = resource
-
-        # Updated resources with the workspace settings
-        # Create a temporary workspace settings object if it does not exist
-        if temporary_ws_config._workspace_settings is None:
-            temporary_ws_config._workspace_settings = WorkspaceSettings(
-                ws_root=temporary_ws_config.ws_root_path,
-                ws_name=temporary_ws_config.ws_root_path.stem,
-            )
-        # Update the resources with the workspace settings
-        if temporary_ws_config._workspace_settings is not None:
-            for resource_name, resource in filtered_infra_objects_by_env.items():
-                logger.debug(f"Setting workspace settings for {resource.__class__.__name__}")
-                resource.set_workspace_settings(temporary_ws_config._workspace_settings)
-
-        # Create a list of InfraResources from the filtered resources
-        infra_resources_list: List[InfraResources] = []
-        for resource_name, resource in filtered_infra_objects_by_env.items():
-            # If the resource is an InfraResources object, add it to the list
-            if isinstance(resource, InfraResources):
-                infra_resources_list.append(resource)
-            # Otherwise, get the InfraResources object from the resource
-            else:
-                _infra_resources = resource.get_infra_resources()
-                if _infra_resources is not None and isinstance(_infra_resources, InfraResources):
-                    infra_resources_list.append(_infra_resources)
-
-        return infra_resources_list

agno/workspace/enums.py

@@ -1,6 +0,0 @@
-from enum import Enum
-
-
-class WorkspaceStarterTemplate(str, Enum):
-    agent_app = "agent-app"
-    agent_api = "agent-api"