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

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -2,25 +2,23 @@ import html
 import logging
 from typing import Optional
 
-import qcanvas_backend.database.types as db
+from libqcanvas import db
 from bs4 import BeautifulSoup, Tag
+from libqcanvas.net.resources.extracting.no_extractor_error import NoExtractorError
+from libqcanvas.util import is_link_invisible
+from PySide6.QtCore import QUrl, Slot
+from PySide6.QtGui import QDesktopServices
+from PySide6.QtWidgets import QTextBrowser
 from qasync import asyncSlot
-from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
-from qcanvas_backend.net.resources.extracting.no_extractor_error import NoExtractorError
-from qcanvas_backend.util import is_link_invisible
-from qtpy.QtCore import QUrl, Slot
-from qtpy.QtGui import QDesktopServices
-from qtpy.QtWidgets import QTextBrowser
 
 from qcanvas.backend_connectors import FrontendResourceManager
 from qcanvas.util.html_cleaner import clean_up_html
-from qcanvas.util.qurl_util import file_url
 
 _logger = logging.getLogger(__name__)
 
 
 class ResourceRichBrowser(QTextBrowser):
-    def __init__(self, downloader: ResourceManager):
+    def __init__(self, downloader: FrontendResourceManager):
         super().__init__()
         self._downloader = downloader
         self._content: Optional[db.CourseContentItem] = None
@@ -30,9 +28,8 @@ class ResourceRichBrowser(QTextBrowser):
         self.setOpenLinks(False)
         self.anchorClicked.connect(self._open_url)
 
-        if isinstance(self._downloader, FrontendResourceManager):
-            self._downloader.download_finished.connect(self._download_updated)
-            self._downloader.download_failed.connect(self._download_updated)
+        self._downloader.download_finished.connect(self._download_updated)
+        self._downloader.download_failed.connect(self._download_updated)
 
     def show_blank(self, completely_blank: bool = False) -> None:
         if completely_blank:
@@ -43,14 +40,14 @@ class ResourceRichBrowser(QTextBrowser):
         self._content = None
         self._current_content_resources.clear()
 
-    def show_content(self, page: db.CourseContentItem) -> None:
+    def show_content(self, page: db.AnyContentItem) -> None:
         if page.body is None:
             self.show_blank()
         else:
             self._collect_resources(page)
             self._show_page_content(page)
 
-    def _collect_resources(self, page: db.CourseContentItem):
+    def _collect_resources(self, page: db.AnyContentItem):
         self._current_content_resources = {
             resource.id: resource for resource in page.resources
         }
@@ -105,17 +102,9 @@ class ResourceRichBrowser(QTextBrowser):
 
         return BeautifulSoup(
             markup=f"""
-            <a href="data:{html.escape(resource_id)}" style="font-weight: normal">
-                <!--<table style="vertical-align: middle; border-collapse: collapse;">
-                    <tr>
-                        <td style="text-decoration: none;">-->
-                            <img height="16" src="{html.escape(self._download_state_icon(resource.download_state))}"/>
-                        <!--</td>
-                        <td>-->
-                            {html.escape(resource.file_name)}
-                        <!--</td>
-                    </tr>
-                </table>-->
+            <a href="data:{html.escape(resource_id)}" style="font-weight: normal;">
+                <img height="18" src="{html.escape(self._download_state_icon(resource.download_state))}"/>
+                {html.escape(resource.file_name)}
             </a>
             """,
             features="html.parser",
@@ -145,16 +134,13 @@ class ResourceRichBrowser(QTextBrowser):
         resource = self._current_content_resources[resource_id]
 
         try:
-            await self._downloader.download(resource)
+            await self._downloader.download_and_open(resource)
         except Exception as e:
             _logger.warning(
                 "Download of resource id=%s failed", resource_id, exc_info=e
             )
             return
 
-        resource_path = file_url(self._downloader.resource_download_location(resource))
-        QDesktopServices.openUrl(resource_path)
-
     @Slot(db.Resource)
     def _download_updated(self, resource: db.Resource) -> None:
         if self._content is not None and resource.id in self._current_content_resources:
@@ -171,8 +157,8 @@ class ResourceRichBrowser(QTextBrowser):
                 _logger.warning(
                     "Resource has diverged from current loaded data, applying bandaid fix"
                 )
-                self._current_content_resources[resource.id].download_state = (
-                    resource.download_state
-                )
+                self._current_content_resources[
+                    resource.id
+                ].download_state = resource.download_state
 
             self._show_page_content(self._content)

qcanvas/ui/course_viewer/tree_widget_data_item.py

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from qtpy.QtWidgets import QTreeWidgetItem
+from PySide6.QtWidgets import QTreeWidgetItem
 
 from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
 

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,16 +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()
 
-        # fixme when using a slow usb stick, this can momentarily block the event loop.
-        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, QTreeWidgetItem] = {}
+        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 hasattr(item, "id"):
-                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/{main_ui → qcanvas_window}/course_viewer_container.py

@@ -1,16 +1,16 @@
 import logging
 from math import floor
-from typing import *
+from typing import Optional, Sequence
 
-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, empty_receipt
-from qtpy.QtCore import Qt, Slot
-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, 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.util import themes
+from qcanvas.theme import app_theme
 
 _logger = logging.getLogger(__name__)
 
@@ -29,17 +29,17 @@ class _PlaceholderLogo(QLabel):
         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
-        themes.theme_changed().connect(self._theme_changed)
+        app_theme.darkModeChanged.connect(self._dark_mode_changed)
 
     def resizeEvent(self, event) -> None:
         self._update_image()
 
     @Slot()
-    def _theme_changed(self) -> None:
+    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 with a max size of 1000x1000
+        # 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)
 

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

@@ -1,12 +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 import icons
-from qcanvas.util import settings
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 

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,11 +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 import icons
-from qcanvas.util import settings, themes
+from qcanvas.theme import app_theme
+import qcanvas.settings as settings
 
 _logger = logging.getLogger(__name__)
 
@@ -21,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)
 
@@ -36,10 +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)