Update app.py

app.py

@@ -8,340 +8,242 @@ import logging
 from simple_salesforce import Salesforce
 import plotly.express as px
 import plotly.graph_objects as go
-import re
-from flask import Flask
-from http import HTTPStatus
+from plotly.subplots import make_subplots
 
 # Set up logging
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-# Initialize Flask for health check
-server = Flask(__name__)
+# Salesforce credentials
+SALESFORCE_USERNAME = "vijaypulmamidi.dev2025@sathkrutha.com"
+SALESFORCE_PASSWORD = "Vij@y9100754977"
+SALESFORCE_SECURITY_TOKEN = "CaZSEwVmB3EIAiV6G8ukdDp0"
 
-# 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)}")
+# Connect to Salesforce
+sf = Salesforce(username=SALESFORCE_USERNAME, password=SALESFORCE_PASSWORD, security_token=SALESFORCE_SECURITY_TOKEN)
+logger.debug("Successfully connected to Salesforce.")
 
 def find_salesforce_project(project_name, sf):
     """Find an existing Project__c record by name and return its ID."""
-    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
+    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
 
 def insert_reconciliation_to_salesforce(df, sf):
-    """Inserts reconciliation records into Salesforce in batches."""
+    """Inserts reconciliation records into Salesforce, linking to existing Project__c records if possible."""
     inserted_count = 0
     project_cache = {}
-    batch_size = 200
     
-    records = []
     for index, row in df.iterrows():
-        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
+        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
         
-        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)}")
+        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
+        
+        logger.debug(f"Inserting record: {reconciliation_record}")
+        sf.Material_Reconciliation_Record__c.create(reconciliation_record)
+        inserted_count += 1
     
     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."""
-    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"
+    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."
 
 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)}")
-    tmp_file_path = None
+
+    # 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']
+    }
     
-    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)
+    # 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}")
         else:
-            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)
-
-        logger.debug(f"CSV read successfully. Columns: {df.columns.tolist()}")
-
-        # 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)
-
-        # 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"
-
-        # 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_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'
-        )
+            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")
 
-        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})')
+    # Insert records into Salesforce
+    salesforce_result = insert_reconciliation_to_salesforce(df, sf)
+    logger.debug(f"Salesforce insert result: {salesforce_result}")
 
-        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)
+    # 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'}
+    )
 
-        ai_summary = "\n".join([f"{row['Material_Type']}: {row['AI_Suggestion']}" for _, row in df.iterrows()])
+    # AI Suggestions summary
+    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
+    return output_file, text_output, df, bar_fig, pie_fig, ai_summary
 
-# Gradio interface
-with app:
-    gr.Markdown("# Material Reconciliation Dashboard", elem_classes="text-3xl font-bold mb-4 text-center")
+# 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")
     with gr.Row():
         with gr.Column(scale=1):
-            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")
+            gr.Markdown("## Upload CSV File")
+            csv_input = gr.File(label="Upload CSV", file_types=[".csv"])
+            submit_button = gr.Button("Reconcile Materials")
         with gr.Column(scale=2):
-            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")
+            gr.Markdown("## Reconciliation Results")
+            output_text = gr.Textbox(label="Detailed Results", lines=20)
     with gr.Row():
         with gr.Column(scale=2):
-            gr.Markdown("## Data Table", elem_classes="text-xl font-semibold mb-2")
-            output_table = gr.Dataframe(label="Reconciled Data", interactive=True)
+            gr.Markdown("## Data Table")
+            output_table = gr.Dataframe(label="Reconciled Data")
         with gr.Column(scale=1):
-            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")
+            gr.Markdown("## AI Suggestions")
+            ai_summary_output = gr.Textbox(label="AI Suggestions Summary")
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("## Deviation by Material", elem_classes="text-lg font-medium mb-2")
+            gr.Markdown("## Deviation by Material")
             bar_plot = gr.Plot(label="Deviation Plot")
         with gr.Column(scale=1):
-            gr.Markdown("## Reconciliation Status Distribution", elem_classes="text-lg font-medium mb-2")
+            gr.Markdown("## Reconciliation Status Distribution")
             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, quantity_plot, ai_summary_output],
-        _js="() => { return { show_progress: 'full' } }"  # Enable loading indicator
+        outputs=[output_file, output_text, output_table, bar_plot, pie_plot, ai_summary_output]
     )
 
-if __name__ == '__main__':
-    port = int(os.getenv("PORT", 7860))
-    app.launch(server_name="0.0.0.0", server_port=port, debug=False)
+logger.debug("Launching Gradio Blocks interface")
+interface.launch()