qcanvas 1.0.11__py3-none-any.whl → 2026.1.19__py3-none-any.whl

qcanvas/ui/{main_ui → qcanvas_window}/qcanvas_window.py

@@ -1,29 +1,39 @@
 import logging
 from threading import BoundedSemaphore
-from typing import *
+from typing import Optional, Sequence
 
 import httpx
-import qcanvas_backend.database.types as db
+from libqcanvas import db
+from libqcanvas.database.data_monolith import DataMonolith
+from libqcanvas.net.sync.sync_receipt import SyncReceipt, empty_receipt
+from libqcanvas.qcanvas import QCanvas
+from PySide6.QtCore import QUrl, Signal, Slot, Qt
+from PySide6.QtGui import QDesktopServices, QKeySequence
+from PySide6.QtWidgets import (
+    QErrorMessage,
+    QHBoxLayout,
+    QMainWindow,
+    QProgressDialog,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
 from qasync import asyncSlot
-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.QtWidgets import *
 
 from qcanvas import icons
 from qcanvas.backend_connectors import FrontendResourceManager
+from qcanvas.settings import course_configs
 from qcanvas.ui.course_viewer import CourseTree
-from qcanvas.ui.main_ui.course_viewer_container import CourseViewerContainer
-from qcanvas.ui.main_ui.options.auto_download_resources_option import (
+from .course_viewer_container import CourseViewerContainer
+from .options.auto_download_resources_option import (
     AutoDownloadResourcesMenu,
 )
-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 .options.quick_sync_option import QuickSyncOption
+from .options.sync_on_start_option import SyncOnStartOption
+from .options.theme_selection_menu import ThemeSelectionMenu
+from .status_bar_progress_display import StatusBarProgressDisplay
+from qcanvas.util import auto_downloader
+import qcanvas.settings as settings
 from qcanvas.util.qurl_util import file_url
 from qcanvas.util.ui_tools import create_qaction
 
@@ -33,20 +43,15 @@ _logger = logging.getLogger(__name__)
 class QCanvasWindow(QMainWindow):
     _loaded = Signal()
 
-    def __init__(self):
+    def __init__(self, _qcanvas: QCanvas[FrontendResourceManager]):
         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
-        self._qcanvas = QCanvas[FrontendResourceManager](
-            canvas_config=settings.client.canvas_config,
-            panopto_config=settings.client.panopto_config,
-            storage_path=paths.data_storage(),
-            resource_manager_class=FrontendResourceManager,
-        )
+        self._qcanvas = _qcanvas
 
         self._course_tree = CourseTree()
         self._course_tree.item_selected.connect(self._on_course_selected)
@@ -62,7 +67,9 @@ class QCanvasWindow(QMainWindow):
         self._setup_menu_bar()
         self._restore_window_position()
 
-        self._loaded.connect(self._on_app_loaded)
+        self._loaded.connect(
+            self._on_app_loaded, Qt.ConnectionType.SingleShotConnection
+        )
         self._loaded.emit()
 
     def _setup_menu_bar(self) -> None:
@@ -74,6 +81,7 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+S"),
             triggered=self._synchronise_requested,
             parent=app_menu,
+            icon=icons.actions.sync,
         )
 
         create_qaction(
@@ -81,17 +89,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,10 +112,11 @@ class QCanvasWindow(QMainWindow):
             shortcut=QKeySequence("Ctrl+Q"),
             triggered=lambda: self.close(),
             parent=app_menu,
+            icon=icons.actions.exit,
         )
 
         options_menu = menu_bar.addMenu("Options")
-
+        options_menu.setToolTipsVisible(True)
         options_menu.addAction(QuickSyncOption(options_menu))
         options_menu.addAction(SyncOnStartOption(options_menu))
         options_menu.addMenu(AutoDownloadResourcesMenu(options_menu))
@@ -140,7 +154,6 @@ class QCanvasWindow(QMainWindow):
 
     @asyncSlot()
     async def _on_app_loaded(self) -> None:
-        await self._qcanvas.init()
         self._course_tree.reload(await self._get_terms(), sync_receipt=empty_receipt())
 
         if settings.client.sync_on_start:
@@ -164,12 +177,18 @@ class QCanvasWindow(QMainWindow):
         except Exception as e:
             _logger.warning("Sync failed", exc_info=e)
             error = QErrorMessage(self)
-            msg = str(e)
 
-            if isinstance(e, httpx.ConnectError):
-                msg = "You may not be connected to the internet\n - " + msg
+            if isinstance(e, ExceptionGroup):
+                msg = "\n".join(str(ex) for ex in e.exceptions)
+            elif isinstance(e, httpx.ConnectError):
+                msg = "You may not be connected to the Internet"
+            else:
+                msg = str(e)
 
-            error.showMessage(msg)
+            error.setWindowTitle("An error has occurred in QCanvas")
+            error.showMessage(
+                msg + " - Please check the log for more details", "sync error"
+            )
         finally:
             self._operation_semaphore.release()
             self._sync_button.setText("Synchronise")
@@ -192,14 +211,14 @@ class QCanvasWindow(QMainWindow):
             await self._get_courses(), sync_receipt=receipt
         )
 
