qcanvas 0.0.3.4a0__py3-none-any.whl → 0.0.4.1a0__py3-none-any.whl

qcanvas/icons/rc_icons.py

@@ -230,10 +230,13 @@ qt_resource_struct = b"\
 \x00\x00\x01\x8d\xcbE['\
 "
 
+
 def qInitResources():
     QtCore.qRegisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data)
 
+
 def qCleanupResources():
     QtCore.qUnregisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data)
 
+
 qInitResources()

qcanvas/net/canvas/__init__.py

@@ -1,2 +1,2 @@
 from .canvas_client import CanvasClient
-from .legacy_canvas_types import LegacyFile, LegacyPage
+from .legacy_canvas_types import LegacyFile, LegacyPage

qcanvas/net/canvas/canvas_client.py

@@ -99,7 +99,8 @@ class CanvasClient(SelfAuthenticating):
     async def get_page(self, page_id: str | int, course_id: str | int) -> LegacyPage:
         async with self._net_op_sem:
             response = detect_ratelimit_and_raise(
-                await self.client.get(self.canvas_url.join(f"api/v1/courses/{course_id}/pages/{page_id}"), **self.get_headers()))
+                await self.client.get(self.canvas_url.join(f"api/v1/courses/{course_id}/pages/{page_id}"),
+                                      **self.get_headers()))
 
             return LegacyPage.from_dict(json.loads(response.text))
 
@@ -155,7 +156,8 @@ class CanvasClient(SelfAuthenticating):
         retries = 0
 
         while retries < self.max_retries:
-            async with self.client.stream(method='GET', url=resource.url, cookies=self.client.cookies, follow_redirects=True) as resp:
+            async with self.client.stream(method='GET', url=resource.url, cookies=self.client.cookies,
+                                          follow_redirects=True) as resp:
                 if await self.reauthenticate_if_needed(resp):
                     retries += 1
                     self._logger.warning("Retrying download of %s", resource.url)

qcanvas/net/canvas/legacy_canvas_types.py

@@ -1,6 +1,5 @@
 from typing import Any, TypeVar, Type, cast
 
-
 T = TypeVar("T")
 
 
@@ -66,7 +65,8 @@ class LegacyFile:
     hidden_for_user: bool
     locked_for_user: bool
 
-    def __init__(self, id: int, uuid: str, display_name: str, filename: str, url: str, size: int, locked: bool, hidden: bool, hidden_for_user: bool, locked_for_user: bool) -> None:
+    def __init__(self, id: int, uuid: str, display_name: str, filename: str, url: str, size: int, locked: bool,
+                 hidden: bool, hidden_for_user: bool, locked_for_user: bool) -> None:
         self.id = id
         self.uuid = uuid
         self.display_name = display_name

qcanvas/net/custom_httpx_async_transport.py

