qcanvas 1.2.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

qcanvas/ui/course_viewer/tabs/content_tab.py

@@ -1,31 +1,33 @@
 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 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
+from PySide6.QtCore import Slot
+from PySide6.QtWidgets import (
+    QGridLayout,
+    QLabel,
+    QWidget,
+    QLayout,
+)
 
 from qcanvas.ui.course_viewer.content_tree import ContentTree
 from qcanvas.ui.course_viewer.tabs.resource_rich_browser import ResourceRichBrowser
-from qcanvas.util.basic_fonts import bold_font
-from qcanvas.util.ui_tools import make_truncatable
 
-_logger = logging.getLogger(__name__)
+import qcanvas.util.ui_tools as ui
 
-T = TypeVar("T", bound=Type["ContentTab"])
+_logger = logging.getLogger(__name__)
 
 
 class ContentTab(QWidget):
     @classmethod
-    def create_from_receipt(
+    def create_from_receipt[T: ContentTab](
         cls: T,
         *,
         course: db.Course,
         sync_receipt: SyncReceipt,
         downloader: ResourceManager,
-    ) -> Type[T]:
+    ) -> type[T]:
         return cls(course=course, sync_receipt=sync_receipt, downloader=downloader)
 
     def __init__(
@@ -36,49 +38,41 @@ class ContentTab(QWidget):
         downloader: ResourceManager,
     ):
         super().__init__()
-        self._content_vbox = QVBoxLayout()
+        self.content_grid = QGridLayout()
         self._placeholder_text = title_placeholder_text
         self._title_label = self._create_title_label()
-        self._info_grid: Optional[QWidget] = None
+        self._use_info_grid = False
+        self._info_grid = QWidget()
+        self._info_grid.hide()
         self._viewer = ResourceRichBrowser(downloader=downloader)
         self._explorer = explorer
 
+        self.setLayout(self.content_grid)
         self._setup_layout()
         self._explorer.item_selected.connect(self._item_selected)
 
     def enable_info_grid(self) -> None:
-        # Info grid needs to be a widget, so it can be hidden/shown
-        grid_layout = self.setup_info_grid()
-
-        grid_widget = QWidget()
-        grid_widget.setLayout(grid_layout)
-        grid_widget.hide()
-
-        self._info_grid = grid_widget
-        self._content_vbox.insertWidget(1, grid_widget)
+        self._info_grid.setLayout(self.setup_info_grid())
+        self._use_info_grid = True
 
     def _create_title_label(self) -> QLabel:
-        title_label = QLabel(self._placeholder_text)
-        title_label.setFont(bold_font)
-        make_truncatable(title_label)
-        return title_label
+        return ui.label(
+            self._placeholder_text,
+            font=ui.font(point_size=12, bold=True),
+            allow_truncation=True,
+        )
 
-    def setup_info_grid(self) -> QGridLayout:
+    def setup_info_grid(self) -> QLayout:
         """
         Override this if you need an info grid
         """
         raise NotImplementedError()
 
     def _setup_layout(self) -> None:
-        parent_layout = QHBoxLayout()
-        parent_layout.addWidget(self._explorer)
-
-        self._content_vbox.addWidget(self._title_label)
-        self._content_vbox.addWidget(self._viewer)
-
-        parent_layout.addLayout(self._content_vbox)
-
-        self.setLayout(parent_layout)
+        self.content_grid.addWidget(self._explorer, 0, 0, 4, 1)
+        self.content_grid.addWidget(self._title_label, 0, 1)
+        self.content_grid.addWidget(self._info_grid, 1, 1)
+        self.content_grid.addWidget(self._viewer, 2, 1)
 
     def reload(self, course: db.Course, *, sync_receipt: SyncReceipt) -> None:
         self._explorer.reload(course, sync_receipt=sync_receipt)
@@ -95,7 +89,7 @@ class ContentTab(QWidget):
         self._title_label.setText(item.name)
         self._viewer.show_content(item)
 
-        if self._info_grid is not None:
+        if self._use_info_grid:
             self._info_grid.show()
             self.update_info_grid(item)
 
@@ -106,5 +100,5 @@ class ContentTab(QWidget):
         self._title_label.setText(self._placeholder_text)
         self._viewer.show_blank(completely_blank=True)
 
-        if self._info_grid is not None:
+        if self._use_info_grid:
             self._info_grid.hide()

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

@@ -1,9 +1,9 @@
 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 libqcanvas import db
+from libqcanvas.net.resources.download.resource_manager import ResourceManager
+from libqcanvas.net.sync.sync_receipt import SyncReceipt
+from PySide6.QtWidgets import QHBoxLayout, QWidget
 
 from qcanvas.ui.course_viewer.tabs.file_tab.pages_file_tree import PagesFileTree
 from qcanvas.util.layouts import layout

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

@@ -1,11 +1,11 @@
 import logging
-from typing import *
+from abc import ABC
 
-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 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 (
@@ -19,10 +19,7 @@ from qcanvas.util.ui_tools import create_qaction
 _logger = logging.getLogger(__name__)
 
 
-T = TypeVar("T")
-
-
-class FileTree(ContentTree[db.Course]):
+class FileTree(ContentTree[db.Course], ABC):
     @classmethod
     def create_from_receipt(
         cls,

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

@@ -1,9 +1,9 @@
 import logging
-from typing import *
+from typing import 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
+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
@@ -12,7 +12,6 @@ _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
@@ -24,14 +23,14 @@ class PagesFileTree(FileTree):
         widgets = []
 
         for group in data.modules:  # type: db.Module
-            if len(group.content_items) == 0:
+            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.content_items:
+            for item in group.pages:
                 resource_widgets = []
 
                 for resource in item.resources:  # type: db.Resource

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,9 +1,9 @@
 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
@@ -13,11 +13,10 @@ _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(
@@ -37,7 +36,7 @@ class MailTree(ContentTree[db.Course]):
     ) -> 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)
@@ -45,7 +44,7 @@ class MailTree(ContentTree[db.Course]):
         return widgets
 
     def _create_mail_widget(
-        self, message: db.CourseMessage, sync_receipt: SyncReceipt
+        self, message: db.Message, sync_receipt: SyncReceipt
     ) -> TreeWidgetDataItem:
         message_widget = TreeWidgetDataItem(
             id=message.id,

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,9 +1,9 @@
 import logging
 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
@@ -17,7 +17,7 @@ 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(
@@ -52,7 +52,7 @@ class PageTree(ContentTree[db.Course]):
         return module_widget
 
     def _create_page_widget(
-        self, page: db.ModulePage, sync_receipt: SyncReceipt
+        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)

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
         }
@@ -137,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:
@@ -163,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