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

qcanvas/ui/course_viewer/tabs/file_tab/file_tree.py

@@ -0,0 +1,96 @@
+import logging
+from abc import ABC
+
+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 QPoint, Qt, Slot
+from PySide6.QtWidgets import QHeaderView, QMenu, QTreeWidgetItem
+
+from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.course_viewer.tree_widget_data_item import (
+    AnyTreeDataItem,
+    TreeWidgetDataItem,
+)
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+from qcanvas.util.file_icons import icon_for_filename
+from qcanvas.util.ui_tools import create_qaction
+
+_logger = logging.getLogger(__name__)
+
+
+class FileTree(ContentTree[db.Course], ABC):
+    @classmethod
+    def create_from_receipt(
+        cls,
+        course: db.Course,
+        *,
+        sync_receipt: SyncReceipt,
+        resource_manager: ResourceManager,
+    ) -> "FileTree":
+        tree = cls(tree_name=course.id, resource_manager=resource_manager)
+        tree.reload(course, sync_receipt=sync_receipt)
+        return tree
+
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(tree_name, emit_selection_signal_for_type=object)
+        self._resource_manager = resource_manager
+
+        self.ui_setup(header_text=["File", "Date"])
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._context_menu)
+
+    def _create_group_widget(
+        self, group: db.ContentGroup, sync_receipt: SyncReceipt
+    ) -> MemoryTreeWidgetItem:
+        group_widget = MemoryTreeWidgetItem(
+            id=group.id, data=group, strings=[group.name]
+        )
+
+        group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
+
+        if sync_receipt.was_updated(group):
+            self.mark_as_unseen(group_widget)
+
+        return group_widget
+
+    def _create_resource_widget(
+        self, resource: db.Resource, sync_receipt: SyncReceipt
+    ) -> QTreeWidgetItem:
+        # fixme the reesource widget items shouls NOT be a memory widget item because they can't be collapsed, but
+        #  mostly because the same file can appear in the tree multiple times in different places, which memory tree
+        #  can NOT deal with!
+        item_widget = TreeWidgetDataItem(
+            id=resource.id,
+            data=resource,
+            strings=[resource.file_name, str(resource.discovery_date.date())],
+        )
+        item_widget.setIcon(
+            0,
+            icon_for_filename(resource.file_name),
+        )
+        item_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+
+        if sync_receipt.was_updated(resource):
+            self.mark_as_unseen(item_widget)
+
+        return item_widget
+
+    @Slot(QPoint)
+    def _context_menu(self, point: QPoint) -> None:
+        item = self.itemAt(point)
+
+        if isinstance(item, AnyTreeDataItem):
+            menu = QMenu()
+            create_qaction(
+                name="Test",
+                parent=menu,
+                triggered=lambda: print(f"Clicked {item.extra_data.file_name}"),
+            )
+            menu.addAction("Another thing")
+
+            menu.exec(self.mapToGlobal(point))

qcanvas/ui/course_viewer/tabs/file_tab/pages_file_tree.py

@@ -0,0 +1,55 @@
+import logging
+from typing import Sequence
+
+from libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+
+from qcanvas.ui.course_viewer.tabs.file_tab.file_tree import FileTree
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+_logger = logging.getLogger(__name__)
+
+
+class PagesFileTree(FileTree):
+    def __init__(self, tree_name: str, *, resource_manager: ResourceManager):
+        super().__init__(
+            tree_name=f"{tree_name}.pages", resource_manager=resource_manager
+        )
+
+    def create_tree_items(
+        self, data: db.Course, sync_receipt: SyncReceipt
+    ) -> Sequence[MemoryTreeWidgetItem]:
+        widgets = []
+
+        for group in data.modules:  # type: db.Module
+            if not group.pages:
+                continue
+
+            # Init group_widget lazily to prevent creating pointless tree widgets
+            group_widget: MemoryTreeWidgetItem | None = None
+            items_in_group = set()
+
+            for item in group.pages:
+                resource_widgets = []
+
+                for resource in item.resources:  # type: db.Resource
+                    if resource.id not in items_in_group:
+                        items_in_group.add(resource.id)
+
+                        if group_widget is None:
+                            group_widget = self._create_group_widget(
+                                group, sync_receipt
+                            )
+
+                        resource_widgets.append(
+                            self._create_resource_widget(resource, sync_receipt)
+                        )
+
+                if len(resource_widgets) > 0:
+                    group_widget.addChildren(resource_widgets)
+
+            if group_widget is not None:
+                widgets.append(group_widget)
+
+        return widgets

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tab.py

