Make lint clean

aleksis/apps/chronos/forms.py

@@ -26,6 +26,4 @@ class LessonSubstitutionForm(forms.ModelForm):
         }
 
 
-AnnouncementForm.add_node_to_layout(
-    Fieldset(_("Options for timetables"), "show_in_timetables")
-)
+AnnouncementForm.add_node_to_layout(Fieldset(_("Options for timetables"), "show_in_timetables"))

aleksis/apps/chronos/managers.py

@@ -33,9 +33,7 @@ class ValidityRangeRelatedQuerySet(QuerySet):
         """Filter for all objects on a certain day."""
         return self.within_dates(day, day)
 
-    def for_validity_range(
-        self, validity_range: "ValidityRange"
-    ) -> "ValidityRangeRelatedQuerySet":
+    def for_validity_range(self, validity_range: "ValidityRange") -> "ValidityRangeRelatedQuerySet":
         return self.filter(validity=validity_range)
 
     def for_current_or_all(self) -> "ValidityRangeRelatedQuerySet":
@@ -175,11 +173,7 @@ class EventManager(CurrentSiteManager):
             .get_queryset()
             .select_related("period_from", "period_to")
             .prefetch_related(
-                "groups",
-                "groups__school_term",
-                "groups__parent_groups",
-                "teachers",
-                "rooms",
+                "groups", "groups__school_term", "groups__parent_groups", "teachers", "rooms",
             )
         )
 
@@ -193,9 +187,7 @@ class ExtraLessonManager(CurrentSiteManager):
             super()
             .get_queryset()
             .select_related("room", "period", "subject")
-            .prefetch_related(
-                "groups", "groups__school_term", "groups__parent_groups", "teachers",
-            )
+            .prefetch_related("groups", "groups__school_term", "groups__parent_groups", "teachers",)
         )
 
 
@@ -259,10 +251,8 @@ class LessonDataQuerySet(models.QuerySet, WeekQuerySetMixin):
     def in_week(self, wanted_week: CalendarWeek):
         """Filter for all lessons within a calendar week."""
         return self.within_dates(
-            wanted_week[0]
-            + timedelta(days=1) * (F(self._period_path + "period__weekday")),
-            wanted_week[0]
-            + timedelta(days=1) * (F(self._period_path + "period__weekday")),
+            wanted_week[0] + timedelta(days=1) * (F(self._period_path + "period__weekday")),
+            wanted_week[0] + timedelta(days=1) * (F(self._period_path + "period__weekday")),
         ).annotate_week(wanted_week)
 
     def on_day(self, day: date):
@@ -376,9 +366,7 @@ class LessonDataQuerySet(models.QuerySet, WeekQuerySetMixin):
 
         return lesson_periods
 
-    def next_lesson(
-        self, reference: "LessonPeriod", offset: Optional[int] = 1
-    ) -> "LessonPeriod":
+    def next_lesson(self, reference: "LessonPeriod", offset: Optional[int] = 1) -> "LessonPeriod":
         """Get another lesson in an ordered set of lessons.
 
         By default, it returns the next lesson in the set. By passing the offset argument,
@@ -443,9 +431,7 @@ class LessonSubstitutionQuerySet(LessonDataQuerySet):
 
     def in_week(self, wanted_week: CalendarWeek):
         """Filter for all lessons within a calendar week."""
-        return self.filter(week=wanted_week.week, year=wanted_week.year).annotate_week(
-            wanted_week
-        )
+        return self.filter(week=wanted_week.week, year=wanted_week.year).annotate_week(wanted_week)
 
     def on_day(self, day: date):
         """Filter for all lessons on a certain day."""
@@ -475,8 +461,7 @@ class LessonSubstitutionQuerySet(LessonDataQuerySet):
         selected substitutions (as substituted or substituting).
         """
         return Person.objects.filter(
-            Q(lessons_as_teacher__in=self.affected_lessons())
-            | Q(lesson_substitutions__in=self)
+            Q(lessons_as_teacher__in=self.affected_lessons()) | Q(lesson_substitutions__in=self)
         ).annotate(lessons_count=Count("lessons_as_teacher"))
 
     def affected_groups(self):
@@ -517,19 +502,13 @@ class AbsenceQuerySet(DateRangeQuerySetMixin, SchoolTermRelatedQuerySet):
     """QuerySet with custom query methods for absences."""
 
     def absent_teachers(self):
-        return Person.objects.filter(absences__in=self).annotate(
-            absences_count=Count("absences")
-        )
+        return Person.objects.filter(absences__in=self).annotate(absences_count=Count("absences"))
 
     def absent_groups(self):
-        return Group.objects.filter(absences__in=self).annotate(
-            absences_count=Count("absences")
-        )
+        return Group.objects.filter(absences__in=self).annotate(absences_count=Count("absences"))
 
     def absent_rooms(self):
