qcanvas 1.2.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

qcanvas/settings/__init__.py

@@ -0,0 +1,6 @@
+from ._client_settings import _ClientSettings
+from ._ui_settings import _UISettings
+from ._course_settings import course_configs
+
+client = _ClientSettings()
+ui = _UISettings()

qcanvas/{util/settings → settings}/_client_settings.py

@@ -1,11 +1,11 @@
 import logging
-from typing import *
+from typing import Optional
 
-from qcanvas_api_clients.canvas import CanvasClientConfig
-from qcanvas_api_clients.panopto import PanoptoClientConfig
+from libqcanvas_clients.canvas import CanvasClientConfig
+from libqcanvas_clients.panopto import PanoptoClientConfig
 
 from qcanvas.util import paths
-from qcanvas.util.settings._mapped_setting import BoolSetting, MappedSetting
+from ._mapped_setting import BoolSetting, MappedSetting
 
 _logger = logging.getLogger(__name__)
 

qcanvas/settings/_course_settings.py

@@ -0,0 +1,54 @@
+import logging
+from pathlib import Path
+
+from aiofile import async_open
+from pydantic import BaseModel, RootModel, Field, ValidationError
+
+from qcanvas.util import paths
+
+_logger = logging.getLogger(__name__)
+
+
+class CourseConfigData(BaseModel):
+    nickname: str | None = Field(default=None)
+
+    async def save(self) -> None:
+        await course_configs.save()
+
+
+_CourseConfigurations = RootModel[dict[str, CourseConfigData]]
+
+
+class _CourseConfig:
+    def __init__(self):
+        self._root_model = self._load_root_model()
+
+    def _load_root_model(self) -> _CourseConfigurations:
+        if self._storage_path.exists():
+            try:
+                return _CourseConfigurations.model_validate_json(
+                    self._storage_path.read_text()
+                )
+            except ValidationError as e:
+                _logger.error("Failed to load course configs", exc_info=e)
+
+        return _CourseConfigurations({})
+
+    async def save(self) -> None:
+        async with async_open(self._storage_path, "wt") as file:
+            await file.write(self._root_model.model_dump_json(indent=4))
+
+    @property
+    def _storage_path(self) -> Path:
+        return paths.config_storage() / "course_settings.json"
+
+    def __getitem__(self, item: str) -> CourseConfigData:
+        if item in self._root_model.root:
+            return self._root_model.root[item]
+        else:
+            new_config = CourseConfigData()
+            self._root_model.root[item] = new_config
+            return new_config
+
+
+course_configs = _CourseConfig()

qcanvas/{util/settings → settings}/_mapped_setting.py

@@ -1,14 +1,11 @@
 import logging
-from typing import *
 
-from qtpy.QtCore import QSettings
+from PySide6.QtCore import QSettings
 
 _logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
 
