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

qcanvas/util/task_pool.py

@@ -1,253 +0,0 @@
-import asyncio
-import logging
-from typing import TypeVar, Generic, Callable
-
-T = TypeVar("T")
-
-
-class TaskPool(Generic[T]):
-    """
-    A TaskPool is a utility that receives submitted tasks which have an identity and which should be executed no more
-    than once. It can be configured to wait for the task to finish when started, wait for the task to finish when it
-    is in progress, and record the result of the task when it finishes and return it when a task with the same ID is
-    submitted again.
-    """
-
-    _logger = logging.getLogger(__name__)
-
-    def __init__(self, remember_result: bool = True, wait_if_in_progress: bool = True,
-                 wait_if_just_started: bool = True, restart_if_finished: bool = False):
-        """
-        Parameters
-        ----------
-        remember_result : bool
-            Whether to store the result of submitted tasks
-
-        wait_if_just_started : bool
-            Whether to await a newly started task or return immediately
-
-        wait_if_in_progress : bool
-            Whether to await a task that is in progress or return immediately
-        """
-
-        if not wait_if_in_progress and remember_result:
-            raise ValueError("Can't remember result without waiting")
-
-        self._results: dict[object, asyncio.Event | T | None] = {}
-        self._semaphore = asyncio.Semaphore()
-        self._remember_result: bool = remember_result
-        self._wait_if_in_progress: bool = wait_if_in_progress
-        self._wait_if_just_started: bool = wait_if_just_started
-        self._restart_if_finished: bool = restart_if_finished
-
-    def add_values(self, results: dict[object, T]) -> None:
-        """
-        Adds the specified values from the dictionary as stored results.
-
-        Parameters
-        ----------
-        results
-            The results to store, where the key is the ID and the value is the result
-
-        Returns
-        -------
-            None
-        """
-        self._results.update(**results)
-
-    async def submit(self, task_id: object, func, **kwargs) -> T | None:
-        """
-        Submits a task and executes it. Depending on configuration, waits for it and returns the result of it.
-
-        Parameters
-        ----------
-        task_id: object
-            The identity of the task. E.g. "task_get_file_1" or "task_get_file_2"
-
-        func : lambda
-            The function to execute.
-            Should be provided in the form of a lambda which executes some async function without using the await keyword.
-            E.g::
-                # Right
-                taskpool.submit(..., func=lambda: some_async_function(some_val))
-                # Wrong
-                taskpool.submit(..., func=lambda: async some_async_function(some_val))
-                #                                 ^^^^^
-        kwargs
-            Extra arguments for the lambda
-        Returns
-        -------
-        T | None
-            None, if the configuration states that we should not wait for the function to finish or not to remember the result.
-            Returns the result of the function otherwise.
-        """
-        sem = self._semaphore
-        await sem.acquire()
-
-        if task_id in self._results.keys():
-            if not self._wait_if_in_progress and isinstance(self._results[task_id], asyncio.Event):
-                self._logger.debug("Task %s in progress but configured to not wait, returning None.", task_id)
-                sem.release()
-                return None
-
-            if not isinstance(self._results[task_id], asyncio.Event):
-                if self._restart_if_finished:
-                    self._logger.debug("Task %s already finished but configured to restart if finished, restarting.",
-                                       task_id)
-                    # start_task releases the semaphore, no need to do it here
-                    return await self._start_task(task_id, func, **kwargs)
-
-                self._logger.debug("Task %s already finished, returning.", task_id)
-                sem.release()
-                return self._results[task_id]
-
-            self._logger.debug("Task %s in progress. Waiting.", task_id)
-
-            event: asyncio.Event = self._results[task_id]
-            sem.release()
-
-            await event.wait()
-
-            self._logger.debug("Finished waiting for %s.", task_id)
-
-            return self._results[task_id]
-        else:
-            # start_task releases the semaphore, no need to do it here
-            return await self._start_task(task_id, func, **kwargs)
-
-    async def _start_task(self, task_id: object, func, **kwargs):
-        """
-        Starts a task and **releases the results list semaphore**
-
-        Parameters
-        ----------
-        task
-            The task to start
-        task_id
-            The ID of the task
-        event
-            The event that the task is attached to
-
-        Returns
-        -------
-        T
-            The result of the task
-        """
-        sem = self._semaphore
-
-        self._logger.debug("Task %s started.", task_id)
-
-        event = asyncio.Event()
-        self._results[task_id] = event
-        sem.release()
-
-        if not self._wait_if_just_started:
-            # noinspection PyAsyncCall
-            asyncio.create_task(self._handle_task(func, task_id, event, func_args=kwargs))
-            return None
-
-        return await self._handle_task(func, task_id, event, func_args=kwargs)
-
-    async def _handle_task(self, func: Callable, task_id: object, event: asyncio.Event, func_args: dict) -> T:
-        """
-        Handles the specified task
-
-        Parameters
-        ----------
-        func
-            The task to handle
-        task_id
-            The ID of the task
-        event
-            The event that the task is attached to
-
-        Returns
-        -------
-        T
-            The result of the task
-        """
-        sem = self._semaphore
-
-        result = await func(**func_args)
-
-        if isinstance(result, asyncio.Event):
-            self._logger.warning("Result was of type asyncio.Event, this will break things!")
-
-        async with sem:
-            self._logger.debug("Task %s finished", task_id)
-            # Record this task as done, storing the result if configured to
-            self._results[task_id] = result if self._remember_result else None
-            event.set()
-
-        return result
-
-    async def wait_if_in_progress(self, task_id: object):
-        """
-        Waits for a task if it is in progress. Returns immediately otherwise.
-
-        Parameters
-        ----------
-        task_id
-            The task id to wait for
-        """
-        sem = self._semaphore
-
-        await sem.acquire()
-
-        if task_id in self._results and isinstance(self._results[task_id], asyncio.Event):
-            event: asyncio.Event = self._results[task_id]
-            sem.release()
-
-            await event.wait()
-
-    def clear(self) -> None:
-        """
-        Deletes the stored results
-
-        Returns
-        -------
-        None
-        """
-        self._results.clear()
-
-    def results(self) -> list[T]:
-        """
-        Gets the results of all currently completed tasks
-
-        Returns
-        -------
-        list[T]
-            The results of all currently completed tasks, excluding Nones
-        """
-
-        def filter_func(it):
-            return not isinstance(it, asyncio.Event) and it is not None
-
-        return list(filter(filter_func, self._results.values()))
-
-    def get_completed_result_or_nothing(self, task_id: object, default: T | None = None) -> T | None:
-        """
-        Returns the result of an already completed task, or nothing at all if result with that id exists or is still in progress
-
-        Returns
-        -------
-        object
-            The result of the task
-
-        Raises
-        ------
-        ValueError
-            If the task is still in progress
-
-        KeyError
-            If the task has not been started yet or does not exist
-        """
-        if task_id in self._results:
-            result = self._results[task_id]
-
-            if isinstance(result, asyncio.Event):
-                return None
-
-            return result
-        else:
-            return None

