Update app.py

app.py

@@ -1,73 +1,87 @@
-import gradio as gr
-import pandas as pd
-import joblib
-import numpy as np
 from fastapi import FastAPI, HTTPException, Header
 from pydantic import BaseModel
 from reportlab.lib.pagesizes import letter
 from reportlab.pdfgen import canvas
 import base64
 import os
+import logging
+from huggingface_hub import InferenceClient
+import numpy as np
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
 # Load API key from environment variable
 API_KEY = os.getenv("HUGGINGFACE_API_KEY")
 if not API_KEY:
+    logger.error("HUGGINGFACE_API_KEY environment variable not set")
     raise ValueError("HUGGINGFACE_API_KEY environment variable not set")
 
+# Initialize Hugging Face Inference Client
+client = InferenceClient(token=API_KEY)
+
 class VendorLog(BaseModel):
     vendorLogId: str
     vendorId: str
-    workCompletionPercentage: float
-    qualityPercentage: float
-    incidentSeverity: str
-    delayDays: int
+    workDetails: str
+    workCompletionDate: str  # ISO format (e.g., "2025-05-12")
+    actualCompletionDate: str  # ISO format
+    incidentLog: str
+    qualityReport: str
+    vendorLogName: str
+
+def analyze_sentiment(text: str) -> float:
+    """Analyze text sentiment using Hugging Face Inference API."""
+    try:
+        if not text:
+            return 50.0  # Neutral score for empty text
+        result = client.text_classification(text, model="distilbert-base-uncased-finetuned-sst-2-english")
+        score = result[0]['score'] if result[0]['label'] == 'POSITIVE' else 1 - result[0]['score']
+        return score * 100  # Convert to percentage
+    except Exception as e:
+        logger.error(f"Sentiment analysis error: {e}")
+        return 50.0  # Fallback score
 
 def calculate_scores(log: VendorLog):
-    quality_score = log.qualityPercentage
-    timeliness_score = 100.0 if log.delayDays == 0 else 80.0 if log.delayDays <= 3 else 60.0 if log.delayDays <= 7 else 40.0
-    safety_score = 100.0 if log.incidentSeverity == 'None' else 80.0 if log.incidentSeverity == 'Minor' else 50.0 if log.incidentSeverity == 'Major' else 20.0
-    communication_score = (quality_score + timeliness_score + safety_score) / 3
-    return {
-        'qualityScore': quality_score,
-        'timelinessScore': timeliness_score,
-        'safetyScore': safety_score,
-        'communicationScore': communication_score
-    }
+    # Sentiment analysis for work details, quality report, incident log
+    work_completion_score = analyze_sentiment(log.workDetails)
+    quality_score = analyze_sentiment(log.qualityReport)
+    incident_score = analyze_sentiment(log.incidentLog) if log.incidentLog else 100.0  # No incidents = high score
 
-def generate_feedback(score: float, metric: str):
-    if score >= 90:
-        return 'Excellent: Maintain this standard.'
-    elif score >= 70:
-        return 'Good: Continue to improve consistency.'
-    elif score >= 50:
-        return f'Needs Improvement: {metric_feedback(metric)}'
-    else:
-        return f'Poor: {metric_feedback(metric, True)}'
+    # Timeliness score based on date difference
+    from datetime import datetime
+    work_date = datetime.fromisoformat(log.workCompletionDate.replace('Z', '+00:00'))
+    actual_date = datetime.fromisoformat(log.actualCompletionDate.replace('Z', '+00:00'))
+    delay_days = (actual_date - work_date).days
+    timeliness_score = 100.0 if delay_days <= 0 else 80.0 if delay_days <= 3 else 60.0 if delay_days <= 7 else 40.0
 
-def metric_feedback(metric: str, poor: bool = False):
-    if metric == 'Timeliness':
-        return 'Significant delays detected; prioritize timely completion.' if poor else 'Maintain schedules to complete tasks on time.'
-    elif metric == 'Safety':
-        return 'Critical safety issues; review safety procedures.' if poor else 'Implement stricter safety protocols.'
-    elif metric == 'Quality':
-        return 'Low quality output; improve quality control.' if poor else 'Enhance work quality standards.'
-    else:
-        return 'Poor communication; improve team interactions.' if poor else 'Enhance coordination with project teams.'
+    # Safety score (inverse of incident sentiment)
+    safety_score = 100.0 - (incident_score if incident_score < 100.0 else 0.0)
+
+    # Communication score (average of work and quality sentiment)
+    communication_score = (work_completion_score + quality_score) / 2
+
+    return {
+        'qualityScore': round(quality_score, 2),
+        'timelinessScore': round(timeliness_score, 2),
+        'safetyScore': round(safety_score, 2),
+        'communicationScore': round(communication_score, 2),
+        'finalScore': round((quality_score + timeliness_score + safety_score + communication_score) / 4, 2)
+    }
 
 def generate_pdf(vendor_id: str, scores: dict):
     filename = f'report_{vendor_id}.pdf'
     c = canvas.Canvas(filename, pagesize=letter)
     c.setFont('Helvetica', 12)
-    c.drawString(100, 750, f'Vendor Performance Report')
+    c.drawString(100, 750, 'Vendor Performance Report')
     c.drawString(100, 730, f'Vendor ID: {vendor_id}')
     y = 700
     for metric, score in scores.items():
-        feedback = generate_feedback(score, metric.replace('Score', ''))
-        c.drawString(100, y, f'{metric.replace("Score", " Score")}: {score}% ({feedback})')
+        c.drawString(100, y, f'{metric.replace("Score", " Score")}: {score}%')
         y -= 20
-    c.drawString(100, y, f'Final Score: {sum(scores.values()) / 4}%')
     c.save()
     
     with open(filename, 'rb') as f:
@@ -75,6 +89,14 @@ def generate_pdf(vendor_id: str, scores: dict):
     os.remove(filename)
     return pdf_content
 
+def send_alert(vendor_id: str, final_score: float):
+    """Placeholder for alert logic (e.g., email or webhook)."""
+    if final_score < 50:
+        logger.info(f"Alert: Vendor {vendor_id} has low final score ({final_score}%)")
+        # Implement email or webhook notification here
+        return {"vendorId": vendor_id, "message": f"Low performance score ({final_score}%) detected"}
+    return None
+
 @app.post('/score')
 async def score_vendor(log: VendorLog, authorization: str = Header(...)):
     if authorization != f'Bearer {API_KEY}':
@@ -83,13 +105,22 @@ async def score_vendor(log: VendorLog, authorization: str = Header(...)):
     scores = calculate_scores(log)
     pdf_content = generate_pdf(log.vendorId, scores)
     pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
+    alert = send_alert(log.vendorId, scores['finalScore'])
     
     return {
         'vendorLogId': log.vendorLogId,
+        'vendorId': log.vendorId,
+        'vendorLogName': log.vendorLogName,
         'qualityScore': scores['qualityScore'],
         'timelinessScore': scores['timelinessScore'],
         'safetyScore': scores['safetyScore'],
         'communicationScore': scores['communicationScore'],
+        'finalScore': scores['finalScore'],
         'pdfContent': pdf_base64,
-        'pdfUrl': f'/files/report_{log.vendorId}.pdf'
-    }
+        'pdfUrl': f'/files/report_{log.vendorId}.pdf',
+        'alert': alert
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)