Update app.py

app.py

@@ -1,91 +1,185 @@
+import streamlit as st
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
 import seaborn as sns
-import plotly.express as px
 from datetime import datetime
 
+# Set page config
+st.set_page_config(page_title="Nuisance Complaints Dashboard", layout="wide")
+
+# Title and introduction
+st.title("Nuisance Complaints Analysis Dashboard")
+st.markdown("**Team Members:** Shreyas Kulkarni (ssk16@illinois.edu) Vishal Devulapalli (nsd3@illinois.edu) Lu Chang (luchang2@illinois.edu)  Li Qiming (qimingl4@illinois.edu) Ruchita Alate (ralate2@illinois.edu) ")
+st.write("This dashboard analyzes nuisance complaints data from the City of Urbana.")
+
 # Load and clean data
+@st.cache_data
 def load_and_clean_data():
+    # Load data
     data = pd.read_csv('Nuisance_Complaints_20241130.csv')
 
-    # Convert date columns
-    date_columns = ['Date Reported', 'Date Notice Mailed or Given', 'File Close Date']
-    for col in date_columns:
-        data[col] = pd.to_datetime(data[col], errors='coerce')
+    # Drop rows with missing File Number
+    data = data.dropna(subset=['File Number'])
 
-    # Handle missing values
+    # Handle Date Notice Mailed or Given
+    data['Date Notice Mailed or Given'] = pd.to_datetime(data['Date Notice Mailed or Given'])
+    data['Date Reported'] = pd.to_datetime(data['Date Reported'])
+    median_delay = (data['Date Notice Mailed or Given'] - data['Date Reported']).dt.days.median()
+    data['Date Notice Mailed or Given'].fillna(data['Date Reported'] + pd.to_timedelta(median_delay, unit='D'), inplace=True)
+
+    # Handle Type of Complaint
     data['Type of Complaint'].fillna('Unknown', inplace=True)
-    data['Disposition'].fillna('Pending', inplace=True)
-    data['Method Submitted'].fillna('Not Specified', inplace=True)
 
-    # Calculate processing time
+    # Handle Disposition
+    most_common_disposition = data.groupby('Type of Complaint')['Disposition'].apply(
+        lambda x: x.mode()[0] if not x.mode().empty else 'Pending')
+    data['Disposition'] = data.apply(
+        lambda row: most_common_disposition[row['Type of Complaint']]
+        if pd.isnull(row['Disposition']) else row['Disposition'], axis=1)
+
+    # Handle File Close Date
+    data['File Close Date'] = pd.to_datetime(data['File Close Date'], errors='coerce')
+
+    # Calculate processing time only for resolved cases
     data['Processing Time'] = (data['File Close Date'] - data['Date Reported']).dt.days
 
-    # Remove duplicates
-    data.drop_duplicates(subset=['File Number'], keep='first', inplace=True)
+    # Handle Method Submitted
+    data['Method Submitted'] = data.apply(
+        lambda row: 'Online' if row['Submitted Online?'] and pd.isnull(row['Method Submitted'])
+        else row['Method Submitted'], axis=1)
+    mode_method = data['Method Submitted'].mode()[0]
+    data['Method Submitted'].fillna(mode_method, inplace=True)
+
+    # Drop rows with missing Submitted Online?
+    data = data.dropna(subset=['Submitted Online?'])
+
+    # Handle Mapped Location
+    data = data.dropna(subset=['Mapped Location'])
+
+    # Extract latitude and longitude
+    data['Latitude'] = data['Mapped Location'].str.extract(r'\(([^,]+),')[0].astype(float)
+    data['Longitude'] = data['Mapped Location'].str.extract(r', ([^,]+)\)').astype(float)
 
     return data
 
-# Create visualizations
-def create_visualizations(data):
-    # 1. Complaint Types Over Time
-    plt.figure(figsize=(12, 6))
-    complaints_over_time = data.groupby(['Year Reported', 'Type of Complaint']).size().unstack()
-    complaints_over_time.plot(kind='line', marker='o')
-    plt.title('Trends in Complaint Types Over Years')
-    plt.xlabel('Year')
-    plt.ylabel('Number of Complaints')
-    plt.legend(title='Complaint Type', bbox_to_anchor=(1.05, 1))
-    plt.tight_layout()
-    plt.show()
-
-    # 2. Resolution Distribution
-    plt.figure(figsize=(10, 6))
-    sns.countplot(data=data, y='Disposition', order=data['Disposition'].value_counts().index)
-    plt.title('Distribution of Complaint Resolutions')
-    plt.xlabel('Count')
-    plt.ylabel('Resolution Type')
-    plt.tight_layout()
-    plt.show()
-
-    # 3. Average Processing Time by Submission Method
-    plt.figure(figsize=(10, 6))
-    avg_processing_time = data.groupby('Method Submitted')['Processing Time'].mean().sort_values()
-    sns.barplot(x=avg_processing_time.values, y=avg_processing_time.index)
-    plt.title('Average Processing Time by Submission Method')
-    plt.xlabel('Average Processing Time (Days)')
-    plt.ylabel('Submission Method')
-    plt.tight_layout()
-    plt.show()
-
-    # 4. Monthly Distribution of Complaints
-    plt.figure(figsize=(10, 6))
-    monthly_complaints = data.groupby('Month Reported').size()
-    sns.barplot(x=monthly_complaints.index, y=monthly_complaints.values)
-    plt.title('Monthly Distribution of Complaints')
-    plt.xlabel('Month')
-    plt.ylabel('Number of Complaints')
-    plt.tight_layout()
-    plt.show()
-
-    # 5. Complaint Type Distribution
-    plt.figure(figsize=(10, 6))
-    sns.countplot(data=data, y='Type of Complaint',
-                 order=data['Type of Complaint'].value_counts().index)
-    plt.title('Distribution of Complaint Types')
-    plt.xlabel('Count')
-    plt.ylabel('Complaint Type')
-    plt.tight_layout()
-    plt.show()
-
-# Main execution
-def main():
-    # Load and clean data
+# Load the data
+try:
     data = load_and_clean_data()
