Update app.py

app.py

@@ -8,27 +8,34 @@ import logging
 from datetime import datetime
 from fastapi.responses import HTMLResponse
 from simple_salesforce import Salesforce
-import json
+from dotenv import load_dotenv
+from datasets import load_dataset  # For Hugging Face
 
-# Set up logging to capture errors and debug information
-logging.basicConfig(level=logging.INFO)
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-# Salesforce credentials
-SF_USERNAME = os.getenv("SF_USERNAME", "scores@app.com")
-SF_PASSWORD = os.getenv("SF_PASSWORD", "Internal@1")
-SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN", "NbUKcTx45azba5HEdntE9YAh")
+# Environment variables
+SF_USERNAME = os.getenv("SF_USERNAME")
+SF_PASSWORD = os.getenv("SF_PASSWORD")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
 SF_DOMAIN = os.getenv("SF_DOMAIN", "login")
-
-# Verify API key is set
 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")
 
-# Connect to Salesforce
+# Validate environment variables
+required_env_vars = ["SF_USERNAME", "SF_PASSWORD", "SF_SECURITY_TOKEN", "HUGGINGFACE_API_KEY"]
+for var in required_env_vars:
+    if not os.getenv(var):
+        logger.error(f"Environment variable {var} is not set")
+        raise ValueError(f"Environment variable {var} is not set")
+
+# Salesforce connection
+sf = None
 try:
     sf = Salesforce(
         username=SF_USERNAME,
@@ -39,9 +46,9 @@ try:
     logger.info("Successfully connected to Salesforce")
 except Exception as e:
     logger.error(f"Failed to connect to Salesforce: {str(e)}")
-    raise
+    raise RuntimeError(f"Cannot connect to Salesforce: {str(e)}")
 
-# VendorLog model to match Salesforce data
+# VendorLog model
 class VendorLog(BaseModel):
     vendorLogId: str
     vendorId: str
@@ -55,15 +62,58 @@ class VendorLog(BaseModel):
     delayDays: int
     project: str
 
-# Store vendor logs for display
+# Store vendor logs
 vendor_logs = []
 
+def validate_salesforce_fields():
+    """Validate required Salesforce fields"""
+    try:
+        vendor_log_fields = [f['name'] for f in sf.Vendor_Log__c.describe()['fields']]
+        required_vendor_fields = [
+            'Vendor__c', 'Work_Completion_Percentage__c', 'Quality_Percentage__c',
+            'Incident_Severity__c', 'Work_Completion_Date__c', 'Actual_Completion_Date__c',
+            'Delay_Days__c', 'Project__c'
+        ]
+        for field in required_vendor_fields:
+            if field not in vendor_log_fields:
+                logger.error(f"Field {field} not found in Vendor_Log__c")
+                raise ValueError(f"Field {field} not found in Vendor_Log__c")
+
+        score_fields = [f['name'] for f in sf.Subcontractor_Performance_Score__c.describe()['fields']]
+        required_score_fields = [
+            'Vendor_Log__c', 'Vendor__c', 'Quality_Score__c', 'Timeliness_Score__c',
+            'Safety_Score__c', 'Communication_Score__c', 'Alert_Flag__c', 'PDF_Link__c'
+        ]
+        for field in required_score_fields:
+            if field not in score_fields:
+                logger.error(f"Field {field} not found in Subcontractor_Performance_Score__c")
+                raise ValueError(f"Field {field} not found in Subcontractor_Performance_Score__c")
+        logger.info("Salesforce fields validated successfully")
+    except Exception as e:
+        logger.error(f"Error validating Salesforce fields: {str(e)}")
+        raise
+
+# Validate fields on startup
+validate_salesforce_fields()
+
+def fetch_huggingface_records(dataset_name: str = "imdb"):
+    """Fetch records from a Hugging Face dataset."""
+    try:
+        os.environ["HUGGINGFACE_TOKEN"] = API_KEY
+        dataset = load_dataset(dataset_name)
+        logger.info(f"Successfully fetched dataset: {dataset_name}")
+        records = [record for record in dataset['train']]  # Assuming 'train' split
+        return records[:10]  # Limit to 10 records for demonstration
+    except Exception as e:
+        logger.error(f"Error fetching Hugging Face dataset {dataset_name}: {str(e)}")
+        return []
+
 def fetch_vendor_logs_from_salesforce():
     try:
         query = """
-        SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, Incident_Severity__c, 
-               Work_Completion_Date__c, Actual_Completion_Date__c, Delay_Days__c,Project__c
-               
+        SELECT Id, Name, Vendor__c, Work_Completion_Percentage__c, Quality_Percentage__c, 
+               Incident_Severity__c, Work_Completion_Date__c, Actual_Completion_Date__c, 
+               Delay_Days__c, Project__c
         FROM Vendor_Log__c
         """
         result = sf.query_all(query)
@@ -73,43 +123,36 @@ def fetch_vendor_logs_from_salesforce():
                 logger.warning(f"Skipping Vendor_Log__c record with ID {record['Id']} due to missing Vendor__c")
                 continue
             log = VendorLog(
-                vendorLogId=record['Id'] or "Unknown",
-                vendorId=record['Name'] or "Unknown",
-                vendorRecordId=record['Vendor__c'] or "Unknown",
-                workDetails=str(record['Work_Completion_Percentage__c'] or "0.0"),
-                qualityReport=str(record['Quality_Percentage__c'] or "0.0"),
-                incidentLog=record['Incident_Severity__c'] or "None",
-                workCompletionDate=record['Work_Completion_Date__c'] or "N/A",
-                actualCompletionDate=record['Actual_Completion_Date__c'] or "N/A",
-                vendorLogName=record['Name'] or "Unknown",
-                delayDays=int(record['Delay_Days__c'] or 0),
-                 project=record['Project__c'] or "Unknown"
+                vendorLogId=record.get('Id', 'Unknown'),
+                vendorId=record.get('Name', 'Unknown'),
+                vendorRecordId=record.get('Vendor__c', 'Unknown'),
+                workDetails=str(record.get('Work_Completion_Percentage__c', 0.0)),
+                qualityReport=str(record.get('Quality_Percentage__c', 0.0)),
+                incidentLog=record.get('Incident_Severity__c', 'None'),
+                workCompletionDate=record.get('Work_Completion_Date__c', 'N/A'),
+                actualCompletionDate=record.get('Actual_Completion_Date__c', 'N/A'),
+                vendorLogName=record.get('Name', 'Unknown'),
+                delayDays=int(record.get('Delay_Days__c', 0)),
+                project=record.get('Project__c', 'Unknown')
             )
             logs.append(log)
+        logger.info(f"Fetched {len(logs)} vendor logs")
         return logs
     except Exception as e:
         logger.error(f"Error fetching vendor logs from Salesforce: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error fetching vendor logs: {str(e)}")
 
 def calculate_scores(log: VendorLog):
     try:
-        work_completion_percentage = float(log.workDetails)
-        quality_percentage = float(log.qualityReport)
+        work_completion_percentage = float(log.workDetails or 0.0)
+        quality_percentage = float(log.qualityReport or 0.0)
 
-        # Quality Score: Directly use the quality percentage
         quality_score = quality_percentage
-
-        # Timeliness Score: Based on delay days
         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: Based on incident severity
         severity_map = {'None': 100.0, 'Low': 80.0, 'Minor': 80.0, 'Medium': 50.0, 'High': 20.0}
         safety_score = severity_map.get(log.incidentLog, 100.0)
-
-        # Communication Score: Weighted average of other scores
         communication_score = (quality_score * 0.33 + timeliness_score * 0.33 + safety_score * 0.33)
 
-        # Removed finalScore calculation since Final_Score__c is a Formula field
         return {
             'qualityScore': round(quality_score, 2),
             'timelinessScore': round(timeliness_score, 2),
@@ -118,7 +161,7 @@ def calculate_scores(log: VendorLog):
         }
     except Exception as e:
         logger.error(f"Error calculating scores: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error calculating scores: {str(e)}")
 
 def get_feedback(score: float, metric: str) -> str:
     try:
@@ -146,11 +189,11 @@ def get_feedback(score: float, metric: str) -> str:
                 return "Poor: Communication issues detected"
     except Exception as e:
         logger.error(f"Error generating feedback: {str(e)}")
-        raise
+        return "Feedback unavailable"
 
 def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
     try:
-        filename = f'report_{vendor_id}.pdf'
+        filename = f'report_{vendor_id}_{datetime.now().strftime("%Y%m%d%H%M%S")}.pdf'
         c = canvas.Canvas(filename, pagesize=letter)
         c.setFont('Helvetica', 12)
         c.drawString(100, 750, 'Subcontractor Performance Report')
@@ -160,7 +203,6 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         c.drawString(100, 670, f'Timeliness Score: {scores["timelinessScore"]}% ({get_feedback(scores["timelinessScore"], "Timeliness")})')
         c.drawString(100, 650, f'Safety Score: {scores["safetyScore"]}% ({get_feedback(scores["safetyScore"], "Safety")})')
         c.drawString(100, 630, f'Communication Score: {scores["communicationScore"]}% ({get_feedback(scores["communicationScore"], "Communication")})')
-        # Removed Final Score from PDF since it's a Formula field
         c.save()
 
         with open(filename, 'rb') as f:
@@ -169,26 +211,23 @@ def generate_pdf(vendor_id: str, vendor_log_name: str, scores: dict):
         return pdf_content
     except Exception as e:
         logger.error(f"Error generating PDF: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error generating PDF: {str(e)}")
 
 def determine_alert_flag(scores: dict, all_logs: list):
     try:
         if not all_logs:
             return False
-        # Since finalScore is a Formula field, we'll need to fetch it from Salesforce or adjust logic
-        # For now, we'll base the alert on the average of other scores
-        avg_score = (scores['qualityScore'] + scores['timelinessScore'] + scores['safetyScore'] + scores['communicationScore']) / 4
+        avg_score = sum(scores.values()) / 4
         if avg_score < 50:
             return True
-        lowest_avg = min([(log['scores']['qualityScore'] + log['scores']['timelinessScore'] + log['scores']['safetyScore'] + log['scores']['communicationScore']) / 4 for log in all_logs])
+        lowest_avg = min([sum(log['scores'].values()) / 4 for log in all_logs], default=avg_score)
         return avg_score == lowest_avg
     except Exception as e:
         logger.error(f"Error determining alert flag: {str(e)}")
-        raise
+        return False
 
 def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes, alert_flag: bool):
     try:
-        # Step 1: Create the Subcontractor_Performance_Score__c record without Final_Score__c
         score_record = sf.Subcontractor_Performance_Score__c.create({
             'Vendor_Log__c': log.vendorLogId,
             'Vendor__c': log.vendorRecordId,
@@ -197,12 +236,10 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'Safety_Score__c': scores['safetyScore'],
             'Communication_Score__c': scores['communicationScore'],
             'Alert_Flag__c': alert_flag
-            # Removed Final_Score__c since it's a Formula field
         })
         score_record_id = score_record['id']
         logger.info(f"Successfully created Subcontractor_Performance_Score__c record with ID: {score_record_id}")
 
-        # Step 2: Upload the PDF as a ContentVersion
         pdf_base64 = base64.b64encode(pdf_content).decode('utf-8')
         content_version = sf.ContentVersion.create({
             'Title': f'Performance_Report_{log.vendorId}',
@@ -210,25 +247,19 @@ def store_scores_in_salesforce(log: VendorLog, scores: dict, pdf_content: bytes,
             'VersionData': pdf_base64,
             'FirstPublishLocationId': score_record_id
         })
-        logger.info(f"Successfully uploaded PDF as ContentVersion for Vendor Log ID: {log.vendorLogId}")
-
-        # Step 3: Get the ContentDocumentId and construct a URL to the file
         content_version_id = content_version['id']
         content_version_record = sf.query(f"SELECT ContentDocumentId FROM ContentVersion WHERE Id = '{content_version_id}'")
+        if content_version_record['totalSize'] == 0:
+            logger.error(f"No ContentVersion for ID: {content_version_id}")
+            raise ValueError("Failed to retrieve ContentDocumentId")
         content_document_id = content_version_record['records'][0]['ContentDocumentId']
         
-        # Construct the URL to the file
         pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/document/download/{content_document_id}"
-
-        # Step 4: Update the Subcontractor_Performance_Score__c record with the PDF URL
-        sf.Subcontractor_Performance_Score__c.update(score_record_id, {
-            'PDF_Link__c': pdf_url
-        })
+        sf.Subcontractor_Performance_Score__c.update(score_record_id, {'PDF_Link__c': pdf_url})
         logger.info(f"Successfully updated Subcontractor_Performance_Score__c record with PDF URL: {pdf_url}")
-
     except Exception as e:
         logger.error(f"Error storing scores in Salesforce: {str(e)}")
-        raise
+        raise HTTPException(status_code=500, detail=f"Error storing scores: {str(e)}")
 
 @app.post('/score')
 async def score_vendor(log: VendorLog, authorization: str = Header(...)):
@@ -269,6 +300,8 @@ async def score_vendor(log: VendorLog, authorization: str = Header(...)):
             'pdfContent': pdf_base64,
             'alert': alert_flag
         }
