qcanvas 0.0.5.6a0__py3-none-any.whl → 1.0.3.post0__py3-none-any.whl

qcanvas/ui/status_bar_reporter.py

@@ -1,40 +0,0 @@
-from typing import Any
-
-from PySide6.QtWidgets import QStatusBar, QProgressBar
-
-from qcanvas.util.progress_reporter import ProgressReporter
-
-
-class StatusBarReporter(ProgressReporter):
-    def __init__(self, status_bar: QStatusBar):
-        self.status_bar = status_bar
-        self.section_name: None | str = None
-        self.progress_bar: QProgressBar | None = None
-
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        self.section_name = section_name
-        self.status_bar.showMessage(section_name)
-
-        if self.progress_bar is None:
-            self.progress_bar = QProgressBar(self.status_bar)
-            self.progress_bar.setMaximumHeight(self.status_bar.height())
-            self.progress_bar.setMinimum(0)
-            self.status_bar.addPermanentWidget(self.progress_bar)
-
-        self.progress_bar.setValue(0)
-        self.progress_bar.setMaximum(total_progress)
-
-    def progress(self, current_progress: int, total: int) -> None:
-        if self.progress_bar is not None:
-            self.progress_bar.setValue(current_progress)
-
-    def finished(self) -> None:
-        self.status_bar.removeWidget(self.progress_bar)
-        self.progress_bar = None
-        self.status_bar.showMessage("Finished", 5000)
-
-    def errored(self, context: Any) -> None:
-        if self.status_bar.parent() is not None:
-            self.status_bar.removeWidget(self.progress_bar)
-            self.progress_bar = None
-            self.status_bar.showMessage("Synchronisation error!!", 5000)

qcanvas/ui/viewer/course_list.py

@@ -1,96 +0,0 @@
-from datetime import datetime
-from typing import Sequence
-
-from PySide6.QtCore import QItemSelection, Slot, Signal, QObject
-from PySide6.QtGui import QStandardItemModel, QStandardItem
-from PySide6.QtWidgets import QTreeView
-from qasync import asyncSlot
-
-import qcanvas.db as db
-from qcanvas.util.course_indexer import DataManager
-
-
-class CourseNode(QStandardItem, QObject):
-    name_changed = Signal(db.Course, str)
-
-    def __init__(self, course: db.Course):
-        QObject.__init__(self)
-        QStandardItem.__init__(self, course.preferences.local_name or course.name)
-        self.course = course
-
-    def setData(self, value, role=...):
-        if isinstance(value, str):
-            value = value.strip()
-
-            if len(value) == 0:
-                super().setData(self.course.name, role)
-                self.name_changed.emit(self.course, None)
-            else:
-                super().setData(value, role)
-                self.name_changed.emit(self.course, value)
-        else:
-            super().setData(value, role)
-
-
-class CourseList(QTreeView):
-    course_selected = Signal(db.Course)
-
-    def __init__(self, data_manager: DataManager):
-        super().__init__()
-        self.data_manager = data_manager
-        self.model = QStandardItemModel()
-        self.setModel(self.model)
-        self.selectionModel().selectionChanged.connect(self._on_selection_changed)
-
-    @asyncSlot(db.Course, str)
-    async def course_name_changed(self, course: db.Course, name: str):
-        course.preferences.local_name = name
-        await self.data_manager.update_item(course.preferences)
-
-    def load_course_list(self, courses: Sequence[db.Course]):
-        self.model.clear()
-        self.model.setHorizontalHeaderLabels(["Course"])
-
-        courses_root = self.model.invisibleRootItem()
-
-        for term, courses in self.group_courses_by_term(courses):
-            term_node = QStandardItem(term.name)
-            term_node.setEditable(False)
-            term_node.setSelectable(False)
-
-            for course in courses:
-                course_node = CourseNode(course)
-                course_node.name_changed.connect(self.course_name_changed)
-                term_node.appendRow(course_node)
-
-            courses_root.appendRow(term_node)
-
-        self.expandAll()
-
-    @staticmethod
-    def group_courses_by_term(courses: Sequence[db.Course]):
-        courses_grouped_by_term: dict[db.Term, list[db.Course]] = {}
-
-        # Put courses into groups in the above dict
-        for course in courses:
-            if course.term in courses_grouped_by_term:
-                courses_grouped_by_term[course.term].append(course)
-            else:
-                courses_grouped_by_term[course.term] = [course]
-
-        # Convert the dict item list into a mutable list
-        pairs = list(courses_grouped_by_term.items())
-        # Sort them by start date, with most recent terms at the start
-        pairs.sort(key=lambda x: x[0].start_at or datetime.min, reverse=True)
-
-        return pairs
-
-    @Slot(QItemSelection, QItemSelection)
-    def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection):
-        if len(self.selectedIndexes()) == 0:
-            self.course_selected.emit(None)
-        else:
-            item = self.model.itemFromIndex(self.selectedIndexes()[0])
-
-            if isinstance(item, CourseNode):
-                self.course_selected.emit(item.course)

