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

qcanvas/ui/qml_components/qml_bridge_types.py

@@ -0,0 +1,95 @@
+from PySide6.QtCore import Property, QObject, Signal
+from PySide6.QtQml import ListProperty, QmlElement
+from libqcanvas.database.tables import ResourceDownloadState
+
+
+QML_IMPORT_NAME = "QCanvas"
+QML_IMPORT_MAJOR_VERSION = 1
+
+
+@QmlElement
+class Attachment(QObject):
+    file_name_changed = Signal()
+    resource_id_changed = Signal()
+    download_state_changed = Signal()
+
+    # Emitted by AttachmentsListDelegate when the user clicks on an attachment
+    opened = Signal(str)
+
+    def __init__(
+        self,
+        file_name: str,
+        resource_id: str,
+        download_state: ResourceDownloadState,
+        parent: QObject | None = None,
+    ):
+        super().__init__(parent)
+        self._file_name = file_name
+        self._resource_id = resource_id
+        self._download_state = download_state.name
+
+    @Property(str, notify=file_name_changed)
+    def file_name(self) -> str:
+        return self._file_name
+
+    @Property(str, notify=resource_id_changed)
+    def resource_id(self) -> str:
+        return self._resource_id
+
+    @Property(str, notify=download_state_changed)
+    def download_state(self) -> str:
+        return self._download_state
+
+    @download_state.setter
+    def download_state(self, value: ResourceDownloadState):
+        if value.name != self._download_state:
+            self._download_state = value.name
+            self.download_state_changed.emit()
+
+
+@QmlElement
+class Comment(QObject):
+    body_changed = Signal()
+    author_changed = Signal()
+    date_changed = Signal()
+    attachments_changed = Signal()
+
+    def __init__(
+        self,
+        body: str,
+        author: str,
+        date: str,
+        attachments: list[Attachment],
+        parent: QObject | None = None,
+    ):
+        super().__init__(parent)
+
+        self._body = body
+        self._author = author
+        self._date = date
+        self._attachments = attachments
+
+    @Property(str, notify=body_changed)
+    def body(self) -> str:
+        return self._body
+
+    @Property(str, notify=date_changed)
+    def date(self) -> str:
+        return self._date
+
+    @Property(str, notify=author_changed)
+    def author(self) -> str:
+        return self._author
+
+    def attachment(self, n) -> Attachment:
+        return self._attachments[n]
+
+    def attachment_count(self) -> int:
+        return len(self._attachments)
+
+    # You must set `count`, `at` and `notify` EXPLICTLY (even if you name them according to the examples, which examples are all inconsistent and wrong).
+    # Qt?? Are you ok???
+    # Oh and you have to use `.length` instead of `.count` on the QML side because javascript.
+    attachments = ListProperty(
+        Attachment, count=attachment_count, at=attachment, notify=attachments_changed
+    )

qcanvas/ui/qml_components/qml_pane.py

@@ -0,0 +1,21 @@
+from PySide6.QtCore import QUrl
+from PySide6.QtQuick import QQuickView
+from PySide6.QtWidgets import QGroupBox, QWidget
+
+from qcanvas.theme import app_theme
+from qcanvas.util.context_dict import ContextDict
+import qcanvas.util.ui_tools as ui
+
+
+class QmlPane(QGroupBox):
+    def __init__(self, qml_path: QUrl, parent: QWidget | None = None):
+        super().__init__(parent)
+        self.qview = QQuickView(parent)
+        self._qml_path = qml_path
+        self.ctx = ContextDict(self.qview.rootContext())
+        self.ctx["appTheme"] = app_theme
+
+        self.setLayout(ui.hbox(QWidget.createWindowContainer(self.qview, self)))
+
+    def load_view(self):
+        self.qview.setSource(self._qml_path)

qcanvas/ui/setup/setup_checker.py

@@ -1,13 +1,13 @@
 import logging
 
-import qcanvas.util.settings as settings
-from qcanvas.util import is_url
+import qcanvas.settings as settings
+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,30 @@
 import logging
 from threading import Semaphore
-
+from typing import Optional
+
+from libqcanvas_clients.canvas import CanvasClient, CanvasClientConfig
+from libqcanvas_clients.panopto import PanoptoClient, PanoptoClientConfig
+from libqcanvas_clients.util.request_exceptions import ConfigInvalidError
+from PySide6.QtCore import Qt, QUrl, Slot
+from PySide6.QtGui import QDesktopServices, QIcon
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDialog,
+    QDialogButtonBox,
+    QErrorMessage,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QProgressBar,
+    QVBoxLayout,
+    QWidget,
+)
 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.QtGui import QDesktopServices, QIcon
-from qtpy.QtWidgets import *
-
-import qcanvas.util.settings as settings
+
+import qcanvas.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,50 +33,132 @@ _tutorial_url = (
 )
 
 
-class SetupDialog(QDialog):
-    closed = Signal()
+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):
     def __init__(self):
         super().__init__()
 
         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.setChecked(settings.client.panopto_disabled)
+        self._disable_panopto_checkbox.checkStateChanged.connect(
+            self._disable_panopto_check_changed
+        )
+        self._panopto_url_box.enabled = not settings.client.panopto_disabled
         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 +175,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 +212,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
@@ -189,22 +265,29 @@ class SetupDialog(QDialog):
             QMessageBox.StandardButton.Ok,
             self,
         )
