qcanvas 1.0.12.dev3__py3-none-any.whl → 1.2.0a0__py3-none-any.whl

qcanvas/run.py

@@ -1,5 +1,29 @@
+# nuitka-project: --enable-plugin=pyside6
+# nuitka-project: --windows-icon-from-ico=./deploy/windows/qcanvas.ico
+# nuitka-project: --windows-console-mode=attach
+# nuitka-project: --linux-icon=deploy/appimage/qcanvas.svg
+# nuitka-project: --standalone
+# nuitka-project: --include-module=yt_dlp
+
+# Anti-bloat
+
+##########################################################
+# nuitka-project: --include-package=aiosqlite
+# nuitka-project: --nofollow-import-to=aiosqlite.tests.*
+##########################################################
+# nuitka-project: --nofollow-import-to=rich
+##########################################################
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.mssql
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.postgresql
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.oracle
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.mysql
+##########################################################
+# nuitka-project: --nofollow-import-to=rich
+##########################################################
+# nuitka-project: --nofollow-import-to=yt_dlp.extractor.lazy_extractors
+
 import logging
-from logging import INFO, WARNING
+from logging import DEBUG, INFO, WARNING
 
 import qcanvas.app_start
 from qcanvas.util import logs, paths
@@ -18,6 +42,7 @@ logs.set_levels(
         "qcanvas.ui": WARNING,
         "qcanvas_backend": INFO,
         "qcanvas.ui.main_ui.status_bar_progress_display": INFO,
+        "qcanvas.util.themes": DEBUG,
     }
 )
 

qcanvas/ui/course_viewer/content_tree.py

@@ -45,8 +45,8 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         *,
         header_text: str | Sequence[str],
         indentation: int = 20,
-        max_width: int,
-        min_width: int,
+        max_width: Optional[int] = None,
+        min_width: Optional[int] = None,
     ) -> None:
         if not isinstance(header_text, str) and isinstance(header_text, Sequence):
             self.setHeaderLabels(header_text)
@@ -54,8 +54,25 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
             self.setHeaderLabel(header_text)
 
         self.setIndentation(indentation)
-        self.setMaximumWidth(max_width)
-        self.setMinimumWidth(min_width)
+
+        if max_width is not None:
+            self.setMaximumWidth(max_width)
+
+        if min_width is not None:
+            self.setMinimumWidth(min_width)
+
+    def set_columns_resize_mode(
+        self,
+        resize_mode_for_columns: list[QHeaderView.ResizeMode],
+        *,
+        stretch_last: bool = False,
+    ) -> None:
+        header = self.header()
+
+        for index, mode in enumerate(resize_mode_for_columns):
+            header.setSectionResizeMode(index, mode)
+
+        header.setStretchLastSection(stretch_last)
 
     def reload(self, data: T, *, sync_receipt: SyncReceipt) -> None:
         self._reloading = True

qcanvas/ui/course_viewer/course_viewer.py

@@ -7,6 +7,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtWidgets import *
 
 from qcanvas.ui.course_viewer.tabs.assignment_tab import AssignmentTab
+from qcanvas.ui.course_viewer.tabs.file_tab import FileTab
 from qcanvas.ui.course_viewer.tabs.mail_tab import MailTab
 from qcanvas.ui.course_viewer.tabs.page_tab import PageTab
 from qcanvas.util.basic_fonts import bold_font
@@ -47,18 +48,17 @@ class CourseViewer(QWidget):
             downloader=downloader,
             sync_receipt=sync_receipt,
         )
-        # self._files_tab = FileTab.create_from_receipt(
-        #     course=course,
-        #     downloader=downloader,
-        #     sync_receipt=sync_receipt,
-        # )
+        self._files_tab = FileTab.create_from_receipt(
+            course=course,
+            downloader=downloader,
+            sync_receipt=sync_receipt,
+        )
 
         self._tabs = QTabWidget()
+        self._tabs.addTab(self._files_tab, "Files")
         self._tabs.addTab(self._pages_tab, "Pages")
         self._tabs.addTab(self._assignments_tab, "Assignments")
         self._tabs.addTab(self._mail_tab, "Mail")
-        self._tabs.addTab(QLabel("Not implemented"), "Files")
-        # self._tabs.addTab(self._files_tab, "Files")
         # self._tabs.addTab(QLabel("Not implemented"), "Panopto")  # The meme lives on!
 
         self.setLayout(layout(QVBoxLayout, self._course_label, self._tabs))
