import datetime import gradio as gr import itertools import numpy as np import os import pandas as pd import re from collections import defaultdict def convert_date(d): return datetime.datetime.strptime(str(d), "%B %d, %Y").date() def main(files): available_files = [] fname_dict = {os.path.basename(f).split(".")[0]: f for f in files} for fname, fpath in fname_dict.items(): available_files.append(fname) if fname == "qgenda_schedule": schedule = pd.read_excel(fpath, header=None) elif fname == "info": core_rotations = pd.read_excel(fpath, sheet_name="Core Rotations", header=None) call_rotations = pd.read_excel(fpath, sheet_name="Call Rotations", header=None) holidays = pd.read_excel(fpath, sheet_name="Holidays", header=None) pto = pd.read_excel(fpath, sheet_name="PTO", header=None) academic_years = pd.read_excel(fpath, sheet_name="AYs") call_shifts = pd.read_excel(fpath, sheet_name="Weekend Call Shifts", header=None) roster = pd.read_excel(fpath, sheet_name="Resident Roster") assert all(x in ["qgenda_schedule", "info"] for x in available_files) # -- for debugging, load files from disk -- # Load in all files # schedule = pd.read_excel("key_files/qgenda_schedule.xlsx", header=None) # remove first 3 rows # core_rotations = pd.read_excel("key_files/rotations.xlsx", sheet_name="core", header=None) # call_rotations = pd.read_excel("key_files/rotations.xlsx", sheet_name="call", header=None) # holidays = pd.read_excel("key_files/holidays.xlsx", header=None) # pto = pd.read_excel("key_files/pto.xlsx", header=None) # academic_years = pd.read_excel("key_files/academic_years.xlsx") # call_shifts = pd.read_excel("key_files/call_shifts.xlsx", header=None) # roster = pd.read_excel("key_files/resident_roster.xlsx") # -- schedule = schedule.iloc[3:].reset_index(drop=True) # remove first 3 rows core_rotations = core_rotations.iloc[:, 0].tolist() call_rotations = call_rotations.iloc[:, 0].tolist() holidays = [_.date() for _ in holidays.iloc[:, 0].tolist()] pto = pto.iloc[:, 0].tolist() call_shifts = call_shifts.iloc[:, 0].tolist() # remove stuff at the bottom try: try: last_row = schedule.iloc[:, 0].tolist().index("Schedule Notes:") except ValueError: last_row = schedule.iloc[:, 0].tolist().index("Phone Numbers") except ValueError: last_row = len(schedule) + 1 schedule = schedule.iloc[:last_row].reset_index(drop=True) # remove days of week rows remove_rows = [] for idx, i in enumerate(schedule.iloc[:, 0].tolist()): if i == "Sunday": remove_rows.append(idx) schedule = schedule.drop(remove_rows).reset_index(drop=True) # split the schedule by weeks sundays, week_rows = [], [] for idx, i in enumerate(schedule.iloc[:, 0].tolist()): try: tmp_date = convert_date(i) sundays.append(tmp_date) week_rows.append(idx) except ValueError: continue weekly_schedule = {} for idx, each_sunday in enumerate(sundays): if idx == len(sundays) - 1: weekly_schedule[each_sunday] = schedule.iloc[week_rows[idx]:].reset_index(drop=True) else: weekly_schedule[each_sunday] = schedule.iloc[week_rows[idx]:week_rows[idx+1]].reset_index(drop=True) daily_schedule = {} for each_week, each_schedule in weekly_schedule.items(): tmp_daily_schedule = {} list_by_day = [each_schedule.iloc[:, idx:idx+2] for idx in range(0, each_schedule.shape[1], 2)] for each_day in list_by_day: tmp_date = convert_date(each_day.iloc[0, 0]) tmp_daily_schedule[tmp_date] = defaultdict(list) tmp_residents, tmp_tasks = each_day.iloc[1:, 0].tolist(), each_day.iloc[1:, 1].tolist() tmp_tasks = [re.sub(r" \([A-Z]+\)", "", str(_)) for _ in tmp_tasks] # PTO supersedes everything else, meaning if you have a PTO task then all other tasks are void pto_residents = [] for resident, task in zip(tmp_residents, tmp_tasks): if task in pto: pto_residents.append(resident) for resident, task in zip(tmp_residents, tmp_tasks): if str(resident) == "nan" or resident in pto_residents: if task not in pto: continue if tmp_date.weekday() in [5, 6] and task in core_rotations + holidays: continue tmp_daily_schedule[tmp_date][resident].append(task) daily_schedule.update(tmp_daily_schedule) weekly_schedule_with_tasks = {} for each_week, each_schedule in weekly_schedule.items(): tmp_weekly_schedule = {} tmp_weekly_schedule[each_week] = defaultdict(list) list_by_day = [each_schedule.iloc[:, idx:idx+2] for idx in range(0, each_schedule.shape[1], 2)] for each_day in list_by_day: tmp_date = convert_date(each_day.iloc[0, 0]) tmp_residents, tmp_tasks = each_day.iloc[1:, 0].tolist(), each_day.iloc[1:, 1].tolist() tmp_tasks = [re.sub(r" \([A-Z]+\)", "", str(_)) for _ in tmp_tasks] pto_residents = [] for resident, task in zip(tmp_residents, tmp_tasks): if task in pto: pto_residents.append(resident) for resident, task in zip(tmp_residents, tmp_tasks): if str(resident) == "nan" or resident in pto_residents: continue task = re.sub(r" \([A-Z]+\)", "", task) if tmp_date.weekday() in [5, 6] and task in core_rotations: continue tmp_weekly_schedule[each_week][resident].append(task) weekly_schedule_with_tasks.update(tmp_weekly_schedule) # create a calendar for each resident resident_calendar = defaultdict(dict) for tmp_date, resident_dict in daily_schedule.items(): for resident_name, tasks in resident_dict.items(): resident_calendar[resident_name][tmp_date] = tasks resident_weekly_calendar = defaultdict(dict) for tmp_week, resident_dict in weekly_schedule_with_tasks.items(): for resident_name, tasks in resident_dict.items(): resident_weekly_calendar[resident_name][tmp_week] = tasks # count number of weeks for each core rotation resident_core_rotation_tallies = {} for row_idx, row in academic_years.iterrows(): # need to subtract 1 day from start since it is a Monday and ED/NF/Consult start on Sunday so will affect # those who start at the beginning of the year start, stop = row["Start"].date() - datetime.timedelta(days=1), row["Stop"].date() ay = row["Year"] resident_core_rotation_tallies[ay] = defaultdict(dict) for resident_name, calendar in resident_weekly_calendar.items(): tmp_rotation_counts = defaultdict(list) tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_week, weekly_tasks in tmp_calendar.items(): tmp_tasks, tmp_counts = np.unique(weekly_tasks, return_counts=True) tmp_task_counts = {k: v for k, v in zip(tmp_tasks, tmp_counts)} for k, v in tmp_task_counts.items(): if k in core_rotations and v >= 3: tmp_rotation_counts[k].append(1) tmp_rotation_counts = {k: np.sum(v) for k, v in tmp_rotation_counts.items()} for each_core_rotation in core_rotations: if each_core_rotation not in tmp_rotation_counts: tmp_rotation_counts[each_core_rotation] = 0 resident_core_rotation_tallies[ay][resident_name] = tmp_rotation_counts for each_ay, each_resident_dict in resident_core_rotation_tallies.items(): for each_resident, resident_rotation_counts in each_resident_dict.items(): resident_rotation_counts["Total Nucs"] = resident_rotation_counts["Nucs"] + resident_rotation_counts["CV Nucs"] # it's easier to keep track of NF, consult by days rather than weeks due to potential random swaps, sick call, and split weeks # also keep track of nucs days since for nucs time requirements days may be more important than weeks resident_rotations_by_days = {} for row_idx, row in academic_years.iterrows(): # need to subtract 1 day from start since it is a Monday and ED/NF/Consult start on Sunday so will affect # those who start at the beginning of the year start, stop = row["Start"].date() - datetime.timedelta(days=1), row["Stop"].date() ay = row["Year"] resident_rotations_by_days[ay] = defaultdict(dict) for resident_name, calendar in resident_weekly_calendar.items(): tmp_rotation_counts = defaultdict(list) tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_week, weekly_tasks in tmp_calendar.items(): tmp_tasks, tmp_counts = np.unique(weekly_tasks, return_counts=True) tmp_task_counts = {k: v for k, v in zip(tmp_tasks, tmp_counts)} for k, v in tmp_task_counts.items(): if k in core_rotations + call_rotations: tmp_rotation_counts[k].append(v) tmp_rotation_counts = {k: np.sum(v) for k, v in tmp_rotation_counts.items()} for each_core_rotation in core_rotations + call_rotations: if each_core_rotation not in tmp_rotation_counts: tmp_rotation_counts[each_core_rotation] = 0 resident_rotations_by_days[ay][resident_name] = tmp_rotation_counts for each_ay, each_resident_dict in resident_rotations_by_days.items(): for each_resident, resident_rotation_counts in each_resident_dict.items(): resident_rotation_counts["Total Nucs"] = resident_rotation_counts["Nucs"] + resident_rotation_counts["CV Nucs"] for each_ay, each_resident_dict in resident_rotations_by_days.items(): for each_resident, resident_rotation_counts in each_resident_dict.items(): resident_core_rotation_tallies[each_ay][each_resident]["ED"] = int(np.round(resident_rotation_counts["ED"] / 6)) resident_core_rotation_tallies[each_ay][each_resident]["Consult"] = int(np.round(resident_rotation_counts["Consult"] / 6)) resident_core_rotation_tallies[each_ay][each_resident]["NF"] = int(np.round(resident_rotation_counts["NF"] / 6)) # count weekend call shifts (Sat Consult, Sat NF, In-House, Sat EDD) # does not include Sundays from NF, consult, ED rotation or Angio/IR call) call_shifts_worked = {} for row_idx, row in academic_years.iterrows(): # note here we do NOT subtract 1 day from start because if you are assigned to Sunday in-house shift # prior to AY start it counts for the that AY start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] call_shifts_worked[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): # use daily calendar tmp_call_shifts = defaultdict(list) tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_day, daily_tasks in tmp_calendar.items(): for each_task in daily_tasks: if each_task in call_shifts: tmp_call_shifts[each_task].append(1) tmp_call_shifts = {k: np.sum(v) for k, v in tmp_call_shifts.items()} for each_call_shift in call_shifts: if each_call_shift not in tmp_call_shifts: tmp_call_shifts[each_call_shift] = 0 call_shifts_worked[ay][resident_name] = tmp_call_shifts # count holidays worked (call shifts only) # differentiates between working on the actual holiday and holiday weekend def count_holidays_worked(which_holidays): holidays_worked = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] holidays_worked[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_holidays = [] tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop and k in which_holidays} for each_holiday, daily_tasks in tmp_calendar.items(): for each_task in daily_tasks: if each_task in call_rotations + call_shifts: tmp_holidays.append(1) break # if stack shifts, break so it doesn't double count holidays_worked[ay][resident_name] = int(np.sum(tmp_holidays)) return holidays_worked holidays_worked = count_holidays_worked(holidays) # identify which holidays are Christmas, New Years, and Thanksgiving # Thanksgiving is the only holiday in November thanksgiving = [_ for _ in holidays if _.month == 11] # consider observed dates as well christmas = [_ for _ in holidays if _.month == 12 and abs(int((datetime.date(_.year, 12, 25) - _).days)) < 2] new_years_candidates = [datetime.date(2000, 1, 1), datetime.date(2000, 12, 31), datetime.date(2000, 1, 2)] new_years = [] for _ in holidays: if _.month == 1 and _.day in [1, 2] or _.month == 12 and _.day == 31: new_years.append(_) thanksgiving_worked = count_holidays_worked(thanksgiving) christmas_worked = count_holidays_worked(christmas) new_years_worked = count_holidays_worked(new_years) # also count weekends for Thanksgiving, Christmas, New Years # if you work more than one day for a weekend, it will count for more than 1 # since thanksgiving is always Thurs, it's easy... thanksgiving_weekend = [] for each_thanksgiving in thanksgiving: tmp_weekend = [] for each_day in [*daily_schedule]: if int((each_day - each_thanksgiving).days) in [2, 3]: assert each_day.weekday() in [5, 6] tmp_weekend.append(each_day) thanksgiving_weekend.append(tmp_weekend) # Christmas/NY a bit trickier # first identify the Christmas and New Year's holiday weeks (AKA which weeks contain the observed holiday) # remember- the week start always precedes the holiday # make dict where key is week and value is all days in that week weeks_dict = {} for each_week in [*weekly_schedule]: # week starts on Sunday assert each_week.weekday() == 6 weeks_dict[each_week] = [each_week + datetime.timedelta(days=_) for _ in range(7)] assert len(weeks_dict[each_week]) == 7 # there are 3 weekends here- weekend before Xmas holiday week, weekend in between, weekend after New Year's holiday week # technically the middle one is the worst # also for some people they may have Xmas holiday week off but then work weekend after New Year's holiday week # which is really not that bad, but this is annoying to take into account so will just treat them all the same christmas_weeks, new_years_weeks = [], [] for each_week, days_in_week in weeks_dict.items(): if len(list(set(days_in_week) & set(christmas))) > 0: christmas_weeks.append(each_week) if len(list(set(days_in_week) & set(new_years))) > 0: new_years_weeks.append(each_week) christmas_new_years_weekend = [] for each_week in christmas_weeks: christmas_new_years_weekend.append([each_week, each_week - datetime.timedelta(days=1)]) # Sunday for each_week in new_years_weeks: christmas_new_years_weekend.append([each_week, each_week - datetime.timedelta(days=1)]) christmas_new_years_weekend.append([each_week + datetime.timedelta(days=7), each_week + datetime.timedelta(days=6)]) def count_holiday_weekends_worked(which_holidays): holidays_worked = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] holidays_worked[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_holidays = [] tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop and k in list(itertools.chain(*which_holidays))} tmp_weekend_task_dict = defaultdict(list) for idx, each_weekend in enumerate(which_holidays): for each_day, daily_tasks in tmp_calendar.items(): if each_day in each_weekend: tmp_weekend_task_dict[idx].extend(daily_tasks) for each_weekend, weekend_tasks in tmp_weekend_task_dict.items(): for each_task in weekend_tasks: if each_task in call_rotations + call_shifts: tmp_holidays.append(1) break holidays_worked[ay][resident_name] = int(np.sum(tmp_holidays)) return holidays_worked thanksgiving_weekends_worked = count_holiday_weekends_worked(thanksgiving_weekend) christmas_new_years_weekends_worked = count_holiday_weekends_worked(christmas_new_years_weekend) # Count PTO days pto_days = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] pto_days[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): # use daily calendar tmp_pto_days = defaultdict(list) tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} in_house_days = 0 for each_day, daily_tasks in tmp_calendar.items(): # doesn't count if weekend or holiday for each_task in daily_tasks: if each_task in pto and each_day.weekday() not in [5, 6]: if each_task == "LOA": # Easier to see how many LOA weeks if we just include holidays tmp_pto_days[each_task].append(1) elif each_task != "LOA" and each_day not in holidays: tmp_pto_days[each_task].append(1) if each_task == "In-House": in_house_days += 1 tmp_pto_days = {k: np.sum(v) for k, v in tmp_pto_days.items()} # treat VACATION and HOLIDAY the same then subtract in house days for pto_day_type in pto: if pto_day_type not in tmp_pto_days: tmp_pto_days[pto_day_type] = 0 tmp_pto_days["VACATION"] = tmp_pto_days["VACATION"] + tmp_pto_days["HOLIDAY"] - in_house_days _ = tmp_pto_days.pop("HOLIDAY") pto_days[ay][resident_name] = tmp_pto_days # Count sick call sick_call_weekdays = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] sick_call_weekdays[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_sick_call_weekdays = [] tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_day, daily_tasks in tmp_calendar.items(): if each_day.weekday() not in [0, 1, 2, 3]: # Mon-Thurs only continue if "Sick Call" in daily_tasks: tmp_sick_call_weekdays.append(1) sick_call_weekdays[ay][resident_name] = int(np.round(np.sum(tmp_sick_call_weekdays) / 4)) sick_call_weekends = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] sick_call_weekends[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_sick_call_weekends = [] tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_day, daily_tasks in tmp_calendar.items(): if each_day.weekday() not in [4, 5, 6]: # Fri-Sun only continue if "Sick Call" in daily_tasks: tmp_sick_call_weekends.append(1) sick_call_weekends[ay][resident_name] = int(np.round(np.sum(tmp_sick_call_weekends) / 3)) sick_call_holidays = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] sick_call_holidays[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_sick_call_holidays = [] tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_day, daily_tasks in tmp_calendar.items(): if each_day not in holidays: continue if "Sick Call" in daily_tasks: tmp_sick_call_holidays.append(1) sick_call_holidays[ay][resident_name] = int(np.sum(tmp_sick_call_holidays)) sick_call_major_holidays = {} for row_idx, row in academic_years.iterrows(): start, stop = row["Start"].date(), row["Stop"].date() ay = row["Year"] sick_call_major_holidays[ay] = defaultdict(dict) for resident_name, calendar in resident_calendar.items(): tmp_sick_call_major_holidays = defaultdict(list) tmp_calendar = {k: v for k, v in calendar.items() if k >= start and k < stop} for each_day, daily_tasks in tmp_calendar.items(): if each_day not in thanksgiving + christmas + new_years: continue if "Sick Call" in daily_tasks: if each_day in thanksgiving: tmp_sick_call_major_holidays["Thanksgiving"].append(1) elif each_day in christmas: tmp_sick_call_major_holidays["Xmas"].append(1) elif each_day in new_years: tmp_sick_call_major_holidays["NY"].append(1) for each_major_holiday in ["Thanksgiving", "Xmas", "NY"]: if each_major_holiday not in tmp_sick_call_major_holidays: tmp_sick_call_major_holidays[each_major_holiday] = 0 for k, v in tmp_sick_call_major_holidays.items(): tmp_sick_call_major_holidays[k] = int(np.sum(v)) sick_call_major_holidays[ay][resident_name] = tmp_sick_call_major_holidays sick_call_combined = sick_call_major_holidays.copy() for ay, residents in sick_call_combined.items(): for resident_name, resident_dict in residents.items(): sick_call_combined[ay][resident_name]["Weekdays"] = sick_call_weekdays[ay][resident_name] sick_call_combined[ay][resident_name]["Weekends"] = sick_call_weekends[ay][resident_name] sick_call_combined[ay][resident_name]["Holidays"] = sick_call_holidays[ay][resident_name] # Eliminate residents from years they were not a resident yet for each_ay, each_resident_dict in resident_core_rotation_tallies.copy().items(): for each_resident, resident_rotation_dict in each_resident_dict.copy().items(): if np.sum(list(resident_rotation_dict.values())) == 0: _ = resident_core_rotation_tallies[each_ay].pop(each_resident) classes = defaultdict(list) for row_idx, row in roster.iterrows(): classes[row.Year].append(row.Resident) ###################################################### # CREATE EXCEL SPREADSHEET FOR CORE ROTATION TALLIES # ###################################################### core_rotation_tallies_by_class = {} for each_class, residents in classes.items(): core_rotation_tallies_by_class[each_class] = {} for each_resident in residents: tmp_df_list = [] for each_ay, ay_tallies in resident_core_rotation_tallies.items(): if each_resident not in ay_tallies: continue tmp_df = pd.DataFrame(ay_tallies[each_resident], index=[0]) tmp_df["Year"] = each_ay tmp_df_list.append(tmp_df) tmp_df = pd.concat(tmp_df_list) tmp_total = dict(tmp_df.sum()) tmp_total["Year"] = "Total" filler = {k: "" for k in [*tmp_total]} filler = pd.DataFrame(filler, index=[0]) tmp_df = pd.concat([tmp_df, pd.DataFrame(tmp_total, index=[0]), filler]) tmp_df["Resident"] = [each_resident] + [""] * (len(tmp_df) - 1) tmp_df = tmp_df[["Resident", "Year"] + list(tmp_df.columns[:-2])] core_rotation_tallies_by_class[each_class][each_resident] = tmp_df core_rotation_tallies_df_by_class = {} for each_class in [*core_rotation_tallies_by_class]: core_rotation_tallies_df_by_class[each_class] = pd.concat(list(core_rotation_tallies_by_class[each_class].values())) #################################################### # CREATE EXCEL SPREADSHEET FOR WEEKEND CALL SHIFTS # #################################################### weekend_call_shifts_by_class = {} for each_class, residents in classes.items(): weekend_call_shifts_by_class[each_class] = {} for each_resident in residents: tmp_df_list = [] for each_ay, ay_tallies in call_shifts_worked.items(): if each_resident not in ay_tallies: continue tmp_df = pd.DataFrame(ay_tallies[each_resident], index=[0]) tmp_df["Year"] = each_ay tmp_df_list.append(tmp_df) tmp_df = pd.concat(tmp_df_list) tmp_total = dict(tmp_df.sum()) tmp_total["Year"] = "Total" filler = {k: "" for k in [*tmp_total]} filler = pd.DataFrame(filler, index=[0]) tmp_df = pd.concat([tmp_df, pd.DataFrame(tmp_total, index=[0]), filler]) tmp_df["Resident"] = [each_resident] + [""] * (len(tmp_df) - 1) tmp_df = tmp_df[["Resident", "Year"] + list(tmp_df.columns[:-2])] weekend_call_shifts_by_class[each_class][each_resident] = tmp_df weekend_call_shifts_df_by_class = {} for each_class in [*weekend_call_shifts_by_class]: weekend_call_shifts_df_by_class[each_class] = pd.concat(list(weekend_call_shifts_by_class[each_class].values())) weekend_call_shifts_df = pd.concat([v for k, v in weekend_call_shifts_df_by_class.items()]) ################################################# # CREATE EXCEL SPREADSHEET FOR SICK CALL SHIFTS # ################################################# sick_call_by_class = {} for each_class, residents in classes.items(): sick_call_by_class[each_class] = {} for each_resident in residents: tmp_df_list = [] for each_ay, ay_tallies in sick_call_combined.items(): if each_resident not in ay_tallies: continue tmp_df = pd.DataFrame(ay_tallies[each_resident], index=[0]) tmp_df = tmp_df[["Weekdays", "Weekends", "Holidays", "Thanksgiving", "Xmas", "NY"]] tmp_df["Year"] = each_ay tmp_df_list.append(tmp_df) tmp_df = pd.concat(tmp_df_list) tmp_total = dict(tmp_df.sum()) tmp_total["Year"] = "Total" filler = {k: "" for k in [*tmp_total]} filler = pd.DataFrame(filler, index=[0]) tmp_df = pd.concat([tmp_df, pd.DataFrame(tmp_total, index=[0]), filler]) tmp_df["Resident"] = [each_resident] + [""] * (len(tmp_df) - 1) tmp_df = tmp_df[["Resident", "Year"] + list(tmp_df.columns[:-2])] sick_call_by_class[each_class][each_resident] = tmp_df sick_call_df_by_class = {} for each_class in [*sick_call_by_class]: sick_call_df_by_class[each_class] = pd.concat(list(sick_call_by_class[each_class].values())) sick_call_df = pd.concat([v for k, v in sick_call_df_by_class.items()]) ######################################### # CREATE EXCEL SPREADSHEET FOR PTO DAYS # ######################################### pto_by_class = {} for each_class, residents in classes.items(): pto_by_class[each_class] = {} for each_resident in residents: tmp_df_list = [] for each_ay, ay_pto in pto_days.items(): if each_resident not in ay_tallies: continue tmp_df = pd.DataFrame(ay_pto[each_resident], index=[0]) tmp_df["Total (Days)"] = tmp_df.sum(1) tmp_df["Total (Weeks)"] = np.round(tmp_df["Total (Days)"] / 5).astype("int") tmp_df["Year"] = each_ay tmp_df_list.append(tmp_df) tmp_df = pd.concat(tmp_df_list) tmp_total = dict(tmp_df.sum()) tmp_total["Year"] = "Total" filler = {k: "" for k in [*tmp_total]} filler = pd.DataFrame(filler, index=[0]) tmp_df = pd.concat([tmp_df, pd.DataFrame(tmp_total, index=[0]), filler]) tmp_df["Resident"] = [each_resident] + [""] * (len(tmp_df) - 1) tmp_df = tmp_df[["Resident", "Year"] + list(tmp_df.columns[:-2])] pto_by_class[each_class][each_resident] = tmp_df pto_df_by_class = {} for each_class in [*pto_by_class]: pto_df_by_class[each_class] = pd.concat(list(pto_by_class[each_class].values())) pto_df = pd.concat([v for k, v in pto_df_by_class.items()]) ######################################### # CREATE EXCEL SPREADSHEET FOR HOLIDAYS # ######################################### # first, combine the separate holiday dicts into 1... combined_holidays = {} for each_ay, residents in holidays_worked.items(): combined_holidays[each_ay] = defaultdict(dict) for resident_name, resident_dict in residents.items(): combined_holidays[each_ay][resident_name] = { "All Holidays": holidays_worked[each_ay][resident_name], "Thanksgiving": thanksgiving_worked[each_ay][resident_name], "Xmas": christmas_worked[each_ay][resident_name], "NY": new_years_worked[each_ay][resident_name], "Thanksgiving Weekend": thanksgiving_weekends_worked[each_ay][resident_name], "Xmas/NY Weekend": christmas_new_years_weekends_worked[each_ay][resident_name] } holidays_by_class = {} for each_class, residents in classes.items(): holidays_by_class[each_class] = {} for each_resident in residents: tmp_df_list = [] for each_ay, ay_holidays in combined_holidays.items(): if each_resident not in ay_holidays: continue tmp_df = pd.DataFrame(ay_holidays[each_resident], index=[0]) tmp_df["Year"] = each_ay tmp_df_list.append(tmp_df) tmp_df = pd.concat(tmp_df_list) tmp_total = dict(tmp_df.sum()) tmp_total["Year"] = "Total" filler = {k: "" for k in [*tmp_total]} filler = pd.DataFrame(filler, index=[0]) tmp_df = pd.concat([tmp_df, pd.DataFrame(tmp_total, index=[0]), filler]) tmp_df["Resident"] = [each_resident] + [""] * (len(tmp_df) - 1) tmp_df = tmp_df[["Resident", "Year"] + list(tmp_df.columns[:-2])] holidays_by_class[each_class][each_resident] = tmp_df holidays_df_by_class = {} for each_class in [*holidays_by_class]: holidays_df_by_class[each_class] = pd.concat(list(holidays_by_class[each_class].values())) holidays_df = pd.concat([v for k, v in holidays_df_by_class.items()]) with pd.ExcelWriter("all_tallies.xlsx") as writer: for each_class, each_df in core_rotation_tallies_df_by_class.items(): each_df.to_excel(writer, sheet_name=f"R{each_class}", index=False) pto_df.to_excel(writer, sheet_name="PTO", index=False) weekend_call_shifts_df.to_excel(writer, sheet_name=f"Call Shifts", index=False) sick_call_df.to_excel(writer, sheet_name=f"Sick Call", index=False) holidays_df.to_excel(writer, sheet_name="Holidays", index=False) return "all_tallies.xlsx" demo = gr.Interface( fn=main, inputs=gr.File(file_count="multiple"), outputs="file") if __name__ == "__main__": demo.launch()