qcanvas 0.0.2a0__py3-none-any.whl → 0.0.3a0__py3-none-any.whl

qcanvas/__main__.py

@@ -4,12 +4,17 @@ import sys
 from datetime import datetime
 
 import httpx
+from PySide6.QtCore import Signal, Slot, QObject
+from PySide6.QtWidgets import QProgressDialog, QMessageBox, QWidget, QMainWindow
+
 from qcanvas.QtVersionHelper.QtWidgets import QApplication
 from httpx import URL
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy.ext.asyncio.session import async_sessionmaker as AsyncSessionMaker
 
 from qcanvas.ui.main_ui import AppMainWindow
+from qcanvas.ui.setup_dialog import SetupDialog
+from qcanvas.util.constants import app_name
 from qcanvas.util.linkscanner import CanvasFileScanner
 from qcanvas.util.course_indexer import DataManager
 from qcanvas.net.canvas.canvas_client import CanvasClient
@@ -18,34 +23,75 @@ from qcanvas.util import AppSettings
 from qcanvas.util.linkscanner.canvas_media_object_scanner import CanvasMediaObjectScanner
 from qcanvas.util.linkscanner.dropbox_scanner import DropboxScanner
 
-from qasync import QEventLoop
+from qasync import QEventLoop, asyncSlot
 import qcanvas.db as db
 import qdarktheme
 
-client = CanvasClient(canvas_url=URL(AppSettings.canvas_url), api_key=AppSettings.canvas_api_key)
-
 engine = create_async_engine("sqlite+aiosqlite:///meme", echo=False)
 
 logging.basicConfig()
 logging.getLogger("canvas_client").setLevel(logging.DEBUG)
-# logging.getLogger("aiosqlite").setLevel(logging.DEBUG)
-
-data_manager = DataManager(
-    client=client,
-    link_scanners=[CanvasFileScanner(client), DropboxScanner(httpx.AsyncClient()),
-                   CanvasMediaObjectScanner(client.client)],
-    sessionmaker=AsyncSessionMaker(engine, expire_on_commit=False),
-    last_update=datetime.min
-)
-
-data_manager.download_pool.download_progress_updated.connect(lambda x, y: print(f"Progress {x} {y}"))
 
 async def begin():
     # Create meta stuff
     async with engine.begin() as conn:
         await conn.run_sync(db.Base.metadata.create_all)
 
-    await data_manager.init()
+
+class LoaderWindow(QMainWindow):
+    init = Signal()
+    setup = Signal()
+    ready = Signal()
+
+    def __init__(self):
+        super().__init__()
+        self.init.connect(self.on_init)
+        self.setup.connect(self.on_setup)
+        self.ready.connect(self.on_ready)
+        self.setWindowTitle(app_name)
+        self.setCentralWidget(QProgressDialog("Verifying config", None, 0, 0))
+
+        self.init.emit()
+
+
+    @asyncSlot()
+    async def on_init(self):
+        try:
+            if not await CanvasClient.verify_config(AppSettings.canvas_url, AppSettings.canvas_api_key):
+                self.setup.emit()
+            else:
+                self.ready.emit()
+        except:
+            self.setup.emit()
+
+    @asyncSlot()
+    async def on_setup(self):
+        setup = SetupDialog(self)
+        setup.rejected.connect(lambda: sys.exit(0))
+        setup.accepted.connect(self.on_ready)
+        setup.show()
+
+    @asyncSlot()
+    async def on_ready(self):
+        client = CanvasClient(canvas_url=URL(AppSettings.canvas_url), api_key=AppSettings.canvas_api_key)
+        data_manager = DataManager(
+            client=client,
+            link_scanners=[CanvasFileScanner(client), DropboxScanner(httpx.AsyncClient()),
+                           CanvasMediaObjectScanner(client.client)],
+            sessionmaker=AsyncSessionMaker(engine, expire_on_commit=False),
+            last_update=datetime.min
+        )
+
+        await data_manager.init()
+        self.close()
+        self.open_main_app(data_manager)
+
+    def open_main_app(self, data_manager: DataManager):
+        self.main_window = AppMainWindow(data_manager)
+        self.main_window.setWindowTitle(app_name)
+        # self.main_window.resize(1200, 600)
+        self.main_window.show()
+        self.setParent(self.main_window)
 
 
 if __name__ == '__main__':
@@ -61,9 +107,8 @@ if __name__ == '__main__':
     app_close_event = asyncio.Event()
     app.aboutToQuit.connect(app_close_event.set)
 
