qcanvas 0.0.5.1a0__tar.gz → 0.0.5.3a0__tar.gz

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qcanvas
-Version: 0.0.5.1a0
+Version: 0.0.5.3a0
 Summary: A canvas client
 Author: QCanvas
 Classifier: Operating System :: OS Independent
@@ -8,7 +8,6 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: <=3.12,>=3.11
 Requires-Dist: aiosqlite-custom~=0.19.0
 Requires-Dist: beautifulsoup4~=4.12.3
-Requires-Dist: bs4~=0.0.1
 Requires-Dist: gql~=3.6.0b0
 Requires-Dist: httpx~=0.26.0
 Requires-Dist: packaging~=23.2

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name="qcanvas"
-version = "0.0.5.1a"
+version = "0.0.5.3a"
 authors= [ {name="QCanvas"} ]
 description="A canvas client"
 requires-python=">=3.11,<=3.12"
@@ -24,7 +24,7 @@ dependencies=[
     "qenerate-custom~=0.6.3",
     "aiosqlite-custom~=0.19.0",
     "qasync~=0.27.1",
-    "bs4~=0.0.1",
+    "beautifulsoup4~=4.12.3",
     "pyqtdarktheme~=2.1.0",
     "packaging~=23.2"
 ]

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/__main__.py

@@ -58,8 +58,9 @@ class LoaderWindow(QMainWindow):
     @asyncSlot()
     async def on_init(self) -> None:
         try:
+            all_set = None not in [settings.api_key, settings.canvas_url, settings.panopto_url]
             # Verify that the canvas urls and api key are valid
-            if not await CanvasClient.verify_config(settings.canvas_url, settings.api_key):
+            if not all_set or not await CanvasClient.verify_config(settings.canvas_url, settings.api_key):
                 # Show the setup dialog
                 self.setup.emit()
             else:

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/net/canvas/canvas_client.py

@@ -1,7 +1,7 @@
 import asyncio
 import json
 import logging
-from typing import BinaryIO, AsyncIterator
+from typing import BinaryIO, AsyncIterator, Any
 
 import gql
 import httpx
@@ -13,7 +13,7 @@ from tenacity import retry, wait_exponential, wait_random, stop_after_attempt, w
 import qcanvas.db as db
 from qcanvas.net.canvas.legacy_canvas_types import LegacyFile, LegacyPage
 from qcanvas.net.custom_httpx_async_transport import CustomHTTPXAsyncTransport
-from qcanvas.net.self_authenticating import SelfAuthenticating, AuthenticationException
+from qcanvas.net.self_authenticating import SelfAuthenticatingWithHttpClient, AuthenticationException
 
 
 class RatelimitedException(Exception):
@@ -48,11 +48,7 @@ def detect_ratelimit_and_raise(response: Response) -> Response:
     return response
 
 
-def detect_authentication_needed(response: Response):
-    return response.url.path == "/login/canvas" or response.status_code == 401
-
-
-class CanvasClient(SelfAuthenticating):
+class CanvasClient(SelfAuthenticatingWithHttpClient):
     _logger = logging.getLogger("canvas_client")
     _net_op_sem = asyncio.Semaphore(20)
 
@@ -73,11 +69,9 @@ class CanvasClient(SelfAuthenticating):
         return response.is_success
 
     def __init__(self, canvas_url: URL, api_key: str, client: httpx.AsyncClient | None = None):
-        super().__init__()
+        super().__init__(client=client or httpx.AsyncClient(timeout=60))
         self.api_key = api_key
         self.canvas_url = canvas_url
-        self.client = client or httpx.AsyncClient(timeout=60)
-        self.max_retries = 3
 
     def get_headers(self) -> dict[str, dict]:
         return {"headers": {"Authorization": f"Bearer {self.api_key}"}}
@@ -132,18 +126,33 @@ class CanvasClient(SelfAuthenticating):
 
             return LegacyFile.from_dict(json.loads(response.text))
 
