Update app.py

app.py

@@ -8,242 +8,340 @@ import logging
 from simple_salesforce import Salesforce
 import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
+import re
+from flask import Flask
+from http import HTTPStatus
 
 # Set up logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-# Salesforce credentials
-SALESFORCE_USERNAME = "vijaypulmamidi.dev2025@sathkrutha.com"
-SALESFORCE_PASSWORD = "Vij@y9100754977"
-SALESFORCE_SECURITY_TOKEN = "CaZSEwVmB3EIAiV6G8ukdDp0"
+# Initialize Flask for health check
+server = Flask(__name__)
 
-# Connect to Salesforce
-sf = Salesforce(username=SALESFORCE_USERNAME, password=SALESFORCE_PASSWORD, security_token=SALESFORCE_SECURITY_TOKEN)
-logger.debug("Successfully connected to Salesforce.")
+# Gradio app
+app = gr.Blocks()
+
+# Salesforce credentials from environment variables
+SALESFORCE_USERNAME = os.getenv("SALESFORCE_USERNAME")
+SALESFORCE_PASSWORD = os.getenv("SALESFORCE_PASSWORD")
+SALESFORCE_SECURITY_TOKEN = os.getenv("SALESFORCE_SECURITY_TOKEN")
+
+# Validate environment variables
+if not all([SALESFORCE_USERNAME, SALESFORCE_PASSWORD, SALESFORCE_SECURITY_TOKEN]):
+    logger.error("Missing Salesforce credentials in environment variables")
+    raise ValueError("Salesforce credentials must be set in environment variables")
+
+# Health check endpoint for Hugging Face Spaces
+@server.route('/health')
+def health_check():
+    return {"status": "healthy"}, HTTPStatus.OK
+
+def sanitize_input(value):
+    """Sanitize input to prevent SOQL injection."""
+    if not value:
+        return value
+    sanitized = re.sub(r'[^a-zA-Z0-9\s_-]', '', str(value))[:100]
+    return sanitized
+
+def connect_to_salesforce():
+    """Connect to Salesforce with error handling."""
+    try:
+        sf = Salesforce(
+            username=SALESFORCE_USERNAME,
+            password=SALESFORCE_PASSWORD,
+            security_token=SALESFORCE_SECURITY_TOKEN
+        )
+        logger.debug("Successfully connected to Salesforce")
+        return sf
+    except Exception as e:
+        logger.error(f"Failed to connect to Salesforce: {str(e)}")
+        raise Exception(f"Salesforce connection failed: {str(e)}")
 
 def find_salesforce_project(project_name, sf):
     """Find an existing Project__c record by name and return its ID."""
-    query = f"SELECT Id FROM Project__c WHERE Name = '{project_name}' LIMIT 1"
-    result = sf.query(query)
-    if result['totalSize'] > 0:
-        project_id = result['records'][0]['Id']
-        logger.debug(f"Found Project__c with Name: {project_name}, ID: {project_id}")
-        return project_id
-    logger.debug(f"No Project__c found with Name: {project_name}")
-    return None
+    try:
+        sanitized_project_name = sanitize_input(project_name)
+        query = f"SELECT Id FROM Project__c WHERE Name = '{sanitized_project_name}' LIMIT 1"
+        result = sf.query(query)
+        if result['totalSize'] > 0:
+            project_id = result['records'][0]['Id']
+            logger.debug(f"Found Project__c with Name: {sanitized_project_name}, ID: {project_id}")
+            return project_id
+        logger.debug(f"No Project__c found with Name: {sanitized_project_name}")
+        return None
+    except Exception as e:
+        logger.error(f"Error finding project {sanitized_project_name}: {str(e)}")
+        return None
 
 def insert_reconciliation_to_salesforce(df, sf):
-    """Inserts reconciliation records into Salesforce, linking to existing Project__c records if possible."""
+    """Inserts reconciliation records into Salesforce in batches."""
     inserted_count = 0
     project_cache = {}
+    batch_size = 200
     
+    records = []
     for index, row in df.iterrows():
