Update app.py

app.py

@@ -5,101 +5,217 @@ from fastapi.responses import JSONResponse
 import uvicorn
 from sklearn.linear_model import LinearRegression
 from sklearn.model_selection import train_test_split
+import base64
+import os
+from datetime import datetime
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from io import BytesIO
 
 # Hardcoded mappings
 weather_map = {"Cloudy": 0, "Rainy": 1, "Sunny": 2}
 
 # Load and preprocess training data
-df = pd.read_csv("new_delay_data.csv")
-
-# Encode categorical features
-df = pd.get_dummies(df, columns=["Phase"], drop_first=True)  # Finishing as baseline
-df["Weather"] = df["Weather"].map(weather_map)
-
-# Handle missing or invalid mappings
-df.dropna(subset=["Phase_Framing", "Phase_Foundation", "Weather", "Absentee", "DelayLog", "Delay%"], inplace=True)
+print("Loading and preprocessing data...")
+try:
+    if not os.path.exists("new_delay_data.csv"):
+        print("Warning: new_delay_data.csv not found. Using default dataset.")
+        default_data = {
+            "Phase": ["Framing", "Foundation", "Finishing"],
+            "Weather": ["Sunny", "Rainy", "Cloudy"],
+            "Absentee": [10, 20, 5],
+            "DelayLog": [5, 10, 2],
+            "Delay%": [30, 60, 15]
+        }
+        df = pd.DataFrame(default_data)
+    else:
+        df = pd.read_csv("new_delay_data.csv")
+    
+    df = pd.get_dummies(df, columns=["Phase"], drop_first=True)  # Finishing as baseline
+    df["Weather"] = df["Weather"].map(weather_map)
+    df.dropna(subset=["Weather", "Absentee", "DelayLog", "Delay%"], inplace=True)
+    
+    for col in ["Phase_Framing", "Phase_Foundation"]:
+        if col not in df.columns:
+            df[col] = 0
+    print("Data loaded and preprocessed successfully. Columns:", df.columns.tolist())
+except Exception as e:
+    print(f"Error loading data: {e}")
+    raise
 
 # Split features and target
-X = df[["Phase_Framing", "Phase_Foundation", "Weather", "Absentee", "DelayLog"]]
-y = df["Delay%"]
+try:
+    X = df[["Phase_Framing", "Phase_Foundation", "Weather", "Absentee", "DelayLog"]]
+    y = df["Delay%"]
+except Exception as e:
+    print(f"Error preparing features: {e}")
+    raise
 
 # Train model