@@ -12,7 +12,8 @@ class CustomHTTPXAsyncTransport(HTTPXAsyncTransport):
     The transport uses the httpx library with anyio.
     """
 
-    def __init__(self, client: httpx.AsyncClient, url: Union[str, httpx.URL], headers: dict[str, Any] | None = None, **kwargs):
+    def __init__(self, client: httpx.AsyncClient, url: Union[str, httpx.URL], headers: dict[str, Any] | None = None,
+                 **kwargs):
         super().__init__(url=url, **kwargs)
         self.client = client
         self.headers = headers or {}
@@ -31,5 +32,3 @@ class CustomHTTPXAsyncTransport(HTTPXAsyncTransport):
         result["headers"] = self.headers
 
         return result
-
-

qcanvas/net/self_authenticating.py

@@ -5,6 +5,7 @@ from asyncio import Lock, Event
 class AuthenticationException(Exception):
     pass
 
+
 # httpx does have an authentication flow mechanism that allows you to also make other requests but I don't know if it
 # will behave the same way as this does. I also finished this before I found out that existed.
 

qcanvas/queries/all_courses.gql

@@ -1,7 +1,7 @@
 # qenerate: plugin=pydantic_v1
 
 query AllCourses($detailed: Boolean!) {
-  allCourses {
-    ...CanvasCourseData
-  }
+    allCourses {
+        ...CanvasCourseData
+    }
 }

qcanvas/queries/all_courses.py

@@ -81,8 +81,8 @@ query AllCourses($detailed: Boolean!) {
 
 class ConfiguredBaseModel(BaseModel):
     class Config:
-        smart_union=True
-        extra=Extra.forbid
+        smart_union = True
+        extra = Extra.forbid
 
 
 class AllCoursesQueryData(ConfiguredBaseModel):

qcanvas/queries/canvas_course_data.py

@@ -72,8 +72,8 @@ fragment CanvasCourseData on Course {
 
 class ConfiguredBaseModel(BaseModel):
     class Config:
-        smart_union=True
-        extra=Extra.forbid
+        smart_union = True
+        extra = Extra.forbid
 
 
 class Term(ConfiguredBaseModel):

qcanvas/ui/container_item.py

@@ -10,12 +10,6 @@ class ContainerItem(QStandardItem):
         self.content = data
         self.setEditable(False)
 
-
     def data(self, role=257):
         if role == Qt.ItemDataRole.DisplayRole:
             return self.content.text
-
-
-
-
-

qcanvas/ui/main_ui.py

@@ -8,8 +8,10 @@ from qasync import asyncSlot
 
 import qcanvas.db.database as db
 from qcanvas.QtVersionHelper.QtCore import Slot, Signal, Qt, QUrl
-from qcanvas.QtVersionHelper.QtGui import QDesktopServices
+from qcanvas.QtVersionHelper.QtGui import QDesktopServices, QAction
 from qcanvas.QtVersionHelper.QtWidgets import *
+from qcanvas.ui.menu_bar.grouping_preferences_menu import GroupingPreferencesMenu
+from qcanvas.ui.menu_bar.theme_selection_menu import ThemeSelectionMenu
 from qcanvas.ui.viewer.course_list import CourseList
 from qcanvas.ui.viewer.file_list import FileRow
 from qcanvas.ui.viewer.file_view_tab import FileViewTab
@@ -20,14 +22,19 @@ from qcanvas.util.course_indexer import DataManager
 
 _aux_settings = AppSettings.auxiliary
 
+
 class AppMainWindow(QMainWindow):
     logger = logging.getLogger()
     loaded = Signal()
+    files_grouping_preference_changed = Signal(db.GroupByPreference)
     operation_lock = Event()
 
     def __init__(self, data_manager: DataManager, parent: QWidget | None = None):
         super().__init__(parent)
 
+        self.group_by_pages_action: QAction | None = None
+        self.group_by_modules_action: QAction | None = None
+        self.file_grouping_menu: QMenu | None = None
         self.selected_course: db.Course | None = None
         self.courses: Sequence[db.Course] = []
         self.resources: dict[str, db.Resource] = {}
@@ -50,8 +57,6 @@ class AppMainWindow(QMainWindow):
         self.pages_viewer.viewer.anchorClicked.connect(self.viewer_link_clicked)
 
         self.file_viewer = FileViewTab(data_manager.download_pool)
-        self.file_viewer.group_by_preference_changed.connect(self.course_file_group_by_preference_changed)
-
         self.file_viewer.files_column.tree.itemActivated.connect(self.download_file_from_file_pane)
         self.file_viewer.assignment_files_column.tree.itemActivated.connect(self.download_file_from_file_pane)
 
@@ -73,17 +78,36 @@ class AppMainWindow(QMainWindow):
         widget.setLayout(v_layout)
         self.setCentralWidget(widget)
 
+        self.setup_menu_bar()
+
+        self.files_grouping_preference_changed.connect(self.on_grouping_preference_changed)
+
         self.loaded.connect(self.load_course_list)
         self.loaded.connect(self.check_for_update)
         self.loaded.emit()
 
-        self.read_settings()
+        self.restore_window_position()
+
+    def setup_menu_bar(self):
+        menu_bar = self.menuBar()
+
+        menu_bar.addMenu(ThemeSelectionMenu())
+        view_menu = menu_bar.addMenu("View")
+
+        view_menu.addMenu(self.setup_group_by_menu())
+
+    def setup_group_by_menu(self) -> QMenu:
+        file_grouping_menu = GroupingPreferencesMenu(self.data_manager)
+        self.course_list.course_selected.connect(file_grouping_menu.course_changed)
+        file_grouping_menu.preference_changed.connect(self.on_grouping_preference_changed)
+
+        return file_grouping_menu
 
     def closeEvent(self, event):
         _aux_settings.setValue("geometry", self.saveGeometry())
         _aux_settings.setValue("windowState", self.saveState())
 
-    def read_settings(self):
+    def restore_window_position(self):
         self.restoreGeometry(_aux_settings.value("geometry"))
         self.restoreState(_aux_settings.value("windowState"))
 
@@ -97,14 +121,12 @@ class AppMainWindow(QMainWindow):
             await self.data_manager.download_resource(resource)
             QDesktopServices.openUrl(QUrl.fromLocalFile(resource.download_location.absolute()))
 
-
     @asyncSlot(QTreeWidgetItem, int)
-    async def download_file_from_file_pane(self, item: QTreeWidgetItem, _ : int):
+    async def download_file_from_file_pane(self, item: QTreeWidgetItem, _: int):
         if isinstance(item, FileRow):
             await self.data_manager.download_resource(item.resource)
             QDesktopServices.openUrl(QUrl.fromLocalFile(item.resource.download_location.absolute()))
 
-
     @asyncSlot()
     async def sync_data(self):
         # # self.operation_lock.
@@ -118,8 +140,6 @@ class AppMainWindow(QMainWindow):
             self.sync_button.setEnabled(True)
             self.sync_button.setText("Synchronize")
 
-
-
     @asyncSlot()
     async def load_course_list(self):
         self.courses = (await self.data_manager.get_data())
@@ -134,13 +154,13 @@ class AppMainWindow(QMainWindow):
     @asyncSlot()
     async def check_for_update(self):
         try:
-            newer_version = await self_updater.get_newer_version()
+            newer_version, installed_version = await self_updater.get_newer_version()
 
             if newer_version is not None and newer_version != AppSettings.last_ignored_update:
                 msg_box = QMessageBox(
                     QMessageBox.Icon.Question,
                     "Update available",
-                    "There is an update available, do you want to update?\nThe program will close after the update is finished.",
+                    f"There is an update available ({installed_version} -> {newer_version})\n do you want to update?\nThe program will close after the update is finished.",
                     QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                     self
                 )
@@ -180,6 +200,7 @@ class AppMainWindow(QMainWindow):
     def on_course_selected(self, course: Optional[db.Course]):
         if course is not None:
             self.selected_course = course
+            # todo these should really be slots connected to this signal...
             self.pages_viewer.fill_tree(course)
             self.assignment_viewer.fill_tree(course)
             self.file_viewer.load_course_files(course)
@@ -187,11 +208,6 @@ class AppMainWindow(QMainWindow):
             self.selected_course = None
             self.file_viewer.clear()
 
-
     @asyncSlot(db.CoursePreferences)
-    async def course_file_group_by_preference_changed(self, preference: db.GroupByPreference):
-        self.selected_course.preferences.files_group_by_preference = preference
-        await self.data_manager.update_item(self.selected_course.preferences)
+    async def on_grouping_preference_changed(self):
         self.file_viewer.load_course_files(self.selected_course)
-
-

qcanvas/ui/menu_bar/grouping_preferences_menu.py

@@ -0,0 +1,61 @@
+from qasync import asyncSlot
+
+import qcanvas.db as db
+from qcanvas.QtVersionHelper.QtCore import Slot, Signal
+from qcanvas.QtVersionHelper.QtGui import create_qaction
+from qcanvas.QtVersionHelper.QtWidgets import QMenu, QWidget
+from qcanvas.util.course_indexer import DataManager
+
+
+class GroupingPreferencesMenu(QMenu):
+    _preference_changed_private = Signal(db.GroupByPreference)
+    preference_changed = Signal()
+
+    def __init__(self, data_manager: DataManager, parent: QWidget | None = None):
+        super().__init__("Group files by", parent)
+        self.setEnabled(False)
+
+        self.data_manager = data_manager
+        self._selected_course: db.Course | None = None
+
+        self.group_by_modules_action = self._make_action("Modules", db.GroupByPreference.GROUP_BY_MODULES)
+        self.group_by_pages_action = self._make_action("Pages", db.GroupByPreference.GROUP_BY_PAGES)
+
+        self.addActions([self.group_by_pages_action, self.group_by_modules_action])
+
+        self._preference_changed_private.connect(self._on_preference_changed)
+
+    def _make_action(self, text: str, preference_value: db.GroupByPreference):
+        return create_qaction(
+            name=text,
+            parent=self,
+            triggered=lambda: self._preference_changed_private.emit(preference_value),
+            checkable=True,
+            checked=False
+        )
+
+    @Slot()
+    def course_changed(self, course: db.Course | None):
+        if course is not None:
+            self._selected_course = course
+            self._update_actions()
+            self.setEnabled(True)
+        else:
+            self._selected_course = None
+            self.setEnabled(False)
+
+    @asyncSlot()
+    async def _on_preference_changed(self, preference: db.GroupByPreference):
+        if self._selected_course is not None:
+            self._selected_course.preferences.files_group_by_preference = preference
+            self._update_actions()
+            # todo not sure if this should go in main_ui or here...
+            await self.data_manager.update_item(self._selected_course.preferences)
+
+            self.preference_changed.emit()
+
+    def _update_actions(self):
+        preference = self._selected_course.preferences.files_group_by_preference
+
+        self.group_by_pages_action.setChecked(preference == db.GroupByPreference.GROUP_BY_PAGES)
+        self.group_by_modules_action.setChecked(preference == db.GroupByPreference.GROUP_BY_MODULES)

qcanvas/ui/menu_bar/theme_selection_menu.py

@@ -0,0 +1,36 @@
+from qcanvas.QtVersionHelper.QtGui import QActionGroup
+from qcanvas.QtVersionHelper.QtGui import create_qaction
+from qcanvas.QtVersionHelper.QtWidgets import QMenu, QWidget
+from qcanvas.util import AppSettings
+
+
+def change_theme(theme_name: str):
+    AppSettings.theme = theme_name
+    AppSettings.apply_selected_theme()
+
+
+class ThemeSelectionMenu(QMenu):
+    def __init__(self, parent: QWidget | None = None):
+        super().__init__("Theme", parent)
+
+        action_group = QActionGroup(self)
+
+        light_theme = self._create_action("Light", "light")
+        dark_theme = self._create_action("Dark", "dark")
+        native_theme = self._create_action("Native (requires restart)", "native")
+
+        actions = [light_theme, dark_theme, native_theme]
+
+        self.addActions(actions)
+
+        for theme in actions:
+            action_group.addAction(theme)
+
+    def _create_action(self, text: str, theme_name: str):
+        return create_qaction(
+            name=text,
+            parent=self,
+            triggered=lambda: change_theme(theme_name),
+            checkable=True,
+            checked=AppSettings.theme == theme_name
+        )

qcanvas/ui/setup_dialog.py

@@ -14,6 +14,7 @@ from qcanvas.util import AppSettings
 
 tutorial_url = "https://www.iorad.com/player/2053777/Canvas---How-to-generate-an-access-token-"
 
+
 def row(name: str) -> QWidget:
     widget = QWidget()
     layout = QHBoxLayout()
@@ -78,7 +79,7 @@ class SetupDialog(QDialog):
                                       "Error",
                                       f"{name} is invalid",
                                       parent=self
-                    )
+                                      )
                     msg.show()
 
                 def ensure_protocol(url: str):
@@ -104,7 +105,7 @@ class SetupDialog(QDialog):
                                       "Error",
                                       f"The canvas URL or API key is invalid.\nPlease check you entered them correctly.",
                                       parent=self
-                    )
+                                      )
                     msg.show()
                 else:
                     AppSettings.canvas_url = canvas_url_text
@@ -144,7 +145,6 @@ Don't share this key. You can revoke it at any time.""",
         msg.accepted.connect(lambda: QDesktopServices.openUrl(tutorial_url))
         msg.show()
 