-    async def _get_resources(self) -> Dict[str, db.Resource]:
-        return (await self._qcanvas.get_data()).resources
+    async def _get_resources(self) -> dict[str, db.Resource]:
+        return (await self._qcanvas.load()).resources
 
     async def _get_terms(self) -> Sequence[db.Term]:
-        return (await self._qcanvas.get_data()).terms
+        return (await self._qcanvas.load()).terms
 
     async def _get_courses(self) -> Sequence[db.Course]:
-        return (await self._qcanvas.get_data()).courses
+        return (await self._qcanvas.load()).courses
 
     @Slot(db.Course)
     def _on_course_selected(self, course: Optional[db.Course]) -> None:
@@ -211,28 +230,38 @@ class QCanvasWindow(QMainWindow):
     @asyncSlot(db.Course, str)
     async def _on_course_renamed(self, course: db.Course, new_name: str) -> None:
         _logger.debug("Rename %s -> %s", course.name, new_name)
-
-        async with self._qcanvas.database.session() as session:
-            session.add(course)
-            course.configuration.nickname = new_name
+        config = course_configs[course.id]
+        config.nickname = new_name
+        await config.save()
 
     @asyncSlot()
     async def _open_quick_auth_in_browser(self) -> None:
         opening_progress_dialog = QProgressDialog("Opening canvas", None, 0, 0, self)
         opening_progress_dialog.setWindowTitle("Please wait")
         opening_progress_dialog.show()
-        QDesktopServices.openUrl(
-            QUrl(await self._qcanvas.canvas_client.get_temporary_session_url())
-        )
-        opening_progress_dialog.close()
+
+        try:
+            open_url = QUrl(
+                await self._qcanvas.canvas_client.get_temporary_session_url()
+            )
+            _logger.info(f"Opening URL {open_url}")
+            QDesktopServices.openUrl(open_url)
+        finally:
+            opening_progress_dialog.close()
 
     @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))
 
     @asyncSlot()
     async def _clear_new_items(self) -> None:
-        await self._reload(None)
+        await self._reload(empty_receipt())

qcanvas/ui/{main_ui → qcanvas_window}/status_bar_progress_display.py

@@ -1,11 +1,10 @@
 import logging
 from asyncio import Lock
 from dataclasses import dataclass
-from typing import *
 
+from libqcanvas.task_master import TaskID
+from PySide6.QtWidgets import QProgressBar, QStatusBar
 from qasync import asyncSlot
-from qcanvas_backend.task_master import TaskID
-from qtpy.QtWidgets import *
 
 from qcanvas.backend_connectors import task_master
 
@@ -77,35 +76,44 @@ 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)
         self.showMessage("Done", 5000)
         self._progress_bar.hide()
 
-    def _show_single_task_progress(self, task: Tuple[TaskID, _TaskProgress]) -> None:
+    def _show_single_task_progress(self, task: tuple[TaskID, _TaskProgress]) -> None:
         _logger.debug("Single task %s", task)
         id, progress = task
 
         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/qml_components/__init__.py

@@ -0,0 +1,4 @@
+from .qml import rc_qml  # Do not remove!! Loads the qml resources
+from .comments_pane import CommentsPane
+from .attachments_pane import AttachmentsPane
+from .qml_bridge_types import Attachment, Comment

qcanvas/ui/qml_components/attachments_pane.py

