Update app.py

app.py

@@ -1,38 +1,41 @@
 import pandas as pd
 import numpy as np
 from sklearn.ensemble import IsolationForest
-import streamlit as st
+import dash
+from dash import dcc, html, Input, Output
+from simple_salesforce import Salesforce
 import plotly.express as px
 import plotly.graph_objects as go
-from simple_salesforce import Salesforce
 import logging
 import os
 import tempfile
-from uuid import uuid4
 
 # Set up logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-# Salesforce credentials
+# Salesforce credentials (should be stored in environment variables in production)
 SALESFORCE_USERNAME = "vijaypulmamidi.dev2025@sathkrutha.com"
 SALESFORCE_PASSWORD = "Vij@y9100754977"
 SALESFORCE_SECURITY_TOKEN = "CaZSEwVmB3EIAiV6G8ukdDp0"
 
-def get_salesforce_connection():
-    """Establish connection to Salesforce using provided credentials."""
+# Initialize Dash app
+app = dash.Dash(__name__, title="Material Reconciliation Dashboard")
+server = app.server  # Required for Hugging Face deployment
+
+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.info("Successfully connected to Salesforce")
+        logger.debug("Successfully connected to Salesforce")
         return sf
     except Exception as e:
         logger.error(f"Failed to connect to Salesforce: {str(e)}")
-        st.error("Failed to connect to Salesforce. Please check credentials.")
-        return None
+        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."""
@@ -41,50 +44,51 @@ def find_salesforce_project(project_name, sf):
         result = sf.query(query)
         if result['totalSize'] > 0:
             project_id = result['records'][0]['Id']
-            logger.info(f"Found Project__c with Name: {project_name}, ID: {project_id}")
+            logger.debug(f"Found Project__c with Name: {project_name}, ID: {project_id}")
             return project_id
-        logger.info(f"No Project__c found with Name: {project_name}")
+        logger.debug(f"No Project__c found with Name: {project_name}")
         return None
     except Exception as e:
-        logger.error(f"Error querying Project__c: {str(e)}")
+        logger.error(f"Error finding project {project_name}: {str(e)}")
         return None
 
 def insert_reconciliation_to_salesforce(df, sf):
-    """Insert reconciliation records into Salesforce."""
+    """Inserts reconciliation records into Salesforce."""
     inserted_count = 0
     project_cache = {}
     
     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 = 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
+            
+            logger.debug(f"Inserting record: {reconciliation_record}")
             sf.Material_Reconciliation_Record__c.create(reconciliation_record)
             inserted_count += 1
-            logger.info(f"Inserted record: {reconciliation_record}")
         except Exception as e:
-            logger.error(f"Error inserting record: {str(e)}")
+            logger.error(f"Error inserting record {index}: {str(e)}")
+            continue
     
-    logger.info(f"Inserted {inserted_count} of {len(df)} records successfully")
-    return inserted_count
+    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."""
@@ -98,16 +102,17 @@ def generate_suggestion(row):
                 return f"Shortage: Order {abs(row['Used_Quantity'] - row['Planned_Quantity'])} more units of {row['Material_Type']}."
         return "No action needed."
     except Exception as e:
-        logger.error(f"Error generating suggestion: {str(e)}")
+        logger.error(f"Error generating suggestion for row: {str(e)}")
         return "Error generating suggestion"
 
-def process_csv_data(file):
-    """Process uploaded CSV file and perform reconciliation."""
+def process_csv(file_path):
+    """Process CSV file and perform reconciliation."""
     try:
-        df = pd.read_csv(file)
-        logger.info(f"CSV read successfully. Columns: {df.columns.tolist()}")
+        # Read CSV
+        df = pd.read_csv(file_path)
+        logger.debug(f"CSV read successfully. Columns: {df.columns.tolist()}")
 
-        # Validate CSV columns
+        # Validate columns
         column_mapping = {
             'Material_Type': 'Material_Type',
             'Planned_Quantity': ['Planned_Quantity', 'Planned_Qty'],
@@ -157,100 +162,169 @@ def process_csv_data(file):
         return df
     except Exception as e:
         logger.error(f"Error processing CSV: {str(e)}")
-        st.error(f"Error processing CSV: {str(e)}")
-        return None
+        raise
 
 def create_visualizations(df):
     """Create visualizations for the dashboard."""
-    # Bar chart for Deviation
-    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 (%)")
+    try:
+        # Bar chart for Deviation
+        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'}
-    )
+        # 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 Suggestions summary
-    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 bar_fig, pie_fig, ai_summary
+        return bar_fig, pie_fig, ai_summary
+    except Exception as e:
+        logger.error(f"Error creating visualizations: {str(e)}")
+        raise
 
