Delete backend

backend/app/api/compare.py

@@ -1,35 +0,0 @@
-import json
-
-from fastapi import APIRouter, Depends, Query
-from sqlalchemy.orm import Session
-
-from backend.app.db import get_db
-from backend.app.repositories.experiment_repo import get_experiments_by_ids, list_experiments
-
-router = APIRouter(tags=["compare"])
-
-
-@router.get("/compare")
-def compare_experiments(experiment_ids: str | None = Query(default=None), db: Session = Depends(get_db)):
-    if experiment_ids:
-        ids = [x.strip() for x in experiment_ids.split(",") if x.strip()]
-        experiments = get_experiments_by_ids(db, ids)
-    else:
-        experiments = list_experiments(db)
-
-    return {
-        "experiments": [
-            {
-                "experiment_id": exp.id,
-                "dataset_id": exp.dataset_id,
-                "algorithm": exp.algorithm,
-                "status": exp.status,
-                "config": json.loads(exp.config_json) if exp.config_json else {},
-                "metrics": json.loads(exp.metrics_json) if exp.metrics_json else {},
-                "summary": json.loads(exp.summary_json) if exp.summary_json else {},
-                "runtime_ms": exp.runtime_ms,
-                "error_message": exp.error_message,
-            }
-            for exp in experiments
-        ]
-    }

backend/app/api/datasets.py

@@ -1,89 +0,0 @@
-import json
-from pathlib import Path
-
-import pandas as pd
-from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
-from sqlalchemy.orm import Session
-
-from backend.app.db import get_db
-from backend.app.repositories.dataset_repo import create_dataset, get_dataset, list_datasets
-from backend.app.services.profiling_service import profile_dataframe
-from backend.app.utils.ids import make_dataset_id
-
-router = APIRouter(tags=["datasets"])
-
-UPLOAD_DIR = Path("/data/uploads")
-UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
-
-
-@router.get("/datasets")
-def datasets_list(db: Session = Depends(get_db)):
-    datasets = list_datasets(db)
-    return {
-        "datasets": [
-            {
-                "id": d.id,
-                "name": d.name,
-                "row_count": d.row_count,
-                "column_count": d.column_count,
-            }
-            for d in datasets
-        ]
-    }
-
-
-@router.post("/datasets/upload")
-async def upload_dataset(file: UploadFile = File(...), db: Session = Depends(get_db)):
-    if not file.filename:
-        raise HTTPException(status_code=400, detail="Missing file name")
-
-    suffix = Path(file.filename).suffix.lower()
-    if suffix not in {".csv", ".xlsx", ".xls"}:
-        raise HTTPException(status_code=400, detail="Only CSV and Excel files are supported")
-
-    dataset_id = make_dataset_id()
-    path = UPLOAD_DIR / f"{dataset_id}{suffix}"
-
-    content = await file.read()
-    path.write_bytes(content)
-
-    if suffix == ".csv":
-        df = pd.read_csv(path)
-    else:
-        df = pd.read_excel(path)
-
-    profile = profile_dataframe(df)
-
-    create_dataset(
-        db=db,
-        id=dataset_id,
-        name=file.filename,
-        file_path=str(path),
-        row_count=int(len(df)),
-        column_count=int(len(df.columns)),
-        schema_json=json.dumps({"columns": list(df.columns)}),
-        profile_json=json.dumps(profile),
-    )
-
-    return {
-        "dataset_id": dataset_id,
-        "name": file.filename,
-        "row_count": int(len(df)),
-        "column_count": int(len(df.columns)),
-    }
-
-
-@router.get("/datasets/{dataset_id}/profile")
-def dataset_profile(dataset_id: str, db: Session = Depends(get_db)):
-    dataset = get_dataset(db, dataset_id)
-    if not dataset:
-        raise HTTPException(status_code=404, detail="Dataset not found")
-
-    return {
-        "dataset_id": dataset.id,
-        "name": dataset.name,
-        "row_count": dataset.row_count,
-        "column_count": dataset.column_count,
-        "schema": json.loads(dataset.schema_json),
-        "profile": json.loads(dataset.profile_json),
-    }