+    @retry(
+        wait=wait_exponential(exp_base=1.2, max=10) + wait_random(0, 1),
+        retry=retry_if_exception_type(RatelimitedException),
+        stop=stop_after_attempt(8)
+    )
+    async def get_temp_session_link(self) -> str | None:
+        """
+        Gets the link which will authenticate a browser/open canvas using a 'legacy session token'
+        Returns
+        -------
+        str | None
+            The url as a string if the request succeeded, None if it didn't
+        """
+
+        token_response = await self.client.get(self.canvas_url.join("login/session_token"), **self.get_headers())
+
+        if token_response.is_success:
+            return json.loads(token_response.text)["session_url"]
+        else:
+            return None
+
     @retry(
         stop=stop_after_attempt(3),
         wait=wait_fixed(5) + wait_random(0, 1),
         retry=retry_if_exception_type(TransportQueryError)
     )
-    async def do_graphql_query(self, query: gql.client.DocumentNode, **kwargs):
-        """
-        Executes a graphql query and reauthenticates the client if needed
-        :param query:
-        :param operation: The operation to execute
-        :return: The result
-        """
+    async def do_graphql_query(self, query: gql.client.DocumentNode, **kwargs) -> dict[str, Any]:
         async with self._net_op_sem:
             gql_transport = CustomHTTPXAsyncTransport(self.client, self.canvas_url.join("api/graphql"),
                                                       **self.get_headers())
@@ -172,36 +181,13 @@ class CanvasClient(SelfAuthenticating):
         self._logger.warning("Gave up download of %s", resource.url)
         raise
 
-    async def do_request_and_retry_if_unauthenticated(self, url: URL):
-        """
-        Executes a http request or reauthenticate and retries if needed
-        :param url: The url of the request
-        :return:
-        """
-        retries = 0
-
-        # Make the initial request
-        response = await self.client.get(url, **self.get_headers())
-
-        # Retry if canvas is trying to get us to reauthenticate
-        while (await self.reauthenticate_if_needed(response)) and retries < self.max_retries:
-            response = await self.client.get(url, **self.get_headers())
-            retries += 1
-
-        return response.text
-
-    async def reauthenticate_if_needed(self, response: Response):
-        """
-        Inspects a response and activates reauthentication if the response indicates we need to
-        :param response: The response to inspect
-        :return: True if reauthentication was activated, false if not
-        """
-
-        if detect_authentication_needed(response):
-            await self.reauthenticate()
-            return True
+    async def do_request_and_retry_if_unauthenticated(self, url: URL, method: str, **kwargs) -> httpx.Response:
+        # Add API token to the request
+        return await super().do_request_and_retry_if_unauthenticated(url, method, **kwargs, **self.get_headers())
 
-        return False
+    def detect_authentication_needed(self, response: Response):
+        # Canvas will silently redirect to the login page or give a 401 if we are not authenticated
+        return response.url.path == "/login/canvas" or response.status_code == 401
 
     async def _authenticate(self):
         token_response = await self.client.get(self.canvas_url.join("login/session_token"), **self.get_headers())

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/net/self_authenticating.py

@@ -1,6 +1,10 @@
 import logging
+from abc import ABC, abstractmethod
 from asyncio import Lock, Event
 
+import httpx
+from httpx import URL
+
 
 class AuthenticationException(Exception):
     pass
@@ -9,14 +13,16 @@ class AuthenticationException(Exception):
 # httpx does have an authentication flow mechanism that allows you to also make other requests but I don't know if it
 # will behave the same way as this does. I also finished this before I found out that existed.
 
-class SelfAuthenticating:
+class SelfAuthenticatingWithHttpClient(ABC):
     _logger = logging.getLogger(__name__)
 
-    def __init__(self):
+    def __init__(self, max_retires: int = 3, client: httpx.AsyncClient = httpx.AsyncClient()):
         self.authentication_lock = Lock()
