app.py

"""
Hugging Face Spaces entry point.
HF Spaces runs: uvicorn app:app --host 0.0.0.0 --port 7860
"""
from fastapi import FastAPI, HTTPException, UploadFile, File
from fastapi.middleware.cors import CORSMiddleware
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.metrics import silhouette_score, davies_bouldin_score, calinski_harabasz_score
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris, make_blobs, make_moons, make_circles
from sklearn.decomposition import PCA
from scipy.cluster.hierarchy import dendrogram, linkage
import io, json, os
from typing import Optional, Dict, Any
from pydantic import BaseModel
import warnings
warnings.filterwarnings('ignore')

try:
    import psycopg2, psycopg2.extras
    _PG = True
except ImportError:
    _PG = False

def get_conn():
    if not _PG: return None
    url = os.environ.get("DATABASE_URL", "")
    if not url: return None
    try: return psycopg2.connect(url, sslmode="require")
    except: return None

def ensure_table(conn):
    try:
        with conn.cursor() as cur:
            cur.execute("""CREATE TABLE IF NOT EXISTS experiments (
                id SERIAL PRIMARY KEY, algorithm VARCHAR(50) NOT NULL,
                dataset_name VARCHAR(100) NOT NULL, params_json JSONB NOT NULL,
                silhouette_score FLOAT, db_score FLOAT, ch_score FLOAT,
                n_clusters_found INTEGER, plot_data JSONB, metrics_json JSONB,
                created_at TIMESTAMPTZ DEFAULT NOW())""")
        conn.commit()
    except: pass

app = FastAPI(title="ClusterLab API", version="2.0.0")
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
                   allow_methods=["*"], allow_headers=["*"])

class ClusterRequest(BaseModel):
    dataset: str
    algorithm: str
    params: Dict[str, Any]
    csv_data: Optional[str] = None

class SaveExperimentRequest(BaseModel):
    algorithm: str
    dataset_name: str
    params_json: Dict[str, Any]
    silhouette_score: Optional[float] = None
    db_score: Optional[float] = None
    ch_score: Optional[float] = None
    n_clusters_found: Optional[int] = None
    plot_data: Optional[Dict] = None
    metrics_json: Optional[Dict] = None

def load_dataset(name, csv_text=None):
    if name == "csv" and csv_text:
        df = pd.read_csv(io.StringIO(csv_text))
        return df[df.select_dtypes(include=[np.number]).columns.tolist()]
    elif name == "iris":
        d = load_iris(); return pd.DataFrame(d.data, columns=d.feature_names)
    elif name == "blobs":
        X,_ = make_blobs(n_samples=300,centers=4,cluster_std=0.8,random_state=42)
        return pd.DataFrame(X,columns=["feature_1","feature_2"])
    elif name == "moons":
        X,_ = make_moons(n_samples=300,noise=0.1,random_state=42)
        return pd.DataFrame(X,columns=["feature_1","feature_2"])
    elif name == "circles":
        X,_ = make_circles(n_samples=300,noise=0.05,factor=0.5,random_state=42)
        return pd.DataFrame(X,columns=["feature_1","feature_2"])
    elif name == "mall":
        np.random.seed(42)
        return pd.DataFrame({
            "annual_income": np.concatenate([np.random.normal(20,5,40),np.random.normal(60,10,60),np.random.normal(85,5,40),np.random.normal(25,5,35),np.random.normal(60,8,25)]),
            "spending_score": np.concatenate([np.random.normal(75,8,40),np.random.normal(55,10,60),np.random.normal(80,8,40),np.random.normal(25,8,35),np.random.normal(20,8,25)]),
        })
    elif name == "wholesale":
        np.random.seed(99); n=250
        return pd.DataFrame({"fresh":np.abs(np.random.normal(12000,12000,n)),"milk":np.abs(np.random.normal(5800,7000,n)),"grocery":np.abs(np.random.normal(7950,9000,n)),"frozen":np.abs(np.random.normal(3075,5000,n))})
    raise HTTPException(400, f"Unknown dataset: {name}")

