@step

@step(
    name: Optional[str] = None,
    enable_cache: Optional[bool] = None,
    enable_artifact_metadata: Optional[bool] = None,
    enable_artifact_visualization: Optional[bool] = None,
    enable_step_logs: Optional[bool] = None,
    experiment_tracker: Optional[Union[bool, str]] = None,
    step_operator: Optional[Union[bool, str]] = None,
    output_materializers: Optional[OutputMaterializersSpecification] = None,
    environment: Optional[Dict[str, Any]] = None,
    secrets: Optional[List[Union[UUID, str]]] = None,
    settings: Optional[Dict[str, SettingsOrDict]] = None,
    extra: Optional[Dict[str, Any]] = None,
    on_failure: Optional[HookSpecification] = None,
    on_success: Optional[HookSpecification] = None,
    model: Optional[Model] = None,
    retry: Optional[StepRetryConfig] = None,
    substitutions: Optional[Dict[str, str]] = None,
    cache_policy: Optional[CachePolicyOrString] = None,
    runtime: Optional[StepRuntime] = None,
    heartbeat_healthy_threshold: Optional[int] = None,
    group: Optional[Union[GroupInfo, str]] = None,
) -> BaseStep

from zenml import step
import pandas as pd

@step
def load_data() -> pd.DataFrame:
    """Load data from a source."""
    return pd.read_csv("data.csv")

@step
def clean_data(df: pd.DataFrame) -> pd.DataFrame:
    """Clean the input data."""
    return df.dropna()

from typing import Annotated
from zenml import step, ArtifactConfig
import pandas as pd

@step
def process_data(
    df: pd.DataFrame
) -> Annotated[
    pd.DataFrame,
    ArtifactConfig(name="processed_data", tags=["clean"])
]:
    """Process and clean data."""
    return df.dropna().reset_index(drop=True)

from zenml import step, Model

@step(
    name="model_trainer",
    enable_cache=False,
    experiment_tracker="mlflow",
    model=Model(name="my_model", version="1.0.0")
)
def train_model(X_train: pd.DataFrame, y_train: pd.Series) -> Any:
    """Train a machine learning model."""
    from sklearn.ensemble import RandomForestClassifier
    model = RandomForestClassifier()
    model.fit(X_train, y_train)
    return model

from zenml import step
from zenml.config import ResourceSettings

@step(
    settings={
        "resources": ResourceSettings(
            cpu_count=4,
            memory="8GB",
            gpu_count=1
        )
    }
)
def train_deep_model(data: pd.DataFrame) -> Any:
    """Train a model with GPU acceleration."""
    # Training code here
    pass