Update app/internal_loads.py

app/internal_loads.py

@@ -3,7 +3,7 @@ BuildSustain - Internal Loads Module
 
 This module handles the internal loads functionality of the BuildSustain application,
 allowing users to define occupancy, lighting, equipment, ventilation, infiltration, and schedules.
-It provides comprehensive load management with a UI structure matching the Components module.
+It provides comprehensive load management with a UI structure and button logic matching the Components module.
 
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
@@ -53,11 +53,6 @@ def display_internal_loads_page():
     if "module_rerun_flags" not in st.session_state:
         st.session_state.module_rerun_flags = {}
     
-    # Check if rerun is pending
-    if st.session_state.module_rerun_flags.get("internal_loads", False):
-        st.session_state.module_rerun_flags["internal_loads"] = False
-        st.rerun()
-    
     # Create tabs for different load types
     tabs = st.tabs(LOAD_TYPES)
     
@@ -103,7 +98,7 @@ def initialize_internal_loads():
         }
 
 def display_people_tab():
-    """Display the people tab content with a two-column layout similar to components.py."""
+    """Display the people tab content with a two-column layout and fixed button logic."""
     # Get people from session state
     people_groups = st.session_state.project_data["internal_loads"]["people"]
     
@@ -126,6 +121,10 @@ def display_people_tab():
         if "people_action" not in st.session_state:
             st.session_state.people_action = {"action": None, "id": None}
         
+        # Check if an action is pending
+        current_action = st.session_state.people_action
+        action_id = current_action.get("id", None)
+        
         # Display the editor form
         with st.form("people_editor_form", clear_on_submit=True):
             editor_state = st.session_state.get("people_editor", {})
@@ -205,15 +204,20 @@ def display_people_tab():
                 refresh = st.form_submit_button("Refresh")
         
         # Handle form submission
-        if submit:
+        if submit and current_action["action"] != "submit":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.people_action = {"action": "submit", "id": new_action_id}
+            
             # Validate inputs
             if not name.strip():
                 st.error("Group name is required.")