qcanvas/ui/viewer/file_list.py

@@ -1,195 +0,0 @@
-from typing import Sequence
-
-from PySide6.QtCore import QObject, Slot, Qt
-from PySide6.QtWidgets import QStyledItemDelegate, QStyleOptionProgressBar, QApplication, QStyle, \
-    QHeaderView, QStyleOptionViewItem, QTreeWidget, QTreeWidgetItem
-
-import qcanvas.db.database as db
-from qcanvas.util.download_pool import DownloadPool
-from qcanvas.util.helpers import file_icon_helper
-
-
-# https://code.whatever.social/questions/1094841/get-human-readable-version-of-file-size#1094933
-def sizeof_fmt(num, suffix="B"):
-    for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
-        if abs(num) < 1024.0:
-            return f"{num:3.1f}{unit}{suffix}"
-        num /= 1024.0
-    return f"{num:.1f}Yi{suffix}"
-
-
-class FileColumnDelegate(QStyledItemDelegate):
-    def __init__(self, tree: QTreeWidget, download_pool: DownloadPool, parent, *args, **kwargs):
-        super().__init__(parent, *args, **kwargs)
-        self.download_pool = download_pool
-        self.tree = tree
-
-    def paint(self, painter, option, index) -> None:
-        item = self.tree.itemFromIndex(index)
-
-        # Check that the item is actually a file row and not already downloaded
-        if not isinstance(item, FileRow) or item.resource.state == db.ResourceState.DOWNLOADED:
-            return super().paint(painter, option, index)
-
-        resource = item.resource
-        progress = item.download_progres
-
-        if progress == resource.file_size:
-            return super().paint(painter, option, index)
-
-        # Check that the file is not currently downloading (signaled by progress = -1)
-        if progress < 0:
-            # Show the state of the file instead (downloaded, failed, not downloaded)
-            view_item = QStyleOptionViewItem(option)
-            self.initStyleOption(view_item, index)
-            view_item.text = db.ResourceState.human_readable(resource.state)
-
-            return QApplication.style().drawControl(QStyle.CE_ItemViewItem, view_item, painter, view_item.widget)
-        else:
-            # otherwise show progress bar
-            progress_bar = QStyleOptionProgressBar()
-            progress_bar.rect = option.rect
-            progress_bar.minimum = 0
-            progress_bar.maximum = resource.file_size
-            progress_bar.progress = progress
-            # Display download progress as a percentage
-            progress_bar.text = "{0:.0f}%".format((progress / resource.file_size) * 100)
-            progress_bar.textVisible = True
-
-            QApplication.style().drawControl(QStyle.CE_ProgressBar, progress_bar, painter)
-
-
-class FileRow(QTreeWidgetItem):
-    def __init__(self, resource: db.Resource):
-        # Set column names
-        super().__init__(
-            [
-                resource.file_name,
-                resource.date_discovered.strftime("%Y-%m-%d"),
-                sizeof_fmt(resource.file_size),
-            ]
-        )
-
-        # Set the icon for this file, displayed in the name column
-        self.setIcon(0, file_icon_helper.icon_for_filename(resource.file_name))
-
-        self.resource = resource
-        # This is used to pass the download progress value from download_progress_updated to FileColumnDelegate. This way
-        # it means we don't have to get the download progress from the DownloadPool a second time with an async function
-        # (which is undesirable from an item delegate...). Use -1 to show that the file is not currently downloading.
-        self.download_progres = -1
-
-
-class FileList(QTreeWidget):
-    def __init__(self, download_pool: DownloadPool, parent: QObject | None = None):
-        super().__init__(parent)
-        self._setup_header()
-
-        # Keep a map of file ids to rows, so we can actually update the download column using a file id.
-        # This has to be a list or else files that are in multiple modules/pages will not be updated properly on the tree
-        self.row_id_map: dict[str, list[FileRow]] = {}
-        self.download_pool = download_pool
-        self.setAlternatingRowColors(True)
-        # Add the download column renderer
-        self.setItemDelegateForColumn(3, FileColumnDelegate(tree=self, download_pool=download_pool, parent=None))
-
-        # Connect download update events
-        self.download_pool.download_progress_updated.connect(self._file_download_progress_update)
-        self.download_pool.download_failed.connect(self._file_download_failed_update)
-
-    @Slot(str, int)
-    def _file_download_progress_update(self, resource_id: str, progress: int):
-        # Ignore files that aren't in this tree
-        if resource_id not in self.row_id_map:
-            return
-
-        rows = self.row_id_map[resource_id]
-
-        # Update each row that maps to this file.
-        # Note that a file may belong to multiple modules or pages
-        for row in rows:
-            # Update the progress
-            row.download_progres = progress
-
-            # Get the download column for the relevant item
-            index = self.indexFromItem(row, 3)
-
-            # Update the download column
-            self.model().dataChanged.emit(index, index, Qt.ItemDataRole.DisplayRole)
-
-    @Slot(str)
-    def _file_download_failed_update(self, resource_id: str):
-        if resource_id not in self.row_id_map:
-            return
-
-        rows = self.row_id_map[resource_id]
-
-        for row in rows:
-            # Get the download column for the relevant item
-            index = self.indexFromItem(row, 3)
-
-            # Update the download column
-            self.model().dataChanged.emit(index, index, Qt.ItemDataRole.DisplayRole)
-
-    def _setup_header(self):
-        self.setColumnCount(4)
-        self.setHeaderLabels(["Name", "Date Found", "Size", "Download"])
-
-        header = self.header()
-        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
-        header.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
-        header.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
-        # Make the download progress column not try to take up all remaining space in the tree, as it just looks weird
-        # and decreases room for more important data
-        header.setStretchLastSection(0)
-
-    def load_items(self, items: Sequence[db.ModuleItem | db.Module]):
-        self.clear()
-
-        groups = []
-
-        for item in items:
-            # Get the resources depending on the type of the item
-            if isinstance(item, (db.PageLike, db.ModuleItem)):
-                resources = item.resources
-            elif isinstance(item, db.Module):
-                resources = []
-
-                for module_item in item.items:
-                    resources.extend(module_item.resources)
-            else:
-                continue
-
-            # Avoid adding groups with no files in them, it just adds clutter
-            if len(resources) == 0:
-                continue
-
-            # Create the group node for this item
-            group_node = QTreeWidgetItem([item.name])
-
-            # fixme this does not remove duplicate files e.g. when on module groups
-
-            for resource in resources:
-                row = FileRow(resource)
-
-                # Put the file into the row id map so we can use the file id provided by download_progress_updated
-                # and such to update the download progress in the tree
-                if resource.id not in self.row_id_map:
-                    self.row_id_map[resource.id] = [row]
-                else:
-                    self.row_id_map[resource.id].append(row)
-
-                # Add the row to the group
-                group_node.addChild(row)
-
-            # Add the module/page to the list
-            groups.append(group_node)
-
-        # Add all the items and expand them
-        self.insertTopLevelItems(0, groups)
-        self.expandAll()
-
-    def clear(self):
-        super().clear()
-        self._setup_header()
-        self.row_id_map.clear()

