qcanvas 1.0.11__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__)
 
@@ -15,6 +15,7 @@ class _ClientSettings:
     canvas_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
     canvas_api_key: MappedSetting[Optional[str]] = MappedSetting(default=None)
     panopto_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
+    panopto_disabled = BoolSetting(default=False)
     quick_sync_enabled = BoolSetting(default=False)
     sync_on_start = BoolSetting(default=False)
     download_new_resources = BoolSetting(default=False)
@@ -27,5 +28,13 @@ class _ClientSettings:
         )
 
     @property
-    def panopto_config(self) -> PanoptoClientConfig:
-        return PanoptoClientConfig(panopto_url=self.panopto_url)
+    def panopto_config(self) -> Optional[PanoptoClientConfig]:
+        """
+        Generates a panopto client config. If panopto is disabled, it returns None.
+        """
+
+        if self.panopto_disabled:
+            _logger.debug("Panopto is disabled")
+            return None
+        else:
+            return PanoptoClientConfig(panopto_url=self.panopto_url)

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.
@@ -53,8 +50,13 @@ class BoolSetting(MappedSetting[bool]):
         try:
             # noinspection PyTypeChecker
             value: str = super()._read()
+
+            if isinstance(value, bool):
+                return value
+
             return value.lower() == "true"
-        except:
+        except Exception as e:
+            _logger.error("Could not read setting", exc_info=e)
             return self.default
 
     # @override

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,28 +1,26 @@
 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.memory_tree import MemoryTreeWidget, MemoryTreeWidgetItem
+from qcanvas.ui.course_viewer.tree_widget_data_item import AnyTreeDataItem
+from qcanvas.ui.memory_tree import MemoryTreeWidget
 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
@@ -31,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
@@ -45,8 +43,9 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         *,
         header_text: str | Sequence[str],
         indentation: int = 20,
-        max_width: int,
-        min_width: int,
+        max_width: Optional[int] = None,
+        min_width: Optional[int] = None,
+        alternating_row_colours: bool = False,
     ) -> None:
         if not isinstance(header_text, str) and isinstance(header_text, Sequence):
             self.setHeaderLabels(header_text)
@@ -54,8 +53,27 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
             self.setHeaderLabel(header_text)
 
         self.setIndentation(indentation)
-        self.setMaximumWidth(max_width)
-        self.setMinimumWidth(min_width)
+
+        if max_width is not None:
+            self.setMaximumWidth(max_width)
+
+        if min_width is not None:
+            self.setMinimumWidth(min_width)
+
+        self.setAlternatingRowColors(alternating_row_colours)
+
+    def set_columns_resize_mode(
+        self,
+        resize_mode_for_columns: list[QHeaderView.ResizeMode],
+        *,
+        stretch_last: bool = False,
+    ) -> None:
+        header = self.header()
+
+        for index, mode in enumerate(resize_mode_for_columns):
+            header.setSectionResizeMode(index, mode)
+
+        header.setStretchLastSection(stretch_last)
 
     def reload(self, data: T, *, sync_receipt: SyncReceipt) -> None:
         self._reloading = True
@@ -77,7 +95,7 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
     @abstractmethod
     def create_tree_items(
         self, data: T, sync_receipt: SyncReceipt
-    ) -> Sequence[MemoryTreeWidgetItem]: ...
+    ) -> Sequence[QTreeWidgetItem]: ...
 
     @Slot(QItemSelection, QItemSelection)
     def _selection_changed(self, _0: QItemSelection, _1: QItemSelection) -> None:
@@ -93,7 +111,7 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         if self.is_unseen(selected):
             self.mark_as_seen(selected)
 
-        if not isinstance(selected, MemoryTreeWidgetItem):
+        if not isinstance(selected, AnyTreeDataItem):
             self._clear_selection()
             return
 

qcanvas/ui/course_viewer/course_tree/__init__.py

@@ -0,0 +1 @@
+from .course_tree import CourseTree

qcanvas/ui/course_viewer/course_tree/_course_icon_generator.py