def reduce_to_2d(X):
    return PCA(n_components=2,random_state=42).fit_transform(X) if X.shape[1]>2 else X

def compute_metrics(X, labels):
    unique = np.unique(labels[labels!=-1]); n=int(len(unique))
    base = {"n_clusters_found":n,"noise_points":int((labels==-1).sum())}
    if n<2: return {**base,"silhouette_score":None,"db_score":None,"ch_score":None}
    mask=labels!=-1; Xv,Lv=X[mask],labels[mask]
    if len(np.unique(Lv))<2: return {**base,"silhouette_score":None,"db_score":None,"ch_score":None}
    try:
        return {**base,
            "silhouette_score":round(float(silhouette_score(Xv,Lv)),4),
            "db_score":round(float(davies_bouldin_score(Xv,Lv)),4),
            "ch_score":round(float(calinski_harabasz_score(Xv,Lv)),2)}
    except:
        return {**base,"silhouette_score":None,"db_score":None,"ch_score":None}

@app.get("/health")
def health():
    conn=get_conn(); db="not_configured"
    if conn:
        try: conn.close(); db="connected"
        except: db="error"
    return {"status":"ok","version":"2.0.0","db":db}

@app.get("/api/datasets")
def list_datasets():
    return {"datasets":[
        {"id":"iris","name":"Iris","description":"Classic 4-feature flower dataset","n_samples":150,"n_features":4},
        {"id":"blobs","name":"Blobs","description":"Well-separated Gaussian clusters","n_samples":300,"n_features":2},
        {"id":"moons","name":"Moons","description":"Two interleaving half-circles","n_samples":300,"n_features":2},
        {"id":"circles","name":"Circles","description":"Concentric circle rings","n_samples":300,"n_features":2},
        {"id":"mall","name":"Mall Customers","description":"Income vs spending score","n_samples":200,"n_features":2},
        {"id":"wholesale","name":"Wholesale","description":"Product category spending (4D)","n_samples":250,"n_features":4},
    ]}