qcanvas/ui/viewer/file_view_tab.py

@@ -1,62 +0,0 @@
-from typing import Sequence
-
-from PySide6.QtWidgets import *  # QWidget, QTreeView, QGroupBox, QBoxLayout, QHeaderView, QHBoxLayout, QComboBox, QLabel
-
-import qcanvas.db as db
-from qcanvas.ui.viewer.file_list import FileList
-from qcanvas.util.constants import default_assignments_module_names
-from qcanvas.util.download_pool import DownloadPool
-
-
-class FileColumn(QGroupBox):
-    def __init__(self, column_name, download_pool: DownloadPool):
-        super().__init__(title=column_name)
-
-        self.tree = FileList(download_pool)
-        self.setLayout(QBoxLayout(QBoxLayout.Direction.TopToBottom))
-        self.layout().addWidget(self.tree)
-
-    def load_items(self, items: Sequence[db.ModuleItem | db.Module]):
-        self.tree.load_items(items)
-
-    def clear(self):
-        self.tree.clear()
-
-
-class FileViewTab(QWidget):
-
-    def __init__(self, download_pool: DownloadPool):
-        super().__init__()
-
-        self.files_column = FileColumn("Files", download_pool)
-        self.assignment_files_column = FileColumn("Assignment files", download_pool)
-
-        layout = QHBoxLayout()
-        layout.addWidget(self.files_column)
-        layout.addWidget(self.assignment_files_column)
-
-        self.setLayout(layout)
-
-    def load_course_files(self, course: db.Course):
-        module_items: list[db.ModuleItem] = []
-        assignment_items: list[db.ModuleItem] = []
-
-        for module_item in course.module_items:
-            if module_item.module.name.lower() in default_assignments_module_names:
-                assignment_items.append(module_item)
-            else:
-                module_items.append(module_item)
-
-        if course.preferences.files_group_by_preference == db.GroupByPreference.GROUP_BY_MODULES:
-            exclude_assignments_module = list(
-                filter(lambda x: x.name.lower() not in default_assignments_module_names, course.modules))
-
-            self.files_column.load_items(exclude_assignments_module)
-        else:
-            self.files_column.load_items(module_items)
-
-        self.assignment_files_column.load_items(assignment_items + course.assignments)
-
-    def clear(self):
-        self.files_column.clear()
-        self.assignment_files_column.clear()

