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

qcanvas/util/progress_reporter.py

@@ -1,101 +0,0 @@
-import itertools
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class ProgressSection:
-    """
-    Convenience class for reporting on a section of a larger task
-    """
-
-    def __init__(self, section_name: str, total_progress: int, reporter: "ProgressReporter"):
-        self.total_progress = total_progress
-        self.reporter = reporter
-        self._counter = itertools.count(1)  # Start at 1 instead of 0
-        self.reporter.section_started(section_name, total_progress)
-
-    def increment_progress(self, *args):
-        self.reporter.progress(next(self._counter), self.total_progress)
-
-
-class ProgressReporter(ABC):
-    """
-    A progress reporter is passed to a function which then uses it to report the progress for whatever task it performs to another place.
-    Only 1 section should be active at a time.
-    """
-
-    @abstractmethod
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        """
-        Signals that a new section of a task has started
-        Parameters
-        ----------
-        section_name
-            The name of the new task section
-        """
-        ...
-
-    @abstractmethod
-    def progress(self, current_progress: int, total_progress: int) -> None:
-        """
-        Updates the current progress of the current task
-        Parameters
-        ----------
-        current_progress
-            The current amount of progress, e.g. the number of bytes of a file that have been downloaded
-        total_progress
-            The total or final amount of progress, e.g. the size of a download
-        """
-        ...
-
-    @abstractmethod
-    def finished(self) -> None:
-        """
-        Signals that the task is finished and there is nothing left to do
-        """
-        ...
-
-    @abstractmethod
-    def errored(self, context: Any) -> None:
-        """
-        Signals that the task could not be completed
-        Parameters
-        ----------
-        context
-            Any information about why the task failed
-        """
-        ...
-
-    def section(self, section_name: str, total_progress: int) -> ProgressSection:
-        """
-        Creates a ProgressSection for this reporter, for reporting on a section of a larger task
-        Parameters
-        ----------
-        section_name
-            The name of the section
-        total_progress
-            The total or final amount of progress, e.g. the size of a download
-        Returns
-        -------
-        ProgressSection
-            The created section
-        """
-        return ProgressSection(section_name, total_progress, self)
-
-
-class _NoopReporter(ProgressReporter):
-
-    def section_started(self, section_name: str, total_progress: int) -> None:
-        pass
-
-    def progress(self, current_progress: int, total: int) -> None:
-        pass
-
-    def finished(self) -> None:
-        pass
-
-    def errored(self, context: Any) -> None:
-        pass
-
-
-noop_reporter = _NoopReporter()

qcanvas/util/self_updater.py

@@ -1,55 +0,0 @@
-import asyncio
-import json
-import os
-from importlib.metadata import version
-
-import httpx
-from packaging.version import Version
-
-from qcanvas.util.constants import package_name
-
-# When true, signals that the program should be restarted when it closes next
-restart_flag = False
-
-
-async def do_update() -> None:
-    """
-    Updates the qcanvas package and sets the restart flag.
-    The restart flag is passed back to the launcher script as a return code.
-    """
-    global restart_flag
-    await asyncio.to_thread(os.system, f"pip install --upgrade {package_name}")
-    restart_flag = True
-
-
-async def get_newer_version() -> tuple[Version | None, Version | None] | None:
-    """
-    Check for a newer version of qcanvas
-    Returns
-    -------
-    tuple
-        A tuple, where the first item is the latest version and the second item is the installed version. If the installed
-        version is up-to-date, then the first item is None
-    """
-    latest_version = await get_latest_version()
-    installed_version = Version(version(package_name))
-
-    print(f"latest = {latest_version}, installed = {installed_version}")
-
-    if installed_version < latest_version:
-        return latest_version, installed_version
-    else:
-        return None, installed_version
-
-
-async def get_latest_version() -> Version:
-    """
-    Retrieves the latest version of the package from pypi
-    Returns
-    -------
-    Version
-        The latest version of qcanvas on pypi
-    """
-    async with httpx.AsyncClient() as client:
-        data = json.loads((await client.get(f"https://pypi.org/pypi/{package_name}/json")).text)
-        return Version(data["info"]["version"])

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