@@ -0,0 +1,70 @@
+from PySide6.QtCore import Slot, QUrl
+from PySide6.QtWidgets import QWidget
+from qasync import asyncSlot
+
+from qcanvas.backend_connectors import FrontendResourceManager
+from .qml_bridge_types import Attachment
+from .qml_pane import QmlPane
+from libqcanvas import db
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+class AttachmentsPane(QmlPane):
+    def __init__(
+        self, downloader: FrontendResourceManager, parent: QWidget | None = None
+    ):
+        super().__init__(qml_path=QUrl("qrc:/qml/AttachmentsPane.qml"), parent=parent)
+
+        self._original_dock_name = None
+        self._downloader = downloader
+        self._files: dict[str, db.Resource] = {}
+        self._qfiles: dict[str, Attachment] = {}
+        self.ctx["submission_files"] = []
+        self.load_view()
+
+        self._downloader.download_finished.connect(self._download_updated)
+        self._downloader.download_failed.connect(self._download_updated)
+
+    def clear_files(self):
+        self.ctx["submission_files"] = []
+        self._files.clear()
+        self._qfiles.clear()
+
+    def load_files(self, files: list[db.Resource]):
+        qfiles = []
+
+        if self._original_dock_name is None:
+            self._original_dock_name = self.parent().windowTitle()
+
+        self.parent().setWindowTitle(f"{self._original_dock_name} ({len(files)})")
+
+        for file in files:
+            qfile = Attachment(
+                file_name=file.file_name,
+                resource_id=file.id,
+                download_state=file.download_state,
+            )
+            qfile.opened.connect(self._on_attachment_opened)
+            qfiles.append(qfile)
+
+            self._qfiles[file.id] = qfile
+            self._files[file.id] = file
+
+        self.ctx["submission_files"] = qfiles
+
+    @asyncSlot(str)
+    async def _on_attachment_opened(self, resource_id: str) -> None:
+        if resource_id in self._files:
+            await self._downloader.download_and_open(self._files[resource_id])
+        else:
+            _logger.warning(
+                "User opened an attachment that doesn't belong to any comment! id=%s",
+                resource_id,
+            )
+
+    @Slot(db.Resource)
+    def _download_updated(self, resource: db.Resource) -> None:
+        if resource.id in self._files:
+            self._qfiles[resource.id].download_state = resource.download_state

qcanvas/ui/qml_components/comments_pane.py

@@ -0,0 +1,83 @@
+from PySide6.QtCore import Signal, Slot, QUrl
+from PySide6.QtWidgets import QWidget
+from libqcanvas.util import remove_unwanted_whitespaces, as_local
+from qasync import asyncSlot
+
+from qcanvas.backend_connectors import FrontendResourceManager
+from .qml_bridge_types import Attachment, Comment
+from libqcanvas import db
+import logging
+from .qml_pane import QmlPane
+
+_logger = logging.getLogger(__name__)
+
+
+class CommentsPane(QmlPane):
+    attachment_opened = Signal(str)
+
+    def __init__(
+        self, downloader: FrontendResourceManager, parent: QWidget | None = None
+    ):
+        super().__init__(qml_path=QUrl("qrc:/qml/CommentsPane.qml"), parent=parent)
+        self._downloader = downloader
+        self._attachments: dict[str, db.Resource] = {}
+        self._qattachments: dict[str, Attachment] = {}
+
+        # Add context objects before we load the view
+        self.ctx["comments"] = []
+        self.load_view()
+
+        self._downloader.download_finished.connect(self._download_updated)
+        self._downloader.download_failed.connect(self._download_updated)
+
+    def clear_comments(self) -> None:
+        self.ctx["comments"] = []
+        self._attachments.clear()
+        self._qattachments.clear()
+
+    def load_comments(self, comments: list[db.SubmissionComment]) -> None:
+        qcomments = []
+
+        self.parent().setWindowTitle(f"Comments ({len(comments)})")
+
+        for comment in comments:
+            attachments = []
+
+            for attachment in comment.attachments:
+                qattachment = Attachment(
+                    file_name=attachment.file_name,
+                    resource_id=attachment.id,
+                    download_state=attachment.download_state,
+                )
+                qattachment.opened.connect(self._on_attachment_opened)
+                attachments.append(qattachment)
+
+                self._attachments[attachment.id] = attachment
+                self._qattachments[attachment.id] = qattachment
+
+            qcomments.append(
+                Comment(
+                    body=remove_unwanted_whitespaces(comment.body),
+                    author=comment.author,
+                    date=as_local(comment.creation_date).strftime("%Y-%m-%d %H:%M"),
+                    attachments=attachments,
+                    parent=self,
+                )
+            )
+
+        self.ctx["comments"] = qcomments
+
+    @asyncSlot(str)
+    async def _on_attachment_opened(self, resource_id: str) -> None:
+        if resource_id in self._attachments:
+            await self._downloader.download_and_open(self._attachments[resource_id])
+        else:
+            _logger.warning(
+                "User opened an attachment that doesn't belong to any comment! id=%s",
+                resource_id,
+            )
+
+    @Slot(db.Resource)
+    def _download_updated(self, resource: db.Resource) -> None:
+        if resource.id in self._qattachments:
+            self._qattachments[resource.id].download_state = resource.download_state

