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

qcanvas/ui/memory_tree/_tree_memory.py

@@ -1,49 +1,41 @@
+import asyncio
 import logging
 from pathlib import Path
-from typing import *
 
-from lightdb import LightDB, Model
+from aiofile import async_open
 
 from qcanvas.util import paths
 
 _logger = logging.getLogger(__name__)
 
 
-def _storage_path() -> Path:
-    path = paths.ui_storage() / "TREE.DB"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    return path
-
-
-_state_db = LightDB(str(_storage_path()))
-
-
-class _TreeState(Model, table="trees", db=_state_db):
-    tree_name: str
-    collapsed_items: List[str] = []
-
+class TreeMemory:
+    def __init__(self, tree_name: str):
+        self._tree_name = tree_name
+        self._loaded = False
+        self._collapsed_items: set[str] = set()
 
-def _get_or_create_state(name: str) -> _TreeState:
-    state = _TreeState.get(tree_name=name)
+    def load(self, force: bool = False):
+        if force or not self._loaded:
+            self._loaded = True
 
-    if state is None:
-        state = _TreeState.create(tree_name=name)
-        # Initialise the list here! Or else every instance has the same list object
-        state.collapsed_items = []
-        # Important or instances will get duplicated data in some cases
-        state.save()
-        return state
-    else:
-        return state
+            if not self._storage_path.exists():
+                # Nothing to do
+                return
 
+            # fixme this blocks the event loop, but using aiofile will require significant changes to other
+            #  parts of the code to accommodate these methods now being async.
+            #  this will really only have any noticeable effect on slow disks, and only ever happens once anyway.
+            with open(self._storage_path, "rt") as file:
+                lines = file.read().splitlines()
+                _logger.debug("Tree % loaded %s", self._tree_name, lines)
+                self._collapsed_items.update(lines)
 
-class TreeMemory:
-    def __init__(self, tree_name: str):
-        self._tree_name = tree_name
-        self._state = _get_or_create_state(tree_name)
+    async def save(self):
+        assert self._loaded, "Memory is not loaded yet"
 
-    def is_expanded(self, node_id: str) -> bool:
-        return node_id in self._state.expanded_items
+        async with async_open(self._storage_path, "wt") as file:
+            await file.write("\n".join(self._collapsed_items))
 
     def expanded(self, node_id: str) -> None:
         self.set_expanded(node_id, True)
@@ -52,15 +44,27 @@ class TreeMemory:
         self.set_expanded(node_id, False)
 
     def set_expanded(self, node_id: str, expanded: bool) -> None:
-        contains = node_id in self._state.collapsed_items
+        self.load()
 
-        if expanded and contains:
-            self._state.collapsed_items.remove(node_id)
-            self._state.save()
-        elif not expanded and not contains:
-            self._state.collapsed_items.append(node_id)
-            self._state.save()
+        if expanded and node_id in self._collapsed_items:
+            self._collapsed_items.remove(node_id)
+        else:
+            self._collapsed_items.add(node_id)
+
+        # hack: avoid blocking the event loop
+        asyncio.create_task(self.save())
+
+    @property
+    def collapsed_ids(self) -> set[str]:
+        assert self._loaded, "Memory not loaded yet"
+        return self._collapsed_items
 
     @property
-    def collapsed_ids(self) -> List[str]:
-        return self._state.collapsed_items
+    def _storage_path(self) -> Path:
+        path = (
+            paths.data_storage()
+            / "tree_state"
+            / f"{self._tree_name}_collapsed_items.txt"
+        )
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path

qcanvas/ui/memory_tree/memory_tree_widget.py

@@ -1,8 +1,8 @@
 import logging
-from typing import *
+from typing import Optional, Sequence
 
-from qtpy.QtCore import QItemSelectionModel, Slot
-from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem, QWidget
+from PySide6.QtCore import QItemSelectionModel, Slot
+from PySide6.QtWidgets import QTreeWidget, QTreeWidgetItem, QWidget
 
 from qcanvas.ui.memory_tree._tree_memory import TreeMemory
 from qcanvas.ui.memory_tree.memory_tree_widget_item import MemoryTreeWidgetItem
@@ -10,6 +10,10 @@ from qcanvas.ui.memory_tree.memory_tree_widget_item import MemoryTreeWidgetItem
 _logger = logging.getLogger(__name__)
 
 
+class _HasID:
+    id: str
+
+
 class MemoryTreeWidget(QTreeWidget):
     def __init__(
         self,
@@ -17,7 +21,7 @@ class MemoryTreeWidget(QTreeWidget):
         parent: Optional[QWidget] = None,
     ):
         super().__init__(parent)
-        self._id_map: dict[str, MemoryTreeWidgetItem] = {}
+        self._id_map: dict[str, QTreeWidgetItem | _HasID] = {}
         self._memory = TreeMemory(tree_name)
         self._suppress_expansion_signals = False
         self._suppress_selection_signal = False
@@ -30,7 +34,7 @@ class MemoryTreeWidget(QTreeWidget):
 
         try:
             self._suppress_expansion_signals = True