+        self.client = client
         self.authentication_in_progress: Event | None = None
+        self.max_retries = max_retires
 
-    async def reauthenticate(self):
+    async def reauthenticate(self) -> None:
         """
         Re-authenticates the client
         """
@@ -55,8 +61,48 @@ class SelfAuthenticating:
             await event.wait()
             self._logger.info(f"Finished waiting for {self.__class__.__name__}")
 
+    async def do_request_and_retry_if_unauthenticated(self, url: URL, method: str, **kwargs) -> httpx.Response:
+        """
+        Executes a http request or reauthenticate and retries if needed
+        :param url: The url of the request
+        :param method: The method the request should use (post, get, etc)
+        :return:
+        """
+        retries = 0
+
+        async def make_request():
+            return await self.client.request(url=url, method=method, **kwargs)
+
+        # Make the initial request
+        response = await make_request()
+
+        # Retry if canvas is trying to get us to reauthenticate
+        while (await self.reauthenticate_if_needed(response)) and retries < self.max_retries:
+            response = await make_request()
+            retries += 1
+
+        return response
+
+    async def reauthenticate_if_needed(self, response: httpx.Response) -> bool:
+        """
+        Inspects a response and activates reauthentication if the response indicates we need to
+        :param response: The response to inspect
+        :return: True if reauthentication was activated, false if not
+        """
+
+        if self.detect_authentication_needed(response):
+            await self.reauthenticate()
+            return True
+
+        return False
+
+    @abstractmethod
+    def detect_authentication_needed(self, response: httpx.Response) -> bool:
+        ...
+
+    @abstractmethod
     async def _authenticate(self) -> None:
         """
         Authenticates the client
         """
-        raise NotImplemented
+        ...

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/ui/main_ui.py

@@ -3,8 +3,8 @@ import sys
 import traceback
 from typing import Sequence, Optional
 
-from PySide6.QtCore import Slot, Signal, Qt, QUrl
-from PySide6.QtGui import QDesktopServices
+from PySide6.QtCore import Slot, Signal, Qt, QUrl, QObject
+from PySide6.QtGui import QDesktopServices, QKeySequence
 from PySide6.QtWidgets import *
 from qasync import asyncSlot
 
@@ -20,6 +20,7 @@ from qcanvas.util import self_updater
 from qcanvas.util.app_settings import settings
 from qcanvas.util.constants import app_name
 from qcanvas.util.course_indexer import DataManager
+from qcanvas.util.helpers.qaction_helper import create_qaction
 
 _aux_settings = settings.auxiliary
 _no_course_selected_text = "No course selected"
@@ -103,9 +104,11 @@ class AppMainWindow(QMainWindow):
     def setup_menu_bar(self):
         menu_bar = self.menuBar()
 
-        menu_bar.addMenu(ThemeSelectionMenu())
-        view_menu = menu_bar.addMenu("View")
+        app_menu: QMenu = menu_bar.addMenu("App")
+        view_menu: QMenu = menu_bar.addMenu("View")
 
+        app_menu.addAction(self.setup_quick_authentication_action(app_menu))
+        app_menu.addMenu(ThemeSelectionMenu())
         view_menu.addMenu(self.setup_group_by_menu())
 
     def setup_group_by_menu(self) -> QMenu:
@@ -115,6 +118,22 @@ class AppMainWindow(QMainWindow):
 
         return file_grouping_menu
 
+    def setup_quick_authentication_action(self, parent: QObject):
+        return create_qaction(
+            name="Quick canvas login",
+            shortcut=QKeySequence("Ctrl+O"),
+            triggered=self.open_quick_auth_in_browser,
+            parent=parent
+        )
+
+    @asyncSlot()
+    async def open_quick_auth_in_browser(self):
+        opening_progress_dialog = QProgressDialog("Opening canvas", None, 0, 0, self)
+        opening_progress_dialog.setWindowTitle("Please wait")
+        opening_progress_dialog.show()
+        QDesktopServices.openUrl(await self.data_manager.client.get_temp_session_link())
+        opening_progress_dialog.close()
+
     def closeEvent(self, event):
         settings.geometry = self.saveGeometry()
         settings.window_state = self.saveState()
