Update app.py

app.py

@@ -1,4 +1,6 @@
-# 0815 Version – Fully Fixed & Optimized (UI + Load Fix)
+# 0815 Version.
+
+# Imports.
 import gradio as gr
 import pandas as pd
 from datetime import datetime, time
@@ -10,145 +12,94 @@ import shutil
 import json
 from weasyprint import HTML, CSS
 import warnings
-from concurrent.futures import ThreadPoolExecutor, as_completed
 
 warnings.filterwarnings("ignore")
 
-# ----------------------------------------------------------------------
-# Constants & Config
-# ----------------------------------------------------------------------
 UPLOAD_DIR = "Uploads"
 UPLOAD_TIMES_FILE = os.path.join(UPLOAD_DIR, "upload_times.json")
 CHICAGO_TZ = ZoneInfo("America/Chicago")
 
-os.makedirs(UPLOAD_DIR, exist_ok=True)
 if os.path.exists(UPLOAD_DIR) and not os.path.isdir(UPLOAD_DIR):
-    raise FileExistsError(f"'{UPLOAD_DIR}' exists as a file. Remove or rename it.")
+    raise FileExistsError(f"Error: '{UPLOAD_DIR}' exists as a file, not a directory. Please rename or remove the 'Uploads' file and try again.")
+os.makedirs(UPLOAD_DIR, exist_ok=True)
 
 AGE_LST = ["Newborn-5mo", "6mo-9yo", "10-17yo", "18-20yo", "21-24yo", "25+yo"]
 OFF_LST = ['OFF', 'VACATION', 'FMLA', 'ADMIN', 'PAID_LEAVE', 'CME', 'TEACHING', 'SICK', 'HOLIDAY']
 UNDER_18G = ["Newborn-5mo", "6mo-9yo", "10-17yo"]
 OVER_18G = ["18-20yo", "21-24yo", "25+yo"]
-
-AVAILABLE_LOCATIONS = [
-    'Berwyn', 'Juarez', 'LVHS', 'Morgan', 'Orozco', 'Western',
-    'Urgent Care', 'Psych', "OB/Gynecology", 'All Locations'
-]
+AVAILABLE_LOCATIONS = ['Berwyn', 'Juarez', 'LVHS', 'Morgan', 'Orozco', 'Western', 'Urgent Care', 'Psych', "OB/Gynecology", 'All Locations']
 NO_AGE_CHECK_LOCATIONS = ['Juarez', 'LVHS', 'Orozco', 'Urgent Care', 'Psych', "OB/Gynecology"]
-NO_OPERATION_CHECK_LOCATIONS = NO_AGE_CHECK_LOCATIONS.copy()
-
-LOCATION_MAP = {
-    'B': 'Berwyn', 'J': 'Juarez', 'L': 'LVHS', 'M': 'Morgan', 'O': 'Orozco', 'W': 'Western',
-    'UC': 'Urgent Care', 'PSY/M': 'Psych', 'PSY/B': 'Psych',
-    "OB/B": "OB/Gynecology", "OB/M": "OB/Gynecology", "OB/W": "OB/Gynecology", "OB": "OB/Gynecology"
-}
+NO_OPERATION_CHECK_LOCATIONS = ['Juarez', 'LVHS', 'Orozco', 'Urgent Care', 'Psych', "OB/Gynecology"]
+LOCATION_MAP = {'B': 'Berwyn', 'J': 'Juarez', 'L': 'LVHS', 'M': 'Morgan', 'O': 'Orozco', 'W': 'Western', 'UC': 'Urgent Care', 
+                'PSY/M': 'Psych', 'PSY/B': 'Psych', "OB/B": "OB/Gynecology", "OB/M": "OB/Gynecology", "OB/W": "OB/Gynecology", "OB": "OB/Gynecology"}
 
-# ----------------------------------------------------------------------
-# Clinic Hours (Defined BEFORE any reference)
-# ----------------------------------------------------------------------
-CLINIC_HOURS = {
-    'Berwyn': {
-        (0,1,3,4): (time(8,30), time(17,30), [(12,30),(13,30)]),
-        2: (time(13,0), time(20,0), [(16,0),(17,0)]),
-        5: (time(8,30), time(15,0), [(11,30),(12,0)])
-    },
-    'Morgan': {},
-    'Western': {},
-    'Urgent Care': {
-        (0,1,3,4): (time(9,0), time(18,0), [(13,0),(14,0)]),
-        2: (time(9,0), time(18,0), [(13,0),(14,0)]),
-        5: (time(9,0), time(13,30), [])
-    },
-    'Juarez': {
-        (0,1,2,3,4): (time(8,30), time(16,0), [(13,0),(14,0)])
-    },
-    'Orozco': {
-        (0,1,2,3,4): (time(8,0), time(16,30), [])
-    },
-    'LVHS': {
-        (0,1,2,3): (time(8,30), time(16,0), [(12,0),(13,0)]),
-        4: (time(12,0), time(13,0), [])
-    },
-    'Psych': {
-        (0,1,3,4): (None, None, [(12,30),(13,30)]),
-        2: (None, None, [(16,0),(17,0)]),
-        5: (None, None, [])
-    }
-}
-
-# Copy Berwyn → Morgan & Western
-CLINIC_HOURS['Morgan'] = {k: v for k, v in CLINIC_HOURS['Berwyn'].items()}
-CLINIC_HOURS['Western'] = {k: v for k, v in CLINIC_HOURS['Berwyn'].items()}
-
-# ----------------------------------------------------------------------
-# Helper Functions
-# ----------------------------------------------------------------------
 def get_time_string(row):
     if row['Location'] == "OB/Gynecology" and pd.isna(row['Start_Time']) and pd.isna(row['End_Time']) and pd.notna(row.get('Note')):
