SchedBuilderClasses2.py

from copy import deepcopy
from ctypes.wintypes import WPARAM
import openpyxl as pyxl
import functools
import SchedBuilderUtyModule as tls
# from importlib import reload

def debug(func):
    """Print the function signature and return value"""
    @functools.wraps(func)
    def wrapper_debug(*args, **kwargs):
        args_repr = [repr(a) for a in args]                      # 1
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]  # 2
        signature = ", ".join(args_repr + kwargs_repr)           # 3
        print(f"Calling {func.__name__}({signature})")
        value = func(*args, **kwargs)
        print(f"{func.__name__!r} returned {value!r}")           # 4
        return value
    return wrapper_debug


class Slot():
    """A single 4 hour time slot for a single job, to be filled by 1 person"""
    def __init__(self,seqID,dispNm,trnNm=None):
        self.trnNm=trnNm #to be used when filtering out staff for training
        self.dispNm=dispNm #to be used for printouts
        self.seqID=seqID
        #self.datetime=   #Determined based on seq. Used in printout of assignments
        self.assignee=None #To store eeid of assignee for printout
        self.assnType=None #e.g. Forced/WWF
        self.slotInShift=0 #1 if first slot in someones shift. 2 if second, etc.
        self.totSlotsInShift=0 # 1 if 4 hours shift, 2 if 8 hour shift, 3 if 12 hour shift
        self.eligVol=0 #This will be used to track which slot is the most constrained...it tracks the count of how many people eligible volunteers this slot has going for it
        self.disallowed=[] #EEID's that were specified as not allowed to be assigned to this slot in the Assn List

    def key(self):
        return str(self.seqID)+'_'+self.dispNm
    
    def assn(self,sch,assnType=None,slAssignee=None,fromList=False):
        """Assign a slot to someone, and perform associated variable tracking etc. Returns a bool indicating if a forcing rule was broken or not"""
        if (slAssignee is not None) and assnType=='DNS': #Case that this is specifying *not* to assign someone. In every other case it is a matter of actually assigning someone 
            self.disallowed.append(slAssignee)
        else:
            self.assnType=assnType
            self.assignee=slAssignee #eeid
            if assnType in ['WWF','F','V']:
                pass
                # del sch.slots[self.key()] #Remove this slot from the 'openslots' collection if someone was actually assigned
                # #del sch.slots[self.key()]
                # del sch.fslots[self.key()]
            elif assnType=='nV':
                pass
                #del sch.slots[self.key()]
            if slAssignee is not None: #Case of specific assignment, only not follwoed through when its no ee and DNS
                sch.ee[slAssignee].assnBookKeeping(self,sch) #add this slot to the ee's assigned slot dictionary & other tasks
                sch.assignments+=1
                sch.aOnly.append((sch.assignments,sch.ee[slAssignee].dispNm(),self.key(),assnType))
                
        #Logging for printout after
        if assnType!=None and slAssignee!=None:
            logTxt=''
            if fromList==True:
                logTxt+= 'Per Assn List: '
            if assnType=='DNS':
                logTxt+='Removed slot '+self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+') from scheduling'
                if slAssignee is not None: logTxt+= ' for ee '+ sch.ee[slAssignee].firstNm[0]+'. '+sch.ee[slAssignee].lastNm
            elif assnType=='WWF': logTxt+="WWF Assignment: "+sch.ee[slAssignee].firstNm[0]+'. '+sch.ee[slAssignee].lastNm+' to ' +self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+')'
            elif assnType=='F': logTxt+="   FORCED Assignment: "+ sch.ee[slAssignee].firstNm[0]+'. '+sch.ee[slAssignee].lastNm+ ' to ' +self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+')'
            elif assnType=='V': logTxt+="   Voluntary Assignment: "+ sch.ee[slAssignee].firstNm[0]+'. '+sch.ee[slAssignee].lastNm+' to ' +self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+')'
            elif assnType=='N':logTxt+="   No voluntary or forced assignment could be made to "+self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+')'
            elif assnType=='nV':logTxt+="   No voluntary assignment could be made to "+self.dispNm+' '+ sch.slLeg[self.seqID-1][2]+' ('+sch.slLeg[self.seqID-1][1]+')'
            sch.assnLog.append(logTxt)
        if slAssignee!=None and assnType in ['V','F']: #Check if assignment breaks forcing rules
            if sch.ee[slAssignee].frcOK(sch)!=True: #Case that the assignment broke a forcing rule... that slot needs be earlier priority.
                return False
        return True