-    main_window = AppMainWindow(data_manager)
-    main_window.resize(800, 600)
-    main_window.show()
+    loader_window = LoaderWindow()
+    loader_window.show()
 
     with event_loop:
         event_loop.run_until_complete(app_close_event.wait())

qcanvas/db/database.py

@@ -1,4 +1,5 @@
 import pathlib
+import platform
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
@@ -68,7 +69,7 @@ class CoursePreferences(Base):
     course: Mapped["Course"] = relationship(back_populates="preferences")
 
 
-class Course(MappedAsDataclass, Base, tree.HasText, init=False):
+class Course(MappedAsDataclass, Base, init=False):
     __tablename__ = "courses"
 
     id: Mapped[str] = mapped_column(primary_key=True)
@@ -85,11 +86,6 @@ class Course(MappedAsDataclass, Base, tree.HasText, init=False):
     assignments: Mapped[List["Assignment"]] = relationship(back_populates="course")
     resources: Mapped[List["Resource"]] = relationship(back_populates="course")
 
-    @property
-    def text(self) -> str:
-        return self.name
-
-
 class Term(MappedAsDataclass, Base):
     """
     A term object.
@@ -216,7 +212,13 @@ class Resource(MappedAsDataclass, Base, tree.HasText):
 
     @property
     def download_location(self) -> pathlib.Path:
-        return pathlib.Path("download", f"{self.id}@{self.file_name}")
+        file_id: str = self.id
+
+        # Colon is illegal in microsoft windows file names
+        if platform.system() == "Windows":
+            file_id.replace(':', '$')
+
+        return pathlib.Path("download", f"{file_id}@{self.file_name}")
 
 
 class ModuleItem(MappedAsDataclass, Base, tree.HasText):

qcanvas/net/canvas/canvas_client.py

@@ -60,7 +60,7 @@ class CanvasClient(SelfAuthenticating):
     _net_op_sem = asyncio.Semaphore(20)
 
     @staticmethod
-    async def verify_config(canvas_url: URL, api_key: str) -> bool:
+    async def verify_config(canvas_url: str, api_key: str) -> bool:
         """
         Makes a request to canvas to verify that the url and key are correct.
         :param canvas_url: The canvas url to verify
@@ -70,7 +70,7 @@ class CanvasClient(SelfAuthenticating):
         client = httpx.AsyncClient()
         # Make a request to an endpoint that returns very little/no data (for students at least) to check if everything
         # is working