-
     def _row(self, name: str, widget: QWidget):
         self.grid.addWidget(QLabel(name), self._row_counter, 0)
         self.grid.addWidget(widget, self._row_counter, 1)

qcanvas/ui/viewer/course_list.py

@@ -18,7 +18,7 @@ class CourseNode(QStandardItem, QObject):
         QStandardItem.__init__(self, course.preferences.local_name or course.name)
         self.course = course
 
-    def setData(self, value, role = ...):
+    def setData(self, value, role=...):
         if isinstance(value, str):
             value = value.strip()
 
@@ -93,5 +93,3 @@ class CourseList(QTreeView):
 
             if isinstance(item, CourseNode):
                 self.course_selected.emit(item.course)
-
-

qcanvas/ui/viewer/file_list.py

@@ -130,7 +130,6 @@ class FileList(QTreeWidget):
             # Update the download column
             self.model().dataChanged.emit(index, index, Qt.ItemDataRole.DisplayRole)
 
-
     def _setup_header(self):
         self.setColumnCount(4)
         self.setHeaderLabels(["Name", "Date Found", "Size", "Download"])
@@ -167,7 +166,7 @@ class FileList(QTreeWidget):
             # Create the group node for this item
             group_node = QTreeWidgetItem([item.name])
 
-            #fixme this does not remove duplicate files e.g. when on module groups
+            # fixme this does not remove duplicate files e.g. when on module groups
 
             for resource in resources:
                 row = FileRow(resource)