qcanvas/ui/viewer/page_list_viewer.py

@@ -1,150 +0,0 @@
-from abc import abstractmethod
-from typing import Sequence
-
-from PySide6.QtCore import QItemSelection, Slot
-from PySide6.QtGui import QStandardItemModel
-from PySide6.QtWidgets import QWidget, QTextBrowser, QTreeView, QHBoxLayout
-from bs4 import BeautifulSoup
-
-import qcanvas.db as db
-from qcanvas.ui.container_item import ContainerItem
-from qcanvas.util.constants import default_assignments_module_names
-from qcanvas.util.course_indexer import resource_helpers
-from qcanvas.util.helpers import canvas_sanitiser
-from qcanvas.util.link_scanner import ResourceScanner
-
-
-class LinkTransformer:
-    # This is used to indicate that a "link" is actually a resource. The resource id is concatenated to this string.
-    # It just has to be a valid url or qt does not send it to anchorClicked properly
-    transformed_url_prefix = "data:,"
-
-    def __init__(self, link_scanners: Sequence[ResourceScanner], files: dict[str, db.Resource]):
-        self.link_scanners = link_scanners
-        self.files = files
-
-    def transform_links(self, html: str):
-        doc = BeautifulSoup(html, 'html.parser')
-
-        for element in doc.find_all(resource_helpers.resource_elements):
-            for scanner in self.link_scanners:
-                if scanner.accepts_link(element):
-                    resource_id = f"{scanner.name}:{scanner.extract_id(element)}"
-                    # todo make images actually show on the viewer page if they're downloaded
-                    if resource_id in self.files:
-                        file = self.files[resource_id]
-
-                        substitute = doc.new_tag(name="a")
-                        # Put the file id on the end of the url so we don't have to use the scanners to extract an id again..
-                        # The actual url doesn't matter
-                        substitute.attrs["href"] = f"{self.transformed_url_prefix}{file.id}"
-                        substitute.string = f"{file.file_name} ({db.ResourceState.human_readable(file.state)})"
-
-                        element.replace_with(substitute)
-                    else:
-                        if element.string is not None:
-                            element.string += " (Failed to index)"
-
-                    break
-
-        return str(doc)
-
-
-class PageLikeViewer(QWidget):
-    def __init__(self, header_name: str, link_transformer: LinkTransformer):
-        super().__init__()
-        self.viewer = QTextBrowser()
-        self.viewer.setOpenLinks(False)
-
-        # todo just use QTreeWidget instead
-        self.tree = QTreeView()
-        self.model = QStandardItemModel()
-        self.header_name = header_name
-        self.link_transformer = link_transformer
-
-        self.tree.setModel(self.model)
-        self.tree.selectionModel().selectionChanged.connect(self.on_item_clicked)
-        self.model.setHorizontalHeaderLabels([self.header_name])
-
-        layout = QHBoxLayout()
-        layout.addWidget(self.tree)
-        layout.addWidget(self.viewer)
-        layout.setStretch(1, 1)
-        self.setLayout(layout)
-
-    def fill_tree(self, data: db.Course):
-        self.model.clear()
-        self.viewer.clear()
-        self._internal_fill_tree(data)
-        self.model.setHorizontalHeaderLabels([self.header_name])
-        self.tree.expandAll()
-
-    def clear(self):
-        self.model.clear()
-        self.viewer.clear()
-        self.model.setHorizontalHeaderLabels([self.header_name])
-
-    @abstractmethod
-    def _internal_fill_tree(self, data: db.Course):
-        ...
-
-    @Slot(QItemSelection, QItemSelection)
-    def on_item_clicked(self, selected: QItemSelection, deselected: QItemSelection):
-        if len(self.tree.selectedIndexes()) == 0:
-            return
-
-        node = self.model.itemFromIndex(self.tree.selectedIndexes()[0])
-
-        if isinstance(node, ContainerItem):
-            item = node.content
-
-            if isinstance(item, db.PageLike):
-                if item.content is None:
-                    return
-
-                # todo when a file is finished downloading it would be nice if the page was refreshed to show the state properly
-                html = canvas_sanitiser.remove_stylesheets_from_html(item.content)
-                self.viewer.setHtml(self.link_transformer.transform_links(html))
-
-
-class PagesViewer(PageLikeViewer):
-    def __init__(self, link_transformer: LinkTransformer):
-        super().__init__("Pages", link_transformer)
-
-    def _internal_fill_tree(self, course: db.Course):
-        root = self.model.invisibleRootItem()
-
-        for module in course.modules:
-            if module.name.lower() in default_assignments_module_names:
-                continue
-
-            module_node = ContainerItem(module)
-            module_node.setSelectable(False)
-
-            for module_item in list[db.ModuleItem](module.items):
-                module_node.appendRow(ContainerItem(module_item))
-
-            root.appendRow(module_node)
-
-
-class AssignmentsViewer(PageLikeViewer):
-
-    def __init__(self, link_transformer: LinkTransformer):
-        super().__init__("Putting the ASS in assignments", link_transformer)
-
-    def _internal_fill_tree(self, course: db.Course):
-        root = self.model.invisibleRootItem()
-
-        default_assessments_module = None
-
-        for module in course.modules:
-            if module.name.lower() in default_assignments_module_names:
-                default_assessments_module = module
-                break
-
-        if default_assessments_module is not None:
-            for module_item in default_assessments_module.items:
-                root.appendRow(ContainerItem(module_item))
-
-        for assignment in course.assignments:
-            root.appendRow(ContainerItem(assignment))