-model = LinearRegression()
-model.fit(X, y)
+print("Training model...")
+try:
+    model = LinearRegression()
+    model.fit(X, y)
+    print("Model trained successfully.")
+except Exception as e:
+    print(f"Error training model: {e}")
+    raise
+
+# Function to generate simple PDF and return base64-encoded string
+def generate_pdf_report(phase, weather, absentee_pct, delay_log, prediction, risk, insight):
+    print("Generating PDF report...")
+    try:
+        buffer = BytesIO()
+        c = canvas.Canvas(buffer, pagesize=letter)
+        c.setFont("Helvetica", 12)
+        
+        c.drawString(100, 750, "Project Delay Prediction Report")
+        c.drawString(100, 730, f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        y_position = 700
+        details = [
+            f"Phase: {phase}",
+            f"Weather: {weather}",
+            f"Absentee Percentage: {absentee_pct}%",
+            f"Previous Delay Log: {delay_log}",
+            f"Predicted Delay: {prediction}%",
+            f"Risk Level: {risk}",
+            f"AI Insight: {insight}"
+        ]
+        for line in details:
+            c.drawString(100, y_position, line)
+            y_position -= 20
+        
+        c.showPage()
+        c.save()
+        
+        pdf_data = buffer.getvalue()
+        buffer.close()
+        pdf_base64 = base64.b64encode(pdf_data).decode("utf-8")
+        
+        output_dir = "pdf_reports"
+        os.makedirs(output_dir, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = os.path.join(output_dir, f"delay_report_{timestamp}.pdf")
+        with open(output_path, "wb") as f:
+            f.write(pdf_data)
+        print(f"PDF saved locally at: {output_path}")
+        
+        return pdf_base64, output_path
+    except Exception as e:
+        print(f"PDF generation failed: {e}")
+        return None, None
 
 # Main prediction function
 def predict_delay(phase, weather, absentee_pct, delay_log):
-    # Encode phase as dummy variables
-    framing = 1 if phase == "Framing" else 0
-    foundation = 1 if phase == "Foundation" else 0
-    weather_encoded = weather_map.get(weather, 0)
-    input_data = [[framing, foundation, weather_encoded, absentee_pct, delay_log]]
-    
-    # Model makes prediction
-    prediction = model.predict(input_data)[0]
-    prediction = round(prediction, 2)
-
-    # Risk tagging based on predicted delay percentage
-    if prediction >= 75:
-        risk = "High Risk"
-    elif prediction >= 50:
-        risk = "Moderate Risk"
-    else:
-        risk = "Low Risk"
+    print(f"Predicting delay for Phase: {phase}, Weather: {weather}, Absentee: {absentee_pct}, Delay Log: {delay_log}")
+    try:
+        valid_phases = ["Framing", "Foundation", "Finishing"]
+        valid_weather = ["Sunny", "Rainy", "Cloudy"]
+        phase = phase if isinstance(phase, str) and phase in valid_phases else "Framing"
+        weather = weather if isinstance(weather, str) and weather in valid_weather else "Sunny"
+        absentee_pct = float(absentee_pct) if isinstance(absentee_pct, (int, float, str)) and float(absentee_pct) >= 0 else 0
+        delay_log = float(delay_log) if isinstance(delay_log, (int, float, str)) and float(delay_log) >= 0 else 0
 
-    # AI reasoning for insights
-    insight = f"Phase: {phase}, Weather: {weather}, Absenteeism: {absentee_pct}%, Previous Delay: {delay_log} → Risk: {risk}"
+        framing = 1 if phase == "Framing" else 0
+        foundation = 1 if phase == "Foundation" else 0
+        weather_encoded = weather_map.get(weather, 0)
+        input_data = [[framing, foundation, weather_encoded, absentee_pct, delay_log]]
 
-    return prediction, risk, insight
+        prediction = model.predict(input_data)[0]
+        prediction = round(prediction, 2)
+
+        if prediction >= 75:
+            risk = "High Risk"
+        elif prediction >= 50:
+            risk = "Moderate Risk"
+        else:
+            risk = "Low Risk"
+
+        insight = f"Phase: {phase}, Weather: {weather}, Absenteeism: {absentee_pct}%, Previous Delay: {delay_log} → Risk: {risk}"
+
+        pdf_base64, pdf_path = generate_pdf_report(phase, weather, absentee_pct, delay_log, prediction, risk, insight)
+
+        return prediction, risk, insight, pdf_base64, pdf_path
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        return None, None, f"Error: {e}", None, None
 
 # FastAPI for Salesforce
 api_app = FastAPI()
 
 @api_app.post("/predict")
 async def predict_from_salesforce(request: Request):
+    print("Received API request...")
     try:
         data = await request.json()
         phase = data.get("phase", "Framing")
         weather = data.get("weather", "Sunny")
-        absentee_pct = float(data.get("absentee_pct", 0))
-        delay_log = float(data.get("delay_log", 0))
+        absentee_pct = data.get("absentee_pct", 0)
+        delay_log = data.get("delay_log", 0)
 
-        prediction, risk, insight = predict_delay(phase, weather, absentee_pct, delay_log)
+        prediction, risk, insight, pdf_base64, pdf_path = predict_delay(phase, weather, absentee_pct, delay_log)
+
+        if prediction is None:
+            return JSONResponse(status_code=500, content={"status": "error", "message": insight})
 
         return JSONResponse(content={
             "delay_probability": prediction,
             "risk_alert": risk,
             "ai_insight": insight,
+            "pdf_report_base64": pdf_base64 if pdf_base64 else "",
+            "pdf_local_path": pdf_path if pdf_path else "PDF generation failed",
             "status": "success"
         })
     except Exception as e:
+        print(f"API error: {e}")
         return JSONResponse(status_code=500, content={"status": "error", "message": str(e)})
 
 # Gradio UI for manual testing
-with gr.Blocks() as demo:
-    gr.Markdown("## 🏗️ Delay Predictor")
-    with gr.Row():
-        phase_input = gr.Textbox(label="Phase (Framing/Foundation/Finishing)")
-        weather_input = gr.Textbox(label="Weather (Sunny/Rainy/Cloudy)")
-    with gr.Row():
-        absentee_input = gr.Number(label="Absentee %")
-        delay_input = gr.Number(label="Previous Delay Log")
-    output = gr.Textbox(label="Prediction Summary")
-
-    def predict_and_format(phase, weather, absentee, delay_log):
-        prediction, risk, insight = predict_delay(phase, weather, absentee, delay_log)
-        return f"Predicted Delay: {prediction}%\nRisk Level: {risk}\nInsight: {insight}"
-
-    submit = gr.Button("Predict")
-    submit.click(
-        predict_and_format,
-        inputs=[phase_input, weather_input, absentee_input, delay_input],
-        outputs=output
-    )
+try:
+    print("Setting up Gradio UI...")
+    with gr.Blocks() as demo:
+        gr.Markdown("## 🏗️ Delay Predictor")
+        with gr.Row():
+            phase_input = gr.Textbox(label="Phase (Framing/Foundation/Finishing)", value="Framing")
+            weather_input = gr.Textbox(label="Weather (Sunny/Rainy/Cloudy)", value="Sunny")
+        with gr.Row():
+            absentee_input = gr.Number(label="Absentee %", value=0)
+            delay_input = gr.Number(label="Previous Delay Log", value=0)
+        output = gr.Textbox(label="Prediction Summary")
+        submit = gr.Button("Predict")
+
+        def predict_and_format(phase, weather, absentee, delay_log):
+            print("Gradio predict button clicked.")
+            prediction, risk, insight, pdf_base64, pdf_path = predict_delay(phase, weather, absentee, delay_log)
+            if prediction is None:
+                return f"Error: {insight}"
+            return f"Predicted Delay: {prediction}%\nRisk Level: {risk}\nInsight: {insight}\nPDF Report: {'Saved locally at ' + pdf_path if pdf_path else 'Failed to generate'}\nPDF Base64: {'Generated' if pdf_base64 else 'Not generated'}"
+
+        submit.click(
+            predict_and_format,
+            inputs=[phase_input, weather_input, absentee_input, delay_input],
+            outputs=output
+        )
+    print("Gradio UI setup complete.")
+except Exception as e:
+    print(f"Error setting up Gradio UI: {e}")
+    raise
 
 # Mount Gradio inside FastAPI
-app = gr.mount_gradio_app(api_app, demo, path="/")
-
-# Run locally (Hugging Face will ignore this)
+try:
+    print("Mounting Gradio app...")
+    app = gr.mount_gradio_app(api_app, demo, path="/")
+    print("Gradio app mounted successfully.")
+except Exception as e:
+    print(f"Error mounting Gradio app: {e}")
+    raise
+
+# Run locally
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)  
+    print("Starting server on http://0.0.0.0:7860...")
+    try:
+        uvicorn.run(app, host="0.0.0.0", port=7860)
+    except Exception as e:
+        print(f"Server failed to start: {e}")
+        raise