-        response = await client.get(url=canvas_url.join("api/v1/accounts"),
+        response = await client.get(url=URL(canvas_url).join("api/v1/accounts"),
                                     headers={"Authorization": f"Bearer {api_key}"})
 
         return response.is_success

qcanvas/ui/container_item.py

@@ -5,12 +5,17 @@ from qcanvas.util import tree_util as tree
 
 
 class ContainerItem(QStandardItem):
-    content: tree.HasText
-
     def __init__(self, data: tree.HasText):
         super().__init__()
         self.content = data
+        self.setEditable(False)
+
 
     def data(self, role=257):
         if role == Qt.ItemDataRole.DisplayRole:
             return self.content.text
+
+
+
+
+

qcanvas/ui/main_ui.py

@@ -1,7 +1,7 @@
 import logging
 from asyncio import Event
 from datetime import datetime
-from typing import Sequence
+from typing import Sequence, Union, Optional
 
 from PySide6.QtCore import QUrl
 from PySide6.QtGui import QDesktopServices
@@ -9,23 +9,27 @@ from qasync import asyncSlot
 
 from qcanvas.QtVersionHelper.QtGui import QStandardItemModel, QStandardItem
 from qcanvas.QtVersionHelper.QtWidgets import *
-from qcanvas.QtVersionHelper.QtCore import QItemSelection, Slot, Signal, Qt, QModelIndex
+from qcanvas.QtVersionHelper.QtCore import QItemSelection, Slot, Signal, Qt, QObject, QModelIndex
 
 import qcanvas.db.database as db
 from qcanvas.ui.container_item import ContainerItem
+from qcanvas.ui.viewer.course_list import CourseList
 from qcanvas.ui.viewer.file_list import FileRow
 from qcanvas.ui.viewer.file_view_tab import FileViewTab
 from qcanvas.ui.viewer.page_list_viewer import AssignmentsViewer, PagesViewer, LinkTransformer
+from qcanvas.util import AppSettings
+from qcanvas.util.constants import app_name
 from qcanvas.util.course_indexer import DataManager
 
+_aux_settings = AppSettings.auxiliary
 
 class AppMainWindow(QMainWindow):
     logger = logging.getLogger()
     loaded = Signal()
     operation_lock = Event()
 
-    def __init__(self, data_manager: DataManager):
-        super().__init__()
+    def __init__(self, data_manager: DataManager, parent: QWidget | None = None):
+        super().__init__(parent)
 
         self.selected_course: db.Course | None = None
         self.courses: Sequence[db.Course] = []
@@ -33,19 +37,14 @@ class AppMainWindow(QMainWindow):
         self.data_manager = data_manager
         self.link_transformer = LinkTransformer(self.data_manager.link_scanners, self.resources)
 
-        self.setWindowTitle("QCanvas (Under construction)")
-
         right_splitter = QSplitter()
         right_splitter.setOrientation(Qt.Orientation.Vertical)
 
         self.sync_button = QPushButton("Synchronize")
         self.sync_button.clicked.connect(self.sync_data)
 
-        #todo just use QTreeWidget instead
-        self.course_selector = QTreeView()
-        self.course_selector_model = QStandardItemModel()
-        self.course_selector.setModel(self.course_selector_model)
-        self.course_selector.selectionModel().selectionChanged.connect(self.on_item_clicked)
+        self.course_list = CourseList(self.data_manager)
+        self.course_list.course_selected.connect(self.on_course_selected)
 
         self.assignment_viewer = AssignmentsViewer(self.link_transformer)
         self.assignment_viewer.viewer.anchorClicked.connect(self.viewer_link_clicked)
@@ -65,7 +64,7 @@ class AppMainWindow(QMainWindow):
         self.tab_widget.insertTab(2, self.pages_viewer, "Pages")
 
         h_layout = QHBoxLayout()
-        h_layout.addWidget(self.course_selector)
+        h_layout.addWidget(self.course_list)
         h_layout.addWidget(self.tab_widget)
         h_layout.setStretch(1, 1)
 
@@ -80,6 +79,15 @@ class AppMainWindow(QMainWindow):
         self.loaded.connect(self.load_course_list)
         self.loaded.emit()
 
+        self.read_settings()
+
+    def closeEvent(self, event):
+        _aux_settings.setValue("geometry", self.saveGeometry())
+        _aux_settings.setValue("windowState", self.saveState())
+
+    def read_settings(self):
+        self.restoreGeometry(_aux_settings.value("geometry"))
+        self.restoreState(_aux_settings.value("windowState"))
 
     @asyncSlot(QUrl)
     async def viewer_link_clicked(self, url: QUrl):
@@ -112,71 +120,35 @@ class AppMainWindow(QMainWindow):
             self.sync_button.setEnabled(True)
             self.sync_button.setText("Synchronize")
 
-    @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
 
     @asyncSlot()
     async def load_course_list(self):
         self.courses = (await self.data_manager.get_data())
-
-        self.resources.clear()
         self.selected_course = None
-        self.course_selector_model.clear()
-        self.course_selector_model.setHorizontalHeaderLabels(["Course"])
-
-        courses_root = self.course_selector_model.invisibleRootItem()
-
-        for term, courses in self.group_courses_by_term(self.courses):
-            term_node = QStandardItem(term.name)
+        self.resources.clear()
 
-            for course in courses:
-                term_node.appendRow(ContainerItem(course))
-                self.resources.update({resource.id: resource for resource in course.resources})
+        for course in self.courses:
+            self.resources.update({resource.id: resource for resource in course.resources})
 
-            courses_root.appendRow(term_node)
+        self.course_list.load_course_list(self.courses)
 
-        self.course_selector.expandAll()
-        # self.link_transformer.files = self.resources
 
-    @Slot(QItemSelection, QItemSelection)
-    def on_item_clicked(self, selected: QItemSelection, deselected: QItemSelection):
-        if len(selected.indexes()) == 0:
+    @Slot(db.Course)
+    def on_course_selected(self, course: Optional[db.Course]):
+        if course is not None:
+            self.selected_course = course
+            self.pages_viewer.fill_tree(course)
+            self.assignment_viewer.fill_tree(course)
+            self.file_viewer.load_course_files(course)
+        else:
             self.selected_course = None
-            return
-
-        node = self.course_selector_model.itemFromIndex(selected.indexes()[0])
+            self.file_viewer.clear()
 
-        if isinstance(node, ContainerItem):
-            item = node.content
-
-            if isinstance(item, db.Course):
-                self.selected_course = item
-                self.pages_viewer.fill_tree(item)
-                self.assignment_viewer.fill_tree(item)
-                self.file_viewer.load_course_files(item)
-                return
-
-        self.selected_course = None
-        self.file_viewer.clear()
 
     @asyncSlot(db.CoursePreferences)
     async def course_file_group_by_preference_changed(self, preference: db.GroupByPreference):
         self.selected_course.preferences.files_group_by_preference = preference
-        await self.data_manager.update_course_preferences(self.selected_course.preferences)
+        await self.data_manager.update_item(self.selected_course.preferences)
         self.file_viewer.load_course_files(self.selected_course)
 

qcanvas/ui/setup_dialog.py

@@ -0,0 +1,151 @@
+import traceback
+from threading import Semaphore
+from typing import Optional
+
+from PySide6.QtWidgets import QProgressBar
+from qasync import asyncSlot
+
+from qcanvas.QtVersionHelper.QtGui import QWindow, QDesktopServices
+from qcanvas.QtVersionHelper.QtWidgets import QDialog, QWidget, QHBoxLayout, QLabel, QLineEdit, QVBoxLayout, QPushButton, QDialogButtonBox, QCheckBox, QGridLayout, QMessageBox
+from qcanvas.QtVersionHelper.QtCore import Qt, Slot, QUrl
+from qcanvas.net.canvas import CanvasClient
+from qcanvas.util import AppSettings
+
+tutorial_url = "https://www.iorad.com/player/2053777/Canvas---How-to-generate-an-access-token-"
+
+def row(name: str) -> QWidget:
+    widget = QWidget()
+    layout = QHBoxLayout()
+
+    layout.addWidget(QLabel(name))
+    layout.addWidget(QLineEdit())
+
+    widget.setLayout(layout)
+
+    return widget
+
+
+class SetupDialog(QDialog):
+    def __init__(self, parent: Optional[QWidget] = None, allow_cancel: bool = True):
+        super().__init__(parent)
+        self.setWindowTitle("Setup")
+        self._row_counter = 0
+        self._operation_sem = Semaphore()
+
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setMaximum(0)
+        self.progress_bar.setMinimum(0)
+        self.progress_bar.setValue(0)
+        self.progress_bar.hide()
+
+        self.grid = QGridLayout()
+        grid_widget = QWidget()
+        grid_widget.setLayout(self.grid)
+
+        stack = QVBoxLayout()
+
+        self.canvas_url = QLineEdit(AppSettings.canvas_url or "")
+        # self.panopto_url = QLineEdit()
+        self.canvas_api_key = QLineEdit(AppSettings.canvas_api_key or "")
+
+        self._row("Canvas URL", self.canvas_url)
+        # self._row("Painopto URL", self.panopto_url)
+        self._row("Canvas API key", self.canvas_api_key)
+
+        self.grid.addWidget(self.progress_bar, self._row_counter, 0, 1, 2)
+
+        button_box = QDialogButtonBox(
+            QDialogButtonBox.Save | QDialogButtonBox.Cancel if allow_cancel else QDialogButtonBox.Ok)
+        button_box.addButton("How to get a canvas API key?", QDialogButtonBox.ButtonRole.HelpRole)
+
+        button_box.helpRequested.connect(self._show_help)
+        button_box.accepted.connect(self._verify)
+        button_box.rejected.connect(lambda: self.reject())
+
+        stack.addWidget(grid_widget)
+        stack.addWidget(button_box)
+
+        self.setLayout(stack)
+        self.resize(500, 200)
+
+    @asyncSlot()
+    async def _verify(self):
+        if self._operation_sem.acquire(False):
+            try:
+                def invalid(name: str):
+                    msg = QMessageBox(QMessageBox.Icon.Warning,
+                                      "Error",
+                                      f"{name} is invalid",
+                                      parent=self
+                    )
+                    msg.show()
+
+                def ensure_protocol(url: str):
+                    if len(url) > 0 and not (url.startswith("http://") or url.startswith("https://")):
+                        return "https://" + url
+                    else:
+                        return url
+
+                canvas_url_text = ensure_protocol(self.canvas_url.text().strip())
+                # panopto_url_text = ensure_protocol(self.panopto_url.text().strip())
+                canvas_api_key_text = self.canvas_api_key.text().strip()
+
+                if not (len(canvas_url_text) > 0 and QUrl(canvas_url_text).isValid()):
+                    invalid("Canvas URL")
+                    return
+                # if not (len(panopto_url_text) > 0 and QUrl(panopto_url_text).isValid()):
+                #     invalid("Panopto URL")
+                #     return
+                elif not len(canvas_api_key_text) > 0:
+                    invalid("API key")
+                elif not (await self._verify_canvas_config(canvas_url_text, canvas_api_key_text)):
+                    msg = QMessageBox(QMessageBox.Icon.Warning,
+                                      "Error",
+                                      f"The canvas URL or API key is invalid.\nPlease check you entered them correctly.",
+                                      parent=self
+                    )
+                    msg.show()
+                else:
+                    AppSettings.canvas_url = canvas_url_text
+                    AppSettings.canvas_api_key = canvas_api_key_text
+
+                    self.accept()
+            finally:
+                self._operation_sem.release()
+        else:
+            QMessageBox(QMessageBox.Icon.Critical, "Error", "An operation is already in progress", parent=self).show()
+
+    async def _verify_canvas_config(self, canvas_url: str, api_key: str) -> bool:
+        self.progress_bar.show()
+
+        try:
+            return await CanvasClient.verify_config(canvas_url, api_key)
+        except:
+            traceback.print_exc()
+            return False
+        finally:
+            self.progress_bar.hide()
+
+    @Slot()
+    def _show_help(self):
+        msg = QMessageBox(
+            QMessageBox.Icon.Information,
+            "Help",
+            """An interactive tutorial will open in your browser when you click OK.
+            
+Note that the "purpose" text doesn't matter and you can enter anything you want.
+
+You should also leave the "expires" item blank if you want the key to last forever.
+
+Don't share this key. You can revoke it at any time.""",
+            parent=self
+        )
+        msg.accepted.connect(lambda: QDesktopServices.openUrl(tutorial_url))
+        msg.show()
+
+
+    def _row(self, name: str, widget: QWidget):
+        self.grid.addWidget(QLabel(name), self._row_counter, 0)
+        self.grid.addWidget(widget, self._row_counter, 1)
+
+        self._row_counter += 1

qcanvas/ui/viewer/course_list.py

@@ -0,0 +1,98 @@
+from datetime import datetime
+from typing import Sequence, Union, Optional
+
+from qasync import asyncSlot
+
+from qcanvas.QtVersionHelper.QtWidgets import QTreeView
+from qcanvas.QtVersionHelper.QtGui import QStandardItemModel, QStandardItem
+from qcanvas.QtVersionHelper.QtCore import QItemSelection, Slot, Signal, Qt, QObject, QModelIndex
+
+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)
+
+            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/page_list_viewer.py