qcanvas/util/tree_util/__init__.py

@@ -1,3 +0,0 @@
-from .expanding_tree import ExpandingTreeView
-from .model_helpers import HasColumnData, HasParent, HasChildren, HasText
-from .tree_model import TreeModel

qcanvas/util/tree_util/expanding_tree.py

@@ -1,165 +0,0 @@
-from typing import Any, TypeVar, Sequence, Optional
-
-from PySide6.QtCore import QModelIndex, Slot, QItemSelectionModel
-from PySide6.QtWidgets import QTreeView, QWidget
-
-from .model_helpers import HasChildren, HasParent
-from .tree_model import TreeModel
-
-T = TypeVar("T")
-
-
-class ExpandingTreeView(QTreeView):
-    """
-    Provides a way to retain the collapsed or expanded state of tree items after a model reset. Expects the tree's
-    model to implement `AbstractItemModelHasListRoot` and any children to implement `HasChildren`. Also provides
-    some methods that can be used to get a model index for an arbitrary object in a tree. These will NOT work when
-    duplicate objects are present in the tree. Does NOT support multi-selection.
-    """
-
-    def __init__(self, parent: Optional[QWidget] = None):
-        """
-        Constructor
-        :param session_factory: The session that will be used to update an item's expanded/collapsed state when it is changed
-        :param parent: The parent of this treeview
-        """
-        super().__init__(parent)
-        self._connect_expanded_listeners()
-
-    def reexpand(self) -> None:
-        """
-        Re-expands all items in the tree that have children based on their saved collapsed/expanded state.
-        """
-        self._disconnect_expanded_listeners()
-
-        try:
-            root: Sequence[Any] = self.model().get_root()
-
-            # Go through every item in the root and reexpand it and any children it has
-            for index, item in enumerate(root):
-                if isinstance(item, HasChildren):
-                    self._reexpand_recur(item, self.model().index(index, 0, QModelIndex()))
-        finally:
-            self._connect_expanded_listeners()
-
-    def _connect_expanded_listeners(self):
-        self.expanded.connect(self.tree_item_expanded)
-        self.collapsed.connect(self.tree_item_collapsed)
-
-    def _disconnect_expanded_listeners(self):
-        self.expanded.disconnect(self.tree_item_expanded)
-        self.collapsed.disconnect(self.tree_item_collapsed)
-
-    def _reexpand_recur(self, item: HasChildren, index: QModelIndex) -> None:
-        """
-        Internal function to expand an item in the tree. Recurs to any children it has.
-        :param item: The object to expand in the tree
-        :param index: The index of that object
-        """
-        # Sanity check
-        if not isinstance(item, HasChildren):
-            raise TypeError("item must be an instance of HasChildren")
-
-        # Expand this item
-        self.setExpanded(index, not item.collapsed)
-
-        for child_index, child in enumerate(item.get_children()):
-            # Check if the child item can also have children and be collapsed. Also check that it actually has
-            # any children.
-            if isinstance(child, HasChildren) and len(child.get_children()) > 0:
-                # Expand it and any children it has
-                self._reexpand_recur(child, self.model().index(child_index, 0, index))
-
-    @Slot()
-    def tree_item_expanded(self, index: QModelIndex) -> None:
-        """
-        Slot that is connected to the tree's `expanded` signal
-        :param index: The index that has been expanded
-        """
-        item = self.model().get_item(index)
-
-        # Update the item's state
-        if isinstance(item, HasChildren):
-            item.collapsed = False
-
-    @Slot()
-    def tree_item_collapsed(self, index: QModelIndex) -> None:
-        """
-        Slot that is connected to the tree's `collapsed` signal
-        :param index: The index that was collapsed
-        """
-        item = self.model().get_item(index)
-
-        # Update the item's state
-        if isinstance(item, HasChildren):
-            item.collapsed = True
-
-    def get_path_of_indexes_for_item(self, item: Any) -> list[int]:
-        """
-        Gets the path of numerical indexes for an arbitrary object in a tree.
-        For example, second child of the first item would be [0, 1].
-
-        :param item: The item to find the path for. The item must belong to the tree
-        :return: The path to the item as a list of indexes to follow
-        """
-        path: list[int] = []
-
-        # Keep going until we reach the root
-        while isinstance(item, HasParent) and item.parent is not None:
-            # Add the index of the item to the path and then go to the parent of that child until there is no parent
-            path.insert(0, item.index_of_self)
-            item = item.parent
-
-        # Insert the index of the item belonging to the root list to the path
-        path.insert(0, self.model().get_root().index(item))
-
-        return path
-
-    def select_object(self, item: Any) -> None:
-        """
-        Selects an arbitrary item that belongs to the tree. Will not work for branches that have duplicate items.
-        :param item: The item to select. Must belong to the tree
-        """
-        self.select_item_by_path(self.get_path_of_indexes_for_item(item))
-
-    def select_item_by_path(self, item_path: list) -> None:
-        """
-        Selects an item based on its path
-        :param item_path: The path of the item
-        """
-        selection_model = self.selectionModel()
-
-        # Convert the path to a model index
-        # Clear previous selection and select the whole row
-        selection_model.select(self.get_model_index_for_path(item_path),
-                               QItemSelectionModel.SelectionFlag.ClearAndSelect | QItemSelectionModel.SelectionFlag.Rows)
-
-    def get_model_index_for_path(self, item_path: list[int]) -> QModelIndex:
-        """
-        Converts an item's path into a QModelIndex
-        :param item_path: The path of the item to convert
-        :return: The path as a QModelIndex
-        """
-        model: TreeModel[Any] = self.model()
-        # Get the first index
-        item_index = item_path.pop(0)
-        # Create the base QModelIndex
-        model_index = model.index(item_index, 0, QModelIndex())
-        # Get the children of the first item
-        children = model.get_root()[item_index]
-
-        while len(item_path) > 0:
-            # Get the next item
-            item_index = item_path.pop(0)
-            # Update the QModelIndex
-            model_index = model.index(item_index, 0, model_index)
-
-            if len(item_path) > 0:
-                # Sanity check
-                if not isinstance(children, HasChildren):
-                    raise TypeError("Parent object does not have any children but a child was expected")
-
-                # Go to the children of this child next
-                children = children.children[item_index]
-
-        return model_index