@@ -132,6 +151,8 @@ class AppMainWindow(QMainWindow):
 
             await self.data_manager.download_resource(resource)
             QDesktopServices.openUrl(QUrl.fromLocalFile(resource.download_location.absolute()))
+        else:
+            QDesktopServices.openUrl(url)
 
     @asyncSlot(QTreeWidgetItem, int)
     async def download_file_from_file_pane(self, item: QTreeWidgetItem, _: int):
@@ -219,6 +240,8 @@ class AppMainWindow(QMainWindow):
         else:
             self.selected_course = None
             self.file_viewer.clear()
+            self.pages_viewer.clear()
+            self.assignment_viewer.clear()
             self.course_name_label.setText(_no_course_selected_text)
 
     @asyncSlot(db.CoursePreferences)

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/ui/setup_dialog.py

@@ -51,12 +51,12 @@ class SetupDialog(QDialog):
 
         # Line edits for the different properties
         self.canvas_url = QLineEdit(settings.canvas_url or "")
-        # self.panopto_url = QLineEdit()
+        self.panopto_url = QLineEdit()
         self.canvas_api_key = QLineEdit(settings.api_key or "")
 
         # Add the line edits to the dialog
         self._row("Canvas URL", self.canvas_url)
-        # self._row("Painopto URL", self.panopto_url)
+        self._row("Painopto URL", self.panopto_url)
         self._row("Canvas API key", self.canvas_api_key)
 
         # Add the activity indicator to the dialog
@@ -93,15 +93,15 @@ class SetupDialog(QDialog):
         if self._operation_sem.acquire(False):
             try:
                 canvas_url_text = self.ensure_protocol(self.canvas_url.text().strip())
-                # panopto_url_text = ensure_protocol(self.panopto_url.text().strip())
+                panopto_url_text = self.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()):
                     self._show_invalid_msgbox("Canvas URL")
                     return
-                # if not (len(panopto_url_text) > 0 and QUrl(panopto_url_text).isValid()):
-                #     invalid("Panopto URL")
-                #     return
+                if not (len(panopto_url_text) > 0 and QUrl(panopto_url_text).isValid()):
+                    self._show_invalid_msgbox("Panopto URL")
+                    return
                 elif not len(canvas_api_key_text) > 0:
                     self._show_invalid_msgbox("API key")
                 elif not (await self._verify_canvas_config(canvas_url_text, canvas_api_key_text)):
@@ -116,7 +116,7 @@ class SetupDialog(QDialog):
                     # If nothing was wrong, everything should be fine
                     # Save the url and api key
                     settings.canvas_url = canvas_url_text
-                    # settings.panoptp_url = panopto_url_text
+                    settings.panopto_url = panopto_url_text
                     settings.api_key = canvas_api_key_text
 
                     self.accept()

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/ui/status_bar_reporter.py

@@ -34,4 +34,7 @@ class StatusBarReporter(ProgressReporter):
         self.status_bar.showMessage("Finished", 5000)
 
     def errored(self, context: Any) -> None:
-        pass
+        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-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/ui/viewer/page_list_viewer.py

@@ -11,7 +11,7 @@ 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.linkscanner import ResourceScanner
+from qcanvas.util.link_scanner import ResourceScanner
 
 
 class LinkTransformer:
@@ -79,6 +79,11 @@ class PageLikeViewer(QWidget):
         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):
         ...

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/util/app_settings.py

@@ -85,6 +85,7 @@ class _AppSettings:
     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")

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/util/course_indexer/data_manager.py

