microeye 2.3.2__py3-none-any.whl

microEye/hardware/protocols/designer.py

@@ -0,0 +1,244 @@
+import json
+import sys
+
+from microEye import __version__
+from microEye.hardware.protocols.actions import (
+    ForLoop,
+    FunctionCall,
+    ParameterAdjustmentAction,
+)
+from microEye.hardware.protocols.scene_manager import SceneManager
+from microEye.qt import QApplication, Qt, QtCore, QtGui, QtWidgets
+
+
+class ExperimentDesignerView(QtWidgets.QGraphicsView):
+    '''
+    Custom QGraphicsView with zooming and key event handling.
+
+    Subclass of QGraphicsView.
+
+    Attributes
+    ----------
+    root : ActionGroupItem
+        The root item in the scene.
+    '''
+
+    def __init__(self):
+        '''
+        Initialize a new ExperimentDesignerView instance.
+        '''
+        super().__init__()
+        self.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing, True)
+        self.setRenderHint(QtGui.QPainter.RenderHint.TextAntialiasing, True)
+        self.setRenderHint(QtGui.QPainter.RenderHint.SmoothPixmapTransform, True)
+
+        # Create an instance of the SceneManager
+        self.scene_manager = SceneManager()
+        self.setScene(self.scene_manager.scene)
+
+        # Set dark background color for the view
+        background_color = QtGui.QColor('#333333')  # Adjust the color as needed
+        self.setBackgroundBrush(background_color)
+
+    def wheelEvent(self, event: QtWidgets.QGraphicsSceneWheelEvent):
+        '''
+        Handle wheel events for zooming.
+
+        Parameters
+        ----------
+        event : QGraphicsSceneWheelEvent
+            The wheel event.
+        '''
+        zoom_factor = 1.2
+
+        if event.angleDelta().y() > 0:
+            self.scale(zoom_factor, zoom_factor)
+        else:
+            self.scale(1 / zoom_factor, 1 / zoom_factor)
+
+        super().wheelEvent(event)
+
+    def keyPressEvent(self, event):
+        '''
+        Handle key press events for swapping and deletion.
+
+        Parameters
+        ----------
+        event : QKeyEvent
+            The key event.
+        '''
+        self.scene_manager.handleKeyPress(event)
+
+        super().keyPressEvent(event)
+
+    def contextMenuEvent(self, event):
+        '''
+        Handle context menu events.
+
+        Parameters
+        ----------
+        event : QContextMenuEvent
+            The context menu event.
+        '''
+        context_menu = QtWidgets.QMenu()
+
+        # Add option to add different types
+        add_menu = context_menu.addMenu('Add')
+        # add_menu.addAction(
+        #     'Function Call', lambda: self.scene_manager.add_action(FunctionCall())
+        # )
+        add_menu.addAction('For Loop', lambda: self.scene_manager.add_action(ForLoop()))
+        add_menu.addAction(
+            'Parameter Adjustment',
+            lambda: self.scene_manager.add_action(ParameterAdjustmentAction()),
+        )
+
+        # Add Move submenu
+        move_submenu = context_menu.addMenu('Move')
+        move_submenu.addAction(
+            'Up',
+            lambda: self.keyPressEvent(
+                QtGui.QKeyEvent(
+                    QtCore.QEvent.Type.KeyPress,
+                    Qt.Key.Key_PageUp,
+                    Qt.KeyboardModifier.NoModifier,
+                    0,
+                    0,
+                    0,
+                )
+            ),
+        )
+        move_submenu.addAction(
+            'Down',
+            lambda: self.keyPressEvent(
+                QtGui.QKeyEvent(
+                    QtCore.QEvent.Type.KeyPress,
+                    Qt.Key.Key_PageDown,
+                    Qt.KeyboardModifier.NoModifier,
+                    0,
+                    0,
+                    0,
+                )
+            ),
+        )
+
+        context_menu.addAction(
+            'Delete',
+            lambda: self.keyPressEvent(
+                QtGui.QKeyEvent(
+                    QtCore.QEvent.Type.KeyPress,
+                    Qt.Key.Key_Delete,
+                    Qt.KeyboardModifier.NoModifier,
+                    0,
+                    0,
+                    0,
+                )
+            ),
+        )
+
+        # Add Execute action
+        context_menu.addAction('Execute', self.scene_manager.execute_actions)
+        context_menu.addAction('Stop Execution', self.scene_manager.stop_execution)
+
+        # Add Export and Import actions
+        context_menu.addAction('Export (protocol)', self.export_protocol)
+        context_menu.addAction('Import (protocol)', self.import_protocol)
+        context_menu.addAction('Import & Execute', self.import_execute_protocol)
+
+        # Show the context menu
+        context_menu.exec(event.globalPos())
+
+    def export_protocol(self):
+        '''
+        Handle exporting the protocol to a JSON file.
+        '''
+        file_dialog = QtWidgets.QFileDialog()
+        file_name, _ = file_dialog.getSaveFileName(
+            self, 'Export Protocol', '', 'JSON Files (*.json)'
+        )
+
+        if file_name:
+            with open(file_name, 'w') as file:
+                protocol_data = self.scene_manager.serialize_protocol()
+                json.dump(protocol_data, file, indent=4)
+
+    def import_protocol(self):
+        '''
+        Handle importing the protocol from a JSON file.
+        '''
+        file_dialog = QtWidgets.QFileDialog()
+        file_name, _ = file_dialog.getOpenFileName(
+            self, 'Import Protocol', '', 'JSON Files (*.json)'
+        )
+
+        if not file_name:
+            return False
+
+        with open(file_name) as file:
+            protocol_data = json.load(file)
+            self.scene_manager.load_actions(protocol_data)
+
+        return True
+
+    def import_execute_protocol(self):
+        '''
+        Handle importing and executing the protocol from a JSON file.
+        '''
+        if self.import_protocol():
+            self.scene_manager.execute_actions()
+
+class ExperimentDesigner(QtWidgets.QWidget):
+    HEADER = '> <span style="color:#0f0;">Experiment Designer ('
+    HEADER += f'<span style="color:#aaf;">microEye v{__version__}</span>)</span>'
+
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+
+    def initUI(self):
+        # Create the ExperimentDesignerView
+        self.experiment_view = ExperimentDesignerView()
+
+        # Create the text terminal
+        self.text_terminal = QtWidgets.QPlainTextEdit()
+        self.text_terminal.setReadOnly(True)
+        self.text_terminal.appendHtml(self.HEADER)
+        self.text_terminal.setStyleSheet(
+            'QPlainTextEdit { background-color: #111;}'
+        )
+
+        self.experiment_view.scene_manager.updateTerminal.connect(self.updateTerminal)
+        self.experiment_view.scene_manager.clearTerminal.connect(self.clearTerminal)
+
+        # Set up the layout
+        layout = QtWidgets.QHBoxLayout()
+        layout.addWidget(self.experiment_view, 2)
+        layout.addWidget(self.text_terminal, 1)
+        self.setLayout(layout)
+
+        # Set window properties
+        self.setWindowTitle('Experiment Designer')
+
+    def updateTerminal(self, text: str, level: int):
+        indent = '>' * (level + 1) + ' '
+        if ':' in text and len(text.split(':')) == 2:
+            text = text.split(':')
+            self.text_terminal.appendHtml(
+                f'{indent}<span style="color: #0f0;">{text[0]}: </span>'
+                f'<span style="color: #aaa;">{text[1]}</span>'
+            )
+        else:
+            self.text_terminal.appendHtml(
+                f'{indent}<span style="color: #0f0;">{text}</span>'
+            )
+
+    def clearTerminal(self):
+        self.text_terminal.clear()
+        self.text_terminal.appendHtml(self.HEADER)
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    editor = ExperimentDesigner()
+    editor.show()
+    sys.exit(app.exec())