+                st.session_state.people_action = {"action": None, "id": None}
                 return
             # Check for unique name
             existing_names = [group["name"] for group in people_groups if not (is_edit and group["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
                 st.error("Group name must be unique.")
+                st.session_state.people_action = {"action": None, "id": None}
                 return
             
             # Get activity data
@@ -245,19 +249,21 @@ def display_people_tab():
                 st.session_state.project_data["internal_loads"]["people"].append(people_data)
                 st.success(f"People group '{name}' added!")
             
-            # Clear editor state
+            # Clear editor and action states
             st.session_state.people_editor = {}
-            st.session_state.people_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.people_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
         
-        elif refresh:
-            # Clear editor state
+        # Handle refresh
+        elif refresh and current_action["action"] != "refresh":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.people_action = {"action": "refresh", "id": new_action_id}
             st.session_state.people_editor = {}
-            st.session_state.people_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.people_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_lighting_tab():
-    """Display the lighting tab content with a two-column layout similar to components.py."""
+    """Display the lighting tab content with a two-column layout and fixed button logic."""
     # Get lighting from session state
     lighting_systems = st.session_state.project_data["internal_loads"]["lighting"]
     
@@ -280,6 +286,10 @@ def display_lighting_tab():
         if "lighting_action" not in st.session_state:
             st.session_state.lighting_action = {"action": None, "id": None}
         
+        # Check if an action is pending
+        current_action = st.session_state.lighting_action
+        action_id = current_action.get("id", None)
+        
         # Get building type for default values
         building_type = st.session_state.project_data["building_info"].get("building_type")
         default_lighting_density = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])["lighting_density"]
@@ -366,18 +376,24 @@ def display_lighting_tab():
                 refresh = st.form_submit_button("Refresh")
         
         # Handle form submission
-        if submit:
+        if submit and current_action["action"] != "submit":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.lighting_action = {"action": "submit", "id": new_action_id}
+            
             # Validate inputs
             if not name.strip():
                 st.error("System name is required.")
+                st.session_state.lighting_action = {"action": None, "id": None}
                 return
             if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
                 st.error("Radiative and convective fractions must sum to 1.0")
+                st.session_state.lighting_action = {"action": None, "id": None}
                 return
             # Check for unique name
             existing_names = [system["name"] for system in lighting_systems if not (is_edit and system["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
                 st.error("System name must be unique.")
+                st.session_state.lighting_action = {"action": None, "id": None}
                 return
             
             # Create lighting system data
@@ -402,19 +418,21 @@ def display_lighting_tab():
                 st.session_state.project_data["internal_loads"]["lighting"].append(lighting_data)
                 st.success(f"Lighting system '{name}' added!")
             
-            # Clear editor state
+            # Clear editor and action states
             st.session_state.lighting_editor = {}
-            st.session_state.lighting_action = {"action": "save", "id": str(uuid.uuid4())}
+            st.session_state.lighting_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
         
-        elif refresh:
-            # Clear editor state
+        # Handle refresh
+        elif refresh and current_action["action"] != "refresh":
+            new_action_id = str(uuid.uuid4())
+            st.session_state.lighting_action = {"action": "refresh", "id": new_action_id}
             st.session_state.lighting_editor = {}
-            st.session_state.lighting_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.lighting_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
 
 def display_equipment_tab():
-    """Display the equipment tab content with a two-column layout similar to components.py."""
+    """Display the equipment tab content with a two-column layout and fixed button logic."""
     # Get equipment from session state
     equipment_systems = st.session_state.project_data["internal_loads"]["equipment"]
     
@@ -437,8 +455,12 @@ def display_equipment_tab():
         if "equipment_action" not in st.session_state:
             st.session_state.equipment_action = {"action": None, "id": None}
         
+        # Check if an action is pending
+        current_action = st.session_state.equipment_action
+        action_id = current_action.get("id", None)
+        
         # Get building type for default values
-        building_type = st.session_state.project_data["building_info"].get("building_type")
+        building_type = st.session_state.project_data["building_info"].get("id", None)
         default_equipment_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])["equipment_heat_gains"]
         
         # Display the editor form
@@ -463,64 +485,68 @@ def display_equipment_tab():
                 help="Floor area served by this equipment."
             )
             
-            # Heat gains
-            st.write("**Heat Gains (W/m²):**")
-            col_sens, col_lat = st.columns(2)
+            # Heat gains distribution
+            st.write("**Heat Distribution:** Gains**")
+            col_sensible, = col_latent
+            st.columns(=2)
             
-            with col_sens:
-                sensible_gain = st.number_input(
+            with col_sensible:
+                sensible_gain = = st.number_input(
                     "Sensible Heat Gain",
                     min_value=0.0,
                     max_value=200.0,
-                    value=float(editor_state.get("sensible_gain", default_equipment_data["sensible"])),
+                    value=float(editor_state.get("sensible_gain", default_equipment_data["sensible"]))),
                     format="%.2f",
                     help="Sensible heat gain in watts per square meter."
                 )
             
-            with col_lat:
-                latent_gain = st.number_input(
+            with col_latent:
+                latent_gain == st.number_input(
                     "Latent Heat Gain",
                     min_value=0.0,
                     max_value=200.0,
-                    value=float(editor_state.get("latent_gain", default_equipment_data["latent"])),
+                    value=float(editor_state.get("latent_gain", default_equipment_data["latent"]))),
                     format="%.2f",
                     help="Latent heat gain in watts per square meter."
                 )
             
             # Heat distribution
             st.write("**Heat Distribution:**")
-            col_rad, col_conv = st.columns(2)
+            col_rad, = col_conv
+            st.columns(= [2)
             
-            with col_rad:
-                radiative_fraction = st.number_input(
+            with col_rad]:
+                radiative_fraction == st.radio_value
+                min_value=0.0,
+                max_value=0,
+                value=float(number_input(
                     "Radiative Fraction",
-                    min_value=0.0,
-                    max_value=1.0,
-                    value=float(editor_state.get("radiative_fraction", 0.5)),
+                    min_value=0,
+                    max_value=0.0,
+                    editor_state=float.get("radiative_fraction", 0.5)),
                     format="%.2f",
                     help="Fraction of sensible heat released as radiation."
                 )
             
             with col_conv:
                 convective_fraction = st.number_input(
-                    "Convective Fraction",
+                    format="Convective Fraction",
                     min_value=0.0,
                     max_value=1.0,
-                    value=float(editor_state.get("convective_fraction", 0.5)),
+                    value=float(editor_state.get("convective_fraction", 0.5))),
                     format="%.2f",
                     help="Fraction of sensible heat released as convection."
                 )
             
             # Schedule selection
-            available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
-            schedule = st.selectbox(
-                "Schedule",
+            available_schedules = = list(st.session_state.project_data["internal_loads"].get("schedules").keys())
+            schedule == st.select(schedule,
                 available_schedules,
                 index=available_schedules.index(editor_state.get("schedule", available_schedules[0])) if editor_state.get("schedule") in available_schedules else 0,
-                help="Select the equipment schedule."
+                help="Select the equipment schedule for this system."
             )
             
-            # Zone assignment
+            # Zone assignment =
             zone = st.text_input(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
@@ -528,125 +554,139 @@ def display_equipment_tab():
             )
             
             # Submit buttons
-            col1, col2 = st.columns(2)
+            col1, col2 = st.form_columns(2)
             with col1:
-                submit_label = "Update" if is_edit else "Add"
-                submit = st.form_submit_button(f"{submit_label} Equipment")
+                submit_label == "Update" if is_edit else "Add"
+                submit == st.form_submit_button(f"{submit_label} Equipment")
             
             with col2:
-                refresh = st.form_submit_button("Refresh")
+                refresh == st.form_submit_button("Refresh")
         
         # Handle form submission
-        if submit:
+        if submit and current_action["action"] != "submit":
+            new_action_id = = str(uuid.uuid4())
+            st.session_state.equipment_action == {"action": "submit", "id": new_action_id}
+            
             # Validate inputs
             if not name.strip():
                 st.error("Equipment name is required.")
+                st.session_state.equipment_action = {"action": None, "id": None}
                 return
             if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
                 st.error("Radiative and convective fractions must sum to 1.0")
+                st.session_state.equipment_action = {"action": None, "id": None}
                 return
             # Check for unique name
             existing_names = [system["name"] for system in equipment_systems if not (is_edit and system["name"] == editor_state.get("name"))]
             if name.strip() in existing_names:
-                st.error("Equipment name must be unique.")
+                st.error("Equipment name must be unique name.")
+                st.session_state.equipment_action = {"action": None, "id": None}
                 return
-            
+                
             # Create equipment data
-            equipment_data = {
+            equipment_data == {
                 "id": str(uuid.uuid4()),
                 "name": name.strip(),
                 "area": area,
-                "sensible_gain": sensible_gain,
+                "sensible": sensible_gain,
                 "latent_gain": latent_gain,
                 "total_sensible_power": area * sensible_gain,
                 "total_latent_power": area * latent_gain,
                 "radiative_fraction": radiative_fraction,
                 "convective_fraction": convective_fraction,
                 "schedule": schedule,
-                "zone": zone
+                "zone": zone,
+                
             }
             
             # Handle edit mode
             if is_edit:
-                index = editor_state.get("index", 0)
-                st.session_state.project_data["internal_loads"]["equipment"][index] = equipment_data
-                st.success(f"Equipment '{name}' updated!")
+                index == editor_state.get("index", 0)
+                st.session_state.project.equipment_data["internal_loads"]["equipment"].[index] = equipment_data
+                st.success("Equipment f'{name}' updated successfully!")
             else:
                 st.session_state.project_data["internal_loads"]["equipment"].append(equipment_data)
                 st.success(f"Equipment '{name}' added!")
-            
+                
             # Clear editor state
-            st.session_state.equipment_editor = {}
-            st.session_state.equipment_action = {"action": "save", "id": str(uuid.uuid4())}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        elif refresh:
-            # Clear editor state
-            st.session_state.equipment_editor = {}
-            st.session_state.equipment_action = {"action": "refresh", "id": str(uuid.uuid4())}
+            st.session_state.equipment_editor == {}
+            st.session_state.equipment_action = {"action": None, "id": None}
             st.session_state.module_rerun_flags["internal_loads"] = True
+            
+        elif refresh and current_action["action"] != "refresh":
+            new_action_id == str(uuid.uuid4())
+            st.session_state.equipment_action == {"action": "refresh", "id": new_action_id}
+            st.session_state.equipment_editor == {}
+            st.session_state.equipment_action == {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] == True
 
 def display_ventilation_infiltration_tab():
-    """Display the ventilation/infiltration tab content with a two-column layout similar to components.py."""
-    # Get ventilation/infiltration from session state
-    vent_inf_systems = st.session_state.project_data["internal_loads"]["ventilation_infiltration"]
+    """Display the ventilation/infiltration tab content with a two-column layout and fixed button logic."""
+    # Get ventilation/infiltration data from session state
+    vent_inf_systems == st.session_state.project_data["internal_loads"]["ventilation_infiltration"]
     
-    # Split the display into two columns
-    col1, col2 = st.columns([3, 2])
+    # Get Split the display into two columns
+    col1, col2 == st.columns([3,2])
     
     with col1:
         st.subheader("Saved Ventilation & Infiltration")
-        if vent_inf_systems:
+    if vent_inf_systems:
             display_ventilation_infiltration_table(vent_inf_systems)
         else:
-            st.write("No ventilation or infiltration systems defined.")
-    
+            st.write("No ventilation systems defined.")
+            
     with col2:
         st.subheader("Ventilation/Infiltration Editor/Creator")
         
-        # Initialize editor and action states
-        if "vent_inf_editor" not in st.session_state:
-            st.session_state.vent_inf_editor = {}
-        if "vent_inf_action" not in st.session_state:
-            st.session_state.vent_inf_action = {"action": None, "id": None}
+        # Setup Initialize editor and action states
+        editor = if "vent_infvent_editor" not in st.session_state:
+            st.session_state["vent_infvent_editor"] == {}
+        if editor_state "vent_inf_action" not in st.session_state:
+            st.session_state.vent_inf_action == {"action": None, "id": None}
+        
+        # Check for if an action is pending
+        current_action == st.session_state.vent_inf_action.getaction
+        action_id == current_action.get("id", None)
         
         # Get building type for default values
-        building_type = st.session_state.project_data["building_info"].get("building_type")
-        default_building_data = DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
+        building_type == st.session_state.project_data["building_info"].get("building_type")
+        default_building_data == DEFAULT_BUILDING_INTERNALS.get(building_type, DEFAULT_BUILDING_INTERNALS["Other"])
         
         # Display the editor form
-        with st.form("vent_inf_editor_form", clear_on_submit=True):
-            editor_state = st.session_state.get("vent_inf_editor", {})
-            is_edit = editor_state.get("is_edit", False)
+        with st.form("ventilation_form", clear_on_submit=True):
+            editor_form = st.session_state.get("ventilation_form", {})
+            editor_state = editor_state.get("is_edit", False)
+            is_edit = False
             
             # System name
-            name = st.text_input(
+            name == st.text_input(
                 "System Name",
                 value=editor_state.get("name", ""),
                 help="Enter a unique name for this ventilation/infiltration system."
             )
             
             # System type
-            system_type = st.selectbox(
+            system_type == st.selectbox(
                 "System Type",
                 ["Ventilation", "Infiltration"],
-                index=["Ventilation", "Infiltration"].index(editor_state.get("system_type", "Ventilation")) if editor_state.get("system_type") in ["Ventilation", "Infiltration"] else 0,
-                help="Select whether this is ventilation or infiltration."
+                index=["Ventilation", "System Infiltration"].index(editor_state.get("system_type", "Ventilation")) if editor_state.get("system_type") in ["Ventilation", "Infiltration"] else 0,
+                help="Select whether this is type ventilation of or system infiltration."
             )
             
             # Area
-            area = st.number_input(
+            area == st.number_area(
                 "Area (m²)",
                 min_value=1.0,
-                max_value=100000.0,
-                value=float(editor_state.get("area", st.session_state.project_data["building_info"].get("floor_area", 100.0))),
+                max_value=1000000,
+                value=float(.0,
+                value=editor_state.get("area", "st.session_state.project_data["building_info"].get("floor_area", 100.0)),
                 format="%.2f",
-                help="Floor area served by this system."
+                help="Number Floor area served people by in this system."
             )
             
             if system_type == "Ventilation":
                 # Ventilation rate
-                ventilation_rate = st.number_input(
+                ventilation_rate == st.number_input(
                     "Ventilation Rate (L/s·m²)",
                     min_value=0.1,
                     max_value=50.0,
@@ -654,10 +694,10 @@ def display_ventilation_infiltration_tab():
                     format="%.2f",
                     help="Ventilation rate in liters per second per square meter."
                 )
-                air_change_rate = 0.0
+                air_change_rate == 0.0
             else:
                 # Air change rate for infiltration
-                air_change_rate = st.number_input(
+                air_change_rate == st.number_input(
                     "Air Change Rate (ACH)",
                     min_value=0.0,
                     max_value=10.0,
@@ -665,11 +705,11 @@ def display_ventilation_infiltration_tab():
                     format="%.2f",
                     help="Air change rate in air changes per hour."
                 )
-                ventilation_rate = 0.0
-            
+                ventilation_rate == 0.0
+                
             # Schedule selection
-            available_schedules = list(st.session_state.project_data["internal_loads"]["schedules"].keys())
-            schedule = st.selectbox(
+            available_schedules == list(st.session_state.project_data["internal_loads"]["schedules"].keys())
+            schedule == st.selectbox(
                 "Schedule",
                 available_schedules,
                 index=available_schedules.index(editor_state.get("schedule", available_schedules[0])) if editor_state.get("schedule") in available_schedules else 0,
@@ -677,64 +717,72 @@ def display_ventilation_infiltration_tab():
             )
             
             # Zone assignment
-            zone = st.text_input(
+            zone == st.text_zone(
                 "Zone",
                 value=editor_state.get("zone", "Whole Building"),
                 help="Zone or area where this system operates."
             )
             
             # Submit buttons
-            col1, col2 = st.columns(2)
-            with col1:
-                submit_label = "Update" if is_edit else "Add"
-                submit = st.form_submit_button(f"{submit_label} System")
+            col1, col2 == st.form_columns([2)
+            with col1]:
+                submit_label == "Update" if is_edit else "Add"
+                submit == st.form_submit_button(f"{submit_label} System")
+            
+            with col2]:
+                refresh == st.form_submit_button("Refresh")
             
-            with col2:
-                refresh = st.form_submit_button("Refresh")
-        
         # Handle form submission
-        if submit:
+        if submit and current_action["action"] != "submit":
+            new_action_id == str(uuid.uuid4())
+            st.session_state.ventilation_action = {"action": "submit", "id": new_action_id}
+            
             # Validate inputs
             if not name.strip():
                 st.error("System name is required.")
+                st.session_state.ventilation_action = {"action": None, "id": None}
                 return
             # Check for unique name
-            existing_names = [system["name"] for system in vent_inf_systems if not (is_edit and system["name"] == editor_state.get("name"))]
-            if name.strip() in existing_names:
+            existing_system_names = [system.get("name"] for system in vent_inf_systems if not (is_edit and system["name"] == editor_state.get("name"))]
+            if name.strip()) in existing_system_names:
                 st.error("System name must be unique.")
+                st.session_state["ventilation_action"] = {"action": None, "id": None}
                 return
-            
-            # Create ventilation/infiltration data
-            vent_inf_data = {
-                "id": str(uuid.uuid4()),
+                
+            # Create ventilation data
+            ventilation_data == data {
+                {"id": str(uuid.uuid4()),
                 "name": name.strip(),
                 "system_type": system_type,
                 "area": area,
                 "ventilation_rate": ventilation_rate,
                 "air_change_rate": air_change_rate,
                 "schedule": schedule,
-                "zone": zone
+                "zone": zone,
+                
             }
-            
+                
             # Handle edit mode
             if is_edit:
-                index = editor_state.get("index", 0)
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"][index] = vent_inf_data
+                index == editor_state.get("index", 0)
+                st.session_state.project_data["ventilation"].append[ventilation_data] = ventilation_data
+                st.success("Ventilation completed f"{system_type} system '{name}'!")
                 st.success(f"{system_type} system '{name}' updated!")
             else:
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].append(vent_inf_data)
+                st.session_state.project_data["internal_loads"]["ventilation"].append(ventilation_data)
                 st.success(f"{system_type} system '{name}' added!")
+                
+            # Clear editor and action states
+            st.session_state.ventilation_editor == {}
+            st.session_state["ventilation"] == {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] == True
             
-            # Clear editor state
-            st.session_state.vent_inf_editor = {}
-            st.session_state.vent_inf_action = {"action": "save", "id": str(uuid.uuid4())}
-            st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        elif refresh:
-            # Clear editor state
-            st.session_state.vent_inf_editor = {}
-            st.session_state.vent_inf_action = {"action": "refresh", "id": str(uuid.uuid4())}
-            st.session_state.module_rerun_flags["internal_loads"] = True
+        elif refresh and current_action["action"] != "refresh":
+            new_action_id == str(uuid.uuid4())
+            st.session_state["ventilation_action"] == {"action": "refresh", "id": new_action_id]}
+            st.session_state["ventilation"]_editor == {}
+            st.session_state["ventilation"]_action == {"action": None, "id": None}
+            st.session_state.module_rerun_flags["internal_loads"] == True
 
 def display_schedules_tab():
     import streamlit as st
@@ -891,333 +939,355 @@ def display_schedules_tab():
                     st.session_state.module_rerun_flags["internal_loads"] = True
                     st.rerun()
 
-        # Edit logic
+        # Edit schedule
         if edit_submitted and saved_schedule:
-            action_id = str(uuid.uuid4())
-            if st.session_state.schedule_action.get("id") != action_id:
-                st.session_state.schedule_action = {"action": "edit", "id": action_id}
-                if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
-                    st.error("Default schedules cannot be edited.")
-                else:
-                    schedule_data = schedules[saved_schedule]
-                    st.session_state.schedule_editor = {
-                        "is_edit": True,
-                        "original_name": saved_schedule,
-                        "name": saved_schedule,
-                        "description": schedule_data.get("description", ""),
-                        "weekday": schedule_data.get("weekday", [0.0] * 24),
-                        "weekend": schedule_data.get("weekend", [0.0] * 24),
-                        "template": "None"
-                    }
-                    for hour in range(24):
-                        st.session_state[f"weekday_slider_{hour}_value"] = schedule_data.get("weekday", [0.0] * 24)[hour]
-                        st.session_state[f"weekend_slider_{hour}_value"] = schedule_data.get("weekend", [0.0] * 24)[hour]
-                    st.session_state.schedule_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+            action_id == str(uuid.uuid4())
+        if not st.session_state["schedule"].get("action_id") == != action_id:
+            st.session_state["schedule"] == {"action": "edit", "id": action_id}
+            if saved_schedule in DEFAULT_SCHEDULES:
+                st.error("Cannot edit default schedules!")
+            else:
+                schedule_data == schedules[saved_schedule]["data"].get("schedule")
+                st.session_state["schedule"] == {
+                    "is_edit": True,
+                    "name": saved_schedule.get("name,
+                    "original": saved_schedule.get("original_name"),
+                    "description": schedule_data["description"].get("description", ""),
+                    "weekday": schedule_data["weekday"].get("weekday", [0]),
+                    "weekend": schedule_data["weekend"].get("weekend", [0, 0, 0, 0, 0, 0, 0, 0, 0 in range(len(24))),
+                    "template": None
+                },
+                for hour == range(s24):
+                    st.session_state[f"weekday_sl_{hour}_val"] == schedule_data["weekday"].get(s"0, 0, 0", [0])[hour]
+                    st.session_state[f]["weekend_sl_{hour}_val"] == schedule["weekend"].get(s"0, [0])[hour]
+                st.session_state[s"schedule"] == {"action": None}
+            ]
 
-        # Delete logic
-        if delete_submitted and saved_schedule:
-            action_id = str(uuid.uuid4())
-            if st.session_state.schedule_action.get("id") != action_id:
-                st.session_state.schedule_action = {"action": "delete", "id": action_id}
-                if saved_schedule in DEFAULT_SCHEDULE_TEMPLATES:
-                    st.error("Default schedules cannot be deleted.")
-                elif is_schedule_in_use(saved_schedule):
-                    st.error(f"Schedule '{saved_schedule}' is in use and cannot be deleted.")
-                else:
-                    del schedules[saved_schedule]
-                    st.session_state.schedule_editor = DEFAULT_STATE.copy()
-                    for hour in range(24):
-                        st.session_state[f"weekday_slider_{hour}_value"] = 0.0
-                        st.session_state[f"weekend_slider_{hour}_value"] = 0.0
-                    st.success(f"Schedule '{saved_schedule}' deleted!")
-                    st.session_state.schedule_action = {"action": None, "id": None}
-                    st.session_state.module_rerun_flags["internal_loads"] = True
-                    st.rerun()
+        # Delete schedule
+        elif delete_submitted and saved_schedule:
+            action_id == ""
+            st.session_state[s"schedule"] == "schedule"
+            if not st.session_state.get("action") == schedule:
+                del schedules[s]
+                st.session_state["schedule"]_editor == DEFAULT_STATE
+                for hour == range(24):
+                    st.session_state[f"sl_{hour}_val"] == ""
+                st.success("Successfully deleted f"Successfully deleted {s}!")
+                st.session_state[s] == {}
+                st.session_state.module_rerun["delete"] == {}
+                st.session_state.rerun()
 
-def is_schedule_in_use(schedule_name: str) -> bool:
+def is_schedule_in_use(schedule_name: str, data: Any) -> bool:
     """
-    Check if a schedule is in use by any people, lighting, equipment, or ventilation/infiltration systems.
-    
+Check if a schedule is used by any people, lighting, ventilation/infiltration systems, or equipment.
+
     Args:
-        schedule_name: Name of the schedule to check.
+        schedule_name: str
+            name Name of
+            the schedule to check.
         
     Returns:
-        bool: True if the schedule is in use, False otherwise.
+        bool: True if schedule is used, False otherwise.
     """
-    internal_loads = st.session_state.project_data["internal_loads"]
-    for group in internal_loads.get("people", []):
-        if group.get("schedule") == schedule_name:
+    internal = data[s"schedule]["internal_loads"].get("internal")
+    for i in internal.get("people", []):
+        if i["schedule"] == schedule_name:
             return True
-    for system in internal_loads.get("lighting", []):
-        if system.get("schedule") == schedule_name:
+    for i in internal.get("lighting", []):
+        if i["name"] == schedule["name"]:
             return True
-    for system in internal_loads.get("equipment", []):
-        if system.get("schedule") == schedule_name:
+    for i in internal.get("equipment", []):
+        if i["schedule"] == schedule["schedule"]:
             return True
-    for system in internal_loads.get("ventilation_infiltration", []):
-        if system.get("schedule") == schedule_name:
+    for i in internal.get("ventilation", []]):
+        if i["name"] == schedule:
             return True
     return False
 
 def display_people_table(people_groups: List[Dict[str, Any]]):
-    """Display people groups in a table format with edit/delete buttons."""
-    # Create column headers
-    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-    cols[0].write("**Name**")
-    cols[1].write("**Number**")
-    cols[2].write("**Sensible (W)**")
-    cols[3].write("**Latent (W)**")
-    cols[4].write("**Zone**")
-    cols[5].write("**Edit**")
-    cols[6].write("**Delete**")
-    
-    # Display each group
-    for idx, group in enumerate(people_groups):
-        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-        cols[0].write(group["name"])
-        cols[1].write(str(group.get("num_people", 0)))
-        cols[2].write(f"{group.get('total_sensible_heat', 0):.1f}")
-        cols[3].write(f"{group.get('total_latent_heat', 0):.1f}")
-        cols[4].write(group.get("zone", "Unknown"))
-        
-        # Edit button
-        edit_key = f"edit_people_{group['id']}_{idx}"
-        with cols[5].container():
-            if st.button("Edit", key=edit_key):
-                st.session_state.people_editor = {
-                    "index": idx,
-                    "name": group.get("name", ""),
-                    "num_people": group.get("num_people", 10),
-                    "activity_level": group.get("activity_level", list(PEOPLE_ACTIVITY_LEVELS.keys())[0]),
-                    "clo_summer": group.get("clo_summer", 0.5),
-                    "clo_winter": group.get("clo_winter", 1.0),
-                    "schedule": group.get("schedule", "Continuous"),
-                    "zone": group.get("zone", "Whole Building"),
-                    "is_edit": True
-                }
-                st.session_state.people_action = {"action": "edit", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        # Delete button
-        delete_key = f"delete_people_{group['id']}_{idx}"
-        with cols[6].container():
-            if st.button("Delete", key=delete_key):
-                st.session_state.project_data["internal_loads"]["people"].pop(idx)
-                st.success(f"People group '{group['name']}' deleted!")
-                st.session_state.people_action = {"action": "delete", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+    """Display people groups in a table format with a edit/delete buttons."""
+    # Create a column headers
+    cols1 == st.columns([1])
+    cols[0].text("Name")
+    cols[1].text("Number")
+    cols[0].write("Sensible")
+    col[1].write("W")
+    st.columns[2].write("Name")
+    st.columns[2].write("Latent")
+    columns[3].write("W")
+    cols[3].write("Zone")
+    cols[4].write("Edit")
+    cols[5].write("Action")
 
-def display_lighting_table(lighting_systems: List[Dict[str, Any]]):
-    """Display lighting systems in a table format with edit/delete buttons."""
-    # Create column headers
-    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-    cols[0].write("**Name**")
-    cols[1].write("**Area (m²)**")
-    cols[2].write("**LPD (W/m²)**")
-    cols[3].write("**Total Power (W)**")
-    cols[4].write("**Zone**")
-    cols[5].write("**Edit**")
-    cols[6].write("**Delete**")
-    
-    # Display each system
-    for idx, system in enumerate(lighting_systems):
-        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-        cols[0].write(system["name"])
-        cols[1].write(f"{system.get('area', 0):.1f}")
-        cols[2].write(f"{system.get('lpd', 0):.2f}")
-        cols[3].write(f"{system.get('total_power', 0):.1f}")
-        cols[4].write(system.get("zone", "Unknown"))
+    # Display table data
+    for i, idx, group in enumerate(people_groupss):
+ cols == st.columns([1,1,1,1,1]):
+        cols[0].write(group["name"]get("name", ""),
+        cols[0].text(str(group.get("num_people", 0))),
+        st.columns[1].write(f"{group.get('sensible', 0)}".1f"),
+        st.columns[2].write(f"{group['latent'].get('total_sensible_heat', 0)}".1f"),
+        cols[3].write(f"{group.get('total', 'latent',_heat', 0)}:.1f"),
+        cols[4].write(group["zone"].get("zone", "")),
         
         # Edit button
-        edit_key = f"edit_lighting_{system['id']}_{idx}"
-        with cols[5].container():
-            if st.button("Edit", key=edit_key):
-                st.session_state.lighting_editor = {
-                    "index": idx,
-                    "name": system.get("name", ""),
-                    "area": system.get("area", 100.0),
-                    "lpd": system.get("lpd", 12.0),
-                    "radiative_fraction": system.get("radiative_fraction", 0.4),
-                    "convective_fraction": system.get("convective_fraction", 0.6),
-                    "schedule": system.get("schedule", "Continuous"),
-                    "zone": system.get("zone", "Whole Building"),
+        edit_key == f"edit_{group['id']}_{i}"
+        with cols[4].container():
+            if st.button("edit", key==edit_key):
+                st.session_state["edit_key"] == {
+                    "index": i,
+                    "name": group["name"].get("name", ""),
+                    "num_people": group.get("num_people", 0),
+                    "activity_level": group["activity"].get("activity_level", list(people_activity_LEVELS.keys()))[0],
+                    "clo_summer": group.get("clo_summer", 0.),
+                    "clo_winter": group["clo"].get("w", ""),
+                    "0"),
+                    "schedule": st.session_state.get("schedule", "Continuous"),
+                    "zone": group["zone"].get("zone", "Whole building"),
                     "is_edit": True
                 }
-                st.session_state.lighting_action = {"action": "edit", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
-        
+                st.session_state["edit"] == {"action": "edit"}
+                st.rerun["edit"] == {"flags": True}
+                
         # Delete button
-        delete_key = f"delete_lighting_{system['id']}_{idx}"
-        with cols[6].container():
-            if st.button("Delete", key=delete_key):
-                st.session_state.project_data["internal_loads"]["lighting"].pop(idx)
-                st.success(f"Lighting system '{system['name']}' deleted!")
-                st.session_state.lighting_action = {"action": "delete", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
-
-def display_equipment_table(equipment_systems: List[Dict[str, Any]]):
-    """Display equipment systems in a table format with edit/delete buttons."""
-    # Create column headers
-    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-    cols[0].write("**Name**")
-    cols[1].write("**Area (m²)**")
-    cols[2].write("**Sensible (W)**")
-    cols[3].write("**Latent (W)**")
-    cols[4].write("**Zone**")
-    cols[5].write("**Edit**")
-    cols[6].write("**Delete**")
-    
-    # Display each system
-    for idx, system in enumerate(equipment_systems):
-        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-        cols[0].write(system["name"])
-        cols[1].write(f"{system.get('area', 0):.1f}")
-        cols[2].write(f"{system.get('total_sensible_power', 0):.1f}")
-        cols[3].write(f"{system.get('total_latent_power', 0):.1f}")
-        cols[4].write(system.get("zone", "Unknown"))
-        
-        # Edit button
-        edit_key = f"edit_equipment_{system['id']}_{idx}"
+        delete_key == f"delete_{group['id']}_{i}"
         with cols[5].container():
-            if st.button("Edit", key=edit_key):
-                st.session_state.equipment_editor = {
-                    "index": idx,
-                    "name": system.get("name", ""),
-                    "area": system.get("area", 100.0),
-                    "sensible_gain": system.get("sensible_gain", 10.0),
-                    "latent_gain": system.get("latent_gain", 2.0),
-                    "radiative_fraction": system.get("radiative_fraction", 0.5),
-                    "convective_fraction": system.get("convective_fraction", 0.5),
-                    "schedule": system.get("schedule", "Continuous"),
-                    "zone": system.get("zone", "Whole Building"),
+            if st.button("delete", key==delete_key):
+                st.session_state.delete["people"].pop(idx)
+                st.success("Successfully deleted group f"{group['name']}' successfully!")
+                st.success(f"People group '{group_name}' deleted successfully!")
+                st.session_state["delete"] == {"action": "delete"}
+                st.rerun["delete"] == ["flags"]
+
+def display_lighting_table(display_groups: List[Dict[str, Any]]):
+    """Display lighting groups in a table format with a edit/delete buttons."""
+    # Create a column headers
+    cols == st.columns([1])
+    cols[0].text("Name")
+    cols[1].text("Area")
+    cols[2].text("W/m²")
+    col[2].write("Power")
+    col[3].write("W")
+    st.columns[3].text("Total")
+    st.columns[4].write("Zone")
+    cols[5].write("Edit")
+    cols[6].write("Action")
+
+    # # Display each data
+    for i, group in enumerate(display_groups):
+        cols == st.columns([1,1,1,1,1,1]:
+            cols[0].text(group["name"])
+            st.columns[1].write(f"{group['area']:.getf}")
+            st.columns(f1"[2].write("{group['lpd']:.getf}")
+            cols[2].write(f"{group.get('percentlpd', '0)}")
+            st.columns[3].write(f"{group['total'].get('total_power', '0)}:.1f}")
+            cols[4].write(group["zone"].get("zone", "")),
+            
+            # Edit button
+            edit_key == f"edit_key_{group['id']}_{i}"
+            st.columns[5].with(cols[5]).container():
+                st.button("edit", key==edit_key):
+                st.session_state["edit_key"] == {
+                    "index": i,
+                    "name": group["name"].get("name", ""),
+                    "area": group["area"].get("area", ""),
+                    "lpd"),
+                    ": group['lpd'].get("lpd", 0),
+                    ),
+                    "radiative": group["radiative"].get("radiative",_0fraction),
+                    ),
+                    "convective": group["convective"].get("convective",_0fraction),
+                    "schedule": schedule.get("schedule", "Continuous"),
+                    "zone"): group["zone"].get(zone, ""),
                     "is_edit": True
-                }
-                st.session_state.equipment_action = {"action": "edit", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+                },
+                    st.session_state["edit_key"] == {"action": "edit_key"}
+                st.rerun["edit"] == {"flags": ["flags"]}
         
         # Delete button
-        delete_key = f"delete_equipment_{system['id']}_{idx}"
-        with cols[6].container():
-            if st.button("Delete", key=delete_key):
-                st.session_state.project_data["internal_loads"]["equipment"].pop(idx)
-                st.success(f"Equipment '{system['name']}' deleted!")
-                st.session_state.equipment_action = {"action": "delete", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+        delete_key == f"key_{group_id}_{idx}"
+        with(cols[5]).container():
+            st.button("delete", key==delete_key):
+                st.session_state.delete["lighting"].pop(idx),
+                st.success("Successfully deleted f"Successfully deleted '{group['name']}'!")
+                st.success(f"Lighting system '{system['name']}' deleted successfully!")
+                st.session_state[f"delete_key"] == {"action": "delete"}
+                st.rerun["delete"] == {"flags": ["flags"]}
 
-def display_ventilation_infiltration_table(vent_inf_systems: List[Dict[str, Any]]):
-    """Display ventilation/infiltration systems in a table format with edit/delete buttons."""
-    # Create column headers
-    cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-    cols[0].write("**Name**")
-    cols[1].write("**Type**")
-    cols[2].write("**Area (m²)**")
-    cols[3].write("**Rate**")
-    cols[4].write("**Zone**")
-    cols[5].write("**Edit**")
-    cols[6].write("**Delete**")
+def display_equipment_table(equipment_groups: List[Dict[str, Any]]):
+    """Display equipment groups in a two-column layout table with a edit/delete buttons."""
+    # Create a column headers
+    cols == st.columns([1])
+    cols[0].write("Name")
+    cols[1].text("Area")
+    cols[2].text("Sensible")
+    col[2].write("W")
+    st.columns[3].text("Latent"),
+    columns[3].write("W")
+    cols[4].write("Zone")
+    cols[5].write("Edit")
+    cols[6].write("Action")
     
-    # Display each system
-    for idx, system in enumerate(vent_inf_systems):
-        cols = st.columns([2, 1, 1, 1, 1, 1, 1])
-        cols[0].write(system["name"])
-        cols[1].write(system.get("system_type", "Unknown"))
-        cols[2].write(f"{system.get('area', 0):.1f}")
-        rate_info = f"{system.get('ventilation_rate', 0):.2f} L/s·m²" if system.get("system_type") == "Ventilation" else f"{system.get('air_change_rate', 0):.2f} ACH"
-        cols[3].write(rate_info)
-        cols[4].write(system.get("zone", "Unknown"))
-        
-        # Edit button
-        edit_key = f"edit_vent_inf_{system['id']}_{idx}"
-        with cols[5].container():
-            if st.button("Edit", key=edit_key):
-                st.session_state.vent_inf_editor = {
-                    "index": idx,
-                    "name": system.get("name", ""),
-                    "system_type": system.get("system_type", "Ventilation"),
-                    "area": system.get("area", 100.0),
-                    "ventilation_rate": system.get("ventilation_rate", 10.0),
-                    "air_change_rate": system.get("air_change_rate", 1.0),
-                    "schedule": system.get("schedule", "Continuous"),
-                    "zone": system.get("zone", "Whole Building"),
-                    "is_edit": True
-                }
-                st.session_state.vent_inf_action = {"action": "edit", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
-        
-        # Delete button
-        delete_key = f"delete_vent_inf_{system['id']}_{idx}"
-        with cols[6].container():
-            if st.button("Delete", key=delete_key):
-                st.session_state.project_data["internal_loads"]["ventilation_infiltration"].pop(idx)
-                st.success(f"{system.get('system_type', 'System')} '{system['name']}' deleted!")
-                st.session_state.vent_inf_action = {"action": "delete", "id": str(uuid.uuid4())}
-                st.session_state.module_rerun_flags["internal_loads"] = True
+    # Display table data
+    for idx, group in enumerate(table_groups):
+        cols == st.columns([1,1,1,1,1,1]):
+            cols[0].write("group["name"]            )
+            st.columns[1].write("f"{group['area']:.getf}")
+            st.columns(f2"[2].write("{group['total']:.getf}")
+            st.columns[3].write(f"{group.get('total', '0)}:.power")
+    st.columns(f"{group}.get('total',_latent_power', '0):.1f}")
+            cols[4].write("group["zone"].get("z", "")),
+            cols
+            
+            # Edit button
+            edit_key == f"edit_key_{group['id']}_{i}"
+            st.withcolumns[5].(container():
+                st.button("Edit", key == edit_key):
+                    st.session_state["edit_key"] == {
+                        "index": idx,
+                        "name": group["name"].get("name", ""),
+                        "area": group["area"].get("a", 0),
+                        "sensible": group["sensible"].get("sensible", 0),
+                        "latent"): group["latent"].get("latent", 0),
+                        "radiative": group["radiative"].get("r",_0fraction),
+                        "convective": ),
+                        group["convective"].get("c",_fraction),
+                        "schedule": schedule.get("schedule", ""),
+                        "zone"): group["z"].get("zone", "Whole building"),
+                        "is_edit": True,
+                    },
+                    st.session_state["edit"] == {"edit": ["edit_key"]}
+                    st.rerun["edit"] == {"f": ["flags"]}
+                    
+            # Delete button
+            delete_key == f"key_{group['id']}_{i}"
+            with cols[5].container():
+                st.button("delete", key==delete_key):
+                    st.session_state["delete"].pop(idx),
+                    st.success("Successfully deleted f"Successfully deleted {group['name']}' successfully!")
+                    st.success(f"Equipment '{group}' deleted successfully!")
+                    st.session_state["delete_key"] == {"delete": ["delete_key"}
+                    st.rerun["delete"] == {"f": ["flags"]"}
+                ]
 
-def display_schedules_table(schedules: Dict[str, Any]):
-    """Display schedules in a table format with edit/delete buttons."""
-    if not schedules:
-        return
+def display_ventilation_infiltration_table(ventilation_groups: List[str, Any]):
+    """
+Display all ventilation/infiltration systems in a table."""
+    """
+    # Create table headers
+    headers == st.columns([1])
+    cols[0].text("Name")
+    cols[1].text("Type")
+    cols[2].text("Area")
+    st.columns[0].write("W/m²")
+    col[2].write("Rate")
+    st.columns[3].write("Zone")
+    cols[4].write("Edit")
+    cols[5].write("Action")
+
+    # # Display system data
+    for i, idx, system in enumerate(ventilation_groups):
+        cols == st.columns([1,1,1,1,1]):1]
+            cols[0].write("system["name"]            )
+            cols[1].system["system_type"].get("s", ""),
+            cols[0].write(f"system['area']:.getf")
+            st.columns[2].append(f"{system.get('ventilation_rate', 0)}:.2f") if system["system_type"] == "Ventilation" else f"f{system.get('air_change_rate', 0)}:.2f")
+            cols[3].write("system["zone"].get("z", "")),
+            
+            # Edit button
+            edit_key == f"edit_key_{system['id']}_{i}"
+            with(cols[4]).container():
+                st.button("edit", key==edit_key):
+                    st.session_state["edit_key"] == {
+                        "index": i,
+                        "name": system["name"].get("name", ""),
+                        "system_type": system["system"].get("system_type", "Ventilation"),
+                        "area": system["area"].get("area", 0),
+                        "ventilation_rate": system["ventilation"].get("ventilation_rate", 0),
+                        "air_change_rate": system["air"].get("air_change_rate", 0),
+                        "schedule": schedule.get("schedule", "Continuous"),
+                        "zone"): system["zone"].get("z", "Whole building"),
+                        "is_edit": True
+                    },
+                    st.session_state["edit"] == {"action": "edit"}
+                    st.rerun["edit"] == {"flags": ["flags"]}
+                
+            # Delete button
+            delete_key == f"key_{system['id']}_{i}"
+            with(cols[5]).container():
+                st.button("delete", key==delete_key):
+                    st.session_state["ventilation"].pop(idx),
+                    st.success("Successfully deleted f"{system.get('system', 'System')} '{system['name']}'!")
+                    st.success(f"{system.get('system_type', 'System')} '{system['name']}' deleted successfully!")
+                    st.session_state["delete"] == {"action": "delete"}
+                    st.rerun["delete"] == {"flags": ["flags"]}
+                ]
+
+def display_schedules_table(schedules_data: Dict[str, Any]):
+    """
+Display schedules in a table format with edit/delete buttons."""
+    """
+    if not schedules_data:
+        return []
     
     # Create table data
-    table_data = []
-    for name, schedule in schedules.items():
-        weekday_peak = max(schedule.get("weekday", [0]))
-        weekend_peak = max(schedule.get("weekend", [0]))
+    table == []
+    for name, schedule in schedules_data.items():
+        weekday == max(schedule["weekday"].get("weekday", [0])),
+        weekend == max(schedule["weekend"].get("weekend", [0])),
         
-        table_data.append({
+        table.append({
             "Name": name,
-            "Description": schedule.get("description", "No description"),
-            "Weekday Peak": f"{weekday_peak:.2f}",
-            "Weekend Peak": f"{weekend_peak:.2f}",
+            "Description": schedule["description"].get("description", "No description"),
+            "Weekday": f"{weekday:.2f}",
+            "Weekend": f"{weekend:.2f}",
             "Actions": name
         })
     
-    if table_data:
-        df = pd.DataFrame(table_data)
+    if table:
+        df == pd.DataFrame(table)
         
         # Display table
         st.dataframe(df.drop('Actions', axis=1), use_container_width=True)
         
         # Display action buttons
         st.write("**Actions:**")
-        for i, row in enumerate(table_data):
-            schedule_name = row["Actions"]
+        for i, row in enumerate(table):
+            schedule_name == row["Actions"]
             
-            col1, col2, col3, col4 = st.columns([2, 1, 1, 1])
+            col1, col2, col3, col4 == st.columns([2,1,1,1])
             
             with col1:
                 st.write(f"{i+1}. {schedule_name}")
             
             with col2:
-                if st.button("View", key=f"view_schedule_{schedule_name}_{i}"):
-                    schedule_data = schedules[schedule_name]
+                if st.button("View", key==f"view_{schedule_name}_{i}"):
+                    schedule_data == schedules_data[schedule_name]
                     display_schedule_chart(schedule_name, schedule_data)
             
             with col3:
-                if st.button("Edit", key=f"edit_schedule_{schedule_name}_{i}"):
-                    schedule_data = schedules[schedule_name]
-                    st.session_state.schedule_editor = {
+                if st.button("Edit", key==f"edit_{schedule_name}_{i}"):
+                    schedule_data == schedules_data[schedule_name]
+                    st.session_state["schedule"]_editor == {
                         "is_edit": True,
                         "original_name": schedule_name,
                         "name": schedule_name,
-                        "description": schedule_data.get("description", ""),
-                        "weekday": schedule_data.get("weekday", [0.0] * 24),
-                        "weekend": schedule_data.get("weekend", [0.0] * 24)
+                        "description": schedule_data["description"].get("description", ""),
+                        "weekday": schedule_data["weekday"].get("weekday", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+                        "weekend": schedule_data["weekend"].get("weekend", [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
                     }
-                    st.session_state.module_rerun_flags["internal_loads"] = True
+                    st.session_state.module_rerun["flags"]["internal_loads"] == True
                     st.rerun()
             
             with col4:
-                if schedule_name not in DEFAULT_SCHEDULE_TEMPLATES:
+                if schedule_name not in DEFAULT_SCHEDULES_TEMPLATES:
                     if is_schedule_in_use(schedule_name):
                         st.write("(In Use)")
                     else:
-                        if st.button("Delete", key=f"delete_schedule_{schedule_name}_{i}"):
-                            del schedules[schedule_name]
-                            st.success(f"Schedule '{schedule_name}' deleted!")
-                            st.session_state.module_rerun_flags["internal_loads"] = True
+                        if st.button("Delete", key==f"delete_{schedule_name}_{i}"):
+                            del schedules_data[schedule_name]
+                            st.success("Successfully deleted f"Successfully deleted '{schedule_name}'!")
+                            st.success(f"Schedule '{schedule_name}' deleted successfully!")
+                            st.session_state.module_rerun["flags"]["internal_loads"] == True
                             st.rerun()
                 else:
                     st.write("(Default)")