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

qcanvas/ui/main_ui/course_viewer_container.py

@@ -1,30 +1,68 @@
 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.QtCore import Qt, Slot
 from qtpy.QtWidgets import *
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.course_viewer import CourseViewer
+from qcanvas.util import themes
 
 _logger = logging.getLogger(__name__)
 
 
+class _PlaceholderLogo(QLabel):
+    """
+    Automatically resizing logo icon for when no course is selected
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._icon = icons.branding.logo_transparent
+        self._old_width = -1
+        self._old_height = -1
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
+        # Because we are using a pixmap for the icon, it will not get updated like a normal QIcon when the theme changes,
+        # So we need to update it ourselves
+        themes.theme_changed().connect(self._theme_changed)
+
+    def resizeEvent(self, event) -> None:
+        self._update_image()
+
+    @Slot()
+    def _theme_changed(self) -> None:
+        self._update_image(force=True)
+
+    def _update_image(self, force: bool = False) -> 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 force or (width != self._old_width and height != self._old_height):
+            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__()
         self._course_viewers: dict[str, CourseViewer] = {}
         self._downloader = downloader
         self._last_course_id: Optional[str] = None
+        self._selected_course: Optional[db.Course] = 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:
         self._last_course_id = None
+        self._selected_course = None
         self.setCurrentWidget(self._placeholder)
 
     def load_course(self, course: db.Course) -> None:
@@ -40,6 +78,7 @@ class CourseViewerContainer(QStackedWidget):
             viewer = self._course_viewers[course.id]
 
         self.setCurrentWidget(viewer)
+        self._selected_course = course
         self._last_course_id = course.id
 
     async def reload_all(
@@ -50,3 +89,7 @@ class CourseViewerContainer(QStackedWidget):
             if course.id in self._course_viewers:
                 viewer = self._course_viewers[course.id]
                 viewer.reload(course, sync_receipt=sync_receipt)
+
+    @property
+    def selected_course(self) -> Optional[db.Course]:
+        return self._selected_course

qcanvas/ui/main_ui/options/auto_download_resources_option.py

@@ -5,6 +5,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtGui import QAction
 from qtpy.QtWidgets import QMenu
 
+from qcanvas import icons
 from qcanvas.util import settings
 
 _logger = logging.getLogger(__name__)
@@ -36,6 +37,7 @@ class _EnableVideoDownloadOption(QAction):
 
 class AutoDownloadResourcesMenu(QMenu):
     def __init__(self, parent: Optional[QMenu] = None):
-        super().__init__("Download new resources", parent)
+        super().__init__("Auto download resources", parent)
         self.addAction(_EnableAutoDownloadOption(self))
         self.addAction(_EnableVideoDownloadOption(self))
+        self.setIcon(icons.options.auto_download)

qcanvas/ui/main_ui/options/theme_selection_menu.py

@@ -4,6 +4,7 @@ from qtpy.QtCore import Slot
 from qtpy.QtGui import QAction, QActionGroup
 from qtpy.QtWidgets import QMenu
 
+from qcanvas import icons
 from qcanvas.util import settings, themes
 
 _logger = logging.getLogger(__name__)
@@ -38,6 +39,7 @@ class ThemeSelectionMenu(QMenu):
         actions = [auto_theme, light_theme, dark_theme, native_theme]
 
         self.addActions(actions)
+        self.setIcon(icons.options.theme)
 
         for theme in actions:
             action_group.addAction(theme)

qcanvas/ui/main_ui/qcanvas_window.py

@@ -9,7 +9,7 @@ from qcanvas_backend.database.data_monolith import DataMonolith
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt, empty_receipt
 from qcanvas_backend.qcanvas import QCanvas
 from qtpy.QtCore import QUrl, Signal, Slot
-from qtpy.QtGui import QDesktopServices, QIcon, QKeySequence
+from qtpy.QtGui import QDesktopServices, QKeySequence
 from qtpy.QtWidgets import *
 
 from qcanvas import icons
@@ -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
 
@@ -37,7 +37,7 @@ class QCanvasWindow(QMainWindow):
         super().__init__()
 
         self.setWindowTitle("QCanvas")
-        self.setWindowIcon(QIcon(icons.main_icon))
+        self.setWindowIcon(icons.branding.main_icon)
 
         self._operation_semaphore = BoundedSemaphore()
         self._data: Optional[DataMonolith] = None
@@ -74,6 +74,7 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+S"),
             triggered=self._synchronise_requested,
             parent=app_menu,
+            icon=icons.actions.sync,
         )
 
         create_qaction(
@@ -81,17 +82,22 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+D"),
             triggered=self._open_downloads_folder,
             parent=app_menu,
+            icon=icons.actions.open_downloads,
         )
 
         create_qaction(
-            name="Quick canvas login",
+            name="Open Canvas in browser",
             shortcut=QKeySequence("Ctrl+O"),
             triggered=self._open_quick_auth_in_browser,
             parent=app_menu,
+            icon=icons.actions.quick_login,
         )
 
         create_qaction(
-            name="Mark all as seen", triggered=self._clear_new_items, parent=app_menu
+            name="Mark all as seen",
+            triggered=self._clear_new_items,
+            parent=app_menu,
+            icon=icons.actions.mark_all_read,
         )
 
         create_qaction(
@@ -99,6 +105,7 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+Q"),
             triggered=lambda: self.close(),
             parent=app_menu,
+            icon=icons.actions.exit,
         )
 
         options_menu = menu_bar.addMenu("Options")
@@ -229,6 +236,12 @@ class QCanvasWindow(QMainWindow):
     @Slot()
     def _open_downloads_folder(self) -> None:
         directory = self._qcanvas.resource_manager.downloads_folder
+
+        if self._course_viewer_container.selected_course is not None:
+            directory /= self._qcanvas.resource_manager.course_folder_name(
+                self._course_viewer_container.selected_course
+            )
+
         directory.mkdir(parents=True, exist_ok=True)
 
         QDesktopServices.openUrl(file_url(directory))

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/memory_tree/_tree_memory.py

@@ -54,6 +54,7 @@ class TreeMemory:
     def set_expanded(self, node_id: str, expanded: bool) -> None:
         contains = node_id in self._state.collapsed_items
 
+        # fixme when using a slow usb stick, this can momentarily block the event loop.
         if expanded and contains:
             self._state.collapsed_items.remove(node_id)
             self._state.save()

qcanvas/ui/memory_tree/memory_tree_widget.py

@@ -17,7 +17,7 @@ class MemoryTreeWidget(QTreeWidget):
         parent: Optional[QWidget] = None,
     ):
         super().__init__(parent)
-        self._id_map: dict[str, MemoryTreeWidgetItem] = {}
+        self._id_map: dict[str, QTreeWidgetItem] = {}
         self._memory = TreeMemory(tree_name)
         self._suppress_expansion_signals = False
         self._suppress_selection_signal = False
@@ -100,7 +100,7 @@ class MemoryTreeWidget(QTreeWidget):
         while len(widget_stack) > 0:
             item = widget_stack.pop()
 
-            if isinstance(item, MemoryTreeWidgetItem):
+            if hasattr(item, "id"):
                 if item.id in self._id_map or item.id in map_updates:
                     raise ValueError(f"Item with ID {item.id} is already in the tree")
 

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

qcanvas/ui/setup/setup_dialog.py

@@ -1,18 +1,19 @@
 import logging
 from threading import Semaphore
+from typing import Optional
 
 from qasync import asyncSlot
 from qcanvas_api_clients.canvas import CanvasClient, CanvasClientConfig
 from qcanvas_api_clients.panopto import PanoptoClient, PanoptoClientConfig
 from qcanvas_api_clients.util.request_exceptions import ConfigInvalidError
-from qtpy.QtCore import QUrl, Signal, Slot
+from qtpy.QtCore import Qt, QUrl, Signal, Slot
 from qtpy.QtGui import QDesktopServices, QIcon
 from qtpy.QtWidgets import *
 
 import qcanvas.util.settings as settings
 from qcanvas import icons
-from qcanvas.util import is_url
-from qcanvas.util.layouts import grid_layout_widget, layout
+from qcanvas.util.layouts import GridItem, grid_layout_widget, layout
+from qcanvas.util.url_checker import is_url
 
 _logger = logging.getLogger(__name__)
 
@@ -21,6 +22,68 @@ _tutorial_url = (
 )
 
 
+class _InputRow:
+    def __init__(
+        self,
+        *,
+        label: str,
+        initial_value: str,
+        placeholder_text: Optional[str] = None,
+        is_password: bool = False,
+    ):
+        self._label = QLabel(label)
+        self._input = QLineEdit(initial_value)
+
+        if placeholder_text is not None:
+            self._input.setPlaceholderText(placeholder_text)
+
+        if is_password:
+            self._input.setEchoMode(QLineEdit.EchoMode.Password)
+
+    def set_error(self, message: Optional[str]) -> None:
+        self._input.setStyleSheet("QLineEdit { border: 1px solid red }")
+        self._input.setToolTip(message)
+
+    def clear_error(self) -> None:
+        self._input.setStyleSheet(None)
+        self._input.setToolTip(None)
+
+    def grid_row(self) -> list[QWidget]:
+        return [self._label, self._input]
+
+    def disable(self) -> None:
+        self._input.setEnabled(False)
+
+    @property
+    def enabled(self) -> bool:
+        return self._input.isEnabled()
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._input.setEnabled(value)
+
+    @property
+    def text(self) -> str:
+        return self._input.text().strip()
+
+    @property
+    def url_text(self) -> str:
+        url = self.text
+
+        if not url.startswith("http"):
+            return "https://" + url
+        else:
+            return url
+
+    @property
+    def is_valid_url(self) -> bool:
+        return is_url(self.url_text)
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.text) == 0
+
+
 class SetupDialog(QDialog):
     closed = Signal()
 
@@ -30,41 +93,61 @@ class SetupDialog(QDialog):
         self.setWindowTitle("Configure QCanvas")
         self.setMinimumSize(550, 200)
         self.resize(550, 200)
-        self.setWindowIcon(QIcon(icons.main_icon))
+        self.setWindowIcon(QIcon(icons.branding.main_icon))
 
         self._semaphore = Semaphore()
-        self._canvas_url_box = QLineEdit(settings.client.canvas_url)
-        self._canvas_url_box.setPlaceholderText("https://instance.canvas.com")
-        self._canvas_api_key_box = QLineEdit(settings.client.canvas_api_key)
-        self._canvas_api_key_box.setEchoMode(QLineEdit.EchoMode.Password)
-        self._panopto_url_box = QLineEdit(settings.client.panopto_url)
-        self._panopto_url_box.setPlaceholderText("https://instance.panopto.com")
+
+        self._canvas_url_box = _InputRow(
+            label="Canvas URL",
+            initial_value=settings.client.canvas_url,
+            placeholder_text="https://instance.canvas.com",
+        )
+        self._panopto_url_box = _InputRow(
+            label="Panopto URL",
+            initial_value=settings.client.panopto_url,
+            placeholder_text="https://instance.panopto.com",
+        )
+        self._canvas_api_key_box = _InputRow(
+            label="Canvas API Key",
+            initial_value=settings.client.canvas_api_key,
+            is_password=True,
+        )
+        self._disable_panopto_checkbox = QCheckBox("Continue without Panopto")
+        self._disable_panopto_checkbox.checkStateChanged.connect(
+            self._disable_panopto_check_changed
+        )
         self._button_box = self._setup_button_box()
-        self._button_box.accepted.connect(self._accepted)
-        self._button_box.helpRequested.connect(self._help_requested)
         self._waiting_indicator = self._setup_progress_bar()
-        self._status_bar = QStatusBar()
 
         self.setLayout(
             layout(
                 QVBoxLayout,
                 grid_layout_widget(
                     [
-                        [QLabel("Canvas URL"), self._canvas_url_box],
-                        [QLabel("Canvas API Key"), self._canvas_api_key_box],
-                        [QLabel("Panopto URL"), self._panopto_url_box],
+                        self._canvas_url_box.grid_row(),
+                        self._canvas_api_key_box.grid_row(),
+                        self._panopto_url_box.grid_row(),
+                        [
+                            GridItem(
+                                self._disable_panopto_checkbox,
+                                col_span=2,
+                                alignment=Qt.AlignmentFlag.AlignRight,
+                            )
+                        ],
                     ]
                 ),
                 self._waiting_indicator,
                 self._button_box,
-                self._status_bar,
             )
         )
 
     def _setup_button_box(self) -> QDialogButtonBox:
         box = QDialogButtonBox()
         box.addButton(QDialogButtonBox.StandardButton.Ok)
-        box.addButton("Get a Canvas API key", QDialogButtonBox.ButtonRole.HelpRole)
+        box.addButton("Get a Canvas API Key", QDialogButtonBox.ButtonRole.HelpRole)
+
+        box.accepted.connect(self._verify_settings)
+        box.helpRequested.connect(self._help_requested)
         return box
 
     def _setup_progress_bar(self) -> QProgressBar:
@@ -81,32 +164,33 @@ class SetupDialog(QDialog):
         widget.setSizePolicy(size_policy)
 
     @asyncSlot()
-    async def _accepted(self) -> None:
+    async def _verify_settings(self) -> None:
         if self._semaphore.acquire(False):
             try:
                 self._clear_errors()
 
-                if not self._all_inputs_valid():
-                    self._status_bar.showMessage("Invalid input!", 5000)
+                if not self._check_all_inputs():
                     return
 
                 self._waiting_indicator.setVisible(True)
-                self._status_bar.showMessage("Checking configuration...")
 
                 canvas_config = CanvasClientConfig(
-                    api_token=self._canvas_api_key_box.text().strip(),
-                    canvas_url=self._get_url(self._canvas_url_box),
+                    api_token=self._canvas_api_key_box.text,
+                    canvas_url=self._canvas_url_box.url_text,
                 )
 
                 if not await self._check_canvas_config(canvas_config):
                     return
 
-                if not await self._check_panopto_config(canvas_config):
-                    self._show_panopto_help()
-                    return
+                if self._panopto_enabled:
+                    if not await self._check_panopto_config(canvas_config):
+                        self._show_panopto_help()
+                        return
             except Exception as e:
-                self._status_bar.showMessage(f"An error occurred: {e}", 5000)
                 _logger.warning("Checking config failed", exc_info=e)
+
+                error_box = QErrorMessage(self)
+                error_box.showMessage(f"Checking config failed: {e}")
             finally:
                 self._waiting_indicator.setVisible(False)
                 self._semaphore.release()
@@ -117,59 +201,40 @@ class SetupDialog(QDialog):
             _logger.debug("Validation already in progress")
 
     def _clear_errors(self) -> None:
-        for line_edit in [
-            self._canvas_url_box,
-            self._panopto_url_box,
-            self._canvas_api_key_box,
-        ]:
-            self._status_bar.clearMessage()
-            line_edit.setStyleSheet(None)
-            line_edit.setToolTip(None)
-
-    def _all_inputs_valid(self) -> bool:
+        self._canvas_url_box.clear_error()
+        self._panopto_url_box.clear_error()
+        self._canvas_api_key_box.clear_error()
+
+    def _check_all_inputs(self) -> bool:
         all_valid = True
 
-        if not is_url(self._get_url(self._canvas_url_box)):
+        if not self._canvas_url_box.is_valid_url:
             all_valid = False
-            self._show_error(self._canvas_url_box, "Canvas URL is invalid")
-        if len(self._canvas_api_key_box.text().strip()) == 0:
+            self._canvas_url_box.set_error("Canvas URL is invalid")
+
+        if self._canvas_api_key_box.is_empty:
             all_valid = False
-            self._show_error(self._canvas_api_key_box, "Canvas API key is empty")
-        if not is_url(self._get_url(self._panopto_url_box)):
+            self._canvas_api_key_box.set_error("Canvas API key is empty")
+
+        if self._panopto_enabled and not self._panopto_url_box.is_valid_url:
             all_valid = False
-            self._show_error(self._panopto_url_box, "Panopto URL is invalid")
+            self._panopto_url_box.set_error("Panopto URL is invalid")
 
         return all_valid
 
-    def _get_url(self, line_edit: QLineEdit) -> str:
-        url = line_edit.text().strip()
-
-        if not url.startswith("http"):
-            return "https://" + url
-        else:
-            return url
-
     async def _check_canvas_config(self, canvas_config: CanvasClientConfig) -> bool:
         try:
             await CanvasClient.verify_config(canvas_config)
             return True
         except ConfigInvalidError:
-            self._show_error(self._canvas_api_key_box, "Canvas API key is invalid")
+            self._canvas_api_key_box.set_error("Canvas API key is invalid")
             return False
 
-    def _show_error(self, line_edit: QLineEdit, text: str) -> None:
-        line_edit.setToolTip(text)
-        self._waiting_indicator.hide()
-        self._highlight_line_edit(line_edit)
-
-    def _highlight_line_edit(self, line_edit: QLineEdit) -> None:
-        line_edit.setStyleSheet("QLineEdit { border: 1px solid red }")
-
     async def _check_panopto_config(self, canvas_config: CanvasClientConfig) -> bool:
         client = CanvasClient(canvas_config)
         try:
             await PanoptoClient.verify_config(
-                PanoptoClientConfig(panopto_url=self._get_url(self._panopto_url_box)),
+                PanoptoClientConfig(panopto_url=self._panopto_url_box.url_text),
                 client,
             )
             return True
@@ -194,15 +259,21 @@ class SetupDialog(QDialog):
 
     @Slot()
     def _open_panopto_login(self) -> None:
-        url = QUrl(self._get_url(self._panopto_url_box))
+        url = QUrl(self._panopto_url_box.url_text)
         url.setPath("/Panopto/Pages/Auth/Login.aspx")
         url.setQuery("instance=Canvas&AllowBounce=true")
         QDesktopServices.openUrl(url)
 
     def _save_and_close(self) -> None:
-        settings.client.canvas_url = self._get_url(self._canvas_url_box)
-        settings.client.panopto_url = self._get_url(self._panopto_url_box)
-        settings.client.canvas_api_key = self._canvas_api_key_box.text().strip()
+        settings.client.canvas_url = self._canvas_url_box.url_text
+
+        if self._panopto_enabled:
+            settings.client.panopto_url = self._panopto_url_box.url_text
+        else:
+            settings.client.panopto_disabled = True
+
+        settings.client.canvas_api_key = self._canvas_api_key_box.text
+
         self.closed.emit()
         self.close()
 
@@ -223,3 +294,11 @@ class SetupDialog(QDialog):
     @Slot()
     def _open_tutorial(self) -> None:
         QDesktopServices.openUrl(QUrl(_tutorial_url))
+
+    @Slot(Qt.CheckState)
+    def _disable_panopto_check_changed(self, state: Qt.CheckState) -> None:
+        self._panopto_url_box.enabled = state == Qt.CheckState.Unchecked
+
+    @property
+    def _panopto_enabled(self) -> bool:
+        return self._disable_panopto_checkbox.checkState() == Qt.CheckState.Unchecked

qcanvas/util/__init__.py

@@ -1,2 +0,0 @@
-# todo remove this
-from .url_checker import is_url

qcanvas/util/auto_downloader.py

@@ -4,8 +4,7 @@ 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 QMessageBox
-from qtpy.QtWidgets import QWidget
+from qtpy.QtWidgets import QMessageBox, QWidget
 
 from qcanvas.util import settings