-        project_id = None
-        if 'Project_ID' in df.columns and pd.notna(row['Project_ID']):
-            project_name = row['Project_ID']
-            if project_name in project_cache:
-                project_id = project_cache[project_name]
-            else:
-                project_id = find_salesforce_project(project_name, sf)
-                if project_id:
-                    project_cache[project_name] = project_id
-        
-        reconciliation_record = {
-            'Material_Type__c': row['Material_Type'],
-            'Planned_Quantity__c': row['Planned_Quantity'],
-            'Received_Quantity__c': row['Received_Quantity'],
-            'Used_Quantity__c': row['Used_Quantity'],
-            'AI_Suggestion__c': row['AI_Suggestion'],
-            'Reconciliation_Status__c': row['Reconciliation_Status']
-        }
-        if project_id:
-            reconciliation_record['Project_ID__c'] = project_id
+        try:
+            project_id = None
+            if 'Project_ID' in df.columns and pd.notna(row['Project_ID']):
+                project_name = sanitize_input(row['Project_ID'])
+                if project_name in project_cache:
+                    project_id = project_cache[project_name]
+                else:
+                    project_id = find_salesforce_project(project_name, sf)
+                    if project_id:
+                        project_cache[project_name] = project_id
+            
+            reconciliation_record = {
+                'Material_Type__c': str(row['Material_Type'])[:255],
+                'Planned_Quantity__c': float(row['Planned_Quantity']),
+                'Received_Quantity__c': float(row['Received_Quantity']),
+                'Used_Quantity__c': float(row['Used_Quantity']),
+                'AI_Suggestion__c': str(row['AI_Suggestion'])[:1000],
+                'Reconciliation_Status__c': str(row['Reconciliation_Status'])
+            }
+            if project_id:
+                reconciliation_record['Project_ID__c'] = project_id
+            
+            records.append(reconciliation_record)
+            
+            if len(records) >= batch_size:
+                try:
+                    sf.bulk.Material_Reconciliation_Record__c.insert(records)
+                    inserted_count += len(records)
+                    logger.debug(f"Inserted batch of {len(records)} records")
+                    records = []
+                except Exception as e:
+                    logger.error(f"Error inserting batch: {str(e)}")
+                    continue
         
-        logger.debug(f"Inserting record: {reconciliation_record}")
-        sf.Material_Reconciliation_Record__c.create(reconciliation_record)
-        inserted_count += 1
+        except Exception as e:
+            logger.error(f"Error preparing record {index}: {str(e)}")
+            continue
+    
+    if records:
+        try:
+            sf.bulk.Material_Reconciliation_Record__c.insert(records)
+            inserted_count += len(records)
+            logger.debug(f"Inserted final batch of {len(records)} records")
+        except Exception as e:
+            logger.error(f"Error inserting final batch: {str(e)}")
     
     logger.debug(f"Inserted {inserted_count} of {len(df)} records successfully")
     return f"Inserted {inserted_count} records into Salesforce"
 
 def generate_suggestion(row):
     """Generate AI suggestions based on reconciliation data."""
-    if row['Anomaly'] == -1 or abs(row['Deviation']) > 50:
-        if row['Balance_Quantity'] < 0:
-            return f"Urgent: Reorder {abs(row['Balance_Quantity'])} units of {row['Material_Type']}."
-        elif row['Deviation'] > 50:
-            return f"Excess: Reduce future orders of {row['Material_Type']} by {row['Balance_Quantity'] - row['Planned_Quantity']} units."
-        elif row['Deviation'] < -50:
-            return f"Shortage: Order {abs(row['Used_Quantity'] - row['Planned_Quantity'])} more units of {row['Material_Type']}."
-    return "No action needed."
+    try:
+        if row['Anomaly'] == -1 or abs(row['Deviation']) > 50:
+            if row['Balance_Quantity'] < 0:
+                return f"Urgent: Reorder {abs(row['Balance_Quantity']):.0f} units of {row['Material_Type']}."
+            elif row['Deviation'] > 50:
+                return f"Excess: Reduce future orders of {row['Material_Type']} by {(row['Balance_Quantity'] - row['Planned_Quantity']):.0f} units."
+            elif row['Deviation'] < -50:
+                return f"Shortage: Order {abs(row['Used_Quantity'] - row['Planned_Quantity']):.0f} more units of {row['Material_Type']}."
+        return "No action needed."
+    except Exception as e:
+        logger.error(f"Error generating suggestion for row: {str(e)}")
+        return "Error generating suggestion"
 
 def reconcile_materials(csv_file):
     """Process CSV and reconcile materials, inserting results into Salesforce."""
     logger.debug("Starting reconcile_materials function")
     logger.debug(f"csv_file type: {type(csv_file)}")
