pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/services/project_updater.py

@@ -0,0 +1,149 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`project_updater`
+Defines the ProjectUpdater class, which enables the project to be updated
+"""
+import inspect
+from threading import Lock
+
+from PyQt5.QtCore import QObject, pyqtSignal, QEvent, QSemaphore, QThread
+from PyQt5.QtWidgets import QApplication
+
+def _check_attribute(name, fields, project):
+    if not name in fields:
+        raise ValueError(f'Could not access property {name} of project {type(project)}')
+
+
+class ProjectProxy:
+    _storage = {}
+
+    def __init__(self, project):
+        ProjectProxy._storage[self] = {}
+        ProjectProxy._storage[self]['_fields'] = []
+        for name, obj in inspect.getmembers(type(project)):
+            if inspect.isdatadescriptor(obj):
+                ProjectProxy._storage[self]['_fields'].append(name)
+        ProjectProxy._storage[self]['_updates'] = {}
+        ProjectProxy._storage[self]['_project'] = project
+    
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        del ProjectProxy._storage[self]
+
+    def __setattr__(self, name, value):
+        _check_attribute(name, ProjectProxy._storage[self]['_fields'], ProjectProxy._storage[self]['_project'])
+        ProjectProxy._storage[self]['_updates'][name] = value
+
+    def __getattribute__(self, name):
+        if name == 'updates':
+            return ProjectProxy._storage[self]['_updates']
+        _check_attribute(name, ProjectProxy._storage[self]['_fields'], ProjectProxy._storage[self]['_project'])
+        return getattr(ProjectProxy._storage[self]['_project'], name)
+
+
+class PropertyUpdatedEvent(QEvent):
+    def __init__(self, prop):
+        super().__init__(QEvent.User)
+        self._prop = prop
+    
+    @property
+    def prop(self):
+        return self._prop
+
+class UpdateCompleteEvent(QEvent):
+    def __init__(self, handler, result):
+        super().__init__(QEvent.User)
+        self._handler = handler
+        self._result = result
+    
+    def exec(self):
+        self._handler(self._result)
+
+class UpdateEvent(QEvent):
+    def __init__(self, updater):
+        super().__init__(QEvent.User)
+        self._updater = updater
+        self._result = None
+        self._semaphore = QSemaphore(1)
+        if QApplication.instance().thread() != QThread.currentThread():
+            self._semaphore.acquire()
+    
+    def exec(self):
+        try:
+            self._result = self._updater(None)
+        finally:
+            self._semaphore.release()
+    
+    def result(self):
+        self._semaphore.acquire()
+        return self._result
+
+class ProjectUpdater(QObject):
+    """class::ProjectUpdater
+    Allows the project to be updated
+    """
+    def __init__(self, project_manager):
+        QObject.__init__(self, project_manager)
+        self._project_manager = project_manager
+        self._is_dirty = False
+        self._lock = Lock()
+
+    projectUpdated = pyqtSignal(str)
+
+    @property
+    def dirty(self):
+        return self._is_dirty
+
+    @dirty.setter
+    def dirty(self, value):
+        self._is_dirty = value
+    
+    @property
+    def update_lock(self):
+        return self._lock
+
+    def update_project(self, update_function, updated_properties=None, on_completed=None):
+        """function::update_project(self, update_function)
+        Calls the update_function to perform the desired updates
+        """
+        self.dirty = True
+        result = update_function(None)
+        if updated_properties:
+            for prop in updated_properties:
+                self._on_project_updated(prop)
+        else:
+            self._on_project_updated(None)
+        if on_completed:
+            QApplication.postEvent(self, UpdateCompleteEvent(on_completed, result))
+    
+    def _on_project_updated(self, prop):
+        QApplication.postEvent(self, PropertyUpdatedEvent(prop))
+    
+    def event(self, event):
+        if isinstance(event, PropertyUpdatedEvent):
+            self.projectUpdated.emit(event.prop)
+            return True
+        if isinstance(event, UpdateCompleteEvent):
+            event.exec()
+            return True
+        if isinstance(event, UpdateEvent):
+            with self.update_lock:
+                event.exec()
+            return True
+        return super().event(event)

pyqttoolkit/services/task_runner.py

@@ -0,0 +1,281 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`task_runner`
+Defines the task runner
+"""
+import logging
+import inspect
+
+from PyQt5.QtCore import QObject, pyqtSignal, QEvent
+from PyQt5.QtWidgets import QApplication
+
+from concurrent.futures import ThreadPoolExecutor
+
+from ..properties import AutoProperty
+from ..exceptions import TaskCancelled
+
+LOGGER = logging.getLogger(__name__)
+
+class BusyArgs(QObject):
+    def __init__(self, busy, indeterminate=True, cancellable=False, description=None):
+        QObject.__init__(self, None)
+        self._busy = busy
+        self._indeterminate = indeterminate
+        self._cancellable = cancellable
+        self._description = description
+        self._progress = 0
+    
+    cancelled = pyqtSignal()
+    cancelComplete = pyqtSignal()
+    progressChanged = pyqtSignal(float, str)
+
+    @property
+    def description(self):
+        return self._description
+
+    @property
+    def progress(self):
+        return self._progress
+
+    def updateProgress(self, progress, description):
+        self._progress = max(99, float(progress))
+        self._description = description
+        self.progressChanged.emit(progress, description)
+
+    @property
+    def busy(self):
+        return self._busy
+
+    @property
+    def indeterminate(self):
+        return self._indeterminate
+    
+    @property
+    def cancellable(self):
+        return self._cancellable
+    
+    def cancel(self):
+        if self._cancellable:
+            self.cancelled.emit()
+
+
+class Worker:
+    def __init__(self, task_runner, f, args, busy_args, on_completed, on_cancelled, on_error, error_description):
+        self._task_runner = task_runner
+        self._f = f
+        self._args = args
+        self._busy_args = busy_args
+        self._on_completed = on_completed
+        self._on_cancelled = on_cancelled
+        self._on_error = on_error
+        self._error_description = error_description
+    
+    def run(self):
+        if self._busy_args:
+            QApplication.postEvent(self._task_runner, BusyEvent(self._busy_args))
+        try:
+            result = self._f(*self._args.args, **self._args.kwargs)
+        except TaskCancelled:
+            QApplication.postEvent(self._task_runner, CancelledEvent(self._on_cancelled))
+        #pylint: disable=broad-except
+        except Exception as e:
+            QApplication.postEvent(self._task_runner, ErrorEvent(e, self._on_error, self._error_description))
+        #pylint: enable=broad-except
+        else:
+            QApplication.postEvent(self._task_runner, ResultEvent(result, self._on_completed))
+
+class ProgressUpdatedEvent(QEvent):
+    def __init__(self, progress, message):
+        super().__init__(QEvent.User)
+        self._progress = progress
+        self._message = message
+    
+    @property
+    def progress(self):
+        return self._progress
+    
+    @property
+    def message(self):
+        return self._message
+
+class CancelledEvent(QEvent):
+    def __init__(self, on_cancelled):
+        super().__init__(QEvent.User)
+        self._on_cancelled = on_cancelled
+    
+    @property
+    def on_cancelled(self):
+        return self._on_cancelled
+
+class ResultEvent(QEvent):
+    def __init__(self, result, on_completed=None):
+        super().__init__(QEvent.User)
+        self._result = result
+        self._on_completed = on_completed
+    
+    @property
+    def result(self):
+        return self._result
+    
+    @property
+    def on_completed(self):
+        return self._on_completed
+
+class ErrorEvent(QEvent):
+    def __init__(self, exception, on_error, error_description):
+        super().__init__(QEvent.User)
+        self._exception = exception
+        self._on_error = on_error
+        self._error_description = error_description
+    
+    @property
+    def exception(self):
+        return self._exception
+    
+    @property
+    def on_error(self):
+        return self._on_error
+    
+    @property
+    def error_description(self):
+        return self._error_description
+
+class BusyEvent(QEvent):
+    def __init__(self, busy_args):
+        super().__init__(QEvent.User)
+        self._busy_args = busy_args
+    
+    @property
+    def args(self):
+        return self._busy_args
+
+class TaskArgs:
+    def __init__(self, args, kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+class TaskRunner(QObject):
+    """class::TaskRunner
+    Runs tasks on a background thread
+    """
+    def __init__(self, parent):
+        QObject.__init__(self, parent)
+        self._is_cancelled = False
+        self._executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix='TaskRunner_Thread')
+
+    def shutdown(self, wait=True):
+        # Tests and short-lived apps need an explicit way to join worker
+        # threads before QApplication teardown.
+        self._executor.shutdown(wait=wait)
+
+    def run_task(self, task_function, task_args=None, on_completed=None, on_cancelled=None, on_error=None, description=None, error_description=None, show_progress=True, cancellable=False, force_indeterminate_start=False, **kwargs):
+        """function::runTask(self, task_function, task_args, on_completed, on_error)
+        :param task_function: The function to execute
+        :param task_args: The arguments to pass to the function
+        :param on_completed: The function to execute when the task completes
+        :param on_error: The function to execute when the task errors
+        """
+        LOGGER.info('Starting task "%s"...', description)
+        task_args = task_args or []
+
+        kwargs = {}
+
+        parameters = inspect.signature(task_function).parameters
+
+        if 'update_progress' in parameters:
+            kwargs['update_progress'] = self.update_progress
+            indeterminate = force_indeterminate_start
+        else:
+            indeterminate = True
+
+        busy_args = BusyArgs(True, indeterminate, cancellable, description) if show_progress else None
+
+        worker = Worker(
+            self, task_function, TaskArgs(task_args, kwargs),
+            busy_args=busy_args, on_completed=on_completed,
+            on_cancelled=on_cancelled, on_error=on_error,
+            error_description=error_description
+        )
+        self._executor.submit(worker.run)
+    
+    def update_progress(self, percent, message):
+        QApplication.postEvent(self, ProgressUpdatedEvent(float(percent), message))
+    
+    def event(self, event):
+        if isinstance(event, ProgressUpdatedEvent):
+            if self.busy is not None:
+                self.busy.updateProgress(float(event.progress), event.message)
+            return True
+        elif isinstance(event, BusyEvent):
+            self.busy = event.args
+            self.busy.cancelled.connect(self.cancel)
+            return True
+        elif isinstance(event, ResultEvent):
+            LOGGER.info('Task complete')
+            self.reset()
+            if event.on_completed is not None:
+                event.on_completed(event.result)
+            self.taskCompleted.emit()
+            return True
+        elif isinstance(event, CancelledEvent):
+            LOGGER.info('Task cancelled')
+            self.reset()
+            self.busy.cancelComplete.emit()
+            self.taskCancelled.emit()
+            if event.on_cancelled is not None:
+                event.on_cancelled()
+            return True
+        elif isinstance(event, ErrorEvent):
+            LOGGER.info('Task error')
+            self.reset()
+            LOGGER.info('Error running task: %s', event.exception)
+            if event.error_description is not None:
+                self.error.emit(event.error_description)
+                self.taskErrored.emit()
+            elif event.on_error is not None:
+                event.on_error(event.exception)
+                self.taskErrored.emit()
+            else:
+                raise event.exception
+            return True
+        return super().event(event)
+    
+    def cancel(self):
+        if not self._is_cancelled:
+            if self.busy:
+                self.busy.updateProgress(self.busy.progress, self.tr('Cancelling...'))
+            self._is_cancelled = True
+    
+    def isCancelled(self):
+        return self._is_cancelled
+    
+    def raiseForCancelled(self):
+        if self._is_cancelled:
+            raise TaskCancelled()
+
+    def reset(self):
+        self.busy = BusyArgs(False, description=None)
+        self._is_cancelled = False
+    
+    busyChanged = pyqtSignal(BusyArgs)
+    error = pyqtSignal(str)
+    cancelComplete = pyqtSignal()
+    taskCompleted = pyqtSignal()
+    taskCancelled = pyqtSignal()
+    taskErrored = pyqtSignal()
+
+    busy = AutoProperty(BusyArgs)

