Merge branch 'reformat' into 'master'

Make lint clean

See merge request !41

aleksis/apps/untis/menus.py

@@ -6,10 +6,7 @@ MENUS = {
             "name": _("Untis XML import"),
             "url": "untis_xml_import",
             "validators": [
-                (
-                    "aleksis.core.util.predicates.permission_validator",
-                    "untis.do_xml_import",
-                ),
+                ("aleksis.core.util.predicates.permission_validator", "untis.do_xml_import",),
             ],
         },
         {

aleksis/apps/untis/model_extensions.py

@@ -6,61 +6,39 @@ from aleksis.apps.chronos import models as chronos_models
 from aleksis.core import models as core_models
 
 core_models.SchoolTerm.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 core_models.Person.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 core_models.Group.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 
 # Chronos models
 chronos_models.ValidityRange.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.ValidityRange.field(
-    school_year_untis=IntegerField(
-        verbose_name=_("UNTIS school year ID"), null=True, blank=True
-    )
+    school_year_untis=IntegerField(verbose_name=_("UNTIS school year ID"), null=True, blank=True)
 )
 chronos_models.ValidityRange.field(
-    school_id_untis=IntegerField(
-        verbose_name=_("UNTIS school id"), null=True, blank=True
-    )
+    school_id_untis=IntegerField(verbose_name=_("UNTIS school id"), null=True, blank=True)
 )
 chronos_models.ValidityRange.field(
-    version_id_untis=IntegerField(
-        verbose_name=_("UNTIS version id"), null=True, blank=True
-    )
+    version_id_untis=IntegerField(verbose_name=_("UNTIS version id"), null=True, blank=True)
 )
 chronos_models.Subject.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.Room.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.SupervisionArea.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.Lesson.field(
-    lesson_id_untis=IntegerField(
-        verbose_name=_("Lesson id in UNTIS"), null=True, blank=True
-    )
+    lesson_id_untis=IntegerField(verbose_name=_("Lesson id in UNTIS"), null=True, blank=True)
 )
 chronos_models.Lesson.field(
     element_id_untis=IntegerField(
@@ -73,37 +51,23 @@ chronos_models.LessonPeriod.field(
     )
 )
 chronos_models.LessonSubstitution.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.SupervisionSubstitution.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.AbsenceReason.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.Absence.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.Event.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.Holiday.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )
 chronos_models.ExtraLesson.field(
-    import_ref_untis=IntegerField(
-        verbose_name=_("UNTIS import reference"), null=True, blank=True
-    )
+    import_ref_untis=IntegerField(verbose_name=_("UNTIS import reference"), null=True, blank=True)
 )

aleksis/apps/untis/preferences.py

@@ -79,6 +79,5 @@ class UseCourseGroups(BooleanPreference):
     default = True
     verbose_name = _("Use course groups")
     help_text = _(
-        "Build or search course groups for every course"
-        " instead of setting classes as groups."
+        "Build or search course groups for every course" " instead of setting classes as groups."
     )

aleksis/apps/untis/util/mysql/importers/absences.py

@@ -42,9 +42,7 @@ def import_absences(
 
     # Get absences
     absences = (
-        run_default_filter(
-            validity_range, mysql_models.Absence.objects, filter_term=False
-        )
+        run_default_filter(validity_range, mysql_models.Absence.objects, filter_term=False)
         .filter(datefrom__lte=untis_term_end, dateto__gte=untis_term_start)
         .order_by("absence_id")
     )

aleksis/apps/untis/util/mysql/importers/common_data.py

@@ -31,9 +31,7 @@ def import_subjects(validity_range: ValidityRange) -> Dict[int, chronos_models.S
     subjects_ref = {}
 
     # Get subjects
-    subjects = run_default_filter(
-        validity_range, mysql_models.Subjects.objects, filter_term=False
-    )
+    subjects = run_default_filter(validity_range, mysql_models.Subjects.objects, filter_term=False)
 
     for subject in tqdm(subjects, desc="Import subjects", **TQDM_DEFAULTS):
         # Check if needed data are provided
@@ -175,9 +173,7 @@ def import_classes(
         # Check if needed data are provided
         if not class_.name:
             raise RuntimeError(
-                "Class ID {}: Cannot import class without short name.".format(
-                    class_.teacher_id
-                )
+                "Class ID {}: Cannot import class without short name.".format(class_.teacher_id)
             )
 
         # Build values
@@ -191,8 +187,7 @@ def import_classes(
 
         try:
             new_group = core_models.Group.objects.get(
-                short_name__iexact=short_name,
-                school_term__in=[None, validity_range.school_term],
+                short_name__iexact=short_name, school_term__in=[None, validity_range.school_term],
             )
         except core_models.Group.DoesNotExist:
             new_group = core_models.Group.objects.create(
@@ -213,10 +208,7 @@ def import_classes(
             changed = True
             logger.info("  Short name updated")
 
-        if (
-            get_site_preferences()["untis_mysql__update_groups_name"]
-            and new_group.name != name
-        ):
+        if get_site_preferences()["untis_mysql__update_groups_name"] and new_group.name != name:
             new_group.name = name
             changed = True
             logger.info("  Name updated")
@@ -256,9 +248,7 @@ def import_rooms(validity_range: ValidityRange) -> Dict[int, chronos_models.Room
     for room in tqdm(rooms, desc="Import rooms", **TQDM_DEFAULTS):
         if not room.name:
             raise RuntimeError(
-                "Room ID {}: Cannot import room without short name.".format(
-                    room.room_id
-                )
+                "Room ID {}: Cannot import room without short name.".format(room.room_id)
             )
 
         # Build values
@@ -269,8 +259,7 @@ def import_rooms(validity_range: ValidityRange) -> Dict[int, chronos_models.Room
         logger.info("Import room {} …".format(short_name))
 
         new_room, created = chronos_models.Room.objects.get_or_create(
-            short_name=short_name,
-            defaults={"name": name, "import_ref_untis": import_ref},
+            short_name=short_name, defaults={"name": name, "import_ref_untis": import_ref},
         )
 
         if created:
@@ -278,10 +267,7 @@ def import_rooms(validity_range: ValidityRange) -> Dict[int, chronos_models.Room
 
         changed = False
 
-        if (
-            get_site_preferences()["untis_mysql__update_rooms_name"]
-            and new_room.name != name
-        ):
+        if get_site_preferences()["untis_mysql__update_rooms_name"] and new_room.name != name:
             new_room.name = name
             changed = True
             logger.info("  Name updated")
@@ -306,9 +292,7 @@ def import_supervision_areas(
     ref = {}
 
     # Get supervision areas
-    areas = run_default_filter(
-        validity_range, mysql_models.Corridor.objects, filter_term=False
-    )
+    areas = run_default_filter(validity_range, mysql_models.Corridor.objects, filter_term=False)
 
     for area in tqdm(areas, desc="Import supervision areas", **TQDM_DEFAULTS):
         if not area.name:
@@ -428,9 +412,7 @@ def import_time_periods(
 ) -> Dict[int, Dict[int, chronos_models.TimePeriod]]:
     """Import time periods an breaks."""
     times = (
-        run_default_filter(
-            validity_range, mysql_models.Commondata.objects, filter_term=False
-        )
+        run_default_filter(validity_range, mysql_models.Commondata.objects, filter_term=False)
         .filter(id=30)
         .order_by("number")
     )
@@ -446,9 +428,7 @@ def import_time_periods(
         times_ref[period] = (start_time, end_time)
 
     periods = (
-        run_default_filter(
-            validity_range, mysql_models.Commondata.objects, filter_term=False
-        )
+        run_default_filter(validity_range, mysql_models.Commondata.objects, filter_term=False)
         .filter(id=CommonDataId.PERIOD.value)
         .order_by("number", "number1")
     )
@@ -460,9 +440,7 @@ def import_time_periods(
         start_time = times_ref[period][0]
         end_time = times_ref[period][1]
 
-        logger.info(
-            "Import time period on weekday {} in the {}. period".format(weekday, period)
-        )
+        logger.info("Import time period on weekday {} in the {}. period".format(weekday, period))
 
         new_time_period, created = chronos_models.TimePeriod.objects.get_or_create(
             weekday=weekday,
@@ -474,10 +452,7 @@ def import_time_periods(
         if created:
             logger.info("  New time period created")
 
-        if (
-            new_time_period.time_start != start_time
-            or new_time_period.time_end != end_time
-        ):
+        if new_time_period.time_start != start_time or new_time_period.time_end != end_time:
             new_time_period.time_start = start_time
             new_time_period.time_end = end_time
             new_time_period.save()
@@ -505,9 +480,7 @@ def import_breaks(
         # Add None two times in order to create breaks before first lesson and after last lesson
         time_periods_for_breaks = [None] + list(time_periods.values()) + [None]
         for i, time_period in tqdm(
-            enumerate(time_periods_for_breaks),
-            desc="Import breaks (period)",
-            **TQDM_DEFAULTS
+            enumerate(time_periods_for_breaks), desc="Import breaks (period)", **TQDM_DEFAULTS
         ):
             # If last item (None) is reached, no further break must be created
             if i + 1 == len(time_periods_for_breaks):
@@ -568,8 +541,7 @@ def import_absence_reasons(
         logger.info("Import absence reason {} …".format(short_name))
 
         new_reason, created = chronos_models.AbsenceReason.objects.get_or_create(
-            import_ref_untis=import_ref,
-            defaults={"short_name": short_name, "name": name},
+            import_ref_untis=import_ref, defaults={"short_name": short_name, "name": name},
         )
 
         if created:

aleksis/apps/untis/util/mysql/importers/events.py

@@ -21,19 +21,13 @@ logger = logging.getLogger(__name__)
 
 
 def import_events(
-    validity_range: ValidityRange,
-    time_periods_ref,
-    teachers_ref,
-    classes_ref,
-    rooms_ref,
+    validity_range: ValidityRange, time_periods_ref, teachers_ref, classes_ref, rooms_ref,
 ):
     ref = {}
 
     # Get absences
     events = (
-        run_default_filter(
-            validity_range, mysql_models.Event.objects, filter_term=False
-        )
+        run_default_filter(validity_range, mysql_models.Event.objects, filter_term=False)
         .filter(
             datefrom__lte=date_to_untis_date(validity_range.date_end),
             dateto__gte=date_to_untis_date(validity_range.date_start),
@@ -140,8 +134,7 @@ def import_events(
 
         # Delete all no longer existing events
         for e in chronos_models.Event.objects.filter(
-            date_start__lte=validity_range.date_start,
-            date_end__gte=validity_range.date_end,
+            date_start__lte=validity_range.date_start, date_end__gte=validity_range.date_end,
         ):
             if e.import_ref_untis and e.import_ref_untis not in existing_events:
                 logger.info("Event {} deleted".format(e.id))

aleksis/apps/untis/util/mysql/importers/holidays.py

@@ -17,9 +17,7 @@ def import_holidays(validity_range: ValidityRange) -> Dict[int, chronos_models.H
     ref = {}
 
     # Get holidays
-    holidays = run_default_filter(
-        validity_range, mysql_models.Holiday.objects, filter_term=False
-    )
+    holidays = run_default_filter(validity_range, mysql_models.Holiday.objects, filter_term=False)
 
     for holiday in tqdm(holidays, desc="Import holidays", **TQDM_DEFAULTS):
         import_ref = holiday.holiday_id
@@ -27,9 +25,7 @@ def import_holidays(validity_range: ValidityRange) -> Dict[int, chronos_models.H
         # Check if needed data are provided
         if not holiday.name:
             raise RuntimeError(
-                "Holiday ID {}: Cannot import holiday without short name.".format(
-                    import_ref
-                )
+                "Holiday ID {}: Cannot import holiday without short name.".format(import_ref)
             )
 
         title = holiday.name[:50]

aleksis/apps/untis/util/mysql/importers/lessons.py

@@ -116,12 +116,8 @@ def import_lessons(
 
                 # Search by parent groups and subject
                 qs = core_models.Group.objects.filter(
-                    parent_groups__in=[c.id for c in course_classes],
-                    subject_id=subject.id,
-                ).filter(
-                    Q(school_term__isnull=True)
-                    | Q(school_term=validity_range.school_term)
-                )
+                    parent_groups__in=[c.id for c in course_classes], subject_id=subject.id,
+                ).filter(Q(school_term__isnull=True) | Q(school_term=validity_range.school_term))
 
                 # Check if found groups match
                 match = False
@@ -139,12 +135,10 @@ def import_lessons(
 
                     # Build names and refs for course groups
                     group_short_name = "{}-{}".format(
-                        "".join([c.short_name for c in course_classes]),
-                        subject.short_name,
+                        "".join([c.short_name for c in course_classes]), subject.short_name,
                     )
                     group_name = "{}: {}".format(
-                        ", ".join([c.short_name for c in course_classes]),
-                        subject.short_name,
+                        ", ".join([c.short_name for c in course_classes]), subject.short_name,
                     )
 
                     # Get or create course group
@@ -227,9 +221,7 @@ def import_lessons(
             lesson.teachers.set(teachers)
 
             # All times for this course
-            old_lesson_periods_qs = chronos_models.LessonPeriod.objects.filter(
-                lesson=lesson
-            )
+            old_lesson_periods_qs = chronos_models.LessonPeriod.objects.filter(lesson=lesson)
 
             # If length has changed, delete all lesson periods
             if old_lesson_periods_qs.count() != len(time_periods):
@@ -253,10 +245,7 @@ def import_lessons(
                     # Update old lesson period
 
                     old_lesson_period = old_lesson_period_qs[0]
-                    if (
-                        old_lesson_period.period != time_period
-                        or old_lesson_period.room != room
-                    ):
+                    if old_lesson_period.period != time_period or old_lesson_period.room != room:
                         old_lesson_period.period = time_period
                         old_lesson_period.room = room
                         old_lesson_period.save()

aleksis/apps/untis/util/mysql/importers/substitutions.py

@@ -37,9 +37,7 @@ def import_substitutions(
 ):
     """Import substitutions."""
     subs = (
-        run_default_filter(
-            validity_range, mysql_models.Substitution.objects, filter_term=False
-        )
+        run_default_filter(validity_range, mysql_models.Substitution.objects, filter_term=False)
         .filter(
             date__gte=date_to_untis_date(validity_range.date_start),
             date__lte=date_to_untis_date(validity_range.date_end),
@@ -141,10 +139,7 @@ def import_substitutions(
                 classes.append(classes_ref[id_])
 
             if lesson_period:
-                (
-                    substitution,
-                    created,
-                ) = chronos_models.LessonSubstitution.objects.get_or_create(
+                (substitution, created,) = chronos_models.LessonSubstitution.objects.get_or_create(
                     lesson_period=lesson_period, week=week.week, year=week.year
                 )
 
@@ -177,18 +172,13 @@ def import_substitutions(
                 logger.info("  Extra lesson detected")
                 time_period = time_periods_ref[date.weekday()][period]
 
-                groups = [
-                    classes_ref[pk] for pk in untis_split_first(sub.classids, int)
-                ]
+                groups = [classes_ref[pk] for pk in untis_split_first(sub.classids, int)]
 
                 room = room_old if not room_new and room_old else room_new
                 subject = subject_old if not subject_new else subject_new
                 teachers = [teacher_old] if not teacher_new else [teacher_new]
 
-                (
-                    extra_lesson,
-                    created,
-                ) = chronos_models.ExtraLesson.objects.update_or_create(
+                (extra_lesson, created,) = chronos_models.ExtraLesson.objects.update_or_create(
                     import_ref_untis=sub_id,
                     defaults={
                         "week": week.week,
@@ -223,9 +213,7 @@ def import_substitutions(
                         substitution,
                         created,
                     ) = chronos_models.SupervisionSubstitution.objects.get_or_create(
-                        supervision=supervision,
-                        date=date,
-                        defaults={"teacher": teacher_new},
+                        supervision=supervision, date=date, defaults={"teacher": teacher_new},
                     )
 
                     if created:

aleksis/apps/untis/util/mysql/importers/terms.py

@@ -25,8 +25,7 @@ def get_terms_for_date(for_date: Optional[date] = None) -> QuerySet:
         for_date = timezone.now().date()
 
     qs = run_using(mysql_models.Terms.objects).filter(
-        datefrom__lte=date_to_untis_date(for_date),
-        dateto__gte=date_to_untis_date(for_date),
+        datefrom__lte=date_to_untis_date(for_date), dateto__gte=date_to_untis_date(for_date),
     )
 
     return qs
@@ -37,9 +36,7 @@ def get_future_terms_for_date(for_date: Optional[date] = None) -> QuerySet:
     if not for_date:
         for_date = timezone.now().date()
 
-    qs = run_using(mysql_models.Terms.objects).filter(
-        datefrom__gt=date_to_untis_date(for_date),
-    )
+    qs = run_using(mysql_models.Terms.objects).filter(datefrom__gt=date_to_untis_date(for_date),)
 
     return qs
 
@@ -47,9 +44,7 @@ def get_future_terms_for_date(for_date: Optional[date] = None) -> QuerySet:
 logger = logging.getLogger(__name__)
 
 
-def import_terms(
-    qs: Optional[QuerySet] = None,
-) -> Dict[int, chronos_models.ValidityRange]:
+def import_terms(qs: Optional[QuerySet] = None,) -> Dict[int, chronos_models.ValidityRange]:
     """Import terms and school years as validity ranges and school terms."""
     ranges_ref = {}
 
@@ -60,9 +55,7 @@ def import_terms(
     for term in tqdm(qs, desc="Import terms (as validity ranges)", **TQDM_DEFAULTS):
         if not term.name:
             raise RuntimeError(
-                "Term ID {}: Cannot import term without short name.".format(
-                    term.term_id
-                )
+                "Term ID {}: Cannot import term without short name.".format(term.term_id)
             )
         term_id = term.term_id
         name = term.longname if term.longname else term.name
@@ -73,9 +66,7 @@ def import_terms(
 
         school_year_id = term.schoolyear_id
         try:
-            school_term = core_models.SchoolTerm.objects.within_dates(
-                date_start, date_end
-            ).get()
+            school_term = core_models.SchoolTerm.objects.within_dates(date_start, date_end).get()
             logger.info("    School term found by time.")
         except core_models.SchoolTerm.DoesNotExist:
             if school_year_id in school_terms:
@@ -86,9 +77,7 @@ def import_terms(
                     schoolyear_id=school_year_id
                 )
                 school_term_name = (
-                    school_year.text
-                    if school_year.text
-                    else school_year.schoolyearzoned
+                    school_year.text if school_year.text else school_year.schoolyearzoned
                 )
 
                 logger.info(f"  Import school year {school_year_id} ...")
@@ -115,9 +104,7 @@ def import_terms(
         school_term.save()
 
         try:
-            validity_range = chronos_models.ValidityRange.objects.get(
-                import_ref_untis=term_id
-            )
+            validity_range = chronos_models.ValidityRange.objects.get(import_ref_untis=term_id)
             logger.info("  Validity range found by import reference.")
         except chronos_models.ValidityRange.DoesNotExist:
             try:

aleksis/apps/untis/util/mysql/main.py

@@ -50,18 +50,11 @@ def untis_import_mysql(terms: Optional[QuerySet] = None):
         holidays_ref = import_holidays(validity_range)
 
         # Supervisions
-        supervision_areas_ref = import_supervision_areas(
-            validity_range, breaks_ref, teachers_ref
-        )
+        supervision_areas_ref = import_supervision_areas(validity_range, breaks_ref, teachers_ref)
 
         # Lessons
         import_lessons(
-            validity_range,
-            time_periods_ref,
-            rooms_ref,
-            subjects_ref,
-            teachers_ref,
-            classes_ref,
+            validity_range, time_periods_ref, rooms_ref, subjects_ref, teachers_ref, classes_ref,
         )
 
         # Substitutions
@@ -84,6 +77,4 @@ def untis_import_mysql(terms: Optional[QuerySet] = None):
         )
 
         # Events
-        import_events(
-            validity_range, time_periods_ref, teachers_ref, classes_ref, rooms_ref
-        )
+        import_events(validity_range, time_periods_ref, teachers_ref, classes_ref, rooms_ref)

aleksis/apps/untis/util/mysql/util.py

@@ -63,9 +63,7 @@ def clean_array(seq: Sequence, conv: Callable[[Any], Any] = lambda el: el) -> Se
     >>> clean_array(["8", "", "12", "0"], int)
     [8, 12]
     """
-    filtered = filter(
-        lambda el: bool(el), map(lambda el: conv(el) if el else None, seq)
-    )
+    filtered = filter(lambda el: bool(el), map(lambda el: conv(el) if el else None, seq))
     return type(seq)(filtered)
 
 
@@ -103,9 +101,7 @@ def untis_colour_to_hex(colour: int) -> str:
     return "#" + hex_rgb
 
 
-def compare_m2m(
-    a: Union[Sequence[Model], QuerySet], b: Union[Sequence[Model], QuerySet]
-) -> bool:
+def compare_m2m(a: Union[Sequence[Model], QuerySet], b: Union[Sequence[Model], QuerySet]) -> bool:
     """Compare if content of two m2m fields is equal."""
     return set(a) == set(b)
 

aleksis/apps/untis/util/xml/xml.py

@@ -134,11 +134,7 @@ def untis_import_xml(request: HttpRequest, untis_xml: Union[BinaryIO, str]) -> N
             else None
         )
         date_end = (
-            date(
-                int(effectiveenddate[:4]),
-                int(effectiveenddate[4:6]),
-                int(effectiveenddate[6:]),
-            )
+            date(int(effectiveenddate[:4]), int(effectiveenddate[4:6]), int(effectiveenddate[6:]),)
             if effectiveenddate
             else None
         )
@@ -150,9 +146,7 @@ def untis_import_xml(request: HttpRequest, untis_xml: Union[BinaryIO, str]) -> N
         try:
             groups = [Group.objects.get(short_name=v) for v in group_short_names]
         except Group.DoesNotExist:
-            messages.error(
-                request, _("Invalid list of classes: %s") % ", ".join(group_short_names)
-            )
+            messages.error(request, _("Invalid list of classes: %s") % ", ".join(group_short_names))
             continue
 
         try:
@@ -160,14 +154,11 @@ def untis_import_xml(request: HttpRequest, untis_xml: Union[BinaryIO, str]) -> N
         except Person.DoesNotExist:
             messages.error(
                 request,
-                _("Failed to import lesson: Teacher %s does not exist.")
-                % teacher_short_name,
+                _("Failed to import lesson: Teacher %s does not exist.") % teacher_short_name,
             )
             continue
 
-        lesson = Lesson.objects.create(
-            subject=subject, date_start=date_start, date_end=date_end
-        )
+        lesson = Lesson.objects.create(subject=subject, date_start=date_start, date_end=date_end)
 
         lesson.groups.set(groups)
         lesson.teachers.set(teachers)