@@ -193,4 +192,3 @@ class FileList(QTreeWidget):
         super().clear()
         self._setup_header()
         self.row_id_map.clear()
-

qcanvas/ui/viewer/file_view_tab.py

@@ -1,8 +1,6 @@
 from typing import Sequence
 
 import qcanvas.db as db
-from qcanvas.QtVersionHelper.QtCore import Signal, Qt, Slot, QPoint
-from qcanvas.QtVersionHelper.QtGui import QActionGroup, create_qaction
 from qcanvas.QtVersionHelper.QtWidgets import *  # QWidget, QTreeView, QGroupBox, QBoxLayout, QHeaderView, QHBoxLayout, QComboBox, QLabel
 from qcanvas.ui.viewer.file_list import FileList
 from qcanvas.util.constants import default_assignments_module_names
@@ -25,7 +23,6 @@ class FileColumn(QGroupBox):
 
 
 class FileViewTab(QWidget):
-    group_by_preference_changed = Signal(db.GroupByPreference)
 
     def __init__(self, download_pool: DownloadPool):
         super().__init__()
@@ -33,37 +30,13 @@ class FileViewTab(QWidget):
         self.files_column = FileColumn("Files", download_pool)
         self.assignment_files_column = FileColumn("Assignment files", download_pool)
 