pyqttoolkit/services/theme_manager.py

@@ -0,0 +1,46 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class ThemeManager:
+    default_theme = {
+        'button_foreground': (0, 0, 0),
+        'button_background_hover': (255, 255, 255),
+        'highlight': (255, 96, 154),
+        'highlight_hover': (255, 163, 196),
+        'highlight_pressed': (255, 147, 186),
+        'highlight': (255, 96, 154),
+        'module_background': (200, 200, 200),
+        'module_text': (0, 0, 0)
+    }
+
+    def __init__(self, application_configuration):
+        self._config = application_configuration
+    
+    def get_color(self, key):
+        selected_theme = self._get_selected_theme()
+        color = self._config.get_value(f'application.themes.{selected_theme}.{key}') if selected_theme else None
+        return tuple(color) if color else self.default_theme.get(key)
+    
+    def _get_selected_theme(self):
+        return self._config.get_value(f'application.themes.selected_theme') or None
+
+    @staticmethod
+    def get(widget):
+        while widget is not None and not hasattr(widget, 'themeManager'):
+            widget = widget.parent()
+        if widget is not None and hasattr(widget, 'themeManager'):
+            return widget.themeManager
+        return None

pyqttoolkit/services/tool_window_service.py

@@ -0,0 +1,46 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+from PyQt5.QtWidgets import QWidget
+
+from pyqttoolkit.views import ToolWindow
+from pyqttoolkit.viewmanagers import ToolViewManager
+
+class ToolWindowService:
+    def __init__(self, dependency_contianer):
+        self._dependency_container = dependency_contianer
+        self._active_tools = []
+    
+    def open(self, parent, model, name, *args, extras=None):
+        extras = {'parent': None, **(extras or {})}
+        view = self._dependency_container.resolve_for(type(model), QWidget, extras, *args)
+        if hasattr(model, 'showButtons'):
+            show_buttons = model.showButtons
+        else:
+            show_buttons = True
+
+        tool_window = ToolWindow(parent, view, name, show_buttons)
+        view_manager = self._dependency_container.resolve_for(type(model), ToolViewManager, {'view': view, 'model': model})
+        tool_window.accepted.connect(self._tool_window_accepted(tool_window, view_manager))
+        self._active_tools.append((tool_window, view_manager))
+        tool_window.show()
+
+    def _tool_window_accepted(self, tool_window, view_manager):
+        def _handler():
+            view_manager.save()
+            self._active_tools.remove((tool_window, view_manager))
+        return _handler

