rbeesoft 1.0.9__tar.gz → 2.0.1__tar.gz

rbeesoft-2.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: rbeesoft
+Version: 2.0.1
+Summary: 
+Author: Brecheisen
+Author-email: r.brecheisen@maastrichtuniversity.nl
+Requires-Python: >=3.11,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+
+# rbeesoft
+Python package with base classes for developing apps and webapps

rbeesoft-2.0.1/README.md

@@ -0,0 +1,2 @@
+# rbeesoft
+Python package with base classes for developing apps and webapps

rbeesoft-2.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "rbeesoft"
+version = "2.0.1"
+description = ""
+authors = [
+    {name = "Brecheisen", email = "r.brecheisen@maastrichtuniversity.nl"}
+]
+readme = "README.md"
+requires-python = ">=3.11,<3.12"
+dependencies = [
+]
+
+[tool.poetry]
+packages = [{include = "rbeesoft", from = "src"}]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.1"
+pyinstaller = "^6.17.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

rbeesoft-2.0.1/src/rbeesoft/app/core/processes/dummyprocess.py

@@ -0,0 +1,18 @@
+import time
+from rbeesoft.app.core.processes.process import Process
+
+
+class DummyProcess(Process):
+    def __init__(self):
+        super(DummyProcess, self).__init__()
+        self._n = 10
+
+    def execute(self):
+        out = []
+        for i in range(self._n):
+            if self.is_canceled():
+                return out
+            time.sleep(0.25)
+            out.append(i)
+            self.progress.emit(int((i+1)/self._n*100))
+        return out

rbeesoft-2.0.1/src/rbeesoft/app/core/processes/process.py

@@ -0,0 +1,64 @@
+from PySide6.QtCore import (
+    QObject, 
+    QThread, 
+    Signal, 
+    Slot,
+    QCoreApplication,
+)
+
+
+class Process(QObject):
+    progress = Signal(int)
+    finished = Signal(object)
+    failed = Signal(Exception)
+    started = Signal()
+    canceled = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._cancel = False
+        self._thread = None
+        self._main_thread = None
+
+    def name(self):
+        return self._name
+
+    def cancel(self):
+        self._cancel = True
+
+    def is_canceled(self) -> bool:
+        return self._cancel
+
+    def execute(self):
+        raise NotImplementedError
+
+    def start(self):
+        if self._thread is not None:
+            raise RuntimeError("Process already started")
+        self._main_thread = QCoreApplication.instance().thread()
+        self._thread = QThread()
+        self.moveToThread(self._thread)
+        self._thread.started.connect(self._run_internal)
+        self.finished.connect(self._thread.quit)
+        self.failed.connect(self._thread.quit)
+        self._thread.finished.connect(self._cleanup)
+        self._thread.start()
+
+    @Slot()
+    def _run_internal(self):
+        self.started.emit()
+        try:
+            if self._cancel:
+                self.canceled.emit()
+                self.finished.emit(None)
+                return
+            result = self.execute()
+            self.finished.emit(result)
+        except Exception as e:
+            self.failed.emit(e)
+
+    @Slot()
+    def _cleanup(self):
+        self.moveToThread(self._main_thread)
+        self._thread.deleteLater()
+        self._thread = None

rbeesoft-2.0.1/src/rbeesoft/app/core/processes/processrunner.py

@@ -0,0 +1,34 @@
+from rbeesoft.common.singleton import singleton
+from rbeesoft.common.logmanager import LogManager
+
+LOG = LogManager()
+
+
+@singleton
+class ProcessRunner:
+    current_process = {}
+
+    def start(self, process, callback_progress=None, callback_finished=None, callback_failed=None):
+        if callback_progress:
+            process.progress.connect(callback_progress)
+        else:
+            process.progress.connect(self.handle_process_progress)
+        if callback_finished:
+            process.finished.connect(callback_finished)
+        else:
+            process.finished.connect(self.handle_process_finished)
+        if callback_failed:
+            process.failed.connect(callback_failed)
+        else:
+            process.failed.connect(self.handle_process_failed)
+        self.current_process = process
+        self.current_process.start()
+
+    def handle_process_progress(self, progress):
+        LOG.info(f'Progress: {progress}')
+
+    def handle_process_finished(self, result):
+        LOG.info(f'Process finished successfully: {result}')
+
+    def handle_process_failed(self, error):
+        LOG.error(f'Process failed ({error})')

