Delete backend

backend/app/api/compare.py

@@ -1,41 +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/experiments.py

@@ -1,104 +0,0 @@
-import secrets
-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.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
-
-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))
-
-    cluster_sizes = {str(label): int((labels == label).sum()) for label in unique_labels}
-    experiment_id = "exp_" + secrets.token_hex(4)
-
-    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,
-    }
-
-    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=pd.Series(metrics).to_json(),
-        summary_json=pd.Series(summary).to_json(),
-        runtime_ms=runtime_ms,
-        error_message=None,
-    )
-
-    return {
-        "experiment_id": experiment_id,
-        "status": "completed",
-        "clusters": labels.tolist(),
-        "silhouette_score": score,
-        "cluster_count": len(unique_labels),
-        "cluster_sizes": cluster_sizes,
-        "runtime_ms": runtime_ms,
-    }

backend/app/api/exports.py

@@ -1,50 +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)
-
-    export_df = df.copy()
-    export_df["experiment_id"] = experiment.id
-    export_df["algorithm"] = experiment.algorithm
-    export_df["experiment_status"] = experiment.status
-
-    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/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/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/experiment_repo.py

@@ -1,46 +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,25 +0,0 @@
-def profile_dataframe(df):
-    numeric_cols = df.select_dtypes(include=["int64", "float64"]).columns.tolist()
-    categorical_cols = df.select_dtypes(include=["object"]).columns.tolist()
-
-    recommended = []
-
-    if len(numeric_cols) > 0:
-        recommended.append("kmeans")
-        recommended.append("birch")
-
-    if len(categorical_cols) > 0:
-        recommended.append("agglomerative")
-
-    return {
-        "columns": [
-            {
-                "name": col,
-                "inferred_type": str(df[col].dtype),
-                "missing_pct": float(df[col].isna().mean()),
-                "cardinality": int(df[col].nunique())
-            }
-            for col in df.columns
-        ],
-        "recommended_algorithms": recommended
-    }