-
+            self._memory.load()
             collapsed_ids = self._memory.collapsed_ids
 
             for widget in self._id_map.values():
@@ -44,7 +48,7 @@ class MemoryTreeWidget(QTreeWidget):
         super().clear()
         self._id_map.clear()
 
-    def select_ids(self, ids: List[str]) -> bool:
+    def select_ids(self, ids: list[str]) -> bool:
         """
         :returns: True if all ids were still found in the tree, False if one or more was missing
         """
@@ -94,26 +98,26 @@ class MemoryTreeWidget(QTreeWidget):
     def _add_widget_to_id_map(
         self, widget: QTreeWidgetItem | Sequence[QTreeWidgetItem]
     ):
-        map_updates = {}
-        widget_stack = widget if isinstance(widget, List) else [widget]
+        widget_stack = widget if isinstance(widget, list) else [widget]
 
         while len(widget_stack) > 0:
-            item = widget_stack.pop()
+            popped_widget = widget_stack.pop()
 
-            if isinstance(item, MemoryTreeWidgetItem):
-                if item.id in self._id_map or item.id in map_updates:
-                    raise ValueError(f"Item with ID {item.id} is already in the tree")
+            if hasattr(popped_widget, "id"):
+                if popped_widget.id in self._id_map:
+                    raise ValueError(
+                        f"Item with ID {popped_widget.id} is already in the tree"
+                    )
 
-                map_updates[item.id] = item
-                _logger.debug("Add %s to map", item.id)
+                self._id_map[popped_widget.id] = popped_widget
+                _logger.debug("Add %s to map", popped_widget.id)
 
-            if item.childCount() > 0:
+            if popped_widget.childCount() > 0:
                 widget_stack.extend(
-                    [item.child(index) for index in range(0, item.childCount())]
+                    popped_widget.child(index)
+                    for index in range(0, popped_widget.childCount())
                 )
 
-        self._id_map.update(map_updates.items())
-
     @Slot(QTreeWidgetItem)
     def _expanded(self, item: QTreeWidgetItem):
         if self._suppress_expansion_signals:

qcanvas/ui/memory_tree/memory_tree_widget_item.py

@@ -1,14 +1,14 @@
 import logging
-from typing import *
+from typing import Optional
 
-from qtpy.QtWidgets import QTreeWidgetItem
+from PySide6.QtWidgets import QTreeWidgetItem
 
 _logger = logging.getLogger(__name__)
 
 
 class MemoryTreeWidgetItem(QTreeWidgetItem):
     def __init__(
-        self, id: str, data: Optional[object], strings: Optional[List[str]] = None
+        self, id: str, data: Optional[object], strings: Optional[list[str]] = None
     ):
         super().__init__(strings)
         self._id = id

qcanvas/ui/qcanvas_window/__init__.py

@@ -0,0 +1 @@
+from .qcanvas_window import QCanvasWindow

qcanvas/ui/qcanvas_window/course_viewer_container.py