rbeesoft-2.0.1/src/rbeesoft/app/main.py

@@ -0,0 +1,86 @@
+import sys
+from PySide6 import QtWidgets, QtCore
+from rbeesoft.app.ui.rbeesoftmainwindow import RbeesoftMainWindow
+from rbeesoft.app.ui.widgets.pages.page import Page
+from rbeesoft.app.core.processes.process import Process
+from rbeesoft.app.core.processes.processrunner import ProcessRunner
+
+
+class MainWindow(RbeesoftMainWindow):
+    def __init__(self, app_icon):
+        super(MainWindow, self).__init__(
+            bundle_identifier='rbeesoft.nl',
+            app_name='example',
+            app_title='Rbeesoft App Example',
+            width=800,
+            height=600,
+            app_icon=app_icon,
+        )
+        self.add_page(HomePage(self.settings()), home_page=True)
+        self.add_page(NextPage(self.settings()))
+
+
+class HomePage(Page):
+    def __init__(self, settings):
+        super(HomePage, self).__init__('home', 'HomePage', settings)
+        button = QtWidgets.QPushButton('Go to next page')
+        button.clicked.connect(self.handle_button)
+        process_button = QtWidgets.QPushButton('Run process')
+        process_button.clicked.connect(self.handle_process_button)
+        self._process_runner = ProcessRunner()
+        layout = QtWidgets.QVBoxLayout()
+        layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
+        layout.addWidget(QtWidgets.QLabel(self.title()))
+        layout.addWidget(button)
+        layout.addWidget(process_button)
+        self.setLayout(layout)
+
+    def handle_button(self):
+        self.switch_to_page('next')
+
+    def handle_process_button(self):
+        self._process_runner.start(ExampleProcess())
+
+
+class NextPage(Page):
+    def __init__(self, settings):
+        super(NextPage, self).__init__('next', 'NextPage', settings)
+        button = QtWidgets.QPushButton('Go to home page')
+        button.clicked.connect(self.handle_button)
+        layout = QtWidgets.QVBoxLayout()
+        layout.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
+        layout.addWidget(QtWidgets.QLabel(self.title()))
+        layout.addWidget(button)
+        self.setLayout(layout)
+
+    def handle_button(self):
+        self.switch_to_page('home')
+
+
+class ExampleProcess(Process):
+    def __init__(self):
+        super(ExampleProcess, self).__init__()
+        self._n = 10
+
+    def execute(self):
+        import time
+        out = []
+        for i in range(self._n):
+            if self.is_canceled():
+                return out
+            time.sleep(0.25)
+            out.append(i)
+            self.progress.emit(int((i+1)/self._n*100))
+        return out
+
+
+def main():
+    QtWidgets.QApplication.setApplicationName('example')
+    app = QtWidgets.QApplication(sys.argv)
+    window = MainWindow(app.style().standardIcon(QtWidgets.QStyle.StandardPixmap.SP_ArrowForward))
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == '__main__':
+    main()

rbeesoft-2.0.1/src/rbeesoft/app/ui/rbeesoftmainwindow.py