-        msg.accepted.connect(self._open_panopto_login)
+        msg.accepted.connect(
+            self._open_panopto_login, Qt.ConnectionType.SingleShotConnection
+        )
         msg.show()
 
     @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()
-        self.closed.emit()
-        self.close()
+        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.accept()
 
     @Slot()
     def _help_requested(self) -> None:
@@ -217,9 +300,19 @@ class SetupDialog(QDialog):
             "Don't share this key. You can revoke it at any time.",
             parent=self,
         )
-        msg.accepted.connect(self._open_tutorial)
+        msg.accepted.connect(
+            self._open_tutorial, Qt.ConnectionType.SingleShotConnection
+        )
         msg.show()
 
     @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

@@ -1,13 +1,13 @@
 import asyncio
 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 PySide6.QtCore import Qt
+from libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtWidgets import QMessageBox, QWidget
 
-from qcanvas.util import settings
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -21,7 +21,7 @@ async def download_new_resources(
 ) -> None:
     resources_to_download = []
 
-    for file_id in receipt.updated_resources:
+    for file_id in receipt.updates[db.Resource]:
         resource = all_resources[file_id]
 
         if _should_auto_download_resource(resource, resource_manager=downloader):
@@ -37,7 +37,8 @@ async def download_new_resources(
         msg.accepted.connect(
             lambda: asyncio.get_running_loop().create_task(
                 downloader.batch_download(resources_to_download),
-            )
+            ),
+            Qt.ConnectionType.SingleShotConnection,
         )
     else:
         await downloader.batch_download(resources_to_download)

qcanvas/util/basic_fonts.py

@@ -1,5 +1,5 @@
-from qtpy.QtGui import QFont
-from qtpy.QtWidgets import QLabel
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import QLabel
 
 normal_font = QFont()
 bold_font = QFont()

qcanvas/util/context_dict.py

@@ -0,0 +1,12 @@
+from PySide6.QtQml import QQmlContext
+
+
+class ContextDict:
+    def __init__(self, context: QQmlContext):
+        self._context = context
+
+    def __getitem__(self, item):
+        return self._context.contextProperty(item)
+
+    def __setitem__(self, key, value):
+        self._context.setContextProperty(key, value)

qcanvas/util/file_icons.py

@@ -0,0 +1,46 @@
+import logging
+import os.path
+
+import cachetools
+from PySide6.QtCore import QFileInfo, QMimeDatabase
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QApplication, QFileIconProvider, QStyle
+
+import qcanvas.util.runtime as runtime
+
+_logger = logging.getLogger(__name__)
+
+# Windows and linux have different ways of doing this
+if runtime.is_running_on_windows:
+    _icon_provider = QFileIconProvider()
+
+    def icon_for_filename(file_name: str) -> QIcon:
+        return _icon_provider.icon(QFileInfo(file_name))
+
+else:
+    _mime_database = QMimeDatabase()
+    _icon_for_suffix: dict[str, QIcon] = {}
+
+    def icon_for_filename(file_name: str) -> QIcon:
+        file_suffix = os.path.splitext(file_name)[1]
+
+        # Check if we already know what icon this file type has
+        if file_suffix in _icon_for_suffix:
+            return _icon_for_suffix[file_suffix]
+
+        # Try to find an icon for this file type
+        for mime_type in _mime_database.mimeTypesForFileName(file_name):
+            icon = QIcon.fromTheme(mime_type.iconName())
+
+            if not icon.isNull():
+                _icon_for_suffix[file_suffix] = icon
+                return icon
+
+        # No icon for this type of file was found, use default icon
+        icon = _default_icon()
+        _icon_for_suffix[file_suffix] = icon
+        return icon
+
+    @cachetools.cached(cachetools.LRUCache(maxsize=1))
+    def _default_icon() -> QIcon:
+        return QApplication.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon)

qcanvas/util/html_cleaner.py

@@ -16,6 +16,8 @@ def clean_up_html(html: str) -> str:
     _remove_tags(doc.find_all(["link", "script"]))
     # Remove font awesome icons (which don't load anyway)
     _remove_tags(doc.find_all(["span"], class_=["dp-icon-content"]))
+    # Remove screen reader elements
+    _remove_tags(doc.find_all(class_="screenreader-only"))
 
     return str(doc)
 

qcanvas/util/layouts.py

@@ -1,13 +1,11 @@
 import logging
-from typing import *
+from typing import Iterable, NamedTuple
 
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import *
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QGridLayout, QLayout, QWidget
 
 _logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-
 
 class GridItem(NamedTuple):
     widget: QWidget
@@ -16,17 +14,20 @@ class GridItem(NamedTuple):
     alignment: Qt.AlignmentFlag = Qt.AlignmentFlag.AlignLeft
 
 
-def layout_widget(layout_type: Type[T], *items: QWidget, **kwargs) -> QWidget:
+def layout_widget[T](layout_type: type[T], *items: QWidget, **kwargs) -> QWidget:
     widget = QWidget()
     widget.setLayout(layout(layout_type, *items, **kwargs))
     return widget
 
 
-def layout(layout_type: Type[T], *items: QWidget, **kwargs) -> T:
+def layout[T](layout_type: type[T], *items: QWidget | QLayout, **kwargs) -> T:
     result_layout: QLayout = layout_type(**kwargs)
 
     for item in items:
-        result_layout.addWidget(item)
+        if isinstance(item, QLayout):
+            result_layout.addItem(item)
+        else:
+            result_layout.addWidget(item)
 
     return result_layout