+    except HTTPException as e:
+        raise
     except Exception as e:
         logger.error(f"Error in /score endpoint: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error processing vendor log: {str(e)}")
@@ -325,11 +358,15 @@ async def get_dashboard():
                 </style>
                 <script>
                     async function generateScores() {
-                        const response = await fetch('/generate', { method: 'POST' });
-                        if (response.ok) {
-                            window.location.reload();
-                        } else {
-                            alert('Error generating scores');
+                        try {
+                            const response = await fetch('/generate', { method: 'POST' });
+                            if (response.ok) {
+                                window.location.reload();
+                            } else {
+                                alert('Error generating scores');
+                            }
+                        } catch (error) {
+                            alert('Error: ' + error.message);
                         }
                     }
                 </script>
@@ -449,11 +486,24 @@ async def generate_scores():
                 'scores': scores,
                 'extracted': True
             })
+        logger.info(f"Generated scores for {len(vendor_logs)} logs")
         return {"status": "success"}
     except Exception as e:
         logger.error(f"Error in /generate endpoint: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error generating scores: {str(e)}")
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+@app.get('/huggingface-records')
+async def get_huggingface_records():
+    """Fetch and return Hugging Face dataset records."""
+    try:
+        records = fetch_huggingface_records()
+        if not records:
+            raise HTTPException(status_code=404, detail="No records fetched from Hugging Face")
+        return {"records": records}
+    except Exception as e:
+        logger.error(f"Error fetching Hugging Face records: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to fetch Hugging Face records: {str(e)}")
+
+@app.get('/debug')
+async def debug_info():
+    """Return