Upload 9 files

backend/app/api/compare.py

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,25 @@
+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
+    }