Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,20 +1,443 @@
 import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+import tempfile
+import os
+from datetime import datetime
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib import colors
+from reportlab.lib.units import inch
+import io
+import base64
+from PIL import Image as PILImage
+import calendar
 
-# Set page title
+# Set page configuration
 st.set_page_config(
-    page_title="Simple Streamlit Test",
-    page_icon="✅"
+    page_title="Charging Outlets Dashboard",
+    page_icon="⚡",
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
-# Main page content
-st.title("Simple Streamlit Test App")
-st.write("This is a minimal Streamlit app to test that everything is working correctly.")
+# Custom CSS for styling
+st.markdown("""
+<style>
+    .main {
+        padding: 2rem;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        white-space: pre-wrap;
+        border-radius: 4px 4px 0px 0px;
+    }
+    h1, h2, h3 {
+        color: #2c3e50;
+    }
+    .metric-card {
+        background-color: #f8f9fa;
+        border-radius: 8px;
+        padding: 20px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        text-align: center;
+    }
+    .metric-value {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #3498db;
+    }
+    .metric-label {
+        font-size: 1.2rem;
+        color: #7f8c8d;
+    }
+</style>
+""", unsafe_allow_html=True)
 
-# Add a simple interactive element
-if st.button("Click me!"):
-    st.success("Button clicked!")
-    st.balloons()
+# Page title
+st.title("⚡ Charging Outlets Analytics Dashboard")
+st.markdown("Upload your data files to analyze charging outlet performance and utilization.")
 
-# Display some basic information
-st.subheader("Next Steps")
-st.info("Once this app is working, we can replace it with the full dashboard application.")
+# File upload section
+st.sidebar.header("Upload Data Files")
+sessions_file = st.sidebar.file_uploader("Upload Sessions.xlsx", type=["xlsx"])
+overview_file = st.sidebar.file_uploader("Upload Overview.xlsx", type=["xlsx"])
+
+# Function to preprocess data
+def preprocess_data(sessions_df, overview_df):
+    # Convert date columns to datetime
+    sessions_df['Startad'] = pd.to_datetime(sessions_df['Startad'])
+    sessions_df['Avslutad'] = pd.to_datetime(sessions_df['Avslutad'])
+    
+    # Extract year and month for analysis
+    sessions_df['Year'] = sessions_df['Startad'].dt.year
+    sessions_df['Month'] = sessions_df['Startad'].dt.month
+    sessions_df['Month_Name'] = sessions_df['Startad'].dt.strftime('%b')
+    sessions_df['Year_Month'] = sessions_df['Startad'].dt.strftime('%Y-%m')
+    
+    # Calculate session duration in hours
+    sessions_df['Duration_Hours'] = (sessions_df['Avslutad'] - sessions_df['Startad']).dt.total_seconds() / 3600
+    
+    # Clean numeric columns
+    if isinstance(sessions_df['Laddat (kWh)'].iloc[0], str):
+        sessions_df['Laddat (kWh)'] = sessions_df['Laddat (kWh)'].str.replace(',', '.').astype(float)
+    
+    if isinstance(sessions_df['Kostnad (exkl)'].iloc[0], str):
+        sessions_df['Kostnad (exkl)'] = sessions_df['Kostnad (exkl)'].str.replace(',', '.').astype(float)
+    
+    # Ensure outlet numbers are integers
+    sessions_df['Uttag'] = pd.to_numeric(sessions_df['Uttag'], errors='coerce').fillna(0).astype(int)
+    
+    return sessions_df, overview_df
+
+# Function to calculate metrics
+def calculate_metrics(sessions_df, overview_df):
+    metrics = {}
+    
+    # Get unique areas
+    unique_areas = sessions_df['Område'].unique()
+    metrics['unique_areas'] = unique_areas
+    metrics['area_count'] = len(unique_areas)
+    
+    # Calculate outlets per area
+    outlets_per_area = sessions_df.groupby('Område')['Uttag'].nunique().reset_index()
+    outlets_per_area.columns = ['Område', 'Number_of_Outlets']
+    metrics['outlets_per_area'] = outlets_per_area
+    
+    # Calculate kWh per month per area
+    kwh_per_month_area = sessions_df.groupby(['Område', 'Year_Month'])['Laddat (kWh)'].sum().reset_index()
+    metrics['kwh_per_month_area'] = kwh_per_month_area
+    
+    # Calculate kWh per outlet per month per area
+    kwh_outlet_month_area = sessions_df.groupby(['Område', 'Year_Month', 'Uttag'])['Laddat (kWh)'].sum().reset_index()
+    metrics['kwh_outlet_month_area'] = kwh_outlet_month_area
+    
+    # Calculate utilization (this is simplified and might need adjustment)
+    # First, get the total possible outlet days for each area (outlets × days in month)
+    all_months = sessions_df['Year_Month'].unique()
+    all_areas = sessions_df['Område'].unique()
+    
+    utilization_data = []
+    
+    for area in all_areas:
+        area_outlets = sessions_df[sessions_df['Område'] == area]['Uttag'].nunique()
+        
+        for ym in all_months:
+            year, month = map(int, ym.split('-'))
+            days_in_month = calendar.monthrange(year, month)[1]
+            total_outlet_days = area_outlets * days_in_month
+            
+            # Count actual used outlet days
+            area_month_data = sessions_df[(sessions_df['Område'] == area) & 
+                                        (sessions_df['Year_Month'] == ym)]
+            
+            # Get unique (outlet, day) combinations
+            area_month_data['Day'] = area_month_data['Startad'].dt.day
+            used_outlet_days = area_month_data.groupby(['Uttag', 'Day']).size().reset_index().shape[0]
+            
+            utilization = used_outlet_days / total_outlet_days if total_outlet_days > 0 else 0
+            
+            utilization_data.append({
+                'Område': area,
+                'Year_Month': ym,
+                'Used_Outlet_Days': used_outlet_days,
+                'Total_Outlet_Days': total_outlet_days,
+                'Utilization': utilization
+            })
+    
+    metrics['utilization'] = pd.DataFrame(utilization_data)
+    
+    # Total kWh and sessions
+    metrics['total_kwh'] = sessions_df['Laddat (kWh)'].sum()
+    metrics['total_sessions'] = len(sessions_df)
+    metrics['avg_kwh_per_session'] = metrics['total_kwh'] / metrics['total_sessions'] if metrics['total_sessions'] > 0 else 0
+    
+    return metrics
+
+# Function to create plotly figures
+def create_visualizations(metrics):
+    figures = {}
+    
+    # 1. Bar chart: Number of outlets per area
+    fig_outlets = px.bar(
+        metrics['outlets_per_area'],
+        x='Område',
+        y='Number_of_Outlets',
+        title='Number of Outlets per Area',
+        color='Number_of_Outlets',
+        color_continuous_scale='Blues',
+        labels={'Number_of_Outlets': 'Number of Outlets', 'Område': 'Area'}
+    )
+    fig_outlets.update_layout(xaxis_tickangle=-45)
+    figures['outlets_per_area'] = fig_outlets
+    
+    # 2. Line chart: kWh per month per area
+    fig_kwh = px.line(
+        metrics['kwh_per_month_area'],
+        x='Year_Month',
+        y='Laddat (kWh)',
+        color='Område',
+        title='kWh per Month per Area',
+        labels={'Laddat (kWh)': 'kWh', 'Year_Month': 'Month', 'Område': 'Area'}
+    )
+    fig_kwh.update_layout(xaxis_tickangle=-45)
+    figures['kwh_per_month'] = fig_kwh
+    
+    # 3. Heatmap: Utilization per area per month
+    pivot_util = metrics['utilization'].pivot(
+        index='Område', 
+        columns='Year_Month', 
+        values='Utilization'
+    ).fillna(0)
+    
+    fig_util = px.imshow(
+        pivot_util,
+        labels=dict(x='Month', y='Area', color='Utilization'),
+        x=pivot_util.columns,
+        y=pivot_util.index,
+        color_continuous_scale='Viridis',
+        title='Outlet Utilization Heatmap (Used Outlet Days / Total Outlet Days)'
+    )
+    fig_util.update_layout(xaxis_tickangle=-45)
+    figures['utilization'] = fig_util
+    
+    # 4. Box plot: kWh per outlet per month per area
+    fig_kwh_outlet = px.box(
+        metrics['kwh_outlet_month_area'],
+        x='Område',
+        y='Laddat (kWh)',
+        color='Year_Month',
+        title='kWh per Outlet Distribution by Area and Month',
+        labels={'Laddat (kWh)': 'kWh', 'Område': 'Area', 'Year_Month': 'Month'}
+    )
+    fig_kwh_outlet.update_layout(xaxis_tickangle=-45)
+    figures['kwh_per_outlet'] = fig_kwh_outlet
+    
+    return figures
+
+# Function to create PDF report
+def generate_pdf(metrics, figures):
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=A4, rightMargin=72, leftMargin=72, topMargin=72, bottomMargin=72)
+    styles = getSampleStyleSheet()
+    
+    # Create a list to hold the PDF elements
+    elements = []
+    
+    # Add title
+    title_style = styles["Title"]
+    elements.append(Paragraph("Charging Outlets Analytics Report", title_style))
+    elements.append(Spacer(1, 20))
+    
+    # Add date
+    date_style = styles["Normal"]
+    date_style.alignment = 1  # Center alignment
+    elements.append(Paragraph(f"Report generated on {datetime.now().strftime('%Y-%m-%d %H:%M')}", date_style))
+    elements.append(Spacer(1, 30))
+    
+    # Add summary metrics
+    elements.append(Paragraph("Key Metrics Summary", styles["Heading2"]))
+    elements.append(Spacer(1, 10))
+    
+    # Create a table with key metrics
+    data = [
+        ["Metric", "Value"],
+        ["Total Areas", metrics['area_count']],
+        ["Total kWh Charged", f"{metrics['total_kwh']:.2f}"],
+        ["Total Charging Sessions", metrics['total_sessions']],
+        ["Average kWh per Session", f"{metrics['avg_kwh_per_session']:.2f}"]
+    ]
+    
+    t = Table(data, colWidths=[200, 200])
+    t.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (1, 0), colors.lightblue),
+        ('TEXTCOLOR', (0, 0), (1, 0), colors.whitesmoke),
+        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+    ]))
+    
+    elements.append(t)
+    elements.append(Spacer(1, 30))
+    
+    # Add visualizations
+    for name, fig in figures.items():
+        # Add section title
+        elements.append(Paragraph(fig.layout.title.text, styles["Heading2"]))
+        elements.append(Spacer(1, 10))
+        
+        # Save the Plotly figure to a temporary file and add it to the PDF
+        img_bytes = fig.to_image(format="png", width=700, height=500, scale=1)
+        img_stream = io.BytesIO(img_bytes)
+        img = PILImage.open(img_stream)
+        img_width = 450
+        img_height = int(img_width * img.height / img.width)
+        elements.append(Image(img_stream, width=img_width, height=img_height))
+        elements.append(Spacer(1, 20))
+    
+    # Build the PDF
+    doc.build(elements)
+    buffer.seek(0)
+    return buffer
+
+# Main application logic
+if sessions_file is not None and overview_file is not None:
+    try:
+        # Read the uploaded files
+        sessions_df = pd.read_excel(sessions_file)
+        overview_df = pd.read_excel(overview_file)
+        
+        # Display data loading success message
+        st.sidebar.success("Data loaded successfully!")
+        
+        # Show data filtering options in sidebar
+        st.sidebar.header("Filter Data")
+        
+        # Preprocess data
+        sessions_df, overview_df = preprocess_data(sessions_df, overview_df)
+        
+        # Get unique areas for filtering
+        all_areas = sorted(sessions_df['Område'].unique())
+        
+        # Area selection dropdown
+        selected_areas = st.sidebar.multiselect(
+            "Select Areas",
+            options=all_areas,
+            default=all_areas
+        )
+        
+        # Filter data based on selection
+        if selected_areas:
+            filtered_sessions = sessions_df[sessions_df['Område'].isin(selected_areas)]
+        else:
+            filtered_sessions = sessions_df  # Use all data if nothing selected
+        
+        # Calculate metrics
+        metrics = calculate_metrics(filtered_sessions, overview_df)
+        
+        # Create visualizations
+        figures = create_visualizations(metrics)
+        
+        # Create tabs for different dashboard views
+        tab1, tab2, tab3 = st.tabs(["Key Metrics", "Utilization Analysis", "Energy Consumption"])
+        
+        with tab1:
+            st.header("Key Performance Metrics")
+            
+            # Key metrics in cards
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.markdown(f"""
+                <div class="metric-card">
+                    <div class="metric-value">{metrics['area_count']}</div>
+                    <div class="metric-label">Total Areas</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            with col2:
+                st.markdown(f"""
+                <div class="metric-card">
+                    <div class="metric-value">{metrics['total_sessions']:,}</div>
+                    <div class="metric-label">Total Sessions</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            with col3:
+                st.markdown(f"""
+                <div class="metric-card">
+                    <div class="metric-value">{metrics['total_kwh']:,.2f}</div>
+                    <div class="metric-label">Total kWh</div>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            st.subheader("Number of Outlets per Area")
+            st.plotly_chart(figures['outlets_per_area'], use_container_width=True)
+            
+            st.subheader("Monthly Energy Consumption by Area")
+            st.plotly_chart(figures['kwh_per_month'], use_container_width=True)
+        
+        with tab2:
+            st.header("Utilization Analysis")
+            st.markdown("""
+            This heatmap shows the utilization rate of charging outlets, calculated as:
+            
+            **Utilization = Used Outlet Days / Total Outlet Days**
+            
+            Where Total Outlet Days = Number of Outlets × Days in Month
+            """)
+            
+            st.plotly_chart(figures['utilization'], use_container_width=True)
+            
+            # Display utilization data table
+            st.subheader("Utilization Data Table")
+            st.dataframe(
+                metrics['utilization'][['Område', 'Year_Month', 'Used_Outlet_Days', 'Total_Outlet_Days', 'Utilization']]
+                .sort_values(['Område', 'Year_Month'])
+                .style.format({'Utilization': '{:.2%}'})
+            )
+        
+        with tab3:
+            st.header("Energy Consumption Analysis")
+            
+            st.subheader("kWh per Outlet Distribution")
+            st.plotly_chart(figures['kwh_per_outlet'], use_container_width=True)
+            
+            # Additional insights section
+            st.subheader("Energy Consumption Insights")
+            
+            # Average kWh per session by area
+            avg_kwh_per_session = filtered_sessions.groupby('Område')['Laddat (kWh)'].mean().reset_index()
+            avg_kwh_per_session.columns = ['Område', 'Average kWh per Session']
+            
+            fig_avg_kwh = px.bar(
+                avg_kwh_per_session,
+                x='Område',
+                y='Average kWh per Session',
+                color='Average kWh per Session',
+                color_continuous_scale='Viridis',
+                labels={'Average kWh per Session': 'Avg kWh per Session', 'Område': 'Area'}
+            )
+            fig_avg_kwh.update_layout(xaxis_tickangle=-45)
+            
+            st.plotly_chart(fig_avg_kwh, use_container_width=True)
+        
+        # Generate PDF button
+        st.sidebar.header("Export Report")
+        if st.sidebar.button("Generate PDF Report"):
+            with st.spinner("Generating PDF report..."):
+                pdf_buffer = generate_pdf(metrics, figures)
+                
+                # Create download link
+                b64_pdf = base64.b64encode(pdf_buffer.read()).decode()
+                href = f'<a href="data:application/pdf;base64,{b64_pdf}" download="charging_outlets_report.pdf">Download PDF Report</a>'
+                st.sidebar.markdown(href, unsafe_allow_html=True)
+                st.sidebar.success("PDF generated successfully!")
+    
+    except Exception as e:
+        st.error(f"Error processing data: {e}")
+        st.exception(e)
+else:
+    # Show instructions when no files are uploaded
+    st.info("Please upload the required Excel files to begin the analysis.")
+    
+    # Show example visualizations or instructions
+    st.header("Dashboard Preview")
+    st.markdown("""
+    This dashboard will help you analyze charging outlet performance with:
+    
+    1. **Key Metrics** - Number of outlets per area and energy consumption over time
+    2. **Utilization Analysis** - Heatmap showing outlet usage patterns
+    3. **Energy Consumption** - Detailed breakdowns of energy usage by outlet
+    
+    You can filter by specific areas and generate PDF reports with all visualizations.
+    """)