qcanvas/util/tree_util/model_helpers.py

@@ -1,36 +0,0 @@
-from typing import Sequence, Any
-
-
-class HasColumnData:
-    def get_column_data(self, column: int, role: int) -> str | None:
-        raise NotImplementedError()
-
-
-class HasText:
-    @property
-    def text(self) -> str:
-        raise NotImplementedError()
-
-
-class HasParent:
-    @property
-    def parent(self) -> Any:
-        raise NotImplementedError()
-
-    @property
-    def index_of_self(self) -> int:
-        raise NotImplementedError()
-
-
-class HasChildren:
-    @property
-    def collapsed(self) -> bool:
-        raise NotImplementedError()
-
-    @collapsed.setter
-    def collapsed(self, value: bool):
-        raise NotImplementedError()
-
-    @property
-    def children(self) -> Sequence[HasColumnData]:
-        raise NotImplementedError()

qcanvas/util/tree_util/tree_model.py

@@ -1,85 +0,0 @@
-from typing import Any, Sequence, TypeVar, Generic, Optional
-
-from PySide6.QtCore import QAbstractItemModel, QModelIndex, QPersistentModelIndex
-from PySide6.QtWidgets import QWidget
-
-from .model_helpers import HasColumnData, HasParent, HasChildren
-
-T = TypeVar("T")
-
-
-# todo comment this
-class TreeModel(QAbstractItemModel, Generic[T]):
-    def __init__(self, parent: Optional[QWidget] = None):
-        super().__init__(parent)
-        self.root: Sequence[T] = []
-
-    def get_item(self, index: QModelIndex | QPersistentModelIndex) -> object:
-        if index.isValid():
-            return index.internalPointer()
-
-        return self.root
-
-    def data(self, index: QModelIndex | QPersistentModelIndex, role: int = ...) -> Any:
-        if not index.isValid():
-            return None
-
-        item = self.get_item(index)
-
-        if isinstance(item, HasColumnData):
-            return item.get_column_data(index.column(), role)
-        else:
-            return None
-
-    def index(self, row: int, column: int, parent: QModelIndex | QPersistentModelIndex = ...) -> QModelIndex:
-        if parent.isValid() and parent.column() != 0:
-            return QModelIndex()
-
-        parent_item = self.get_item(parent)
-
-        if isinstance(parent_item, HasChildren):
-            parent_list = parent_item.children
-        elif isinstance(parent_item, Sequence):
-            parent_list = parent_item
-        else:
-            raise TypeError(
-                f"Expected parent of item to be Sequence or HasChildren, actually {parent_item.__class__}")
-
-        if row > len(parent_list) or row < 0:
-            return QModelIndex()
-
-        return self.createIndex(row, column, parent_list[row])
-
-    def parent(self, child: QModelIndex | QPersistentModelIndex = QModelIndex()) -> QModelIndex:
-        if not child.isValid():
-            return QModelIndex()
-
-        child_item = self.get_item(child)
-
-        # We don't need to handle the root items here because... they are the root and have no parents
-
-        if isinstance(child_item, HasParent) and child_item.parent is not None:
-            return self.createIndex(child_item.index_of_self, 0, child_item.parent)
-
-        return QModelIndex()
-
-    def rowCount(self, parent: QModelIndex | QPersistentModelIndex = QModelIndex()) -> int:
-        if parent.isValid() and parent.column() > 0:
-            return 0
-
-        parent_item = self.get_item(parent)
-
-        if isinstance(parent_item, HasChildren):
-            return len(parent_item.children)
-        elif isinstance(parent_item, Sequence):
-            return len(parent_item)
-        else:
-            return 0
-
-    def get_root(self) -> Sequence[T]:
-        """
-        Returns the list of root level items (i.e. items which have no parents) for the tree
-        :return: List of root level items (i.e. items which have no parents) for the tree
-        :return: List of root level items (i.e. items which have no parents) for the tree
-        """
-        return self.root