qcanvas/ui/qml_components/qml/AttachmentsList.ui.qml

@@ -0,0 +1,15 @@
+
+
+/*
+This is a UI file (.ui.qml) that is intended to be edited in Qt Design Studio only.
+It is supposed to be strictly declarative and only uses a subset of QML. If you edit
+this file manually, you might introduce QML code that is not supported by Qt Design Studio.
+Check out https://doc.qt.io/qtcreator/creator-quick-ui-forms.html for details on .ui.qml files.
+*/
+import QtQuick
+
+ListView {
+    id: view
+    model: AttachmentsListModel {}
+    delegate: AttachmentsListDelegate {}
+}

qcanvas/ui/qml_components/qml/AttachmentsListDelegate.qml

@@ -0,0 +1,77 @@
+import QtQuick
+import QtQuick.Layouts
+
+Item {
+    id: delegate
+    height: childrenRect.height
+    anchors {
+        left: parent.left
+        right: parent.right
+    }
+
+    ColumnLayout {
+        spacing: 0
+
+        anchors {
+            left: parent.left
+            right: parent.right
+        }
+
+        RowLayout {
+            height: childrenRect.implicitHeight
+            Layout.fillWidth: true
+            spacing: 10
+
+            Image {
+                function attachmentIcon(downloadStatus) {
+                    switch(downloadStatus)
+                    {
+                        case "DOWNLOADED":
+                            return "qrc:///icons/universal/downloads/downloaded.svg";
+                        case "FAILED":
+                            return "qrc:///icons/universal/downloads/download_failed.svg";
+                        case "NOT_DOWNLOADED":
+                            return "qrc:///icons/universal/downloads/not_downloaded.svg";
+                        default:
+                            return "qrc:///icons/universal/downloads/unknown.svg"
+                    }
+                }
+
+                id: fileIcon
+                source: attachmentIcon(modelData.download_state)
+                fillMode: Image.PreserveAspectFit
+                sourceSize.height: 17
+                sourceSize.width: 17
+            }
+
+            Text {
+                id: file_name_text
+                text: modelData.file_name
+                wrapMode: Text.WrapAtWordBoundaryOrAnywhere
+                Layout.fillWidth: true
+                font.underline: true
+                color: palette.link
+
+                MouseArea {
+                    id: textClickArea
+                    anchors.fill: parent
+                    cursorShape: Qt.PointingHandCursor
+                    hoverEnabled: true
+                }
+            }
+        }
+
+        Spacer {
+            size: 5
+            visible: index !== count - 1
+        }
+    }
+
+    Connections {
+        target: textClickArea
+
+        function onClicked() {
+            modelData.opened(modelData.resource_id)
+        }
+    }
+}

qcanvas/ui/qml_components/qml/AttachmentsListModel.qml

@@ -0,0 +1,19 @@
+import QtQuick
+
+ListModel {
+    ListElement {
+        file_name: "texas.pdf"
+        resource_id: "1"
+        download_state: "NOT_DOWNLOADED"
+    }
+    ListElement {
+        file_name: "oh_no_what_a_terribly_long_file_name_its_not_like_someone_would_actually_do_this.pdf"
+        resource_id: "2"
+        download_state: "FAILED"
+    }
+    ListElement {
+        file_name: "i was transported to another world where javascript doesn't exist.cbz"
+        resource_id: "3"
+        download_state: "DOWNLOADED"
+    }
+}

qcanvas/ui/qml_components/qml/AttachmentsPane.qml

@@ -0,0 +1,11 @@
+import QtQuick
+
+ThemedRectangle {
+    anchors.fill: parent
+
+    AttachmentsList {
+        anchors.fill: parent
+        model: submission_files
+        palette: theme
+    }
+}

qcanvas/ui/qml_components/qml/CommentsList.ui.qml

@@ -0,0 +1,15 @@
+
+
+/*
+This is a UI file (.ui.qml) that is intended to be edited in Qt Design Studio only.
+It is supposed to be strictly declarative and only uses a subset of QML. If you edit
+this file manually, you might introduce QML code that is not supported by Qt Design Studio.
+Check out https://doc.qt.io/qtcreator/creator-quick-ui-forms.html for details on .ui.qml files.
+*/
+import QtQuick
+
+ListView {
+    id: view
+    model: CommentsListModel {}
+    delegate: CommentsListDelegate {}
+}