backend/app/api/experiments.py

@@ -1,140 +0,0 @@
-import json
-import time
-
-import pandas as pd
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel
-from sqlalchemy.orm import Session
-from sklearn.cluster import AgglomerativeClustering, Birch, KMeans
-from sklearn.decomposition import PCA
-from sklearn.metrics import silhouette_score
-
-from backend.app.db import get_db
-from backend.app.repositories.dataset_repo import get_dataset
-from backend.app.repositories.experiment_repo import create_experiment
-from backend.app.utils.ids import make_experiment_id
-
-router = APIRouter(tags=["experiments"])
-
-
-class RunRequest(BaseModel):
-    dataset_id: str
-    name: str | None = None
-    algorithm: str = "kmeans"
-    n_clusters: int = 4
-    feature_columns: list[str]
-
-
-@router.post("/experiments/run")
-def run_experiment(req: RunRequest, db: Session = Depends(get_db)):
-    dataset = get_dataset(db, req.dataset_id)
-    if not dataset:
-        raise HTTPException(status_code=404, detail="Dataset not found")
-
-    if dataset.file_path.endswith(".csv"):
-        df = pd.read_csv(dataset.file_path)
-    else:
-        df = pd.read_excel(dataset.file_path)
-
-    if not req.feature_columns:
-        raise HTTPException(status_code=400, detail="feature_columns is required")
-
-    missing = [c for c in req.feature_columns if c not in df.columns]
-    if missing:
-        raise HTTPException(status_code=400, detail=f"Missing columns: {', '.join(missing)}")
-
-    X = df[req.feature_columns].copy()
-    X = pd.get_dummies(X)
-    X = X.fillna(0)
-
-    start = time.time()
-
-    if req.algorithm == "kmeans":
-        model = KMeans(n_clusters=req.n_clusters, n_init=10, random_state=42)
-        labels = model.fit_predict(X)
-    elif req.algorithm == "agglomerative":
-        model = AgglomerativeClustering(n_clusters=req.n_clusters)
-        labels = model.fit_predict(X)
-    elif req.algorithm == "birch":
-        model = Birch(n_clusters=req.n_clusters)
-        labels = model.fit_predict(X)
-    else:
-        raise HTTPException(status_code=400, detail="Unsupported algorithm")
-
-    runtime_ms = int((time.time() - start) * 1000)
-    unique_labels = sorted(set(labels.tolist()))
-    score = None
-    if len(unique_labels) > 1 and len(unique_labels) < len(X):
-        score = float(silhouette_score(X, labels))
-
-    pca = PCA(n_components=2, random_state=42)
-    coords = pca.fit_transform(X)
-
-    points = [
-        {
-            "row_index": int(i),
-            "cluster_label": int(labels[i]),
-            "x": float(coords[i][0]),
-            "y": float(coords[i][1]),
-        }
-        for i in range(len(labels))
-    ]
-
-    cluster_sizes = {str(label): int((labels == label).sum()) for label in unique_labels}
-    experiment_id = make_experiment_id()
-
-    metrics = {
-        "silhouette_score": score,
-        "cluster_count": len(unique_labels),
-        "row_count": int(len(X)),
-        "runtime_ms": runtime_ms,
-    }
-    summary = {
-        "feature_columns": req.feature_columns,
-        "cluster_sizes": cluster_sizes,
-        "points": points,
-    }
-
-    create_experiment(
-        db=db,
-        id=experiment_id,
-        dataset_id=req.dataset_id,
-        algorithm=req.algorithm,
-        status="completed",
-        config_json=req.model_dump_json(),
-        metrics_json=json.dumps(metrics),
-        summary_json=json.dumps(summary),
-        runtime_ms=runtime_ms,
-        error_message=None,
-    )
-
-    return {
-        "experiment_id": experiment_id,
-        "status": "completed",
-        "silhouette_score": score,
-        "cluster_count": len(unique_labels),
-        "cluster_sizes": cluster_sizes,
-        "runtime_ms": runtime_ms,
-        "points": points,
-    }
-
-
-@router.get("/experiments/{experiment_id}/results")
-def experiment_results(experiment_id: str, db: Session = Depends(get_db)):
-    from backend.app.repositories.experiment_repo import get_experiment
-
-    exp = get_experiment(db, experiment_id)
-    if not exp:
-        raise HTTPException(status_code=404, detail="Experiment not found")
-
-    return {
-        "experiment_id": exp.id,
-        "dataset_id": exp.dataset_id,
-        "algorithm": exp.algorithm,
-        "status": exp.status,
-        "config": json.loads(exp.config_json) if exp.config_json else {},
-        "metrics": json.loads(exp.metrics_json) if exp.metrics_json else {},
-        "summary": json.loads(exp.summary_json) if exp.summary_json else {},
-        "runtime_ms": exp.runtime_ms,
-        "error_message": exp.error_message,
-    }