@@ -6,30 +6,31 @@ from bs4 import BeautifulSoup
 import qcanvas.db as db
 from qcanvas.QtVersionHelper.QtWidgets import QWidget, QTextBrowser, QTreeView, QHBoxLayout
 from qcanvas.QtVersionHelper.QtGui import QStandardItemModel
-from qcanvas.QtVersionHelper.QtCore import QItemSelection, Slot, QUrl, QModelIndex
+from qcanvas.QtVersionHelper.QtCore import QItemSelection, Slot
 from qcanvas.ui.container_item import ContainerItem
 from qcanvas.util import canvas_garbage_remover
 from qcanvas.util.constants import default_assignments_module_names
 from qcanvas.util.course_indexer import resource_helpers
 from qcanvas.util.linkscanner 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 = "http://use-your-imagination.sexy/"
+    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):
+    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
+                    # todo make images actually show on the viewer page if they're downloaded
                     if resource_id in self.files:
                         file = self.files[resource_id]
 
@@ -48,13 +49,14 @@ class LinkTransformer:
 
         return str(doc)
 
+
 class PageLikeViewer(QWidget):
-    def __init__(self, header_name : str, link_transformer : LinkTransformer):
+    def __init__(self, header_name: str, link_transformer: LinkTransformer):
         super().__init__()
         self.viewer = QTextBrowser()
         self.viewer.setOpenLinks(False)
 