microEye/hardware/protocols/scene_manager.py

@@ -0,0 +1,191 @@
+import threading
+import traceback
+from typing import Any
+
+from microEye.hardware.protocols.actions import ActionGroup, BaseAction
+from microEye.hardware.protocols.actions_items import (
+    ActionGroupItem,
+    BaseActionItem,
+    get_action_item,
+)
+from microEye.hardware.protocols.serialization import (
+    deserialize_action,
+    serialize_action,
+)
+from microEye.qt import Qt, QtCore, QtGui, QtWidgets, Signal
+from microEye.utils.thread_worker import QThreadWorker
+
+
+class SceneManager(QtCore.QObject):
+    '''
+    Class responsible for managing the scene and its layout.
+    '''
+
+    updateTerminal = Signal(str, int)
+    clearTerminal = Signal()
+
+    def __init__(self):
+        '''
+        Initialize a new SceneManager instance.
+        '''
+        super().__init__()
+        self.scene = QtWidgets.QGraphicsScene()
+        self.action = ActionGroup()
+        self.action.name = 'Main'
+        self.root = ActionGroupItem(self.action)
+        self.scene.addItem(self.root)
+
+        self.worker = None
+
+    def add_action(self, action: BaseAction):
+        '''
+        Add an action to the scene.
+
+        Parameters
+        ----------
+        action : BaseAction
+            The action to be added.
+        '''
+        selected_items = self.scene.selectedItems()
+
+        if len(selected_items) == 1:
+            action_item = get_action_item(action)
+
+            if isinstance(selected_items[0], ActionGroupItem):
+                selected_item = selected_items[0]
+                selected_item.add_child_item(action_item)
+            else:
+                selected_item = selected_items[0]
+                parent_item = selected_item.parentItem()
+                if isinstance(parent_item, ActionGroupItem):
+                    parent_item.add_child_item(action_item)
+
+    def handleKeyPress(self, event: QtGui.QKeyEvent):
+        selected_items = self.scene.selectedItems()
+
+        if len(selected_items) == 1 and isinstance(selected_items[0], BaseActionItem):
+            selected_item = selected_items[0]
+            parent_item = selected_item.parentItem()
+            if parent_item is not None and isinstance(parent_item, ActionGroupItem):
+                index_self = parent_item.child_items.index(selected_item)
+
+                if event.key() == Qt.Key.Key_PageUp:
+                    # Move item up
+                    if index_self > 0:
+                        parent_item.swap_children(index_self, index_self - 1)
+                elif event.key() == Qt.Key.Key_PageDown:
+                    # Move item down
+                    if index_self < len(parent_item.child_items) - 1:
+                        parent_item.swap_children(index_self, index_self + 1)
+                elif event.key() == Qt.Key.Key_Delete:
+                    # Delete item and its children
+                    parent_item.remove_child_item(selected_item)
+                    self.scene.removeItem(selected_item)
+
+    def remove_action(self, action: BaseAction):
+        '''
+        Remove an action from the scene.
+
+        Parameters
+        ----------
+        action : BaseAction
+            The action to be removed.
+        '''
+        action_item = self.find_action_item(action)
+        if action_item:
+            parent_item = action_item.parentItem()
+            if parent_item:
+                parent_item.remove_child_item(action_item)
+            self.scene.removeItem(action_item)
+
+    def find_action_item(self, action: BaseAction) -> ActionGroupItem:
+        '''
+        Find the action item corresponding to the given action.
+
+        Parameters
+        ----------
+        action : BaseAction
+            The action to find.
+
+        Returns
+        -------
+        ActionGroupItem
+            The action item corresponding to the given action, or None if not found.
+        '''
+        for item in self.scene.items():
+            if isinstance(item, ActionGroupItem) and item.action == action:
+                return item
+        return None
+
+    def execute_actions(self):
+        '''
+        Execute the actions in the scene.
+        '''
+        if isinstance(self.root, ActionGroupItem) and (
+            self.worker is None or self.worker.is_set()
+        ):
+            self.clearTerminal.emit()
+
+            def actions(root: ActionGroupItem, updateTerminal, **kwargs):
+                try:
+                    time = QtCore.QDateTime.currentDateTime().date()
+                    root.action.execute(
+                        output=updateTerminal, level=0, event=kwargs.get('event'),
+                        year=time.year(), month=time.month(), day=time.day()
+                    )
+                except Exception:
+                    updateTerminal.emit(traceback.format_exc(), 0)
+                finally:
+                    updateTerminal.emit('Done!', 0)
+
+            self.worker = QThreadWorker(
+                actions, self.root, self.updateTerminal
+            )
+            # Execute
+            QtCore.QThreadPool.globalInstance().start(self.worker)
+
+    def stop_execution(self):
+        if self.worker:
+            self.worker.stop()  # This will signal the thread to stop
+
+        # self.updateTerminal.emit('Execution stopped.', 0)
+
+    def load_actions(self, actions: list[dict[str, Any]]):
+        '''
+        Load actions from a list of serialized action data.
+
+        Parameters
+        ----------
+        actions : list[dict[str, Any]]
+            A list of serialized action data.
+        '''
+        self.clear_scene()
+        for action_data in actions:
+            action, action_item = deserialize_action(action_data)
+            self.root.add_child_item(action_item)
+
+    def clear_scene(self):
+        '''
+        Clear the scene by removing all items.
+        '''
+        self.scene.clear()
+        BaseAction.id_counter = 1
+        self.action = ActionGroup()
+        self.action.name = 'Main'
+        self.root = ActionGroupItem(self.action)
+        self.scene.addItem(self.root)
+
+    def serialize_protocol(self) -> list[dict[str, Any]]:
+        '''
+        Serialize the protocol to a JSON-serializable data structure.
+
+        Returns
+        -------
+        list[dict[str, Any]]
+            A list of serialized action data.
+        '''
+        protocol_data = []
+        for action in self.root.action.child_actions:
+            action_data = serialize_action(action)
+            protocol_data.append(action_data)
+        return protocol_data