-
-    # Read CSV based on input type
-    if isinstance(csv_file, str):
-        logger.debug(f"Reading CSV from path: {csv_file}")
-        df = pd.read_csv(csv_file)
-    elif hasattr(csv_file, 'name'):
-        logger.debug(f"Reading CSV from file object with name: {csv_file.name}")
-        df = pd.read_csv(csv_file.name)
-    else:
-        logger.debug("Reading CSV from file object directly")
-        csv_file.seek(0)
-        df = pd.read_csv(csv_file)
-
-    logger.debug(f"CSV read successfully. Columns: {df.columns.tolist()}")
-
-    # Validate CSV columns (Project_ID is optional)
-    column_mapping = {
-        'Material_Type': 'Material_Type',
-        'Planned_Quantity': ['Planned_Quantity', 'Planned_Qty'],
-        'Received_Quantity': ['Received_Quantity', 'Received_Qty'],
-        'Used_Quantity': ['Used_Quantity', 'Used_Qty']
-    }
+    tmp_file_path = None
     
-    # Check for required columns and rename if necessary
-    for internal_name, possible_names in column_mapping.items():
-        if isinstance(possible_names, list):
-            found = False
-            for name in possible_names:
-                if name in df.columns:
-                    df.rename(columns={name: internal_name}, inplace=True)
-                    found = True
-                    break
-            if not found:
-                raise ValueError(f"Missing required column: {internal_name}")
+    try:
+        # Validate file input
+        if csv_file is None:
+            raise ValueError("No file uploaded")
+        
+        # Handle Gradio file input
+        if isinstance(csv_file, str):
+            logger.debug(f"Reading CSV from path: {csv_file}")
+            if not csv_file.lower().endswith('.csv'):
+                raise ValueError("Invalid file type. Please upload a CSV file.")
+            if os.path.getsize(csv_file) / (1024 * 1024) > 10:
+                raise ValueError("File size exceeds 10MB limit")
+            df = pd.read_csv(csv_file)
         else:
-            if possible_names not in df.columns:
-                raise ValueError(f"Missing required column: {possible_names}")
-
-    # Validate data types
-    for col in ['Planned_Quantity', 'Received_Quantity', 'Used_Quantity']:
-        df[col] = pd.to_numeric(df[col], errors='coerce')
-        if df[col].isna().any():
-            raise ValueError(f"Column '{col}' contains non-numeric values or empty cells.")
-
-    # Calculate balance
-    df['Balance_Quantity'] = df['Received_Quantity'] - df['Used_Quantity']
-    logger.debug("Balance_Quantity calculated")
-
-    # Calculate deviation
-    df['Deviation'] = df.apply(
-        lambda row: ((row['Balance_Quantity'] - row['Planned_Quantity']) / row['Planned_Quantity'])
-        if row['Planned_Quantity'] != 0 else 0, axis=1
-    )
-    logger.debug("Deviation calculated")
-
-    # Anomaly detection with forced anomaly for large deviations
-    iso_forest = IsolationForest(contamination=0.1, random_state=42)
-    features = df[['Planned_Quantity', 'Received_Quantity', 'Used_Quantity', 'Deviation']]
-    df['Anomaly'] = iso_forest.fit_predict(features)
-    df.loc[df['Deviation'].abs() > 50, 'Anomaly'] = -1
-    logger.debug("Anomaly detection completed")
-
-    # Generate suggestions
-    df['AI_Suggestion'] = df.apply(generate_suggestion, axis=1)
-    df['Reconciliation_Status'] = df.apply(
-        lambda row: 'Flagged' if row['Anomaly'] == -1 or abs(row['Deviation']) > 50 else 'Complete', axis=1
-    )
-    logger.debug("Suggestions and status generated")
+            logger.debug("Reading CSV from file object")
+            if not hasattr(csv_file, 'name') or not csv_file.name.lower().endswith('.csv'):
+                raise ValueError("Invalid file type. Please upload a CSV file.")
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp_file:
+                tmp_file.write(csv_file.read())
+                tmp_file_path = tmp_file.name
+            if os.path.getsize(tmp_file_path) / (1024 * 1024) > 10:
+                raise ValueError("File size exceeds 10MB limit")
+            df = pd.read_csv(tmp_file_path)
 