-        #todo just use QTreeWidget instead
+        # todo just use QTreeWidget instead
         self.tree = QTreeView()
         self.model = QStandardItemModel()
         self.header_name = header_name
@@ -70,7 +72,6 @@ class PageLikeViewer(QWidget):
         layout.setStretch(1, 1)
         self.setLayout(layout)
 
-
     def fill_tree(self, data: db.Course):
         self.model.clear()
         self.viewer.clear()
@@ -78,7 +79,6 @@ class PageLikeViewer(QWidget):
         self.model.setHorizontalHeaderLabels([self.header_name])
         self.tree.expandAll()
 
-
     @abstractmethod
     def _internal_fill_tree(self, data: db.Course):
         ...
@@ -126,7 +126,7 @@ 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):
+    def _internal_fill_tree(self, course: db.Course):
         root = self.model.invisibleRootItem()
 
         default_assessments_module = None

qcanvas/util/app_settings.py

@@ -1,15 +1,33 @@
-from datetime import datetime
-
-from qcanvas.QtVersionHelper.QtCore import QSettings
+from qcanvas.QtVersionHelper.QtCore import QSettings, QUrl
 
 
 class _AppSettings:
-    settings = QSettings("RetardSoft", "QCanvasViewer")
+    def __init__(self):
+        self.settings = QSettings("QCanvas", "client")
+        self.auxiliary = QSettings("QCanvas", "ui")
+        self._canvas_url = self.settings.value("canvas_url", None)
+        self._api_key = self.settings.value("api_key", defaultValue=None)
 
     @property