+    st.success("Data successfully loaded and cleaned!")
+except Exception as e:
+    st.error(f"Error loading data: {str(e)}")
+    st.stop()
+
+# Create sidebar
+st.sidebar.header("Dashboard Controls")
+selected_year = st.sidebar.selectbox(
+    "Select Year",
+    options=sorted(data['Year Reported'].unique()),
+)
+
+# Add visualization type selector
+viz_type = st.sidebar.selectbox(
+    "Select Visualization",
+    ["Complaint Types", "Geographic Distribution", "Resolution Status",
+     "Submission Methods", "Processing Time"]
+)
+
+# Filter data based on selected year
+filtered_data = data[data['Year Reported'] == selected_year]
+
+# Main content
+st.header(f"Analysis for Year {selected_year}")
+
+# Create metrics
+col1, col2, col3 = st.columns(3)
+with col1:
+    st.metric("Total Complaints", len(filtered_data))
+with col2:
+    # Calculate average processing time only for resolved cases
+    resolved_cases = filtered_data[filtered_data['File Close Date'].notna()]
+    if len(resolved_cases) > 0:
+        avg_process_time = resolved_cases['Processing Time'].mean()
+        st.metric("Average Processing Time", f"{avg_process_time:.1f} days")
+    else:
+        st.metric("Average Processing Time", "N/A")
+with col3:
+    st.metric("Most Common Type", filtered_data['Type of Complaint'].mode()[0])
+
+
+if viz_type == "Complaint Types":
+    # Interactive Pie Chart
+    st.subheader("Interactive Complaint Types Pie Chart")
+    complaint_counts = filtered_data['Type of Complaint'].value_counts().reset_index()
+    complaint_counts.columns = ['Complaint Type', 'Count']
+
+    fig = px.pie(
+        complaint_counts,
+        names='Complaint Type',
+        values='Count',
+        title=f'Complaint Types Distribution in {selected_year}',
+        hole=0.4  # Donut style
+    )
+    fig.update_traces(textinfo='percent+label')
+    st.plotly_chart(fig, use_container_width=True)
+
+elif viz_type == "Geographic Distribution":
+    # Clustered Heatmap
+    st.subheader("Clustered Heatmap of Complaints")
+    map_center = [filtered_data['Latitude'].mean(), filtered_data['Longitude'].mean()]
+    m = folium.Map(location=map_center, zoom_start=12)
+
+    heat_data = filtered_data[['Latitude', 'Longitude']].dropna().values.tolist()
+    HeatMap(heat_data).add_to(m)
+
+    st_data = st_folium(m, width=700, height=500)
+
+
+elif viz_type == "Resolution Status":
+    st.subheader("Complaint Resolution Status")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    resolution_counts = filtered_data['Disposition'].value_counts()
+    sns.barplot(x=resolution_counts.values, y=resolution_counts.index)
+    plt.title(f'Resolution Status Distribution in {selected_year}')
+    st.pyplot(fig)
+
+elif viz_type == "Submission Methods":
+    st.subheader("Submission Methods Analysis")
+    fig, ax = plt.subplots(figsize=(10, 6))
+    submission_counts = filtered_data['Method Submitted'].value_counts()
+    sns.barplot(x=submission_counts.values, y=submission_counts.index)
+    plt.title(f'Submission Methods in {selected_year}')
+    st.pyplot(fig)
+
+
+elif viz_type == "Processing Time":
+    st.subheader("Processing Time Analysis")
+    # Filter for resolved cases only
+    resolved_data = filtered_data[filtered_data['File Close Date'].notna()]
+    if len(resolved_data) > 0:
+        fig, ax = plt.subplots(figsize=(10, 6))
+        sns.histplot(data=resolved_data, x='Processing Time', bins=30)
+        plt.title(f'Distribution of Processing Times in {selected_year}')
+        plt.xlabel('Processing Time (Days)')
+        st.pyplot(fig)
+    else:
+        st.write("No resolved cases in this period")
+
+# Additional insights
+st.header("Key Insights")
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("Top 3 Complaint Types")
+    top_complaints = filtered_data['Type of Complaint'].value_counts().head(3)
+    st.write(top_complaints)
 
-    # Create visualizations
-    create_visualizations(data)
+with col2:
+    st.subheader("Resolution Efficiency")
+    resolution_rate = (filtered_data['Disposition'].value_counts() /
+                      len(filtered_data) * 100).round(2)
+    st.write(resolution_rate)
 
-if __name__ == "__main__":
-    main()
+# Footer
+st.markdown("---")
+st.markdown("Dataset provided by the City of Urbana Open Data Portal")