-        self.group_by_combobox = QComboBox()
-
-        self.group_by_preference: db.GroupByPreference | None = None
-        self.group_preference_layout = QHBoxLayout()
-        self.group_preference_layout.addWidget(QLabel("Group By:"))
-        self.group_preference_layout.addWidget(self.group_by_combobox)
-        self.group_preference_layout.setStretch(1, 1)
-
-        widget = QWidget()
-        widget.setLayout(self.group_preference_layout)
-
-        # fixme this can't stay here
-        self.files_column.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
-        self.files_column.customContextMenuRequested.connect(self.files_column_context_menu)
-
-        self.group_by_preference_changed.connect(self.update_group_by_preferences)
-
         layout = QHBoxLayout()
         layout.addWidget(self.files_column)
         layout.addWidget(self.assignment_files_column)
 
         self.setLayout(layout)
 
-    @Slot(db.GroupByPreference)
-    def update_group_by_preferences(self, preference : db.GroupByPreference):
-        if self.group_by_preference is not None:
-            self.group_by_preference = preference
-
     def load_course_files(self, course: db.Course):
-        self.group_by_preference = course.preferences.files_group_by_preference
-
         module_items: list[db.ModuleItem] = []
         assignment_items: list[db.ModuleItem] = []
 
@@ -73,8 +46,9 @@ class FileViewTab(QWidget):
             else:
                 module_items.append(module_item)
 