pyqttoolkit/viewmanagers/__init__.py

@@ -0,0 +1,17 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from .tool import ToolViewManager

pyqttoolkit/viewmanagers/tool.py

@@ -0,0 +1,23 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class ToolViewManager:
+    def __init__(self, view, model):
+        self._view = view
+        self._model = model
+    
+    def save(self):
+        raise NotImplementedError()

pyqttoolkit/views/__init__.py

@@ -0,0 +1,50 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`components`
+Components module
+"""
+from .modulewindow import ModuleWindow
+from .editable_combo_box import EditableComboBox
+from .shrunk_push_button import ShrunkPushButton, VShrunkPushButton
+from .tool_window import ToolWindow
+from .combo_box import ComboBox, BindableComboBox, typed_bindable_combo_box
+from .steppable_combo_box import SteppableComboBox
+from .linkable import LinkableWidget
+from .datetime import DateTimeEdit
+from .line_edit import LineEdit, BindableLineEdit
+from .table import TableView
+from .property_tree import PropertyTreeView
+from .json_edit import JsonEdit
+from .file_selector import FileSelector
+from .code import CodeEdit, PythonCodeEdit
+from .text_edit import TextEdit
+from .metadata_selector import MetadataSelector, MetadataSelectorDropDown
+from .default_text_line_edit import DefaultTextLineEdit
+from .icon_button import IconButton, BindableIconButton
+from .main_window import MainWindow
+from .icon import Icon
+from .dtype_edit import FloatEdit, IntEdit, InfFloatLineEdit, AutoFloatLineEdit
+from .check_box import BindableCheckBox
+from .bulk_value_selector import BulkValueSelectorWidget
+from .datetime_range_selector import DatetimeRangeSelectorWidget
+from .count_selector import CountSelectorWidget
+from .list_view import ListView
+from .styleable import make_styleable
+from .popout import PopoutWidget
+from .popup import Popup
+from .delegates import ComboBoxItemDelegate, DateTimeItemDelegate, BulkValueSelectorItemDelegate
+from .labelled import make_labelled