Update app.py

app.py

@@ -5,7 +5,6 @@ from reportlab.pdfgen import canvas
 import bleach
 import logging
 import os
-import tempfile
 from huggingface_hub import InferenceClient
 from retry import retry
 import time
@@ -114,7 +113,7 @@ def summarize_text(text, max_length=100, min_length=30):
         return text  # Fallback to original text
 
 # Create Salesforce record in custom object Project_Closure_Handover__c
-def create_salesforce_record(score, checklist_summary, missing_summary, status, escalated, logs, qa_report, punch_list_text, open_punch_items, pdf_url):
+def create_salesforce_record(score, checklist_summary, missing_summary, status, escalated, logs, qa_report, punch_list_text, open_punch_items, pdf_path=None):
     if not SALESFORCE_AVAILABLE:
         logging.error("Salesforce library not available. Skipping record creation.")
         return "Salesforce library not available"
@@ -143,9 +142,19 @@ def create_salesforce_record(score, checklist_summary, missing_summary, status,
         open_punch_items = int(open_punch_items) if open_punch_items is not None else 0
         evaluated_at = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")  # Salesforce Date/Time format
         # Explicitly convert escalated to lowercase boolean string for Salesforce
-        alert_sent = str(bool(escalated)).lower()
+        alert_sent = str(bool(escalated)).lower()  # Converts True/False to "true"/"false"
         logging.info(f"Setting Alert_Sent__c to: {alert_sent}")
-        escalation_flag = str(bool(escalated)).lower()
+        # Explicitly convert escalated to lowercase boolean string for Escalation_Flag__c
+        escalation_flag = str(bool(escalated)).lower()  # Ensure this is also a proper boolean string
+
+        # Check if pdf_path is a valid URL
+        pdf_url = ""
+        if pdf_path:
+            # In a real environment, you'd need to upload the PDF to a publicly accessible location
+            # For now, we'll log a warning and set the URL to empty to avoid Salesforce validation errors
+            logging.warning(f"PDF path provided: {pdf_path}. However, this is a local file path, not a valid URL.")
+            logging.warning("To set Client_PDF_Pack_URL__c, the PDF must be hosted publicly (e.g., via S3 or another service).")
+            logging.warning("Setting Client_PDF_Pack_URL__c to empty string to avoid Salesforce validation error.")
 
         # Create a record in the custom object Project_Closure_Handover__c
         record = {
@@ -155,8 +164,8 @@ def create_salesforce_record(score, checklist_summary, missing_summary, status,
             "Status__c": status,
             "Summarized_Missing_Items__c": summarized_missing,
             "Alert_Sent__c": alert_sent,
-            "Client_PDF_Pack_URL__c": pdf_url if pdf_url else "",
-            "Closure_Pack_URL__c": "",
+            "Client_PDF_Pack_URL__c": pdf_url,  # Set to empty string to avoid validation error
+            "Closure_Pack_URL__c": "",  # Placeholder; update if you have a closure pack URL
             "Escalation_Flag__c": escalation_flag,
             "Evaluated_At__c": evaluated_at,
             "Logs__c": logs,
@@ -182,33 +191,34 @@ def create_salesforce_record(score, checklist_summary, missing_summary, status,
         logging.error(f"Failed to create Salesforce Project_Closure_Handover__c record: {str(e)}")
         return f"Error creating record: {str(e)}"
 
-# Clean input to prevent injection attacks and ensure PDF compatibility
+# Clean input to prevent injection attacks
 def sanitize_input(text):
     if not text or not isinstance(text, str):
         return ""
-    # Clean HTML and strip whitespace
-    cleaned = bleach.clean(text.strip(), tags=[], attributes={})
-    # Replace non-ASCII characters with a space
-    cleaned = cleaned.encode('ascii', 'replace').decode('ascii').replace('?', ' ')
-    return cleaned
+    return bleach.clean(text.strip())
 
 # Rule-based completeness engine with weighted scoring
 def evaluate_readiness(logs, qa_report, punch_list_text):
     try:
+        # Log inputs for debugging
         logging.info(f"Inputs - Logs: {logs}, QA Report: {qa_report}, Punch List: {punch_list_text}")
 
+        # Initialize score and lists for tracking
         score = 0
         missing_items = []
         checklist_details = []
 
-        LOGS_WEIGHT = 30
-        QA_WEIGHT = 40
-        PUNCH_WEIGHT = 30
+        # Define weights for scoring
+        LOGS_WEIGHT = 30  # 30% weight for logs
+        QA_WEIGHT = 40    # 40% weight for QA report
+        PUNCH_WEIGHT = 30 # 30% weight for punch list
 
+        # Sanitize inputs
         logs = sanitize_input(logs)
         qa_report = sanitize_input(qa_report)
         punch_list_text = sanitize_input(punch_list_text)
 
+        # Process Project Logs (30% weight)
         log_keywords = r"complete|handover done|finished|closed|successful"
         logs_pass = logs and re.search(log_keywords, logs.lower())
         if logs_pass:
@@ -219,6 +229,7 @@ def evaluate_readiness(logs, qa_report, punch_list_text):
             checklist_details.append("Logs: Pending")
         logging.info(f"Logs Check: {'Pass' if logs_pass else 'Fail'}, Score so far: {score}%")
 
+        # Process QA Report (40% weight)
         qa_keywords = r"approved|passed|cleared"
         qa_pass = qa_report and re.search(qa_keywords, qa_report.lower())
         if qa_pass:
@@ -229,6 +240,7 @@ def evaluate_readiness(logs, qa_report, punch_list_text):
             checklist_details.append("QA Report: Pending")
         logging.info(f"QA Check: {'Pass' if qa_pass else 'Fail'}, Score so far: {score}%")
 
+        # Process Punch List (30% weight)
         punch_keywords = r"none|resolved|closed|no issues"
         punch_pass = punch_list_text and re.search(punch_keywords, punch_list_text.lower())
         if punch_pass:
@@ -239,15 +251,20 @@ def evaluate_readiness(logs, qa_report, punch_list_text):
             checklist_details.append("Punch List: Pending")
         logging.info(f"Punch List Check: {'Pass' if punch_pass else 'Fail'}, Final Score: {score}%")
 
+        # Calculate open punch items
         open_punch_items = 0 if punch_pass else len(punch_list_text.split(",")) if punch_list_text else 1
 
+        # Handle critical issues (escalation)
         escalated = any("incomplete" in item.lower() or "missing" in item.lower() for item in missing_items)
+        # Map "Pending" to "In Progress" for Salesforce Status__c picklist
         status = "Escalated" if escalated else ("Completed" if not missing_items else "In Progress")
-        checklist_status = "Escalated" if escalated else ("Completed" if not missing_items else "Pending")
+        checklist_status = "Escalated" if escalated else ("Completed" if not missing_items else "Pending")  # For UI display
 
+        # Build summaries
         checklist_summary = "\n".join(checklist_details)
         missing_summary = "None" if not missing_items else ", ".join(missing_items)
 
+        # Generate progress bar HTML using div elements
         color_class = "red" if score < 70 else "yellow" if score <= 90 else "green"
         logging.info(f"Readiness Score: {score}%, Color Class: {color_class}")
         progress_bar = f"""
@@ -258,116 +275,71 @@ def evaluate_readiness(logs, qa_report, punch_list_text):
         </div>
         """
 
+        # Return necessary values for PDF generation and Salesforce record
         return (score, checklist_summary, missing_summary, status, progress_bar, escalated, logs, qa_report, punch_list_text, open_punch_items, checklist_status)
     except Exception as e:
         logging.error(f"Error in evaluate_readiness: {str(e)}")
         raise
 
-# Generate PDF report with signature slots and return a publicly accessible URL
+# Generate PDF report with signature slots and write to a temporary file
 def generate_pdf(score, checklist_summary, missing_summary, checklist_status, logs, qa_report, punch_list_text):
     try:
-        # Sanitize inputs and handle None values
+        # Sanitize inputs to ensure they are strings and handle None
         logging.info("Sanitizing inputs for PDF generation")
         score = str(float(score)) if score is not None else "0"
-        checklist_summary = sanitize_input(checklist_summary) if checklist_summary else "No checklist summary provided"
-        missing_summary = sanitize_input(missing_summary) if missing_summary else "None"
-        checklist_status = sanitize_input(checklist_status) if checklist_status else "Unknown"
-        logs = sanitize_input(logs) if logs else "No logs provided"
-        qa_report = sanitize_input(qa_report) if qa_report else "No QA report provided"
-        punch_list_text = sanitize_input(punch_list_text) if punch_list_text else "No punch list provided"
-
-        # Use a temporary directory for PDF generation
-        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False, dir="/tmp") as temp_file:
-            pdf_path = temp_file.name
-        logging.info(f"Attempting to create PDF at {pdf_path}")
+        checklist_summary = str(checklist_summary) if checklist_summary is not None else ""
+        checklist_status = str(checklist_status) if checklist_status is not None else ""
+
+        # Remove non-ASCII characters to prevent rendering issues
+        checklist_summary = checklist_summary.encode('ascii', 'ignore').decode('ascii')
+        checklist_status = checklist_status.encode('ascii', 'ignore').decode('ascii')
+
+        # Define the temporary file path
+        pdf_path = "readiness_report.pdf"
+        logging.info(f"Creating PDF at {pdf_path}")
 
         # Create the PDF using reportlab
         c = canvas.Canvas(pdf_path, pagesize=letter)
-
-        # Set initial font and draw title
-        logging.info("Setting font to Helvetica-Bold for title (fallback)")
-        try:
-            c.setFont("Helvetica-Bold", 16)
-        except Exception as e:
-            logging.error(f"Font error: {str(e)}. Using default font.")
-            c.setFont("Helvetica", 16)
+        
+        # Set initial font and draw title using Times-Bold
+        logging.info("Setting font to Times-Bold")
+        c.setFont("Times-Bold", 16)
         c.drawString(50, 750, "Project Closure Readiness Report")
-
-        # Draw basic fields
-        logging.info("Drawing basic fields with Helvetica")
-        try:
-            c.setFont("Helvetica", 12)
-        except Exception as e:
-            logging.error(f"Font error: {str(e)}. Continuing with default font.")
+        
+        # Draw basic fields using Times-Roman
+        logging.info("Drawing basic fields")
+        c.setFont("Times-Roman", 12)
         c.drawString(50, 720, f"Readiness Score: {score}%")
         c.drawString(50, 700, f"Status: {checklist_status}")
+        c.drawString(50, 680, "Checklist Summary:")
 
-        # Draw checklist summary
+        # Draw checklist summary with Y-position overflow handling
         logging.info("Drawing checklist summary")
-        y = 680
-        LINE_HEIGHT = 20
-        BOTTOM_MARGIN = 50
-        c.drawString(50, y, "Checklist Summary:")
-        y -= LINE_HEIGHT
-
-        lines = checklist_summary.split("\n")
-        if not lines or lines == [""]:
-            lines = ["No checklist summary available"]
-        for line in lines:
-            # Truncate long lines to prevent overflow
-            if len(line) > 80:
-                line = line[:77] + "..."
+        y = 660
+        BOTTOM_MARGIN = 50  # Minimum Y position before creating a new page
+        for line in checklist_summary.split("\n"):
             if y < BOTTOM_MARGIN:
                 logging.info("Y position below margin, creating new page")
-                c.showPage()
-                try:
-                    c.setFont("Helvetica", 12)
-                except:
-                    pass
-                y = 750
+                c.showPage()  # Create a new page
+                c.setFont("Times-Roman", 12)  # Reset font for new page
+                y = 750  # Reset Y position
             c.drawString(50, y, line)
-            y -= LINE_HEIGHT
-
-        # Draw missing summary
-        logging.info("Drawing missing summary")
-        y -= 20
-        c.drawString(50, y, "Missing Items:")
-        y -= LINE_HEIGHT
-        missing_lines = missing_summary.split("\n") if missing_summary else ["None"]
-        for line in missing_lines:
-            if len(line) > 80:
-                line = line[:77] + "..."
-            if y < BOTTOM_MARGIN:
-                c.showPage()
-                try:
-                    c.setFont("Helvetica", 12)
-                except:
-                    pass
-                y = 750
-            c.drawString(50, y, line)
-            y -= LINE_HEIGHT
+            y -= 20
 
         # Draw signature slots
-        logging.info("Drawing signature slots")
-        y -= 20
         if y - 40 < BOTTOM_MARGIN:
+            logging.info("Y position below margin, creating new page")
             c.showPage()
-            try:
-                c.setFont("Helvetica", 12)
-            except:
-                pass
+            c.setFont("Times-Roman", 12)
             y = 750
-        c.drawString(50, y - 20, "Stakeholder Signature: ____________________")
+        c.drawString(50, y - 40, "Stakeholder Signature: ____________________")
 
-        y -= 20
         if y - 60 < BOTTOM_MARGIN:
+            logging.info("Y position below margin, creating new page")
             c.showPage()
-            try:
-                c.setFont("Helvetica", 12)
-            except:
-                pass
+            c.setFont("Times-Roman", 12)
             y = 750
-        c.drawString(50, y - 40, "Date: ____________________")
+        c.drawString(50, y - 60, "Date: ____________________")
 
         # Finalize the PDF
         logging.info("Finalizing PDF")
@@ -378,12 +350,8 @@ def generate_pdf(score, checklist_summary, missing_summary, checklist_status, lo
             logging.error(f"PDF file {pdf_path} was not created")
             raise FileNotFoundError(f"PDF file {pdf_path} was not created")
 
-        # Simulate uploading the PDF to a publicly accessible location
-        simulated_public_url = f"https://example.com/pdf/readiness_report_{int(time.time())}.pdf"
-        logging.info(f"Simulated public URL for PDF: {simulated_public_url}")
-
         logging.info(f"PDF generated successfully at {pdf_path}")
-        return simulated_public_url, f"PDF generation completed. File saved at {pdf_path}. Click the link to download."
+        return pdf_path, "PDF generation completed. Click the link to download."
     except Exception as e:
         logging.error(f"Error in generate_pdf: {str(e)}")
         raise
@@ -417,9 +385,10 @@ with gr.Blocks(css="""
                 gr.Markdown("### Handover Summary")
                 checklist_output = gr.Textbox(label="Checklist Summary")
                 missing_output = gr.Textbox(label="Missing Items")
-            pdf_output = gr.File(label="Download PDF Report", type="filepath", interactive=False)
-            pdf_debug = gr.Textbox(label="PDF Debug Output")
+            pdf_output = gr.File(label="Download PDF Report", type="filepath", interactive=False)  # Output only, no auto-download
+            pdf_debug = gr.Textbox(label="PDF Debug Output")  # Temporary debug output
 
+    # Chain the evaluation, PDF generation, and Salesforce record creation
     submit_btn.click(
         fn=evaluate_readiness,
         inputs=[logs_input, qa_input, punch_input],
@@ -432,6 +401,9 @@ with gr.Blocks(css="""
     ).then(
         fn=create_salesforce_record,
         inputs=[score_output, checklist_output, missing_output, status_output, gr.State(), gr.State(), gr.State(), gr.State(), gr.State(), pdf_output],
-        outputs=None
+        outputs=None  # No UI output for Salesforce status
     )
-    demo.launch()
+    demo.launch()
+
+# Comment out demo.launch() for Hugging Face Spaces deployment
+# demo.launch()