@@ -1,16 +1,18 @@
 import logging
-from typing import *
+from typing import override
 
-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, QMainWindow, QDockWidget
 
+from qcanvas.backend_connectors import FrontendResourceManager
 from qcanvas.ui.course_viewer.tabs.content_tab import ContentTab
 from qcanvas.ui.course_viewer.tabs.mail_tab.mail_tree import MailTree
-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
+import qcanvas.util.ui_tools as ui
+from qcanvas.ui.qml_components import AttachmentsPane
 
 _logger = logging.getLogger(__name__)
 
@@ -22,38 +24,59 @@ class MailTab(ContentTab):
         *,
         course: db.Course,
         sync_receipt: SyncReceipt,
-        downloader: ResourceManager,
+        downloader: FrontendResourceManager,
     ):
+        self._main_container = QMainWindow()
+
         super().__init__(
             explorer=MailTree.create_from_receipt(course, sync_receipt=sync_receipt),
             title_placeholder_text="No mail selected",
             downloader=downloader,
         )
 
+        self._main_container.setCentralWidget(self._viewer)
+        self._files_pane = AttachmentsPane(downloader)
+        self._files_dock = ui.dock_widget(
+            widget=self._files_pane,
+            title="Attachments",
+            name="attachments",
+            min_size=ui.size(150, 100),
+            features=QDockWidget.DockWidgetFeature.DockWidgetMovable,
+        )
+        self._main_container.addDockWidget(
+            Qt.DockWidgetArea.TopDockWidgetArea, self._files_dock
+        )
         self._date_sent_label = QLabel("")
         self._sender_label = QLabel("")
 
         self.enable_info_grid()
 
