revised dockerfile, package, server,app_new, and add api

Dockerfile

@@ -1,28 +1,14 @@
-FROM python:3.11-slim
-
-# 安装 Node（用于构建前端）
-RUN apt-get update && apt-get install -y curl gnupg && \
-    curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
-    apt-get install -y nodejs && \
-    rm -rf /var/lib/apt/lists/*
-
+FROM node:18 AS build
 WORKDIR /app
-
-# 前端依赖优先装
-COPY package.json package-lock.json* yarn.lock* pnpm-lock.yaml* .npmrc* ./
-RUN if [ -f package-lock.json ]; then npm ci; \
-    elif [ -f yarn.lock ]; then yarn install --frozen-lockfile; \
-    elif [ -f pnpm-lock.yaml ]; then npm i -g pnpm && pnpm i --frozen-lockfile; \
-    else npm i; fi
-
-# 复制全部代码（包含 src/, index.html, server.py 等）
+COPY package*.json ./
+RUN npm install
 COPY . .
-
-# 构建前端（Vite -> dist/）
 RUN npm run build
 
-# Python 依赖
-RUN pip install --no-cache-dir -r requirements.txt
-
-EXPOSE 7860
+FROM python:3.10
+WORKDIR /app
+COPY --from=build /app/dist ./dist
+COPY server.py ./
+RUN pip install fastapi uvicorn huggingface_hub
+ENV PORT=7860
 CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

package.json

@@ -1,23 +1,21 @@
 {
-  "name": "asset-choice-space",
+  "name": "hf-asset-annotator",
+  "version": "1.0.0",
   "private": true,
-  "version": "0.0.2",
-  "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "preview": "vite preview --port 7860 --strictPort"
+    "preview": "vite preview"
   },
   "dependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "recharts": "^2.12.7"
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "recharts": "^2.7.2"
   },
   "devDependencies": {
-    "typescript": "^5.4.0",
-    "vite": "^5.2.0",
-    "@vitejs/plugin-react": "^4.2.0",
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0"
+    "typescript": "^5.3.3",
+    "vite": "^5.0.0",
+    "@types/react": "^18.2.17",
+    "@types/react-dom": "^18.2.7"
   }
-}
+}

server.py

@@ -1,122 +1,107 @@
-from fastapi import FastAPI, UploadFile, File, HTTPException
-from fastapi.responses import JSONResponse, HTMLResponse
+import os
+import io
+import json
+from typing import Any, Dict, List, Optional
+from fastapi import FastAPI, Query, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
-from datetime import datetime
-import os, json, uuid, pathlib
+from datetime import datetime, timezone
+from huggingface_hub import HfApi, upload_file, hf_hub_download, create_repo
 
+# === Configuration ===
+REPO_ID = os.environ.get("STORE_REPO", "your-org/asset-annotator-store")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+api = HfApi(token=HF_TOKEN)
 app = FastAPI()
 
-# 允许前端访问（你也可以改成你的域名）
+# Allow local frontend access
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
-    allow_headers=["*"],
+    allow_credentials=True,
     allow_methods=["*"],
+    allow_headers=["*"],
 )
 
-DATA_DIR = pathlib.Path("./data")
-DATA_DIR.mkdir(exist_ok=True)
-RUN_DIR = DATA_DIR / "runs"
-RUN_DIR.mkdir(parents=True, exist_ok=True)
 
-DIST_DIR = pathlib.Path("./dist")  # Vite build 输出目录
+def ensure_repo():
+    try:
+        create_repo(REPO_ID, repo_type="dataset", exist_ok=True, token=HF_TOKEN)
+    except Exception:
+        pass
 
-# ========== 数据集：上传与获取 ==========
 
-@app.post("/api/upload")
-async def upload_dataset(file: UploadFile = File(...)):
-    if not file.filename.endswith(".json"):
-        raise HTTPException(status_code=400, detail="Only .json allowed")
+def upload_json(path_in_repo: str, obj: Any, message: str):
+    ensure_repo()
+    buf = io.BytesIO(json.dumps(obj, ensure_ascii=False, indent=2).encode("utf-8"))
+    upload_file(
+        path_or_fileobj=buf,
+        path_in_repo=path_in_repo,
+        repo_id=REPO_ID,
+        repo_type="dataset",
+        token=HF_TOKEN,
+        commit_message=message,
+    )
+
+
+def download_json(path_in_repo: str) -> Optional[Any]:
     try:
-        raw = await file.read()
-        payload = json.loads(raw.decode("utf-8"))
-
-        keys = list(payload.keys())
-        if not keys:
-            raise ValueError("Empty dataset")
-        first = payload[keys[0]]
-        if not isinstance(first, list) or not first or "date" not in first[0] or "close" not in first[0]:
-            raise ValueError("Invalid series format (need { TICKER: [{date, close}, ...] })")
-
-        # 生成数据集 ID，并保存为只读源
-        dsid = uuid.uuid4().hex[:12]
-        out_path = DATA_DIR / f"{dsid}.json"
-        out_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
-        return {"id": dsid}
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.get("/api/dataset/{dsid}")
-def get_dataset(dsid: str):
-    path = DATA_DIR / f"{dsid}.json"
-    if not path.exists():
-        raise HTTPException(status_code=404, detail="Not found")
-    return JSONResponse(json.loads(path.read_text(encoding="utf-8")))
-
-# ========== 运行结果（每人一份，不覆盖数据集） ==========
-
-class RunPayload(BaseModel):
+        local = hf_hub_download(repo_id=REPO_ID, repo_type="dataset", filename=path_in_repo, token=HF_TOKEN)
+        with open(local, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+@app.get("/api/health")
+def health():
+    return {"ok": True, "repo": REPO_ID}
+
+
+class Dataset(BaseModel):
+    dataset_id: str
+    name: str
+    data: Dict[str, List[Dict[str, Any]]]
+    assets: List[str]
+    dates: List[str]
+
+
+class Annotation(BaseModel):
     dataset_id: str
-    email: str | None = None
-    note: str | None = None
-    selections: list[dict]
-    portfolio: list[dict]
-    stats: dict
-    meta: dict | None = None
-
-@app.post("/api/submit_run")
-def submit_run(payload: RunPayload):
-    ds_path = DATA_DIR / f"{payload.dataset_id}.json"
-    if not ds_path.exists():
-        raise HTTPException(status_code=400, detail="dataset_id not found")
-
-    run_id = uuid.uuid4().hex[:12]
-    run_path = RUN_DIR / payload.dataset_id
-    run_path.mkdir(parents=True, exist_ok=True)
-
-    record = {
-        "run_id": run_id,
-        "dataset_id": payload.dataset_id,
-        "created_at": datetime.utcnow().isoformat() + "Z",
-        "payload": payload.model_dump(),
-    }
-    out = run_path / f"{run_id}.json"
-    out.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
-    return {"run_id": run_id}
-
-@app.get("/api/list_runs/{dataset_id}")
-def list_runs(dataset_id: str):
-    path = RUN_DIR / dataset_id
-    if not path.exists():
-        return {"dataset_id": dataset_id, "runs": []}
-    items = []
-    for p in sorted(path.glob("*.json")):
-        try:
-            obj = json.loads(p.read_text(encoding="utf-8"))
-            items.append({
-                "run_id": obj.get("run_id"),
-                "created_at": obj.get("created_at"),
-                "email": obj.get("payload", {}).get("email"),
-                "N": obj.get("payload", {}).get("stats", {}).get("N"),
-                "cumRet": obj.get("payload", {}).get("stats", {}).get("cumRet"),
-            })
-        except Exception:
-            pass
-    return {"dataset_id": dataset_id, "runs": items}
-
-@app.get("/api/run/{dataset_id}/{run_id}")
-def get_run(dataset_id: str, run_id: str):
-    p = RUN_DIR / dataset_id / f"{run_id}.json"
-    if not p.exists():
-        raise HTTPException(status_code=404, detail="Not found")
-    return JSONResponse(json.loads(p.read_text(encoding="utf-8")))
-
-# ========== 静态资源（前端） ==========
-if DIST_DIR.exists():
-    app.mount("/", StaticFiles(directory=str(DIST_DIR), html=True), name="static")
-else:
-    @app.get("/")
-    def hello():
-        return HTMLResponse("<h3>Build not found. Please run: npm run build</h3>")
+    user_id: str
+    selections: List[Dict[str, Any]]
+    step: int
+    window_len: int
+
+
+@app.post("/api/dataset/upsert")
+def upsert_dataset(ds: Dataset):
+    payload = ds.dict()
+    payload["saved_at"] = datetime.now(timezone.utc).isoformat()
+    upload_json("datasets/latest.json", payload, f"upsert dataset {ds.dataset_id}")
+    return {"ok": True}
+
+
+@app.get("/api/dataset/latest")
+def get_latest():
+    obj = download_json("datasets/latest.json")
+    if obj is None:
+        raise HTTPException(status_code=404, detail="No dataset yet.")
+    return obj
+
+
+@app.get("/api/annotation/get")
+def get_annotation(dataset_id: str = Query(...), user_id: str = Query(...)):
+    obj = download_json(f"annotations/{dataset_id}/{user_id}.json")
+    if obj is None:
+        return {"user_id": user_id, "dataset_id": dataset_id, "selections": [], "step": 1, "window_len": 7}
+    return obj
+
+
+@app.post("/api/annotation/upsert")
+def upsert_annotation(ann: Annotation):
+    payload = ann.dict()
+    payload["updated_at"] = datetime.now(timezone.utc).isoformat()
+    upload_json(f"annotations/{ann.dataset_id}/{ann.user_id}.json", payload, f"upsert annotation {ann.dataset_id}/{ann.user_id}")
+    return {"ok": True}

src/api.ts

@@ -0,0 +1,46 @@
+export type DataDict = Record<string, { date: string; close: number[] }[]>;
+
+export async function apiGetLatestDataset() {
+  const r = await fetch("/api/dataset/latest");
+  if (!r.ok) throw new Error(await r.text());
+  return r.json();
+}
+
+export async function apiUpsertDataset(body: {
+  dataset_id: string;
+  name: string;
+  data: DataDict;
+  assets: string[];
+  dates: string[];
+}) {
+  const r = await fetch("/api/dataset/upsert", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) throw new Error(await r.text());
+  return r.json();
+}
+
+export async function apiGetAnnotation(dataset_id: string, user_id: string) {
+  const url = `/api/annotation/get?dataset_id=${dataset_id}&user_id=${user_id}`;
+  const r = await fetch(url);
+  if (!r.ok) throw new Error(await r.text());
+  return r.json();
+}
+
+export async function apiUpsertAnnotation(body: {
+  dataset_id: string;
+  user_id: string;
+  selections: any[];
+  step: number;
+  window_len: number;
+}) {
+  const r = await fetch("/api/annotation/upsert", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) throw new Error(await r.text());
+  return r.json();
+}