-        if self.group_by_preference == db.GroupByPreference.GROUP_BY_MODULES:
-            exclude_assignments_module = list(filter(lambda x: x.name.lower() not in default_assignments_module_names, course.modules))
+        if course.preferences.files_group_by_preference == db.GroupByPreference.GROUP_BY_MODULES:
+            exclude_assignments_module = list(
+                filter(lambda x: x.name.lower() not in default_assignments_module_names, course.modules))
 
             self.files_column.load_items(exclude_assignments_module)
         else:
@@ -83,40 +57,5 @@ class FileViewTab(QWidget):
         self.assignment_files_column.load_items(assignment_items + course.assignments)
 
     def clear(self):
-        self.group_by_preference = None
         self.files_column.clear()
         self.assignment_files_column.clear()
-
-    @Slot(QPoint)
-    def files_column_context_menu(self, pos: QPoint):
-        if self.group_by_preference is None:
-            return
-
-        menu = QMenu(self.files_column)
-
-        group_by_menu = menu.addMenu("Group by")
-
-        select_group_preference_modules = create_qaction(
-            name="Modules",
-            checkable=True,
-            checked=self.group_by_preference == db.GroupByPreference.GROUP_BY_MODULES,
-            triggered=lambda: self.group_by_preference_changed.emit(db.GroupByPreference.GROUP_BY_MODULES)
-        )
-
-        select_group_preference_pages = create_qaction(
-            name="Pages",
-            checkable=True,
-            checked=self.group_by_preference == db.GroupByPreference.GROUP_BY_PAGES,
-            triggered=lambda: self.group_by_preference_changed.emit(db.GroupByPreference.GROUP_BY_PAGES)
-        )
-
-        action_group = QActionGroup(menu)
-        action_group.addAction(select_group_preference_modules)
-        action_group.addAction(select_group_preference_pages)
-
-        group_by_menu.addAction(select_group_preference_pages)
-        group_by_menu.addAction(select_group_preference_modules)
-
-        menu.exec(self.files_column.mapToGlobal(pos))
-
-

qcanvas/util/__init__.py

@@ -1,3 +1,3 @@
 from .app_settings import _AppSettings
 
-AppSettings = _AppSettings()
+AppSettings = _AppSettings()

qcanvas/util/app_settings.py

@@ -1,6 +1,15 @@
+import qdarktheme
+
 from qcanvas.QtVersionHelper.QtCore import QSettings, QUrl
 
 
+def ensure_theme_is_valid(theme: str) -> str:
+    if theme not in ["auto", "light", "dark", "native"]:
+        return "light"
+    else:
+        return theme
+
+
 class _AppSettings:
     def __init__(self):
         self.settings = QSettings("QCanvas", "client")
@@ -8,6 +17,7 @@ class _AppSettings:
         self._canvas_url = self.settings.value("canvas_url", None)
         self._api_key = self.settings.value("api_key", defaultValue=None)
         self._ignored_update = self.settings.value("ignored_update", defaultValue=None)
