Upload main.py

main.py

@@ -411,17 +411,6 @@ app = FastAPI(
     default_response_class=ORJSONResponse,
 )
 
-# In-memory model state
-@dataclass
-class ModelSlot:
-    model: Optional["DATFIDModel"] = None
-    result: Optional[Any] = None
-
-# Per-ID registry + silent internal stats (not returned)
-model_store: Dict[str, ModelSlot] = {}
-fit_stats: Dict[str, int] = {"fitted": 0, "failed": 0}     # internal only
-fc_stats: Dict[str, int] = {"forecasted": 0, "skipped": 0} # internal only
-
 @app.get("/")
 def root():
     return {"message": "DATFID API is alive."}
@@ -615,265 +604,4 @@ async def modelforecast_file(
     except Exception as e:
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=f"Error during model forecast (file): {str(e)}")
-    
-@app.post("/modelfit_ind/")
-async def modelfit_ind(
-    df: List[Dict] = Body(...),
-    id_col: str = Body(...),
-    time_col: str = Body(...),
-    y: str = Body(...),
-    lag_y: Any = Body(None),
-    lagged_features: Any = Body({}),
-    current_features: Any = Body([]),
-    filter_by_significance: bool = Body(False),
-    meanvar_test: bool = Body(False),
-    signif: Any = Body(0.05),
-):
-    global model_store, fit_stats
-    try:
-        sig_val = float(signif)
-    except (TypeError, ValueError):
-        sig_val = 0.05
-    df1 = pd.DataFrame(df)
-
-    if id_col not in df1.columns:
-        raise HTTPException(status_code=400, detail=f"id_col '{id_col}' not in data.")
-
-    # reset registry + counters
-    model_store = {}
-    fit_stats = {"fitted": 0, "failed": 0}
-
-    per_id_results: Dict[str, Dict[str, Any]] = {}
-
-    for id_val, sub in df1.groupby(id_col, sort=False):
-        key = str(id_val)
-        try:
-            mdl = DATFIDModel(
-                df=sub,
-                id_col=id_col,
-                time_col=time_col,
-                y=y,
-                lag_y=lag_y,
-                lagged_features=lagged_features,
-                current_features=current_features,
-                filter_by_significance=filter_by_significance,
-                meanvar_test=meanvar_test,
-                signif=sig_val,
-            )
-            rj = await run_in_threadpool(mdl.fit)
-            model_store[key] = ModelSlot(model=mdl, result=rj)
-            fit_stats["fitted"] += 1
-            result = rj.result
-            result_dict: Dict[str, Any] = {}
-            for k, v in result.__dict__.items():
-                if isinstance(v, pd.DataFrame):
-                    result_dict[k] = v.to_dict(orient="records")
-                elif isinstance(v, pd.Series):
-                    result_dict[k] = v.to_dict()
-                elif isinstance(v, (list, dict, str, int, float, bool, type(None))):
-                    result_dict[k] = v
-                else:
-                    result_dict[k] = str(v)
-            per_id_results[key] = result_dict
-        except Exception:
-            traceback.print_exc()
-            fit_stats["failed"] += 1
-
-    return per_id_results
-
-@app.post("/modelforecast_ind/")
-async def modelforecast_ind(
-    df_forecast: List[Dict] = Body(...),
-):
-    # Use per-ID models created by /modelfit_ind/
-    global model_store
-    if not model_store:
-        raise HTTPException(status_code=400, detail="No per-ID models. Call /modelfit_ind/ first.")
-
-    dfF = pd.DataFrame(df_forecast)
-
-    # Infer the id column name from any stored model (same as used in fit)
-    try:
-        any_slot = next(iter(model_store.values()))
-        id_col_name = getattr(any_slot.model, "id_col")
-    except StopIteration:
-        raise HTTPException(status_code=400, detail="No per-ID models available.")
-    except Exception:
-        raise HTTPException(status_code=500, detail="Could not infer id column from stored models.")
-
-    if id_col_name not in dfF.columns:
-        raise HTTPException(status_code=400, detail=f"Forecast data must include id column '{id_col_name}'.")
-
-    frames = []
-    for id_val, sub in dfF.groupby(id_col_name, sort=False):
-        key = str(id_val)
-        slot = model_store.get(key)
-        if not slot or not slot.model or not slot.result:
-            continue
-        try:
-            fc = await run_in_threadpool(
-                slot.model.forecast,
-                extern_self=slot.result,
-                df_forecast=sub,
-            )
-            if id_col_name not in fc.columns:
-                fc[id_col_name] = key
-            for col in list(fc.columns):
-                if col and col.lower() == "product":
-                    fc = fc.drop(columns=[col])
-                    break
-            frames.append(fc)
-        except Exception:
-            traceback.print_exc()
-
-    out_df = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
-    return out_df.to_dict(orient="records")
-
-
-@app.post("/modelfit-file_ind/")
-async def modelfit_file_ind(
-    file: UploadFile = File(...),
-    id_col: str = Form(...),
-    time_col: str = Form(...),
-    y: str = Form(...),
-    lag_y: str = Form(""),
-    lagged_features: str = Form(""),
-    current_features: str = Form(""),
-    filter_by_significance: str = Form("false"),
-    meanvar_test: str = Form("false"),
-    signif: str = Form("0.05"),
-):
-    global model_store, fit_stats
-    try:
-        df = _read_table_from_upload(file)
-
-        for col in df.columns:
-            if pd.api.types.is_datetime64_any_dtype(df[col]):
-                df[col] = df[col].astype(str)
-
-        if id_col not in df.columns:
-            raise HTTPException(status_code=400, detail=f"id_col '{id_col}' not in data.")
-
-        lagged = _maybe_json_dict(lagged_features)
-        curr = _maybe_json_list(current_features)
-        filt_sig = str(filter_by_significance).strip().lower() == "true"
-        mv_test = str(meanvar_test).strip().lower() == "true"
-        ly = None if (lag_y is None or lag_y.strip() == "") else lag_y.strip()
-        try:
-            sig_val = float(signif)
-        except (TypeError, ValueError):
-            sig_val = 0.05
-
-        model_store = {}
-        fit_stats = {"fitted": 0, "failed": 0}
-        report_parts: List[str] = []
-
-        for id_val, sub in df.groupby(id_col, sort=False):
-            key = str(id_val)
-            try:
-                mdl = DATFIDModel(
-                    df=sub,
-                    id_col=id_col,
-                    time_col=time_col,
-                    y=y,
-                    lag_y=ly,
-                    lagged_features=lagged,
-                    current_features=curr,
-                    filter_by_significance=filt_sig,
-                    meanvar_test=mv_test,
-                    signif=sig_val,
-                )
-                rj = await run_in_threadpool(mdl.fit)
-                model_store[key] = ModelSlot(model=mdl, result=rj)
-                fit_stats["fitted"] += 1
-                section = f"=== Entity ({id_col}): {key} ===\n\n" + _result_to_text(rj.result)
-                report_parts.append(section)
-            except Exception:
-                traceback.print_exc()
-                fit_stats["failed"] += 1
-
-        report_text = ("\n\n" + "=" * 72 + "\n\n").join(report_parts)
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".txt")
-        tmp.write(report_text.encode("utf-8"))
-        tmp.flush()
-        tmp.close()
-        return FileResponse(
-            tmp.name,
-            media_type="text/plain; charset=utf-8",
-            filename="result.txt",
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Error during model fit (file_ind): {str(e)}")
-
-
-@app.post("/modelforecast-file_ind/")
-async def modelforecast_file_ind(
-    df_forecast: UploadFile = File(...),
-):
-    global model_store
-    if not model_store:
-        raise HTTPException(status_code=400, detail="No per-ID models. Call /modelfit-file_ind/ or /modelfit_ind/ first.")
-    try:
-        df_fc = _read_table_from_upload(df_forecast)
-        for col in df_fc.columns:
-            if pd.api.types.is_datetime64_any_dtype(df_fc[col]):
-                df_fc[col] = df_fc[col].astype(str)
-
-        try:
-            any_slot = next(iter(model_store.values()))
-            id_col_name = getattr(any_slot.model, "id_col")
-        except StopIteration:
-            raise HTTPException(status_code=400, detail="No per-ID models available.")
-        except Exception:
-            raise HTTPException(status_code=500, detail="Could not infer id column from stored models.")
-
-        if id_col_name not in df_fc.columns:
-            raise HTTPException(status_code=400, detail=f"Forecast data must include id column '{id_col_name}'.")
-
-        frames = []
-        for id_val, sub in df_fc.groupby(id_col_name, sort=False):
-            key = str(id_val)
-            slot = model_store.get(key)
-            if not slot or not slot.model or not slot.result:
-                continue
-            try:
-                fc = await run_in_threadpool(
-                    slot.model.forecast,
-                    extern_self=slot.result,
-                    df_forecast=sub,
-                )
-                if id_col_name not in fc.columns:
-                    fc[id_col_name] = key
-                for col in list(fc.columns):
-                    if col and col.lower() == "product":
-                        fc = fc.drop(columns=[col])
-                        break
-                frames.append(fc)
-            except Exception:
-                traceback.print_exc()
-
-        out_df = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
-
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".csv")
-        tmp_path = tmp.name
-        tmp.close()
-        buf = io.StringIO()
-        out_df.to_csv(buf, index=False)
-        csv_text = buf.getvalue()
-        csv_text = "sep=,\n" + csv_text
-        with open(tmp_path, "w", encoding="utf-8-sig", newline="") as f:
-            f.write(csv_text)
-
-        return FileResponse(
-            tmp_path,
-            media_type="text/csv; charset=utf-8",
-            filename="forecast.csv",
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Error during model forecast (file_ind): {str(e)}")
+