-        return row['Note'].strip()
+        note = row['Note'].strip()
+        return note
     if pd.isna(row['Start_Time']) and pd.isna(row['End_Time']) and pd.notna(row.get('Note')):
         note = row['Note'].strip().upper()
-        return "OFF" if note == 'SCHOOL CLOSED' else (row['Note'] if note in OFF_LST else "OFF")
+        if note == 'SCHOOL CLOSED':
+            return "OFF"
+        if note in OFF_LST:
+            return row['Note']
     if pd.notna(row['Start_Time']) and pd.notna(row['End_Time']):
         time_str = f"{row['Start_Time'].strftime('%H:%M')} - {row['End_Time'].strftime('%H:%M')}"
-        note = row.get('Note', '').strip().upper()
-        return f"{time_str} ({row['Note']})" if note and note != 'SCHOOL CLOSED' else time_str
+        if pd.notna(row.get('Note')) and row['Note'].strip() != '':
+            note = row['Note'].strip().upper()
+            if note == 'SCHOOL CLOSED':
+                return time_str
+            return f"{time_str} ({row['Note']})"
+        return time_str
     return "OFF"
 
 def parse_date(val):
     if pd.isna(val) or val is None:
         return None
-    if isinstance(val, (int, float)):
-        return pd.Timestamp('1899-12-30') + pd.Timedelta(days=val)
-    if isinstance(val, str):
-        for fmt in ['%m/%d/%y', '%m/%d/%Y', '%Y-%m-%d']:
-            try:
-                return pd.to_datetime(val, format=fmt)
-            except ValueError:
-                continue
-    return pd.to_datetime(val, errors='coerce')
-
-def parse_time(val):
-    if pd.isna(val) or val in ["", "OFF", "nan", "NaT"]:
-        return None
-    if isinstance(val, time):
-        return val
-    if isinstance(val, datetime):
-        return val.time()
     try:
-        return pd.to_datetime(val, format='%H:%M:%S', errors='coerce').time()
-    except:
-        try:
-            return pd.to_datetime(val, format='%H:%M', errors='coerce').time()
-        except:
-            try:
-                hours = float(val) * 24
-                h, m = int(hours), int((hours - int(hours)) * 60)
-                return time(h, m) if 0 <= h < 24 and 0 <= m < 60 else None
-            except:
-                return None
+        if isinstance(val, (int, float)):
+            # Handle Excel serial numbers
+            return pd.Timestamp('1899-12-30') + pd.Timedelta(days=val)
+        elif isinstance(val, str):
+            # Try different date formats
+            for fmt in ['%m/%d/%y', '%m/%d/%Y', '%Y-%m-%d']:
+                try:
+                    return pd.to_datetime(val, format=fmt)
+                except ValueError:
+                    continue
+            # Fallback to general parsing
+            return pd.to_datetime(val)
+        elif isinstance(val, (pd.Timestamp, datetime)):
+            return val
+        return None
+    except (ValueError, TypeError) as e:
+        print(f"Date parsing error for value {val}: {str(e)}")
+        return None
 
-# ----------------------------------------------------------------------
-# Excel Parsing (Parallel)
-# ----------------------------------------------------------------------
-def _parse_excel_file(path):
+def validate_excel_file(file_path, expected_columns):
     try:
-        all_sheets = pd.read_excel(path, engine='openpyxl', sheet_name=None)
+        all_sheets = pd.read_excel(file_path, engine='openpyxl', sheet_name=None)
         if not all_sheets:
-            return None, "No sheets found."
-        combined = []
+            return None, "No sheets found in the Excel file!"
+        
+        combined_dfs = []
+        
         for sheet_name, df in all_sheets.items():
             print(f"Processing sheet: {sheet_name}")
             base_columns = ['Name', 'Location']
             if not all(col in df.columns for col in base_columns):
                 return None, f"Missing required columns in sheet '{sheet_name}'. Expected at least: {base_columns}"
+            
             if 'Start_Time1' not in df.columns:
                 return None, f"No valid time columns (e.g., Start_Time1) found in sheet '{sheet_name}'!"
+            
             num_days = sum(1 for col in df.columns if col.startswith('Start_Time'))
+            
             week_rows = df[df['Name'].str.startswith('Week', na=False)].index.tolist()
             if not week_rows:
                 print(f"No week rows found in sheet '{sheet_name}'")
                 continue
+            
             for week_idx in week_rows:
                 dates = []
                 for day in range(1, num_days + 1):
@@ -160,21 +111,27 @@ def _parse_excel_file(path):
                         print(f"Parsed date for {col} in sheet '{sheet_name}': {parsed_date}")
                     else:
                         dates.append(None)
+                
                 next_week = next((idx for idx in week_rows if idx > week_idx), len(df))
                 provider_df = df.loc[week_idx + 1: next_week - 1]
                 provider_df = provider_df[~provider_df['Name'].eq('Name')]
+                
                 if provider_df.empty:
                     print(f"No provider data found for week starting at index {week_idx} in sheet '{sheet_name}'")
                     continue