class ee():
    """A staff persons data as related to weekend scheduling"""
    def __init__(self,snty,crew,id,Last,First,refHrs,wkHrs,wkndHrs=0,skills=[]):
        self.seniority=int(snty)
        if refHrs==None:
            self.refHrs=0
        else:
            self.refHrs=float(refHrs)
        if crew=='wwf':self.wkdyHrs=0
        else: self.wkdyHrs=float(wkHrs)
        self.wkndHrs=float(wkndHrs)
        self.frcHrs=0
        self.lastNm=Last
        self.firstNm=First
        self.eeID=int(id)
        self.crew=crew
        self.assignments=[]#To be appended with slots as they are assigned, keyed as they are in the slot dictionary
        self.skills=skills 
    
    def dispNm(self,slt=None):
        if slt is None:
            if int(self.seniority)>50000: return self.firstNm[0]+'.'+self.lastNm[0]+self.lastNm[1:].lower()+'(T)' #Case of Temps
            else: return (self.firstNm[0]+'.'+self.lastNm[0]+self.lastNm[1:].lower()).replace(' ','-')
        # elif : #Can make functionality to pass in 'MESR' to display name based on some slot criteria?
            # pass
        elif slt=='read':
            return (self.firstNm[0]+'.'+self.lastNm[0]+self.lastNm[1:].lower()).replace(' ','-')

    def frcOK(self,sch):
        """Returns if the present assignments are permissible with rules around forcing limitations"""
        #Used after making assignments to check if need make a slot priority or not
        asn=sorted(self.assignments,key=lambda k:int(k[:k.index('_')])) #Order assignment keys by their slot ID's
        h=self.wkdyHrs #initialize tally
        for k in asn: #For each slot, considering the hours worked upon completion of that workslot
            h+=4
            if h>48 and sch.slots[k].assnType=='F': return False #Forcing rules broken, if condition is met then forcing past 48 hours in week
        return True #if the above condition not met.. all good    

    def frcOKdblAssn(self,sch,sl):
        """Acts as if 2 slots are to be assigned (phase 1v3) and checks if previously made forcing,sched'd later in time, not ok with that"""
        #Used after making assignments to check if need make a slot priority or not
        if self.frcHrs==0: return True
        asn=sorted(self.assignments,key=lambda k:int(k[:k.index('_')])) #Order assignment keys by their slot ID's
        h=self.wkdyHrs #initialize tally
        c=0 #Tracks if the extra 8 have already been applied
        for k in asn: #For each slot, considering the hours worked upon completion of that workslot
            h+=4
            if c==0 and int(k[:k.index("_")])>sl.seqID: #Branch taken first time seeing a slot later in time than the 8 being tested
                h+=8 #Pretend 2 slots assigned
                c=1 #So this doesn't keep getting reapplied every time moving forward
            if h>48 and sch.slots[k].assnType=='F': return False #Forcing rules broken, if condition is met then forcing past 48 hours in week
        return True #if the above condition not met.. all good    

    def assnBookKeeping(self,sl,sch):
        """Carried out when assigned to slot, adjusts tally of eligible volunteers to other slots accordingly"""
        self.assignments.append(sl.key())
        if sl.assnType=='F': self.frcHrs+=4 #Track forced hours
        if sl.assnType!='WWF': self.wkndHrs+=4 #Don't track wwf hours as weekend hours because then it goes over 60 and they dont get any voluntary OT
        #   Return keys for slots that the person was counted as an eligible volunteer for
        kys=[k for k in sch.slots if self.eeID in sch.slots[k].eligVol]
        for k in kys:
            if self.slOK(sch,sch.slots[k],pt=False,poll=tls.viewTBL('allPollData',filterOn=[('eeid',self.eeID)])[0]) is not True: sch.slots[k].eligVol.pop(sch.slots[k].eligVol.index(self.eeID)) 
            #pop the eeId out of eligVol list if the given slot is no longer ok to assign
        #The slOK function does not capture if making a voluntary assignment earlier in the weekend invaldiates a forced assignment later in the weekend.
        #That is captured in a separate function 'frcOK'

    
    def totShiftHrs(self,sl,toFlw=False,styling=False):
        """Given a slot, assuming it is assigned, what is the total shift length of the shift in which that slot is a constituent. If toFlw=True then return # slots to follow present slot in same shift"""
        sLen=1 #start off shift length at one because the slot being passed in is always minimum
        assnSeqIDs=[int(k[:k.index('_')]) for k in self.assignments] #Pull out the seqID's from the key strings for each slot an ee is already assigned
        if len(assnSeqIDs)==0:
            if toFlw==False:
                return 4 #Case that no slots assigned so far, so if sl assigned then its alone
            else: return 0 #single shift, no following
        else:
            if toFlw==False:
                anch=sl.seqID
                assnSeqIDs.append(anch)
                assnSeqIDs.sort() #sorts integers lowest to highest
                if styling==True: #Coutning method is simpler when just counting shift length for schedule colouring, need not account for slot passed in being potential 4slot consectuvie work slot
                    for offset in [-2,-1,1,2]: #Knowing that shifts will never be assigned 4 in a row, and there won't be a 4 hour gap between shifts, just count neighbouring 4 slots (2 on each side)
                        if anch+offset in assnSeqIDs: 
                            sLen+=1
                    return sLen*4 #Return num hours
                else: #Originally was using the same method as styling, with limits as -3,+3, but made a bug.. even if the two neighbouring slots on 1 side were unassigned (8hr gap), it would still count the 3rd if it was assigned, even though it shouldnt be counted as not a contiguous shift
                    assnSeqIDs=list(set(assnSeqIDs)) #converting to set eliminates duplicates ( in event slot being passed in was already assigned.. it was appended again)
                    def ranges(nums):
                        """Returns a list of (open,close) intervals a list spans"""
                        nums = sorted(set(nums))
                        gaps = [[s, e] for s, e in zip(nums, nums[1:]) if s+1 < e]
                        edges = iter(nums[:1] + sum(gaps, []) + nums[-1:])
                        return list(zip(edges, edges))
                    rns=ranges(assnSeqIDs) #dont have to worry that following line failes to index list comp @[0] because the slot in question is always passed in, even if no other assignments, the slot in question will be returned as 1 slot 4 hours
                    myRn=[x for x in rns if x[0]<=anch and x[1]>=anch][0] #Pull out a tuple contianing lower and upper bound of sequence of seqID's of which the slot in question is a part
                    return (myRn[1]-myRn[0]+1)*4 #e.g. range is seqIDs (6,7), thats two slots. 7-6+1=2
            else: #Count # of slots that follow this one consecutively
                i=0 #Count of slots to follow on same shift
                for offset in [1,2]: #Never more than 3 in a row so need only check the 2 following slot seqID's for assignment
                    if anch+offset in assnSeqIDs: 
                        i+=1
                return i
    
    def assnConflict(self,sl):
        """Returns true if someone is already assigned to a slot with same seqID as potential assignment, false if no conflict"""
        assns=[int(k[:k.index('_')]) for k in self.assignments] #Pull out the seqID's form the key strings for each slot an ee is already assigned
        if len(assns)==0:return False #if no other assignments.. no conflict
        elif sl.seqID not in assns: return False #if no other assns with same seqID.. no conflict
        elif sl.seqID in assns: return True #if other assignment already amde with same seqID... true, conflict present

    
    def gapOK(self,sl,sch,tp='V'):
        """Returns true if the slot, when assigned, doesn't break the rule for minimum gap between shifts. 12 hours for forcing, 8 for vol"""
        assns=[int(k[:k.index('_')]) for k in self.assignments] #Pull out the seqID's form the key strings for each slot an ee is already assigned
        #Just need to check the nearest neighbours aren't with a gap of 1 empty slot
        deltaNextShifts=[v for v in [sId-sl.seqID for sId in assns] if v>0]  # Define this and the next before defining next/prevNeighDist to manage case of 0 this being equal to [], which min() can't accept
        deltaPrevShifts=[v for v in [sl.seqID-sId  for sId in assns] if v>0] ##Basically, subtract various Id's from sl in question. Remove vlaues<0 bc those slots come later (next neighb). Then take the minimum value, which is the diff in seqID between sl being compared, and nearest neighbour on left when sorted chronologically 
        if len(deltaNextShifts)==0:
            deltaNextShifts=[0] #Fill with bogus # to give 'ok' result to function
        if len(deltaPrevShifts)==0:
            deltaPrevShifts=[0]
        nextNeighbDist=min(deltaNextShifts)
        prevNeighbDist=min(deltaPrevShifts) 
        #Utility functions:
        def okForLastWkShift():
            if self.crew==sch.Bcrew and sl.seqID-6*(sch.friOT==False)<3+1*(tp=='F'):
                return False #Case of B shift worker being assigned within 8 (or 12 if forced) hrs of last weeks final afternoon shift, no go
            elif self.crew==sch.Acrew and tp=='F' and sl.seqID-6*(sch.friOT==False)<2:
                return False #Case of A shift worker being forced onto first slot of the weekend
            else: return True
        def okForNextWkShift():
            if self.crew=='rock' and tp=='V' and sl.seqID+6*(sch.monOT==False)==23:
                return False #Case of night shift person being assigned 3p-7p afternoon before weekday night shift
            elif self.crew=='rock' and tp=='F' and sl.seqID+6*(sch.monOT==False)>21: 
                return False #Case of night shift forcing.. can't be forced such that <12 hours before next shift
            elif self.crew==sch.Acrew and tp=='F' and sl.seqID+6*(sch.monOT==False)==24:
                return False #Case of day shift ee (next week) being forced 7p-11p the night before
            else: return True
        #=====
        if tp=='V' and (nextNeighbDist==2 or prevNeighbDist==2):
            return False#Distance of one means consecutive slots (shiftlength already checked), distance greater than 2 is gap of 8 hours or more
        elif tp=='F' and ((nextNeighbDist==2 or prevNeighbDist==2) or prevNeighbDist==3):return False #Forcing requires gap of 12h or more going into it, 8 hours after it
        elif okForLastWkShift()==True and okForNextWkShift()==True: return True #Reaching this elif means that the other conditions aren't true, so lastly just have to check the gap with weekday shifts ok
        else: return False #Some condition not met       

    def slOK(self,sch,sl,poll=0,tp='V',pt=True): #pt is 'print', pVol is 'print did not volunteer' or not
        """Returns True if the slot being tested is ok to be assigned, false if not"""
        #Test all conditions (trained, wk hrs, consec shift, time between shifts, before making a branch to test willingness or not based on assignment type forced/voluntary)
        if sl.assignee==None:#Finding people assigned to WWF slots for some reason.. this fixed that category of problem.
            if (sl.dispNm in self.skills) or sl.trnNm=='ODD JOB': #the person is trained and hasn't been specified in assignment log *not* to be assigned here
                if (self.eeID not in sl.disallowed): #this ee/slot pairing isn't ruled out in disallowment list
                    if (self.wkndHrs+self.wkdyHrs<60 and sl.seqID<19) or sl.seqID>18: #total week hours ok!
                        if self.assnConflict(sl)==False: #No existing assignment at same time!
                            if self.totShiftHrs(sl)<=12: #This slot wouldn't have a given shift exceed 12 hours
                                if self.gapOK(sl,sch,tp=tp): #This slot being assigned doesn't break a shift gap rule
                                    if self.crew in ['wwf','bud','blue','rock','silver','gold','student']:
                                        if tp=='V':#voluntary: check willigness
                                            if (poll[3+sl.seqID] !="") and (poll[3+sl.seqID] is not None) and (poll[3+sl.seqID]!='n'): #Person is willing!
                                                if self.lastNm=='Bruno': sch.assnLog.append(self.lastNm+' found ok for sl'+sl.key())
                                                return True
                                            else: 
                                                if sch.sF==False and pt==True and sch.pVol==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Did not volunteer for this shift')
                                                return False
                                        else: 
                                            if (self.wkndHrs+self.wkdyHrs<48) and (self.crew in ['bud','blue','rock','student']): return True #Forced
                                            elif (sch.sF==False and pt==True) and (self.crew in ['bud','blue','rock','student']): sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Cannot force past 48 hours worked in week')
                                            elif (sch.sF==False and pt==True) and (self.crew in ['wwf','silver','gold']): sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Cannot force a WWF person')
                                    elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Crew is not in list wwf,bud,blue,rock,silver,gold,student')
                                elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Insufficient gap time between this shift and another')
                            elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Total consecutive hours would exceed 12')
                        elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Is already assigned for slot in same time period')
                    elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Total hours in week exceeds 60')
                elif sch.sF==False and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Disallowed in Assignment List')
            elif sch.sF==False and sch.pNT==True and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Not Trained')
        elif sch.sF==False and sch.pNT==True and pt==True: sch.assnLog.append('   Fail to assign '+self.firstNm[0]+'. '+self.lastNm+' to ' +sl.dispNm+ ' '+sch.slLeg[sl.seqID-1][1]+' '+sch.slLeg[sl.seqID-1][2]+' || Slot already assigned')        
        return False

