Update app.py

app.py

@@ -1,150 +1,109 @@
 import streamlit as st
 import pandas as pd
 import plotly.graph_objects as go
-from PIL import Image, ImageDraw, ImageFilter, ImageColor  # Added ImageColor import
-
-# Function to create a 3D-like glowing circular indicator
-def create_glowing_indicator(color):
-    size = 100  # Size of the indicator
-    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
-    draw = ImageDraw.Draw(img)
-    glow_color = tuple(map(lambda x: int(x * 0.7), ImageColor.getrgb(color))) + (100,)
-
-    # Outer glow
-    for i in range(20, 0, -1):
-        draw.ellipse(
-            (i, i, size - i, size - i),
-            fill=glow_color,
-            outline=None
-        )
-        glow_color = tuple(map(lambda x: min(x + 10, 255), glow_color[:3])) + (100,)
-
-    # Main circle
-    draw.ellipse(
-        (20, 20, size - 20, size - 20),
-        fill=color,
-        outline=None
-    )
-    return img
-
-# Function to load data
+
 @st.cache_data
 def load_data():
+    """Load grid data from the dataset."""
     df = pd.read_excel("grid_load_data.xlsx")
-    
-    # Identify 'Time' column
     time_column = next((col for col in df.columns if "time" in col.lower() or "date" in col.lower()), None)
-    if time_column:
-        df["Time"] = pd.to_datetime(df[time_column])
-    else:
-        raise KeyError("Time column is missing in the dataset.")
-    
-    # Identify 'Grid Load (kW)' column
     load_column = next((col for col in df.columns if "grid" in col.lower() and "load" in col.lower()), None)
-    if load_column:
+
+    if time_column and load_column:
+        df["Time"] = pd.to_datetime(df[time_column])
         df["Grid Load (kW)"] = df[load_column]
     else:
-        raise KeyError("Grid Load (kW) column is missing in the dataset.")
-    
+        raise KeyError("Dataset must contain 'Time' and 'Grid Load (kW)' columns.")
     return df
 
-# Function to calculate available EV charging slots
-def calculate_ev_slots(grid_load, threshold=3000, ev_capacity=50):
-    if grid_load < threshold:
-        return (threshold - grid_load) // ev_capacity
-    return 0
-
-# Function to calculate EVs needed to stabilize the grid
-def calculate_evs_needed(grid_load, threshold=3000, ev_capacity=50):
-    if grid_load > threshold:
-        return (grid_load - threshold) // ev_capacity
-    return 0
-
-# Main function
 def main():
-    st.set_page_config(layout="wide")  # Optimize for a wide screen
-    
+    # Page Layout
+    st.set_page_config(layout="wide")
+
     # Title
-    st.title("Grid Load and EV Management Dashboard")
-    
-    # Alarm Indicators
-    st.sidebar.write("**Alarm Indicators**")
-    st.sidebar.write("Green: Normal Load")
-    st.sidebar.write("Red: Overload")
-    
+    st.title("Interactive Grid and EV Management Dashboard")
+
     # Load dataset
     try:
         df = load_data()
     except KeyError as e:
         st.error(f"Error loading data: {e}")
         return
-    
-    # Grid Load Slider
-    grid_load = st.slider("Select Grid Load (kW)", 0, 5000, 2000, step=50)
-    
-    # Alarm Status
-    is_overloaded = grid_load > 3000
-    alarm_color = "red" if is_overloaded else "green"
-    left_alarm = create_glowing_indicator(alarm_color)
-    right_alarm = create_glowing_indicator(alarm_color)
-    
-    # Layout with alarms and meter
-    col1, col2, col3 = st.columns([1, 2, 1])
-    
-    with col1:
-        st.image(left_alarm, caption="Alarm", use_column_width=True)
-    
-    with col2:
-        # Meter Visualization for Grid Load
+
+    # Sidebar Input Mode
+    st.sidebar.header("Input Mode")
+    input_mode = st.sidebar.radio("Choose Input Mode", ["Automatic Fetch", "Manual Input"])
+    current_grid_load = 0
+
+    if input_mode == "Automatic Fetch":
+        current_time = st.sidebar.selectbox("Select Time", df["Time"].dt.strftime("%Y-%m-%d %H:%M:%S"))
+        current_time = pd.to_datetime(current_time)
+        current_grid_load = df[df["Time"] == current_time]["Grid Load (kW)"].values[0]
+    else:
+        current_grid_load = st.sidebar.slider("Select Grid Load (kW)", 0, 5000, 2500, step=50)
+
+    # Layout: Grid Details (Left) | EV Details (Right)
+    col1, col2 = st.columns([1, 1])
+
+    with col1:  # Grid Details
+        st.subheader("Grid Details")
+
+        # Status Indicator
+        grid_status = "Normal" if current_grid_load <= 3000 else "Overloaded"
+        status_color = "green" if grid_status == "Normal" else "red"
+
+        st.markdown(f"**Status**: <span style='color:{status_color}; font-size:20px;'>{grid_status}</span>", unsafe_allow_html=True)
+
+        # Gauge for Grid Load
         fig = go.Figure(go.Indicator(
             mode="gauge+number",
-            value=grid_load,
+            value=current_grid_load,
             title={'text': "Grid Load (kW)"},
             gauge={
                 'axis': {'range': [0, 5000]},
-                'bar': {'color': "blue"},
+                'bar': {'color': status_color},
                 'steps': [
-                    {'range': [0, 3000], 'color': "green"},
+                    {'range': [0, 3000], 'color': "lightgreen"},
                     {'range': [3000, 3200], 'color': "orange"},
-                    {'range': [3200, 5000], 'color': "red"}]
+                    {'range': [3200, 5000], 'color': "red"}
+                ]
             }
         ))
         st.plotly_chart(fig, use_container_width=True)