@@ -69,10 +69,10 @@ class CourseViewer(QWidget):
         self._unhighlight_tab(0)  # Because the first tab always gets auto-selected
 
     def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
+        self._files_tab.reload(course, sync_receipt=sync_receipt)
         self._pages_tab.reload(course, sync_receipt=sync_receipt)
         self._assignments_tab.reload(course, sync_receipt=sync_receipt)
         self._mail_tab.reload(course, sync_receipt=sync_receipt)
-
         self._highlight_tabs(sync_receipt)
 
     @Slot(int)
@@ -84,18 +84,17 @@ class CourseViewer(QWidget):
         updates = sync_receipt.updates_by_course.get(self._course_id, None)
 
         if updates is not None:
-            # if len(updates.updated_resources) > 0:
-            #     raise Exception("Looks like you forgot to update the other numbers??????"")
-            #     self._highlight_tab(0)
+            if len(updates.updated_resources) > 0:
+                self._highlight_tab(0)
 
             if len(updates.updated_pages) > 0:
-                self._highlight_tab(0)
+                self._highlight_tab(1)
 
             if len(updates.updated_assignments) > 0:
-                self._highlight_tab(1)
+                self._highlight_tab(2)
 
             if len(updates.updated_messages) > 0:
-                self._highlight_tab(2)
+                self._highlight_tab(3)
         else:
             for index in range(0, 4):
                 self._unhighlight_tab(index)

qcanvas/ui/course_viewer/tabs/assignment_tab/assignment_tree.py

@@ -18,6 +18,7 @@ class AssignmentTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.assignment_groups",
             emit_selection_signal_for_type=db.Assignment,
         )
+
         self.ui_setup(
             header_text=["Assignments", "Weight"],
             indentation=15,
@@ -25,13 +26,9 @@ class AssignmentTree(ContentTree[db.Course]):
             min_width=150,
         )
 
