Merge fork for interoperability of KoMa solver

The KoMa developed a tool to approximate an optimal conference schedule based on constraints and participant preferences. The aim of this MR is to enable interoperability with that solver. To do this, two functionalities are added:

• A workflow to export data from this tool (rooms, AKs, timeslots, ...) in a JSON format that can be fed to the solver
• A workflow to import the schedule of the solver back into this

Note that the solver also needs preferences of all participants. As this tool does not collect such data (for now at least), one needs to employ a third tool, e.g. this very basic one.

Export data to the solver

The key functionality is the AKJSONExportView which generates a JSON string that can be imported into the solver.

Notably, the KoMa solver models timeslots differently to this tool. Where this tool basically allows for arbitrary time slot design, the KoMa solver has a more constricted notion: The timeslots are modeled as blocks (i.e. simple lists) of consecutive timeslots of a fixed length. The AKs simply store an integer duration, i.e. the number of consecutive timeslots covered by the AK.

To convert the data of this tool into the solver's model, the following strategy is implemented (see Event::default_time_slots, Event::merge_blocks):

• all DefaultSlot instances are discretized into timeslots of a uniform length (beginning at the start and dropping partial timeslots at the end) → each DefaultSlot forms a "block"
• Consecutive blocks are merged. Overlapping timeslots are identified with each other, but partial overlap errors out

The unit tests are expanded quite a bit to test the correctness of the export.

Import a schedule from the solver

This is realized in the form JSONImportForm and the corresponding view AKJSONImportView. The JSON string is simply read from the form and passed to Event::schedule_from_json.

Minor changes