backend/app/api/exports.py

@@ -1,53 +0,0 @@
-import io
-import json
-
-import pandas as pd
-from fastapi import APIRouter, Depends, HTTPException
-from fastapi.responses import StreamingResponse
-from sqlalchemy.orm import Session
-
-from backend.app.db import get_db
-from backend.app.repositories.dataset_repo import get_dataset
-from backend.app.repositories.experiment_repo import get_experiment
-
-router = APIRouter(tags=["exports"])
-
-
-@router.get("/exports/{experiment_id}")
-def export_experiment(experiment_id: str, db: Session = Depends(get_db)):
-    experiment = get_experiment(db, experiment_id)
-    if not experiment:
-        raise HTTPException(status_code=404, detail="Experiment not found")
-
-    dataset = get_dataset(db, experiment.dataset_id)
-    if not dataset:
-        raise HTTPException(status_code=404, detail="Dataset not found")
-
-    if dataset.file_path.endswith(".csv"):
-        df = pd.read_csv(dataset.file_path)
-    else:
-        df = pd.read_excel(dataset.file_path)
-
-    summary = json.loads(experiment.summary_json) if experiment.summary_json else {}
-    points = summary.get("points", [])
-    if points and len(points) == len(df):
-        export_df = df.copy()
-        export_df["cluster_label"] = [p["cluster_label"] for p in points]
-        export_df["pca_x"] = [p["x"] for p in points]
-        export_df["pca_y"] = [p["y"] for p in points]
-    else:
-        export_df = df.copy()
-
-    metrics = json.loads(experiment.metrics_json) if experiment.metrics_json else {}
-    for key, value in metrics.items():
-        export_df[f"metric_{key}"] = value
-
-    buffer = io.StringIO()
-    export_df.to_csv(buffer, index=False)
-    buffer.seek(0)
-
-    return StreamingResponse(
-        iter([buffer.getvalue()]),
-        media_type="text/csv",
-        headers={"Content-Disposition": f"attachment; filename={experiment_id}_export.csv"},
-    )

backend/app/api/health.py

@@ -1,7 +0,0 @@
-from fastapi import APIRouter
-
-router = APIRouter(tags=["health"])
-
-@router.get("/health")
-def health():
-    return {"ok": True, "service": "clusterbuster-api"}

backend/app/api/presets.py

@@ -1,13 +0,0 @@
-from fastapi import APIRouter
-
-router = APIRouter(tags=["presets"])
-
-@router.get("/presets/algorithms")
-def list_algorithms():
-    return {
-        "algorithms": [
-            {"key": "kmeans", "label": "KMeans", "params": {"n_clusters": 4}},
-            {"key": "agglomerative", "label": "Agglomerative", "params": {"n_clusters": 4}},
-            {"key": "birch", "label": "Birch", "params": {"n_clusters": 4}},
-        ]
-    }