@@ -7,6 +7,7 @@ from typing import Sequence
 
 from gql import gql
 from sqlalchemy import select
+from sqlalchemy.dialects.sqlite import insert as sqlite_upsert
 from sqlalchemy.ext.asyncio.session import async_sessionmaker as AsyncSessionMaker, AsyncSession
 from sqlalchemy.orm import selectin_polymorphic, selectinload
 
@@ -16,8 +17,8 @@ import qcanvas.util.course_indexer.conversion_helpers as conv_helper
 import qcanvas.util.course_indexer.resource_helpers as resource_helper
 from qcanvas.net.canvas import CanvasClient
 from qcanvas.util.download_pool import DownloadPool
-from qcanvas.util.linkscanner.canvas_link_scanner import canvas_resource_id_prefix
-from qcanvas.util.linkscanner.resource_scanner import ResourceScanner
+from qcanvas.util.link_scanner.canvas_link_scanner import canvas_resource_id_prefix
+from qcanvas.util.link_scanner.resource_scanner import ResourceScanner
 from qcanvas.util.progress_reporter import ProgressReporter, noop_reporter
 from qcanvas.util.task_pool import TaskPool
 
@@ -83,7 +84,7 @@ class DataManager:
                  sessionmaker: AsyncSessionMaker,
                  link_scanners: Sequence[ResourceScanner]):
 
-        self._client = client
+        self.client = client
         self._link_scanners = link_scanners
         self._session_maker = sessionmaker
 
@@ -188,7 +189,7 @@ class DataManager:
 
     async def synchronize_with_canvas(self, progress_reporter: ProgressReporter = noop_reporter):
         section = progress_reporter.section("Loading index", 0)
-        raw_query = (await self._client.do_graphql_query(gql(queries.all_courses.DEFINITION), detailed=True))
+        raw_query = (await self.client.do_graphql_query(gql(queries.all_courses.DEFINITION), detailed=True))
         section.increment_progress()
 
         await self.load_courses_data(queries.AllCoursesQueryData(**raw_query).all_courses, progress_reporter)
@@ -201,28 +202,32 @@ class DataManager:
         if not self._init_called:
             raise Exception("Init was not called")
 
-        async with self._session_maker.begin() as session:
-            # Load module pages/files for the courses
-            await self._load_module_items(g_courses, session, progress_reporter)
+        try:
+            async with self._session_maker.begin() as session:
+                # Load module pages/files for the courses
+                await self._load_module_items(g_courses, session, progress_reporter)
 
-            # Collect assignments from the courses
-            assignments = []
+                # Collect assignments from the courses
+                assignments = []
 
-            for g_course in g_courses:
-                # Create needed data in the session
-                term = await conv_helper.create_term(g_course, session)
-                await conv_helper.create_course(g_course, session, term)
-                await conv_helper.create_modules(g_course, session)
+                for g_course in g_courses:
+                    # Create needed data in the session
+                    term = await conv_helper.create_term(g_course, session)
+                    await conv_helper.create_course(g_course, session, term)
+                    await conv_helper.create_modules(g_course, session)
 
-                # Add course assignments to the list
-                assignments.extend(await conv_helper.create_assignments(g_course, session))
+                    # Add course assignments to the list
+                    assignments.extend(await conv_helper.create_assignments(g_course, session))
 
-            # Scan assignments for resources
-            await self._scan_assignments_for_resources(assignments, session, progress_reporter)
+                # Scan assignments for resources
+                await self._scan_assignments_for_resources(assignments, session, progress_reporter)
 
-            # Add all resources back into the session
-            session.add_all(self._resource_pool.results())
-            progress_reporter.finished()
+                # Add all resources back into the session
+                session.add_all(self._resource_pool.results())
+                progress_reporter.finished()
+        except BaseException as e:
+            traceback.print_exc()
+            progress_reporter.errored(e)
 
     async def _scan_assignments_for_resources(self, assignments: Sequence[db.Assignment], session: AsyncSession,
                                               progress_reporter: ProgressReporter):