-    
-    with col3:
-        st.image(right_alarm, caption="Alarm", use_column_width=True)
-    
-    # Interactive ON/OFF for V2G Connectivity
-    v2g_enabled = st.sidebar.checkbox("Enable V2G Connectivity")
-    
-    if v2g_enabled:
-        st.sidebar.write("V2G is enabled.")
-    else:
-        st.sidebar.write("V2G is disabled.")
-    
-    # Status Messages
-    if grid_load < 3000:
-        st.success("Grid is stable. Slots available for EV charging.")
-        ev_slots = calculate_ev_slots(grid_load)
-        st.write(f"Available EV charging slots: {ev_slots}")
-    elif 3000 <= grid_load < 3200:
-        st.warning("Grid is under load. Monitoring EV connectivity.")
-        if v2g_enabled:
-            st.write("EVs can support the grid if needed.")
+
+        # Suggestions
+        if current_grid_load < 3000:
+            st.success("Grid is stable. No action needed.")
+        elif 3000 <= current_grid_load < 3200:
+            st.warning("Grid is under moderate load. Monitor EV connectivity.")
+        else:
+            st.error("Grid is overloaded. Immediate action required!")
+
+    with col2:  # EV Details
+        st.subheader("EV Details")
+
+        ev_capacity = 50  # Each EV contributes or consumes 50 kW
+        if current_grid_load < 3000:
+            # Calculate EV charging slots
+            ev_slots = (3000 - current_grid_load) // ev_capacity
+            st.write(f"Available EV charging slots: **{ev_slots}**")
+        elif current_grid_load > 3200:
+            # Calculate EVs needed to stabilize grid
+            evs_needed = (current_grid_load - 3000) // ev_capacity
+            st.write(f"Number of EVs needed to stabilize the grid: **{evs_needed}**")
+
+            # Button to simulate EV connection
+            num_evs = st.slider("Number of EVs to connect", 0, int(evs_needed), step=1)
+            if st.button("Connect EVs to Grid"):
+                reduced_load = current_grid_load - (num_evs * ev_capacity)
+                st.success(f"EVs connected! New Grid Load: {reduced_load} kW")
+
+    # Alarm Lights
+    st.sidebar.header("Alarms")
+    if current_grid_load > 3000:
+        st.sidebar.markdown("**Alarm Status**: <span style='color:red;'>Overloaded</span>", unsafe_allow_html=True)
     else:
-        st.error("Grid is overloaded. Connect EVs to stabilize.")
-        evs_needed = calculate_evs_needed(grid_load)
-        st.write(f"EVs needed to stabilize the grid: {evs_needed}")
-        
-        # Connect EVs Bar
-        num_evs = st.number_input("Number of EVs to connect to grid", min_value=0, max_value=evs_needed, step=1)
-        if st.button("Connect EVs"):
-            reduced_load = grid_load - (num_evs * 50)
-            if reduced_load < 3000:
-                reduced_load = 3000  # Set to minimum threshold
-            st.success(f"Grid stabilized. Updated load: {reduced_load} kW")
-            st.write(f"Number of EVs connected: {num_evs}")
-
-# Run app
+        st.sidebar.markdown("**Alarm Status**: <span style='color:green;'>Normal</span>", unsafe_allow_html=True)
+
 if __name__ == "__main__":
-    main()
+    main()