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

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}"

agno/infra/resource.py

@@ -1,205 +0,0 @@
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from agno.infra.base import InfraBase
-from agno.utils.log import logger
-
-
-class InfraResource(InfraBase):
-    """Base class for Infrastructure Resources."""
-
-    # Resource name (required)
-    name: str
-    # Resource type
-    resource_type: Optional[str] = None
-    # List of resource types to match for filtering
-    resource_type_list: Optional[List[str]] = None
-
-    # -*- Cached Data
-    active_resource: Optional[Any] = None
-    resource_created: bool = False
-    resource_updated: bool = False
-    resource_deleted: bool = False
-
-    def read(self, client: Any) -> bool:
-        raise NotImplementedError
-
-    def is_active(self, client: Any) -> bool:
-        raise NotImplementedError
-
-    def create(self, client: Any) -> bool:
-        raise NotImplementedError
-
-    def update(self, client: Any) -> bool:
-        raise NotImplementedError
-
-    def delete(self, client: Any) -> bool:
-        raise NotImplementedError
-
-    def get_resource_name(self) -> str:
-        return self.name or self.__class__.__name__
-
-    def get_resource_type(self) -> str:
-        if self.resource_type is None:
-            return self.__class__.__name__
-        return self.resource_type
-
-    def get_resource_type_list(self) -> List[str]:
-        if self.resource_type_list is None:
-            return [self.get_resource_type().lower()]
-
-        type_list: List[str] = [resource_type.lower() for resource_type in self.resource_type_list]
-        if self.get_resource_type() not in type_list:
-            type_list.append(self.get_resource_type().lower())
-        return type_list
-
-    def get_input_file_path(self) -> Optional[Path]:
-        workspace_dir: Optional[Path] = self.workspace_dir
-        if workspace_dir is None:
-            from agno.workspace.helpers import get_workspace_dir_from_env
-
-            workspace_dir = get_workspace_dir_from_env()
-        if workspace_dir is not None:
-            resource_name: str = self.get_resource_name()
-            if resource_name is not None:
-                input_file_name = f"{resource_name}.yaml"
-                input_dir_path = workspace_dir
-                if self.input_dir is not None:
-                    input_dir_path = input_dir_path.joinpath(self.input_dir)
-                else:
-                    input_dir_path = input_dir_path.joinpath("input")
-                    if self.env is not None:
-                        input_dir_path = input_dir_path.joinpath(self.env)
-                    if self.group is not None:
-                        input_dir_path = input_dir_path.joinpath(self.group)
-                    if self.get_resource_type() is not None:
-                        input_dir_path = input_dir_path.joinpath(self.get_resource_type().lower())
-                return input_dir_path.joinpath(input_file_name)
-        return None
-
-    def get_output_file_path(self) -> Optional[Path]:
-        workspace_dir: Optional[Path] = self.workspace_dir
-        if workspace_dir is None:
-            from agno.workspace.helpers import get_workspace_dir_from_env
-
-            workspace_dir = get_workspace_dir_from_env()
-        if workspace_dir is not None:
-            resource_name: str = self.get_resource_name()
-            if resource_name is not None:
-                output_file_name = f"{resource_name}.yaml"
-                output_dir_path = workspace_dir
-                output_dir_path = output_dir_path.joinpath("output")
-                if self.env is not None:
-                    output_dir_path = output_dir_path.joinpath(self.env)
-                if self.output_dir is not None:
-                    output_dir_path = output_dir_path.joinpath(self.output_dir)
-                elif self.get_resource_type() is not None:
-                    output_dir_path = output_dir_path.joinpath(self.get_resource_type().lower())
-                return output_dir_path.joinpath(output_file_name)
-        return None
-
-    def save_output_file(self) -> bool:
-        output_file_path: Optional[Path] = self.get_output_file_path()
-        if output_file_path is not None:
-            try:
-                from agno.utils.yaml_io import write_yaml_file
-
-                if not output_file_path.exists():
-                    output_file_path.parent.mkdir(parents=True, exist_ok=True)
-                    output_file_path.touch(exist_ok=True)
-                write_yaml_file(output_file_path, self.active_resource)
-                logger.info(f"Resource saved to: {str(output_file_path)}")
-                return True
-            except Exception as e:
-                logger.error(f"Could not write {self.get_resource_name()} to file: {e}")
-        return False
-
-    def read_resource_from_file(self) -> Optional[Dict[str, Any]]:
-        output_file_path: Optional[Path] = self.get_output_file_path()
-        if output_file_path is not None:
-            try:
-                from agno.utils.yaml_io import read_yaml_file
-
-                if output_file_path.exists() and output_file_path.is_file():
-                    data_from_file = read_yaml_file(output_file_path)
-                    if data_from_file is not None and isinstance(data_from_file, dict):
-                        return data_from_file
-                    else:
-                        logger.warning(f"Could not read {self.get_resource_name()} from {output_file_path}")
-            except Exception as e:
-                logger.error(f"Could not read {self.get_resource_name()} from file: {e}")
-        return None
-
-    def delete_output_file(self) -> bool:
-        output_file_path: Optional[Path] = self.get_output_file_path()
-        if output_file_path is not None:
-            try:
-                if output_file_path.exists() and output_file_path.is_file():
-                    output_file_path.unlink()
-                    logger.debug(f"Output file deleted: {str(output_file_path)}")
-                    return True
-            except Exception as e:
-                logger.error(f"Could not delete output file: {e}")
-        return False
-
-    def matches_filters(
-        self,
-        group_filter: Optional[str] = None,
-        name_filter: Optional[str] = None,
-        type_filter: Optional[str] = None,
-    ) -> bool:
-        if group_filter is not None:
-            group_name = self.get_group_name()
-            logger.debug(f"{self.get_resource_name()}: Checking {group_filter} in {group_name}")
-            if group_name is None or group_filter not in group_name:
-                return False
-        if name_filter is not None:
-            resource_name = self.get_resource_name()
-            logger.debug(f"{self.get_resource_name()}: Checking {name_filter} in {resource_name}")
-            if resource_name is None or name_filter not in resource_name:
-                return False
-        if type_filter is not None:
-            resource_type_list = self.get_resource_type_list()
-            logger.debug(f"{self.get_resource_name()}: Checking {type_filter.lower()} in {resource_type_list}")
-            if resource_type_list is None or type_filter.lower() not in resource_type_list:
-                return False
-        return True
-
-    def should_create(
-        self,
-        group_filter: Optional[str] = None,
-        name_filter: Optional[str] = None,
-        type_filter: Optional[str] = None,
-    ) -> bool:
-        if not self.enabled or self.skip_create:
-            return False
-        return self.matches_filters(group_filter, name_filter, type_filter)
-
-    def should_delete(
-        self,
-        group_filter: Optional[str] = None,
-        name_filter: Optional[str] = None,
-        type_filter: Optional[str] = None,
-    ) -> bool:
-        if not self.enabled or self.skip_delete:
-            return False
-        return self.matches_filters(group_filter, name_filter, type_filter)
-
-    def should_update(
-        self,
-        group_filter: Optional[str] = None,
-        name_filter: Optional[str] = None,
-        type_filter: Optional[str] = None,
-    ) -> bool:
-        if not self.enabled or self.skip_update:
-            return False
-        return self.matches_filters(group_filter, name_filter, type_filter)
-
-    def __hash__(self):
-        return hash(f"{self.get_resource_type()}:{self.get_resource_name()}")
-
-    def __eq__(self, other):
-        if isinstance(other, InfraResource):
-            if other.get_resource_type() == self.get_resource_type():
-                return self.get_resource_name() == other.get_resource_name()
-        return False