-        self._adjust_header()
-
-    def _adjust_header(self) -> None:
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setStretchLastSection(False)
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
 
     def create_tree_items(
         self, course: db.Course, sync_receipt: SyncReceipt
@@ -39,8 +36,11 @@ class AssignmentTree(ContentTree[db.Course]):
         widgets = []
 
         for assignment_group in course.assignment_groups:  # type: db.AssignmentGroup
+            if len(assignment_group.assignments) == 0:
+                continue
+
             assignment_group_widget = self._create_assignment_group_widget(
-                assignment_group, sync_receipt
+                assignment_group
             )
 
             widgets.append(assignment_group_widget)
@@ -54,7 +54,7 @@ class AssignmentTree(ContentTree[db.Course]):
         return widgets
 
     def _create_assignment_group_widget(
-        self, assignment_group: db.AssignmentGroup, sync_receipt: SyncReceipt
+        self, assignment_group: db.AssignmentGroup
     ) -> MemoryTreeWidgetItem:
         assignment_group_widget = MemoryTreeWidgetItem(
             id=assignment_group.id,
@@ -64,9 +64,6 @@ class AssignmentTree(ContentTree[db.Course]):
 
         assignment_group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
 
-        if sync_receipt.was_updated(assignment_group):
-            self.mark_as_unseen(assignment_group_widget)
-
         return assignment_group_widget
 
     def _create_assignment_widget(

qcanvas/ui/course_viewer/tabs/file_tab/__init__.py

@@ -0,0 +1 @@
+from .file_tab import FileTab

qcanvas/ui/course_viewer/tabs/file_tab/file_tab.py

@@ -0,0 +1,46 @@
+import logging
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.tabs.file_tab.pages_file_tree import PagesFileTree
+from qcanvas.util.layouts import layout
+
+_logger = logging.getLogger(__name__)
+
+
+class FileTab(QWidget):
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: SyncReceipt,
+        downloader: ResourceManager,
+    ) -> "FileTab":
+        return FileTab(course=course, sync_receipt=sync_receipt, downloader=downloader)
+
+    def __init__(
+        self,
+        course: db.Course,
+        downloader: ResourceManager,
+        *,
+        sync_receipt: SyncReceipt = None,
+    ):
+        super().__init__()
+
+        self._page_file_tree = PagesFileTree.create_from_receipt(
+            course, sync_receipt=sync_receipt, resource_manager=downloader
+        )
+        # self._assignment_file_tree = FileTree.create_from_receipt(
+        #     course,
+        #     sync_receipt=sync_receipt,
+        #     mode="assignments",
+        #     resource_manager=downloader,
+        # )
+
+        self.setLayout(layout(QHBoxLayout, self._page_file_tree))
+
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
+        pass

qcanvas/ui/course_viewer/tabs/file_tab/file_tree.py

@@ -0,0 +1,95 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+from qtpy.QtCore import QPoint, Qt, Slot
+from qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+from qcanvas.util.file_icons import icon_for_filename
+from qcanvas.util.ui_tools import create_qaction
+
+_logger = logging.getLogger(__name__)
+
+
+T = TypeVar("T")
+
+
+class FileTree(ContentTree[db.Course]):
+    @classmethod
+    def create_from_receipt(
+        cls,
+        course: db.Course,
+        *,
+        sync_receipt: SyncReceipt,
+        resource_manager: ResourceManager,
+    ) -> "FileTree":
+        tree = cls(tree_name=course.id, resource_manager=resource_manager)
+        tree.reload(course, sync_receipt=sync_receipt)
+        return tree
+
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(tree_name, emit_selection_signal_for_type=object)
+        self._resource_manager = resource_manager
+
+        self.ui_setup(header_text=["File", "Date"])
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._context_menu)
+
+    def _create_group_widget(
+        self, group: db.ContentGroup, sync_receipt: SyncReceipt
+    ) -> MemoryTreeWidgetItem:
+        group_widget = MemoryTreeWidgetItem(
+            id=group.id, data=group, strings=[group.name]
+        )
+
+        group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        if sync_receipt.was_updated(group):
+            self.mark_as_unseen(group_widget)
+
+        return group_widget
+
+    def _create_resource_widget(
+        self, resource: db.Resource, sync_receipt: SyncReceipt
+    ) -> QTreeWidgetItem:
+        # fixme the reesource widget items shouls NOT be a memory widget item because they can't be collapsed, but
+        #  mostly because the same file can appear in the tree multiple times in different places, which memory tree
+        #  can NOT deal with!
+        item_widget = QTreeWidgetItem(
+            [resource.file_name, str(resource.discovery_date.date())],
+        )
+        item_widget.setIcon(
+            0,
+            icon_for_filename(resource.file_name),
+        )
+        item_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+
+        if sync_receipt.was_updated(resource):
+            self.mark_as_unseen(item_widget)
+
+        return item_widget
+
+    @Slot(QPoint)
+    def _context_menu(self, point: QPoint) -> None:
+        item = self.itemAt(point)
+
+        if item is None or not isinstance(item, MemoryTreeWidgetItem):
+            return
+
+        menu = QMenu()
+        create_qaction(
+            name="Test",
+            parent=menu,
+            triggered=lambda: print(f"Clicked {item.extra_data.file_name}"),
+        )
+        menu.addAction("Another thing")
+
+        menu.exec(self.mapToGlobal(point))

qcanvas/ui/course_viewer/tabs/file_tab/pages_file_tree.py

@@ -0,0 +1,50 @@
+import logging
+from typing import *
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+
+from qcanvas.ui.course_viewer.tabs.file_tab.file_tree import FileTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class PagesFileTree(FileTree):
+
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(
+            tree_name=f"{tree_name}.pages", resource_manager=resource_manager
+        )
+
+    def create_tree_items(
+        self, data: db.Course, sync_receipt: SyncReceipt
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for group in data.modules:  # type: db.Module
+            if len(group.content_items) == 0:
+                continue
+
+            group_widget = self._create_group_widget(group, sync_receipt)
+            items_in_group = set()
+
+            for item in group.content_items:
+                for resource in item.resources:  # type: db.Resource
+
+                    if resource.id not in items_in_group:
+                        items_in_group.add(resource.id)
+                    else:
+                        continue
+
+                    resource_widget = self._create_resource_widget(
+                        resource, sync_receipt
+                    )
+
+                    group_widget.addChild(resource_widget)
+
+            if group_widget.childCount() > 0:
+                widgets.append(group_widget)
+
+        return widgets

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tree.py

@@ -18,6 +18,7 @@ class MailTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.mail",
             emit_selection_signal_for_type=db.CourseMessage,
         )
+
         self.ui_setup(
             header_text=["Subject", "Sender"],
             max_width=500,
@@ -25,13 +26,9 @@ class MailTree(ContentTree[db.Course]):
             indentation=20,
         )
 
-        self._adjust_header()
-
-    def _adjust_header(self) -> None:
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setStretchLastSection(False)
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
 
     def create_tree_items(
         self, course: db.Course, sync_receipt: SyncReceipt

qcanvas/ui/course_viewer/tabs/page_tab/page_tree.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Sequence
+from typing import Sequence
 
 import qcanvas_backend.database.types as db
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
@@ -17,6 +17,7 @@ class PageTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.modules",
             emit_selection_signal_for_type=db.ModulePage,
         )
+
         self.ui_setup(
             header_text="Content", indentation=15, max_width=300, min_width=150
         )
@@ -27,7 +28,10 @@ class PageTree(ContentTree[db.Course]):
         widgets = []
 
         for module in course.modules:  # type: db.Module
-            module_widget = self._create_module_widget(module, sync_receipt)
+            if len(module.pages) == 0:
+                continue
+
+            module_widget = self._create_module_widget(module)
             widgets.append(module_widget)
 
             for page in module.pages:  # type: db.ModulePage
@@ -36,18 +40,12 @@ class PageTree(ContentTree[db.Course]):
 
         return widgets
 
-    def _create_module_widget(
-        self, module: db.Module, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
+    def _create_module_widget(self, module: db.Module) -> MemoryTreeWidgetItem:
         module_widget = MemoryTreeWidgetItem(
             id=module.id, data=module, strings=[module.name]
         )
         module_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
 
-        # Todo not sure if modules should get highlighted since they can't be unhighlighted by selecting them...
-        if sync_receipt.was_updated(module):
-            self.mark_as_unseen(module_widget)
-
         return module_widget
 
     def _create_page_widget(

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -50,12 +50,6 @@ class ResourceRichBrowser(QTextBrowser):
             self._downloader.download_finished.connect(self._download_updated)
             self._downloader.download_failed.connect(self._download_updated)
 
-        # _dark_listener.theme_changed.connect(self._theme_changed)
-
-    # @Slot()
-    # def _theme_changed(self, theme: str) -> None:
-    #     print(theme)
-
     def show_blank(self, completely_blank: bool = False) -> None:
         if completely_blank:
             self.clear()
@@ -102,16 +96,31 @@ class ResourceRichBrowser(QTextBrowser):
                     )
                     continue
 
-                file_link_tag = self._create_resource_link_tag(doc, resource_id)
+                file_link_tag = self._create_resource_link_tag(
+                    doc, resource_id, resource_link.name == "img"
+                )
                 resource_link.replace_with(file_link_tag)
             except NoExtractorError:
                 pass
 
         return str(doc)
 
-    def _create_resource_link_tag(self, doc: BeautifulSoup, resource_id: str) -> Tag:
+    def _create_resource_link_tag(
+        self, doc: BeautifulSoup, resource_id: str, is_image: bool
+    ) -> Tag:
         resource = self._current_content_resources[resource_id]
 
+        # todo not sure if this is a good idea or not
+        # if is_image and resource.download_state == db.ResourceDownloadState.DOWNLOADED:
+        #     location = self._downloader.resource_download_location(resource)
+        #
+        #     file_link_tag = doc.new_tag(
+        #         "img",
+        #         attrs={
+        #             "source": location.absolute(),
+        #         },
+        #     )
+        # else:
         file_link_tag = doc.new_tag(
             "a",
             attrs={

qcanvas/ui/course_viewer/tabs/util.py

@@ -1 +1,11 @@
+from typing import Protocol
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+
 date_strftime_format = "%A, %Y-%m-%d, %H:%M:%S"
+
+
+# todo what the hell is the point of this?
+class SupportsReload(Protocol):
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None: ...

qcanvas/ui/main_ui/course_viewer_container.py

@@ -1,17 +1,48 @@
 import logging
+from math import floor
 from typing import *
 
 import qcanvas_backend.database.types as db
 from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt, empty_receipt
 from qtpy.QtCore import Qt
+from qtpy.QtGui import QIcon
 from qtpy.QtWidgets import *
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.course_viewer import CourseViewer
 
 _logger = logging.getLogger(__name__)
 
 
+# todo needs to handle dark mode
+class _PlaceholderLogo(QLabel):
+    """
+    Automatically resizing logo icon for when no course is selected
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._icon = QIcon(icons.logo_transparent_light)
+        self._old_width = -1
+        self._old_height = -1
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
+
+    def resizeEvent(self, event) -> None:
+        # Calculate the size of the logo as half of the width/height with a max size of 1000x1000
+        width = min(floor(self.width() * 0.5), 500)
+        height = min(floor(self.height() * 0.5), 500)
+
+        if width == self._old_width or height == self._old_height:
+            return
+        else:
+            self._old_width = width
+            self._old_height = height
+
+        self.setPixmap(self._icon.pixmap(width, height))
+
+
 class CourseViewerContainer(QStackedWidget):
     def __init__(self, downloader: ResourceManager):
         super().__init__()
@@ -19,8 +50,7 @@ class CourseViewerContainer(QStackedWidget):
         self._downloader = downloader
         self._last_course_id: Optional[str] = None
         self._last_sync_receipt: SyncReceipt = empty_receipt()
-        self._placeholder = QLabel("No Course Selected")
-        self._placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._placeholder = _PlaceholderLogo()
         self.addWidget(self._placeholder)
 
     def show_blank(self) -> None:

qcanvas/ui/main_ui/qcanvas_window.py

@@ -23,7 +23,7 @@ from qcanvas.ui.main_ui.options.quick_sync_option import QuickSyncOption
 from qcanvas.ui.main_ui.options.sync_on_start_option import SyncOnStartOption
 from qcanvas.ui.main_ui.options.theme_selection_menu import ThemeSelectionMenu
 from qcanvas.ui.main_ui.status_bar_progress_display import StatusBarProgressDisplay
-from qcanvas.util import paths, settings, auto_downloader
+from qcanvas.util import auto_downloader, paths, settings
 from qcanvas.util.qurl_util import file_url
 from qcanvas.util.ui_tools import create_qaction
 

qcanvas/ui/main_ui/status_bar_progress_display.py

@@ -77,10 +77,13 @@ class StatusBarProgressDisplay(QStatusBar):
         async with self._lock:
             if self._has_no_tasks:
                 self._show_done()
-            elif self._has_single_task:
-                self._show_single_task_progress(list(self._tasks.items())[0])
             else:
-                self._show_multiple_tasks_progress(list(self._tasks.values()))
+                tasks = list(self._tasks.items())
+
+                if self._has_single_task:
+                    self._show_single_task_progress(tasks[0])
+                else:
+                    self._show_multiple_tasks_progress(tasks)
 
     def _show_done(self) -> None:
         _logger.info("Finished tasks. Tasks: %s", self._tasks)
@@ -94,18 +97,24 @@ class StatusBarProgressDisplay(QStatusBar):
         self._show_progress(progress)
         self.showMessage(id.step_name)
 
-    def _show_multiple_tasks_progress(self, tasks: list[_TaskProgress]) -> None:
+    def _show_multiple_tasks_progress(
+        self, tasks: list[Tuple[TaskID, _TaskProgress]]
+    ) -> None:
         _logger.debug("Multiple tasks %s", tasks)
-        self.showMessage(f"{len(tasks)} tasks in progress")
+        self.showMessage(
+            f"{len(tasks)} tasks in progress - {', '.join([task[0].step_name for task in tasks])}"
+        )
         self._show_progress(self._calculate_progress(tasks))
 
-    def _calculate_progress(self, tasks: list[_TaskProgress]) -> _TaskProgress:
-        # Used to represent 0..1 progress as 0..multiplier
+    def _calculate_progress(
+        self, tasks: list[Tuple[TaskID, _TaskProgress]]
+    ) -> _TaskProgress:
+        # Task progresses are floats from 0 to 1, multiplier is used to turn them into ints
         multiplier = 1000
         current_sum = 0
         total_sum = 0
 
-        for task in tasks:
+        for _, task in tasks:
             if task.total != 0:
                 current_sum += (task.current / task.total) * multiplier
 

qcanvas/ui/setup/setup_checker.py

@@ -1,13 +1,13 @@
 import logging
 
 import qcanvas.util.settings as settings
-from qcanvas.util import is_url
+from qcanvas.util.url_checker import is_url
 
 _logger = logging.getLogger(__name__)
 
 
 def needs_setup() -> bool:
-    if not is_url(settings.client.panopto_url):
+    if not settings.client.panopto_disabled and not is_url(settings.client.panopto_url):
         return True
     elif not is_url(settings.client.canvas_url):
         return True