qcanvas/util/app_settings.py

@@ -1,98 +0,0 @@
-from typing import TypeVar, Generic
-
-from PySide6.QtCore import QSettings
-from packaging.version import Version
-
-default_theme = "light"
-
-
-def ensure_theme_is_valid(theme: str) -> str:
-    """
-    Ensures that a theme name is valid.
-    If it is invalid, the default theme ("light") is returned
-    Parameters
-    ----------
-    theme
-        The theme name
-    Returns
-    -------
-    str
-        A valid theme name
-    """
-    if theme not in ["auto", "light", "dark", "native"]:
-        return default_theme
-    else:
-        return theme
-
-
-T = TypeVar("T")
-
-
-class MappedSetting(Generic[T]):
-    """
-    Acts as a proxy for a named value in a QSettings object.
-    Stores the value in memory when initialised and updates it accordingly, to protect it from changes on disk.
-    """
-
-    def __init__(self, settings_object: QSettings, setting_name: str, default: T | None = None):
-        self.settings_object = settings_object
-        self.setting_name = setting_name
-        self.value = self.settings_object.value(self.setting_name, default)
-
-    def __get__(self, instance, owner):
-        return self.value
-
-    def __set__(self, instance, value) -> None:
-        self.value = value
-        self.settings_object.setValue(self.setting_name, value)
-
-
-class ThemeSetting(MappedSetting):
-    def __init__(self, settings_object: QSettings):
-        super().__init__(settings_object, "theme", default_theme)
-
-    def __get__(self, instance, owner):
-        return ensure_theme_is_valid(super().__get__(instance, owner))
-
-    def __set__(self, instance, value):
-        super().__set__(instance, ensure_theme_is_valid(value))
-
-
-class _AppSettings:
-    """
-    Attributes
-    ----------
-    settings : QSettings
-        Primary settings map for client settings
-    auxiliary : QSettings
-        Secondary settings map for settings which aren't related to canvas/panopto client functionality
-    ignored_update
-        If there is an update available and the user chooses not to update, then that version will be stored in here and
-        the user will not be asked to update to that version again
-    geometry
-        Used to restore the main window position when it is re-opened
-    window_state
-        Used to restore the main window position when it is re-opened
-    theme
-        The theme of the app
-    canvas_url
-        The canvas url
-    api_key
-        The api key for canvas
-    """
-
-    settings = QSettings("QCanvas", "client")
-    auxiliary = QSettings("QCanvas", "ui")
-
-    canvas_url: MappedSetting[str] = MappedSetting(settings, "canvas_url")
-    panopto_url: MappedSetting[str] = MappedSetting(settings, "panopto_url")
-    api_key: MappedSetting[str] = MappedSetting(settings, "api_key")
-
-    ignored_update: MappedSetting[Version] = MappedSetting(auxiliary, "ignored_update")
-    theme: ThemeSetting = ThemeSetting(auxiliary)
-    geometry = MappedSetting(auxiliary, "geometry")
-    window_state = MappedSetting(auxiliary, "window_state")
-
-
-# Global _AppSettings instance
-settings = _AppSettings()

qcanvas/util/constants.py

@@ -1,5 +0,0 @@
-default_assignments_module_names = ["assessments", "assessment"]
-app_name = "QCanvas"
-package_name = "qcanvas"
-# Passed back to the launcher script to indicate that the program should be restarted (after an update)
-updated_and_needs_restart_return_code = 144

qcanvas/util/course_indexer/__init__.py

@@ -1 +0,0 @@
-from .data_manager import DataManager