dashboard and backend updates

LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

app/api/routes.py

@@ -1,19 +1,16 @@
 # app/api/routes.py
 # /predict, /health, /dashboard, /monitoring/run
 
-from fastapi import APIRouter, BackgroundTasks, UploadFile, File, Request
+from fastapi import APIRouter, BackgroundTasks, UploadFile, File, Request, HTTPException
 from fastapi.responses import JSONResponse
 from fastapi.templating import Jinja2Templates
-from app.api.schemas import PredictionRequest, PredictionResponse
+
 from app.inference.predictor import Predictor
-from app.core.logging import log_prediction
 from app.monitoring.data_loader import load_production_data
 from app.monitoring.drift import run_drift_check
 from app.monitoring.governance import run_governance_checks
+
 import pandas as pd
-import os
-from app.core.templates import templates
-from fastapi.templating import Jinja2Templates
 
 templates = Jinja2Templates(directory="app/templates")
 
@@ -21,33 +18,58 @@ router = APIRouter()
 predictor = Predictor()
 
 
-# Endpoint for CSV upload & prediction with drift
+# CSV upload & prediction
 @router.post("/predict")
 async def predict_file(
     background_tasks: BackgroundTasks,
     file: UploadFile = File(...)
 ):
     df = pd.read_csv(file.file)
-    predictions, probability = predictor.predict(df)
 
+    # ---- STRICT MODE: schema enforcement ----
+    missing = set(predictor.features) - set(df.columns)
+    if missing:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid schema. Missing required columns: {sorted(missing)}"
+        )
+
+    # ---- Model inference ----
+    preds, probas = predictor.predict(df)
+
+    results = []
+    for i, (pred, proba) in enumerate(zip(preds, probas)):
+        results.append({
+            "row": i,
+            "probability": round(float(proba), 4),
+            "prediction": "Default" if pred == 1 else "No Default",
+            "risk_level": (
+                "High" if proba >= 0.75 else
+                "Medium" if proba >= 0.5 else
+                "Low"
+            )
+        })
+
+    # ---- Drift scheduled in background ----
     reference_df = pd.read_csv("models/v1/reference_data.csv")
     background_tasks.add_task(
-        run_drift_check, df, reference_df, "v1"
+        run_drift_check, df[predictor.features], reference_df[predictor.features], "v1"
     )
 
     return JSONResponse({
-        "predictions": predictions.tolist() if hasattr(predictions, "tolist") else predictions,
+        "n_rows": len(results),
+        "results": results,
         "drift": "scheduled"
     })
 
 
-
-
+# Health
 @router.get("/health")
 def health():
     return {"status": "ok"}
 
 
+# Manual drift run
 @router.get("/run-drift")
 def run_drift():
     current_df = load_production_data()
@@ -58,23 +80,31 @@ def run_drift():
     }
 
 
+# Monitoring pipeline
 @router.get("/monitoring/run")
 def monitoring_run(background_tasks: BackgroundTasks, model_version: str = "v1"):
-    """
-    Run production monitoring including drift + governance checks in background.
-    """
-    # Load current and reference data
     current_data = pd.read_csv("data/processed/current_data.csv")
-    reference_data = pd.read_csv("data/processed/credit_default_clean.csv")  # reference
+    reference_data = pd.read_csv("data/processed/credit_default_clean.csv")
 
-    # Schedule background tasks
-    background_tasks.add_task(run_drift_check, current_data, reference_data, model_version=model_version)
-    background_tasks.add_task(run_governance_checks, current_data, model_version=model_version)
+    background_tasks.add_task(
+        run_drift_check,
+        current_data[predictor.features],
+        reference_data[predictor.features],
+        model_version
+    )
+    background_tasks.add_task(
+        run_governance_checks,
+        current_data,
+        model_version=model_version
+    )
 
-    return {"status": "monitoring triggered", "model_version": model_version}
+    return {
+        "status": "monitoring triggered",
+        "model_version": model_version
+    }
 
 
-# Dashboard endpoint
+# Dashboard
 @router.get("/dashboard")
 def dashboard(request: Request):
     return templates.TemplateResponse(

app/inference/predictor.py

@@ -12,8 +12,8 @@ class Predictor:
         with open(FEATURES_PATH, "r") as f:
             self.features = json.load(f)
 
-    def predict(self, payload: dict):
-        X = np.array([[payload[f] for f in self.features]])
-        proba = self.model.predict_proba(X)[0, 1]
-        pred = int(proba >= 0.5)
-        return pred, float(proba)
+    def predict(self, df):
+        X = df[self.features]
+        probas = self.model.predict_proba(X)[:, 1]
+        preds = (probas >= 0.5).astype(int)
+        return preds.tolist(), probas.tolist()

app/templates/dashboard.html

@@ -20,33 +20,49 @@
     <h2>Drift Metrics</h2>
     <div id="drift-chart"></div>
 
-    <script>
-        async function fetchResults(csvFile) {
-            const formData = new FormData();
-            formData.append("file", csvFile);
+<script>
+    async function fetchResults(csvFile) {
+        const formData = new FormData();
+        formData.append("file", csvFile);
 
-            const response = await fetch("/predict", { method: "POST", body: formData });
-            const data = await response.json();
+        const response = await fetch("/predict", {
+            method: "POST",
+            body: formData
+        });
+
+        const data = await response.json();
+
+        /* ---- Predictions (FIXED) ---- */
+        document.getElementById("predictions").innerHTML =
+            `<pre>${JSON.stringify(data.predictions, null, 2)}</pre>`;
 
-            // Show predictions
-            document.getElementById("predictions").innerHTML = 
-                `<pre>${JSON.stringify(data.predictions, null, 2)}</pre>`;
+        /* ---- Drift (GUARDED) ---- */
+        const driftContainer = document.getElementById("drift-chart");
+        driftContainer.innerHTML = "";
 
-            // Show simplified drift chart
-            const drift = data.drift || [];
-            const cols = drift.map(d => d.column);
-            const scores = drift.map(d => d.score);
+        if (Array.isArray(data.drift)) {
+            const cols = data.drift.map(d => d.column);
+            const scores = data.drift.map(d => d.score);
 
-            const trace = { x: cols, y: scores, type: 'bar' };
-            Plotly.newPlot('drift-chart', [trace]);
+            Plotly.newPlot(driftContainer, [{
+                x: cols,
+                y: scores,
+                type: "bar"
+            }]);
+        } else {
+            driftContainer.innerHTML =
+                "<p>Drift report scheduled. Open the Evidently HTML report.</p>";
         }
+    }
 
-        document.getElementById("upload-form").addEventListener("submit", async (e) => {
-            e.preventDefault();
-            const fileInput = e.target.file.files[0];
-            if (fileInput) await fetchResults(fileInput);
-        });
-    </script>
+    document.getElementById("upload-form").addEventListener("submit", async (e) => {
+        e.preventDefault();
+        const fileInput = e.target.file.files[0];
+        if (fileInput) {
+            await fetchResults(fileInput);
+        }
+    });
+</script>
 </body>
 </html>