qcanvas 1.2.0__py3-none-any.whl → 2026.1.19__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))
@@ -20,7 +20,7 @@ class ThemeSetting(MappedSetting):
 
 
 class _UISettings:
-    settings = QSettings("QCanvasTeam", "QCanvas")
+    settings = QSettings("QCanvasTeam", "UI")
     theme: ThemeSetting = ThemeSetting()
     last_geometry: MappedSetting[QByteArray] = MappedSetting()
     last_window_state: MappedSetting[QByteArray] = MappedSetting()

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,33 +1,31 @@
 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__)
 
 
 @dataclass
 class _Tab:
-    index: int
     icon: QIcon
     highlighted_icon: QIcon
+    update_type: type
 
 
 class CourseViewer(QWidget):
-
     def __init__(
         self,
         course: db.Course,
@@ -40,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,
@@ -66,7 +64,7 @@ class CourseViewer(QWidget):
         # )
 
         self._tab_widget = QTabWidget()
-        self._tabs: dict[str, _Tab] = {}
+        self._tabs: dict[int, _Tab] = {}
 
         # self._setup_tab(
         #     name="Files",
@@ -74,40 +72,45 @@ class CourseViewer(QWidget):
         #     icon=icons.tabs.pages,
         #     highlighted_icon=icons.tabs.pages_new_content,
         # )
-        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._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._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!
 
         self.setLayout(layout(QVBoxLayout, self._course_label, self._tab_widget))
-
         self._tab_widget.currentChanged.connect(self._tab_changed)
-
         self._highlight_tabs(sync_receipt)
-        # self._highlight_tab(
-        #     self._tab_widget.tabText(0)
-        # )  # Because the first tab always gets auto-selected
 
-    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[name] = _Tab(index, 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:
         # self._files_tab.reload(course, sync_receipt=sync_receipt)
@@ -118,39 +121,22 @@ class CourseViewer(QWidget):
 
     @Slot(int)
     def _tab_changed(self, index: int) -> None:
+        _logger.debug(f"Index = {index}")
         if index != -1:
-            self._unhighlight_tab(self._tab_widget.tabText(self._previous_tab_index))
+            _logger.debug(f"Previous 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_resources) > 0:
-            #     self._highlight_tab(0)
-
-            if len(updates.updated_pages) > 0:
-                self._highlight_tab("Pages")
-            else:
-                self._unhighlight_tab("Pages")
-
-            if len(updates.updated_assignments) > 0:
-                self._highlight_tab("Assignments")
-            else:
-                self._unhighlight_tab("Assignments")
-
-            if len(updates.updated_messages) > 0:
-                self._highlight_tab("Mail")
-            else:
-                self._unhighlight_tab("Mail")
-        else:
-            for tab_name in self._tabs.keys():
-                self._unhighlight_tab(tab_name)
-
-    def _highlight_tab(self, tab_name: str) -> None:
-        tab = self._tabs[tab_name]
-        self._tab_widget.setTabIcon(tab.index, tab.highlighted_icon)
-
-    def _unhighlight_tab(self, tab_name: str) -> None:
-        tab = self._tabs[tab_name]
-        self._tab_widget.setTabIcon(tab.index, tab.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 _set_tab_highlight(self, tab_index: int, highlighted: bool) -> None:
+        tab = self._tabs[tab_index]
+        self._tab_widget.setTabIcon(
+            tab_index, tab.highlighted_icon if highlighted else tab.icon
+        )