@@ -256,8 +261,13 @@ class DataManager:
 
         # Filter out pages that don't need updating
         pages_to_update = _prepare_out_of_date_pages_for_loading(g_courses, existing_pages)
+
+        if len(pages_to_update) == 0:
+            return
+
         # Load the content for all the pages that need updating
-        module_items = await self._load_content_for_pages(pages_to_update, progress_reporter)
+        module_items: list[db.ModuleItem] = await self._load_content_for_pages(pages_to_update, progress_reporter)
+        module_pages = [item for item in module_items if isinstance(item, db.ModulePage)]
 
         # Link the resources found to the pages they were found on and add them to the database
         await resource_helper.create_module_item_resource_relations(
@@ -267,13 +277,43 @@ class DataManager:
                 resource_pool=self._resource_pool,
                 progress_reporter=progress_reporter,
                 # Collect just the module pages for scanning
-                items=[item for item in module_items if isinstance(item, db.ModulePage)]
+                items=module_pages
             ),
             session
         )
 
-        # Add all the module items to the session
-        session.add_all(module_items)
+        # empty inserts/upserts causes an sql error. don't do them
+        if len(module_pages) > 0:
+            # Add all the module items to the session
+            # shitty bandaid fix
+            upsert_item = sqlite_upsert(db.ModuleItem).values([self.moduleitem_dict(item) for item in module_pages])
+            upsert_item = upsert_item.on_conflict_do_update(
+                index_elements=[db.ModuleItem.id],
+                set_=dict(name=upsert_item.excluded.name, updated_at=upsert_item.excluded.updated_at,
+                          position=upsert_item.excluded.position),
+
+            )
+
+            upsert_page = sqlite_upsert(db.ModulePage).values([self.page_dict(item) for item in module_pages])
+            upsert_page = upsert_page.on_conflict_do_update(
+                index_elements=[db.ModulePage.id],
+                set_=dict(content=upsert_page.excluded.content)
+            )
+
+            await session.execute(upsert_item)
+            await session.execute(upsert_page)
+
+        session.add_all([item for item in module_items if isinstance(item, db.ModuleFile)])
+
+    @staticmethod
+    def page_dict(page: db.ModulePage) -> dict[str, object]:
+        return {"id": page.id, "content": page.content}
+
+    @staticmethod
+    def moduleitem_dict(page: db.ModuleItem) -> dict[str, object]:
+        return {"id": page.id, "name": page.name, "updated_at": page.updated_at, "position": page.position,
+                "module_id": page.module_id, "course_id": page.course_id, "type": page.type,
+                "created_at": page.created_at}
 
     def _add_resources_and_pages_to_taskpool(self, existing_pages: Sequence[db.ModuleItem],
                                              existing_resources: Sequence[db.Resource]):
@@ -293,6 +333,7 @@ class DataManager:
             The pages to load
         Returns
         -------
+        list
             The list of complete pages with page content loaded.
         """
         progress = progress_reporter.section("Loading page content", len(pages))
@@ -343,7 +384,7 @@ class DataManager:
         Fetches information about the specified file from canvas
         """
         _logger.debug(f"Fetching file (for module file) %s %s", file.m_id, file.display_name)
-        result = await self._client.get_file(file.m_id, course_id)
+        result = await self.client.get_file(file.m_id, course_id)
         resource = db.convert_file(file, result.size)
         resource.id = f"{canvas_resource_id_prefix}:{resource.id}"
         resource.course_id = course_id
@@ -369,7 +410,7 @@ class DataManager:
 
         try:
             # Get the page
-            result = await self._client.get_page(page.m_id, course_id)
+            result = await self.client.get_page(page.m_id, course_id)
         except BaseException as e:
             # Handle any errors
             _logger.error(e)

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/util/course_indexer/resource_helpers.py