-def main():
-    """Main function to set up Streamlit dashboard."""
-    st.set_page_config(page_title="Material Reconciliation Dashboard", layout="wide")
-    st.title("Material Reconciliation Dashboard")
+# Dash layout
+app.layout = html.Div([
+    html.H1("Material Reconciliation Dashboard", className="text-3xl font-bold mb-4"),
+    html.Div([
+        html.H2("Upload CSV File", className="text-xl font-semibold mb-2"),
+        dcc.Upload(
+            id='upload-data',
+            children=html.Button('Upload CSV', className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded"),
+            multiple=False,
+            accept='.csv'
+        ),
+        html.Div(id='upload-status', className="mt-2 text-gray-600")
+    ], className="mb-6"),
     
-    # Initialize Salesforce connection
-    sf = get_salesforce_connection()
-    
-    # File upload
-    st.subheader("Upload CSV File")
-    uploaded_file = st.file_uploader("Choose a CSV file", type=["csv"])
+    html.Div(id='output-container', children=[
+        html.H2("Reconciliation Results", className="text-xl font-semibold mb-2"),
+        html.Div(id='output-text', className="bg-gray-100 p-4 rounded mb-4"),
+        
+        html.H2("Data Table", className="text-xl font-semibold mb-2"),
+        dcc.Graph(id='data-table'),
+        
+        html.H2("AI Suggestions", className="text-xl font-semibold mb-2"),
+        html.Div(id='ai-suggestions', className="bg-gray-100 p-4 rounded mb-4"),
+        
+        html.H2("Visualizations", className="text-xl font-semibold mb-2"),
+        html.Div([
+            html.Div([
+                html.H3("Deviation by Material", className="text-lg font-medium mb-2"),
+                dcc.Graph(id='bar-plot')
+            ], className="w-full md:w-1/2 p-2"),
+            html.Div([
+                html.H3("Reconciliation Status Distribution", className="text-lg font-medium mb-2"),
+                dcc.Graph(id='pie-plot')
+            ], className="w-full md:w-1/2 p-2")
+        ], className="flex flex-wrap"),
+        
+        html.A(
+            "Download Reconciled CSV",
+            id='download-link',
+            download="reconciled_data.csv",
+            href="",
+            className="bg-green-500 hover:bg-green-700 text-white font-bold py-2 px-4 rounded mt-4 inline-block"
+        )
+    ], className="container mx-auto p-4")
+], className="p-6 bg-gray-50 min-h-screen")
+
+@app.callback(
+    [
+        Output('upload-status', 'children'),
+        Output('output-text', 'children'),
+        Output('data-table', 'figure'),
+        Output('bar-plot', 'figure'),
+        Output('pie-plot', 'figure'),
+        Output('ai-suggestions', 'children'),
+        Output('download-link', 'href')
+    ],
+    [Input('upload-data', 'contents')],
+    [Input('upload-data', 'filename')]
+)
+def update_output(uploaded_file, filename):
+    """Callback to process uploaded CSV and update dashboard."""
+    if uploaded_file is None:
+        return "No file uploaded.", "", {}, {}, {}, "", ""
     
-    if uploaded_file:
-        with st.spinner("Processing data..."):
-            df = process_csv_data(uploaded_file)
-            if df is not None:
-                # Save results to 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.info(f"Output CSV saved to: {output_file}")
+    try:
+        # Save uploaded file temporarily
+        content_type, content_string = uploaded_file.split(',')
+        import base64
+        decoded = base64.b64decode(content_string)
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as tmp_file:
+            tmp_file.write(decoded)
+            tmp_file_path = tmp_file.name
+
+        # Process CSV
+        df = process_csv(tmp_file_path)
+        
+        # Connect to Salesforce and insert records
+        sf = connect_to_salesforce()
+        salesforce_result = insert_reconciliation_to_salesforce(df, sf)
 
-                # Insert to Salesforce if connection is available
-                if sf:
-                    inserted_count = insert_reconciliation_to_salesforce(df, sf)
-                    st.success(f"Inserted {inserted_count} records into Salesforce")
+        # Generate visualizations
+        bar_fig, pie_fig, ai_summary = create_visualizations(df)
 
-                # Create visualizations
-                bar_fig, pie_fig, ai_summary = create_visualizations(df)
+        # Create table figure
+        table_fig = go.Figure(data=[go.Table(
+            header=dict(values=list(df.columns), fill_color='paleturquoise', align='left'),
+            cells=dict(values=[df[col] for col in df.columns], fill_color='lavender', align='left')
+        )])
 
-                # Display results
-                st.subheader("Reconciliation Results")
-                col1, col2 = st.columns([2, 1])
-                
-                with col1:
-                    st.subheader("Data Table")
-                    st.dataframe(df, use_container_width=True)
-                
-                with col2:
-                    st.subheader("AI Suggestions")
-                    st.text_area("Suggestions", ai_summary, height=200)
+        # 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']}\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 += f"{'-'*30}\n"
 
-                # Visualizations
-                st.subheader("Visualizations")
-                col3, col4 = st.columns(2)
-                
-                with col3:
-                    st.plotly_chart(bar_fig, use_container_width=True)
-                
-                with col4:
-                    st.plotly_chart(pie_fig, use_container_width=True)
+        # Create download link
+        csv_string = df.to_csv(index=False)
+        csv_string = "data:text/csv;charset=utf-8," + csv_string
+        import urllib.parse
+        csv_string = urllib.parse.quote(csv_string, safe=':,')
 
-                # Download link
-                st.subheader("Download Results")
-                with open(output_file, "rb") as file:
-                    st.download_button(
-                        label="Download Reconciled CSV",
-                        data=file,
-                        file_name="reconciled_data.csv",
-                        mime="text/csv"
-                    )
+        # Clean up temporary file
+        os.unlink(tmp_file_path)
+
+        return (
+            f"File {filename} processed successfully.",
+            text_output,
+            table_fig,
+            bar_fig,
+            pie_fig,
+            ai_summary,
+            csv_string
+        )
+    except Exception as e:
+        logger.error(f"Error in callback: {str(e)}")
+        return f"Error processing file: {str(e)}", "", {}, {}, {}, "", ""
 
-if __name__ == "__main__":
-    main()
+if __name__ == '__main__':
+    app.run_server(debug=True)