+                
                 temp_dfs = []
                 for day in range(1, num_days + 1):
                     if day > len(dates) or dates[day - 1] is None:
                         continue
+                    
                     start_col = f'Start_Time{day}'
                     end_col = f'End_Time{day}'
                     note_col = f'Note{day}'
+                    
                     if start_col not in df.columns or end_col not in df.columns:
                         continue
+                    
                     temp = provider_df[['Name', 'Location', start_col, end_col, note_col]].copy()
                     temp['Date'] = dates[day - 1]
                     temp = temp.rename(columns={
@@ -183,36 +140,65 @@ def _parse_excel_file(path):
                         note_col: 'Note'
                     })
                     temp_dfs.append(temp)
+                
                 if temp_dfs:
                     sheet_week_df = pd.concat(temp_dfs, ignore_index=True)
                     sheet_week_df = sheet_week_df.dropna(subset=['Name'])
                     sheet_week_df['Location'] = sheet_week_df['Location'].map(lambda x: LOCATION_MAP.get(x, x) if pd.notna(x) else x)
+                    
                     for time_col in ['Start_Time', 'End_Time']:
                         if time_col in sheet_week_df.columns:
                             sheet_week_df[time_col] = sheet_week_df[time_col].apply(parse_time)
-                    combined.append(sheet_week_df)
-        if not combined:
+                    
+                    combined_dfs.append(sheet_week_df)
+        
+        if not combined_dfs:
             return None, "No valid data found across all sheets! Check date formats and ensure data exists for the specified range."
-        final_df = pd.concat(combined, ignore_index=True)
+        final_df = pd.concat(combined_dfs, ignore_index=True)
         final_df = final_df.drop_duplicates()
         final_df = final_df.dropna(subset=["Date"])
         final_df = final_df[final_df["Location"] != "Location"]
         final_df = final_df[final_df["Name"] != "Name"]
         final_df["Date"] = pd.to_datetime(final_df["Date"])
+        
         if final_df.empty:
             return None, "No valid data after filtering! Ensure the date range matches the data in the Excel files."
+        
         print(f"Final DataFrame shape: {final_df.shape}")
         print(f"Available dates: {final_df['Date'].unique()}")
         return final_df, None
     except Exception as e:
         return None, f"Error reading Excel: {str(e)}!"
 
-# ----------------------------------------------------------------------
-# Provider Info Validation
-# ----------------------------------------------------------------------
-def validate_provider_info(path):
+def parse_time(value):
+    if value in ["nan", "NaT", "", "OFF"] or pd.isna(value):
+        return None
+    try:
+        if isinstance(value, (datetime, time)):
+            return value if isinstance(value, time) else value.time()
+        try:
+            return pd.to_datetime(value, format='%H:%M:%S').time()
+        except ValueError:
+            try:
+                return pd.to_datetime(value, format='%H:%M').time()
+            except ValueError:
+                try:
+                    hours = float(value) * 24
+                    if hours < 0 or hours > 24:
+                        return None
+                    hour = int(hours)
+                    minute = int((hours - hour) * 60)
+                    if hour >= 24 or minute >= 60:
+                        return None
+                    return time(hour, minute)
+                except (ValueError, TypeError):
+                    return None
+    except (ValueError, TypeError):
+        return None
+
+def validate_provider_info(file_path):
     try:
-        df = pd.read_excel(path, engine='openpyxl')
+        df = pd.read_excel(file_path, engine='openpyxl')
         expected_columns = ["Provider", "Last_Name", "Location"] + AGE_LST
         if not all(col in df.columns for col in expected_columns):
             return None, f"Invalid columns in Provider_Info. Expected: {expected_columns}!"
@@ -224,9 +210,6 @@ def validate_provider_info(path):
     except Exception as e:
         return None, f"Error reading Provider_Info Excel: {str(e)}!"
 
-# ----------------------------------------------------------------------
-# File Management
-# ----------------------------------------------------------------------
 def save_files(file_list):
     if not file_list:
         return update_file_display()
@@ -279,9 +262,6 @@ def delete_file(filename):
                         json.dump(upload_times, f, indent=2)
     return update_file_display()
 