-    def setup_info_grid(self) -> QGridLayout:
-        grid = grid_layout(
-            [
-                [
-                    bold_label("From:"),
-                    self._sender_label,
-                ],
-                [
-                    bold_label("Date:"),
-                    self._date_sent_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)
-
-        return grid
+    def setup_info_grid(self) -> QLayout:
+        return ui.form_layout(
+            {"From": self._sender_label, "Date": self._date_sent_label},
+        )
 
-    def update_info_grid(self, mail: db.CourseMessage) -> None:
-        self._date_sent_label.setText(mail.creation_date.strftime(date_strftime_format))
+    def update_info_grid(self, mail: db.Message) -> None:
+        self._date_sent_label.setText(
+            as_local(mail.creation_date).strftime(date_strftime_format)
+        )
         self._sender_label.setText(mail.sender_name)
+
+        if mail.attachments:
+            self._files_pane.load_files(mail.attachments)
+            self._files_dock.show()
+        else:
+            self._files_dock.hide()
+
+    @override
+    def _show_blank(self) -> None:
+        super()._show_blank()
+        self._files_dock.hide()

qcanvas/ui/course_viewer/tabs/mail_tab/mail_tree.py

@@ -1,53 +1,52 @@
 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.QtWidgets import *
+from libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtWidgets import QHeaderView
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.content_tree import ContentTree
-from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+from qcanvas.ui.course_viewer.tree_widget_data_item import TreeWidgetDataItem
 
 _logger = logging.getLogger(__name__)
 
 
 class MailTree(ContentTree[db.Course]):
-
     def __init__(self, course_id: str):
         super().__init__(
             tree_name=f"course.{course_id}.mail",
-            emit_selection_signal_for_type=db.CourseMessage,
+            emit_selection_signal_for_type=db.Message,
         )
+
         self.ui_setup(
             header_text=["Subject", "Sender"],
             max_width=500,
             min_width=300,
             indentation=20,
+            alternating_row_colours=True,
         )
 
-        self._adjust_header()
-
-    def _adjust_header(self) -> None:
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setStretchLastSection(False)
+        self.set_columns_resize_mode(
+            [QHeaderView.ResizeMode.Stretch, QHeaderView.ResizeMode.ResizeToContents]
+        )
 
     def create_tree_items(
         self, course: db.Course, sync_receipt: SyncReceipt
-    ) -> Sequence[MemoryTreeWidgetItem]:
+    ) -> Sequence[TreeWidgetDataItem]:
         widgets = []
 
-        for message in course.messages:  # type: db.CourseMessage
+        for message in course.messages:  # type: db.Message
             message_widget = self._create_mail_widget(message, sync_receipt)
+            message_widget.setIcon(0, icons.tree_items.mail)
             widgets.append(message_widget)
 
         return widgets
 
     def _create_mail_widget(
-        self, message: db.CourseMessage, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
-        message_widget = MemoryTreeWidgetItem(
+        self, message: db.Message, sync_receipt: SyncReceipt
+    ) -> TreeWidgetDataItem:
+        message_widget = TreeWidgetDataItem(
             id=message.id,
             data=message,
             strings=[message.name, message.sender_name],

qcanvas/ui/course_viewer/tabs/page_tab/page_tab.py

@@ -1,8 +1,8 @@
 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 libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
 
 from qcanvas.ui.course_viewer.tabs.content_tab import ContentTab
 from qcanvas.ui.course_viewer.tabs.page_tab.page_tree import PageTree

qcanvas/ui/course_viewer/tabs/page_tab/page_tree.py

@@ -1,11 +1,13 @@
 import logging
-from typing import Optional, Sequence
+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 libqcanvas import db
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtCore import Qt
 
+from qcanvas import icons
 from qcanvas.ui.course_viewer.content_tree import ContentTree
+from qcanvas.ui.course_viewer.tree_widget_data_item import TreeWidgetDataItem
 from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
 
 _logger = logging.getLogger(__name__)
@@ -15,8 +17,9 @@ class PageTree(ContentTree[db.Course]):
     def __init__(self, course_id: str):
         super().__init__(
             tree_name=f"course.{course_id}.modules",
-            emit_selection_signal_for_type=db.ModulePage,
+            emit_selection_signal_for_type=db.Page,
         )
+
         self.ui_setup(
             header_text="Content", indentation=15, max_width=300, min_width=150
         )
@@ -27,7 +30,10 @@ class PageTree(ContentTree[db.Course]):
         widgets = []
 
         for module in course.modules:  # type: db.Module
-            module_widget = self._create_module_widget(module, sync_receipt)
+            if len(module.pages) == 0:
+                continue
+
+            module_widget = self._create_module_widget(module)
             widgets.append(module_widget)
 
             for page in module.pages:  # type: db.ModulePage
@@ -36,25 +42,21 @@ class PageTree(ContentTree[db.Course]):
 
         return widgets
 
-    def _create_module_widget(
-        self, module: db.Module, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
+    def _create_module_widget(self, module: db.Module) -> MemoryTreeWidgetItem:
         module_widget = MemoryTreeWidgetItem(
             id=module.id, data=module, strings=[module.name]
         )
         module_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
-
-        # Todo not sure if modules should get highlighted since they can't be unhighlighted by selecting them...
-        if sync_receipt.was_updated(module):
-            self.mark_as_unseen(module_widget)
+        module_widget.setIcon(0, icons.tree_items.module)
 
         return module_widget
 
     def _create_page_widget(
-        self, page: db.ModulePage, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
-        page_widget = MemoryTreeWidgetItem(id=page.id, data=page, strings=[page.name])
+        self, page: db.Page, sync_receipt: SyncReceipt
+    ) -> TreeWidgetDataItem:
+        page_widget = TreeWidgetDataItem(id=page.id, data=page, strings=[page.name])
         page_widget.setFlags(Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable)
+        page_widget.setIcon(0, icons.tree_items.page)
 
         if sync_receipt.was_updated(page):
             self.mark_as_unseen(page_widget)

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -1,42 +1,24 @@
+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.net.resources.scanning.resource_scanner import ResourceScanner
-from qtpy.QtCore import QUrl, Slot
-from qtpy.QtGui import QDesktopServices
-from qtpy.QtWidgets import QTextBrowser
-
-from qcanvas import icons
+
 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 _DarkListener(QObject):
-#     theme_changed = Signal(str)
-#
-#     def __init__(self):
-#         super().__init__()
-#
-#         self._thread = threading.Thread(target=darkdetect.listener, args=(self._emit,))
-#         self._thread.daemon = True
-#         self._thread.start()
-#
-#     def _emit(self, theme: str) -> None:
-#         self.theme_changed.emit(theme)
-#
-# _dark_listener = _DarkListener()
-
-
 class ResourceRichBrowser(QTextBrowser):
-    def __init__(self, downloader: ResourceManager):
+    def __init__(self, downloader: FrontendResourceManager):
         super().__init__()
         self._downloader = downloader
         self._content: Optional[db.CourseContentItem] = None
@@ -46,15 +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)
-
-        # _dark_listener.theme_changed.connect(self._theme_changed)
-
-    # @Slot()
-    # def _theme_changed(self, theme: str) -> None:
-    #     print(theme)
+        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:
@@ -65,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
         }
@@ -91,8 +66,7 @@ class ResourceRichBrowser(QTextBrowser):
                 extractor = self._extractors.extractor_for_tag(resource_link)
                 resource_id = extractor.resource_id_from_tag(resource_link)
 
-                # FIXME private method
-                if ResourceScanner._is_link_invisible(resource_link):
+                if is_link_invisible(resource_link):
                     _logger.debug("Found dead link for %s, removing", resource_id)
                     resource_link.decompose()
                     continue
@@ -102,50 +76,49 @@ class ResourceRichBrowser(QTextBrowser):
                     )
                     continue
 
-                file_link_tag = self._create_resource_link_tag(doc, resource_id)
+                file_link_tag = self._create_resource_link_tag(
+                    resource_id, resource_link.name == "img"
+                )
                 resource_link.replace_with(file_link_tag)
             except NoExtractorError:
                 pass
 
         return str(doc)
 
-    def _create_resource_link_tag(self, doc: BeautifulSoup, resource_id: str) -> Tag:
+    def _create_resource_link_tag(self, resource_id: str, is_image: bool) -> Tag:
         resource = self._current_content_resources[resource_id]
 
-        file_link_tag = doc.new_tag(
-            "a",
-            attrs={
-                "href": f"data:{resource_id}",
-            },
-        )
-
-        file_link_tag.append(self._file_icon_tag(doc, resource.download_state))
-        file_link_tag.append("\N{NO-BREAK SPACE}" + resource.file_name)
-
-        _logger.debug(str(file_link_tag))
-
-        return file_link_tag
-
-    def _file_icon_tag(
-        self, document: BeautifulSoup, download_state: db.ResourceDownloadState
-    ) -> Tag:
-        return document.new_tag(
-            "img",
-            attrs={
-                "src": self._download_state_icon(download_state),
-                "style": "vertical-align:middle",
-                "width": 18,
-            },
-        )
+        # todo not sure if this is a good idea or not
+        # if is_image and resource.download_state == db.ResourceDownloadState.DOWNLOADED:
+        #     location = self._downloader.resource_download_location(resource)
+        #
+        #     file_link_tag = doc.new_tag(
+        #         "img",
+        #         attrs={
+        #             "source": location.absolute(),
+        #         },
+        #     )
+        # else:
+
+        return BeautifulSoup(
+            markup=f"""
+            <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",
+        ).a
 
     def _download_state_icon(self, download_state: db.ResourceDownloadState) -> str:
+        icon_path = ":icons/universal/downloads"
         match download_state:
             case db.ResourceDownloadState.DOWNLOADED:
-                return icons.file_downloaded
+                return f"{icon_path}/downloaded.svg"
             case db.ResourceDownloadState.NOT_DOWNLOADED:
-                return icons.file_not_downloaded
+                return f"{icon_path}/not_downloaded.svg"
             case db.ResourceDownloadState.FAILED:
-                return icons.file_download_failed
+                return f"{icon_path}/download_failed.svg"
             case _:
                 raise ValueError()
 
@@ -161,17 +134,31 @@ 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:
+            # BANDAID FIX: In the following situation:
+            # - Download is started
+            # - Synchronisation is started
+            # - Download finishes AFTER the sync
+            # --> `resource` is NOT `self._current_content_resources[resource.id]`, because the sync will reload the
+            # resource from the DB, but the downloader will still only know about the old resource object.
+            # This causes resources not update their download state in the viewer. This line "fixes" that, but does NOT
+            # address the root cause. I think reloading the resource from the DB somewhere is the only true fix for this
+
+            if self._current_content_resources[resource.id] is not resource:
+                _logger.warning(
+                    "Resource has diverged from current loaded data, applying bandaid fix"
+                )
+                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

@@ -0,0 +1,22 @@
+from typing import List, Optional
+
+from PySide6.QtWidgets import QTreeWidgetItem
+
+from qcanvas.ui.memory_tree import MemoryTreeWidgetItem
+
+
+class TreeWidgetDataItem(QTreeWidgetItem):
+    def __init__(
+        self, id: str, data: Optional[object], strings: Optional[List[str]] = None
+    ):
+        super().__init__(strings)
+        # Still needs ID because it is used to reselect the item
+        self._id = id
+        self.extra_data = data
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+
+AnyTreeDataItem = TreeWidgetDataItem | MemoryTreeWidgetItem