backend/app/api/runs.py

@@ -1,29 +0,0 @@
-import json
-
-from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
-
-from backend.app.db import get_db
-from backend.app.repositories.experiment_repo import list_experiments
-
-router = APIRouter(tags=["runs"])
-
-
-@router.get("/runs")
-def get_runs(db: Session = Depends(get_db)):
-    experiments = list_experiments(db)
-    return {
-        "runs": [
-            {
-                "experiment_id": exp.id,
-                "dataset_id": exp.dataset_id,
-                "algorithm": exp.algorithm,
-                "status": exp.status,
-                "metrics": json.loads(exp.metrics_json) if exp.metrics_json else {},
-                "summary": json.loads(exp.summary_json) if exp.summary_json else {},
-                "runtime_ms": exp.runtime_ms,
-                "error_message": exp.error_message,
-            }
-            for exp in experiments
-        ]
-    }

backend/app/db.py

@@ -1,34 +0,0 @@
-import os
-from sqlalchemy import create_engine
-from sqlalchemy.orm import declarative_base, sessionmaker
-
-DB_PATH = os.getenv("DB_PATH", "/data/clusterforge.db")
-DATABASE_URL = f"sqlite:///{DB_PATH}"
-
-engine = create_engine(
-    DATABASE_URL,
-    connect_args={"check_same_thread": False},
-)
-
-SessionLocal = sessionmaker(
-    autocommit=False,
-    autoflush=False,
-    bind=engine,
-)
-
-Base = declarative_base()
-
-
-def init_db() -> None:
-    import backend.app.models.dataset
-    import backend.app.models.experiment
-
-    Base.metadata.create_all(bind=engine)
-
-
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()

backend/app/main.py