class Schedule():
    def __init__(self,Acrew,slots,ee,preAssn,senList,polling,slLeg,sF=False,pNT=True,assnWWF=False,pVol=True,xtraDays=None,maxI=100):
        # self.ftInfoTbl=ftInfoTbl
        self.xtraDays=xtraDays #Selected on Gradio interface. a list of Monday and or Friday if those are to be scheduled. Used obly for gapOK funciton 
        if 'Friday' in xtraDays: self.friOT=True
        else: self.friOT=False
        if 'Monday' in xtraDays: self.monOT=True
        else: self.monOT=False 
        self.pVol=pVol
        self.assnWWF=assnWWF #this boolean indicates if we will be slotting WWF workers into the schedule according to their polling or not. This would be set to 'True' on a long weekend. Whenever it is set to false, the expectation would be that the WWF are fully assigned via assertions in the template file.
        self.pNT=pNT #if True prints '...Not Trained'' statement as applicable when testing if a given slot is ok for someone
        self.sF=sF #suppressFails.. if false, prints out 'failed to schedule' statements
        self.Acrew=Acrew
        if Acrew=='Bud':self.Bcrew='Blue'
        else:self.Bcrew='Bud'
        self.slots= slots  #A collection of Slot objects that compose this schedule
        # self.slots= deepcopy(slots) #Referenced in forcing phase 1
        # self.slots=deepcopy(slots) #Referenced in voluntary assignment phase
        # self.fslots=deepcopy(slots) #Referenced in forcing phase 2
        self.ee=ee #A dictionary containing ee info
        self.preAssn=preAssn #A list of lists containing the predefind assignment info
        self.senList=senList
        self.polling=polling
        self.assnLog=[] #To be appended when assignments made, for read out with final product
        self.slLeg=slLeg #Slot Legend. Used for easy refernece of slot times after.
        seqIDs=[int(k[:k.index('_')]) for k in self.slots]
        self.rev=0
        self.noVol=[] #A list to contain keys of slots with no eligible volunteers.
        self.assignments=1
        self.maxI=maxI
        self.aOnly=[]
        self.assns=0
    
    # @debug
    def trackAssn(self,i=0,loc=None):
        self.assns+=1
    
    def evalAssnList(self):
        """Enter all predefined assignments into the schedule"""
        #First, iterate through the assignment list. Each record will generate one or more records for the 'slot change log'
        #The slot change log will have one record for each slot for which an assignment (or other specified status change) should be made
        #So assignment log records that indicate a span of multiple slots will generate multiple records in the change log.
        slChLg=[] #Initialize slot change log. It will be a list of lists where each sublist has the necessary info within to pass to the slot assignment function
        #===
        def getKeys(seqId_1,seqId_2,jobNm=None):
            """Returns the keys for all slots that a given assnLog record applies to, job specified or not"""
            myKeys=[]
            if jobNm==None:
                for seqNo in range(seqId_1,seqId_2+1):#Apply to all slots in given range.. +1 due to range fn not being inclusive
                    moreKeys=[k for k in self.slots.keys() if k[:len(str(seqNo))+1]==str(seqNo)+'_'] #Pull dict keys for Slots where it is a slot with matching seqNo, regardless of job name
                    myKeys.extend(moreKeys)
            else: #job is defined
                for seqNo in range(seqId_1,seqId_2+1):
                    myKeys.append(str(seqNo)+'_'+jobNm)
            return myKeys
        #===
        #Here we get down to business - Reading the assignment log, generating records in the slotChangeLog, and then evaluating those changes
        for myAssn in self.preAssn:
            if myAssn[0]==1: #Only evaluate those with '1' in 'Active' (first) column
                assnTp=myAssn[1]
                if (myAssn[5]=="" or myAssn[5]==None): jb=None #grab job name
                else: jb=myAssn[5]
                if (myAssn[4]=="" or myAssn[4]==None): asgne=None #grab assignee
                else: asgne=myAssn[4]
                keys=getKeys(myAssn[2],myAssn[3],jb) #pull all the keys for slots this particular assn list item applies to
                for k in keys:
                    slChLg.append([k,self,assnTp,asgne]) #Add record(s) to the slot change long, one for each record.
        #Now that the slChLg is made, carry out the function that reads it record by record and goes and modifies the slots
        def evalLogRec(rec):
            """Carry out the 'assn' method on the associated slot with relevant data from Assn log"""
            if rec[0] in list(self.slots.keys()): #Only assign if the guy actually 
                self.slots[rec[0]].assn(rec[1],rec[2],rec[3],fromList=True)
            else: self.assnLog.append('Could not assign ee '+str(rec[3])+' (Assntype='+str(rec[2])+") because slot wasn't created via All_Slots tab")
        for rec in slChLg:
            evalLogRec(rec)
    
    def proofEligVol(self):
        """This clears the eligVol lists for all slots of the eeID's where the person isn't eligible"""
        #Necessary because had to make slots before making schedule, so wasn't able to actually test if slOK before assigning ee to slot when initializing everything
        for k in self.slots:
            s=self.slots[k]
            for e in s.eligVol:
                if self.ee[e].slOK(self,s,poll=tls.viewTBL('allPollData',filterOn=[('eeid',e)])[0],pt=False) is not True:
                    s.eligVol.pop(s.eligVol.index(e))

    def nextSlots(self,force=0):
        """Returns the next most constrained unassigned slot object. If 'forcing'=True then returns list of slots with 0 eligible assignes, ordered by seqID"""
        if force==0: #Proceed with selecting most constrained slot with >=1 potential assignees
            kyNonZero=[s for s in self.slots if (len(self.slots[s].eligVol)>0) and self.slots[s].assnType not in ['WWF','F','V','nV','DNS','N'] ] #Get keys for slots with >0 eligVol
            if len(kyNonZero)==0: return None #if none left to assign, just return None
            eligCnts=[len(self.slots[k].eligVol) for k in kyNonZero]
            # print(list(zip([self.slots[s].key() for s in kyNonZero],eligCnts)))
            if eligCnts.count(min(eligCnts))>1: #Case that there are slots tied for most constrained
                slts=[self.slots[s] for s in kyNonZero if len(self.slots[s].eligVol)==min(eligCnts)] #Retrieve the tied slot objects
                totSkills=[sum([len(self.ee[eId].skills) for eId in s.eligVol ]) for s in slts ] #For each slot, make a list of integers, whee each integer is the number of jobs an ee eligible for that slot is trained on. Sum those lists, and the slot with the highest number is selected, since that is correlated with the eligible assignees for that slot having the most ability to cover other slots.
                if totSkills.count(min(totSkills))>1: #Case that 2 slots are tied for minimum of total # of training records for eligible operators
                    #Go with the one for which there is an operator with least spots trained... assuming that the operator who is most constrained training wise gets it.. while this is an assumption without great basis, there is at least the point that someone with less training will likely have less refusal hours in the year.. so it may turn to work out ok
                    trainRecForLeastTrainedEE=[min([len(self.ee[eId].skills) for eId in s.eligVol ]) for s in slts ] #Same formula as totSkills except min instead of sum
                    pickSl=slts[trainRecForLeastTrainedEE.index(min(trainRecForLeastTrainedEE))]
                    self.assnLog.append('Slot '+pickSl.key()+' (assnType: '+str(pickSl.assnType)+') chosen as most constrained, was tied for totSkills, chose first')
                    return pickSl #Here only 1 return statement because if its a tie we'll just take the first one, which the index function here will give.
                else: 
                    pickSl=self.slots[ kyNonZero[totSkills.index(max(totSkills))]]
                    self.assnLog.append(pickSl.key()+' (assnType: '+str(pickSl.assnType)+') chosen as most constrained, had least training across all volunteers')
                    return pickSl #Case of one slot having more totSkills than another. Call slots keys, then index that by the totSKills count tog et the index of the slot we want, and retrieve that from slots, 
            else:
                pickSl=self.slots[kyNonZero[eligCnts.index(min(eligCnts))]]
                self.assnLog.append(pickSl.key()+' (assnType: '+str(pickSl.assnType)+') chosen as most constrained, had least ('+str(len(pickSl.eligVol))+') eligible volunteers')
                return pickSl #Retrieve most constrained if not tied with any other.
        elif force==1:#Forcing for the first time. Return list of slots to force into in chronological order
            return sorted([self.slots[s] for s in self.slots if len(self.slots[s].eligVol)==0 and self.slots[s].assnType == None],key=lambda x: x.seqID)
        elif force==2: #Forcing for teh 2nd time. Return all slots. the 'eligibility tracking' isn't perfect so can't filter by it because when people were assigned, would be a pain to make logic to properly remove their 'eligVol' status from the slots which they were no longer eligible for for reasons like max shift length etc. Only removed it for slots happenign at same time
            return sorted([self.slots[s] for s in self.slots if self.slots[s].assnType == 'nV' or self.slots[s].assnType == None],key=lambda x: x.seqID)

    def pickAssignee(self,sl,tp='V',pt=True,lsOtpt=False):
        """Returns an eeid and the assignment type, either voluntary or forced, or 'N' for None/No staff, for the passed slot"""
        if tp=='V':
            def tblSeq(sl,Acrew,Bcrew):
                """Returns keys for retrieving poll data tables in sequence of priority assignment. With respect to shift, assignment priority goes in CABCA sequence, first FT then Temps"""
                if sl.seqID in [1,2,7,8,13,14,19,20]: homeShift='C'
                elif sl.seqID in [3,4,9,10,15,16,21,22]: homeShift='A'
                else: homeShift='B'
                keys=[]
                seqStr='CABCA'
                cD={'C':'Rock','A':Acrew,'B':Bcrew} #Crew Dict
                for eeTp in ['FT','P','Temp']: #Go through all FT's before temps
                    for i in range(3):#code below uses variable homeShift in conjunction with stepping through seqStr to pull out crews in order of priority selection of OT
                        keys.append('tbl_'+cD[seqStr[seqStr.index(homeShift)+i]]+eeTp)
                #Keys list is in form: ['tbl_crw1FT','tbl_crw2FT','tbl_crw3FT','tbl_crw1P','tbl_crw2P','tbl_crw3P','tbl_crw1Temp','tbl_crw2Temp','tbl_crw3Temp']
                #  Point is, no matter which order they end up (crw1/2/3), we can inject the WWF crew keys in if we are weekend scheduling
                    if self.assnWWF==True: #long weekend, wwf to be assigned via refusal and all by program. Insert tbl keys in sequence
                        keys.insert(3,'tbl_wFT')
                        keys.insert(7,'tbl_wP')
                        keys.append('tbl_wT')
                return keys
            #===
            ks=tblSeq(sl,self.Acrew,self.Bcrew)
            ls=[]#For appending eId's in order of their priority selection, if its list output mode
            #Relying on the fact that the tables in the excel sheet were already sequenced in order of refusal hours...
            for k in ks:#Iterate through the tables in provided sequence to pull from crews in sequence of priority pick
                for rec in self.polling[k]: #Iterate through rows in table to pull eeID's in sequence of hours
                    if rec[0] is not None: #Error proof on having an empty polling table for a particular crew
                        if self.ee[rec[0]].slOK(self,sl,poll=tls.viewTBL('allPollData',filterOn=[('eeid',rec[0])])[0],pt=pt):
                            if lsOtpt==False: #Return first person encountered
                                return rec[0],'V' #Person has been found 
                            else: ls.append(rec[0])
                        else: pass
            if lsOtpt==True: return ls
            return None,'nV' #No voluntary assignee found                                
        elif tp=='F':
            if self.pickAssignee(sl,pt=False)[0]!=None: return self.pickAssignee(sl,pt=False) #Check that someone is willing. This branch can be reached in phase 1 forcing when recursing because one force created no takers in previous slot, and now testing to force a slot of different time code. Possible that someone may be willing but shift gap doesnt allow forcing, so need this statement to test on voluntary though command is called from forcing phase
            for i in range(len(self.senList)-1,-1,-1): #Work way down seniority list
                lowManID=int(self.senList[i][2])
                if self.ee[lowManID].slOK(self,sl,tp='F'): return lowManID,'F'
            self.assnLog.append('NO STAFF! No one to force to '+sl.key())
            return None,'N' #No one to force
    # @debug
    def checkForceStop(self,tup,iter,assn):
        if tup!=None:
            if iter==tup[0] and assn==tup[1]: return True
            else: return False
        else: return None

    def handleAssnLog(self,WIPschd):
        self.assnLog.extend(WIPschd.assnLog) #Add whats been logged this final iteration to master log
        self.assnLog.extend(['final iteration: '+str(iter)])
        WIPschd.assnLog=self.assnLog #Replace WIP with the master now that master had WIP tacked on to WWF assn since WIP sched object being passed as final outcome
        return WIPschd
        
    
    @debug
    def fillOutSched_v3(self,noVol=None,iter=0,pre8={},last=None,stop=None):
        """Improvement on v2 to prioritize voluntary 8 hour over voluntary 4hr, plus WWF crew assigning on long weekends"""
        if iter>self.maxI: return last
        #Setup
        iter+=1 #increment iteration counter
        WIPschd=deepcopy(self) #WIPschd will have assignments made to it. 'Self' is kept with only the AssnList stuff coming into this point so that across multiple iterations where the NoVol list is potentially expanded, it serves as the blank slate w.r.t slot objects having no assignees
        WIPschd.assnLog=[] #The assnLog up until this function being called is stored with the parent. In each iteration, bits arae added to WIPschd
        #at end of iteration (whther because recursively calling, or finished) this iterations log is appended to the master log
        if iter==1: #First iteration. Initialize noEligVol list. Do not define it this way in future iterations, because you will lose the slots that were discovered that needed to be added!
            WIPschd.noVol=[k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['DNS','WWF','V','F']] #pull all slots that are unassigned, with no eligible volunteers either
        else: #2nd and further iterations.. coming here because more slots were found to force and would've passed along in function call... so retrieve them here
            # stragglers=[k for k in last.slots if last.slots[k].assnType in ['nV','N']]
            # noVol.extend(stragglers)
            WIPschd.noVol=noVol
        #===Logging for printout
        WIPschd.assnLog.append('Iteration: '+str(iter)+' ||  Starting Schedule With '+str(len(WIPschd.noVol))+' Identified Priority Slots, Forcing As Necessary:')
        mynoVol=''
        for x in sorted(WIPschd.noVol,key=lambda k:int(k[:k.index('_')])): mynoVol+=' '+x
        WIPschd.assnLog.append('Prelim Priority Assignment Sequence: '+mynoVol)
        #=====
        #======
        #Phase ZERO... Volunteer assignments or force as necessary for priority slots identified via no volunteers, or became no-vol on previous iterations
        #       Slots found to lose all eligVol on prev iterations added to this bunch
        #       Also need to check if making a forcing creates the need to make another forcing, and perform recursion in that case as well!
        #       Because the forcing list has slots which were determined via prior recurses in the scheduling that identified a dead end requiring forcing, can't use the same method for tracking new slots needing forcings as used for voluntary assignments
        ######
        WIPschd.noVol.extend(list(pre8.keys()))
        for k in sorted(WIPschd.noVol,key=lambda k: int(k[:k.index('_')])): #Iterate through the keys in chronological order          
            if k in list(pre8.keys()): #Perform 8 hr assign.. thats why list of pre8 was generated after all
                eId=pre8[k] #pull the eId out of the predefined pr
                k2=[pr[0] for pr in [(x,pre8[x]) for x in pre8.keys()] if pr[1]==eId and abs(int(pr[0][:pr[0].index("_")])-int(k[:k.index("_")]))==1][0] 
                #^^^Takes list of all key:val in pre8, pulls out key where seqID within 1 of the seqID for sl k being looked at right now. This is then used to confirm both of these slots are ok to assign. Necessary to shouble check, because other even earlier forcings couldv'e happened after that entry was added to the pre8 dictionary the first time requiring. So can't just blindly assing 
                if (True,True)==(WIPschd.ee[eId].slOK(WIPschd,WIPschd.slots[k],pt=False,poll=tls.viewTBL('allPollData',filterOn=[('eeid',eId)])[0]),WIPschd.ee[eId].slOK(WIPschd,WIPschd.slots[k2],pt=False,poll=tls.viewTBL('allPollData',filterOn=[('eeid',eId)])[0])):
                    WIPschd.assnLog.append('Making previously identified 8 hour voluntary assignment for '+ WIPschd.ee[eId].lastNm +' to '+k+', '+k2)
                    #Checks both slots are ok. Need not check forcing rule because at this stage in process later forcings wouldnt yet exist
                    if WIPschd.slots[k].assnType not in ['V','F']: #If k1 was already reached on prev iteration through k loop then don't perform assn function again
                        WIPschd.trackAssn(self.assns,loc='pre8 Success 1')
                        r=WIPschd.slots[k].assn(WIPschd,assnType="V",slAssignee=eId) 
                        if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                            WIPschd=self.handleAssnLog(WIPschd)
                            return WIPschd
                    if WIPschd.slots[k2].assnType not in ['V','F']: #See above
                        WIPschd.trackAssn(self.assns,loc='pre8 Success 2')
                        r=WIPschd.slots[k2].assn(WIPschd,assnType="V",slAssignee=eId) #Assign both. When the second one gets iterated to, slOK will return False for being assigned on same slot arleady and itll be harmless
                        if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                            WIPschd=self.handleAssnLog(WIPschd)
                            return WIPschd
                #If this ee was forced earlier and so they are no longer ok for the full8 assign, then the pre8 is effectively skipped and re evaluated in the '8hr assn' phase
            else: #Case of assigning a slot not from pre8 list
                s=WIPschd.slots[k]
                WIPschd.assnLog.append('Forcing if necessary to '+s.dispNm+' '+ WIPschd.slLeg[s.seqID-1][1]+' '+ WIPschd.slLeg[s.seqID-1][2])
                eId,tp=WIPschd.pickAssignee(s,tp='F')
                WIPschd.trackAssn(self.assns,loc='force phase')
                r=WIPschd.slots[k].assn(WIPschd,assnType=tp,slAssignee=eId) #return value to variable r is false if making that force assignments breaks rules around forcing past 48 hrs in week
                if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                    WIPschd=self.handleAssnLog(WIPschd)
                    return WIPschd
                if r==False and s.key() not in WIPschd.noVol: #also check if this slot is already in noVol list. Coming to this statement after the fact, I realize there isn't any sensical logic path happening here if the persons forcing broke a rule, but the slot is not in the list. I realize this is because I wrote this if statement at a point where I thought forcings might happen mid-iteration, but after making it so that forcings only happen start of iteration, I think this if statement will never be met. That's because at this point in the algorithm, no voluntary weekend OT has been assigned. but the point of the 'return value' was checking if already-assigned voluntary OT happends before or after the OT that is being forced. But since no voluntary OT has been assigned at all, the return constraint will always be ok. The pickAssignee() method will always return the guy who si to be assigned because if the perosn simply worked enough OT in the week that they can't be forced, then the pickAssignee wouldn't havepicked them anyways
                    WIPschd.noVol.append(s.key())
                    WIPschd.assnLog.append('The last assignment created a broken schedule where the person' +WIPschd.ee[eId].lastNm+' had a forcing (previously assigned) after 48h in the week (just assigned.) Adding this slot to priority sequence and reiterating')
                    self.assnLog.extend(WIPschd.assnLog) #add to master before iterating
                    self.assnLog.extend('RETURN A')
                    return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) #WIPschd,'P-Frce Brk' #<-Alt return for debugging
                newK=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #After assignment, see if anything now needing forcing that hasn't been seen before
                if len(newK-set(WIPschd.noVol))>0: #Case that a forced assignment made someone ineligible for a slot they were marked as the last volunteer in, creating a slot requiring forcing that hasn't been seen before, requiring re iteration
                    pullK=newK-set(WIPschd.noVol) #Get the keys for slots that are now without volunteers(could be more than one so use set subtraction)
                    WIPschd.assnLog.append('The last assignment resulted in slot(s) '+str(list(pullK))+' having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                    WIPschd.noVol.extend(pullK)
                    self.assnLog.extend(WIPschd.assnLog) #Add to master before iterating
                    self.assnLog.extend('RETURN B')
                    return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) # WIPschd,'P-Bump'  #<-Alt return for debugging
        #=====
        #======
        #Phase 0.5 - Make 8 Hour shift assignments previously identified in Phase 1, to set the scene
        #pre8 is a list of tuples (key,eeid) indicating if an ee should be assigned to an 8 hour shift to start. This only happens when they need to be assigned first so as to properly followthrough forcing someone else later.
        #These follow the reverse chronological order of assignment like the rest of voluntary assignments, unlike forcings which were chronological
        #If the slot was put in this list as part of a 'preassigned 8 hours that messed with a forcing previously defined' then it gets evaluated for actually still being feasible with forcingds happening before those 8 that might've come to be after this 'pre8' entry was added. If not valid, no assignment is made and this goes back to being assigned at phase 1 as applicable
        #if not part of the 'pre8' business then proceed like usual with single slot assignment forcing as necessary
        # for k in sorted(list(pre8.keys()),key=lambda k: int(k[:k.index('_')])): #this slot is part of a premade 8hr assignment
        #     #Don't need to worry about key sequencing because the process of adding these to dictionary was already doing that and sequencing is maintained
        #     eId=pre8[k] #pull the eId out of the predefined pr
        #     k2=[pr[0] for pr in [(x,pre8[x]) for x in pre8.keys()] if pr[1]==eId and abs(int(pr[0][:pr[0].index("_")])-int(k[:k.index("_")]))==1][0] 
        #     #^^^Takes list of all key:val in pre8, pulls out key where seqID within 1 of the seqID for sl k being looked at right now. This is then used to confirm both of these slots are ok to assign. Necessary to shouble check, because other even earlier forcings couldv'e happened after that entry was added to the pre8 dictionary the first time requiring. So can't just blindly assing 
        #     if (True,True)==(WIPschd.ee[eId].slOK(WIPschd,WIPschd.slots[k],pt=False,poll=tls.viewTBL('allPollData',filterOn=[('eeid',eId)])[0]),WIPschd.ee[eId].slOK(WIPschd,WIPschd.slots[k2],pt=False,poll=tls.viewTBL('allPollData',filterOn=[('eeid',eId)])[0])):
        #         #Checks both slots are ok. Need not check forcing rule because at this stage in process later forcings wouldnt yet exist
        #         r=WIPschd.slots[k].assn(WIPschd,assnType="V",slAssignee=eId) 
        #         r=WIPschd.slots[k2].assn(WIPschd,assnType="V",slAssignee=eId) #Assign both. When the second one gets iterated to, slOK will return False for being assigned on same slot arleady and itll be harmless
        #============
        #Phase 1-A... Assigning 8 hour slots as priority, for defined shift times
        #--------
        #Note first ha ddefined this section and used it as a function, but calling the return statement which was meant to eb the end of the fillOutSched function within this was causing recursion problems
        ## First, define function that does the 8 hour assignments. Will use it twice.
        ## def assn8(prK):
        #    |-------Sunday--------||----Friday------||------Saturday-----||--------Monday---------|
        prK=[(15,16),(17,18),(13,14),(3,4),(5,6),(1,2),(9,10),(11,12),(7,8),(21,22),(23,24),(19,20)]
        for pr in prK:
            wkColl1=sorted([s for s in WIPschd.slots if (len(WIPschd.slots[s].eligVol)>0) and (WIPschd.slots[s].assnType not in ['WWF','F','V','nV','DNS','N']) and (str(pr[0])==s[:s.index('_')]) ],key=lambda k: len(WIPschd.slots[k].eligVol)) #initialize working Collections, which will contain the unassinged slots in those slot_ID's, in order of least volunteers
            for k1 in wkColl1:
                if WIPschd.slots[k1].assnType not in ['WWF','F','V','nV','DNS','N']: #Last iteration through all eligVols for a k2 didnt find an assignee.... proceed
                    wkColl2=sorted([s for s in WIPschd.slots if (len(WIPschd.slots[s].eligVol)>0) and (WIPschd.slots[s].assnType not in ['WWF','F','V','nV','DNS','N']) and (str(pr[1])==s[:s.index('_')]) ],key=lambda k: len(WIPschd.slots[k].eligVol))
                    for k2 in wkColl2: #wkColl2 was defined in every iteration of wkColl1 because previous times thorugh the loop could've assigned slots previously in wkColl2 so we want to cut them out each time, so recompute it
                        s=0 #Flag to skip out of loop to next k1
                        WIPschd.assnLog.append('Attempting to fill 8 hrs '+str(WIPschd.slLeg[int(k1[:k1.index("_")])-1][2])+' '+str(WIPschd.slLeg[int(k1[:k1.index("_")])-1][1])+ ' '+WIPschd.slots[k1].dispNm+' and '+str(WIPschd.slLeg[int(k2[:k2.index("_")])-1][2])+' '+str(WIPschd.slLeg[int(k2[:k2.index("_")])-1][1])+ ' '+WIPschd.slots[k2].dispNm)#     s.dispNm+' '+ WIPschd.slLeg[s.seqID-1][1]+' '+ WIPschd.slLeg[s.seqID-1][2])
                        #Iterate through every pair of keys to see if someone is ok for the both of them.. if so, assign. Sequenced by most constrained slots
                        for eId in WIPschd.pickAssignee(WIPschd.slots[k1],lsOtpt=True): #Retrieve priority sequence list of who gets it
                            if eId in WIPschd.slots[k2].eligVol and (WIPschd.ee[eId].wkndHrs+WIPschd.ee[eId].wkdyHrs<=52): #Are they eligVol for the other and ok for 8?
                                #Note that at this point, the schedule has only WWF assignments, and forcings that have been identified as required and made. Although 'eligVol' is set for each 4 hr slot in isolation, my thought experiment concludes the 2 eligVol criteria can be used together to check for being ok for a full 8 hour slot in terms of shift gap on each side.. If an 8 hour slot was already assigned in a neighbouring shift, then the eligVol status would've been removed from the far neighbouring slot on this shift, so it wouldn't assign 16 in a row although the eprson would be eligible to use one half of this shift to extend the other to a 12. What isn't caught, however, is taking total week hours beyond 60, since each only cehcks for 4. So that check needs to be added here. Also before an 8 hour assignment is made, need to check if adding those voluntary hours would stop that person from being a valid forcing later in the weekend, that has already been put in the schedule. If so, then assign them and remove the forcing. This latter forcing check I am moving to human review
                                if WIPschd.ee[eId].frcOKdblAssn(WIPschd,WIPschd.slots[k1]): #If function returns true.. no forcing rules were broken
                                    WIPschd.trackAssn(self.assns,loc='asn 8 on shift 1')
                                    r1=WIPschd.slots[k1].assn(WIPschd,assnType="V",slAssignee=eId)
                                    WIPschd.trackAssn(self.assns,loc='asn 8 on shift 2')
                                    r2=WIPschd.slots[k2].assn(WIPschd,assnType="V",slAssignee=eId) #Don't need to check r1 or r2, they are redudnant with passing through frcOKdblAssn to get here
                                    if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                                        WIPschd=self.handleAssnLog(WIPschd)
                                        return WIPschd
                                    s=1
                                    #------ Check if their assignments being made requires that another slot be forced due to losing eligVol
                                    newK=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #After assignment, see if anything now needing forcing that hasn't been seen before
                                    if len(newK-set(WIPschd.noVol))>0: #Case that a forced assignment made someone ineligible for a slot they were marked as the last volunteer in, creating a slot requiring forcing that hasn't been seen before, requiring re iteration
                                        pullK=newK-set(WIPschd.noVol) #Get the keys for slots that are now without volunteers(could be more than one so use set subtraction)
                                        WIPschd.assnLog.append('The last assignment resulted in slot(s) '+str(list(pullK))+' having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                                        WIPschd.noVol.extend(pullK)
                                        self.assnLog.extend(WIPschd.assnLog) #Add to master before iterating
                                        self.assnLog.extend('RETURN C')
                                        return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) # WIPschd,'P-Bump'  #<-Alt return for debugging
                                else:                                         
                                    pre8[k1]=eId
                                    pre8[k2]=eId
                                    WIPschd.assnLog.append("Assigning "+str(WIPschd.ee[eId].lastNm)+" a voluntary 8 hour shift to "+str(k1)+", "+str(k2)+" means they can't be forced for a later slot they were forced in for already. Reiterating schedule with this 8 hour assignment on the initial-fill priority list")
                                    self.assnLog.extend(WIPschd.assnLog)
                                    self.assnLog.extend('RETURN D')
                                    return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop)
                                if s==1: 
                                    break #Break out of searching through ee's, it got assigned and so, done
                        if s==1: break #Break out of incrementing through k2 as k1 has been assignd so we need to look at another k1
        #=============
        #Phase 1-B: Assign straddle shift times.... duplicate code of the section above, with different prK inputs
        prK=[(16,17),(14,15),(18,19),(12,13),(4,5),(2,3),(6,7),(10,11),(8,9),(22,23),(20,21)]
        for pr in prK:
            wkColl1=sorted([s for s in WIPschd.slots if (len(WIPschd.slots[s].eligVol)>0) and (WIPschd.slots[s].assnType not in ['WWF','F','V','nV','DNS','N']) and (str(pr[0])==s[:s.index('_')]) ],key=lambda k: len(WIPschd.slots[k].eligVol)) #initialize working Collections, which will contain the unassinged slots in those slot_ID's, in order of least volunteers
            for k1 in wkColl1:
                if WIPschd.slots[k1].assnType not in ['WWF','F','V','nV','DNS','N']: #Last iteration through all eligVols for a k2 didnt find an assignee.... proceed
                    wkColl2=sorted([s for s in WIPschd.slots if (len(WIPschd.slots[s].eligVol)>0) and (WIPschd.slots[s].assnType not in ['WWF','F','V','nV','DNS','N']) and (str(pr[1])==s[:s.index('_')]) ],key=lambda k: len(WIPschd.slots[k].eligVol))
                    for k2 in wkColl2: #wkColl2 was defined in every iteration of wkColl1 because previous times thorugh the loop could've assigned slots previously in wkColl2 so we want to cut them out each time, so recompute it
                        s=0 #Flag to skip out of loop to next k1
                        WIPschd.assnLog.append('Attempting to fill 8 hrs '+str(WIPschd.slLeg[int(k1[:k1.index("_")])-1][2])+' '+str(WIPschd.slLeg[int(k1[:k1.index("_")])-1][1])+ ' '+WIPschd.slots[k1].dispNm+' and '+str(WIPschd.slLeg[int(k2[:k2.index("_")])-1][2])+' '+str(WIPschd.slLeg[int(k2[:k2.index("_")])-1][1])+ ' '+WIPschd.slots[k2].dispNm)#     s.dispNm+' '+ WIPschd.slLeg[s.seqID-1][1]+' '+ WIPschd.slLeg[s.seqID-1][2])
                        #Iterate through every pair of keys to see if someone is ok for the both of them.. if so, assign. Sequenced by most constrained slots
                        for eId in WIPschd.pickAssignee(WIPschd.slots[k1],lsOtpt=True): #Retrieve priority sequence list of who gets it
                            if eId in WIPschd.slots[k2].eligVol and (WIPschd.ee[eId].wkndHrs+WIPschd.ee[eId].wkdyHrs<=52): #Are they eligVol for the other and ok for 8?
                                #Note that at this point, the schedule has only WWF assignments, and forcings that have been identified as required and made. Although 'eligVol' is set for each 4 hr slot in isolation, my thought experiment concludes the 2 eligVol criteria can be used together to check for being ok for a full 8 hour slot in terms of shift gap on each side.. If an 8 hour slot was already assigned in a neighbouring shift, then the eligVol status would've been removed from the far neighbouring slot on this shift, so it wouldn't assign 16 in a row although the eprson would be eligible to use one half of this shift to extend the other to a 12. What isn't caught, however, is taking total week hours beyond 60, since each only cehcks for 4. So that check needs to be added here. Also before an 8 hour assignment is made, need to check if adding those voluntary hours would stop that person from being a valid forcing later in the weekend, that has already been put in the schedule. If so, then assign them and remove the forcing. This latter forcing check I am moving to human review
                                if WIPschd.ee[eId].frcOKdblAssn(WIPschd,WIPschd.slots[k1]): #If function returns true.. no forcing rules were broken
                                    WIPschd.trackAssn(self.assns,loc='asn 8 straddle 1')
                                    r1=WIPschd.slots[k1].assn(WIPschd,assnType="V",slAssignee=eId)
                                    if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                                        WIPschd=self.handleAssnLog(WIPschd)
                                        return WIPschd
                                    WIPschd.trackAssn(self.assns,loc='asn 8 straddle 2')
                                    r2=WIPschd.slots[k2].assn(WIPschd,assnType="V",slAssignee=eId) #Don't need to check r1 or r2, they are redudnant with passing through frcOKdblAssn to get here
                                    if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                                        WIPschd=self.handleAssnLog(WIPschd)
                                        return WIPschd
                                    s=1
                                    #------ Check if their assignments being made requires that another slot be forced due to losing eligVol
                                    newK=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #After assignment, see if anything now needing forcing that hasn't been seen before
                                    if len(newK-set(WIPschd.noVol))>0: #Case that a forced assignment made someone ineligible for a slot they were marked as the last volunteer in, creating a slot requiring forcing that hasn't been seen before, requiring re iteration
                                        pullK=newK-set(WIPschd.noVol) #Get the keys for slots that are now without volunteers(could be more than one so use set subtraction)
                                        WIPschd.assnLog.append('The last assignment resulted in slot(s) '+str(list(pullK))+' having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                                        WIPschd.noVol.extend(pullK)
                                        self.assnLog.extend(WIPschd.assnLog) #Add to master before iterating
                                        self.assnLog.extend('RETURN G')
                                        return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) # WIPschd,'P-Bump'  #<-Alt return for debugging
                                else:                                         
                                    pre8[k1]=eId
                                    pre8[k2]=eId
                                    WIPschd.assnLog.append("Assigning "+str(WIPschd.ee[eId].lastNm)+" a voluntary 8 hour shift to "+str(k1)+", "+str(k2)+" means they can't be forced for a later slot they were forced in for already. Reiterating schedule with this 8 hour assignment on the initial-fill priority list")
                                    self.assnLog.extend(WIPschd.assnLog)
                                    self.assnLog.extend('RETURN H')
                                    return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop)
                                if s==1: 
                                    break #Break out of searching through ee's, it got assigned and so, done
                        if s==1: break #Break out of incrementing through k2 as k1 has been assignd so we need to look at another k1
        #=============
        #Phase 1-A: Using the function defined.. priority sequence of slots to look for 8hr assns as below
        #    |-------Sunday--------||----Friday------||------Saturday-----||--------Monday---------|
        # prK=[(15,16),(17,18),(13,14),(3,4),(5,6),(1,2),(9,10),(11,12),(7,8),(21,22),(23,24),(19,20)]
        # r=assn8(prK) 
        # if r==1: self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8)
        #=============
        #Phase 1-B... Assigning 8 hour slots as priority, this time all those that straddle defined shift times
        #   |SunA-B|SunC-A|S.B-MonC|SatB-S.C|FriA-B|F.C-A|F.B-S.C|St.A-B|St.C-A|M.A-B|M.C-A
        # prK=[(16,17),(14,15),(18,19),(12,13),(4,5),(2,3),(6,7),(10,11),(8,9),(22,23),(20,21)]
        # r=assn8(prK)#Because the first of the two shifts straddled is always passed in as the first of the pair, the assignment sequence will always be priority choice to the shift the straddle is starting on, then ending on, then off shift.
        # if r==1: self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8)
        #=============
        #=============
        #Phase 2 - Fill any remaining 4 hour holes.
        #(Copied from schedule function v2 phase 2)
        #OldToAssn=[k for k in WIPschd.slots if (len(WIPschd.slots[k].eligVol)>0) and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N'] ]
        OldToAssn=[k for k in WIPschd.slots if WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N'] ]
        NumSl=len(OldToAssn)
        #===========Printouts for Reporting
        appn='Second Phase Assignments (Sequence by Most Constrained): '+str(NumSl)+' slots  ||  '
        for x in OldToAssn: appn+=x+' - '
        WIPschd.assnLog.append(appn)
        for i in range(NumSl): #Iterate across all slots identified at the start
            # NewToAssn=[k for k in WIPschd.slots if (len(WIPschd.slots[k].eligVol)>0) and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N'] ]
            NewToAssn=[k for k in WIPschd.slots if WIPschd.slots[k].assnType not in ['WWF','F','V','DNS','N','nV'] ]
            #===========Printouts for troubleshooting
            # appn='Iter: '+str(i)+' | OldToAssn: '
            # for x in OldToAssn: appn+=x
            # appn+='  | NewToAssn: '
            # for x in NewToAssn: appn+=x
            # WIPschd.assnLog.append(appn)
            #============
            slLost=set(OldToAssn)-set(NewToAssn)
            if len(slLost)<2:
                #Case that this is iteration one (old-new=0) OR this is the expected most common case of the last assignment having been made means that NewToAssn is only missing that last slot, as compared to the Old. If >=2, this means that the last assignment made has resulted in no eligible volunteers for a slot, so there are 2 or more slots missing from NewToAssn list
                OldToAssn=NewToAssn #consider the new as old for next iteration
                curS=WIPschd.nextSlots() #Pick most constrained of all avail slots
                preNoVol=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #For comparison against after assignment
                if curS is not None:
                    lastK=curS.key() #In case needed to remove this slot from set of keys to add to WIPschd.noVol in next iter if multiple slots made to require forcing
                    WIPschd.assnLog.append('Looking to voluntarily assign to '+curS.dispNm+' '+ WIPschd.slLeg[curS.seqID-1][1]+' '+ WIPschd.slLeg[curS.seqID-1][2])
                    eId,tp=WIPschd.pickAssignee(curS)
                    WIPschd.trackAssn(self.assns,loc='4 hr assn')
                    r=WIPschd.slots[curS.key()].assn(WIPschd,assnType=tp,slAssignee=eId) #Note the assign method acts on original, not deepcopy, retrieved via key
                    if self.checkForceStop(stop,iter,WIPschd.assignments)==True: 
                            WIPschd=self.handleAssnLog(WIPschd)
                            return WIPschd
                    newK=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #After assignment, see if anything now needing forcing that hasn't been seen before
                    if len(newK-set(WIPschd.noVol))>0: #Case that a forced assignment made someone ineligible for a slot they were marked as the last volunteer in, creating a slot requiring forcing that hasn't been seen before, requiring re iteration
                        pullK=newK-set(WIPschd.noVol) #Get the keys for slots that are now without volunteers(could be more than one so use set subtraction)
                        WIPschd.assnLog.append('The last assignment resulted in slot(s) '+str(list(pullK))+' having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                        WIPschd.noVol.extend(pullK)
                        self.assnLog.extend(WIPschd.assnLog) #Add to master before iterating
                        self.assnLog.extend('RETURN I')
                        return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) # WIPschd,'P-Bump'  #<-Alt return for debugging
                    if r==False and curS.key() not in WIPschd.noVol:
                        WIPschd.noVol.append(curS.key())
                        WIPschd.assnLog.append('The last assignment created a broken schedule where the person ('+WIPschd.ee[eId].lastNm+') had a forcing (previously assigned) after 48h in the week (just assigned.) Adding this slot to priority sequence and reiterating')
                        self.assnLog.extend(WIPschd.assnLog)
                        self.assnLog.extend('RETURN E')
                        return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop) # WIPschd,'V-F Rule'   #<-Alt return for debugging
                    # if len(postNoVol-preNoVol)>0: #Recurse, an assignment made another slot have noVol
                    #     WIPschd.assnLog.append('The last assignment caused slot(s) '+str(list(postNoVol-preNoVol))+' to have no more eligible volunteers. A new iteration will take place with these slots getting priority assignment')
                    #     WIPschd.noVol.extend(list(postNoVol-preNoVol))
                    #     self.assnLog.extend(WIPschd.assnLog)
                    #     self.assnLog.extend('RETURN I')
                    #     return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd)
                WIPschd.assnLog.extend([str(i)+' of '+str(NumSl-1)])
                if i==NumSl-1:
                    WIPschd.assnLog.extend(['Done.'])
                    self.assnLog.extend(WIPschd.assnLog) #Add whats been logged this final iteration to master log
                    WIPschd.assnLog=self.assnLog #Replace WIP with the master now that master had WIP tacked on to WWF assn since WIP sched object being passed as final outcome
                    self.assnLog.extend(['final iteration: '+str(iter)])
                    # return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,winner=WIPschd)
                    return WIPschd#,'WIN' #Once all voluntary assignments made, schedule done? May need to force more, or go through force function to designate 'no staff' slots
            else: #Case that assignment being made resulted in more slots being left with no EligVol.. add those slots to noVol list and re start the function
                WIPschd.noVol.extend([k for k in slLost if k!=lastK]) #lastK got assigned, so remove it from slLost to get all slots that are identified as needing to be forced due to person last assigned not being available for other slots...
                WIPschd.assnLog.append('The last assignment resulted in slot ('+str([k for k in slLost if k!=lastK])+') having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                self.assnLog.extend(WIPschd.assnLog)
                self.assnLog.extend('RETURN F')
                return self.fillOutSched_v3(WIPschd.noVol,iter,pre8=pre8,last=WIPschd,stop=stop)# WIPschd,'V-Bump' #<-Alt return for debugging 

                                

    # @debug
    def fillOutSched_v2(self,noVol=None,iter=0):
        """Fills out schedule in a recursive way... see blog... when filling with voluntary folks, if a slot with no takers is encountered and has never been identified as such before, then restart from a fresh sched seed where that slot is forced before any voluntary assignments happen"""
        iter+=1
        WIPschd=deepcopy(self) #WIPschd will have assignments made to it. 'Self' is kept with only the AssnList stuff coming into this point so that across multiple iterations where the NoVol list is potentially expanded, it serves as the blank slate 
        if iter==1: #First iteration. Initialize noEligVol list. Do not define it this way in future iterations, because you will lose the slots that were discovered that needed to be added!
            WIPschd.noVol=[k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['DNS','WWF','V','F']]
        else: #2nd and further iterations.. coming here because more slots were found to force and would've passed along in function call... so retrieve them here
            WIPschd.noVol=noVol
        #===Logging for printout
        WIPschd.assnLog.append('Iteration: '+str(iter)+' ||  Starting Schedule With Identified Priority Slots, Forcing As Necessary:')
        mynoVol=''
        for x in sorted(WIPschd.noVol,key=lambda k:int(k[:k.index('_')])): mynoVol+=' '+x
        WIPschd.assnLog.append('Prelim Priority Assignment Sequence: '+mynoVol)
        #=====
        #Initial phase.. Volunteer assignments or force as necessary for priority slots identified via no volunteers, or became no-vol on previous iterations
        #       Slots found to lose all eligVol on prev iterations added to this bunch
        #       Also need to check if making a forcing creates the need to make another forcing, and perform recursion in that case as well!
        #       Because the forcing list has slots which were determined via prior recurses in the scheduling that identified a dead end requiring forcing, can't use the same method for tracking new slots needing forcings as used for voluntary assignments
        for k in sorted(WIPschd.noVol,key=lambda k: int(k[:k.index('_')])): #Iterate through the keys in chronological order          
            s=WIPschd.slots[k]
            WIPschd.assnLog.append('Looking to Force to '+s.dispNm+' '+ WIPschd.slLeg[s.seqID-1][1]+' '+ WIPschd.slLeg[s.seqID-1][2])
            eId,tp=WIPschd.pickAssignee(s,tp='F')
            r=s.assn(WIPschd,assnType=tp,slAssignee=eId)
            if r==False and s.key() not in WIPschd.noVol:
                WIPschd.noVol.append(s.key())
                return self.fillOutSched_v2(WIPschd.noVol,iter) #WIPschd,'P-Frce Brk' #<-Alt return for debugging
            newK=set([k for k in WIPschd.slots if len(WIPschd.slots[k].eligVol)==0 and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N']]) #After assignment, see if anything now needing forcing that hasn't been seen before
            if len(newK-set(WIPschd.noVol))>0: #Case that a forced assignment made someone ineligible for a slot they were marked as a volunteer in
                pullK=newK-set(WIPschd.noVol) #Get the keys for slots that are now without volunteers(could be more than one so use set subtraction)
                WIPschd.assnLog.append('The last assignment resulted in slot(s) '+str(list(pullK))+' having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                WIPschd.noVol.extend(pullK)
                self.assnLog.extend(WIPschd.assnLog)
                return self.fillOutSched_v2(WIPschd.noVol,iter) # WIPschd,'P-Bump'  #<-Alt return for debugging

        #Second phase - Follow most constrained slot to amke assignments
        #      If a slot gets reduced to no eligible volunteers, track it to the priority list and restart
        OldToAssn=[k for k in WIPschd.slots if (len(WIPschd.slots[k].eligVol)>0) and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N'] ]
        NumSl=len(OldToAssn)
        #===========Printouts for Reporting
        appn='Second Phase Assignments (Sequence by Most Constrained): '+str(NumSl)+' slots  ||  '
        for x in OldToAssn: appn+=x+' - '
        WIPschd.assnLog.append(appn)
        for i in range(NumSl): #Iterate across all slots identified at the start
            NewToAssn=[k for k in WIPschd.slots if (len(WIPschd.slots[k].eligVol)>0) and WIPschd.slots[k].assnType not in ['WWF','F','V','nV','DNS','N'] ]
            #===========Printouts for troubleshooting
            # appn='Iter: '+str(i)+' | OldToAssn: '
            # for x in OldToAssn: appn+=x
            # appn+='  | NewToAssn: '
            # for x in NewToAssn: appn+=x
            # WIPschd.assnLog.append(appn)
            #============
            slLost=set(OldToAssn)-set(NewToAssn)
            if len(slLost)<2:
                #Case that this is iteration one (old-new=0) OR this is the expected most common case of the last assignment having been made means that NewToAssn is only missing that last slot, as compared to the Old. If >=2, this means that the last assignment made has resulted in no eligible volunteers for a slot, so there are 2 or more slots missing from NewToAssn list
                OldToAssn=NewToAssn #consider the new as old for next iteration
                curS=WIPschd.nextSlots() #Pick most constrained of all avail slots
                lastK=curS.key() #In case needed to remove this slot from set of keys to add to WIPschd.noVol in next iter if multiple slots made to require forcing
                if curS is not None:
                    WIPschd.assnLog.append('Looking to voluntarily assign to '+curS.dispNm+' '+ WIPschd.slLeg[curS.seqID-1][1]+' '+ WIPschd.slLeg[curS.seqID-1][2])
                    eId,tp=WIPschd.pickAssignee(curS)
                    r=WIPschd.slots[curS.key()].assn(WIPschd,assnType=tp,slAssignee=eId) #Note the assign method acts on original, not deepcopy, retrieved via key
                    if r==False and curS.key() not in WIPschd.noVol:
                        WIPschd.noVol.append(curS.key())
                        return self.fillOutSched_v2(WIPschd.noVol,iter) # WIPschd,'V-F Rule'   #<-Alt return for debugging
                if i==NumSl-1:return WIPschd#,'WIN' #Once all voluntary assignments made, schedule done? May need to force more, or go through force function to designate 'no staff' slots
            else: #Case that assignment being made resulted in more slots being left with no EligVol.. add those slots to noVol list and re start the function
                WIPschd.assnLog.append('The last assignment resulted in 1 or more other slots having no more eligible volunteers. Those slots are added to the list of slots to force at the start, and a new schedule will be made with updated list of slots to Force')
                WIPschd.noVol.extend([k for k in slLost if k!=lastK]) #lastK got assigned, so remove it from slLost to get all slots that are identified as needing to be forced due to person last assigned not being available for other slots...
                return self.fillOutSched_v2(WIPschd.noVol,iter)# WIPschd,'V-Bump' #<-Alt return for debugging
        #Third phase
        # 3. Final Forced Filling
        # WIPschd.assnLog.append('Final Forcing Phase... Forcing to slots with no more eligible volunteers after having assigned voluntary OT')
        # sls=WIPschd.nextSlots(force=2)
        # for s in sls:
        #     WIPschd.assnLog.append('Forcing Phase 2 on '+s.dispNm+' '+ WIPschd.slLeg[s.seqID-1][1]+' '+ WIPschd.slLeg[s.seqID-1][2])
        #     eId,tp=WIPschd.pickAssignee(s,tp='F')
        #     s.assn(WIPschd,assnType=tp,slAssignee=eId)

    def fillOutSched(self):
        """Having made the predetermined assignments, fill in the voids in the schedule"""
        #Algorithm is basically:
        # 1. Force staff for slots with no eligible assignees
        # 2. Iterate through unassigned slots in sequence of which is most constrained
        #    Assign staff in order of who gets priority pick at the slot
        # 3. Force for slots that had no eligible after giivng the eligble their voluntary choices
        #    If no forcing availability, label as such and move on
        #End when no more unassigned slots left

        #Proceed with carrying out the algorithm:
        # 1. Initial Forcing
        sls=self.nextSlots(force=1)
        self.assnLog.append('Initial Forcing phase... Forcing to slots with no eligible volunteers')
        for s in sls:
            self.assnLog.append('Looking to Force to '+s.dispNm+' '+ self.slLeg[s.seqID-1][1]+' '+ self.slLeg[s.seqID-1][2])
            eId,tp=self.pickAssignee(s,tp='F')
            s.assn(self,assnType=tp,slAssignee=eId)
        # 2. Voluntary Filling
        self.assnLog.append('Voluntary Assignment Phase... Assigning slots in sequence of most to least constrained by number of eligible volunteers')
        sls=deepcopy(self.slots)
        toAssn=[s for s in self.slots if (len(self.slots[s].eligVol)>0) and self.slots[s].assnType not in ['WWF','F','V','nV','DNS','N'] ]
        #toAssn is the same as the first action in nextSlots().. needed here to iterate the right number of times
        for i in range(len(toAssn)): #Iterate across all slots,
            s=self.nextSlots() #Pick most constrained of all avail slots
            if s is not None:
                self.assnLog.append('Looking to voluntarily assign to '+s.dispNm+' '+ self.slLeg[s.seqID-1][1]+' '+ self.slLeg[s.seqID-1][2])
                # sls.pop(s.key()) #Remove that one from set for next iteration
                eId,tp=self.pickAssignee(s)
                self.slots[s.key()].assn(self,assnType=tp,slAssignee=eId) #Note the assign method acts on original, not deepcopy, retrieved via key        
                # print(str(i))
                # print(self.slots['8_Labeler'].assnType)
        # 3. Final Forced Filling
        self.assnLog.append('Final Forcing Phase... Forcing to slots with no more eligible volunteers after having assigned voluntary OT')
        sls=self.nextSlots(force=2)
        # print('force slots:')
        # print([x.key() for x in sls])
        for s in sls:
            self.assnLog.append('Forcing Phase 2 on '+s.dispNm+' '+ self.slLeg[s.seqID-1][1]+' '+ self.slLeg[s.seqID-1][2])
            eId,tp=self.pickAssignee(s,tp='F')
            s.assn(self,assnType=tp,slAssignee=eId)


    def printToExcel(self):
        """Print all slot assignments to an excel file for human-readable schedule interpretation"""
        #Define Cell styling function
        def styleCell(cl,clType,s=None,horizMergeLength=0):
                for i in range(horizMergeLength+1):
                    cl=cl.offset(0,i)
                    if clType=='hours':
                        cl.font=pyxl.styles.Font(bold=True,size=16,color="00FFFFFF")
                        cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='00FF0000',end_color='00FF0000')
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thick'),
                        right=pyxl.styles.Side(border_style='thick'),
                        top=pyxl.styles.Side(border_style='thick'),
                        bottom=pyxl.styles.Side(border_style='thick'))
                    elif clType=='shift':
                        cl.font=pyxl.styles.Font(bold=True,size=16)
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thick'),
                        right=pyxl.styles.Side(border_style='thick'),
                        top=pyxl.styles.Side(border_style='thick'),
                        bottom=pyxl.styles.Side(border_style='thick'))
                    elif clType=='day':
                        cl.font=pyxl.styles.Font(bold=True,size=28)
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thick'),
                        right=pyxl.styles.Side(border_style='thick'),
                        top=pyxl.styles.Side(border_style='thick'),
                        bottom=pyxl.styles.Side(border_style='thick'))
                    elif clType=='DNS':
                        cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='B2B2B2',end_color='B2B2B2')
                        cl.font=pyxl.styles.Font(bold=True,size=14)
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                        right=pyxl.styles.Side(border_style='thin'),
                        top=pyxl.styles.Side(border_style='thin'),
                        bottom=pyxl.styles.Side(border_style='thin'))
                    elif clType=='WWF':
                        cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='00B0F0',end_color='00B0F0')
                        cl.font=pyxl.styles.Font(bold=True,size=14,color="00FFFFFF")
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                        right=pyxl.styles.Side(border_style='thin'),
                        top=pyxl.styles.Side(border_style='thin'),
                        bottom=pyxl.styles.Side(border_style='thin'))
                    elif clType=='F':
                        cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='CC99FF',end_color='CC99FF')
                        cl.font=pyxl.styles.Font(bold=True,size=14)
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                        right=pyxl.styles.Side(border_style='thin'),
                        top=pyxl.styles.Side(border_style='thin'),
                        bottom=pyxl.styles.Side(border_style='thin'))
                    elif clType=='N':
                        cl.font=pyxl.styles.Font(bold=True,size=16,color="00FFFFFF")
                        cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='00FF0000',end_color='00FF0000')
                        cl.alignment=pyxl.styles.Alignment(horizontal='center')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thick'),
                        right=pyxl.styles.Side(border_style='thick'),
                        top=pyxl.styles.Side(border_style='thick'),
                        bottom=pyxl.styles.Side(border_style='thick'))
                    elif clType=='jbNm':
                        cl.font=pyxl.styles.Font(bold=True,size=14)
                        cl.alignment=pyxl.styles.Alignment(horizontal='left')
                        cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                        right=pyxl.styles.Side(border_style='thin'),
                        top=pyxl.styles.Side(border_style='thin'),
                        bottom=pyxl.styles.Side(border_style='thin'))
                    elif clType=='V': #Note that if slot was forced, it will be purple per above if branch, regardless of shift length
                        if self.ee[s.assignee].totShiftHrs(s,styling=True)==4: #Colour 4 hour shifts yellow
                            cl.font=pyxl.styles.Font(bold=True,size=14)
                            cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='00FFC000',end_color='00FFC000')
                            cl.alignment=pyxl.styles.Alignment(horizontal='center')
                            cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                            right=pyxl.styles.Side(border_style='thin'),
                            top=pyxl.styles.Side(border_style='thin'),
                            bottom=pyxl.styles.Side(border_style='thin'))
                        elif self.ee[s.assignee].totShiftHrs(s,styling=True)==8: #Leave 8 hrs shift white
                            cl.font=pyxl.styles.Font(bold=False,size=14)
                            cl.alignment=pyxl.styles.Alignment(horizontal='center')
                            cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='00FFFFFF',end_color='00FFFFFF')
                            cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                            right=pyxl.styles.Side(border_style='thin'),
                            top=pyxl.styles.Side(border_style='thin'),
                            bottom=pyxl.styles.Side(border_style='thin'))
                        elif self.ee[s.assignee].totShiftHrs(s,styling=True)==12: #Colour 12 hrs shift green
                            cl.font=pyxl.styles.Font(bold=True,size=14)   
                            cl.alignment=pyxl.styles.Alignment(horizontal='center')
                            cl.fill=pyxl.styles.PatternFill(fill_type="solid",start_color='0092D050',end_color='0092D050')
                            cl.border=pyxl.styles.Border(left=pyxl.styles.Side(border_style='thin'),
                            right=pyxl.styles.Side(border_style='thin'),
                            top=pyxl.styles.Side(border_style='thin'),
                            bottom=pyxl.styles.Side(border_style='thin'))
                            
        #Initial Setup
        self.rev+=1
        wb=pyxl.Workbook()
        dest_filename = 'Wknd Sched_Rev '+str(self.rev)+'.xlsx'
        ws = wb.active
        ws.title = "Full Schedule" #Title worksheet for printout
        ws['A1']='Rev '+str(self.rev)
        styleCell(ws['A1'],'shift')
        ws['A2']='Manager'
        styleCell(ws['A2'],'shift')
        ws.column_dimensions['A'].width =22.78
        dys=['Friday','Saturday','Sunday','Monday']
        shifts=['C','A','B']*4
        tSlots=['11p - 3a','3a - 7a','7a - 11a', '11a - 3p','3p-7p', '7p-11p']*4
        for i in range(0,24,6): #Print Days of week
            cl=ws.cell(column=2+i,row=1)
            styleCell(cl,'day',6) #Style all the cells within the merge
            ws.merge_cells(start_row=1, start_column=2+i, end_row=1, end_column=2+i+5)
            cl.value=dys.pop(0)
        for i in range(0,24,2): #Print the shift title
            cl=ws.cell(column=2+i,row=3)
            styleCell(cl,'shift',1)
            ws.merge_cells(start_row=3, start_column=2+i, end_row=3, end_column=2+i+1)
            cl.value=shifts.pop(0)
        for i in range(24): #Print the shift times row
            cl=ws.cell(column=2+i,row=4)
            cl.value=tSlots.pop(0)
            styleCell(cl,'hours')

        def styleNfill(cl,s):
            if s.assnType=='DNS': cl.value="N/A"
            elif s.assignee is not None:
                val=self.ee[s.assignee].dispNm()
                if s.assnType=='F': val=val+'(F)' #Append force identifier
                cl.value=val
            else: 
                s.assnType='N'
                cl.value='NO STAFF'
            styleCell(cl,s.assnType,s)

        #==================
        #Enter shifts
        #The sequence of keys returned from self.slots.keys() is the same as the slots required were defined in "AllSlots"
        #They should all be in order which would allow for a naive method here but I will generalize it in case someone changes the template
        #And they are not in order after all.
        #The method here is to use a dictionary keyed by job name to track which row a job is printed out to,
        #and to add a job to the dictionary if/when it is encountered for the first time.
        jrD={} #job/Row Dict {job:row}
        r=5 #Start printing job slot info's at row 5 in excel
        for k in self.slots:
            s=self.slots[k] #Retrieve slot
            if s.dispNm not in jrD: #jobRowDict - Add to dict if first time seeing a job
                jrD[s.dispNm]=r
                jbCl=ws.cell(row=r,column=1)
                jbCl.value=s.dispNm
                styleCell(jbCl,'jbNm')
                r+=1 #increment for next one to be observed
            cl=ws.cell(row=jrD[s.dispNm],column=1+s.seqID)
            styleNfill(cl,s)
        #=========================================
        #Go through the schedule to add the (1/3),(1/2),(2/2) etc etc etc slot identifiers for human readibility
        #Define helper function
        def ranges(nums):
            """Returns a list of (open,close) intervals a list spans"""
            nums = sorted(set(nums))
            gaps = [[s, e] for s, e in zip(nums, nums[1:]) if s+1 < e]
            edges = iter(nums[:1] + sum(gaps, []) + nums[-1:])
            return list(zip(edges, edges))
        #===================
        #Proceed with helper function
        for k in self.slots:
            s=self.slots[k] #Retrieve slot
            if s.assignee!=None:
                ids=sorted([self.slots[k].seqID for k in self.ee[s.assignee].assignments])
                rn=ranges(ids)#sets of start-end intervals
                myRn=[x for x in rn if s.seqID>= x[0] and s.seqID<= x[1]][0] #Retrieve start and end sqID for shift containing slot in question
                mysls=[self.slots[k] for k in self.ee[s.assignee].assignments if self.slots[k].seqID>=min(myRn) and self.slots[k].seqID<=max(myRn)] #Retrieve slots
                contents= [[s.dispNm,s.assnType] for s in mysls] #pull slots jobs/assn.Type
                denom=1
                for i in range(len(contents)-1):
                    if contents[i]!=contents[i+1]:
                        denom+=1
                numrtr=[x.key() for x in sorted(mysls, key=lambda x: x.seqID)].index(s.key())+1 #Check for index of current slot within myRn to see its numerator in sequence
                x=ws.cell(row=jrD[s.dispNm],column=1+s.seqID).value
                if denom!=1:
                    ws.cell(row=jrD[s.dispNm],column=1+s.seqID).value=str(x)+' ('+str(numrtr)+'/'+str(denom)+')'
        #======================================================
        #Merge contiguous shifts cells
        #- Define a custom function to facilitate it
        def numInARow(cl,n=1):
            """Given a cell, return the number of cells in a row have the same name in them... Forced shifts break the count. Count starts from 1 for a voluntary shift immediately following a forced shift"""
            nextval=cl.offset(0,1).value
            if nextval is None or nextval=='':
                return n
            elif cl.value!='' and cl.value is not None:
                if '/' in nextval:
                    nextval=cl.offset(0,1).value[:cl.offset(0,1).value.index('/')-3]
                curVal=cl.value
                if '/' in cl.value:
                    curVal=cl.value[:cl.value.index('/')-3]
                if nextval==curVal:
                    return numInARow(cl.offset(0,1),n+1) #Recursive fn. If next cell matches current, use this function on the next one again
                else: return n
            else: return n
        #====== Proceed with above function to be used
        nSkip=0 #Initialize for skipping cells in this loop as applicable
        for rw in range(5,r):
            for i in range(2,26):
                if nSkip<1:
                    inArow=numInARow(ws.cell(row=rw,column=i))
                    nSkip+=(inArow-1)
                    ws.merge_cells(start_row=rw, start_column=i, end_row=rw, end_column=i+inArow-1)
                elif nSkip>0: 
                    nSkip=nSkip-1 #This facilitates *not* checking cells that have already been merged.. thats because if i,i+1,i+2 merged at i, then when loop increments to i+1, it would give an error when checking on i+2.. need to skip to i+3 after having merged i,+1,+2
        #======================================
        #Format column widths
        #Doesnt appear to be working for some reason :(  
        for k in self.slots:
            s=self.slots[k] #Retrieve slot
            ws.column_dimensions[chr(65+s.seqID)].width = max(10.33,len(cl.value),ws.column_dimensions[chr(64+s.seqID)].width-5) #Widen column if new value is wider than any previously existing
        #=============================================
        #Print all forcings
        ws3 = wb.create_sheet(title="FORCINGS")
        ws3.cell(row=1,column=1).value='Employee ID'
        ws3.cell(row=1,column=2).value='Time slot'
        c=0
        for k in [k for k in self.slots if self.slots[k].assnType=='F']:
            ws3.cell(row=2+c,column=1).value=self.ee[self.slots[k].assignee].dispNm()
            ws3.cell(row=2+c,column=2).value=self.slots[k].dispNm+' '+ self.slLeg[self.slots[k].seqID-1][2]+' ('+self.slLeg[self.slots[k].seqID-1][1]+')'
            c+=1
        #=============================================
        #Print assignments to a separate sheet, in alphabetical order by last name
        ws = wb.create_sheet(title="Assignments (Alpha)")
        ws.cell(row=3,column=1).value='Last, First'
        ws.cell(row=2,column=2).value='Time slots'
        styleCell(ws['A3'],'shift')
        # styleCell(ws['A2'],'shift')
        ws.column_dimensions['A'].width =22.78
        dys=['Friday','Saturday','Sunday','Monday']
        shifts=['C','A','B']*4
        tSlots=['11p - 3a','3a - 7a','7a - 11a', '11a - 3p','3p-7p', '7p-11p']*4
        for i in range(0,24,6): #Print Days of week
            cl=ws.cell(column=2+i,row=1)
            styleCell(cl,'day',6) #Style all the cells within the merge
            ws.merge_cells(start_row=1, start_column=2+i, end_row=1, end_column=2+i+5)
            cl.value=dys.pop(0)
        for i in range(0,24,2): #Print the shift title
            cl=ws.cell(column=2+i,row=2)
            styleCell(cl,'shift',1)
            ws.merge_cells(start_row=2, start_column=2+i, end_row=2, end_column=2+i+1)
            cl.value=shifts.pop(0)
        for i in range(24): #Print the shift times row
            cl=ws.cell(column=2+i,row=3)
            cl.value=tSlots.pop(0)
            styleCell(cl,'hours')
        # ws2.cell(row=1,column=1).value='Note that the seniority value presented is not actual plant seniority number, but just the sequence of '
        n=3
        for rec in tls.viewTBL('senRef',sortBy=[('last','ASC')]):
            eId=rec[2]
            if len(self.ee[eId].assignments)>0 and self.slots[self.ee[eId].assignments[0]].assnType!='WWF':#If the person has an assignment and isn't WWF, print it
                n+=1
                ws.cell(row=n,column=1).value=self.ee[eId].lastNm+', '+self.ee[eId].firstNm[0]+'.' #Print name in column A
                #Print N/A to all other cells, actual assignments will overwrite.
                for i in range(2,26):
                    styleCell(ws.cell(row=n,column=i),'DNS')
                    ws.cell(row=n,column=i).value="-"
                c=0
                for k in sorted(self.ee[eId].assignments,key=lambda k:int(k[:k.index('_')])):
                    styleNfill(ws.cell(row=n,column=1+int(k[:k.index('_')])),self.slots[k])
                    # ws2.cell(row=n+1,column=2+c).value=self.slots[k].dispNm+' '+ self.slLeg[self.slots[k].seqID-1][2]+' ('+self.slLeg[self.slots[k].seqID-1][1]+')'
                    ws.cell(row=n,column=1+int(k[:k.index('_')])).value=self.slots[k].dispNm
                    c+=1
        #==========================
        #Print succint assignment log to a separate sheet
        ws2 = wb.create_sheet(title="Succint Ass'n Log")
        ws2.cell(row=1,column=1).value="This data can be used on Tab C of the schedule building web app to investigate what a schedule looked like mid-generation"
        ws2.cell(row=2,column=1).value='Assn #'
        ws2.cell(row=2,column=2).value='EE Nm'
        ws2.cell(row=2,column=3).value='Slot #_Job Nm'
        ws2.cell(row=2,column=4).value='Assignment Type'
        n=1
        for rec in self.aOnly:
            ws2.cell(column=1,row=2+n).value=rec[0]
            ws2.cell(column=2,row=2+n).value=rec[1]
            ws2.cell(column=3,row=2+n).value=rec[2]
            ws2.cell(column=4,row=2+n).value=rec[3]
            n+=1
        #==========================
        #Print verbose assignment log to a separate sheet
        ws2 = wb.create_sheet(title="Verbose Ass'n Log")
        ws2.cell(row=2,column=1).value='List of assignment decisions made throughout scheduling process'
        # ws2.cell(row=1,column=1).value='Note that the seniority value presented is not actual plant seniority number, but just the sequence of '
        n=1
        for rec in self.assnLog:
            ws2.cell(column=1,row=2+n).value=rec
            n+=1

        #==========================================================
        #Print assignments to a separate sheet, sequenced by seniority
        ws2 = wb.create_sheet(title="Assignments (Sen'ty)")
        ws2.cell(row=2,column=1).value='Seniority'
        ws2.cell(row=2,column=2).value='Employee ID'
        ws2.cell(row=2,column=3).value='Time slots'
        # ws2.cell(row=1,column=1).value='Note that the seniority value presented is not actual plant seniority number, but just the sequence of '
        n=1
        for i in range(len(self.senList)-1):
            eId=self.senList[i][2]
            if len(self.ee[eId].assignments)>0 and self.slots[self.ee[eId].assignments[0]].assnType!='WWF':#If the person has an assignment and isn't WWF, print it
                n+=1
                ws2.cell(row=n+1,column=2).value=self.senList[i][0]
                ws2.cell(row=n+1,column=2).value=eId
                c=0
                for k in sorted(self.ee[eId].assignments,key=lambda k:int(k[:k.index('_')])):
                    styleNfill(ws2.cell(row=n+1,column=3+c),self.slots[k])
                    ws2.cell(row=n+1,column=3+c).value=self.slots[k].dispNm+' '+ self.slLeg[self.slots[k].seqID-1][2]+' ('+self.slLeg[self.slots[k].seqID-1][1]+')'
                    c+=1
        #====================================================
               


        wb.save(filename = dest_filename)
        return dest_filename