-
-class MappedSetting(Generic[T]):
+class MappedSetting[T]:
     """
     Acts as a proxy for a named value in a QSettings object.
     Stores the value in memory when initialised and updates it accordingly, to protect it from changes on disk.

qcanvas/{util/settings → settings}/_ui_settings.py

@@ -1,16 +1,16 @@
 import logging
 
-from qtpy.QtCore import QByteArray, QSettings
+from PySide6.QtCore import QByteArray, QSettings
 
-from qcanvas.util.settings._mapped_setting import MappedSetting
-from qcanvas.util.themes import default_theme, ensure_theme_is_valid
+from ._mapped_setting import MappedSetting
+from qcanvas.theme import ensure_theme_is_valid
 
 _logger = logging.getLogger(__name__)
 
 
 class ThemeSetting(MappedSetting):
     def __init__(self):
-        super().__init__(default=default_theme)
+        super().__init__(default="auto")
 
     def __get__(self, instance, owner):
         return ensure_theme_is_valid(super().__get__(instance, owner))

qcanvas/theme.py

@@ -0,0 +1,101 @@
+import logging
+from typing import Literal
+
+import qdarktheme
+from PySide6.QtCore import QObject, Signal, Property, Slot
+from PySide6.QtGui import QGuiApplication, Qt, QIcon
+from PySide6.QtWidgets import QStyleFactory, QApplication
+
+type Theme = Literal["native", "auto", "dark", "light"]
+
+_logger = logging.getLogger(__name__)
+
+
+class _AppTheme(QObject):
+    themeChanged = Signal()
+    darkModeChanged = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self._last_system_theme = QGuiApplication.styleHints().colorScheme()
+        self._theme: Theme | None = None
+        self._dark_mode: bool | None = None
+
+        self.darkModeChanged.connect(self._set_icon_paths)
+        QGuiApplication.styleHints().colorSchemeChanged.connect(
+            self._on_system_theme_changed
+        )
+
+    @Property(bool, notify=darkModeChanged)
+    def dark_mode(self) -> bool:
+        assert self._theme is not None, "Theme has not been set"
+        return self._dark_mode
+
+    @Property(str, notify=themeChanged)
+    def theme(self) -> Theme:
+        assert self._theme is not None, "Theme has not been set"
+        return self._theme
+
+    @theme.setter
+    def theme(self, value: str):
+        value = ensure_theme_is_valid(value)
+
+        if value != self._theme:
+            self._update_theme(value)
+
+    def _update_theme(self, theme: str):
+        if theme is None or (theme == self._theme and theme not in ["native", "auto"]):
+            return
+
+        was_dark_mode = self._dark_mode
+
+        if theme != "native":
+            if theme == "auto":
+                self._dark_mode = _is_system_using_dark_mode()
+                selected_colour_scheme = "dark" if self._dark_mode else "light"
+            else:
+                self._dark_mode = theme == "dark"
+                selected_colour_scheme = theme
+
+            if was_dark_mode != self._dark_mode:
+                qdarktheme.setup_theme(
+                    selected_colour_scheme,
+                    custom_colors={"primary": "e02424"},
+                )
+
+                QApplication.setStyle(QStyleFactory.create("Fusion"))
+        else:
+            self._dark_mode = _is_system_using_dark_mode()
+
+        if theme != self._theme:
+            self._theme = theme
+            self.themeChanged.emit()
+
+        if was_dark_mode != self._dark_mode:
+            self.darkModeChanged.emit()
+
+    @Slot()
+    def _set_icon_paths(self):
+        QIcon.setFallbackSearchPaths(
+            [":icons/dark" if self._dark_mode else ":icons/light", ":icons/universal"]
+        )
+
+    @Slot()
+    def _on_system_theme_changed(self, scheme: Qt.ColorScheme):
+        if scheme != self._last_system_theme:
+            self._last_system_theme = scheme
+            self._update_theme(self._theme)
+
+
+def _is_system_using_dark_mode() -> bool:
+    return QGuiApplication.styleHints().colorScheme() == Qt.ColorScheme.Dark
+
+
+def ensure_theme_is_valid(theme_name: str) -> Theme:
+    if theme_name not in ["auto", "light", "dark", "native"]:
+        return "auto"
+    else:
+        return theme_name
+
+
+app_theme = _AppTheme()

qcanvas/ui/course_viewer/content_tree.py

@@ -1,11 +1,11 @@
 import logging
 from abc import abstractmethod
-from typing import *
+from typing import Optional, Self, Sequence
 
-import qcanvas_backend.database.types as db
-from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
-from qtpy.QtCore import QItemSelection, Signal, Slot
-from qtpy.QtWidgets import *
+from libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtCore import QItemSelection, Signal, Slot
+from PySide6.QtWidgets import QHeaderView, QTreeWidgetItem
 
 from qcanvas.ui.course_viewer.tree_widget_data_item import AnyTreeDataItem
 from qcanvas.ui.memory_tree import MemoryTreeWidget
@@ -13,17 +13,14 @@ from qcanvas.util.basic_fonts import bold_font, normal_font
 
 _logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-U = TypeVar("U", bound=Type["ContentTree"])
 
-
-class ContentTree(MemoryTreeWidget, Generic[T]):
+class ContentTree[T](MemoryTreeWidget):
     item_selected = Signal(object)
 
     @classmethod
-    def create_from_receipt(
+    def create_from_receipt[U: Self](
         cls: U, course: db.Course, *, sync_receipt: SyncReceipt
-    ) -> Type[U]:
+    ) -> type[U]:
         tree = cls(course.id)
         tree.reload(course, sync_receipt=sync_receipt)
         return tree
@@ -32,7 +29,7 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         self,
         tree_name: str,
         *,
-        emit_selection_signal_for_type: Type,
+        emit_selection_signal_for_type: type,
     ):
         super().__init__(tree_name)
         self._reloading = False

qcanvas/ui/course_viewer/course_tree/_course_icon_generator.py

@@ -3,9 +3,9 @@ import logging
 import random
 
 from cachetools import cached
-from qtpy.QtCore import QByteArray
-from qtpy.QtGui import QColor, QPainter, QPixmap
-from qtpy.QtSvg import QSvgRenderer
+from PySide6.QtCore import QByteArray
+from PySide6.QtGui import QColor, QPainter, QPixmap
+from PySide6.QtSvg import QSvgRenderer
 
 _logger = logging.getLogger(__name__)
 _transparent = QColor("#00000000")

qcanvas/ui/course_viewer/course_tree/course_tree.py

@@ -1,11 +1,12 @@
 import logging
-from typing import *
+from typing import Sequence
 
-import qcanvas_backend.database.types as db
-from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
-from qtpy.QtCore import Qt, Signal
+from libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtCore import Qt, Signal
 
 from qcanvas import icons
+from qcanvas.settings import course_configs
 from qcanvas.ui.course_viewer.content_tree import ContentTree
 from qcanvas.ui.course_viewer.course_tree._course_icon_generator import (
     CourseIconGenerator,
@@ -22,7 +23,7 @@ class _CourseTreeItem(TreeWidgetDataItem):
             self,
             id=course.id,
             data=course,
-            strings=[course.configuration.nickname or course.name],
+            strings=[course_configs[course.id].nickname or course.name],
         )
 
         self._owner = owner
@@ -34,7 +35,7 @@ class _CourseTreeItem(TreeWidgetDataItem):
             | Qt.ItemFlag.ItemIsEnabled
         )
 
-    def setData(self, column: int, role: int, value: Any):
+    def setData(self, column: int, role: int, value: object):
         if column != 0 or not isinstance(value, str):
             return super().setData(column, role, value)
 
@@ -59,11 +60,11 @@ class CourseTree(ContentTree[Sequence[db.Term]]):
         )
 
     def create_tree_items(
-        self, terms: List[db.Term], sync_receipt: SyncReceipt
+        self, terms: list[db.Term], sync_receipt: SyncReceipt
     ) -> Sequence[MemoryTreeWidgetItem]:
         widgets = []
 
-        for term in reversed(terms):
+        for term in terms:
             term_widget = self._create_term_widget(term)
             course_icon_generator = CourseIconGenerator(term.id)
 

qcanvas/ui/course_viewer/course_viewer.py

@@ -1,20 +1,19 @@
 import logging
 from dataclasses import dataclass
 
-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 Slot
-from qtpy.QtGui import QIcon
-from qtpy.QtWidgets import *
+from libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtCore import Slot
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QTabWidget, QVBoxLayout, QWidget
 
 from qcanvas import icons
 from qcanvas.ui.course_viewer.tabs.assignment_tab import AssignmentTab
 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
 from qcanvas.util.layouts import layout
-from qcanvas.util.ui_tools import make_truncatable
+import qcanvas.util.ui_tools as ui
 
 _logger = logging.getLogger(__name__)
 
@@ -23,10 +22,10 @@ _logger = logging.getLogger(__name__)
 class _Tab:
     icon: QIcon
     highlighted_icon: QIcon
+    update_type: type
 
 
 class CourseViewer(QWidget):
-
     def __init__(
         self,
         course: db.Course,
@@ -39,9 +38,9 @@ class CourseViewer(QWidget):
         self._course_id = course.id
         self._previous_tab_index = 0
 
-        self._course_label = QLabel(course.name)
-        self._course_label.setFont(bold_font)
-        make_truncatable(self._course_label)
+        self._course_label = ui.label(
+            course.name, font=ui.font(point_size=13, bold=True), allow_truncation=True
+        )
 
         self._pages_tab = PageTab.create_from_receipt(
             course=course,
@@ -73,23 +72,26 @@ class CourseViewer(QWidget):
         #     icon=icons.tabs.pages,
         #     highlighted_icon=icons.tabs.pages_new_content,
         # )
-        self._PAGES_TAB = self._setup_tab(
+        self._PAGES_TAB = self._set_up_tab(
             name="Pages",
             widget=self._pages_tab,
             icon=icons.tabs.pages,
             highlighted_icon=icons.tabs.pages_new_content,
+            content_update_key=db.Page,
         )
-        self._ASSIGNMENTS_TAB = self._setup_tab(
+        self._ASSIGNMENTS_TAB = self._set_up_tab(
             name="Assignments",
             widget=self._assignments_tab,
             icon=icons.tabs.assignments,
             highlighted_icon=icons.tabs.assignments_new_content,
+            content_update_key=db.Assignment,
         )
-        self._MAIL_TAB = self._setup_tab(
+        self._MAIL_TAB = self._set_up_tab(
             name="Mail",
             widget=self._mail_tab,
             icon=icons.tabs.mail,
             highlighted_icon=icons.tabs.mail_new_content,
+            content_update_key=db.Message,
         )
         # self._tabs.addTab(QLabel("Not implemented"), "Panopto")  # The meme lives on!
 
@@ -97,11 +99,17 @@ class CourseViewer(QWidget):
         self._tab_widget.currentChanged.connect(self._tab_changed)
         self._highlight_tabs(sync_receipt)
 
-    def _setup_tab(
-        self, widget: QWidget, icon: QIcon, highlighted_icon: QIcon, name: str
+    def _set_up_tab(
+        self,
+        *,
+        widget: QWidget,
+        icon: QIcon,
+        highlighted_icon: QIcon,
+        name: str,
+        content_update_key: type,
     ) -> int:
         index = self._tab_widget.addTab(widget, icon, name)
-        self._tabs[index] = _Tab(icon, highlighted_icon)
+        self._tabs[index] = _Tab(icon, highlighted_icon, update_type=content_update_key)
         return index
 
     def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
@@ -116,35 +124,19 @@ class CourseViewer(QWidget):
         _logger.debug(f"Index = {index}")
         if index != -1:
             _logger.debug(f"Previous tab = {self._previous_tab_index}")
-            self._unhighlight_tab(self._previous_tab_index)
+            self._set_tab_highlight(self._previous_tab_index, False)
             self._previous_tab_index = index
 
     def _highlight_tabs(self, sync_receipt: SyncReceipt) -> None:
         updates = sync_receipt.updates_by_course.get(self._course_id, None)
 
-        if updates is not None:
-            if len(updates.updated_pages) > 0:
-                self._highlight_tab(self._PAGES_TAB)
-            else:
-                self._unhighlight_tab(self._PAGES_TAB)
-
-            if len(updates.updated_assignments) > 0:
-                self._highlight_tab(self._ASSIGNMENTS_TAB)
-            else:
-                self._unhighlight_tab(self._ASSIGNMENTS_TAB)
-
-            if len(updates.updated_messages) > 0:
-                self._highlight_tab(self._MAIL_TAB)
-            else:
-                self._unhighlight_tab(self._MAIL_TAB)
-        else:
-            for index in range(0, len(self._tabs)):
-                self._unhighlight_tab(index)
-
-    def _highlight_tab(self, tab_index: int) -> None:
-        tab = self._tabs[tab_index]
-        self._tab_widget.setTabIcon(tab_index, tab.highlighted_icon)
+        for tab_index, tab in enumerate(self._tabs.values()):
+            self._set_tab_highlight(
+                tab_index, updates is not None and updates[tab.update_type] is not None
+            )
 
-    def _unhighlight_tab(self, tab_index: int) -> None:
+    def _set_tab_highlight(self, tab_index: int, highlighted: bool) -> None:
         tab = self._tabs[tab_index]
-        self._tab_widget.setTabIcon(tab_index, tab.icon)
+        self._tab_widget.setTabIcon(
+            tab_index, tab.highlighted_icon if highlighted else tab.icon
+        )

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

@@ -1,28 +1,40 @@
 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 PySide6.QtCore import Qt
+from libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from libqcanvas.util import as_local
+from PySide6.QtWidgets import (
+    QLabel,
+    QLayout,
+    QDockWidget,
+    QMainWindow,
+)
+from typing_extensions import override
 
-from qcanvas.ui.course_viewer.tabs.assignment_tab.assignment_tree import AssignmentTree
+import qcanvas.util.ui_tools as ui
+from qcanvas.backend_connectors import FrontendResourceManager
+from .assignment_tree import AssignmentTree
+from qcanvas.ui.qml_components import CommentsPane, AttachmentsPane
 from qcanvas.ui.course_viewer.tabs.content_tab import ContentTab
-from qcanvas.ui.course_viewer.tabs.util import date_strftime_format
-from qcanvas.util.basic_fonts import bold_label
-from qcanvas.util.layouts import grid_layout
+from qcanvas.ui.course_viewer.tabs.constants import (
+    date_strftime_format,
+)
 
 _logger = logging.getLogger(__name__)
 
 
 class AssignmentTab(ContentTab):
-
     def __init__(
         self,
         *,
         course: db.Course,
         sync_receipt: SyncReceipt,
-        downloader: ResourceManager,
+        downloader: FrontendResourceManager,
     ):
+        # must be before super init, otherwise _setup_layout will be called before it is initialised
+        self._main_container = QMainWindow()
+
         super().__init__(
             explorer=AssignmentTree.create_from_receipt(
                 course, sync_receipt=sync_receipt
@@ -31,38 +43,104 @@ class AssignmentTab(ContentTab):
             downloader=downloader,
         )
 
+        # fixme: can't figure out how to get the panes to have the right size without showing them when nothing is selected
+        self._comments_pane = CommentsPane(downloader)
+        self._comments_dock = ui.dock_widget(
+            title="Comments",
+            name="comments_dock",
+            widget=self._comments_pane,
+            min_size=ui.size(150, 150),
+            features=QDockWidget.DockWidgetFeature.DockWidgetMovable,
+            hide=False,
+        )
+
+        self._submission_files_pane = AttachmentsPane(downloader)
+        self._submission_files_dock = ui.dock_widget(
+            title="Submission Files",
+            name="sub_files_dock",
+            widget=self._submission_files_pane,
+            min_size=ui.size(150, 150),
+            features=QDockWidget.DockWidgetFeature.DockWidgetMovable,
+            hide=False,
+        )
+
+        self._main_container.setCentralWidget(self._viewer)
+        self._main_container.addDockWidget(
+            Qt.DockWidgetArea.RightDockWidgetArea, self._submission_files_dock
+        )
+        self._main_container.addDockWidget(
+            Qt.DockWidgetArea.RightDockWidgetArea, self._comments_dock
+        )
+
+        self._main_container.resizeDocks(
+            [self._submission_files_dock, self._comments_dock],
+            [350, 350],
+            Qt.Orientation.Horizontal,
+        )
+        self._main_container.resizeDocks(
+            [self._submission_files_dock],
+            [200],
+            Qt.Orientation.Vertical,
+        )
+
         self._due_date_label = QLabel("")
         self._score_label = QLabel("")
-
         self.enable_info_grid()
 
-    def setup_info_grid(self) -> QGridLayout:
-        grid = grid_layout(
-            [
-                [
-                    bold_label("Due:"),
-                    self._due_date_label,
-                ],
-                [
-                    bold_label("Score:"),
-                    self._score_label,
-                ],
-            ]
+    @override
+    def _setup_layout(self) -> None:
+        super()._setup_layout()
+        self.content_grid.replaceWidget(
+            self._viewer,
+            self._main_container,
         )
 
-        grid.setColumnStretch(0, 0)
-        grid.setColumnStretch(1, 1)
+        self.content_grid.setColumnStretch(0, 1)
+        self.content_grid.setColumnStretch(1, 3)
 
-        return grid
+    @override
+    def setup_info_grid(self) -> QLayout:
+        return ui.form_layout(
+            {"Due": self._due_date_label, "Score": self._score_label},
+        )
 
+    # fixme: kind of a misleading name? it's not just updating the info "grid" anymore
+    @override
     def update_info_grid(self, assignment: db.Assignment) -> None:
         if assignment.due_date is not None:
-            due_text = assignment.due_date.strftime(date_strftime_format)
+            due_text = as_local(assignment.due_date).strftime(date_strftime_format)
         else:
-            due_text = "?"
+            due_text = "No due date"
 
         self._due_date_label.setText(due_text)
 
+        last_submission = assignment.submissions[-1] if assignment.submissions else None
+        submission_score = "-"
+
+        if last_submission and last_submission.score:
+            submission_score = last_submission.score
+
         self._score_label.setText(
-            f"{assignment.mark or '?'}/{assignment.max_mark_possible or '?'}"
+            f"<b>{submission_score}</b>/{assignment.max_score or '?'}"
         )
+
+        if last_submission and last_submission.attachments:
+            self._submission_files_pane.load_files(last_submission.attachments)
+            self._submission_files_dock.show()
+        else:
+            self._submission_files_pane.clear_files()
+            self._submission_files_dock.hide()
+
+        if last_submission and last_submission.comments:
+            self._comments_pane.load_comments(last_submission.comments)
+            self._comments_dock.show()
+        else:
+            self._comments_pane.clear_comments()
+            self._comments_dock.hide()
+
+    @override
+    def _show_blank(self) -> None:
+        super()._show_blank()
+
+        self._comments_dock.hide()
+        self._submission_files_dock.hide()

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

@@ -1,10 +1,10 @@
 import logging
 from typing import Sequence
 
-import qcanvas_backend.database.types as db
-from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import QHeaderView
+from libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QHeaderView
 
 from qcanvas import icons
 from qcanvas.ui.course_viewer.content_tree import ContentTree

qcanvas/ui/course_viewer/tabs/constants.py

@@ -0,0 +1 @@
+date_strftime_format = "%A, %Y-%m-%d, %H:%M:%S"