Update app.py

app.py

@@ -1,144 +1,40 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI
 from pydantic import BaseModel
-from typing import List, Optional
-import numpy as np
-from datetime import datetime
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="Vendor Scoring API")
-
-# Input model for a single log entry
-class LogEntry(BaseModel):
-    vendor_id: str
-    delay_percentage: Optional[float] = 0.0
-    quality_incident_count: Optional[int] = 0
-    quality_severity: Optional[str] = None
-    safety_incident_count: Optional[int] = 0
-    feedback_score: Optional[float] = 0.0
-
-# Input model for the API request
-class VendorInput(BaseModel):
-    vendor_id: str
-    month: str  # Format: YYYY-MM
-    logs: List[LogEntry]
-    previous_final_score: Optional[float] = None  # For trend detection
-
-# Output model for the API response
-class VendorScore(BaseModel):
-    vendor_id: str
-    month: str
-    quality_score: float
-    timeliness_score: float
-    safety_score: float
-    communication_score: float
-    final_score: float
-    trend_deviation: float
-    alert_flag: bool
-
-@app.post("/score", response_model=VendorScore)
-async def calculate_vendor_score(input_data: VendorInput):
-    try:
-        logger.info(f"Processing score for vendor {input_data.vendor_id} for {input_data.month}")
-
-        # Validate month format (YYYY-MM)
-        try:
-            datetime.strptime(input_data.month, "%Y-%m")
-        except ValueError:
-            raise HTTPException(status_code=400, detail="Invalid month format. Use YYYY-MM.")
-
-        # Initialize scores
-        quality_score = 100.0
-        timeliness_score = 100.0
-        safety_score = 100.0
-        communication_score = 0.0
-        log_count = len(input_data.logs)
-
-        if log_count == 0:
-            raise HTTPException(status_code=400, detail="No logs provided for scoring.")
-
-        # Process logs to calculate scores
-        total_delay_percentage = 0.0
-        total_quality_incidents = 0
-        total_safety_incidents = 0
-        total_feedback_score = 0.0
-        feedback_count = 0
-
-        for log in input_data.logs:
-            # Timeliness: Deduct based on delay percentage
-            total_delay_percentage += log.delay_percentage or 0.0
-
-            # Quality: Deduct based on incident count and severity
-            total_quality_incidents += log.quality_incident_count or 0
-            if log.quality_severity:
-                severity_deduction = {"Low": 5, "Medium": 10, "High": 20}.get(log.quality_severity, 0)
-                quality_score -= severity_deduction * (log.quality_incident_count or 0)
-
-            # Safety: Deduct based on safety incident count
-            total_safety_incidents += log.safety_incident_count or 0
-
-            # Communication: Average feedback scores
-            if log.feedback_score is not None and log.feedback_score > 0:
-                total_feedback_score += log.feedback_score
-                feedback_count += 1
-
-        # Calculate scores
-        # Timeliness: Reduce score based on average delay percentage
-        avg_delay_percentage = total_delay_percentage / log_count if log_count > 0 else 0.0
-        timeliness_score -= avg_delay_percentage * 0.5  # 1% delay reduces score by 0.5
-
-        # Quality: Further deduct based on total incidents
-        quality_score -= total_quality_incidents * 5  # Each incident reduces score by 5
-        quality_score = max(0, min(100, quality_score))  # Clamp between 0 and 100
-
-        # Safety: Deduct 10 points per safety incident
-        safety_score -= total_safety_incidents * 10
-        safety_score = max(0, min(100, safety_score))  # Clamp between 0 and 100
-
-        # Communication: Average feedback score
-        communication_score = total_feedback_score / feedback_count if feedback_count > 0 else 50.0
-        communication_score = max(0, min(100, communication_score))
-
-        # Calculate final score (weighted average)
-        final_score = (
-            (quality_score * 0.3) +
-            (timeliness_score * 0.3) +
-            (safety_score * 0.2) +
-            (communication_score * 0.2)
-        )
-        final_score = round(final_score, 2)
-
-        # Trend detection: Compare with previous final score
-        trend_deviation = 0.0
-        if input_data.previous_final_score is not None:
-            trend_deviation = round(final_score - input_data.previous_final_score, 2)
-
-        # Alert flag: Trigger if final score is below 60
-        alert_flag = final_score < 60
-
-        # Prepare response
-        response = VendorScore(
-            vendor_id=input_data.vendor_id,
-            month=input_data.month,
-            quality_score=round(quality_score, 2),
-            timeliness_score=round(timeliness_score, 2),
-            safety_score=round(safety_score, 2),
-            communication_score=round(communication_score, 2),
-            final_score=final_score,
-            trend_deviation=trend_deviation,
-            alert_flag=alert_flag
-        )
-
-        logger.info(f"Score calculated successfully for vendor {input_data.vendor_id}")
-        return response
-
-    except Exception as e:
-        logger.error(f"Error processing score: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
-
-@app.get("/health")
-async def health_check():
-    return {"status": "healthy"}
+import uvicorn
+
+app = FastAPI()
+
+# Define the request body structure
+class VendorLog(BaseModel):
+    work_logs: int
+    delay_logs: int
+    quality_logs: int
+    incident_logs: int
+
+# Scoring logic
+@app.post("/score")
+async def calculate_score(logs: VendorLog):
+    # Simple scoring logic (you can customize this)
+    quality_score = (logs.quality_logs / (logs.work_logs + 1)) * 100
+    timeliness_score = (1 - logs.delay_logs / (logs.work_logs + 1)) * 100
+    safety_score = (1 - logs.incident_logs / (logs.work_logs + 1)) * 100
+    communication_score = 50  # Placeholder, adjust based on your logic
+
+    # Final score (average of individual scores)
+    final_score = (quality_score + timeliness_score + safety_score + communication_score) / 4
+
+    # Alert flag logic (example: flag if final score < 50)
+    alert_flag = final_score < 50
+
+    return {
+        "final_score": round(final_score, 2),
+        "alert_flag": alert_flag,
+        "quality_score": round(quality_score, 2),
+        "timeliness_score": round(timeliness_score, 2),
+        "safety_score": round(safety_score, 2),
+        "communication_score": round(communication_score, 2)
+    }
+
+# Run the server
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)