def test_removed_event_schedule_difference(slots):
events = [
Event(name='Talk 1', duration=30, demand=30),
Event(name='Talk 2', duration=30, demand=500),
Event(name='Workshop 1', duration=60, demand=20),
Event(name='Workshop 2', duration=60, demand=20)
]
old_schedule = (
ScheduledItem(events[0], slots[1]),
ScheduledItem(events[1], slots[4]),
ScheduledItem(events[2], slots[2]),
ScheduledItem(events[3], slots[5])
)
new_schedule = (
ScheduledItem(events[0], slots[1]),
ScheduledItem(events[1], slots[3]),
ScheduledItem(events[2], slots[4])
)
difference = scheduler.event_schedule_difference(
old_schedule, new_schedule)
expected = [
ChangedEventScheduledItem(events[1], slots[4], slots[3]),
ChangedEventScheduledItem(events[2], slots[2], slots[4]),
ChangedEventScheduledItem(events[3], slots[5], None)
]
assert difference == expected
def test_unchanged_event_schedule_difference(events, slots):
old_schedule = (
ScheduledItem(events[0], slots[1]),
ScheduledItem(events[1], slots[4]),
ScheduledItem(events[2], slots[2])
)
difference = scheduler.event_schedule_difference(
old_schedule, old_schedule)
assert difference == []
def build(
verbosity, algorithm, objective, diff, input_dir, solution_dir, build_dir
):
logging.setup(verbosity)
if input_dir:
session.folders['input'] = Path(input_dir)
if solution_dir:
session.folders['solution'] = Path(solution_dir)
if build_dir:
session.folders['build'] = Path(build_dir)
resources = defn.resources()
events, slots = events_and_slots(resources)
slots_by_index = {
idx: f'{slot.starts_at} {slot.venue}'
for idx, slot in enumerate(slots)}
logger.debug(f'\nSlots List:\n{slots_by_index}')
kwargs = {}
if objective == 'consistency' or algorithm == 'simulated_annealing' or diff:
original_solution = io.import_solution(session.folders['solution'])
revised_solution = [
item for item in original_solution
if item[0] < len(events)]
original_schedule = solution_to_schedule(
revised_solution, events, slots)
diff = True
kwargs['original_schedule'] = original_schedule
solution = calc.solution(events, slots, algorithm, objective, **kwargs)
if diff:
schedule = solution_to_schedule(solution, events, slots)
event_diff = event_schedule_difference(original_schedule, schedule)
logger.debug(f'\nevent_diff:')
for item in event_diff:
logger.debug(f'{item.event.name} has moved from {item.old_slot.venue} at {item.old_slot.starts_at} to {item.new_slot.venue} at {item.new_slot.starts_at}')
if solution is not None:
allocations = defn.allocations(resources)
unbounded = defn.unbounded(resources)
defn.add_allocations(events, slots, solution, allocations, unbounded)
logger.debug(convert.schedule_to_text(solution, events, slots))
io.export_solution_and_definition(
resources, events, slots, allocations, solution,
session.folders['solution'])
def test_changed_event_schedule_difference(events, slots):
old_schedule = (
ScheduledItem(events[0], slots[1]),
ScheduledItem(events[1], slots[4]),
ScheduledItem(events[2], slots[2])
)
new_schedule = (
ScheduledItem(events[0], slots[1]),
ScheduledItem(events[1], slots[3]),
ScheduledItem(events[2], slots[4])
)
difference = scheduler.event_schedule_difference(
old_schedule, new_schedule)
expected = [
ChangedEventScheduledItem(events[1], slots[4], slots[3]),
ChangedEventScheduledItem(events[2], slots[2], slots[4])
]
assert difference == expected
def diff(self, original_schedule, new_schedule):
"""
This method returns a dict of Event differences and Slot differences between
the two schedules.
"""
slot_diff = scheduler.slot_schedule_difference(
original_schedule,
new_schedule,
)
slot_output = []
for item in slot_diff:
slot_output.append(
{
"event_location": self.camp.event_locations.get(pk=item.slot.venue),
"starttime": item.slot.starts_at,
"old": {},
"new": {},
},
)
if item.old_event:
try:
old_event = self.camp.events.get(pk=item.old_event.name)
except self.camp.events.DoesNotExist:
old_event = item.old_event.name
slot_output[-1]["old"]["event"] = old_event
if item.new_event:
try:
new_event = self.camp.events.get(pk=item.new_event.name)
except self.camp.events.DoesNotExist:
new_event = item.old_event.name
slot_output[-1]["new"]["event"] = new_event
# then get a list of differences per event
event_diff = scheduler.event_schedule_difference(
original_schedule,
new_schedule,
)
event_output = []
# loop over the differences and build the dict
for item in event_diff:
try:
event = self.camp.events.get(pk=item.event.name)
except self.camp.events.DoesNotExist:
event = item.event.name
event_output.append(
{
"event": event,
"old": {},
"new": {},
},
)
# do we have an old slot for this event?
if item.old_slot:
event_output[-1]["old"][
"event_location"
] = self.camp.event_locations.get(id=item.old_slot.venue)
event_output[-1]["old"]["starttime"] = item.old_slot.starts_at
# do we have a new slot for this event?
if item.new_slot:
event_output[-1]["new"][
"event_location"
] = self.camp.event_locations.get(id=item.new_slot.venue)
event_output[-1]["new"]["starttime"] = item.new_slot.starts_at
# all good
return {"event_diffs": event_output, "slot_diffs": slot_output}