-    # Insert records into Salesforce
-    salesforce_result = insert_reconciliation_to_salesforce(df, sf)
-    logger.debug(f"Salesforce insert result: {salesforce_result}")
+        logger.debug(f"CSV read successfully. Columns: {df.columns.tolist()}")
 
-    # Generate text output
-    text_output = "Material Reconciliation Results\n"
-    text_output += "=============================\n\n"
-    text_output += salesforce_result + "\n\n"
-    text_output += "Detailed Records:\n"
-    for index, row in df.iterrows():
-        text_output += f"Record {index + 1}:\n"
-        if 'Project_ID' in df.columns and pd.notna(row['Project_ID']):
-            text_output += f"  Project ID: {row['Project_ID']}\n"
-        text_output += f"  Material Type: {row['Material_Type']}\n"
-        text_output += f"  Planned Quantity: {row['Planned_Quantity']}\n"
-        text_output += f"  Received Quantity: {row['Received_Quantity']}\n"
-        text_output += f"  Used Quantity: {row['Used_Quantity']}\n"
-        text_output += f"  Balance Quantity: {row['Balance_Quantity']}\n"
-        text_output += f"  Deviation: {row['Deviation']:.2f}%\n"
-        text_output += f"  Anomaly: {'Yes' if row['Anomaly'] == -1 else 'No'}\n"
-        text_output += f"  AI Suggestion: {row['AI_Suggestion']}\n"
-        text_output += f"  Reconciliation Status: {row['Reconciliation_Status']}\n"
-        text_output += "-----------------------------\n"
-
-    # Save results to a temporary file
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp_file:
-        output_file = tmp_file.name
-        df.to_csv(output_file, index=False)
-        logger.debug(f"Output CSV saved to: {output_file}")
-
-    # Create visualizations
-    # Bar chart for Deviation by Material_Type
-    bar_fig = px.bar(
-        df,
-        x='Material_Type',
-        y='Deviation',
-        color='Reconciliation_Status',
-        title='Deviation by Material Type',
-        labels={'Deviation': 'Deviation (%)'},
-        color_discrete_map={'Flagged': '#FF4B4B', 'Complete': '#36A2EB'}
-    )
-    bar_fig.update_layout(xaxis_title="Material Type", yaxis_title="Deviation (%)")
-
-    # Pie chart for Reconciliation Status
-    status_counts = df['Reconciliation_Status'].value_counts().reset_index()
-    status_counts.columns = ['Reconciliation_Status', 'Count']
-    pie_fig = px.pie(
-        status_counts,
-        names='Reconciliation_Status',
-        values='Count',
-        title='Reconciliation Status Distribution',
-        color_discrete_map={'Flagged': '#FF4B4B', 'Complete': '#36A2EB'}
-    )
+        # Validate CSV columns
+        column_mapping = {
+            'Material_Type': 'Material_Type',
+            'Planned_Quantity': ['Planned_Quantity', 'Planned_Qty'],
+            'Received_Quantity': ['Received_Quantity', 'Received_Qty'],
+            'Used_Quantity': ['Used_Quantity', 'Used_Qty']
+        }
+        
+        for internal_name, possible_names in column_mapping.items():
+            if isinstance(possible_names, list):
+                found = False
+                for name in possible_names:
+                    if name in df.columns:
+                        df.rename(columns={name: internal_name}, inplace=True)
+                        found = True
+                        break
+                if not found:
+                    raise ValueError(f"Missing required column: {internal_name}")
+            else:
+                if possible_names not in df.columns:
+                    raise ValueError(f"Missing required column: {possible_names}")
+
+        # Validate data types
+        for col in ['Planned_Quantity', 'Received_Quantity', 'Used_Quantity']:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+            if df[col].isna().any():
+                raise ValueError(f"Column '{col}' contains non-numeric values or empty cells.")
+
+        # Calculate balance and deviation
+        df['Balance_Quantity'] = df['Received_Quantity'] - df['Used_Quantity']
+        df['Deviation'] = df.apply(
+            lambda row: ((row['Balance_Quantity'] - row['Planned_Quantity']) / row['Planned_Quantity'] * 100)
+            if row['Planned_Quantity'] != 0 else 0, axis=1
+        )
+
+        # Anomaly detection
+        iso_forest = IsolationForest(contamination=0.1, random_state=42)
+        features = df[['Planned_Quantity', 'Received_Quantity', 'Used_Quantity', 'Deviation']]
+        df['Anomaly'] = iso_forest.fit_predict(features)
+        df.loc[df['Deviation'].abs() > 50, 'Anomaly'] = -1
+
+        # Generate suggestions and status
+        df['AI_Suggestion'] = df.apply(generate_suggestion, axis=1)
+        df['Reconciliation_Status'] = df.apply(
+            lambda row: 'Flagged' if row['Anomaly'] == -1 or abs(row['Deviation']) > 50 else 'Complete', axis=1
+        )
+
+        # Insert records into Salesforce
+        sf = connect_to_salesforce()
+        salesforce_result = insert_reconciliation_to_salesforce(df, sf)
 