• Bump python version to 3.10
• Availability::{merge_with,intersect_with}: If both objects are from the same Event, set the event also for the returned Availability object
• Add utility class-method Availibility::is_event_covered to check if Event is covered by a list of Availability objects
  • (Possible bug in Availability::with_event_length: To my understanding the returned availability does in fact not have the exact duration of `event
• ak_requirements_changed_handler: Skip slots with no set room
• Add beautifulsoup4 to test requirements

Changes to model objects (AKModel/models.py)

Event

• Event::_generate_slots_from_block: Given a start and time as well as a slot duration, discretizes it into blocks of consecutive discrete time slots.
  • Slots are dropped if no room is available for the slot.
  • If end - start is not a multiple of duration, the last slot is dropped as well.
• Event::uniform_time_slots to uniformly discretize the full event into blocks of time slots:
  • For the block creation, see Event::_generate_slots_from_block
  • Adds constraints to allow all AKCategories in each timeslot
• Event::default_time_slots to derive blocks by uniformly discretizing DefaultSlots
  • Splits each DefaultSlotof the event into one block.
  • Adds constraints such that only AKs from the DefaultSlot's primary categories are allowed to be scheduled in the block
• Event::merge_blocks: Merge blocks in iterable
  • Flatten blocks into list of all timeslots
  • If two slots overlap:
    • If start and end match: merge slots
    • If overlap only partial: error out
  • group consecutive slots into block
• Event::discretize_timeslots: To select the discretization scheme
• Event::schedule_from_json: Load scheduling from json file, i.e. assign each slot a room, start time and duration
• Add field export_slot to Event to store the discretization granularity for the JSON export

AKCategory

• AKOwner::create_category_constraints: static method to create constraint strings for all AKCategories in iterable

Room

• Room::as_json: Export JSON representation for the room object

AKSlot

• AKSlot::as_json: Export JSON representation for the AKobject of this slot

Open ToDos

• Check data consistency at import
• Add tests for JSON import
• Close discussion on "proxy rooms"

AKModel/tests/test_json_export.py

@@ -248,7 +248,7 @@ class JSONExportTest(TestCase):
                 )
                 self.assertEqual(
                     self.export_dict["timeslots"]["info"].keys(),
-                    {"duration"},
+                    {"duration", "blocknames"},
                     "timeslot info keys not as expected",
                 )
                 self._check_type(
@@ -257,6 +257,21 @@ class JSONExportTest(TestCase):
                     "info/duration",
                     item=item,
                 )
+                self._check_lst(
+                    self.export_dict["timeslots"]["info"]["blocknames"],
+                    "info/blocknames",
+                    item=item,
+                    contained_type=list,
+                )
+                for blockname in self.export_dict["timeslots"]["info"]["blocknames"]:
+                    self.assertEqual(len(blockname), 2)
+                    self._check_lst(
+                        blockname,
+                        "info/blocknames/entry",
+                        item=item,
+                        contained_type=str,
+                    )
+
                 self._check_lst(
                     self.export_dict["timeslots"]["blocks"],
                     "blocks",
@@ -710,72 +725,120 @@ class JSONExportTest(TestCase):
                 self.set_up_event(event=event)
 
                 cat_avails = self._get_cat_availability()
-                for timeslot in chain.from_iterable(
+                num_blocks = len(self.export_dict["timeslots"]["blocks"])
+                for block_idx, block in enumerate(
                     self.export_dict["timeslots"]["blocks"]
                 ):
-                    start, end = self._get_timeslot_start_end(timeslot)
-                    timeslot_avail = Availability(
-                        event=self.event, start=start, end=end
-                    )
-
-                    fulfilled_time_constraints = set()
+                    for timeslot in block:
+                        start, end = self._get_timeslot_start_end(timeslot)
+                        timeslot_avail = Availability(
+                            event=self.event, start=start, end=end
+                        )
 
-                    # reso deadline
-                    if self.event.reso_deadline is not None:
-                        # timeslot ends before deadline
-                        if end < self.event.reso_deadline.astimezone(
-                            self.event.timezone
-                        ):
-                            fulfilled_time_constraints.add("resolution")
-
-                    # add category constraints
-                    fulfilled_time_constraints |= (
-                        AKCategory.create_category_constraints(
-                            [
-                                cat
-                                for cat in AKCategory.objects.filter(
-                                    event=self.event
-                                ).all()
-                                if timeslot_avail.is_covered(cat_avails[cat.name])
-                            ]
+                        fulfilled_time_constraints = set()
+
+                        # reso deadline
+                        if self.event.reso_deadline is not None:
+                            # timeslot ends before deadline
+                            if end < self.event.reso_deadline.astimezone(
+                                self.event.timezone
+                            ):
+                                fulfilled_time_constraints.add("resolution")
+
+                        # add category constraints
+                        fulfilled_time_constraints |= (
+                            AKCategory.create_category_constraints(
+                                [
+                                    cat
+                                    for cat in AKCategory.objects.filter(
+                                        event=self.event
+                                    ).all()
+                                    if timeslot_avail.is_covered(cat_avails[cat.name])
+                                ]
+                            )
                         )
-                    )
 
-                    # add owner constraints
-                    fulfilled_time_constraints |= {
-                        f"availability-person-{owner.id}"
-                        for owner in AKOwner.objects.filter(event=self.event).all()
-                        if self._is_restricted_and_contained_slot(
-                            timeslot_avail,
-                            Availability.union(owner.availabilities.all()),
+                        # add owner constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-person-{owner.id}"
+                            for owner in AKOwner.objects.filter(event=self.event).all()
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(owner.availabilities.all()),
+                            )
+                        }
+
+                        # add room constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-room-{room.id}"
+                            for room in self.rooms
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(room.availabilities.all()),
+                            )
+                        }
+
+                        # add ak constraints
+                        fulfilled_time_constraints |= {
+                            f"availability-ak-{ak.id}"
+                            for ak in AK.objects.filter(event=event)
+                            if self._is_restricted_and_contained_slot(
+                                timeslot_avail,
+                                Availability.union(ak.availabilities.all()),
+                            )
+                        }
+                        fulfilled_time_constraints |= {
+                            f"fixed-akslot-{slot.id}"
+                            for slot in self.ak_slots
+                            if self._is_ak_fixed_in_slot(slot, timeslot_avail)
+                        }
+
+                        fulfilled_time_constraints |= {
+                            f"notblock{idx}"
+                            for idx in range(num_blocks)
+                            if idx != block_idx
+                        }
+
+                        self.assertEqual(
+                            fulfilled_time_constraints,
+                            set(timeslot["fulfilled_time_constraints"]),
                         )
-                    }
-
-                    # add room constraints
-                    fulfilled_time_constraints |= {
-                        f"availability-room-{room.id}"
-                        for room in self.rooms
-                        if self._is_restricted_and_contained_slot(
-                            timeslot_avail,
-                            Availability.union(room.availabilities.all()),
+
+    def test_timeslots_info(self):
+        """Test timeslots info dict"""
+        for event in Event.objects.all():
+            with self.subTest(event=event):
+                self.set_up_event(event=event)
+
+                self.assertAlmostEqual(
+                    self.export_dict["timeslots"]["info"]["duration"],
+                    float(self.event.export_slot),
+                )
+
+                block_names = []
+                for block in self.export_dict["timeslots"]["blocks"]:
+                    if not block:
+                        continue
+
+                    block_start, _ = self._get_timeslot_start_end(block[0])
+                    _, block_end = self._get_timeslot_start_end(block[-1])
+
+                    start_day = block_start.strftime("%A, %d. %b")
+                    if block_start.date() == block_end.date():
+                        # same day
+                        time_str = (
+                            block_start.strftime("%H:%M")
+                            + " – "
+                            + block_end.strftime("%H:%M")
                         )
-                    }
-
-                    # add ak constraints
-                    fulfilled_time_constraints |= {
-                        f"availability-ak-{ak.id}"
-                        for ak in AK.objects.filter(event=event)
-                        if self._is_restricted_and_contained_slot(
-                            timeslot_avail, Availability.union(ak.availabilities.all())
+                    else:
+                        # different days
+                        time_str = (
+                            block_start.strftime("%a %H:%M")
+                            + " – "
+                            + block_end.strftime("%a %H:%M")
                         )
-                    }
-                    fulfilled_time_constraints |= {
-                        f"fixed-akslot-{slot.id}"
-                        for slot in self.ak_slots
-                        if self._is_ak_fixed_in_slot(slot, timeslot_avail)
-                    }
-
-                    self.assertEqual(
-                        fulfilled_time_constraints,
-                        set(timeslot["fulfilled_time_constraints"]),
-                    )
+                    block_names.append([start_day, time_str])
+                self.assertEqual(
+                    block_names, self.export_dict["timeslots"]["info"]["blocknames"]
+                )