initial commit

app.py

@@ -0,0 +1,652 @@
+
+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 == "rotations":
+            core_rotations = pd.read_excel(fpath, sheet_name="core", header=None)
+            call_rotations = pd.read_excel(fpath, sheet_name="call", header=None)
+        elif fname == "holidays":
+            holidays = pd.read_excel(fpath, header=None)
+        elif fname == "pto":
+            pto = pd.read_excel(fpath, header=None)
+        elif fname == "academic_years":
+            academic_years = pd.read_excel(fpath)
+        elif fname == "call_shifts":
+            call_shifts = pd.read_excel(fpath, header=None)
+        elif fname == "resident_roster":
+            roster = pd.read_excel(fpath)
+    assert all(x in ["qgenda_schedule", "rotations", "holidays", "pto", "academic_years", "call_shifts", "resident_roster"] 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:
+        last_row = schedule.iloc[:, 0].tolist().index("Schedule Notes:")
+    except ValueError:
+        last_row = schedule.iloc[:, 0].tolist().index("Phone Numbers")
+
+
+    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()
+
+
+
+
+

requirements.txt

@@ -0,0 +1,2 @@
+pandas
+openpyxl