@@ -0,0 +1,95 @@
+import logging
+from math import floor
+from typing import Optional, Sequence
+
+from libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt, empty_receipt
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtWidgets import QLabel, QSizePolicy, QStackedWidget
+
+from qcanvas import icons
+from qcanvas.ui.course_viewer.course_viewer import CourseViewer
+from qcanvas.theme import app_theme
+
+_logger = logging.getLogger(__name__)
+
+
+class _PlaceholderLogo(QLabel):
+    """
+    Automatically resizing logo icon for when no course is selected
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._icon = icons.branding.logo_transparent
+        self._old_width = -1
+        self._old_height = -1
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
+        # Because we are using a pixmap for the icon, it will not get updated like a normal QIcon when the theme changes,
+        # So we need to update it ourselves
+        app_theme.darkModeChanged.connect(self._dark_mode_changed)
+
+    def resizeEvent(self, event) -> None:
+        self._update_image()
+
+    @Slot()
+    def _dark_mode_changed(self) -> None:
+        self._update_image(force=True)
+
+    def _update_image(self, force: bool = False) -> None:
+        # Calculate the size of the logo as half of the width/height, but prevent it from becoming too large
+        width = min(floor(self.width() * 0.5), 500)
+        height = min(floor(self.height() * 0.5), 500)
+
+        if force or (width != self._old_width and height != self._old_height):
+            self._old_width = width
+            self._old_height = height
+            self.setPixmap(self._icon.pixmap(width, height))
+
+
+class CourseViewerContainer(QStackedWidget):
+    def __init__(self, downloader: ResourceManager):
+        super().__init__()
+        self._course_viewers: dict[str, CourseViewer] = {}
+        self._downloader = downloader
+        self._last_course_id: Optional[str] = None
+        self._selected_course: Optional[db.Course] = None
+        self._last_sync_receipt: SyncReceipt = empty_receipt()
+        self._placeholder = _PlaceholderLogo()
+        self.addWidget(self._placeholder)
+
+    def show_blank(self) -> None:
+        self._last_course_id = None
+        self._selected_course = None
+        self.setCurrentWidget(self._placeholder)
+
+    def load_course(self, course: db.Course) -> None:
+        if course.id not in self._course_viewers:
+            viewer = CourseViewer(
+                course=course,
+                downloader=self._downloader,
+                sync_receipt=self._last_sync_receipt,
+            )
+            self._course_viewers[course.id] = viewer
+            self.addWidget(viewer)
+        else:
+            viewer = self._course_viewers[course.id]
+
+        self.setCurrentWidget(viewer)
+        self._selected_course = course
+        self._last_course_id = course.id
+
+    async def reload_all(
+        self, courses: Sequence[db.Course], *, sync_receipt: SyncReceipt
+    ) -> None:
+        self._last_sync_receipt = sync_receipt
+        for course in courses:
+            if course.id in self._course_viewers:
+                viewer = self._course_viewers[course.id]
+                viewer.reload(course, sync_receipt=sync_receipt)
+
+    @property
+    def selected_course(self) -> Optional[db.Course]:
+        return self._selected_course

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

@@ -1,11 +1,12 @@
 import logging
-from typing import *
+from typing import Optional
 
-from qtpy.QtCore import Slot
-from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QMenu
+from PySide6.QtCore import Slot
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMenu
 
-from qcanvas.util import settings
+from qcanvas import icons
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -36,6 +37,7 @@ class _EnableVideoDownloadOption(QAction):
 
 class AutoDownloadResourcesMenu(QMenu):
     def __init__(self, parent: Optional[QMenu] = None):
-        super().__init__("Download new resources", parent)
+        super().__init__("Auto download resources", parent)
         self.addAction(_EnableAutoDownloadOption(self))
         self.addAction(_EnableVideoDownloadOption(self))
+        self.setIcon(icons.options.auto_download)

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

@@ -1,11 +1,11 @@
 import logging
-from typing import *
+from typing import Optional
 
-from qtpy.QtCore import Slot
-from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QMenu
+from PySide6.QtCore import Slot
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMenu
 
-from qcanvas.util import settings
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -14,11 +14,12 @@ class QuickSyncOption(QAction):
     def __init__(self, parent: Optional[QMenu] = None):
         super().__init__("Ignore old courses", parent)
         self.setToolTip(
-            "When this option is selected, old courses will not be synchronised. This will only effect the first sync."
+            "When enabled, old courses will not be synchronised. This won't hide any old courses that were previously synchronised."
         )
         self.setCheckable(True)
         self.setChecked(settings.client.quick_sync_enabled)
         self.triggered.connect(self._triggered)
+        # self.setIcon(icons.options.ignore_old)
 
     @Slot()
     def _triggered(self) -> None:

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

@@ -1,11 +1,11 @@
 import logging
-from typing import *
+from typing import Optional
 
-from qtpy.QtCore import Slot
-from qtpy.QtGui import QAction
-from qtpy.QtWidgets import QMenu
+from PySide6.QtCore import Slot
+from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMenu
 
-from qcanvas.util import settings
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -14,11 +14,12 @@ class SyncOnStartOption(QAction):
     def __init__(self, parent: Optional[QMenu] = None):
         super().__init__("Sync on start", parent)
         self.setToolTip(
-            "When this option is selected, synchronisation will be started automatically when the app starts."
+            "When enabled, synchronisation will start when the application is opened."
         )
         self.setCheckable(True)
         self.setChecked(settings.client.sync_on_start)
         self.triggered.connect(self._triggered)
+        # self.set(icons.options.sync_on_start)
 
     @Slot()
     def _triggered(self) -> None:

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

@@ -1,10 +1,12 @@
 import logging
 
-from qtpy.QtCore import Slot
-from qtpy.QtGui import QAction, QActionGroup
-from qtpy.QtWidgets import QMenu
+from PySide6.QtCore import Slot
+from PySide6.QtGui import QAction, QActionGroup
+from PySide6.QtWidgets import QMenu
 
-from qcanvas.util import settings, themes
+from qcanvas import icons
+from qcanvas.theme import app_theme
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -20,11 +22,10 @@ class _ThemeAction(QAction):
     @Slot()
     def _change_theme(self) -> None:
         settings.ui.theme = self._theme_name
-        themes.apply(self._theme_name)
+        app_theme.theme = self._theme_name
 
 
 class ThemeSelectionMenu(QMenu):
-
     def __init__(self, parent: QMenu):
         super().__init__("Theme", parent)
 
@@ -35,9 +36,10 @@ class ThemeSelectionMenu(QMenu):
         dark_theme = _ThemeAction("Dark", "dark", self)
         native_theme = _ThemeAction("Native (requires restart)", "native", self)
 
-        actions = [auto_theme, light_theme, dark_theme, native_theme]
+        select_theme_actions = [auto_theme, light_theme, dark_theme, native_theme]
 
-        self.addActions(actions)
+        self.addActions(select_theme_actions)
+        self.setIcon(icons.options.theme)
 
-        for theme in actions:
-            action_group.addAction(theme)
+        for selection_action in select_theme_actions:
+            action_group.addAction(selection_action)