+        self._theme = ensure_theme_is_valid(self.settings.value("theme", defaultValue="light"))
 
     @property
     def canvas_url(self) -> str | None:
@@ -37,7 +47,23 @@ class _AppSettings:
         self.settings.setValue("ignored_update", value)
 
     @property
-    def is_set(self):
-        return self.canvas_url is not None and QUrl(self.canvas_url).isValid() and self.canvas_url is not None
+    def theme(self) -> str | None:
+        return self._theme
 
+    @theme.setter
+    def theme(self, value: str):
+        value = ensure_theme_is_valid(value)
+        self._theme = value
+        self.settings.setValue("theme", value)
 
+    # fixme should this really be here
+    def apply_selected_theme(self):
+        if self.theme != "native":
+            qdarktheme.setup_theme(
+                self.theme,
+                custom_colors={"primary": "FF804F"}
+            )
+
+    @property
+    def is_set(self):
+        return self.canvas_url is not None and QUrl(self.canvas_url).isValid() and self.canvas_url is not None

qcanvas/util/constants.py

@@ -1,3 +1,3 @@
 default_assignments_module_names = ["assessments", "assessment"]
 app_name = "QCanvas"
-package_name = "qcanvas"
+package_name = "qcanvas"

qcanvas/util/course_indexer/__init__.py

@@ -1 +1 @@
-from .data_manager import DataManager
+from .data_manager import DataManager

qcanvas/util/course_indexer/data_manager.py

@@ -33,7 +33,8 @@ class TransientModulePage:
     position: int
 
 
-def _prepare_out_of_date_pages_for_loading(g_courses: Sequence[queries.Course], pages: Sequence[db.ModuleItem]) -> list[TransientModulePage]:
+def _prepare_out_of_date_pages_for_loading(g_courses: Sequence[queries.Course], pages: Sequence[db.ModuleItem]) -> list[
+    TransientModulePage]:
     """
     Removes pages that are up-to-date from the pages list by comparing the last update time of the pages from the query
     to the last update time of the pages in the database.
@@ -70,6 +71,7 @@ def _prepare_out_of_date_pages_for_loading(g_courses: Sequence[queries.Course],
 
     return result
 
+
 # todo make this reusable and add some way of refreshing only a list of pages or one page or one course or something
 # todo use logger instead of print and put some signals around the place for useful things, e.g. indexing progress
 class DataManager:
@@ -111,7 +113,7 @@ class DataManager:
             self._add_resources_and_pages_to_taskpool(existing_pages=existing_pages,
                                                       existing_resources=existing_resources)
 
-    async def _download_resource_helper(self, link_handler : ResourceScanner, resource: db.Resource):
+    async def _download_resource_helper(self, link_handler: ResourceScanner, resource: db.Resource):
         try:
             async for progress in link_handler.download(resource):
                 yield progress
@@ -263,7 +265,8 @@ class DataManager:
         self._moduleitem_pool.add_values({page.id: page for page in existing_pages})
         self._resource_pool.add_values({resource.id: resource for resource in existing_resources})
         # Add downloaded resources to the resource pool so we don't download them again
-        self.download_pool.add_values({resource.id: None for resource in existing_resources if resource.state == db.ResourceState.DOWNLOADED})
+        self.download_pool.add_values(
+            {resource.id: None for resource in existing_resources if resource.state == db.ResourceState.DOWNLOADED})
 
     async def _load_page_content(self, pages: Sequence[TransientModulePage]) -> list[db.ModuleItem]:
         """
@@ -282,7 +285,8 @@ class DataManager:
             content = page.page
 
             if isinstance(content, queries.File):
-                task = asyncio.create_task(self._load_module_file(content, page.course_id, page.module_id, page.position))
+                task = asyncio.create_task(
+                    self._load_module_file(content, page.course_id, page.module_id, page.position))
                 tasks.append(task)
             elif isinstance(content, queries.Page):
                 tasks.append(