@@ -0,0 +1,86 @@
+import itertools
+import logging
+import random
+
+from cachetools import cached
+from PySide6.QtCore import QByteArray
+from PySide6.QtGui import QColor, QPainter, QPixmap
+from PySide6.QtSvg import QSvgRenderer
+
+_logger = logging.getLogger(__name__)
+_transparent = QColor("#00000000")
+_colours = [
+    QColor(f"#{colour}")
+    for colour in [
+        "2ad6cb",
+        "2d50ed",
+        "7a10e4",
+        "c61aaf",
+        "d91b1b",
+        "c7541b",
+        "facd07",  # facd07
+        "a9cf12",
+    ]
+]
+
+
+class CourseIconGenerator:
+    @staticmethod
+    @cached(cache={})
+    def get_for_term(term_id: str) -> "CourseIconGenerator":
+        return CourseIconGenerator(term_id)
+
+    def __init__(self, term_id: str):
+        shuffled = list(_colours)
+
+        # This is the dumbest way I've ever seen a language implement setting a seed for a RNG.
+        # WTF python?! Why???
+        random.seed(term_id)
+        random.shuffle(shuffled)
+
+        self._iterator = itertools.cycle(shuffled)
+
+    def get_icon(self) -> QPixmap:
+        return _create_icon(self._get_colour())
+
+    def _get_colour(self) -> QColor:
+        return next(self._iterator)
+
+
+@cached(cache={}, key=lambda colour: colour.name(QColor.NameFormat.HexRgb))
+def _create_icon(base_colour: QColor) -> QPixmap:
+    dark_colour = QColor.fromHslF(
+        base_colour.hslHueF(),
+        base_colour.hslSaturationF(),
+        base_colour.lightnessF() * 0.6875,
+    )
+
+    result_pixmap = QPixmap(256, 256)
+    result_pixmap.fill(_transparent)
+
+    with (painter := QPainter(result_pixmap)):
+        svg = _create_svg_from_colours(base_colour, dark_colour)
+        svg.render(painter)
+
+    return result_pixmap
+
+
+def _create_svg_from_colours(light_colour: QColor, dark_colour: QColor) -> QSvgRenderer:
+    # Original SVG is from SVGRepo.com
+    return QSvgRenderer(
+        QByteArray(
+            f"""
+            <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+            <svg width="800px" height="800px" viewBox="0 0 24 24" >
+             <g transform="translate(0 -1028.4)">
+              <path d="m3 8v2 1 3 1 5 1c0 1.105 0.8954 2 2 2h14c1.105 0 2-0.895 2-2v-1-5-4-3h-18z" transform="translate(0 1028.4)" fill="{dark_colour.name()}"/>
+              <path d="m3 1035.4v2 1 3 1 5 1c0 1.1 0.8954 2 2 2h14c1.105 0 2-0.9 2-2v-1-5-4-3h-18z" fill="#ecf0f1"/>
+              <path d="m3 1034.4v2 1 3 1 5 1c0 1.1 0.8954 2 2 2h14c1.105 0 2-0.9 2-2v-1-5-4-3h-18z" fill="#bdc3c7"/>
+              <path d="m3 1033.4v2 1 3 1 5 1c0 1.1 0.8954 2 2 2h14c1.105 0 2-0.9 2-2v-1-5-4-3h-18z" fill="#ecf0f1"/>
+              <path d="m5 1c-1.1046 0-2 0.8954-2 2v1 4 2 1 3 1 5 1c0 1.105 0.8954 2 2 2h2v-1h-1.5c-0.8284 0-1.5-0.672-1.5-1.5s0.6716-1.5 1.5-1.5h12.5 1c1.105 0 2-0.895 2-2v-1-5-4-3-1c0-1.1046-0.895-2-2-2h-4-10z" transform="translate(0 1028.4)" fill="{dark_colour.name()}"/>
+              <path d="m8 1v18h1 9 1c1.105 0 2-0.895 2-2v-1-5-4-3-1c0-1.1046-0.895-2-2-2h-4-6-1z" transform="translate(0 1028.4)" fill="{light_colour.name()}"/>
+             </g>
+            </svg>
+            """.strip().encode()
+        )
+    )

qcanvas/ui/course_viewer/{course_tree.py → course_tree/course_tree.py}

@@ -1,23 +1,29 @@
 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,
+)
+from qcanvas.ui.course_viewer.tree_widget_data_item import TreeWidgetDataItem
 from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
 
 _logger = logging.getLogger(__name__)
 
 
-class _CourseTreeItem(MemoryTreeWidgetItem):
+class _CourseTreeItem(TreeWidgetDataItem):
     def __init__(self, course: db.Course, owner: "CourseTree"):
-        MemoryTreeWidgetItem.__init__(
+        TreeWidgetDataItem.__init__(
             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
@@ -29,7 +35,7 @@ class _CourseTreeItem(MemoryTreeWidgetItem):
             | 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)
 
@@ -49,19 +55,23 @@ class CourseTree(ContentTree[Sequence[db.Term]]):
     def __init__(self):
         super().__init__("course_tree", emit_selection_signal_for_type=db.Course)
 
-        self.ui_setup(max_width=250, min_width=150, header_text="Courses")
+        self.ui_setup(
+            max_width=250, min_width=150, header_text="Courses", indentation=15
+        )
 
     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)
 
             for course in term.courses:
-                course_widget = self._create_course_widget(course, sync_receipt)
-                # course_widget.renamed.connect(self._on_course_renamed)
+                course_widget = self._create_course_widget(
+                    course, course_icon_generator, sync_receipt
+                )
                 term_widget.addChild(course_widget)
 
             widgets.append(term_widget)
@@ -69,9 +79,13 @@ class CourseTree(ContentTree[Sequence[db.Term]]):
         return widgets
 
     def _create_course_widget(
-        self, course: db.Course, sync_receipt: SyncReceipt
+        self,
+        course: db.Course,
+        course_icon_generator: CourseIconGenerator,
+        sync_receipt: SyncReceipt,
     ) -> _CourseTreeItem:
         course_widget = _CourseTreeItem(course, self)
+        course_widget.setIcon(0, course_icon_generator.get_icon())
 
         if sync_receipt.was_updated(course):
             self.mark_as_unseen(course_widget)
@@ -81,5 +95,6 @@ class CourseTree(ContentTree[Sequence[db.Term]]):
     def _create_term_widget(self, term: db.Term) -> MemoryTreeWidgetItem:
         term_widget = MemoryTreeWidgetItem(id=term.id, data=term, strings=[term.name])
         term_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+        term_widget.setIcon(0, icons.tree_items.semester)
 
         return term_widget