def scheduleSingleSet(self, jobSet, limits):
jobSet.sort(key=lambda x: x.canStart)
for job in jobSet:
newLimits = [(max(limits[0],
job.canStart), min(limits[1], job.canEnd))]
for subjob in jobSet:
updatedLimits = []
for limit in newLimits:
mockJob = Job()
mockJob.canStart = limit[0]
mockJob.canEnd = limit[1]
overlap = checkOverlap(mockJob, subjob)
updatedLimit = getNewLimits(subjob, overlap, limit)
if isinstance(updatedLimit[0], list):
for sublist in updatedLimit:
updatedLimits.append(sublist)
else:
updatedLimits.append(updatedLimit)
newLimits = updatedLimits
if not self.fitLimits(job, newLimits):
break
limitForJob = self.fitLimits(job, newLimits)
if limitForJob:
self.scheduleSingleJob(job, limitForJob[0],
limitForJob[0] + job.duration)
def getSingleJobs(index, initJob):
job = Job()
job.number = index
job.canStart = initJob[1]
job.canEnd = initJob[2]
job.weight = initJob[3]
job.duration = initJob[0]
return job
def isOverlapping(job, overlapping):
for i in range(0, len(overlapping)):
start = min(map(lambda x: x.canStart, overlapping[i]))
end = max(map(lambda x: x.canEnd, overlapping[i]))
mockJob = Job()
mockJob.canEnd = end
mockJob.canStart = start
overlap = checkOverlap(mockJob, job)
if -1 <= overlap <= 1:
return i
return -1
def getPossibleChanges(self, job, overlaps):
output = []
for overlappingJob in overlaps:
startSet = []
endSet = []
if overlappingJob.canStart + job.duration <= job.canEnd:
mockStart = Job()
mockStart.canStart = overlappingJob.canStart
mockStart.canEnd = overlappingJob.canStart + job.duration
for subJob in overlaps:
if -1 <= checkOverlap(mockStart, subJob) <= 1:
startSet.append(subJob)
if overlappingJob.canEnd + job.duration <= job.canEnd:
mockEnd = Job()
mockEnd.canStart = overlappingJob.canEnd
mockEnd.canEnd = overlappingJob.canEnd + job.duration
for subJob in overlaps:
if -1 <= checkOverlap(mockEnd, subJob) <= 1:
endSet.append(subJob)
if len(startSet) > 0 and startSet not in output:
output.append((startSet, overlappingJob.canStart))
if len(endSet) > 0 and endSet not in output:
output.append((endSet, overlappingJob.canEnd))
return output
def limitJobSet(self, jobs):
minimumStart = min(map(lambda job: job.canStart, jobs))
maximumEnd = max(map(lambda job: job.canEnd, jobs))
mockedJob = Job()
mockedJob.canStart = minimumStart
mockedJob.canEnd = maximumEnd
for scheduled in self.scheduled:
overlap = checkOverlap(mockedJob, scheduled)
if overlap == -1:
minimumStart = scheduled.finished
elif overlap == 1:
maximumEnd = scheduled.begin
else:
continue
return minimumStart, maximumEnd