@@ -1,45 +0,0 @@
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from backend.app.db import init_db
-from backend.app.api.health import router as health_router
-from backend.app.api.datasets import router as datasets_router
-from backend.app.api.presets import router as presets_router
-from backend.app.api.experiments import router as experiments_router
-from backend.app.api.compare import router as compare_router
-from backend.app.api.exports import router as exports_router
-from backend.app.api.runs import router as runs_router
-
-app = FastAPI(title="ClusterBuster API")
-
-
-@app.on_event("startup")
-def on_startup() -> None:
-    init_db()
-
-
-origins = [
-    "http://localhost:3000",
-    "https://cluster-buster.vercel.app",
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(health_router, prefix="/api")
-app.include_router(datasets_router, prefix="/api")
-app.include_router(presets_router, prefix="/api")
-app.include_router(experiments_router, prefix="/api")
-app.include_router(compare_router, prefix="/api")
-app.include_router(exports_router, prefix="/api")
-app.include_router(runs_router, prefix="/api")
-
-
-@app.get("/")
-def root():
-    return {"ok": True, "service": "clusterbuster-api"}

backend/app/models/dataset.py

@@ -1,14 +0,0 @@
-from sqlalchemy import Column, Integer, String, Text
-from backend.app.db import Base
-
-
-class Dataset(Base):
-    __tablename__ = "datasets"
-
-    id = Column(String, primary_key=True, index=True)
-    name = Column(String, nullable=False)
-    file_path = Column(String, nullable=False)
-    row_count = Column(Integer, nullable=False)
-    column_count = Column(Integer, nullable=False)
-    schema_json = Column(Text, nullable=False)
-    profile_json = Column(Text, nullable=False)

backend/app/models/experiment.py

@@ -1,16 +0,0 @@
-from sqlalchemy import Column, Integer, String, Text
-from backend.app.db import Base
-
-
-class Experiment(Base):
-    __tablename__ = "experiments"
-
-    id = Column(String, primary_key=True, index=True)
-    dataset_id = Column(String, nullable=False, index=True)
-    algorithm = Column(String, nullable=False)
-    status = Column(String, nullable=False)
-    config_json = Column(Text, nullable=True)
-    metrics_json = Column(Text, nullable=True)
-    summary_json = Column(Text, nullable=True)
-    runtime_ms = Column(Integer, nullable=True)
-    error_message = Column(Text, nullable=True)

backend/app/repositories/dataset_repo.py

@@ -1,35 +0,0 @@
-from sqlalchemy.orm import Session
-from backend.app.models.dataset import Dataset
-
-
-def create_dataset(
-    db: Session,
-    id: str,
-    name: str,
-    file_path: str,
-    row_count: int,
-    column_count: int,
-    schema_json: str,
-    profile_json: str,
-) -> Dataset:
-    dataset = Dataset(
-        id=id,
-        name=name,
-        file_path=file_path,
-        row_count=row_count,
-        column_count=column_count,
-        schema_json=schema_json,
-        profile_json=profile_json,
-    )
-    db.add(dataset)
-    db.commit()
-    db.refresh(dataset)
-    return dataset
-
-
-def get_dataset(db: Session, dataset_id: str) -> Dataset | None:
-    return db.query(Dataset).filter(Dataset.id == dataset_id).first()
-
-
-def list_datasets(db: Session) -> list[Dataset]:
-    return db.query(Dataset).order_by(Dataset.name.asc()).all()

backend/app/repositories/experiment_repo.py

@@ -1,45 +0,0 @@
-from sqlalchemy.orm import Session
-from backend.app.models.experiment import Experiment
-
-
-def create_experiment(
-    db: Session,
-    id: str,
-    dataset_id: str,
-    algorithm: str,
-    status: str,
-    config_json: str | None = None,
-    metrics_json: str | None = None,
-    summary_json: str | None = None,
-    runtime_ms: int | None = None,
-    error_message: str | None = None,
-) -> Experiment:
-    experiment = Experiment(
-        id=id,
-        dataset_id=dataset_id,
-        algorithm=algorithm,
-        status=status,
-        config_json=config_json,
-        metrics_json=metrics_json,
-        summary_json=summary_json,
-        runtime_ms=runtime_ms,
-        error_message=error_message,
-    )
-    db.add(experiment)
-    db.commit()
-    db.refresh(experiment)
-    return experiment
-
-
-def get_experiment(db: Session, experiment_id: str) -> Experiment | None:
-    return db.query(Experiment).filter(Experiment.id == experiment_id).first()
-
-
-def list_experiments(db: Session) -> list[Experiment]:
-    return db.query(Experiment).order_by(Experiment.id.desc()).all()
-
-
-def get_experiments_by_ids(db: Session, experiment_ids: list[str]) -> list[Experiment]:
-    if not experiment_ids:
-        return []
-    return db.query(Experiment).filter(Experiment.id.in_(experiment_ids)).all()

backend/app/services/profiling_service.py

@@ -1,23 +0,0 @@
-def profile_dataframe(df):
-    numeric_cols = df.select_dtypes(include=["int64", "float64", "int32", "float32"]).columns.tolist()
-    categorical_cols = df.select_dtypes(include=["object", "bool"]).columns.tolist()
-
-    recommended = []
-    if numeric_cols:
-        recommended.extend(["kmeans", "birch"])
-    if categorical_cols:
-        recommended.append("agglomerative")
-
-    cols = []
-    for col in df.columns:
-        cols.append({
-            "name": col,
-            "inferred_type": str(df[col].dtype),
-            "missing_pct": float(df[col].isna().mean()),
-            "cardinality": int(df[col].nunique(dropna=True)),
-        })
-
-    return {
-        "columns": cols,
-        "recommended_algorithms": recommended,
-    }

backend/app/utils/ids.py

@@ -1,7 +0,0 @@
-import secrets
-
-def make_dataset_id() -> str:
-    return "ds_" + secrets.token_hex(4)
-
-def make_experiment_id() -> str:
-    return "exp_" + secrets.token_hex(4)