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

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

qcanvas/util/course_indexer/conversion_helpers.py

@@ -1,78 +0,0 @@
-from typing import Sequence
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-import qcanvas.db as db
-import qcanvas.queries as queries
-from qcanvas.util.helpers import canvas_sanitiser
-
-
-async def create_assignments(g_course: queries.Course, session: AsyncSession) -> Sequence[db.Assignment]:
-    """
-    Puts assignments for a course into the database
-    """
-    assignments = []
-
-    for g_assignment in g_course.assignments_connection.nodes:
-        assignment = await session.get(db.Assignment, g_assignment.q_id)
-
-        if assignment is None:
-            assignment = db.Assignment()
-            assignment.id = g_assignment.q_id
-            assignment.course_id = g_course.m_id
-            session.add(assignment)
-        # todo related to scanning old modulepages, but assignment content is already present in the query result so no more requests need to be made
-        elif g_assignment.updated_at.replace(tzinfo=None) <= assignment.updated_at:
-            continue
-
-        assignment.name = canvas_sanitiser.remove_garbage_from_title(g_assignment.name)
-        assignment.description = g_assignment.description
-        assignment.created_at = g_assignment.created_at
-        assignment.updated_at = g_assignment.updated_at
-        assignment.due_at = g_assignment.due_at
-        assignment.position = g_assignment.position
-
-        assignments.append(assignment)
-
-    return assignments
-
-
-async def create_modules(g_course: queries.Course, session: AsyncSession):
-    """
-    Creates modules for a course and puts them in the database
-    """
-    for g_module in g_course.modules_connection.nodes:
-        module = await session.get(db.Module, g_module.q_id)
-
-        if module is None:
-            module = db.Module()
-            module.id = g_module.q_id
-            module.course_id = g_course.m_id
-            session.add(module)
-
-        module.name = canvas_sanitiser.remove_garbage_from_title(g_module.name)
-
-
-async def create_course(g_course: queries.Course, session: AsyncSession, term: db.Term):
-    """
-    Creates course entries in the database
-    """
-    course = await session.get(db.Course, g_course.m_id)
-    if course is None:
-        course = db.Course()
-        course.id = g_course.m_id
-        course.preferences = db.CoursePreferences()
-        session.add(course)
-
-    course.name = canvas_sanitiser.remove_garbage_from_title(g_course.name)
-    course.term = term
-
-
-async def create_term(g_course: queries.Course, session) -> db.Term:
-    term = await session.get(db.Term, g_course.term.q_id)
-
-    if term is None:
-        term = db.convert_term(g_course.term)
-        session.add(term)
-
-    return term