qcanvas 1.0.12.dev3__py3-none-any.whl → 1.2.0__py3-none-any.whl

qcanvas/ui/course_viewer/tabs/assignment_tab/assignment_tree.py

@@ -6,7 +6,9 @@ from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QHeaderView
 
+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__)
@@ -18,6 +20,7 @@ class AssignmentTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.assignment_groups",
             emit_selection_signal_for_type=db.Assignment,
         )
+
         self.ui_setup(
             header_text=["Assignments", "Weight"],
             indentation=15,
@@ -25,13 +28,9 @@ class AssignmentTree(ContentTree[db.Course]):
             min_width=150,
         )
 
-        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
@@ -39,8 +38,11 @@ class AssignmentTree(ContentTree[db.Course]):
         widgets = []
 
         for assignment_group in course.assignment_groups:  # type: db.AssignmentGroup
+            if len(assignment_group.assignments) == 0:
+                continue
+
             assignment_group_widget = self._create_assignment_group_widget(
-                assignment_group, sync_receipt
+                assignment_group
             )
 
             widgets.append(assignment_group_widget)
@@ -54,7 +56,7 @@ class AssignmentTree(ContentTree[db.Course]):
         return widgets
 
     def _create_assignment_group_widget(
-        self, assignment_group: db.AssignmentGroup, sync_receipt: SyncReceipt
+        self, assignment_group: db.AssignmentGroup
     ) -> MemoryTreeWidgetItem:
         assignment_group_widget = MemoryTreeWidgetItem(
             id=assignment_group.id,
@@ -63,22 +65,21 @@ class AssignmentTree(ContentTree[db.Course]):
         )
 
         assignment_group_widget.setFlags(Qt.ItemFlag.ItemIsEnabled)
-
-        if sync_receipt.was_updated(assignment_group):
-            self.mark_as_unseen(assignment_group_widget)
+        assignment_group_widget.setIcon(0, icons.tree_items.module)
 
         return assignment_group_widget
 
     def _create_assignment_widget(
         self, assignment: db.Assignment, sync_receipt: SyncReceipt
-    ) -> MemoryTreeWidgetItem:
-        assignment_widget = MemoryTreeWidgetItem(
+    ) -> TreeWidgetDataItem:
+        assignment_widget = TreeWidgetDataItem(
             id=assignment.id, data=assignment, strings=[assignment.name]
         )
 
         assignment_widget.setFlags(
             Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable
         )
+        assignment_widget.setIcon(0, icons.tree_items.assignment)
 
         if sync_receipt.was_updated(assignment):
             self.mark_as_unseen(assignment_widget)

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

@@ -0,0 +1 @@
+from .file_tab import FileTab

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

@@ -0,0 +1,46 @@
+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 qtpy.QtWidgets import *
+
+from qcanvas.ui.course_viewer.tabs.file_tab.pages_file_tree import PagesFileTree
+from qcanvas.util.layouts import layout
+
+_logger = logging.getLogger(__name__)
+
+
+class FileTab(QWidget):
+    @staticmethod
+    def create_from_receipt(
+        *,
+        course: db.Course,
+        sync_receipt: SyncReceipt,
+        downloader: ResourceManager,
+    ) -> "FileTab":
+        return FileTab(course=course, sync_receipt=sync_receipt, downloader=downloader)
+
+    def __init__(
+        self,
+        course: db.Course,
+        downloader: ResourceManager,
+        *,
+        sync_receipt: SyncReceipt = None,
+    ):
+        super().__init__()
+
+        self._page_file_tree = PagesFileTree.create_from_receipt(
+            course, sync_receipt=sync_receipt, resource_manager=downloader
+        )
+        # self._assignment_file_tree = FileTree.create_from_receipt(
+        #     course,
+        #     sync_receipt=sync_receipt,
+        #     mode="assignments",
+        #     resource_manager=downloader,
+        # )
+
+        self.setLayout(layout(QHBoxLayout, self._page_file_tree))
+
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
+        pass

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

@@ -0,0 +1,99 @@
+import logging
+from typing import *
+
+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 QPoint, Qt, Slot
+from qtpy.QtWidgets import *
+
+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__)
+
+
+T = TypeVar("T")
+
+
+class FileTree(ContentTree[db.Course]):
+    @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,56 @@
+import logging
+from typing import *
+
+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 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 len(group.content_items) == 0:
+                continue
+
+            # Init group_widget lazily to prevent creating pointless tree widgets
+            group_widget: MemoryTreeWidgetItem | None = None
+            items_in_group = set()
+
+            for item in group.content_items:
+                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_tree.py

@@ -5,8 +5,9 @@ import qcanvas_backend.database.types as db
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
 from qtpy.QtWidgets import *
 
+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__)
 
@@ -18,36 +19,35 @@ class MailTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.mail",
             emit_selection_signal_for_type=db.CourseMessage,
         )
+
         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
             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(
+    ) -> TreeWidgetDataItem:
+        message_widget = TreeWidgetDataItem(
             id=message.id,
             data=message,
             strings=[message.name, message.sender_name],

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 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__)
@@ -17,6 +19,7 @@ class PageTree(ContentTree[db.Course]):
             tree_name=f"course.{course_id}.modules",
             emit_selection_signal_for_type=db.ModulePage,
         )
+
         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])
+    ) -> 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,3 +1,4 @@
+import html
 import logging
 from typing import Optional
 
@@ -6,12 +7,11 @@ from bs4 import BeautifulSoup, Tag
 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 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 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
@@ -19,22 +19,6 @@ 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):
         super().__init__()
@@ -50,12 +34,6 @@ class ResourceRichBrowser(QTextBrowser):
             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)
-
     def show_blank(self, completely_blank: bool = False) -> None:
         if completely_blank:
             self.clear()
@@ -91,8 +69,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 +79,57 @@ 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">
+                <!--<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>
+            """,
+            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()
 
@@ -174,4 +158,21 @@ class ResourceRichBrowser(QTextBrowser):
     @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/tabs/util.py

@@ -1 +1,11 @@
+from typing import Protocol
+
+import qcanvas_backend.database.types as db
+from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
+
 date_strftime_format = "%A, %Y-%m-%d, %H:%M:%S"
+
+
+# todo what the hell is the point of this?
+class SupportsReload(Protocol):
+    def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None: ...

qcanvas/ui/course_viewer/tree_widget_data_item.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+
+from qtpy.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