microEye/hardware/protocols/serialization.py

@@ -0,0 +1,97 @@
+from typing import Any
+
+from microEye.hardware.protocols.actions import (
+    BaseAction,
+    ForLoop,
+    FunctionCall,
+    ParameterAdjustmentAction,
+)
+from microEye.hardware.protocols.actions_items import (
+    ActionGroupItem,
+    get_action_item,
+)
+
+
+def serialize_action(action: BaseAction) -> dict[str, Any]:
+    '''
+    Serialize an action to a JSON-serializable data structure.
+
+    Parameters
+    ----------
+    action : BaseAction
+        The action to be serialized.
+
+    Returns
+    -------
+    dict[str, Any]
+        A dictionary representing the serialized action data.
+    '''
+    action_data = {
+        'type': type(action).__name__,
+        'id': action.id,
+        'name': action.name,
+    }
+
+    if isinstance(action, FunctionCall):
+        action_data['function'] = action.function.__name__
+        action_data['function_args'] = list(action.function_args)
+    elif isinstance(action, ForLoop):
+        action_data['repeat_count'] = action.repeat_count
+        action_data['child_actions'] = [
+            serialize_action(child) for child in action.child_actions
+        ]
+    elif isinstance(action, ParameterAdjustmentAction):
+        action_data['target_object'] = action.target_object
+        action_data['parameter_name'] = action.parameter_name
+        action_data['parameter_value'] = action.parameter_value
+        action_data['delay'] = action.delay
+        action_data['is_expression'] = action.is_expression
+
+    return action_data
+
+
+def deserialize_action(action_data: dict[str, Any]) -> tuple[BaseAction, Any]:
+    '''
+    Deserialize an action from the JSON data structure.
+
+    Parameters
+    ----------
+    action_data : dict[str, Any]
+        The dictionary containing the serialized action data.
+
+    Returns
+    -------
+    tuple[BaseAction, Any]
+        A tuple containing the deserialized action instance and its corresponding
+        action item.
+    '''
+    action_type = globals()[action_data['type']]
+
+    if action_type == FunctionCall:
+        function = globals()[action_data['function']]
+        args = tuple(action_data['function_args'])
+        action = FunctionCall(function, args)
+        action_item = get_action_item(action)
+    elif action_type == ForLoop:
+        action = ForLoop(action_data['repeat_count'])
+        action_item = ActionGroupItem(action)
+        for child_data in action_data['child_actions']:
+            child_action, child_item = deserialize_action(child_data)
+            action_item.add_child_item(child_item)
+    elif action_type == ParameterAdjustmentAction:
+        action = ParameterAdjustmentAction(
+            target_object=action_data.get('target_object'),
+            parameter_name=action_data.get('parameter_name'),
+            parameter_value=action_data.get('parameter_value'),
+            delay=action_data.get('delay', 0.0),
+            is_expression=action_data.get('is_expression', False)
+        )
+        action_item = get_action_item(action)
+    else:
+        action = action_type()
+        action_item = get_action_item(action)
+
+    # action.id = action_data['id']
+    action.name = action_data['name']
+
+    return action, action_item

microEye/hardware/pycromanager/__init__.py

@@ -0,0 +1,16 @@
+# get pycromanager version
+from mmpycorex import __version__ as mmpycorex_version
+from pycromanager import __version__ as pycromanager_version
+
+required_pycromanager_version = '1.0.2'
+required_mmpycorex_version = '0.3.16'
+
+if pycromanager_version != required_pycromanager_version:
+    raise ImportError(
+        f'This module requires pycromanager version {required_pycromanager_version}'
+    )
+
+if mmpycorex_version < required_mmpycorex_version:
+    raise ImportError(
+        f'This module requires mmpycorex version {required_mmpycorex_version}'
+    )