-        return Person.objects.filter(absences__in=self).annotate(
-            absences_count=Count("absences")
-        )
+        return Person.objects.filter(absences__in=self).annotate(absences_count=Count("absences"))
 
 
 class HolidayQuerySet(QuerySet, DateRangeQuerySetMixin):
@@ -635,9 +614,7 @@ class TimetableQuerySet(models.QuerySet):
             return None
 
 
-class EventQuerySet(
-    DateRangeQuerySetMixin, SchoolTermRelatedQuerySet, TimetableQuerySet
-):
+class EventQuerySet(DateRangeQuerySetMixin, SchoolTermRelatedQuerySet, TimetableQuerySet):
     """QuerySet with custom query methods for events."""
 
     def annotate_day(self, day: date):
@@ -645,9 +622,7 @@ class EventQuerySet(
         return self.annotate(_date=models.Value(day, models.DateField()))
 
 
-class ExtraLessonQuerySet(
-    TimetableQuerySet, SchoolTermRelatedQuerySet, GroupByPeriodsMixin
-):
+class ExtraLessonQuerySet(TimetableQuerySet, SchoolTermRelatedQuerySet, GroupByPeriodsMixin):
     """QuerySet with custom query methods for extra lessons."""
 
     _multiple_rooms = False

aleksis/apps/chronos/mixins.py

@@ -16,9 +16,7 @@ from .managers import ValidityRangeRelatedQuerySet
 class ValidityRangeRelatedExtensibleModel(ExtensibleModel):
     """Add relation to validity range."""
 
-    objects = CurrentSiteManagerWithoutMigrations.from_queryset(
-        ValidityRangeRelatedQuerySet
-    )()
+    objects = CurrentSiteManagerWithoutMigrations.from_queryset(ValidityRangeRelatedQuerySet)()
 
     validity = models.ForeignKey(
         "chronos.ValidityRange",
@@ -36,9 +34,7 @@ class ValidityRangeRelatedExtensibleModel(ExtensibleModel):
 class WeekRelatedMixin:
     @property
     def date(self) -> date:
-        return week_weekday_to_date(
-            self.calendar_week, self.lesson_period.period.weekday
-        )
+        return week_weekday_to_date(self.calendar_week, self.lesson_period.period.weekday)
 
     @property
     def calendar_week(self) -> CalendarWeek:

aleksis/apps/chronos/model_extensions.py

@@ -83,11 +83,7 @@ def lesson_periods_as_teacher(self):
 @Person.method
 def lessons_on_day(self, day: date):
     """Get all lessons of this person (either as participant or teacher) on the given day."""
-    return (
-        LessonPeriod.objects.on_day(day)
-        .filter_from_person(self)
-        .order_by("period__period")
-    )
+    return LessonPeriod.objects.on_day(day).filter_from_person(self).order_by("period__period")
 
 
 @Person.method
@@ -106,17 +102,13 @@ def _adjacent_lesson(
 
 
 @Person.method
-def next_lesson(
-    self, lesson_period: "LessonPeriod", day: date
-) -> Union["LessonPeriod", None]:
+def next_lesson(self, lesson_period: "LessonPeriod", day: date) -> Union["LessonPeriod", None]:
     """Get next lesson of the person (either as participant or teacher) on the same day."""
     return self._adjacent_lesson(lesson_period, day)
 
 
 @Person.method
-def previous_lesson(
-    self, lesson_period: "LessonPeriod", day: date
-) -> Union["LessonPeriod", None]:
+def previous_lesson(self, lesson_period: "LessonPeriod", day: date) -> Union["LessonPeriod", None]:
     """Get previous lesson of the person (either as participant or teacher) on the same day."""
     return self._adjacent_lesson(lesson_period, day, offset=-1)
 
@@ -128,9 +120,7 @@ def for_timetables(cls):
 
 Announcement.class_method(for_timetables)
 Announcement.field(
-    show_in_timetables=BooleanField(
-        verbose_name=_("Show announcement in timetable views?")
-    )
+    show_in_timetables=BooleanField(verbose_name=_("Show announcement in timetable views?"))
 )
 
 Group.foreign_key("subject", Subject, related_name="groups")

aleksis/apps/chronos/models.py

@@ -90,33 +90,25 @@ class ValidityRange(ExtensibleModel):
     def clean(self):
         """Ensure there is only one validity range at each point of time."""
         if self.date_end < self.date_start:
-            raise ValidationError(
-                _("The start date must be earlier than the end date.")
-            )
+            raise ValidationError(_("The start date must be earlier than the end date."))
 
         if self.school_term:
             if (
                 self.date_end > self.school_term.date_end
                 or self.date_start < self.school_term.date_start
             ):
-                raise ValidationError(
-                    _("The validity range must be within the school term.")
-                )
+                raise ValidationError(_("The validity range must be within the school term."))
 
         qs = ValidityRange.objects.within_dates(self.date_start, self.date_end)
         if self.pk:
             qs = qs.exclude(pk=self.pk)
         if qs.exists():
             raise ValidationError(
-                _(
-                    "There is already a validity range for this time or a part of this time."
-                )
+                _("There is already a validity range for this time or a part of this time.")
             )
 
     def __str__(self):
-        return (
-            self.name or f"{date_format(self.date_start)}–{date_format(self.date_end)}"
-        )
+        return self.name or f"{date_format(self.date_start)}–{date_format(self.date_end)}"
 
     class Meta:
         verbose_name = _("Validity range")
@@ -158,16 +150,12 @@ class TimePeriod(ValidityRangeRelatedExtensibleModel):
 
         return wanted_week[self.weekday]
 
-    def get_datetime_start(
-        self, week: Optional[Union[CalendarWeek, int]] = None
-    ) -> datetime:
+    def get_datetime_start(self, week: Optional[Union[CalendarWeek, int]] = None) -> datetime:
         """Get datetime of lesson start in a specific week."""
         day = self.get_date(week)
         return datetime.combine(day, self.time_start)
 
-    def get_datetime_end(
-        self, week: Optional[Union[CalendarWeek, int]] = None
-    ) -> datetime:
+    def get_datetime_end(self, week: Optional[Union[CalendarWeek, int]] = None) -> datetime:
         """Get datetime of lesson end in a specific week."""
         day = self.get_date(week)
         return datetime.combine(day, self.time_end)
@@ -202,9 +190,7 @@ class TimePeriod(ValidityRangeRelatedExtensibleModel):
         return day
 
     @classmethod
-    def get_relevant_week_from_datetime(
-        cls, when: Optional[datetime] = None
-    ) -> CalendarWeek:
+    def get_relevant_week_from_datetime(cls, when: Optional[datetime] = None) -> CalendarWeek:
         """Return currently relevant week depending on current date and time."""
         if not when:
             when = timezone.now()
@@ -254,20 +240,12 @@ class TimePeriod(ValidityRangeRelatedExtensibleModel):
     @classproperty
     @cache_memoize(3600)
     def time_min(cls) -> Optional[time]:
-        return (
-            cls.objects.for_current_or_all()
-            .aggregate(Min("time_start"))
-            .get("time_start__min")
-        )
+        return cls.objects.for_current_or_all().aggregate(Min("time_start")).get("time_start__min")
 
     @classproperty
     @cache_memoize(3600)
     def time_max(cls) -> Optional[time]:
-        return (
-            cls.objects.for_current_or_all()
-            .aggregate(Max("time_end"))
-            .get("time_end__max")
-        )
+        return cls.objects.for_current_or_all().aggregate(Max("time_end")).get("time_end__max")
 
     @classproperty
     @cache_memoize(3600)
@@ -299,8 +277,7 @@ class TimePeriod(ValidityRangeRelatedExtensibleModel):
         )
 
         period_choices = [("", "")] + [
-            (period, f"{period}.")
-            for period in time_periods.values_list("period", flat=True)
+            (period, f"{period}.") for period in time_periods.values_list("period", flat=True)
         ]
 
         return period_choices
@@ -314,9 +291,7 @@ class TimePeriod(ValidityRangeRelatedExtensibleModel):
 
 
 class Subject(ExtensibleModel):
-    short_name = models.CharField(
-        verbose_name=_("Short name"), max_length=255, unique=True
-    )
+    short_name = models.CharField(verbose_name=_("Short name"), max_length=255, unique=True)
     name = models.CharField(verbose_name=_("Long name"), max_length=255, unique=True)
 
     colour_fg = ColorField(verbose_name=_("Foreground colour"), blank=True)
@@ -332,9 +307,7 @@ class Subject(ExtensibleModel):
 
 
 class Room(ExtensibleModel):
-    short_name = models.CharField(
-        verbose_name=_("Short name"), max_length=255, unique=True
-    )
+    short_name = models.CharField(verbose_name=_("Short name"), max_length=255, unique=True)
     name = models.CharField(verbose_name=_("Long name"), max_length=255)
 
     def __str__(self) -> str:
@@ -349,27 +322,17 @@ class Room(ExtensibleModel):
         verbose_name_plural = _("Rooms")
 
 
-class Lesson(
-    ValidityRangeRelatedExtensibleModel, GroupPropertiesMixin, TeacherPropertiesMixin
-):
+class Lesson(ValidityRangeRelatedExtensibleModel, GroupPropertiesMixin, TeacherPropertiesMixin):
     subject = models.ForeignKey(
-        "Subject",
-        on_delete=models.CASCADE,
-        related_name="lessons",
-        verbose_name=_("Subject"),
+        "Subject", on_delete=models.CASCADE, related_name="lessons", verbose_name=_("Subject"),
     )
     teachers = models.ManyToManyField(
         "core.Person", related_name="lessons_as_teacher", verbose_name=_("Teachers")
     )
     periods = models.ManyToManyField(
-        "TimePeriod",
-        related_name="lessons",
-        through="LessonPeriod",
-        verbose_name=_("Periods"),
-    )
-    groups = models.ManyToManyField(
-        "core.Group", related_name="lessons", verbose_name=_("Groups")
+        "TimePeriod", related_name="lessons", through="LessonPeriod", verbose_name=_("Periods"),
     )
+    groups = models.ManyToManyField("core.Group", related_name="lessons", verbose_name=_("Groups"))
 
     def get_year(self, week: int) -> int:
         year = self.validity.date_start.year
@@ -394,9 +357,7 @@ class Lesson(
 class LessonSubstitution(ExtensibleModel, WeekRelatedMixin):
     objects = LessonSubstitutionManager.from_queryset(LessonSubstitutionQuerySet)()
 
-    week = models.IntegerField(
-        verbose_name=_("Week"), default=CalendarWeek.current_week
-    )
+    week = models.IntegerField(verbose_name=_("Week"), default=CalendarWeek.current_week)
     year = models.IntegerField(verbose_name=_("Year"), default=get_current_year)
 
     lesson_period = models.ForeignKey(
@@ -412,14 +373,9 @@ class LessonSubstitution(ExtensibleModel, WeekRelatedMixin):
         verbose_name=_("Subject"),
     )
     teachers = models.ManyToManyField(
-        "core.Person",
-        related_name="lesson_substitutions",
-        blank=True,
-        verbose_name=_("Teachers"),
-    )
-    room = models.ForeignKey(
-        "Room", models.CASCADE, null=True, blank=True, verbose_name=_("Room")
+        "core.Person", related_name="lesson_substitutions", blank=True, verbose_name=_("Teachers"),
     )
+    room = models.ForeignKey("Room", models.CASCADE, null=True, blank=True, verbose_name=_("Room"))
 
     cancelled = models.BooleanField(default=False, verbose_name=_("Cancelled?"))
     cancelled_for_teachers = models.BooleanField(
@@ -430,9 +386,7 @@ class LessonSubstitution(ExtensibleModel, WeekRelatedMixin):
 
     def clean(self) -> None:
         if self.subject and self.cancelled:
-            raise ValidationError(
-                _("Lessons can only be either substituted or cancelled.")
-            )
+            raise ValidationError(_("Lessons can only be either substituted or cancelled."))
 
     @property
     def date(self):
@@ -466,39 +420,24 @@ class LessonPeriod(ExtensibleModel, WeekAnnotationMixin):
     objects = LessonPeriodManager.from_queryset(LessonPeriodQuerySet)()
 
     lesson = models.ForeignKey(
-        "Lesson",
-        models.CASCADE,
-        related_name="lesson_periods",
-        verbose_name=_("Lesson"),
+        "Lesson", models.CASCADE, related_name="lesson_periods", verbose_name=_("Lesson"),
     )
     period = models.ForeignKey(
-        "TimePeriod",
-        models.CASCADE,
-        related_name="lesson_periods",
-        verbose_name=_("Time period"),
+        "TimePeriod", models.CASCADE, related_name="lesson_periods", verbose_name=_("Time period"),
     )
 
     room = models.ForeignKey(
-        "Room",
-        models.CASCADE,
-        null=True,
-        related_name="lesson_periods",
-        verbose_name=_("Room"),
+        "Room", models.CASCADE, null=True, related_name="lesson_periods", verbose_name=_("Room"),
     )
 
-    def get_substitution(
-        self, week: Optional[CalendarWeek] = None
-    ) -> LessonSubstitution:
+    def get_substitution(self, week: Optional[CalendarWeek] = None) -> LessonSubstitution:
         wanted_week = week or self.week or CalendarWeek()
 
         # We iterate over all substitutions because this can make use of
         # prefetching when this model is loaded from outside, in contrast
         # to .filter()
         for substitution in self.substitutions.all():
-            if (
-                substitution.week == wanted_week.week
-                and substitution.year == wanted_week.year
-            ):
+            if substitution.week == wanted_week.week and substitution.year == wanted_week.year:
                 return substitution
         return None
 
@@ -567,9 +506,7 @@ class TimetableWidget(DashboardWidget):
 
         request = get_request()
         context = {"has_plan": True}
-        wanted_day = TimePeriod.get_next_relevant_day(
-            timezone.now().date(), datetime.now().time()
-        )
+        wanted_day = TimePeriod.get_next_relevant_day(timezone.now().date(), datetime.now().time())
 
         if has_person(request.user):
             person = request.user.person
@@ -603,9 +540,7 @@ class TimetableWidget(DashboardWidget):
 
 class AbsenceReason(ExtensibleModel):
     short_name = models.CharField(verbose_name=_("Short name"), max_length=255)
-    name = models.CharField(
-        verbose_name=_("Name"), blank=True, null=True, max_length=255
-    )
+    name = models.CharField(verbose_name=_("Name"), blank=True, null=True, max_length=255)
 
     def __str__(self):
         if self.name:
@@ -692,10 +627,7 @@ class Absence(SchoolTermRelatedExtensibleModel):
 
 class Exam(SchoolTermRelatedExtensibleModel):
     lesson = models.ForeignKey(
-        "Lesson",
-        on_delete=models.CASCADE,
-        related_name="exams",
-        verbose_name=_("Lesson"),
+        "Lesson", on_delete=models.CASCADE, related_name="exams", verbose_name=_("Lesson"),
     )
 
     date = models.DateField(verbose_name=_("Date of exam"), null=True)
@@ -749,9 +681,7 @@ class Holiday(ExtensibleModel):
             holiday_date = week[weekday]
             holidays = list(
                 filter(
-                    lambda h: holiday_date >= h.date_start
-                    and holiday_date <= h.date_end,
-                    holidays,
+                    lambda h: holiday_date >= h.date_start and holiday_date <= h.date_end, holidays,
                 )
             )
             if holidays:
@@ -809,27 +739,15 @@ class Break(ValidityRangeRelatedExtensibleModel):
 
     @property
     def weekday(self):
-        return (
-            self.after_period.weekday
-            if self.after_period
-            else self.before_period.weekday
-        )
+        return self.after_period.weekday if self.after_period else self.before_period.weekday
 
     @property
     def after_period_number(self):
-        return (
-            self.after_period.period
-            if self.after_period
-            else self.before_period.period - 1
-        )
+        return self.after_period.period if self.after_period else self.before_period.period - 1
 
     @property
     def before_period_number(self):
-        return (
-            self.before_period.period
-            if self.before_period
-            else self.after_period.period + 1
-        )
+        return self.before_period.period if self.before_period else self.after_period.period + 1
 
     @property
     def time_start(self):
@@ -870,10 +788,7 @@ class Supervision(ValidityRangeRelatedExtensibleModel, WeekAnnotationMixin):
         Break, models.CASCADE, verbose_name=_("Break"), related_name="supervisions"
     )
     teacher = models.ForeignKey(
-        "core.Person",
-        models.CASCADE,
-        related_name="supervisions",
-        verbose_name=_("Teacher"),
+        "core.Person", models.CASCADE, related_name="supervisions", verbose_name=_("Teacher"),
     )
 
     def get_year(self, week: int) -> int:
@@ -913,10 +828,7 @@ class SupervisionSubstitution(ExtensibleModel):
 
     date = models.DateField(verbose_name=_("Date"))
     supervision = models.ForeignKey(
-        Supervision,
-        models.CASCADE,
-        verbose_name=_("Supervision"),
-        related_name="substitutions",
+        Supervision, models.CASCADE, verbose_name=_("Supervision"), related_name="substitutions",
     )
     teacher = models.ForeignKey(
         "core.Person",
@@ -938,16 +850,12 @@ class SupervisionSubstitution(ExtensibleModel):
         verbose_name_plural = _("Supervision substitutions")
 
 
-class Event(
-    SchoolTermRelatedExtensibleModel, GroupPropertiesMixin, TeacherPropertiesMixin
-):
+class Event(SchoolTermRelatedExtensibleModel, GroupPropertiesMixin, TeacherPropertiesMixin):
     label_ = "event"
 
     objects = EventManager.from_queryset(EventQuerySet)()
 
-    title = models.CharField(
-        verbose_name=_("Title"), max_length=255, blank=True, null=True
-    )
+    title = models.CharField(verbose_name=_("Title"), max_length=255, blank=True, null=True)
 
     date_start = models.DateField(verbose_name=_("Start date"), null=True)
     date_end = models.DateField(verbose_name=_("End date"), null=True)
@@ -959,18 +867,11 @@ class Event(
         related_name="+",
     )
     period_to = models.ForeignKey(
-        "TimePeriod",
-        on_delete=models.CASCADE,
-        verbose_name=_("End time period"),
-        related_name="+",
+        "TimePeriod", on_delete=models.CASCADE, verbose_name=_("End time period"), related_name="+",
     )
 
-    groups = models.ManyToManyField(
-        "core.Group", related_name="events", verbose_name=_("Groups")
-    )
-    rooms = models.ManyToManyField(
-        "Room", related_name="events", verbose_name=_("Rooms")
-    )
+    groups = models.ManyToManyField("core.Group", related_name="events", verbose_name=_("Groups"))
+    rooms = models.ManyToManyField("Room", related_name="events", verbose_name=_("Rooms"))
     teachers = models.ManyToManyField(
         "core.Person", related_name="events", verbose_name=_("Teachers")
     )
@@ -999,29 +900,20 @@ class Event(
 
     class Meta:
         ordering = ["date_start"]
-        indexes = [
-            models.Index(fields=["period_from", "period_to", "date_start", "date_end"])
-        ]
+        indexes = [models.Index(fields=["period_from", "period_to", "date_start", "date_end"])]
         verbose_name = _("Event")
         verbose_name_plural = _("Events")
 
 
-class ExtraLesson(
-    SchoolTermRelatedExtensibleModel, GroupPropertiesMixin, WeekRelatedMixin
-):
+class ExtraLesson(SchoolTermRelatedExtensibleModel, GroupPropertiesMixin, WeekRelatedMixin):
     label_ = "extra_lesson"
 
     objects = ExtraLessonManager.from_queryset(ExtraLessonQuerySet)()
 
-    week = models.IntegerField(
-        verbose_name=_("Week"), default=CalendarWeek.current_week
-    )
+    week = models.IntegerField(verbose_name=_("Week"), default=CalendarWeek.current_week)
     year = models.IntegerField(verbose_name=_("Year"), default=get_current_year)
     period = models.ForeignKey(
-        "TimePeriod",
-        models.CASCADE,
-        related_name="extra_lessons",
-        verbose_name=_("Time period"),
+        "TimePeriod", models.CASCADE, related_name="extra_lessons", verbose_name=_("Time period"),
     )
 
     subject = models.ForeignKey(
@@ -1034,21 +926,13 @@ class ExtraLesson(
         "core.Group", related_name="extra_lessons", verbose_name=_("Groups")
     )
     teachers = models.ManyToManyField(
-        "core.Person",
-        related_name="extra_lessons_as_teacher",
-        verbose_name=_("Teachers"),
+        "core.Person", related_name="extra_lessons_as_teacher", verbose_name=_("Teachers"),
     )
     room = models.ForeignKey(
-        "Room",
-        models.CASCADE,
-        null=True,
-        related_name="extra_lessons",
-        verbose_name=_("Room"),
+        "Room", models.CASCADE, null=True, related_name="extra_lessons", verbose_name=_("Room"),
     )
 
-    comment = models.CharField(
-        verbose_name=_("Comment"), blank=True, null=True, max_length=255
-    )
+    comment = models.CharField(verbose_name=_("Comment"), blank=True, null=True, max_length=255)
 
     def __str__(self):
         return f"{self.week}, {self.period}, {self.subject}"

aleksis/apps/chronos/preferences.py

@@ -27,9 +27,7 @@ class ShortenGroups(BooleanPreference):
     name = "shorten_groups"
     default = True
     verbose_name = _("Shorten groups in timetable views")
-    help_text = _(
-        "If there are more groups than the set limit, they will be collapsed."
-    )
+    help_text = _("If there are more groups than the set limit, they will be collapsed.")
 
 
 @site_preferences_registry.register

aleksis/apps/chronos/rules.py

@@ -11,9 +11,7 @@ from .models import LessonSubstitution
 from .util.predicates import has_timetable_perm
 
 # View timetable overview
-view_timetable_overview_predicate = has_person & has_global_perm(
-    "chronos.view_timetable_overview"
-)
+view_timetable_overview_predicate = has_person & has_global_perm("chronos.view_timetable_overview")
 add_perm("chronos.view_timetable_overview", view_timetable_overview_predicate)
 
 # View my timetable

aleksis/apps/chronos/tables.py

@@ -31,12 +31,8 @@ class LessonsTable(tables.Table):
         row_attrs = {"class": _css_class_from_lesson_state}
 
     period__period = tables.Column(accessor="period__period")
-    lesson__groups = tables.Column(
-        accessor="lesson__group_names", verbose_name=_("Groups")
-    )
-    lesson__teachers = tables.Column(
-        accessor="lesson__teacher_names", verbose_name=_("Teachers")
-    )
+    lesson__groups = tables.Column(accessor="lesson__group_names", verbose_name=_("Groups"))
+    lesson__teachers = tables.Column(accessor="lesson__teacher_names", verbose_name=_("Teachers"))
     lesson__subject = tables.Column(accessor="lesson__subject")
     room = tables.Column(accessor="room")
     edit_substitution = tables.LinkColumn(

aleksis/apps/chronos/urls.py

@@ -17,15 +17,11 @@ urlpatterns = [
         name="timetable_by_week",
     ),
     path(
-        "timetable/<str:type_>/<int:pk>/<str:regular>/",
-        views.timetable,
-        name="timetable_regular",
+        "timetable/<str:type_>/<int:pk>/<str:regular>/", views.timetable, name="timetable_regular",
     ),
     path("lessons/", views.lessons_day, name="lessons_day"),
     path(
-        "lessons/<int:year>/<int:month>/<int:day>/",
-        views.lessons_day,
-        name="lessons_day_by_date",
+        "lessons/<int:year>/<int:month>/<int:day>/", views.lessons_day, name="lessons_day_by_date",
     ),
     path(
         "lessons/<int:id_>/<int:week>/substition/",
@@ -39,10 +35,7 @@ urlpatterns = [
     ),
     path("substitutions/", views.substitutions, name="substitutions"),
     path(
-        "substitutions/print/",
-        views.substitutions,
-        {"is_print": True},
-        name="substitutions_print",
+        "substitutions/print/", views.substitutions, {"is_print": True}, name="substitutions_print",
     ),
     path(
         "substitutions/<int:year>/<int:month>/<int:day>/",

aleksis/apps/chronos/util/build.py

@@ -46,9 +46,7 @@ def build_timetable(
     if is_person:
         lesson_periods = LessonPeriod.objects.daily_lessons_for_person(obj, date_ref)
     else:
-        lesson_periods = LessonPeriod.objects.in_week(date_ref).filter_from_type(
-            type_, obj
-        )
+        lesson_periods = LessonPeriod.objects.in_week(date_ref).filter_from_type(type_, obj)
 
     # Sort lesson periods in a dict
     lesson_periods_per_period = lesson_periods.group_by_periods(is_person=is_person)
@@ -127,10 +125,7 @@ def build_timetable(
         else:
             week = date_ref
         supervisions = (
-            Supervision.objects.in_week(week)
-            .all()
-            .annotate_week(week)
-            .filter_by_teacher(obj)
+            Supervision.objects.in_week(week).all().annotate_week(week).filter_by_teacher(obj)
         )
 
         if is_person:
@@ -145,10 +140,7 @@ def build_timetable(
             if period_after_break not in needed_breaks:
                 needed_breaks.append(period_after_break)
 
-            if (
-                not is_person
-                and period_after_break not in supervisions_per_period_after
-            ):
+            if not is_person and period_after_break not in supervisions_per_period_after:
                 supervisions_per_period_after[period_after_break] = {}
 
             if is_person:
@@ -174,9 +166,7 @@ def build_timetable(
             if not is_person:
                 cols = []
 
-                for weekday in range(
-                    TimePeriod.weekday_min, TimePeriod.weekday_max + 1
-                ):
+                for weekday in range(TimePeriod.weekday_min, TimePeriod.weekday_max + 1):
                     col = None
                     if (
                         period in supervisions_per_period_after
@@ -205,32 +195,21 @@ def build_timetable(
 
             if not is_person:
                 cols = []
-                for weekday in range(
-                    TimePeriod.weekday_min, TimePeriod.weekday_max + 1
-                ):
+                for weekday in range(TimePeriod.weekday_min, TimePeriod.weekday_max + 1):
                     col = []
 
                     # Add lesson periods
-                    if (
-                        period in lesson_periods_per_period
-                        and weekday not in holidays_per_weekday
-                    ):
+                    if period in lesson_periods_per_period and weekday not in holidays_per_weekday:
                         if weekday in lesson_periods_per_period[period]:
                             col += lesson_periods_per_period[period][weekday]
 
                     # Add extra lessons
-                    if (
-                        period in extra_lessons_per_period
-                        and weekday not in holidays_per_weekday
-                    ):
+                    if period in extra_lessons_per_period and weekday not in holidays_per_weekday:
                         if weekday in extra_lessons_per_period[period]:
                             col += extra_lessons_per_period[period][weekday]
 
                     # Add events
-                    if (
-                        period in events_per_period
-                        and weekday not in holidays_per_weekday
-                    ):
+                    if period in events_per_period and weekday not in holidays_per_weekday:
                         if weekday in events_per_period[period]:
                             col += events_per_period[period][weekday]
 
@@ -331,9 +310,7 @@ def build_substitutions_list(wanted_day: date) -> List[dict]:
     return rows
 
 
-def build_weekdays(
-    base: List[Tuple[int, str]], wanted_week: CalendarWeek
-) -> List[dict]:
+def build_weekdays(base: List[Tuple[int, str]], wanted_week: CalendarWeek) -> List[dict]:
     holidays_per_weekday = Holiday.in_week(wanted_week)
 
     weekdays = []
@@ -343,9 +320,7 @@ def build_weekdays(
             "key": key,
             "name": name,
             "date": wanted_week[key],
-            "holiday": holidays_per_weekday[key]
-            if key in holidays_per_weekday
-            else None,
+            "holiday": holidays_per_weekday[key] if key in holidays_per_weekday else None,
         }
         weekdays.append(weekday)
 

aleksis/apps/chronos/util/chronos_helpers.py

@@ -20,10 +20,7 @@ def get_el_by_pk(
 ):
     if type_ == TimetableType.GROUP.value:
         return get_object_or_404(
-            Group.objects.prefetch_related("owners", "parent_groups")
-            if prefetch
-            else Group,
-            pk=pk,
+            Group.objects.prefetch_related("owners", "parent_groups") if prefetch else Group, pk=pk,
         )
     elif type_ == TimetableType.TEACHER.value:
         return get_object_or_404(Person, pk=pk)

aleksis/apps/chronos/views.py

@@ -36,8 +36,7 @@ def all_timetables(request: HttpRequest) -> HttpResponse:
         .order_by("short_name", "last_name")
     )
     groups = Group.objects.for_current_school_term_or_all().annotate(
-        lessons_count=Count("lessons"),
-        child_lessons_count=Count("child_groups__lessons"),
+        lessons_count=Count("lessons"), child_lessons_count=Count("child_groups__lessons"),
     )
     classes = groups.filter(lessons_count__gt=0, parent_groups=None) | groups.filter(
         child_lessons_count__gt=0, parent_groups=None
@@ -69,9 +68,7 @@ def my_timetable(
         wanted_day = timezone.datetime(year=year, month=month, day=day).date()
         wanted_day = TimePeriod.get_next_relevant_day(wanted_day)
     else:
-        wanted_day = TimePeriod.get_next_relevant_day(
-            timezone.now().date(), datetime.now().time()
-        )
+        wanted_day = TimePeriod.get_next_relevant_day(timezone.now().date(), datetime.now().time())
 
     if has_person(request.user):
         person = request.user.person
@@ -141,9 +138,7 @@ def timetable(
 
     # Build lists with weekdays and corresponding dates (long and short variant)
     context["weekdays"] = build_weekdays(TimePeriod.WEEKDAY_CHOICES, wanted_week)
-    context["weekdays_short"] = build_weekdays(
-        TimePeriod.WEEKDAY_CHOICES_SHORT, wanted_week
-    )
+    context["weekdays_short"] = build_weekdays(TimePeriod.WEEKDAY_CHOICES_SHORT, wanted_week)
 
     context["weeks"] = get_weeks_for_year(year=wanted_week.year)
     context["week"] = wanted_week
@@ -154,8 +149,7 @@ def timetable(
     context["week_select"] = {
         "year": wanted_week.year,
         "dest": reverse(
-            "timetable_by_week",
-            args=[type_.value, pk, wanted_week.year, wanted_week.week],
+            "timetable_by_week", args=[type_.value, pk, wanted_week.year, wanted_week.week],
         )
         .replace(str(wanted_week.year), "year")
         .replace(str(wanted_week.week), "cw"),
@@ -195,9 +189,7 @@ def lessons_day(
         wanted_day = timezone.datetime(year=year, month=month, day=day).date()
         wanted_day = TimePeriod.get_next_relevant_day(wanted_day)
     else:
-        wanted_day = TimePeriod.get_next_relevant_day(
-            timezone.now().date(), datetime.now().time()
-        )
+        wanted_day = TimePeriod.get_next_relevant_day(timezone.now().date(), datetime.now().time())
 
     # Get lessons
     lesson_periods = LessonPeriod.objects.on_day(wanted_day)
@@ -251,9 +243,7 @@ def edit_substitution(request: HttpRequest, id_: int, week: int) -> HttpResponse
             messages.success(request, _("The substitution has been saved."))
 
             date = wanted_week[lesson_period.period.weekday]
-            return redirect(
-                "lessons_day_by_date", year=date.year, month=date.month, day=date.day
-            )
+            return redirect("lessons_day_by_date", year=date.year, month=date.month, day=date.day)
 
     context["edit_substitution_form"] = edit_substitution_form
 
@@ -274,9 +264,7 @@ def delete_substitution(request: HttpRequest, id_: int, week: int) -> HttpRespon
     messages.success(request, _("The substitution has been deleted."))
 
     date = wanted_week[lesson_period.period.weekday]
-    return redirect(
-        "lessons_day_by_date", year=date.year, month=date.month, day=date.day
-    )
+    return redirect("lessons_day_by_date", year=date.year, month=date.month, day=date.day)
 
 
 @permission_required("chronos.view_substitutions")
@@ -294,9 +282,7 @@ def substitutions(
         wanted_day = timezone.datetime(year=year, month=month, day=day).date()
         wanted_day = TimePeriod.get_next_relevant_day(wanted_day)
     else:
-        wanted_day = TimePeriod.get_next_relevant_day(
-            timezone.now().date(), datetime.now().time()
-        )
+        wanted_day = TimePeriod.get_next_relevant_day(timezone.now().date(), datetime.now().time())
 
     day_number = get_site_preferences()["chronos__substitutions_print_number_of_days"]
     day_contexts = {}