@@ -7,11 +7,11 @@ from bs4 import Tag, BeautifulSoup
 from sqlalchemy.ext.asyncio import AsyncSession
 
 import qcanvas.db as db
-from qcanvas.util.linkscanner import ResourceScanner
+from qcanvas.util.link_scanner import ResourceScanner
 from qcanvas.util.progress_reporter import ProgressReporter
 from qcanvas.util.task_pool import TaskPool
 
-_logger = logging.getLogger()
+_logger = logging.getLogger(__name__)
 
 resource_elements = ["a", "iframe", "img"]
 
@@ -63,6 +63,7 @@ async def create_assignment_resource_relations(relations: Sequence[TransientReso
             )
 
 
+# todo change resource system to think of resources as links on a page with a shallow id (that may be the same as the deep id) which links to one or more deep ids
 async def find_resources_in_pages(link_scanners: Sequence[ResourceScanner], resource_pool: TaskPool[db.Resource],
                                   items: Sequence[db.PageLike], progress_reporter: ProgressReporter) -> list[
     TransientResourceToPageLink]:

{qcanvas-0.0.5.1a0/qcanvas/util/linkscanner → qcanvas-0.0.5.3a0/qcanvas/util/link_scanner}/canvas_link_scanner.py

@@ -3,7 +3,7 @@ from httpx import URL
 
 from qcanvas import db as db
 from qcanvas.net.canvas import CanvasClient
-from qcanvas.util.linkscanner.resource_scanner import ResourceScanner
+from qcanvas.util.link_scanner.resource_scanner import ResourceScanner
 
 canvas_resource_id_prefix = "canvas_file"
 

{qcanvas-0.0.5.1a0/qcanvas/util/linkscanner → qcanvas-0.0.5.3a0/qcanvas/util/link_scanner}/canvas_media_object_scanner.py

@@ -5,7 +5,7 @@ from bs4 import Tag, BeautifulSoup
 from httpx import AsyncClient
 
 from qcanvas import db as db
-from qcanvas.util.linkscanner import ResourceScanner
+from qcanvas.util.link_scanner import ResourceScanner
 
 
 class CanvasMediaObjectScanner(ResourceScanner):

{qcanvas-0.0.5.1a0/qcanvas/util/linkscanner → qcanvas-0.0.5.3a0/qcanvas/util/link_scanner}/dropbox_scanner.py

@@ -3,7 +3,7 @@ from bs4 import Tag
 from httpx import URL
 
 from qcanvas import db as db
-from qcanvas.util.linkscanner import ResourceScanner
+from qcanvas.util.link_scanner import ResourceScanner
 
 
 # from httpx import URL

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/qcanvas/util/task_pool.py

@@ -225,9 +225,9 @@ class TaskPool(Generic[T]):
 
         return list(filter(filter_func, self._results.values()))
 
-    def get_completed_result(self, task_id: object) -> T | None:
+    def get_completed_result_or_nothing(self, task_id: object, default: T | None = None) -> T | None:
         """
-        Returns the result of an already completed task
+        Returns the result of an already completed task, or nothing at all if result with that id exists or is still in progress
 
         Returns
         -------
@@ -246,8 +246,8 @@ class TaskPool(Generic[T]):
             result = self._results[task_id]
 
             if isinstance(result, asyncio.Event):
-                raise ValueError(f"{task_id} is still in progress")
+                return None
 
             return result
         else:
-            raise KeyError(f"{task_id} has not been started")
+            return None

{qcanvas-0.0.5.1a0 → qcanvas-0.0.5.3a0}/requirements.txt

@@ -10,6 +10,6 @@ beautifulsoup4~=4.12.3
 qenerate-custom~=0.6.3
 aiosqlite-custom~=0.19.0
 qasync~=0.27.1
-bs4~=0.0.1
+beautifulsoup4~=4.12.3
 pyqtdarktheme~=2.1.0
 packaging~=23.2