@@ -0,0 +1,77 @@
+from PySide6.QtCore import Qt, QByteArray
+from PySide6.QtWidgets import QMainWindow, QStyle
+from PySide6.QtGui import QGuiApplication, QAction
+from rbeesoft.app.ui.settings import Settings
+from rbeesoft.app.ui.widgets.centraldockwidget import CentralDockWidget
+from rbeesoft.app.ui.widgets.logdockwidget import LogDockWidget
+from rbeesoft.common.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class RbeesoftMainWindow(QMainWindow):
+    def __init__(self, bundle_identifier, app_name, app_title, width=1024, height=1024, app_icon=None):
+        super(RbeesoftMainWindow, self).__init__()
+        self._settings = Settings(bundle_identifier, app_name)
+        self._app_title = app_title
+        self._width = width
+        self._height = height
+        self._app_icon = app_icon
+        self._central_dockwidget = CentralDockWidget(self, self._settings)
+        self._log_dockwidget = LogDockWidget(self)
+        self.init()
+
+    # INITIALIZATION
+
+    def init(self):
+        self.setWindowTitle(self._app_title)
+        self.addDockWidget(Qt.DockWidgetArea.TopDockWidgetArea, self._central_dockwidget)
+        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self._log_dockwidget)
+        if self._app_icon:
+            self.setWindowIcon(self._app_icon)
+        self.load_geometry_and_state()
+        self.init_default_menus()
+        self.statusBar().showMessage('Ready')
+        LOG.info(f'Settings path: {self.settings().fileName()}')
+
+    def init_default_menus(self):
+        exit_action_icon = self.style().standardIcon(QStyle.StandardPixmap.SP_DialogCloseButton)
+        exit_action = QAction(exit_action_icon, 'E&xit', self)
+        exit_action.triggered.connect(self.close)
+        application_menu = self.menuBar().addMenu('Application')
+        application_menu.addAction(exit_action)
+
+    # GETTERS
+
+    def settings(self):
+        return self._settings
+    
+    # EVENT HANDLERS
+
+    def closeEvent(self, _):
+        self.save_geometry_and_state()
+
+    # HELPERS
+
+    def add_page(self, page, home_page=False):
+        self._central_dockwidget.add_page(page, home_page)
+
+    def load_geometry_and_state(self):
+        geometry = self.settings().get('mainwindow/geometry')
+        state = self.settings().get('mainwindow/state')
+        if isinstance(geometry, QByteArray) and self.restoreGeometry(geometry):
+            if isinstance(state, QByteArray):
+                self.restoreState(state)
+            return
+        self.resize(self._width, self._height)
+        self.center_window()        
+
+    def save_geometry_and_state(self):
+        self.settings().set('mainwindow/geometry', self.saveGeometry())
+        self.settings().set('mainwindow/state', self.saveState())
+
+    def center_window(self):
+        screen = QGuiApplication.primaryScreen().geometry()
+        x = (screen.width() - self.geometry().width()) / 2
+        y = (screen.height() - self.geometry().height()) / 2
+        self.move(int(x), int(y))

rbeesoft-2.0.1/src/rbeesoft/app/ui/settings.py