-# ----------------------------------------------------------------------
-# Check Functions
-# ----------------------------------------------------------------------
 def check_age_coverage(providers_df, provider_info_df, location, date):
     date_key = pd.to_datetime(date).strftime('%m/%d/%y')
     providers_on_date = providers_df[
@@ -374,22 +354,92 @@ def check_provider_location_conflicts(providers_df, date, locations):
                 conflicts.append((provider, conflict_locations, 'conflict-warning', f'Provider {provider} scheduled at: {", ".join(conflict_locations)}'))
     return conflicts
 
-def get_clinic_hours(loc, weekday):
-    config = CLINIC_HOURS.get(loc, {})
-    for days, (start, end, breaks) in config.items():
-        if isinstance(days, tuple):
-            if weekday in days:
-                return start, end, [(time(b[0], b[1]), time(b[2], b[3])) for b in breaks]
-        elif weekday == days:
-            return start, end, [(time(b[0], b[1]), time(b[2], b[3])) for b in breaks]
-    return None, None, []
-
 def check_operation_time_coverage(providers_df, date, location):
     date_key = pd.to_datetime(date).strftime('%m/%d/%y')
     weekday = pd.to_datetime(date).weekday()
-    clinic_start, clinic_end, break_times = get_clinic_hours(location, weekday)
-    if clinic_start is None:
+    
+    if location in ['Berwyn', 'Morgan', 'Western']:
+        if weekday in [0, 1, 3, 4]:
+            clinic_start = time(8, 30)
+            clinic_end = time(17, 30)
+            break_times = [(time(12, 30), time(13, 30))]
+        elif weekday == 2:
+            clinic_start = time(13, 0)
+            clinic_end = time(20, 0)
+            break_times = [(time(16, 0), time(17, 0))]
+        elif weekday == 5:
+            clinic_start = time(8, 30)
+            clinic_end = time(15, 0)
+            break_times = [(time(11, 30), time(12, 00))]
+        else:
+            return []
+    elif location == 'Urgent Care':
+        if weekday in [0, 1, 3, 4]:
+            clinic_start = time(9, 0)
+            clinic_end = time(18, 0)
+            break_times = [(time(13, 0), time(14, 0))]
+        elif weekday == 2:
+            clinic_start = time(9, 0)
+            clinic_end = time(18, 0)
+            break_times = [(time(13, 0), time(14, 0))]
+        elif weekday == 5:
+            clinic_start = time(9, 0)
+            clinic_end = time(13, 30)
+            break_times = []
+        else:
+            return []
+    elif location == 'Juarez':
+        if weekday in [0, 1, 2, 3, 4]:
+            clinic_start = time(8, 30)
+            clinic_end = time(16, 0)
+            break_times = [(time(13, 0), time(14, 0))]
+        else:
+            return []
+    elif location == 'Orozco':
+        if weekday in [0, 1, 2, 3, 4]:
+            clinic_start = time(8, 0)
+            clinic_end = time(16, 30)
+            break_times = []
+        else:
+            return []
+    elif location == 'LVHS':
+        if weekday in [0, 1, 2, 3]:
+            clinic_start = time(8, 30)
+            clinic_end = time(16, 0)
+            break_times = [(time(12, 0), time(13, 0))]
+        elif weekday == 4:
+            clinic_start = time(12, 0)
+            clinic_end = time(13, 0)
+            break_times = []
+        else:
+            return []
+    elif location == 'Psych':
+        providers_on_date = providers_df[
+            (providers_df['Date'] == date_key) &
+            (providers_df['Location'] == location) &
+            (providers_df['Start_Time'].notna()) &
+            (providers_df['End_Time'].notna()) &
+            (~providers_df['Note'].str.upper().fillna('').isin(OFF_LST))
+        ]
+        if providers_on_date.empty:
+            return []
+        if weekday in [0, 1, 3, 4]:
+            break_times = [(time(12, 30), time(13, 30))]
+        elif weekday == 2:
+            break_times = [(time(16, 0), time(17, 0))]
+        elif weekday == 5:
+            break_times = []
+        else:
+            return []
+        start_times = [row['Start_Time'] for _, row in providers_on_date.iterrows() if row['Start_Time']]
+        end_times = [row['End_Time'] for _, row in providers_on_date.iterrows() if row['End_Time']]
+        if not start_times or not end_times:
+            return []
+        clinic_start = min(start_times)
+        clinic_end = max(end_times)
+    else:
         return []
+
     providers_on_date = providers_df[
         (providers_df['Date'] == date_key) &
         (providers_df['Location'] == location) &
@@ -407,12 +457,14 @@ def check_operation_time_coverage(providers_df, date, location):
         if current_time < clinic_end:
             gaps.append(f"{current_time.strftime('%H:%M')} - {clinic_end.strftime('%H:%M')}")
         return gaps if gaps else []
+
     intervals = []
     for _, row in providers_on_date.iterrows():
         start = row['Start_Time']
         end = row['End_Time']
         if start and end:
             intervals.append((start, end))
+    
     intervals.sort(key=lambda x: x[0])
     merged_intervals = []
     current_start = None
@@ -429,6 +481,7 @@ def check_operation_time_coverage(providers_df, date, location):
             current_end = end
     if current_start is not None:
         merged_intervals.append((current_start, current_end))
+    
     operational_intervals = []
     for start, end in merged_intervals:
         current_start = start
@@ -439,6 +492,7 @@ def check_operation_time_coverage(providers_df, date, location):
                 current_start = max(current_start, break_end)
         if current_start < end:
             operational_intervals.append((current_start, end))
+    
     gaps = []
     current_time = clinic_start
     for break_start, break_end in break_times:
@@ -456,28 +510,117 @@ def check_operation_time_coverage(providers_df, date, location):
             current_time = max(current_time, end)
         if current_time < clinic_end:
             gaps.append(f"{current_time.strftime('%H:%M')} - {clinic_end.strftime('%H:%M')}")
+    
     return gaps
 
-# ----------------------------------------------------------------------
-# Weekly Hours
-# ----------------------------------------------------------------------
 def calculate_weekly_hours(providers_df, provider_info_df, start_date, end_date, locations):
     weekly_hours = {}
     weekly_totals = {}
     current_date = start_date
     week_number = 1
+    week_start = start_date
     while current_date <= end_date:
         if current_date.weekday() == 6:
             current_date += pd.Timedelta(days=1)
             continue
         if current_date.weekday() == 0 and current_date != start_date:
             week_number += 1
+            week_start = current_date
         date_key = current_date.strftime('%m/%d/%y')
         weekday = current_date.weekday()
+        
         for location in sorted(locations):
-            clinic_start, clinic_end, break_times = get_clinic_hours(location, weekday)
-            if clinic_start is None:
+            if location in ['Berwyn', 'Morgan', 'Western']:
+                if weekday in [0, 1, 3, 4]:
+                    clinic_start = time(8, 30)
+                    clinic_end = time(17, 30)
+                    break_times = [(time(12, 30), time(13, 30))]
+                elif weekday == 2:
+                    clinic_start = time(13, 0)
+                    clinic_end = time(20, 0)
+                    break_times = [(time(16, 0), time(17, 0))]
+                elif weekday == 5:
+                    clinic_start = time(8, 30)
+                    clinic_end = time(15, 0)
+                    break_times = [(time(11, 30), time(12, 00))]
+                else:
+                    break_times = []
+                    continue
+            elif location == 'Urgent Care':
+                if weekday in [0, 1, 3, 4]:
+                    clinic_start = time(9, 0)
+                    clinic_end = time(18, 0)
+                    break_times = [(time(13, 0), time(14, 0))]
+                elif weekday == 2:
+                    clinic_start = time(9, 0)
+                    clinic_end = time(18, 0)
+                    break_times = [(time(13, 0), time(14, 0))]
+                elif weekday == 5:
+                    clinic_start = time(9, 0)
+                    clinic_end = time(13, 30)
+                    break_times = []
+                else:
+                    break_times = []
+                    continue
+            elif location == 'Juarez':
+                if weekday in [0, 1, 2, 3, 4]:
+                    clinic_start = time(8, 30)
+                    clinic_end = time(16, 0)
+                    break_times = [(time(13, 0), time(14, 0))]
+                else:
+                    break_times = []
+                    continue
+            elif location == 'Orozco':
+                if weekday in [0, 1, 2, 3, 4]:
+                    clinic_start = time(8, 0)
+                    clinic_end = time(16, 30)
+                    break_times = []
+                else:
+                    break_times = []
+                    continue
+            elif location == 'LVHS':
+                if weekday in [0, 1, 2, 3]:
+                    clinic_start = time(8, 30)
+                    clinic_end = time(16, 0)
+                    break_times = [(time(12, 0), time(13, 0))]
+                elif weekday == 4:
+                    clinic_start = time(12, 0)
+                    clinic_end = time(13, 0)
+                    break_times = []
+                else:
+                    break_times = []
+                    continue
+            elif location == 'Psych':
+                loc_providers_df = providers_df[
+                    (providers_df['Date'] == date_key) &
+                    (providers_df['Location'] == location) &
+                    (providers_df['Start_Time'].notna()) &
+                    (providers_df['End_Time'].notna()) &
+                    (~providers_df['Note'].str.upper().fillna('').isin(OFF_LST))
+                ]
+                if loc_providers_df.empty:
+                    break_times = []
+                    continue
+                if weekday in [0, 1, 3, 4]:
+                    break_times = [(time(12, 30), time(13, 30))]
+                elif weekday == 2:
+                    break_times = [(time(16, 0), time(17, 0))]
+                elif weekday == 5:
+                    break_times = []
+                else:
+                    break_times = []
+                    continue
+                start_times = [row['Start_Time'] for _, row in loc_providers_df.iterrows() if row['Start_Time']]
+                end_times = [row['End_Time'] for _, row in loc_providers_df.iterrows() if row['End_Time']]
+                if not start_times or not end_times:
+                    break_times = []
+                    continue
+                clinic_start = min(start_times)
+                clinic_end = max(end_times)
+            else:
+                break_times = []
                 continue
+
             loc_providers_df = providers_df[
                 (providers_df['Date'] == date_key) &
                 (providers_df['Location'] == location) &
@@ -502,18 +645,22 @@ def calculate_weekly_hours(providers_df, provider_info_df, start_date, end_date,
                     weekly_hours[week_key][location][display_name] = 0.0
                 if display_name not in weekly_totals[week_key]:
                     weekly_totals[week_key][display_name] = 0.0
-               
+                
                 start_dt = datetime.combine(current_date, start_time)
                 end_dt = datetime.combine(current_date, end_time)
                 if end_dt < start_dt:
                     end_dt += pd.Timedelta(days=1)
                 total_hours = (end_dt - start_dt).total_seconds() / 3600
-               
+                
+                # Add 1 hour if the note contains "6-7/TELE"
                 if note == '6-7/TELE':
                     total_hours += 1.0
+
+                # Newly added.
+                # Check if clinical hours are less than 5 hours to decide on break time deduction
                 clinical_hours = total_hours
                 apply_break = clinical_hours >= 5.0
-               
+                
                 if apply_break:
                     for break_start, break_end in break_times:
                         break_start_dt = datetime.combine(current_date, break_start)
@@ -525,7 +672,7 @@ def calculate_weekly_hours(providers_df, provider_info_df, start_date, end_date,
                         if overlap_start < overlap_end:
                             overlap_hours = (overlap_end - overlap_start).total_seconds() / 3600
                             total_hours -= overlap_hours
-               
+                
                 clinic_start_dt = datetime.combine(current_date, clinic_start)
                 clinic_end_dt = datetime.combine(current_date, clinic_end)
                 if clinic_end_dt < clinic_start_dt:
@@ -536,16 +683,13 @@ def calculate_weekly_hours(providers_df, provider_info_df, start_date, end_date,
                     total_hours = min(total_hours, (overlap_end - overlap_start).total_seconds() / 3600)
                 else:
                     total_hours = 0.0
-               
+                
                 weekly_hours[week_key][location][display_name] += max(total_hours, 0.0)
                 weekly_totals[week_key][display_name] += max(total_hours, 0.0)
-       
+        
         current_date += pd.Timedelta(days=1)
     return weekly_hours, weekly_totals
 
-# ----------------------------------------------------------------------
-# Entry Count for Pagination
-# ----------------------------------------------------------------------
 def calculate_max_entries_per_day(providers_df, ma_df, start_obj, end_obj, all_locations, check_age_coverage_flag, check_location_conflicts_flag, check_operation_coverage_flag, check_ma_mismatch_flag, num_provider_files):
     week_entries = []
     current_date = start_obj
@@ -610,10 +754,10 @@ def calculate_max_entries_per_day(providers_df, ma_df, start_obj, end_obj, all_l
                             ma_on_day['End_Time'].notna() &
                             ~ma_on_day['Note'].str.upper().fillna('').isin(OFF_LST)
                         ]) if not ma_on_day.empty else 0
-                        total_entries_day += 1 # MAs header
-                        total_entries_day += ma_count # Each MA
+                        total_entries_day += 1  # MAs header
+                        total_entries_day += ma_count  # Each MA
                         if not (ma_count == working_providers or ma_count == working_providers + 1):
-                            total_entries_day += 1 # Warning
+                            total_entries_day += 1  # Warning
                 has_providers = True
         if perform_overall_check and has_providers:
             total_entries_day += 1
@@ -628,118 +772,6 @@ def calculate_max_entries_per_day(providers_df, ma_df, start_obj, end_obj, all_l
         week_entries.append(sum(current_week))
     return week_entries
 
-# ----------------------------------------------------------------------
-# HTML Day Renderer
-# ----------------------------------------------------------------------
-def _render_day(providers_df, provider_info_df, ma_df, date, locations, checks):
-    date_key = pd.to_datetime(date).strftime('%m/%d/%y')
-    html = f'<div class="day">{date.day}<br>'
-    has_content = False
-    # Conflicts
-    if checks[1]:
-        conflicts = check_provider_location_conflicts(providers_df, date, locations)
-        for provider, conflict_locations, warning_class, message in conflicts:
-            html += f'<div class="{warning_class}"><span class="warning-details">{message}</span></div>'
-            has_content = True
-    # Overall age
-    if checks[0]:
-        missing_ages, is_holiday = check_overall_age_coverage(providers_df, provider_info_df, date, locations)
-        if not is_holiday and missing_ages:
-            html += f'<div class="overall-warning"><span class="warning-details">Missing age all locations: {", ".join(missing_ages)}</span></div>'
-            has_content = True
-    for location in sorted(locations):
-        loc_providers_df = providers_df[(providers_df['Date'] == pd.to_datetime(date_key, format='%m/%d/%y')) &
-                                        (providers_df['Location'] == location)] if not providers_df.empty else pd.DataFrame()
-        loc_provider_info_df = provider_info_df[provider_info_df['Location'] == location] if provider_info_df is not None else pd.DataFrame()
-        is_holiday = False
-        is_school_closed = False
-        if not loc_providers_df.empty:
-            all_provider_notes = loc_providers_df['Note'].dropna().str.strip().str.upper().tolist()
-            if all_provider_notes and all(note == 'HOLIDAY' for note in all_provider_notes):
-                is_holiday = True
-            elif all_provider_notes and all(note == 'SCHOOL CLOSED' for note in all_provider_notes) and location in NO_AGE_CHECK_LOCATIONS:
-                is_school_closed = True
-        if not loc_providers_df.empty:
-            loc_providers_df = loc_providers_df[
-                ~((loc_providers_df['Start_Time'].isna()) &
-                  (loc_providers_df['End_Time'].isna()) &
-                  (loc_providers_df['Note'].isna() | (loc_providers_df['Note'] == '')))
-            ]
-        if not loc_providers_df.empty or is_holiday or is_school_closed:
-            has_content = True
-            html += f'<div class="location-section"><strong>{location}</strong><br>'
-            if is_holiday:
-                html += '<div class="holiday-message">Holiday!<br>Clinic Closed!</div>'
-            if is_school_closed:
-                html += '<div class="holiday-message">School Closed!</div>'
-            if not is_holiday and not is_school_closed:
-                if not loc_providers_df.empty:
-                    html += '<div class="event"><strong>Providers:</strong><br>'
-                    missing_ages, full_age_providers, under_18_providers, over_18_providers, only_25_plus_providers = check_age_coverage(providers_df, loc_provider_info_df, location, date)
-                    for _, row in loc_providers_df.iterrows():
-                        provider_info = loc_provider_info_df[loc_provider_info_df['Provider'] == row['Name']]
-                        display_name = provider_info['Last_Name'].iloc[0] if not provider_info.empty else row['Name']
-                        time_str = get_time_string(row)
-                        style = "font-size: 7pt; margin: 1mm; line-height: 1.1;"
-                        if row['Name'] in full_age_providers:
-                            style += "color: #ff6347;"
-                        elif row['Name'] in under_18_providers:
-                            style += "color: #008000;"
-                        elif row['Name'] in over_18_providers:
-                            style += "color: #0000ff;"
-                        elif row['Name'] in only_25_plus_providers:
-                            style += "color: #8E44AD;"
-                        else:
-                            style += "color: #000000;"
-                        if time_str in OFF_LST:
-                            style += " text-decoration: line-through;"
-                        html += f'<span style="{style}">{display_name}: {time_str}</span><br>'
-                    html += '</div>'
-                    if checks[2] and location not in NO_OPERATION_CHECK_LOCATIONS:
-                        gaps = check_operation_time_coverage(providers_df, date, location)
-                        if gaps:
-                            gap_text = ", ".join(gaps)
-                            html += f'<div class="operation-warning"><span class="warning-details">Missing: {gap_text}</span></div>'
-                    if checks[0] and missing_ages and location not in NO_AGE_CHECK_LOCATIONS:
-                        warning_text = f"Missing: {', '.join(missing_ages)}"
-                        html += f'<div class="warning"><span class="warning-details">{warning_text}</span></div>'
-                    if checks[3]:
-                        loc_ma_df = ma_df[(ma_df['Date'] == pd.to_datetime(date_key, format='%m/%d/%y')) &
-                                          (ma_df['Location'] == location)] if not ma_df.empty else pd.DataFrame()
-                        if not loc_ma_df.empty:
-                            loc_ma_df = loc_ma_df[
-                                ~((loc_ma_df['Start_Time'].isna()) &
-                                  (loc_ma_df['End_Time'].isna()) &
-                                  (loc_ma_df['Note'].isna() | (loc_ma_df['Note'] == '')))
-                            ]
-                            html += '<div class="event"><strong>MAs:</strong><br>'
-                            for _, row in loc_ma_df.iterrows():
-                                display_name = row['Name']
-                                time_str = get_time_string(row)
-                                style = "font-size: 7pt; margin: 1mm; line-height: 1.1; color: #000000;"
-                                if time_str in OFF_LST:
-                                    style += " text-decoration: line-through;"
-                                html += f'<span style="{style}">{display_name}: {time_str}</span><br>'
-                            html += '</div>'
-                            working_providers = len(loc_providers_df[
-                                loc_providers_df['Start_Time'].notna() &
-                                loc_providers_df['End_Time'].notna() &
-                                ~loc_providers_df['Note'].str.upper().fillna('').isin(OFF_LST)
-                            ])
-                            working_mas = len(loc_ma_df[
-                                loc_ma_df['Start_Time'].notna() &
-                                loc_ma_df['End_Time'].notna() &
-                                ~loc_ma_df['Note'].str.upper().fillna('').isin(OFF_LST)
-                            ])
-                            if not (working_mas == working_providers or working_mas == working_providers + 1):
-                                html += f'<div class="warning"><span class="warning-details">MA Mismatch: {working_mas} MAs for {working_providers} Providers</span></div>'
-            html += '</div>'
-    html += '</div>'
-    return html
-
-# ----------------------------------------------------------------------
-# Main Schedule Generator
-# ----------------------------------------------------------------------
 def combine_schedules(provider_info_file, provider_files, ma_files, start_date, end_date, check_age_coverage_flag, check_location_conflicts_flag, check_operation_coverage_flag, check_ma_mismatch_flag, show_weekly_hours, selected_locations):
     save_files([provider_info_file] if provider_info_file else [])
     save_files(provider_files if provider_files else [])
@@ -823,7 +855,7 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
     day_header_height = 10
     entry_height = 10
     num_locations = len(display_locations)
-    num_provider_files = len(provider_schedule_paths)
+    num_provider_files = len(providers_dfs)
     buffer_height = 200 + (num_locations * 20) + (num_provider_files * 25)
     week_entries = calculate_max_entries_per_day(providers_df, ma_df, start_obj, end_obj, display_locations, check_age_coverage_flag, check_location_conflicts_flag, check_operation_coverage_flag, check_ma_mismatch_flag, num_provider_files)
     if show_weekly_hours:
@@ -833,7 +865,7 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
             loc_providers = providers_df[providers_df['Location'] == location]['Name'].unique()
             loc_provider_info = provider_info_df[provider_info_df['Provider'].isin(loc_providers)]
             providers_per_location[location] = sorted(
-                [loc_provider_info[loc_provider_info['Provider'] == p]['Last_Name'].iloc[0] if not loc_provider_info[loc_provider_info['Provider'] == p].empty else p for p in loc_providers]
+                [provider_info_df[provider_info_df['Provider'] == p]['Last_Name'].iloc[0] if not provider_info_df[provider_info_df['Provider'] == p].empty else p for p in loc_providers]
             )
         max_providers = max([len(providers) for providers in providers_per_location.values()], default=0)
         hours_table_height = (len(weekly_hours) * (max_providers + 2) * entry_height) + 20
@@ -844,8 +876,8 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
         hours_table_height = 0
     a4_height = 842
     bmw_locations = [loc for loc in display_locations if loc in ['Berwyn', 'Morgan', 'Western']]
-    perform_overall_check = check_age_coverage_flag and num_provider_files > 1 and len(bmw_locations) > 1
-    perform_conflict_check = check_location_conflicts_flag and num_provider_files > 1 and len(display_locations) > 1
+    perform_overall_check = check_age_coverage_flag and len(providers_dfs) > 1 and len(bmw_locations) > 1
+    perform_conflict_check = check_location_conflicts_flag and len(providers_dfs) > 1 and len(display_locations) > 1
     locations_str = ", ".join(sorted(display_locations)) if display_locations else "No Locations"
     generation_time = datetime.now(CHICAGO_TZ).strftime('%I:%M %p CDT, %B %d, %Y')
     html_content = f"""
@@ -936,6 +968,7 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
                 flex-direction: column;
                 align-items: flex-start;
                 break-inside: avoid;
+                break-inside: avoid;
                 page-break-inside: avoid;
                 overflow-wrap: break-word;
                 line-height: 1.1;
@@ -1180,8 +1213,8 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
                         day_html += '<div class="event"><strong>Providers:</strong><br>'
                         missing_ages, full_age_providers, under_18_providers, over_18_providers, only_25_plus_providers = check_age_coverage(providers_df, loc_provider_info_df, location, pd.to_datetime(date_key, format='%m/%d/%y'))
                         for _, row in loc_providers_df.iterrows():
-                            provider_info = loc_provider_info_df[loc_provider_info_df['Provider'] == row['Name']]
-                            display_name = provider_info['Last_Name'].iloc[0] if not provider_info.empty else row['Name']
+                            provider_info_row = loc_provider_info_df[loc_provider_info_df['Provider'] == row['Name']]
+                            display_name = provider_info_row['Last_Name'].iloc[0] if not provider_info_row.empty else row['Name']
                             time_str = get_time_string(row)
                             style = "font-size: 7pt; margin: 1mm; line-height: 1.1;"
                             if row['Name'] in full_age_providers:
@@ -1552,23 +1585,27 @@ def combine_schedules(provider_info_file, provider_files, ma_files, start_date,
             shutil.copy(output_pdf_file, final_output_pdf)
         return html_content, final_output_file, final_output_pdf
 
-# ----------------------------------------------------------------------
-# UI – Full Gradio Interface
-# ----------------------------------------------------------------------
-def check_password(input_password):
-    correct_password = "alivio0000"  # Change this!
-    
-    if input_password == correct_password:
-        return gr.update(visible=False), gr.update(visible=True), "Access granted!"
+def check_password(pwd):
+    if pwd == "alivio0000":
+        return gr.update(visible=False), gr.update(visible=True), ""
     else:
         return gr.update(visible=True), gr.update(visible=False), "Incorrect password."
 
 def create_interface():
-    with gr.Blocks(title="Alivio Schedule Generator") as demo:
-        gr.Markdown("# Alivio Schedule Generator")
-        gr.Markdown("Enter password to unlock the tool.")
+    with gr.Blocks(title="Alivio Schedule Display") as demo:
+        gr.Markdown("# Alivio Schedule Display")
+        gr.Markdown("""
+        Upload the Provider Information Excel and at least one Provider Schedule Excel file. Files are stored persistently in the 'Uploads' directory. Schedules will be generated for the selected locations (or all locations if 'All Locations' is selected) found in the uploaded provider schedule files, displayed on a single calendar.
+        Providers are always displayed in different colors based on age coverage:
+        - <span style="color: #ff6347;">Red</span>: Covers all age groups (Newborn-5mo, 6mo-9yo, 10-17yo, 18-20yo, 21-24yo, 25+yo).
+        - <span style="color: #0000ff;">Blue</span>: Covers patients above 18 (18-20yo, 21-24yo, 25+yo).
+        - <span style="color: #008000;">Green</span>: Covers patients under 18 (Newborn-5mo, 6mo-9yo, 10-17yo).
+        - <span style="color: #8E44AD;">Purple</span>: Covers only patients above 25 (25+yo).
+        - Black: Other coverage combinations.
+        """)
         with gr.Column(visible=True) as password_section:
-            pwd_input = gr.Textbox(label="Enter Password", type="password")
+            gr.Markdown("## 🔐 Enter Password to Access the Main Function")
+            password_input = gr.Textbox(label="Enter Password", type="password")
             password_feedback = gr.Textbox(label="Status", interactive=False)
             password_button = gr.Button("Submit")
         with gr.Column(visible=False) as app_section:
@@ -1588,8 +1625,8 @@ def create_interface():
                 start_date = gr.Textbox(label="Start Date (e.g., 06/02/25 for June 2, 2025)", placeholder="e.g., 06/02/25")
                 end_date = gr.Textbox(label="End Date (e.g., 07/05/25 for July 5, 2025)", placeholder="e.g., 07/05/25")
             check_age_coverage = gr.Checkbox(label="Age Coverage Check", value=False)
-            check_location_conflicts = gr.Checkbox(label="Provider Location Conflict Check", value=True)
             check_operation_coverage = gr.Checkbox(label="Operation Hours Check", value=False)
+            check_location_conflicts = gr.Checkbox(label="Provider Location Conflict Check", value=True)
             check_ma_mismatch = gr.Checkbox(label="Staffing Ratio Check", value=False)
             show_weekly_hours = gr.Checkbox(label="Provider Hours Summary", value=False)
             location_selector = gr.CheckboxGroup(label="Select Locations to Display", choices=AVAILABLE_LOCATIONS, value=['All Locations'])
@@ -1608,9 +1645,10 @@ def create_interface():
                 inputs=[provider_info_file, provider_files, ma_files, start_date, end_date, check_age_coverage, check_location_conflicts, check_operation_coverage, check_ma_mismatch, show_weekly_hours, location_selector],
                 outputs=[output, download_html, download_pdf]
             )
-        password_button.click(fn=check_password, inputs=pwd_input, outputs=[password_section, app_section, password_feedback])
+        password_button.click(fn=check_password, inputs=password_input, outputs=[password_section, app_section, password_feedback])
     return demo
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch()
+    demo.launch()
+