-    # AI Suggestions summary
-    ai_summary = "\n".join([f"{row['Material_Type']}: {row['AI_Suggestion']}" for _, row in df.iterrows()])
+        # Generate text output
+        text_output = f"Material Reconciliation Results\n{'='*30}\n\n{salesforce_result}\n\nDetailed Records:\n"
+        for index, row in df.iterrows():
+            text_output += f"Record {index + 1}:\n"
+            if 'Project_ID' in df.columns and pd.notna(row['Project_ID']):
+                text_output += f"  Project ID: {row['Project_ID']}\n"
+            text_output += f"  Material Type: {row['Material_Type']}\n"
+            text_output += f"  Planned Quantity: {row['Planned_Quantity']:.0f}\n"
+            text_output += f"  Received Quantity: {row['Received_Quantity']:.0f}\n"
+            text_output += f"  Used Quantity: {row['Used_Quantity']:.0f}\n"
+            text_output += f"  Balance Quantity: {row['Balance_Quantity']:.0f}\n"
+            text_output += f"  Deviation: {row['Deviation']:.2f}%\n"
+            text_output += f"  Anomaly: {'Yes' if row['Anomaly'] == -1 else 'No'}\n"
+            text_output += f"  AI Suggestion: {row['AI_Suggestion']}\n"
+            text_output += f"  Reconciliation Status: {row['Reconciliation_Status']}\n"
+            text_output += f"{'-'*30}\n"
 
-    return output_file, text_output, df, bar_fig, pie_fig, ai_summary
+        # Save results to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp_file:
+            output_file = tmp_file.name
+            df.to_csv(output_file, index=False)
+            logger.debug(f"Output CSV saved to: {output_file}")
 