-    def canvas_url(self) -> str:
-        return str(self.settings.value("canvas_url"))
+    def canvas_url(self) -> str | None:
+        return self._canvas_url
+
+    @canvas_url.setter
+    def canvas_url(self, value: str):
+        self._canvas_url = value
+        self.settings.setValue("canvas_url", value)
 
     @property
-    def canvas_api_key(self) -> str:
-        return str(self.settings.value("api_key"))
+    def canvas_api_key(self) -> str | None:
+        return self._api_key
+
+    @canvas_api_key.setter
+    def canvas_api_key(self, value: str):
+        self._api_key = value
+        self.settings.setValue("api_key", value)
+
+    @property
+    def is_set(self):
+        return self.canvas_url is not None and QUrl(self.canvas_url).isValid() and self.canvas_url is not None
+
+

qcanvas/util/constants.py

@@ -1 +1,2 @@
 default_assignments_module_names = ["assessments", "assessment"]
+app_name = "QCanvas (Under construction)"

qcanvas/util/course_indexer/data_manager.py

@@ -140,9 +140,9 @@ class DataManager:
 
         await self.download_pool.submit(resource.id, lambda: self._download_resource_helper(scanner, resource))
 
-    async def update_course_preferences(self, preferences: db.CoursePreferences):
+    async def update_item(self, item: db.Base):
         async with self._session_maker.begin() as session:
-            await session.merge(preferences)
+            await session.merge(item)
 
     async def get_data(self):
         """

{qcanvas-0.0.2a0.dist-info → qcanvas-0.0.3a0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: qcanvas
-Version: 0.0.2a0
+Version: 0.0.3a0
 Summary: A canvas client
 Author: QCanvas
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
+Requires-Python: ==3.11
 Requires-Dist: aiosqlite-custom~=0.19.0
 Requires-Dist: beautifulsoup4~=4.12.3
 Requires-Dist: bs4~=0.0.1
@@ -17,6 +17,5 @@ Requires-Dist: pyside6~=6.6.1
 Requires-Dist: qasync~=0.27.1
 Requires-Dist: qenerate-custom~=0.6.3
 Requires-Dist: requests~=2.31.0
-Requires-Dist: setuptools~=69.0.3
 Requires-Dist: sqlalchemy~=2.0.25
 Requires-Dist: tenacity~=8.2.3

{qcanvas-0.0.2a0.dist-info → qcanvas-0.0.3a0.dist-info}/RECORD

@@ -1,17 +1,17 @@
 qcanvas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/__main__.py,sha256=I-oTK8nEaVo5OxJIRgM4AGoraYzXqkhJu2mwYp-yAww,2149
+qcanvas/__main__.py,sha256=xrVcfihwbMdEeO3QwCaIU4C6pJjBBdkdtp8pjDpJrxs,3552
 qcanvas/QtVersionHelper/__init__.py,sha256=AHg0tv2hhTpapl6pZQWDWqOSes0ceHx0wMLSsHJEG1s,405
 qcanvas/QtVersionHelper/QtCore/__init__.py,sha256=LYVV4s0gsUn1yi8NLB_H0RPFR4IaLH0WzVcBJ4TA-3g,240
 qcanvas/QtVersionHelper/QtGui/__init__.py,sha256=Ml3Evje04C7hr2WSBALEJy79Yz7C92ZkE2hmBHbULzQ,1026
 qcanvas/QtVersionHelper/QtWidgets/__init__.py,sha256=Kq-bgC2LJzwuTmH_A8i7Y6WrhsQYT4RO3xEVDU8szEc,246
 qcanvas/db/__init__.py,sha256=wK5HUSGOplql2RBTpw6dSCwRjHChtTWX2zkhbe6OaQw,414
-qcanvas/db/database.py,sha256=UDBKFmce7Ed9fdgCFjAjxwgtcSdr3RrwXxdbMXpeJBE,10144
+qcanvas/db/database.py,sha256=2eWREp5DhHfP5JBWGyQIKnc5iApvKMbUwjWUtXFT5Z4,10251
 qcanvas/db/db_converter_helper.py,sha256=LxmGxv50gM7Ir6TRksIqufnVk0WIL5BOAVTYl9MR6GE,2167
 qcanvas/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qcanvas/net/custom_httpx_async_transport.py,sha256=kSkBD1v476CVPY2qWAarcyG8mbKyNDNuR32ByIhG94c,1212
 qcanvas/net/self_authenticating.py,sha256=Qyx8vYtSLDClx-WMcrVUeeqUI5jCftiuAqN2RU8goUE,2514
 qcanvas/net/canvas/__init__.py,sha256=NgLiTbeKoYKDVoEd1AoP8RB_tEFi6Jzwj9gGhSu5mw4,95
-qcanvas/net/canvas/canvas_client.py,sha256=uV75qHy91RhvSMqGkkypiJ5EGp7bZnra6D54G_ifRFQ,8865
+qcanvas/net/canvas/canvas_client.py,sha256=Dnb3PC_9eNf2ynAH-HivYOAX2zTaDC5Al1a_FcJWrrA,8870
 qcanvas/net/canvas/legacy_canvas_types.py,sha256=QN1BFaDF-W1ep0X2Ax2n92-I66IzxqLdRwHYrAom5Ck,3926
 qcanvas/queries/__init__.py,sha256=tRUwMS1OvYIWRd4WpmAHrDrcelj_dLEaesxh9NngC6s,227
 qcanvas/queries/all_courses.gql,sha256=LoGcuyYtA0tVC2L8BVOmfC10DfvhFAxxhqhovvBYOuU,116
@@ -19,23 +19,24 @@ qcanvas/queries/all_courses.py,sha256=kt-vEclAYUGoscQc2W4wwYGwJ93CIElzF215I1wo7_
 qcanvas/queries/canvas_course_data.gql,sha256=KJHjdu5sMKld4L6mPGfUrhqRLx_wdgGH8fwTnmRFGrI,1115
 qcanvas/queries/canvas_course_data.py,sha256=JDWDGv-aZ1n9y5uNtKTG5v33BZqA7dceLzL3-_zoU94,4311
 qcanvas/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/ui/container_item.py,sha256=yfAPzkdxAYAHXkq8OCaAOgD9VPJCnwsDSscw-aYJ55Y,426
-qcanvas/ui/main_ui.py,sha256=v6TkxUvmZW7MCf0rxLWFQKRAI1mLk9ia6nFPFfpCgVU,7145
+qcanvas/ui/container_item.py,sha256=rcoCp7xS4WGdbfH4pDOirTn3ioBQqCEsfgQzLKHiF7M,437
+qcanvas/ui/main_ui.py,sha256=5g8ekck2vFsUjXMSkBEE6lkrgbOwex9x81uu2-41nVs,5975
+qcanvas/ui/setup_dialog.py,sha256=EJjlsWlBo3bRncuDcdqctSVkEBm7VYv2veJlKhuHvd0,5666
 qcanvas/ui/viewer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/ui/viewer/course_viewer.py,sha256=vq2umErB_6cTsBtfcOAhJWKuB6UFscBMbterDdHH0ik,198
+qcanvas/ui/viewer/course_list.py,sha256=qa7hqDi2gDToit0bN_TUXGuZSc7yQhPOFOho8yj_3Rc,3457
 qcanvas/ui/viewer/file_list.py,sha256=jL0BKls-90LSUzKA4-V_8ViznrzONNEUjLcRLPzLNCU,6441
 qcanvas/ui/viewer/file_view_tab.py,sha256=QAClZVnJQ0PsVD4AMR8DyfKwGwBdcY2M08pRCmuTH3g,4684
-qcanvas/ui/viewer/page_list_viewer.py,sha256=A4IKd70uTNgNq_r4XLiZanX3lTIFyhUZyvmyhvTS6Fc,5590
+qcanvas/ui/viewer/page_list_viewer.py,sha256=4diKsosp5lZ0FnDzGIVabF8mevUIHS55ncrFGckk3yc,5542
 qcanvas/util/__init__.py,sha256=4nrMAMxWMpItgg2iaE1Z6ysoRVG3ljUTHrVNxOazGGQ,68
-qcanvas/util/app_settings.py,sha256=AnvmC0oWB0YrqYtJiT3gCoG2yfxc8dUEZg2ltnVNP8k,366
+qcanvas/util/app_settings.py,sha256=3wFq_FMwPwPqr4v8tYMUM1O-ATdeA4ww2djaEt_nuzk,974
 qcanvas/util/canvas_garbage_remover.py,sha256=c6r6cyJomQ1zn5wFK-LX-ZsZXQZ-A2awBFtCB_JqUtE,1184
-qcanvas/util/constants.py,sha256=Gx8g7DPocfBw4dppog_uJgfZthKpptUY-H0PvVAlLMg,65
+qcanvas/util/constants.py,sha256=e8xUAI3F-XogKQu_GMXETVaNbIiHfv4oc5XyFUpBzM0,106
 qcanvas/util/download_pool.py,sha256=ezQH3Dp8aPCYUudLfqgDmGILY_H_0KgrJR1BBg5GTN4,2375
 qcanvas/util/file_icon_helper.py,sha256=3xcvclI0QoKhE0_vPLWAqLgVpO-G_ra524DNYgg2YRM,630
 qcanvas/util/task_pool.py,sha256=tOkcjQ6MqjztpA8L94nqfFemrsWRYXuCx04oIJmxT48,8964
 qcanvas/util/course_indexer/__init__.py,sha256=qDPevtjuQv72m23QLg6uXN3MDugJuKYF_12xlsWehNI,37
 qcanvas/util/course_indexer/conversion_helpers.py,sha256=WggJmf4to7hpBpDTOpdBbaDQQv6OdEuLiFnhazcsjcM,2660
-qcanvas/util/course_indexer/data_manager.py,sha256=7HvXT1tBBiZ_20WOE6B6xb5pQsvGYyX-9EVfZGkYPn0,15530
+qcanvas/util/course_indexer/data_manager.py,sha256=HROkN9BVISKSpndBKmsbPpgdJYs9bHeU7GgUcVsJSkI,15489
 qcanvas/util/course_indexer/resource_helpers.py,sha256=M1iT3ShQ2xe3BZ8wNnJU3nm6LiqDqLR2MwkDHaIc32Q,6465
 qcanvas/util/linkscanner/__init__.py,sha256=gIg-zNU0VtmJgEWNS__MNRrBToyKMXLo15q2UoVeI5I,96
 qcanvas/util/linkscanner/canvas_link_scanner.py,sha256=Bl2Rzyb9wdkYx8yN0_r1zdm3wiC8Y1Y-Csd0RIBuAfs,1466
@@ -46,6 +47,6 @@ qcanvas/util/tree_util/__init__.py,sha256=iW-k9zMIPL3xrDby8N38UsMNpri6t9qPceXznm
 qcanvas/util/tree_util/expanding_tree.py,sha256=Mmi0U8qe_CbwQo_areF_TMcqHlccKXIB1b29CwBagco,6748
 qcanvas/util/tree_util/model_helpers.py,sha256=gtkZAUIxRbFUSHeiI65GAD_y9q2-HrJPH1ijYSstS5c,794
 qcanvas/util/tree_util/tree_model.py,sha256=SDrm8XVZFllP1NFEnrTeSsCBct_Dx23pyJ5DGwoOhB0,3015
-qcanvas-0.0.2a0.dist-info/METADATA,sha256=LqRUI6zG1lUnnQcXc5kd0XEPybiS0d2Aj94QxgeFLLo,670
-qcanvas-0.0.2a0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-qcanvas-0.0.2a0.dist-info/RECORD,,
+qcanvas-0.0.3a0.dist-info/METADATA,sha256=e_xVT_Ai46iMlCEx1eYxWg8-EdXMoq7KTjt3Svpyrrs,636
+qcanvas-0.0.3a0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
+qcanvas-0.0.3a0.dist-info/RECORD,,

qcanvas/ui/viewer/course_viewer.py

@@ -1,12 +0,0 @@
-import qcanvas.db as db
-
-class CourseViewer:
-    course: db.Course | None = None
-
-    def __init__(self):
-        pass
-
-    def load_course(self, course : db.Course):
-        self.course = course
-
-