microeye 2.3.2__py3-none-any.whl

microEye/utils/pyscripting.py

@@ -0,0 +1,444 @@
+import sys
+from subprocess import PIPE, Popen
+
+from microEye.qt import (
+    QT_API,
+    QApplication,
+    QtCore,
+    QtGui,
+    QtWidgets,
+    Slot,
+    getOpenFileName,
+    getSaveFileName,
+)
+
+if 'PyQt' in QT_API:
+    from microEye.qt import Qsci
+
+    class CodeEditorWidget(Qsci.QsciScintilla):
+        """
+        Customized code editor widget based on QsciScintilla.
+
+        Parameters
+        ----------
+        linter : str, optional
+            The linter to be used (default is 'pyflakes').
+        formatter : str, optional
+            The code formatter to be used (default is 'autopep8').
+        """
+
+        def __init__(self, linter='pyflakes', formatter='autopep8'):
+            """
+            Initialize the CodeEditorWidget.
+
+            Parameters
+            ----------
+            linter : str, optional
+                The linter to be used (default is 'pyflakes').
+            formatter : str, optional
+                The code formatter to be used (default is 'autopep8').
+            """
+            super().__init__()
+
+            self.setUtf8(True)
+            self.setMarginType(0, Qsci.QsciScintilla.MarginType.NumberMargin)
+
+            # 1. Text wrapping
+            # -----------------
+            self.setWrapMode(Qsci.QsciScintilla.WrapMode.WrapWord)
+            self.setWrapVisualFlags(
+                Qsci.QsciScintilla.WrapVisualFlag.WrapFlagByText,
+                Qsci.QsciScintilla.WrapVisualFlag.WrapFlagInMargin,
+            )
+            self.setWrapIndentMode(Qsci.QsciScintilla.WrapIndentMode.WrapIndentSame)
+
+            # 2. End-of-line mode
+            # --------------------
+            self.setEolMode(Qsci.QsciScintilla.EolMode.EolUnix)
+            self.setEolVisibility(False)
+
+            # 3. Indentation
+            # ---------------
+            self.setIndentationsUseTabs(False)
+            self.setTabWidth(4)
+            self.setIndentationGuides(True)
+            self.setTabIndents(True)
+            self.setAutoIndent(True)
+
+            # 4. Caret
+            # ---------
+            # self.setCaretForegroundColor(QColor('#ff0000ff'))
+            self.setCaretLineVisible(True)
+            self.setCaretLineBackgroundColor(QtGui.QColor('#1f00007f'))
+            self.setCaretForegroundColor(QtGui.QColor('#ffffff'))
+            self.setCaretWidth(2)
+
+            # 5. Margins
+            # -----------
+            # Margin 0 = Line nr margin
+            self.setMarginType(0, Qsci.QsciScintilla.MarginType.NumberMargin)
+            self.setMarginWidth(0, '0000000000')
+            self.setMarginsForegroundColor(QtGui.QColor('#ffffff'))
+            self.setMarginsBackgroundColor(QtGui.QColor('#181818'))
+            # Margin 1 = Symbol
+            # self.setMarginType(1, QsciScintilla.SymbolMarginColor)
+            # self.setMarginWidth(0, '00')
+            # self.markerDefine(QsciScintilla.Circle, 0)
+            # self.setMarginMarkerMask(1, 0b1)
+
+            self.linter = linter
+            self.formatter = formatter
+
+            self.__lexer = Qsci.QsciLexerPython(self)
+            self.__lexer.setDefaultFont(QtGui.QFont('Consolas'))
+            self.__lexer.setDefaultPaper(QtGui.QColor('#1F1F1F'))
+            self.__lexer.setDefaultColor(QtGui.QColor('#f9f9f9'))
+            self.__lexer.setColor(QtGui.QColor('#B5CEA8'), Qsci.QsciLexerPython.Number)
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.DoubleQuotedFString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.DoubleQuotedString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.SingleQuotedFString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.SingleQuotedString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.TripleDoubleQuotedFString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.TripleDoubleQuotedString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.TripleSingleQuotedFString
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#CE9178'), Qsci.QsciLexerPython.TripleSingleQuotedString
+            )
+
+            self.__lexer.setColor(QtGui.QColor('#569CD6'), Qsci.QsciLexerPython.Keyword)
+            self.__lexer.setColor(
+                QtGui.QColor('#DCDCAA'), Qsci.QsciLexerPython.FunctionMethodName
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#4DC9B0'), Qsci.QsciLexerPython.ClassName
+            )
+            self.__lexer.setColor(QtGui.QColor('#6A9955'), Qsci.QsciLexerPython.Comment)
+            self.__lexer.setFont(QtGui.QFont('Consolas'), Qsci.QsciLexerPython.Comment)
+            self.__lexer.setColor(
+                QtGui.QColor('#6A9955'), Qsci.QsciLexerPython.CommentBlock
+            )
+            self.__lexer.setFont(
+                QtGui.QFont('Consolas'), Qsci.QsciLexerPython.CommentBlock
+            )
+            self.__lexer.setColor(
+                QtGui.QColor('#FFD70F'), Qsci.QsciLexerPython.Operator
+            )
+
+            self.__api = Qsci.QsciAPIs(self.__lexer)
+            self.setLexer(self.__lexer)
+            # self.setAutoCompletionSource(QsciScintilla.AcsAll)
+            # self.setAutoCompletionThreshold(1)
+
+            self.currentLineNumber = 0
+
+            self.timer = QtCore.QTimer(self)
+            self.timer.timeout.connect(self.lintCode)
+            self.timer.setSingleShot(True)
+            self.timer.setInterval(100)
+
+            self.textChanged.connect(self.debouncedLintCode)
+
+        def debouncedLintCode(self):
+            '''
+            Start a timer to debounce code linting on text changes.
+            '''
+            self.timer.start()
+
+        def lintCode(self):
+            '''
+            Lint the code using the specified linter.
+
+            Returns
+            -------
+            str
+                A message indicating the linting result.
+            '''
+            code = self.text()
+
+            if self.linter == 'pyflakes':
+                process = Popen(
+                    ['pyflakes'], stdin=PIPE, stdout=PIPE, stderr=PIPE, text=True
+                )
+            else:
+                return 'Unsupported linter.'
+
+            output, errors = process.communicate(code)
+
+            if errors:
+                self.markLintingErrors(errors)
+                return errors
+            else:
+                self.clearAnnotations()
+                return 'Linting passed successfully.'
+
+        def markLintingErrors(self, errors: str):
+            '''
+            Mark linting errors in the editor.
+
+            Parameters
+            ----------
+            errors : str
+                Error messages from the linter.
+            '''
+            error_lines_set = []
+            error_lines = errors.splitlines()
+
+            self.clearAnnotations()
+
+            message = ''
+            for line in error_lines:
+                parts = line.split(':')
+                if len(parts) >= 2 and parts[1].isdigit():
+                    line_number = int(parts[1])
+                    col_number = int(parts[2])
+                    error_lines_set.append(line_number)
+                    message += f'Col {col_number}: {parts[-1]}\n'
+                else:
+                    if len(line.strip()) > 0:
+                        new_line = '' if '^' in line else '\n'
+                        message += f'{line}{new_line}'
+
+            self.annotate(line_number - 1, message, 3)
+
+        def formatCode(self):
+            '''
+            Format the code using the specified code formatter.
+
+            Returns
+            -------
+            str
+                A message indicating the formatting result.
+            '''
+            code = self.text()
+
+            if self.formatter == 'autopep8':
+                process = Popen(
+                    ['autopep8', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE, text=True
+                )
+                formatted_code, errors = process.communicate(input=code)
+
+                if errors:
+                    return errors
+                else:
+                    self.setText(formatted_code)
+                    return 'Code formatted successfully.'
+            else:
+                return 'Unsupported code formatter.'
+else:
+    class PythonHighlighter(QtGui.QSyntaxHighlighter):
+        def __init__(self, parent=None):
+            super().__init__(parent)
+            self.highlightingRules = []
+
+            keywordFormat = QtGui.QTextCharFormat()
+            keywordFormat.setForeground(QtGui.QColor('#569CD6'))
+            keywords = [
+                'and', 'as', 'assert', 'break', 'class', 'continue','def', 'del',
+                'elif', 'else', 'except', 'False', 'finally', 'for', 'from', 'global',
+                'if', 'import', 'in', 'is', 'lambda', 'None', 'nonlocal', 'not',
+                'or', 'pass', 'raise', 'return', 'True', 'try', 'while', 'with', 'yield'
+                ]
+
+            for keyword in keywords:
+                pattern = QtCore.QRegularExpression(r'\b' + keyword + r'\b')
+                self.highlightingRules.append((pattern, keywordFormat))
+
+            # Add more patterns and formats for strings, comments, etc.
+
+        def highlightBlock(self, text):
+            for pattern, format in self.highlightingRules:
+                expression = QtCore.QRegularExpression(pattern)
+
+                # Start at the beginning of the text
+                cursor = 0
+
+                while cursor < len(text):
+                    match = expression.match(text, cursor)
+
+                    if not match.hasMatch():
+                        break
+
+                    index = match.capturedStart()
+                    length = match.capturedLength()
+                    self.setFormat(index, length, format)
+
+                    # Move cursor to the end of the current match
+                    cursor = index + length
+
+            self.setCurrentBlockState(0)
+
+    class CodeEditorWidget(QtWidgets.QPlainTextEdit):
+        def __init__(self, linter='pyflakes', formatter='autopep8', parent=None):
+            super().__init__(parent)
+            self.setFont(QtGui.QFont('Consolas', 10))
+            self.setTabStopDistance(4 * self.fontMetrics().horizontalAdvance(' '))
+
+            self.highlighter = PythonHighlighter(self.document())
+
+            self.linter = linter
+            self.formatter = formatter
+
+            self.textChanged.connect(self.debouncedLintCode)
+            self.timer = QtCore.QTimer(self)
+            self.timer.timeout.connect(self.lintCode)
+            self.timer.setSingleShot(True)
+            self.timer.setInterval(100)
+
+        def text(self):
+            return self.toPlainText()
+
+        def setText(self, value):
+            self.setPlainText(value)
+
+        @Slot()
+        def debouncedLintCode(self):
+            self.timer.start()
+
+        @Slot()
+        def lintCode(self):
+            code = self.toPlainText()
+            if self.linter == 'pyflakes':
+                process = Popen(
+                    ['pyflakes', '-'],
+                    stdin=PIPE, stdout=PIPE, stderr=PIPE, text=True)
+                output, errors = process.communicate(input=code)
+                if errors:
+                    self.markLintingErrors(errors)
+                else:
+                    self.clearAnnotations()
+
+        def markLintingErrors(self, errors):
+            # Add logic to mark linting errors
+            pass
+
+        def clearAnnotations(self):
+            # Add logic to clear annotations
+            pass
+
+        @Slot()
+        def formatCode(self):
+            code = self.toPlainText()
+            if self.formatter == 'autopep8':
+                process = Popen(
+                    ['autopep8', '-'],
+                    stdin=PIPE, stdout=PIPE, stderr=PIPE, text=True)
+                formatted_code, errors = process.communicate(input=code)
+                if errors:
+                    return errors
+                else:
+                    self.setPlainText(formatted_code)
+                    return 'Code formatted successfully.'
+            else:
+                return 'Unsupported code formatter.'
+
+
+class pyEditor(QtWidgets.QWidget):
+    '''
+    Main window containing the code editor.
+
+    Parameters
+    ----------
+    parent : QWidget, optional
+        The parent widget (default is None).
+    '''
+
+    def __init__(self, parent=None):
+        '''
+        Initialize the pyEditor.
+
+        Parameters
+        ----------
+        parent : QWidget, optional
+            The parent widget (default is None).
+        '''
+        super().__init__(parent=parent)
+
+        self.mLayout = QtWidgets.QVBoxLayout()
+        self.setLayout(self.mLayout)
+
+        self.codeEditorWidget = CodeEditorWidget()
+        self.codeEditorWidget.setAcceptDrops(True)
+        self.codeEditorWidget.dragEnterEvent = self.pydragEnterEvent
+        self.codeEditorWidget.dropEvent = (
+            lambda e: self.codeEditorWidget.insertPlainText(e.mimeData().text())
+        )
+
+        self.btns_layout = QtWidgets.QHBoxLayout()
+        self.open_btn = QtWidgets.QPushButton('Open', clicked=lambda: self.openScript())
+        self.save_btn = QtWidgets.QPushButton('Save', clicked=lambda: self.saveScript())
+        self.format_btn = QtWidgets.QPushButton(
+            'Format', clicked=self.codeEditorWidget.formatCode
+        )
+        self.exec_btn = QtWidgets.QPushButton('Execute')
+        self.btns_layout.addWidget(self.open_btn)
+        self.btns_layout.addWidget(self.save_btn)
+        self.btns_layout.addWidget(self.format_btn)
+        self.btns_layout.addWidget(self.exec_btn)
+
+        self.mLayout.addWidget(self.codeEditorWidget)
+        self.mLayout.addLayout(self.btns_layout)
+
+    def openScript(self):
+        '''
+        Open a Python script file and load its content into the editor.
+        '''
+        filename, _ = getOpenFileName(
+            self, 'Load Script', filter='Python Files (*.py);;'
+        )
+
+        if len(filename) > 0:
+            with open(filename, encoding='utf-8') as file:
+                self.codeEditorWidget.setText(file.read())
+
+    def saveScript(self):
+        '''
+        Save the content of the editor into a Python script file.
+        '''
+        filename, _ = getSaveFileName(
+            self, 'Save Script', filter='Python Files (*.py);;'
+        )
+
+        if len(filename) > 0:
+            with open(filename, 'w', encoding='utf-8') as file:
+                file.write(self.codeEditorWidget.text())
+
+    def pydragEnterEvent(self, e):
+        '''
+        Handle drag enter event for plain text.
+        '''
+        if e.mimeData().hasFormat('text/plain'):
+            e.accept()
+        else:
+            e.ignore()
+
+    def toPlainText(self):
+        '''
+        Get the plain text content of the code editor.
+
+        Returns
+        -------
+        str
+            The plain text content of the code editor.
+        '''
+        return self.codeEditorWidget.text()
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    window = pyEditor()
+    window.show()
+    sys.exit(app.exec())

microEye/utils/retry_exec.py

@@ -0,0 +1,35 @@
+import sys
+import traceback
+
+from microEye.qt import QApplication, QtWidgets
+
+
+def retry_exec(func, *args, **kwargs):
+    while True:
+        try:
+            func(*args, **kwargs)
+            break
+        except Exception as e:
+            if not show_error_dialog(str(e)):
+                break
+
+
+def show_error_dialog(error_message):
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication(sys.argv)
+
+    msg_box = QtWidgets.QMessageBox()
+    msg_box.setIcon(QtWidgets.QMessageBox.Icon.Critical)
+    msg_box.setWindowTitle('Error')
+    msg_box.setText('An error occurred')
+    msg_box.setInformativeText(error_message)
+    msg_box.setDetailedText(traceback.format_exc())
+    retry_button = msg_box.addButton(
+        'Retry', QtWidgets.QMessageBox.ButtonRole.AcceptRole
+    )
+    ok_button = msg_box.addButton(QtWidgets.QMessageBox.StandardButton.Ok)
+
+    msg_box.exec()
+
+    return msg_box.clickedButton() == retry_button

microEye/utils/start_gui.py

@@ -0,0 +1,112 @@
+import os
+import random
+import sys
+
+import pyfiglet
+import pyjokes
+import qdarkstyle
+import qdarktheme
+
+from microEye import __version__
+from microEye.qt import QT_API, QApplication, QtCore, QtGui, QtWidgets
+
+
+def splash(module):
+    fonts = [
+        # 'ansi_shadow',
+        # 'big',
+        # 'doom',
+        # 'slant',
+        'small',
+        'small_slant',
+        'smslant',
+        # 'standard',
+        # 'stop',
+    ]
+    print(
+        pyfiglet.Figlet(font=random.choice(fonts), width=250).renderText(
+            f'MicroEye v{__version__}\n{module}'
+        )
+    )
+
+
+QSS = '''
+    ParameterControlledButton {
+        font-weight: 600;
+        min-width: 100px;
+        min-height: 20px;
+    }
+    QPushButton {
+        padding: 4px;
+        font-weight: 600;
+    }
+    QDockWidget {
+        font-weight: 600;
+        font-size: 11pt;
+    }
+    microLauncher {
+        border: 1px solid white;
+        padding: 0;
+    }
+    QPushButton#closeButton {
+        border: none;
+    }
+    '''
+
+
+def StartGUI(cls: type, *args, **kwargs):
+    '''Initializes a new QApplication and module.
+
+    Use
+    -------
+    app, window = StartGUI(module_type)
+
+
+    app.exec()
+
+    Returns
+    -------
+    tuple (QApplication, module)
+        Returns a tuple with QApp and module window.
+    '''
+    splash(cls.__name__)
+    print(pyjokes.get_joke())
+    # create a QApp
+    QtWidgets.QApplication.setAttribute(
+        QtCore.Qt.ApplicationAttribute.AA_ShareOpenGLContexts
+    )
+    app = QApplication(sys.argv)
+    # set darkmode from *qdarkstyle* (not compatible with pyqt6)
+    # Additional stylesheet
+
+    theme = os.environ.get('MITHEME', default=None)
+    if theme is not None:
+        if theme == 'qdarkstyle':
+            app.setStyleSheet(qdarkstyle.load_stylesheet(qt_api=QT_API))
+        elif theme == 'qdarktheme':
+            qdarktheme.setup_theme(additional_qss=QSS)
+        elif theme in QtWidgets.QStyleFactory.keys():  # noqa: SIM118
+            app.setStyle(theme)
+
+    # sets the app icon
+    dirname = os.path.dirname(os.path.abspath(__file__))
+    app_icon = QtGui.QIcon()
+    app_icon.addFile(os.path.join(dirname, '../icons/16.png'), QtCore.QSize(16, 16))
+    app_icon.addFile(os.path.join(dirname, '../icons/24.png'), QtCore.QSize(24, 24))
+    app_icon.addFile(os.path.join(dirname, '../icons/32.png'), QtCore.QSize(32, 32))
+    app_icon.addFile(os.path.join(dirname, '../icons/48.png'), QtCore.QSize(48, 48))
+    app_icon.addFile(os.path.join(dirname, '../icons/64.png'), QtCore.QSize(64, 64))
+    app_icon.addFile(os.path.join(dirname, '../icons/128.png'), QtCore.QSize(128, 128))
+    app_icon.addFile(os.path.join(dirname, '../icons/256.png'), QtCore.QSize(256, 256))
+    app_icon.addFile(os.path.join(dirname, '../icons/512.png'), QtCore.QSize(512, 512))
+
+    app.setWindowIcon(app_icon)
+
+    if sys.platform.startswith('win'):
+        import ctypes
+
+        myappid = f'samhitech.mircoEye.{cls.__name__}'  # appid
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
+
+    window = cls(*args)
+    return app, window

microEye/utils/thread_worker.py

@@ -0,0 +1,115 @@
+import sys
+import threading
+import traceback
+
+import numpy as np
+
+from microEye.qt import QtCore, Signal, Slot
+
+
+class WorkerSignals(QtCore.QObject):
+    '''
+    Defines the signals available from a running worker thread.
+
+    Supported signals are:
+    - finished: No data
+    - error: tuple (exctype, value, traceback.format_exc())
+    - result: object data returned from processing, anything
+    - progress: object for progress updates
+    '''
+    finished = Signal()
+    error = Signal(tuple)
+    result = Signal(object)
+    progress = Signal(object)
+
+
+class QThreadWorker(QtCore.QRunnable):
+    '''Thread worker
+
+    Inherits from QRunnable to handler worker thread setup,
+    signals and wrap-up.
+
+    Parameters
+    ----------
+    callback : function
+        The function callback to run on this worker thread. Supplied args and
+        kwargs will be passed through to the runner.
+    args:
+        Arguments to pass to the callback function
+    kwargs:
+        Keywords to pass to the callback function
+    '''
+
+    def __init__(self, fn, *args, **kwargs):
+        super().__init__()
+
+        # Store constructor arguments (re-used for processing)
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+        self.signals = WorkerSignals()
+        self.stop_event = threading.Event()
+        self._started = False
+        self._done = False
+
+        self.kwargs['event'] = self.stop_event
+
+        # Add the callback to our kwargs
+        if kwargs.get('progress'):
+            self.kwargs['progress_callback'] = self.signals.progress
+
+    @property
+    def done(self) -> bool:
+        return self._done
+
+    @property
+    def started(self) -> bool:
+        return self._started
+
+    @Slot()
+    def run(self):
+        '''Initialise the runner function with passed args, kwargs.'''
+        self._started = True
+        # Retrieve args/kwargs here; and fire processing using them
+        try:
+            if self.kwargs.get('nokwargs'):
+                result = self.fn(*self.args)
+            else:
+                result = self.fn(*self.args, **self.kwargs)
+        except Exception:
+            traceback.print_exc()
+            exctype, value = sys.exc_info()[:2]
+            self.signals.error.emit((exctype, value, traceback.format_exc()))
+        else:
+            # Return the result of the processing
+            self.signals.result.emit(result)
+        finally:
+            self.stop_event.set()
+            self._done = True
+            self.signals.finished.emit()  # Done
+
+    def stop(self):
+        '''
+        Request the worker to stop.
+        '''
+        self.stop_event.set()
+
+    def is_set(self):
+        '''
+        Check if the stop has been requested.
+        '''
+        return self.stop_event.is_set()
+
+    def wait(self, timeout=None):
+        '''
+        Wait until the worker has finished or the stop has been requested.
+
+        Parameters
+        ----------
+        timeout : float or None
+            The maximum number of seconds to wait. If None, waits indefinitely.
+        '''
+        if self._started:
+            self.stop_event.wait(timeout)
+        else:
+            raise RuntimeError('Cannot wait on a worker that has not been started')