add backend

Author: sungmin-woo-devops

backend/README.md

@@ -0,0 +1,5 @@
+```bash
+uvicorn app.main:app --reload
+```
+
+https://grok.com/chat/dc587791-ef1c-420c-b823-db6bff5957f9

backend/database.py

@@ -0,0 +1,10 @@
+from supabase import create_client, Client
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_SECRET_KEY = os.getenv("SUPABASE_SECRET_KEY")
+
+supbase: Client = create_client(SUPABASE_URL, SUPABASE_SECRET_KEY)

backend/main.py

@@ -0,0 +1,122 @@
+import re
+from fastapi import FastAPI, HTTPException
+from fastapi.security import OAuth2PasswordBearer
+from typing import Annotated, List, Dict, Optional
+from uuid import UUID
+from models import (
+    User, UserCreate, 
+    Dataset, DatasetCreate, 
+    Model, ModelCreate, 
+    Experiment, ExperimentCreate,
+    Artifact
+)
+from database import supabase
+from utils.supabase import get_supabase_client
+from utils.mongodb import get_mongo_collection
+from routes.artifacts import router as artifacts_router
+
+app = FastAPI()
+
+# CRUD for Users
+@app.port("/users", response_model=User)
+async def create_user(user: UserCreate):
+    try:
+        response = supabase.table("users").insert(user.dict(exclude_unset=True)).execute()
+        return response.data[0]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/users", response_model=List[User]):
+async def list_users():
+    response = supabase.table("users").select("*").execute()
+    return response.data
+
+@app.get("/users/{user_id}", response_model=User)
+async def get_user(user_id: UUID):
+    response = supabase.table("users").select("*").eq("id", str(user_id)).execute()
+    if not response.data:
+        raise HTTPException(status_code=404, detail="User not found")
+    return response.data[0]
+
+@app.put("/users/{user_id}", response_model=User)
+async def update_user(user_id: UUID, user: UserCreate):
+    response = supabase.table("users").update(user.dict(exclude_unset=True)).eq("id", str(user_id)).execute()
+    if not response.data:
+        raise HTTPException(status_code=404, detail="User not found")
+    return response.data[0]
+
+@app.delete("/users/{user_id}")
+async def delete_user(user_id: UUID):
+    response = supabase.table("users").delete().eq("id", str(user_id)).execute()
+    if not response.data:
+        raise HTTPException(status_code=404, detail="User not found")
+    return {"message": "User deleted"}
+
+# CRUD for Datasets
+@app.post("/datasets", response_model=Dataset)
+async def create_dataset(dataset: DatasetCreate):
+    try:
+        response = supabase.table("datasets").insert(dataset.dict(exclude_unset=True)).execute()
+        return response.data[0]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/datasets", response_model=List[Dataset])
+async def list_datasets():
+    response = supabase.table("datasets").select("*").execute()
+    return response.data
+
+# CRUD for Models
+@app.post("/models", response_model=Model)
+async def create_model(model: ModelCreate):
+    try:
+        response = supabase.table("models").insert(model.dict(exclude_unset=True)).execute()
+        return response.data[0]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/models", response_model=List[Model])
+async def list_models():
+    response = supabase.table("models").select("*").execute()
+    return response.data
+
+# CRUD for Experiments
+@app.post("/experiments", response_model=Experiment)
+async def create_experiment(experiment: ExperimentCreate):
+    try:
+        response = supabase.table("experiments").insert(experiment.dict(exclude_unset=True)).execute()
+        return response.data[0]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/experiments", response_model=List[Experiment])
+async def list_experiments():
+    response = supabase.table("experiments").select("*").execute()
+    return response.data
+
+# Seed Dummy Data
+@app.post("/seed-data")
+async def seed_data():
+    try:
+        # Insert users
+        users = generate_dummy_users(3)
+        user_response = supabase.table("users").insert(users).execute()
+        user_ids = [user["id"] for user in user_response.data]
+
+        # Insert datasets
+        datasets = generate_dummy_datasets(3)
+        dataset_response = supabase.table("datasets").insert(datasets).execute()
+        dataset_ids = [dataset["id"] for dataset in dataset_response.data]
+
+        # Insert models
+        models = generate_dummy_models(3, dataset_ids, user_ids)
+        model_response = supabase.table("models").insert(models).execute()
+        model_ids = [model["id"] for model in model_response.data]
+
+        # Insert experiments
+        experiments = generate_dummy_experiments(3, model_ids, user_ids)
+        supabase.table("experiments").insert(experiments).execute()
+
+        return {"message": "Dummy data inserted successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

backend/models.py

@@ -0,0 +1,69 @@
+from fastapi.background import P
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, union
+from sqlalchemy.dialects.postgresql import UUID as PGUUID
+from sqlalchemy.engine import create
+from sqlalchemy.ext.declarative import declarative_base
+from datetime import datetime
+import uuid
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(PGUUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    email = Column(String, unique=True, index=True)
+    api_token = Column(String, nullable=True)
+    role = Column(String, default="user")
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Dataset(Base):
+    __tablename__ = "datasets"
+    id = Column(PGUUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String, index=True)
+    description = Column(String, nullable=True)
+    file_path = Column(String, nullable=True)
+    file_size = Column(Integer, nullable=True)
+    metadata = Column(String, nullable=True)    # JSONB로 저장 가능
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Model(Base):
+    __tablename__ = "models"
+    id = Column(PGUUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    name = Column(String, index=True)
+    version = Column(String, index=True)
+    framework = Column(String, index=True)
+    format = Column(String, index=True)
+    file_size = Column(Integer, nullable=True)
+    metadata = Column(String, nullable=True)
+    dataset_id = Column(PGUUID(as_uuid=True), ForeignKey("datasets.id"), nullable=True)
+    created_by = Column(PGUUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+class Experiment(Base):
+    __tablename__ = "experiments"
+    id = Column(PGUUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    model_id = Column(PGUUID(as_uuid=True), ForeignKey("models.id"), nullable=False)
+    name = Column(String, nullable=False)
+    framework = Column(String, nullable=False)
+    hyperparameters = Column(String, nullable=True)  # JSONB로 저장 가능
+    metrics = Column(String, nullable=True)  # JSONB로 저장 가능
+    start_time = Column(DateTime, nullable=True)
+    end_time = Column(DateTime, nullable=True)
+    created_by = Column(PGUUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+class Artifact(Base):
+    __tablename__ = "artifacts"
+    id = Column(PGUUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    run_id = Column(String, nullable=False)
+    artifact_type = Column(String, nullable=False)
+    description = Column(String, nullable=True)
+    file_name = Column(String, nullable=False)
+    file_type = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+    

backend/models/__init__.py

@@ -0,0 +1,3 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0

backend/requirements.txt

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from models.artifact import Artifact
+from database import artifacts
+
+router = APIRouter()
+
+@router.post("/artifacts/")
+def create_artifact(artifact: Artifact):
+    artifacts.append(artifact)
+    return {"message": "Artifact saved", "artifact": artifact}
+
+@router.get("/artifacts/")
+def list_artifacts():
+    return artifacts

backend/routes/__init__.py

@@ -0,0 +1,62 @@
+import jwt
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from database import get_db
+from models import User
+from schemas import UserCreate, User
+from utils import verify_password, get_password_hash, create_access_token
+from datetime import timedelta
+
+router = APIRouter()
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except Exception as e:
+        raise credentials_exception
+    user = db.query(User).filter(User.email == username).first()    # email로 인증
+    if user is None:
+        raise credentials_exception
+    return user
+
+@router.post("/register", response_model=User)
+async def register(user: UserCreate, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.email == user.email).first()
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    
+    db_user = User(**user.dict(exclude_unset=True))
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.post("/token", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+    # Supabase 인증 대신 이메일/비밀번호로 가정 (Supabase Auth API 통합 필요)
+    user = db.query(User).filter(User.email == form_data.username).first()
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(data={"sub": user.email}, expires_delta=access_token_expires)
+    return {"access_token": access_token, "token_type": "bearer"}

backend/routes/artifacts.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from database import get_db
+from models import Dataset, Model, Experiment, Artifact
+from schemas import DatasetCreate, Dataset, ModelCreate, Model, ExperimentCreate, Experiment, ArtifactCreate, Artifact
+from uuid import UUID
+
+router = APIRouter()
+
+@router.post("/datasets", response_model=Dataset)
+async def create_dataset(dataset: DatasetCreate, db: Session = Depends(get_db)):
+    db_dataset = Dataset(**dataset.dict(exclude_unset=True))
+    db.add(db_dataset)
+    db.commit()
+    db.refresh(db_dataset)
+    return db_dataset
+
+@router.post("/models", response_model=Model)
+async def create_model(model: ModelCreate, db: Session = Depends(get_db)):
+    db_model = Model(**model.dict(exclude_unset=True))
+    db.add(db_model)
+    db.commit()
+    db.refresh(db_model)
+    return db_model
+
+@router.post("/experiments", response_model=Experiment)
+async def create_experiment(experiment: ExperimentCreate, db: Session = Depends(get_db)):
+    db_experiment = Experiment(**experiment.dict(exclude_unset=True))
+    db.add(db_experiment)
+    db.commit()
+    db.refresh(db_experiment)
+    return db_experiment
+
+@router.post("/artifacts", response_model=Artifact)
+async def create_artifact(artifact: ArtifactCreate, db: Session = Depends(get_db)):
+    db_artifact = Artifact(**artifact.dict(exclude_unset=True))
+    db.add(db_artifact)
+    db.commit()
+    db.refresh(db_artifact)
+    return db_artifact