Update app.py

app.py

@@ -1,4 +1,3 @@
-import gradio as gr
 import os
 import logging
 import matplotlib.pyplot as plt
@@ -12,51 +11,64 @@ from reportlab.pdfgen import canvas
 from reportlab.lib.utils import ImageReader
 from reportlab.lib.colors import red, black
 import requests
-from simple_salesforce import Salesforce  # Added for Salesforce integration
+from simple_salesforce import Salesforce, SalesforceLoginError
 
 # Set up logging
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Load environment variables
 load_dotenv()
-HF_TOKEN = os.getenv("HF_TOKEN", "not_set")
+HF_TOKEN = os.getenv("HF_TOKEN")
 SF_USERNAME = os.getenv("SF_USERNAME")
 SF_PASSWORD = os.getenv("SF_PASSWORD")
 SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
+SF_INSTANCE_URL = os.getenv("SF_INSTANCE_URL", "https://budgetoverrunriskestimator-dev-ed.develop.my.salesforce.com")
 
 # Validate environment variables
-if HF_TOKEN == "not_set":
-    logger.info("Hugging Face token not set. Using heuristic formula until HF_TOKEN is provided in .env.")
+if not HF_TOKEN:
+    logger.error("Hugging Face token not set. Please add HF_TOKEN to .env file.")
 else:
     logger.info("Hugging Face token loaded successfully.")
 
-# Initialize Salesforce connection
-try:
-    sf = Salesforce(
-        username=SF_USERNAME,
-        password=SF_PASSWORD,
-        security_token=SF_SECURITY_TOKEN
-    )
-    logger.info("Salesforce connection established successfully.")
-except Exception as e:
-    logger.error(f"Failed to connect to Salesforce: {str(e)}")
+if not all([SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN]):
+    logger.error("Salesforce credentials incomplete. Please set SF_USERNAME, SF_PASSWORD, and SF_SECURITY_TOKEN in .env.")
     sf = None
+else:
+    # Initialize Salesforce connection
+    try:
+        sf = Salesforce(
+            username=SF_USERNAME,
+            password=SF_PASSWORD,
+            security_token=SF_SECURITY_TOKEN,
+            instance_url=SF_INSTANCE_URL
+        )
+        logger.info("Salesforce connection established successfully.")
+    except SalesforceLoginError as e:
+        logger.error(f"Failed to connect to Salesforce: {str(e)}")
+        sf = None
+    except Exception as e:
+        logger.error(f"Unexpected error connecting to Salesforce: {str(e)}")
+        sf = None
 
 # Custom function to format numbers in Indian style (e.g., 100000000 as 1,00,00,000.00)
 def format_indian_number(number):
-    number = float(number)
-    integer_part, decimal_part = f"{number:.2f}".split(".")
-    integer_part = integer_part[::-1]
-    formatted = ""
-    for i, digit in enumerate(integer_part):
-        if i == 3:
-            formatted += ","
-        elif i > 3 and (i - 3) % 2 == 0:
-            formatted += ","
-        formatted += digit
-    integer_part = formatted[::-1]
-    return f"₹{integer_part}.{decimal_part}"
+    try:
+        number = float(number)
+        integer_part, decimal_part = f"{number:.2f}".split(".")
+        integer_part = integer_part[::-1]
+        formatted = ""
+        for i, digit in enumerate(integer_part):
+            if i == 3:
+                formatted += ","
+            elif i > 3 and (i - 3) % 2 == 0:
+                formatted += ","
+            formatted += digit
+        integer_part = formatted[::-1]
+        return f"₹{integer_part}.{decimal_part}"
+    except (ValueError, TypeError) as e:
+        logger.error(f"Error formatting number {number}: {str(e)}")
+        return "₹0.00"
 
 # Function to fetch budget data from Salesforce
 def fetch_budget_from_salesforce(project_id):
@@ -75,228 +87,272 @@ def fetch_budget_from_salesforce(project_id):
         if not records:
             return None, "Error: No budget data found for the given project ID."
         
-        # Convert records to DataFrame for consistency with CSV processing
         data = []
         for record in records:
             data.append({
-                'Planned_Cost': record['Planned_Cost__c'],
-                'Actual_Spend': record['Actual_Spend_To_Date__c']
+                'Planned_Cost': record['Planned_Cost__c'] or 0,
+                'Actual_Spend': record['Actual_Spend_To_Date__c'] or 0
             })
         df = pd.DataFrame(data)
         return df, None
     except Exception as e:
+        logger.error(f"Error fetching data from Salesforce: {str(e)}")
         return None, f"Error fetching data from Salesforce: {str(e)}"
 
 # Function to process uploaded file for line items
 def process_uploaded_file(file):
     if file is None:
         return 0, 0, []
-    df = pd.read_csv(file)
-    if len(df) > 200:
-        raise ValueError("File exceeds 200 line items. Please upload a file with 200 or fewer line items.")
-    planned_cost = df['Planned_Cost'].sum()
-    actual_spend = df['Actual_Spend'].sum()
-    line_items = df.to_dict('records')
-    return planned_cost, actual_spend, line_items
+    try:
+        df = pd.read_csv(file)
+        if len(df) > 200:
+            raise ValueError("File exceeds 200 line items. Please upload a file with 200 or fewer line items.")
+        planned_cost = df['Planned_Cost'].sum()
+        actual_spend = df['Actual_Spend'].sum()
+        line_items = df.to_dict('records')
+        return planned_cost, actual_spend, line_items
+    except Exception as e:
+        logger.error(f"Error processing uploaded file: {str(e)}")
+        return 0, 0, []
 
 # Function to cross-check indices with 3rd-party sources
 def cross_check_indices(material_cost_index, labor_index):
-    if not (0 <= material_cost_index <= 300 and 0 <= labor_index <= 300):
-        return "Warning: Material Cost Index or Labor Index out of expected range (0-300)."
-    return "Indices within expected range (placeholder validation)."
+    try:
+        material_cost_index = float(material_cost_index)
+        labor_index = float(labor_index)
+        if not (0 <= material_cost_index <= 300 and 0 <= labor_index <= 300):
+            return "Warning: Material Cost Index or Labor Index out of expected range (0-300)."
+        return "Indices within expected range."
+    except (ValueError, TypeError) as e:
+        logger.error(f"Error validating indices: {str(e)}")
+        return "Error: Invalid indices provided."
 
 # Function to generate a bar chart
 def generate_bar_plot(planned_cost_inr, actual_spend_inr, forecast_cost_inr):
-    fig, ax = plt.subplots(figsize=(8, 6))
-    categories = ['Planned Cost', 'Actual Spend', 'Forecasted Cost']
-    values = [planned_cost_inr, actual_spend_inr, forecast_cost_inr]
-    bars = ax.bar(categories, values, color=['#1f77b4', '#ff7f0e', '#2ca02c'])
-    ax.set_title("Budget Overview", fontsize=14, pad=15)
-    ax.set_ylabel("Amount (₹)", fontsize=12)
-    ax.tick_params(axis='x', rotation=45)
-    ax.grid(True, axis='y', linestyle='--', alpha=0.7)
-    
-    for bar in bars:
-        height = bar.get_height()
-        ax.text(
-            bar.get_x() + bar.get_width() / 2, height,
-            format_indian_number(height), ha='center', va='bottom', fontsize=10
-        )
-    
-    buf_gradio = io.BytesIO()
-    plt.savefig(buf_gradio, format='png', bbox_inches='tight', dpi=100)
-    buf_gradio.seek(0)
-    gradio_image = Image.open(buf_gradio)
-    
-    buf_pdf = io.BytesIO()
-    plt.savefig(buf_pdf, format='png', bbox_inches='tight', dpi=100)
-    buf_pdf.seek(0)
-    
-    plt.close()
-    return gradio_image, buf_pdf
+    try:
+        fig, ax = plt.subplots(figsize=(8, 6))
+        categories = ['Planned Cost', 'Actual Spend', 'Forecasted Cost']
+        values = [planned_cost_inr, actual_spend_inr, forecast_cost_inr]
+        bars = ax.bar(categories, values, color=['#1f77b4', '#ff7f0e', '#2ca02c'])
+        ax.set_title("Budget Overview", fontsize=14, pad=15)
+        ax.set_ylabel("Amount (₹)", fontsize=12)
+        ax.tick_params(axis='x', rotation=45)
+        ax.grid(True, axis='y', linestyle='--', alpha=0.7)
+        
+        for bar in bars:
+            height = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2, height,
+                format_indian_number(height), ha='center', va='bottom', fontsize=10
+            )
+        
+        buf_gradio = io.BytesIO()
+        plt.savefig(buf_gradio, format='png', bbox_inches='tight', dpi=100)
+        buf_gradio.seek(0)
+        gradio_image = Image.open(buf_gradio)
+        
+        buf_pdf = io.BytesIO()
+        plt.savefig(buf_pdf, format='png', bbox_inches='tight', dpi=100)
+        buf_pdf.seek(0)
+        
+        plt.close()
+        return gradio_image, buf_pdf
+    except Exception as e:
+        logger.error(f"Error generating bar plot: {str(e)}")
+        return None, None
 
 # Function to generate a pie chart for risk distribution
 def generate_pie_chart_data(cost_deviation_factor, material_cost_factor, labor_cost_factor, scope_change_factor):