@@ -0,0 +1,61 @@
+from PySide6.QtCore import QSettings
+
+
+class Settings(QSettings):
+    def __init__(self, bundle_identifier: str, app_name: str):
+        super(Settings, self).__init__(
+            QSettings.IniFormat, 
+            QSettings.UserScope, 
+            bundle_identifier, 
+            app_name,
+        )
+        self._bundle_identifier = bundle_identifier
+        self._app_name = app_name
+
+    def _prepend_bundle_identifier_and_name(self, name):
+        return '{}.{}.{}'.format(self._bundle_identifier, self._app_name, name)
+
+    def get(self, name, default=None):
+        if not name.startswith(self._bundle_identifier):
+            name = self._prepend_bundle_identifier_and_name(name)
+        value = self.value(name)
+        if value is None or value == '':
+            return default
+        return value
+    
+    def get_int(self, name, default=None):
+        try:
+            return int(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_float(self, name, default=None):
+        try:
+            return float(self.get(name, default))
+        except ValueError as e:
+            return default
+        
+    def get_bool(self, name, default=None):
+        try:
+            value = self.get(name, default)
+            if value and isinstance(value, str):
+                if value == '0' or value.lower() == 'false':
+                    return False
+                elif value == '1' or value.lower() == 'true':
+                    return True
+                else:
+                    return default
+            if value and isinstance(value, bool):
+                return value
+        except ValueError as e:
+            return default
+    
+    def set(self, name, value):
+        name = self._prepend_bundle_identifier_and_name(name)
+        self.setValue(name, value)
+
+    def to_string(self):
+        text = f'Settings path: {self.fileName()}'
+        for key in self.allKeys():
+            text += f'\nSettings: {key}'
+        return text

rbeesoft-2.0.1/src/rbeesoft/app/ui/widgets/centraldockwidget.py

@@ -0,0 +1,51 @@
+from PySide6.QtWidgets import (
+    QWidget,
+    QVBoxLayout,
+    QDockWidget,
+)
+from rbeesoft.common.logmanager import LogManager
+from rbeesoft.app.ui.widgets.pages.pagerouter import PageRouter
+
+LOG = LogManager()
+
+
+class CentralDockWidget(QDockWidget):
+    def __init__(self, parent, settings):
+        super(CentralDockWidget, self).__init__(parent)
+        self._settings = settings
+        self._page_router = None
+        self.init()
+
+    # INITIALIZATION
+
+    def init(self):
+        layout = QVBoxLayout()
+        layout.addWidget(self.page_router())
+        container = QWidget()
+        container.setLayout(layout)
+        self.setObjectName('centraldockwidget') # Needed for saving geometry/state
+        self.setWidget(container)
+
+    # GETTERS/SETTERS
+
+    def settings(self):
+        return self._settings
+    
+    def page_router(self):
+        if not self._page_router:
+            self._page_router = PageRouter()
+        return self._page_router
+    
+    # HELPERS
+
+    def add_page(self, page, home_page=False):
+        page.page_changed.connect(self.handle_page_changed)
+        self.page_router().add_page(page, home_page)
+
+    def switch_to_page(self, name):
+        self.page_router().switch_to_page(name)
+
+    # EVENT HANDLERS
+
+    def handle_page_changed(self, name):
+        self.switch_to_page(name)

rbeesoft-1.0.9/rbeesoft/ui/panels/logpanel.py → rbeesoft-2.0.1/src/rbeesoft/app/ui/widgets/logdockwidget.py

@@ -6,22 +6,19 @@ from PySide6.QtWidgets import (
     QVBoxLayout,
     QLabel,
 )
+from rbeesoft.common.logmanagerlistener import LogManagerListener
 
-from rbeesoft.ui.constants import Constants
 
-from rbeesoft.core.utils.logmanagerlistener import LogManagerListener
-
-
-class LogPanel(QDockWidget, LogManagerListener):
-    def __init__(self):
-        super(LogPanel, self).__init__()
+class LogDockWidget(QDockWidget, LogManagerListener):
+    def __init__(self, parent):
+        super(LogDockWidget, self).__init__(parent)
         self._title_label = None
         self._text_edit = None
         self.init_layout()
 
     def title_label(self):
         if not self._title_label:
-            self._title_label = QLabel(Constants.RBEESOFT_LOG_PANEL_TITLE)
+            self._title_label = QLabel('Output log')
         return self._title_label
 
     def text_edit(self):
@@ -30,20 +27,30 @@ class LogPanel(QDockWidget, LogManagerListener):
         return self._text_edit
     
     def init_layout(self):
-        clear_logs_button = QPushButton(Constants.RBEESOFT_LOG_PANEL_CLEAR_LOGS_BUTTON)
+        clear_logs_button = QPushButton('Clear log')
         clear_logs_button.clicked.connect(self.handle_clear_logs_button)
         layout = QVBoxLayout()
-        # layout.addWidget(self.title_label())
         layout.addWidget(self.text_edit())
         layout.addWidget(clear_logs_button)
         container = QWidget()
         container.setLayout(layout)
-        self.setObjectName(Constants.RBEESOFT_LOG_PANEL_NAME)
+        self.setObjectName('logdockwidget') # Needed for save geometry/state
         self.setWindowTitle(self.title_label().text())
         self.setWidget(container)
 
+    # HELPERS
+
     def add_line(self, line):
         self.text_edit().insertPlainText(line + '\n')
+        self.move_to_end()
+
+    def move_to_end(self):
+        cursor = self.text_edit().textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        self.text_edit().setTextCursor(cursor)
+        self.text_edit().ensureCursorVisible()
+
+    # EVENTS
 
     def handle_clear_logs_button(self):
         self.text_edit().clear()

rbeesoft-2.0.1/src/rbeesoft/app/ui/widgets/pages/page.py

@@ -0,0 +1,24 @@
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QWidget
+
+
+class Page(QWidget):
+    page_changed = Signal(str)
+
+    def __init__(self, name, title, settings):
+        super(Page, self).__init__()
+        self._name = name
+        self._title = title
+        self._settings = settings
+
+    def name(self):
+        return self._name
+
+    def title(self):
+        return self._title
+    
+    def settings(self):
+        return self._settings
+    
+    def switch_to_page(self, name):
+        self.page_changed.emit(name)

rbeesoft-2.0.1/src/rbeesoft/app/ui/widgets/pages/pagerouter.py

@@ -0,0 +1,48 @@
+from PySide6.QtWidgets import QStackedWidget
+
+
+class PageRouter(QStackedWidget):
+    def __init__(self):
+        super(PageRouter, self).__init__()
+        self._pages = {}
+        self._home_page = None
+        self._current_page = None
+        self._previous_page = None
+
+    def pages(self):
+        return self._pages
+    
+    def page(self, name):
+        if name in self.pages().keys():
+            return self.pages()[name]
+        return None
+    
+    def home_page(self):
+        return self._home_page
+    
+    def current_page(self):
+        return self._current_page
+    
+    def previous_page(self):
+        return self._previous_page
+    
+    def add_page(self, page, home_page=False):
+        if page.name() not in self.pages().keys():
+            self.pages()[page.name()] = page
+            if home_page:
+                self._home_page = page
+            self.addWidget(page)
+    
+    def switch_to_page(self, name):
+        if self._current_page and name == self._current_page.name():
+            return
+        if self._current_page:
+            self._previous_page = self._current_page
+        self._current_page = self.page(name)
+        self.setCurrentWidget(self._current_page)
+
+    def switch_to_home(self):
+        if self._current_page:
+            self._previous_page = self._current_page
+        self._current_page = self._home_page
+        self.setCurrentWidget(self._current_page)

{rbeesoft-1.0.9/rbeesoft/core/utils → rbeesoft-2.0.1/src/rbeesoft/common}/logmanager.py

@@ -1,6 +1,8 @@
+import os
+import atexit
 import datetime
-
-from rbeesoft.core.singleton import singleton
+from pathlib import Path
+from rbeesoft.common.singleton import singleton
 
 
 @singleton
@@ -8,12 +10,16 @@ class LogManager:
     def __init__(self, suppress_print=False):
         self._suppress_print = suppress_print
         self._listeners = []
+        file_path = os.path.join(Path.home(), 'mosamatic2.log')
+        self._file_handle = open(file_path, 'w', buffering=1)
+        atexit.register(self.close_file)
 
     def _log(self, level, message):
         timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
         message = f'[{timestamp}] {level} : {message}'
         if not self._suppress_print:
             print(message)
+        self._file_handle.write(message + '\n')
         self.notify_listeners(message)
         return message
 
@@ -33,3 +39,7 @@ class LogManager:
     def notify_listeners(self, message):
         for listener in self._listeners:
             listener.new_message(message)
+
+    def close_file(self):
+        if self._file_handle:
+            self._file_handle.close()