@app.post("/api/cluster")
def cluster(req: ClusterRequest):
    df=load_dataset(req.dataset,req.csv_data)
    scaler=StandardScaler(); X=scaler.fit_transform(df.values.astype(float))
    X_2d=reduce_to_2d(X); p=req.params; algo=req.algorithm.lower(); extra={}
    if algo=="kmeans":
        n=int(p.get("n_clusters",3))
        model=KMeans(n_clusters=n,init=p.get("init","k-means++"),max_iter=int(p.get("max_iter",300)),n_init=10,random_state=42)
        labels=model.fit_predict(X)
        c=scaler.inverse_transform(model.cluster_centers_)
        extra["cluster_centers_2d"]=(reduce_to_2d(c) if c.shape[1]>2 else c).tolist()
        ks=list(range(2,min(11,len(X)//5+2))); ins,ss=[],[]
        for k in ks:
            km=KMeans(n_clusters=k,n_init=10,random_state=42).fit(X)
            ins.append(float(km.inertia_))
            try: ss.append(float(silhouette_score(X,km.labels_)))
            except: ss.append(0.0)
        extra["elbow"]={"k":ks,"inertia":ins,"silhouette":ss,"best_k":ks[int(np.argmax(ss))] if ss else n}
    elif algo=="dbscan":
        model=DBSCAN(eps=float(p.get("eps",0.5)),min_samples=int(p.get("min_samples",5)))
        labels=model.fit_predict(X); extra["core_sample_indices"]=model.core_sample_indices_.tolist()[:200]
    elif algo=="hierarchical":
        n=int(p.get("n_clusters",3)); lm=p.get("linkage","ward")
        labels=AgglomerativeClustering(n_clusters=n,linkage=lm).fit_predict(X)
        idx=np.random.choice(len(X),min(100,len(X)),replace=False)
        try:
            dend=dendrogram(linkage(X[idx],method=lm),no_plot=True)
            extra["dendrogram"]={"icoord":dend["icoord"],"dcoord":dend["dcoord"],"leaves":dend["leaves"],"color_list":dend["color_list"]}
        except Exception as e: extra["dendrogram"]={"error":str(e)}
    else: raise HTTPException(400,f"Unknown algorithm: {algo}")
    metrics=compute_metrics(X,labels)
    return {"cluster_labels":labels.tolist(),"metrics":metrics,
            "plot_data":{"x":X_2d[:,0].tolist(),"y":X_2d[:,1].tolist(),"labels":labels.tolist(),"feature_names":df.columns.tolist()[:2],"n_points":int(len(X_2d))},
            "silhouette_score":metrics.get("silhouette_score"),"extra":extra,
            "dataset_info":{"n_samples":int(len(X)),"n_features":int(df.shape[1]),"columns":df.columns.tolist()}}

@app.post("/api/cluster/compare")
def compare_all(req: ClusterRequest):
    DEFAULTS={"kmeans":{"n_clusters":3,"init":"k-means++","max_iter":300},"dbscan":{"eps":0.5,"min_samples":5},"hierarchical":{"n_clusters":3,"linkage":"ward"}}
    results={}
    for algo,dp in DEFAULTS.items():
        try: results[algo]=cluster(ClusterRequest(dataset=req.dataset,algorithm=algo,params=dp,csv_data=req.csv_data))
        except Exception as e: results[algo]={"error":str(e)}
    return results

@app.post("/api/csv-upload")
async def upload_csv(file: UploadFile=File(...)):
    content=await file.read(); text=content.decode("utf-8")
    df=pd.read_csv(io.StringIO(text)); num=df.select_dtypes(include=[np.number]).columns.tolist()
    if len(num)<2: raise HTTPException(400,"CSV must have at least 2 numeric columns")
    return {"csv_data":text,"columns":num,"n_rows":int(len(df)),"preview":df[num].head(5).fillna(0).to_dict(orient="records")}

@app.get("/api/experiments")
def get_experiments():
    conn=get_conn()
    if not conn: return {"experiments":[],"message":"DB not configured"}
    try:
        ensure_table(conn)
        with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
            cur.execute("SELECT id,algorithm,dataset_name,params_json,silhouette_score,db_score,ch_score,n_clusters_found,metrics_json,created_at FROM experiments ORDER BY created_at DESC LIMIT 50")
            rows=[dict(r) for r in cur.fetchall()]
        conn.close()
        for r in rows:
            if r.get("created_at"): r["created_at"]=r["created_at"].isoformat()
        return {"experiments":rows}
    except Exception as e: conn.close(); raise HTTPException(500,str(e))

@app.post("/api/experiments/save")
def save_experiment(req: SaveExperimentRequest):
    conn=get_conn()
    if not conn: return {"id":None,"message":"DB not configured"}
    try:
        ensure_table(conn)
        with conn.cursor() as cur:
            cur.execute("INSERT INTO experiments (algorithm,dataset_name,params_json,silhouette_score,db_score,ch_score,n_clusters_found,plot_data,metrics_json) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s) RETURNING id,created_at",
                (req.algorithm,req.dataset_name,json.dumps(req.params_json),req.silhouette_score,req.db_score,req.ch_score,req.n_clusters_found,
                 json.dumps(req.plot_data) if req.plot_data else None,json.dumps(req.metrics_json) if req.metrics_json else None))
            row=cur.fetchone()
        conn.commit(); conn.close()
        return {"id":row[0],"created_at":row[1].isoformat(),"message":"Saved successfully"}
    except Exception as e: conn.close(); raise HTTPException(500,str(e))

@app.delete("/api/experiments/{exp_id}")
def delete_experiment(exp_id: int):
    conn=get_conn()
    if not conn: raise HTTPException(503,"DB not configured")
    try:
        with conn.cursor() as cur: cur.execute("DELETE FROM experiments WHERE id=%s",(exp_id,))
        conn.commit(); conn.close(); return {"deleted":exp_id}
    except Exception as e: conn.close(); raise HTTPException(500,str(e))