-    labels = ['Cost Deviation', 'Material Cost', 'Labor Cost', 'Scope Change']
-    values = [
-        max(cost_deviation_factor * 100, 0),
-        max(material_cost_factor * 100, 0),
-        max(labor_cost_factor * 100, 0),
-        max(scope_change_factor * 100, 0)
-    ]
-    total = sum(values)
-    if total == 0:
-        values = [25, 25, 25, 25]
-    return {
-        "type": "pie",
-        "data": {
-            "labels": labels,
-            "datasets": [{
-                "label": "Risk Distribution",
-                "data": values,
-                "backgroundColor": ["#FF6384", "#36A2EB", "#FFCE56", "#4BC0C0"],
-                "borderColor": ["#FF6384", "#36A2EB", "#FFCE56", "#4BC0C0"],
-                "borderWidth": 1
-            }]
-        },
-        "options": {
-            "responsive": true,
-            "plugins": {
-                "legend": {
-                    "position": "top"
-                },
-                "title": {
-                    "display": true,
-                    "text": "Risk Factor Distribution"
+    try:
+        labels = ['Cost Deviation', 'Material Cost', 'Labor Cost', 'Scope Change']
+        values = [
+            max(float(cost_deviation_factor) * 100, 0),
+            max(float(material_cost_factor) * 100, 0),
+            max(float(labor_cost_factor) * 100, 0),
+            max(float(scope_change_factor) * 100, 0)
+        ]
+        total = sum(values)
+        if total == 0:
+            values = [25, 25, 25, 25]
+        return {
+            "type": "pie",
+            "data": {
+                "labels": labels,
+                "datasets": [{
+                    "label": "Risk Distribution",
+                    "data": values,
+                    "backgroundColor": ["#FF6384", "#36A2EB", "#FFCE56", "#4BC0C0"],
+                    "borderColor": ["#FF6384", "#36A2EB", "#FFCE56", "#4BC0C0"],
+                    "borderWidth": 1
+                }]
+            },
+            "options": {
+                "responsive": true,
+                "plugins": {
+                    "legend": {
+                        "position": "top"
+                    },
+                    "title": {
+                        "display": true,
+                        "text": "Risk Factor Distribution"
+                    }
                 }
             }
         }
-    }
+    except (ValueError, TypeError) as e:
+        logger.error(f"Error generating pie chart data: {str(e)}")
+        return {
+            "type": "pie",
+            "data": {
+                "labels": ["Error"],
+                "datasets": [{"label": "Error", "data": [100], "backgroundColor": ["#FF0000"]}]
+            }
+        }
 
 # Function to generate a gauge chart
 def generate_gauge_chart(risk_percentage, category):
-    return {
-        "type": "radar",
-        "data": {
-            "labels": ["Risk Level"],
-            "datasets": [{
-                "label": f"Risk for {category} (%)",
-                "data": [risk_percentage],
-                "backgroundColor": "rgba(255, 99, 132, 0.2)",
-                "borderColor": "rgba(255, 99, 132, 1)",
-                "borderWidth": 1,
-                "pointBackgroundColor": "rgba(255, 99, 132, 1)"
-            }]
-        },
-        "options": {
-            "responsive": true,
-            "scales": {
-                "r": {
-                    "min": 0,
-                    "max": 100,
-                    "ticks": {
-                        "stepSize": 20
-                    }
-                }
+    try:
+        risk_percentage = float(risk_percentage)
+        return {
+            "type": "radar",
+            "data": {
+                "labels": ["Risk Level"],
+                "datasets": [{
+                    "label": f"Risk for {category} (%)",
+                    "data": [risk_percentage],
+                    "backgroundColor": "rgba(255, 99, 132, 0.2)",
+                    "borderColor": "rgba(255, 99, 132, 1)",
+                    "borderWidth": 1,
+                    "pointBackgroundColor": "rgba(255, 99, 132, 1)"
+                }]
             },
-            "plugins": {
-                "legend": {
-                    "position": "top"
+            "options": {
+                "responsive": true,
+                "scales": {
+                    "r": {
+                        "min": 0,
+                        "max": 100,
+                        "ticks": {
+                            "stepSize": 20
+                        }
+                    }
                 },
-                "title": {
-                    "display": true,
-                    "text": f"Risk Level Dashboard for {category}"
+                "plugins": {
+                    "legend": {
+                        "position": "top"
+                    },
+                    "title": {
+                        "display": true,
+                        "text": f"Risk Level Dashboard for {category}"
+                    }
                 }
             }
         }
-    }
+    except (ValueError, TypeError) as e:
+        logger.error(f"Error generating gauge chart: {str(e)}")
+        return {
+            "type": "radar",
+            "data": {
+                "labels": ["Error"],
+                "datasets": [{"label": "Error", "data": [0], "backgroundColor": ["#FF0000"]}]
+            }
+        }
 
 # Function to generate a PDF report
 def generate_pdf(planned_cost_inr, actual_spend_inr, forecast_cost_inr, total_risk, risk_percentage, insights, status, top_causes, category, project_phase, material_cost_index, labor_index, scope_change_impact, alert_message, indices_validation, bar_chart_image):
-    pdf_path = f"budget_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-    c = canvas.Canvas(pdf_path, pagesize=letter)
-    width, height = letter
-
-    c.setFont("Helvetica-Bold", 16)
-    c.drawString(50, height - 50, "Budget Overrun Risk Report")
-
-    c.setFont("Helvetica", 12)
-    y_position = height - 100
-
-    text_color = red if status == "Critical" else black
-    c.setFillColor(text_color)
-
-    c.drawString(50, y_position, f"Category: {category}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Project Phase: {project_phase}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Material Cost Index: {material_cost_index}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Labor Index: {labor_index}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Indices Validation: {indices_validation}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Scope Change Impact: {scope_change_impact}%")
-    y_position -= 20
-    c.drawString(50, y_position, f"Planned Cost: {format_indian_number(planned_cost_inr)}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Actual Spend: {format_indian_number(actual_spend_inr)}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Forecasted Cost: {format_indian_number(forecast_cost_inr)}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Total Risk: {total_risk}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Risk Percentage: {risk_percentage}%")
-    y_position -= 20
-    c.drawString(50, y_position, f"Status: {status}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Insights: {insights}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Top Causes: {top_causes}")
-    y_position -= 20
-    c.drawString(50, y_position, f"Alert: {alert_message}")
-    y_position -= 40
-
-    chart_reader = ImageReader(bar_chart_image)
-    c.drawImage(chart_reader, 50, y_position - 300, width=500, height=300)
-
-    c.showPage()
-    c.save()
-    return pdf_path
+    try:
+        pdf_path = f"budget_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        c = canvas.Canvas(pdf_path, pagesize=letter)
+        width, height = letter
+
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(50, height - 50, "Budget Overrun Risk Report")
+
+        c.setFont("Helvetica", 12)
+        y_position = height - 100
+
+        text_color = red if status == "Critical" else black
+        c.setFillColor(text_color)
+
+        c.drawString(50, y_position, f"Category: {category}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Project Phase: {project_phase}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Material Cost Index: {material_cost_index}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Labor Index: {labor_index}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Indices Validation: {indices_validation}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Scope Change Impact: {scope_change_impact}%")
+        y_position -= 20
+        c.drawString(50, y_position, f"Planned Cost: {format_indian_number(planned_cost_inr)}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Actual Spend: {format_indian_number(actual_spend_inr)}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Forecasted Cost: {format_indian_number(forecast_cost_inr)}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Total Risk: {total_risk}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Risk Percentage: {risk_percentage}%")
+        y_position -= 20
+        c.drawString(50, y_position, f"Status: {status}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Insights: {insights}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Top Causes: {top_causes}")
+        y_position -= 20
+        c.drawString(50, y_position, f"Alert: {alert_message}")
+        y_position -= 40
+
+        if bar_chart_image:
+            chart_reader = ImageReader(bar_chart_image)
+            c.drawImage(chart_reader, 50, y_position - 300, width=500, height=300)
+
+        c.showPage()
+        c.save()
+        return pdf_path
+    except Exception as e:
+        logger.error(f"Error generating PDF: {str(e)}")
+        return None
 
 # Function to generate an Excel file
 def generate_excel(planned_cost_inr, actual_spend_inr, forecast_cost_inr, total_risk, risk_percentage, insights, status, top_causes, category, project_phase, material_cost_index, labor_index, scope_change_impact, alert_message, indices_validation):
-    data = {
-        "Category": [category],
-        "Project Phase": [project_phase],
-        "Material Cost Index": [material_cost_index],
-        "Labor Index": [labor_index],
-        "Indices Validation": [indices_validation],
-        "Scope Change Impact (%)": [scope_change_impact],
-        "Planned Cost (INR)": [planned_cost_inr],
-        "Actual Spend (INR)": [actual_spend_inr],
-        "Forecasted Cost (INR)": [forecast_cost_inr],
-        "Total Risk": [total_risk],
-        "Risk Percentage (%)": [risk_percentage],
-        "Insights": [insights],
-        "Status": [status],
-        "Top Causes": [top_causes],
-        "Alert": [alert_message]
-    }
-    df = pd.DataFrame(data)
-    
-    excel_path = f"prediction_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-    with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
-        df.to_excel(writer, index=False, sheet_name='Results')
-        workbook = writer.book
-        worksheet = writer.sheets['Results']
+    try:
+        data = {
+            "Category": [category],
+            "Project Phase": [project_phase],
+            "Material Cost Index": [material_cost_index],
+            "Labor Index": [labor_index],
+            "Indices Validation": [indices_validation],
+            "Scope Change Impact (%)": [scope_change_impact],
+            "Planned Cost (INR)": [planned_cost_inr],
+            "Actual Spend (INR)": [actual_spend_inr],
+            "Forecasted Cost (INR)": [forecast_cost_inr],
+            "Total Risk": [total_risk],
+            "Risk Percentage (%)": [risk_percentage],
+            "Insights": [insights],
+            "Status": [status],
+            "Top Causes": [top_causes],
+            "Alert": [alert_message]
+        }
+        df = pd.DataFrame(data)
         
-        number_format = workbook.add_format({'num_format': '[₹]#,##,##,##0.00'})
-        worksheet.set_column('G:G', None, number_format)
-        worksheet.set_column('H:H', None, number_format)
-        worksheet.set_column('I:I', None, number_format)
-    
-    return excel_path
+        excel_path = f"prediction_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
+            df.to_excel(writer, index=False, sheet_name='Results')
+            workbook = writer.book
+            worksheet = writer.sheets['Results']
+            
+            number_format = workbook.add_format({'num_format': '[₹]#,##,##,##0.00'})
+            worksheet.set_column('G:G', None, number_format)
+            worksheet.set_column('H:H', None, number_format)
+            worksheet.set_column('I:I', None, number_format)
+        
+        return excel_path
+    except Exception as e:
+        logger.error(f"Error generating Excel: {str(e)}")
+        return None
 
 # Function to store results in Salesforce
 def store_results_in_salesforce(project_id, planned_cost_inr, actual_spend_inr, forecast_cost_inr, risk_percentage, insights, status, top_causes, category, project_phase, pdf_path):
@@ -304,7 +360,6 @@ def store_results_in_salesforce(project_id, planned_cost_inr, actual_spend_inr,
         return "Error: Salesforce connection not available."
     
     try:
-        # Update or create record in Project_Budget_Risk__c
         record = {
             'Project_Name__c': project_id,
             'Budget_Category__c': category,
@@ -318,7 +373,6 @@ def store_results_in_salesforce(project_id, planned_cost_inr, actual_spend_inr,
             'Project_Phase__c': project_phase
         }
         
-        # Check if record exists
         query = f"SELECT Id FROM Project_Budget_Risk__c WHERE Project_Name__c = '{project_id}'"
         result = sf.query(query)
         if result['records']:
@@ -327,28 +381,33 @@ def store_results_in_salesforce(project_id, planned_cost_inr, actual_spend_inr,
         else:
             sf.Project_Budget_Risk__c.create(record)
         
-        # Upload PDF to Salesforce Files
-        with open(pdf_path, 'rb') as pdf_file:
-            sf_file = sf.ContentVersion.create({
-                'Title': f"Budget Report {project_id} {datetime.now().strftime('%Y%m%d_%H%M%S')}",
-                'PathOnClient': pdf_path,
-                'VersionData': pdf_file.read().hex()
-            })
-            file_id = sf_file['id']
-        
-        # Link PDF to the record
-        sf.ContentDocumentLink.create({
-            'ContentDocumentId': file_id,
-            'LinkedEntityId': record_id,
-            'ShareType': 'V'
-        })
-        
-        return f"Results stored in Salesforce with PDF ID: {file_id}"
+        if pdf_path and os.path.exists(pdf_path):
+            with open(pdf_path, 'rb') as pdf_file:
+                sf_file = sf.ContentVersion.create({
+                    'Title': f"Budget Report {project_id} {datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                    'PathOnClient': pdf_path,
+                    'VersionData': pdf_file.read().hex()
+                })
+                file_id = sf_file['id']
+                
+                sf.ContentDocumentLink.create({
+                    'ContentDocumentId': file_id,
+                    'LinkedEntityId': record_id,
+                    'ShareType': 'V'
+                })
+                return f"Results stored in Salesforce with PDF ID: {file_id}"
+        return "Results stored in Salesforce (no PDF uploaded)."
     except Exception as e:
+        logger.error(f"Error storing results in Salesforce: {str(e)}")
         return f"Error storing results in Salesforce: {str(e)}"
 
 # Prediction function
 def predict_risk(username, file, project_id, category, material_cost_index, labor_index, scope_change_impact, project_phase):
+    # Validate inputs
+    if not username:
+        logger.error("Username is empty.")
+        return "Error: Salesforce username is required.", None, None, None, None, None, None
+
     # Validate user role via Salesforce
     if not sf:
         return "Error: Salesforce connection not available.", None, None, None, None, None, None
@@ -357,8 +416,10 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
         user_query = f"SELECT Profile.Name FROM User WHERE Username = '{username}'"
         user_result = sf.query(user_query)
         if not user_result['records'] or user_result['records'][0]['Profile']['Name'] != 'Finance':
+            logger.warning(f"Access denied for user {username}: Not a Finance role.")
             return "Access Denied: This app is restricted to finance roles only.", None, None, None, None, None, None
     except Exception as e:
+        logger.error(f"Error validating user {username}: {str(e)}")
         return f"Error validating user: {str(e)}", None, None, None, None, None, None
 
     # Fetch data from Salesforce if no file is uploaded
@@ -378,6 +439,7 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
         else:
             planned_cost_inr, actual_spend_inr, line_items = process_uploaded_file(file)
     except Exception as e:
+        logger.error(f"Error processing data: {str(e)}")
         return f"Error processing data: {str(e)}", None, None, None, None, None, None
 
     # Validate numeric inputs
@@ -386,7 +448,7 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
         labor_index = float(labor_index) if labor_index else 0
         scope_change_impact = float(scope_change_impact) if scope_change_impact else 0
     except ValueError:
-        logger.error("Invalid input: Inputs must be numeric.")
+        logger.error("Invalid input: Material Cost Index, Labor Index, or Scope Change Impact must be numeric.")
         return "Error: All numeric inputs must be valid numbers.", None, None, None, None, None, None
 
     logger.debug(f"Starting prediction: planned_cost_inr={planned_cost_inr}, actual_spend_inr={actual_spend_inr}, "
@@ -397,7 +459,7 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
     indices_validation = cross_check_indices(material_cost_index, labor_index)
 
     # Risk calculation with Hugging Face API
-    if HF_TOKEN != "not_set":
+    if HF_TOKEN:
         try:
             api_url = "https://api.huggingface.co/models/budget-overrun-risk"
             headers = {"Authorization": f"Bearer {HF_TOKEN}"}
@@ -417,23 +479,19 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
             labor_cost_factor = result.get('labor_cost_factor', 0)
             scope_change_factor = result.get('scope_change_factor', 0)
         except Exception as e:
-            logger.error(f"Hugging Face API call failed: {str(e)}")
-            return f"Error with Hugging Face API: {str(e)}", None, None, None, None, None, None
+            logger.error(f"Hugging Face API call failed: {str(e)}. Falling back to heuristic formula.")
+            cost_deviation_factor = (actual_spend_inr - planned_cost_inr) / planned_cost_inr if planned_cost_inr > 0 else 0
+            material_cost_factor = (material_cost_index - 100) / 100 if material_cost_index > 100 else 0
+            labor_cost_factor = (labor_index - 100) / 100 if labor_index > 100 else 0
+            scope_change_factor = scope_change_impact / 100
+            risk_percentage = calculate_heuristic_risk(cost_deviation_factor, material_cost_factor, labor_cost_factor, scope_change_factor)
     else:
-        # Fallback to heuristic formula
+        logger.warning("No HF_TOKEN provided. Using heuristic formula for risk calculation.")
         cost_deviation_factor = (actual_spend_inr - planned_cost_inr) / planned_cost_inr if planned_cost_inr > 0 else 0
         material_cost_factor = (material_cost_index - 100) / 100 if material_cost_index > 100 else 0
         labor_cost_factor = (labor_index - 100) / 100 if labor_index > 100 else 0
         scope_change_factor = scope_change_impact / 100
-
-        weights = {'cost_deviation': 0.4, 'material_cost': 0.2, 'labor_cost': 0.2, 'scope_change': 0.2}
-        risk_percentage = (
-            weights['cost_deviation'] * min(cost_deviation_factor * 100, 100) +
-            weights['material_cost'] * min(material_cost_factor * 100, 100) +
-            weights['labor_cost'] * min(labor_cost_factor * 100, 100) +
-            weights['scope_change'] * min(scope_change_factor * 100, 100)
-        )
-        risk_percentage = round(max(0, min(risk_percentage, 100)), 2)
+        risk_percentage = calculate_heuristic_risk(cost_deviation_factor, material_cost_factor, labor_cost_factor, scope_change_factor)
 
     total_risk = 1 if risk_percentage > 50 else 0
     forecast_cost_inr = planned_cost_inr * (1 + risk_percentage / 100)
@@ -508,6 +566,21 @@ def predict_risk(username, file, project_id, category, material_cost_index, labo
 
     return output_text, bar_chart_image, pie_chart_data, gauge_chart_data, pdf_file, excel_file, f"<div style='{alert_style}'>{alert_message}</div>"
 
+# Helper function for heuristic risk calculation
+def calculate_heuristic_risk(cost_deviation_factor, material_cost_factor, labor_cost_factor, scope_change_factor):
+    try:
+        weights = {'cost_deviation': 0.4, 'material_cost': 0.2, 'labor_cost': 0.2, 'scope_change': 0.2}
+        risk_percentage = (
+            weights['cost_deviation'] * min(float(cost_deviation_factor) * 100, 100) +
+            weights['material_cost'] * min(float(material_cost_factor) * 100, 100) +
+            weights['labor_cost'] * min(float(labor_cost_factor) * 100, 100) +
+            weights['scope_change'] * min(float(scope_change_factor) * 100, 100)
+        )
+        return round(max(0, min(risk_percentage, 100)), 2)
+    except (ValueError, TypeError) as e:
+        logger.error(f"Error calculating heuristic risk: {str(e)}")
+        return 0
+
 # Function to update explanations
 def update_material_cost_explanation(category):
     material_examples = {
@@ -634,11 +707,14 @@ with gr.Blocks(title="Budget Overrun Risk Estimator", css=custom_css) as demo:
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        auth_message="Please log in with your Salesforce credentials.",
-        allowed_paths=["/home/user/app"],
-        ssr_mode=False
-    )
+    try:
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            auth_message="Please log in with your Salesforce credentials.",
+            allowed_paths=["/home/user/app"],
+            ssr_mode=False
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch Gradio app: {str(e)}")