qcanvas-0.0.5.7a0.dist-info/METADATA

@@ -1,21 +0,0 @@
-Metadata-Version: 2.1
-Name: qcanvas
-Version: 0.0.5.7a0
-Summary: A canvas client
-Author: QCanvas
-Classifier: Operating System :: OS Independent
-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: gql~=3.6.0b0
-Requires-Dist: httpx~=0.26.0
-Requires-Dist: packaging~=23.2
-Requires-Dist: pydantic~=2.6.0
-Requires-Dist: pyqtdarktheme~=2.1.0
-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: sqlalchemy~=2.0.25
-Requires-Dist: tenacity~=8.2.3

qcanvas-0.0.5.7a0.dist-info/RECORD

@@ -1,62 +0,0 @@
-qcanvas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/__main__.py,sha256=FOj1TahcG6GSDppkpe09X2Grddc0sXu5Ql5YUABbG5w,5192
-qcanvas/db/__init__.py,sha256=j5ZiTiLuY0CYRUV2bktc8qE5x-jBNaSaSVNKAF8DKF0,420
-qcanvas/db/database.py,sha256=jKSExpMuq1x7GppeDW2mRHJznLGHeexf76wgvnBnNWQ,10557
-qcanvas/db/db_converter_helper.py,sha256=-Rpe4CvMJBmvYXLw68caJWwEMPvxsYJB800Z8vHyqX4,2169
-qcanvas/icons/__init__.py,sha256=nknAcvd97UBIYO1dR4atTCY3PHudbPprPT7FPyhqugc,35
-qcanvas/icons/icons.qrc,sha256=_wGNdTTOuygPLeFMJxA3Q2HleqJKKkzW38VEhWJ76Rg,110
-qcanvas/icons/main_icon.svg,sha256=26moo6Ki_YSkazCgOZgs4pi2p4qWNLDIWugwLMfAWfs,16104
-qcanvas/icons/rc_icons.py,sha256=F8TS5WzBbKdNOm3uARzOU0O2ODpOlh4OPIddp1B-1P4,10896
-qcanvas/icons/sync.svg,sha256=ArqfW_jH-eEjDnxyVPBBo2OOoDNja1OfN3KiptPs258,2835
-qcanvas/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/net/custom_httpx_async_transport.py,sha256=1OyszJO8TrwDrq-no-angb-AIjgq_GiV67tQHuPxmm0,1227
-qcanvas/net/self_authenticating.py,sha256=VkWpp7kxaWQHvqMjW9Dw-oY0aNFOT-6SYkJMnSvCdqU,4136
-qcanvas/net/canvas/__init__.py,sha256=EPLFN05Vx9yNHDLK-eUp97C6ymtMTnscwdn28OBlNJw,96
-qcanvas/net/canvas/canvas_client.py,sha256=yxhk3uxjkZFXkp-99Jmr7_GDqpa5OBtNBpQU6zQSGuc,8778
-qcanvas/net/canvas/legacy_canvas_types.py,sha256=pKuTBh1m5oSq9e7jmbHzYfKeoPSw0uHAqLwddKZpsr4,3942
-qcanvas/queries/__init__.py,sha256=tRUwMS1OvYIWRd4WpmAHrDrcelj_dLEaesxh9NngC6s,227
-qcanvas/queries/all_courses.gql,sha256=8U0_3VOcD66SRCfvhZ9IOTmxVgDPJdMD_LuGPbM9vVU,124
-qcanvas/queries/all_courses.py,sha256=-DpMy7eDFUeYp3ffZrwXp15qo_t6Lfx8K-rFi3OK1DM,2751
-qcanvas/queries/canvas_course_data.gql,sha256=KJHjdu5sMKld4L6mPGfUrhqRLx_wdgGH8fwTnmRFGrI,1115
-qcanvas/queries/canvas_course_data.py,sha256=_ZNv9stXAyap2eBbCqmajXVpWr0920ZUcCS6Gtyyo0g,4314
-qcanvas/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/ui/container_item.py,sha256=MNGL3Z6dNlM59XXWqmXB1Ql3FTOEdA6TY2K9Do1LmTE,285
-qcanvas/ui/main_ui.py,sha256=4OKDbY3l4f6lxOAiN6v9_yy1Ak1F8pyZ-lCySsqJABI,10219
-qcanvas/ui/setup_dialog.py,sha256=Rh9Zj595-OdPUN31cN8QcY5V2giQ3zPRUg65t6wQ-LY,7270
-qcanvas/ui/status_bar_reporter.py,sha256=uLX_C8r0augOSOwS-HCeDFxuSQKUJ8qYM5RE8kTKklU,1524
-qcanvas/ui/menu_bar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/ui/menu_bar/grouping_preferences_menu.py,sha256=nSe9qt3pI9WAiKVTOEtHN9JPW3gaDxpU8YiSGGRjR5M,2407
-qcanvas/ui/menu_bar/theme_selection_menu.py,sha256=WdcFMEO-FRYJm3qKjYbUpRhJPVe0-RhwrVxcyckSr0Q,1248
-qcanvas/ui/viewer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/ui/viewer/course_list.py,sha256=umJr_zUUPuL4sGNfcaiDl-Vsodned5egTxEydAKdiCw,3421
-qcanvas/ui/viewer/file_list.py,sha256=hqKXrLs4bLHA9himFEuE8d8Pq2TJnvuUGGJgZftiyrA,7869
-qcanvas/ui/viewer/file_view_tab.py,sha256=DrXwHwIPBoHVjsKU3zUbOvA4tTarp29d4cMYvZnE-O8,2205
-qcanvas/ui/viewer/page_list_viewer.py,sha256=FKFuqgy_yQPS_i3c0AbQk5E3mxtOfgYI7Q81mD28bLI,5678
-qcanvas/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/util/app_settings.py,sha256=G_aq-7FPXmV4pN0cM2VldFS1HwTIzofgezgXt0y-AQ0,3017
-qcanvas/util/constants.py,sha256=GNRlqG9rnWlW5ijKoJEsyuOWTdrXNSiWL_a5XeEZzI0,259
-qcanvas/util/download_pool.py,sha256=8MRzdxZMmCibMx1rwh0G8U2SPjITtvDieLyr8drhJ7c,2003
-qcanvas/util/progress_reporter.py,sha256=wgD8A_mrZ3EZQtrJeCYoQ0TvMIVtdFKDVNTQrbZMoDA,2934
-qcanvas/util/self_updater.py,sha256=oItk-J-CSN74RGu4P_xtJ4S8vGnaAZL23Bm4jpLbLzg,1655
-qcanvas/util/task_pool.py,sha256=NHrsgY8Srd4I9Iv3qqGLblF2RRqLqbLcYFgvnEGpvaY,8192
-qcanvas/util/course_indexer/__init__.py,sha256=IqwTfB8KVk7Go_yuBL8NOANgFiBCzjt0z38D4CEgq7w,38
-qcanvas/util/course_indexer/conversion_helpers.py,sha256=DZwx3Ct-MYzxQwuvqem5c2cARSkr_2SJvz0gaZDJq6c,2644
-qcanvas/util/course_indexer/data_manager.py,sha256=-bqw28YZNoq-BcT3LsJl5RZS5tTpgk85wmfR2bgSCPc,18872
-qcanvas/util/course_indexer/resource_helpers.py,sha256=htd3XnrnOEkS8iAxTqAIypgMzqJEcjs1Qte9wmF2ccQ,6966
-qcanvas/util/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qcanvas/util/helpers/canvas_sanitiser.py,sha256=c6r6cyJomQ1zn5wFK-LX-ZsZXQZ-A2awBFtCB_JqUtE,1184
-qcanvas/util/helpers/file_icon_helper.py,sha256=6Rgy5K5wB6Hofsx4Etu6JlurAJEqma32zOLWgRHTf48,925
-qcanvas/util/helpers/qaction_helper.py,sha256=lQ3eouIgR3w3o1jLNAmu2plAdc6HBBT5qaE4cnW6cX8,667
-qcanvas/util/helpers/theme_helper.py,sha256=_qnXIMSeuXW3a8mincehHRtJgTv2Rm93Q3y2N7dW3Zo,1290
-qcanvas/util/link_scanner/__init__.py,sha256=VVZ4L0AwC-TQtX6JQNUcpWH8UhKaCaSS3_7X4i3mipE,97
-qcanvas/util/link_scanner/canvas_link_scanner.py,sha256=M7_zc7AU2pI9RdR8AaC9cyEiNufnu6bNxu4qu7FaLns,1451
-qcanvas/util/link_scanner/canvas_media_object_scanner.py,sha256=8xnDtrdqxIzW-8JuoKXGUoB2usR6S8rzma_QB6rGzaI,2219
-qcanvas/util/link_scanner/dropbox_scanner.py,sha256=_xIOGpPH5voORGPGLCEXcQCWWf-PVSBg8MEm-hcIs3M,2034
-qcanvas/util/link_scanner/resource_scanner.py,sha256=EY5AzDXG6Ix18YpRkJcMjOPaygird6iD1akaG-yUyHc,1988
-qcanvas/util/tree_util/__init__.py,sha256=yqjNHrD8SiyW_fGPfw7xdS-Rctjdu-RMWSkUxcGSn8k,154
-qcanvas/util/tree_util/expanding_tree.py,sha256=5UM9kfcHtVavzAc9nwd7lucVnjI_dkVH8qC3GvmBvtc,6622
-qcanvas/util/tree_util/model_helpers.py,sha256=io1bHOMNgVqkPvGH2Iohug1-wx2MwC_-qlWlpVA0fFE,743
-qcanvas/util/tree_util/tree_model.py,sha256=JhlYmGqxlul8jUUQ-KtPXIehzgG-UtszHve7Wh-XbtE,2981
-qcanvas-0.0.5.7a0.dist-info/METADATA,sha256=y1oIx74ntPhF74IYe1uVsBwXWefTp9wNjpcV1QPrlgo,650
-qcanvas-0.0.5.7a0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-qcanvas-0.0.5.7a0.dist-info/RECORD,,