-# Gradio interface using Blocks
-logger.debug("Setting up Gradio Blocks interface")
-with gr.Blocks(css='button:has(span:contains("Share via Link")) { display: none !important; }') as interface:
-    gr.Markdown("# Material Reconciliation Dashboard")
+        # Create visualizations
+        bar_fig = px.bar(
+            df,
+            x='Material_Type',
+            y='Deviation',
+            color='Reconciliation_Status',
+            title='Deviation by Material Type',
+            labels={'Deviation': 'Deviation (%)'},
+            color_discrete_map={'Flagged': '#FF4B4B', 'Complete': '#36A2EB'},
+            hover_data=['Planned_Quantity', 'Received_Quantity', 'Used_Quantity']
+        )
+        bar_fig.update_layout(
+            xaxis_title="Material Type",
+            yaxis_title="Deviation (%)",
+            xaxis_tickangle=45,
+            hovermode='closest'
+        )
+
+        status_counts = df['Reconciliation_Status'].value_counts().reset_index()
+        status_counts.columns = ['Reconciliation_Status', 'Count']
+        pie_fig = px.pie(
+            status_counts,
+            names='Reconciliation_Status',
+            values='Count',
+            title='Reconciliation Status Distribution',
+            color_discrete_map={'Flagged': '#FF4B4B', 'Complete': '#36A2EB'}
+        )
+        pie_fig.update_traces(textinfo='percent+label', hovertemplate='%{label}: %{value} (%{percent})')
+
+        quantity_fig = px.bar(
+            df,
+            x='Material_Type',
+            y=['Planned_Quantity', 'Received_Quantity', 'Used_Quantity'],
+            title='Quantity Comparison by Material',
+            labels={'value': 'Quantity', 'variable': 'Quantity Type'},
+            barmode='stack'
+        )
+        quantity_fig.update_layout(xaxis_title="Material Type", yaxis_title="Quantity", xaxis_tickangle=45)
+
+        ai_summary = "\n".join([f"{row['Material_Type']}: {row['AI_Suggestion']}" for _, row in df.iterrows()])
+
+        return output_file, text_output, df, bar_fig, pie_fig, quantity_fig, ai_summary
+    
+    except Exception as e:
+        logger.error(f"Error in reconcile_materials: {str(e)}")
+        return None, f"Error: {str(e)}", None, None, None, None, ""
+    finally:
+        if tmp_file_path and os.path.exists(tmp_file_path):
+            try:
+                os.unlink(tmp_file_path)
+            except:
+                pass
+
+# Gradio interface
+with app:
+    gr.Markdown("# Material Reconciliation Dashboard", elem_classes="text-3xl font-bold mb-4 text-center")
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## Upload CSV File")
-            csv_input = gr.File(label="Upload CSV", file_types=[".csv"])
-            submit_button = gr.Button("Reconcile Materials")
+            gr.Markdown("## Upload CSV File", elem_classes="text-xl font-semibold mb-2")
+            csv_input = gr.File(label="Upload CSV (max 10MB)", file_types=[".csv"])
+            submit_button = gr.Button("Reconcile Materials", variant="primary")
         with gr.Column(scale=2):
-            gr.Markdown("## Reconciliation Results")
-            output_text = gr.Textbox(label="Detailed Results", lines=20)
+            gr.Markdown("## Reconciliation Results", elem_classes="text-xl font-semibold mb-2")
+            output_text = gr.Textbox(label="Detailed Results", lines=20, elem_classes="bg-gray-100 p-4 rounded")
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("## Data Table")
-            output_table = gr.Dataframe(label="Reconciled Data")
+            gr.Markdown("## Data Table", elem_classes="text-xl font-semibold mb-2")
+            output_table = gr.Dataframe(label="Reconciled Data", interactive=True)
         with gr.Column(scale=1):
-            gr.Markdown("## AI Suggestions")
-            ai_summary_output = gr.Textbox(label="AI Suggestions Summary")
+            gr.Markdown("## AI Suggestions", elem_classes="text-xl font-semibold mb-2")
+            ai_summary_output = gr.Textbox(label="AI Suggestions Summary", elem_classes="bg-gray-100 p-4 rounded")
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## Deviation by Material")
+            gr.Markdown("## Deviation by Material", elem_classes="text-lg font-medium mb-2")
             bar_plot = gr.Plot(label="Deviation Plot")
         with gr.Column(scale=1):
-            gr.Markdown("## Reconciliation Status Distribution")
+            gr.Markdown("## Reconciliation Status Distribution", elem_classes="text-lg font-medium mb-2")
             pie_plot = gr.Plot(label="Status Distribution")
+        with gr.Column(scale=1):
+            gr.Markdown("## Quantity Comparison", elem_classes="text-lg font-medium mb-2")
+            quantity_plot = gr.Plot(label="Quantity Plot")
     output_file = gr.File(label="Download Reconciled CSV")
     
     submit_button.click(
         fn=reconcile_materials,
         inputs=csv_input,
-        outputs=[output_file, output_text, output_table, bar_plot, pie_plot, ai_summary_output]
+        outputs=[output_file, output_text, output_table, bar_plot, pie_plot, quantity_plot, ai_summary_output],
+        _js="() => { return { show_progress: 'full' } }"  # Enable loading indicator
     )
 
-logger.debug("Launching Gradio Blocks interface")
-interface.launch
+if __name__ == '__main__':
+    port = int(os.getenv("PORT", 7860))
+    app.launch(server_name="0.0.0.0", server_port=port, debug=False)