mxbiflow 0.1.1__py3-none-any.whl

mxbiflow/ui/components/device_card/detector/fusion_detector.py

@@ -0,0 +1,45 @@
+from pymxbi.detector import FusionContinuousDetectorModel
+from PySide6.QtWidgets import QComboBox, QLabel, QLineEdit
+
+from .....utils.serial import get_all_ports, get_baudrates
+from ..device_card import DeviceCard
+
+
+class FusionDetectorCard(DeviceCard[FusionContinuousDetectorModel]):
+    def __init__(self):
+        super().__init__()
+
+        self.set_title("Fusion Detector")
+
+        label_pin = QLabel("Beam Break Pin")
+        self._line_pin = QLineEdit()
+        self._line_pin.setPlaceholderText("Pin Number")
+        self.layout_config.addRow(label_pin, self._line_pin)
+
+        label_port = QLabel("Port")
+        self._combo_port = QComboBox()
+        self._combo_port.addItems(get_all_ports())
+        self.layout_config.addRow(label_port, self._combo_port)
+
+        label_baudrate = QLabel("Baudrate")
+        self._combo_baudrate = QComboBox()
+        for text, value in get_baudrates():
+            self._combo_baudrate.addItem(text, value)
+        self.layout_config.addRow(label_baudrate, self._combo_baudrate)
+
+    def load_config(self, model: FusionContinuousDetectorModel) -> None:
+        self.checkbox_enabled.setChecked(model.enabled)
+        self.line_device_id.setText(str(model.id))
+        self._line_pin.setText(str(model.pin))
+        self._combo_port.setCurrentText(model.port)
+        self._combo_baudrate.setCurrentText(str(model.baudrate))
+
+    @property
+    def result(self) -> FusionContinuousDetectorModel:
+        return FusionContinuousDetectorModel(
+            enabled=self.checkbox_enabled.isChecked(),
+            id=int(self.line_device_id.text()),
+            pin=int(self._line_pin.text()),
+            port=self._combo_port.currentText(),
+            baudrate=int(self._combo_baudrate.currentData()),
+        )

mxbiflow/ui/components/device_card/detector/mock_detector_card.py

@@ -0,0 +1,20 @@
+from pymxbi.detector import MockDetectorModel
+
+from ..device_card import DeviceCard
+
+
+class MockDetectorCard(DeviceCard[MockDetectorModel]):
+    def __init__(self):
+        super().__init__()
+        self.set_title("Mock Detector")
+
+    def load_config(self, model: MockDetectorModel) -> None:
+        self.checkbox_enabled.setChecked(model.enabled)
+        self.line_device_id.setText(str(model.id))
+
+    @property
+    def result(self) -> MockDetectorModel:
+        return MockDetectorModel(
+            enabled=self.checkbox_enabled.isChecked(),
+            id=int(self.line_device_id.text()),
+        )

mxbiflow/ui/components/device_card/detector/rfid_detector.py

@@ -0,0 +1,40 @@
+from pymxbi.detector import RFIDContinuousDetectorModel
+from PySide6.QtWidgets import (
+    QComboBox,
+    QLabel,
+)
+
+from .....utils.serial import get_all_ports, get_baudrates
+from ..device_card import DeviceCard
+
+
+class RFIDDetectorCard(DeviceCard[RFIDContinuousDetectorModel]):
+    def __init__(self):
+        super().__init__()
+        self.set_title("Single RFID Detector")
+
+        lable_port = QLabel("Port:")
+        self.combo_port = QComboBox()
+        self.combo_port.addItems(get_all_ports())
+        self.layout_config.addRow(lable_port, self.combo_port)
+
+        lable_baudrate = QLabel("Baudrate:")
+        self.combo_baudrate = QComboBox()
+        for text, value in get_baudrates():
+            self.combo_baudrate.addItem(text, value)
+        self.layout_config.addRow(lable_baudrate, self.combo_baudrate)
+
+    def load_config(self, model: RFIDContinuousDetectorModel) -> None:
+        self.checkbox_enabled.setChecked(model.enabled)
+        self.line_device_id.setText(str(model.id))
+        self.combo_port.setCurrentText(model.port)
+        self.combo_baudrate.setCurrentText(str(model.baudrate))
+
+    @property
+    def result(self) -> RFIDContinuousDetectorModel:
+        return RFIDContinuousDetectorModel(
+            enabled=self.checkbox_enabled.isChecked(),
+            id=int(self.line_device_id.text()),
+            port=self.combo_port.currentText(),
+            baudrate=int(self.combo_baudrate.currentText()),
+        )

mxbiflow/ui/components/device_card/device_card.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QIntValidator
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QFormLayout,
+    QLabel,
+    QLineEdit,
+    QMenu,
+    QVBoxLayout,
+)
+
+from ..card import CardFrame
+
+TModel = TypeVar("TModel")
+
+
+class DeviceCard(CardFrame, Generic[TModel]):
+    remove_requested = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent=parent, object_name="card")
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._open_menu)
+
+        self.layout_main = QVBoxLayout()
+        self.setLayout(self.layout_main)
+        self.layout_main.setContentsMargins(8, 8, 8, 8)
+
+        self.label_title = QLabel("Device Configuration")
+        self.layout_main.addWidget(self.label_title)
+
+        self.layout_config = QFormLayout()
+        self.layout_main.addLayout(self.layout_config)
+
+        self.lable_enabled = QLabel("Enabled:")
+        self.checkbox_enabled = QCheckBox()
+        self.checkbox_enabled.setChecked(False)
+        self.layout_config.addRow(self.lable_enabled, self.checkbox_enabled)
+
+        self.label_id = QLabel("Device ID:")
+        self.line_device_id = QLineEdit("0")
+        self.int_validator = QIntValidator(0, 1000, self)
+        self.line_device_id.setValidator(self.int_validator)
+        self.layout_config.addRow(self.label_id, self.line_device_id)
+
+    def _open_menu(self, position) -> None:
+        menu = QMenu(self)
+        action_remove = menu.addAction("Remove")
+        action_remove.triggered.connect(
+            lambda _checked=False: self.remove_requested.emit()
+        )
+        menu.exec(self.mapToGlobal(position))
+
+    def set_title(self, title: str) -> None:
+        self.label_title.setText(title)
+
+    def load_config(self, model: TModel) -> None:
+        raise NotImplementedError
+
+    @property
+    def result(self) -> TModel:
+        raise NotImplementedError

mxbiflow/ui/components/device_card/rewarder/mock_rewarder_card.py

@@ -0,0 +1,20 @@
+from pymxbi.rewarder import MockRewarderModel
+
+from ..device_card import DeviceCard
+
+
+class MockRewarderCard(DeviceCard[MockRewarderModel]):
+    def __init__(self):
+        super().__init__()
+        self.set_title("Mock Rewarder")
+
+    def load_config(self, model: MockRewarderModel) -> None:
+        self.checkbox_enabled.setChecked(model.enabled)
+        self.line_device_id.setText(str(model.id))
+
+    @property
+    def result(self) -> MockRewarderModel:
+        return MockRewarderModel(
+            enabled=self.checkbox_enabled.isChecked(),
+            id=int(self.line_device_id.text()),
+        )

mxbiflow/ui/components/device_card/rewarder/rpi_gpio_rewarder.py

@@ -0,0 +1,33 @@
+from pymxbi.rewarder import GPIORewarderModel
+from PySide6.QtGui import QIntValidator
+from PySide6.QtWidgets import (
+    QLabel,
+    QLineEdit,
+)
+
+from ..device_card import DeviceCard
+
+
+class RPIGpioPumpCard(DeviceCard[GPIORewarderModel]):
+    def __init__(self):
+        super().__init__()
+        self.set_title("GPIO Pump")
+
+        lable_gpio_pin = QLabel("GPIO Pin:")
+        self.line_gpio_pin = QLineEdit("0")
+        int_validator = QIntValidator(0, 40, self)
+        self.line_gpio_pin.setValidator(int_validator)
+        self.layout_config.addRow(lable_gpio_pin, self.line_gpio_pin)
+
+    def load_config(self, model: GPIORewarderModel) -> None:
+        self.checkbox_enabled.setChecked(model.enabled)
+        self.line_device_id.setText(str(model.id))
+        self.line_gpio_pin.setText(str(model.pin))
+
+    @property
+    def result(self) -> GPIORewarderModel:
+        return GPIORewarderModel(
+            enabled=self.checkbox_enabled.isChecked(),
+            id=int(self.line_device_id.text()),
+            pin=int(self.line_gpio_pin.text()),
+        )

mxbiflow/ui/components/devices.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Generic, TypeVar
+
+from pymxbi.detector import DetectorModel
+from pymxbi.rewarder import RewarderModel
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QDialog,
+    QGridLayout,
+    QGroupBox,
+    QMenu,
+    QMessageBox,
+    QWidget,
+)
+
+from .device_card.device_card import DeviceCard
+from .dialog.add_devices_dialog import AddDeviceDialog
+
+T = TypeVar("T", RewarderModel, DetectorModel)
+
+
+class Devices(QGroupBox, Generic[T]):
+    def __init__(
+        self,
+        parent: QWidget | None,
+        title: str,
+        *,
+        action_label: str,
+        device_types: Sequence[str],
+        dialog_title: str,
+        label: str,
+        card_factories: Mapping[str, type[QWidget]],
+        columns: int = 2,
+    ):
+        super().__init__(title, parent)
+
+        self._action_label = action_label
+        self._device_types = list(device_types)
+        self._dialog_title = dialog_title
+        self._label = label
+        self._card_factories = dict(card_factories)
+        self._columns = max(1, int(columns))
+
+        self._cards: list[DeviceCard[T]] = []
+
+        self._build_ui()
+        self._bind_events()
+
+    @property
+    def cards(self) -> list[DeviceCard[T]]:
+        return list(self._cards)
+
+    def results(self) -> list[T]:
+        return [card.result for card in self._cards]
+
+    def load_models(self, models: Sequence[T]) -> None:
+        for model in models:
+            self.add_model(model)
+
+    def add_model(self, model: T) -> None:
+        try:
+            device_type = model.device_type
+        except Exception as exc:
+            QMessageBox.warning(
+                self,
+                "Unsupported device",
+                f"Failed to determine device type ({exc!s})",
+            )
+            return
+        if device_type is None:
+            QMessageBox.warning(
+                self,
+                "Unsupported device",
+                "Missing device type",
+            )
+            return
+
+        self._add_device_card(str(device_type), model=model)
+
+    # -----------------------------
+    # UI / Events
+    # -----------------------------
+
+    def _build_ui(self) -> None:
+        layout = QGridLayout()
+        layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        for col in range(self._columns):
+            layout.setColumnStretch(col, 1)
+        self.setLayout(layout)
+
+    def _bind_events(self) -> None:
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._open_menu)
+
+    def _open_menu(self, position) -> None:
+        menu = QMenu(self)
+        action = menu.addAction(self._action_label)
+        action.triggered.connect(lambda _checked=False: self._on_add_clicked())
+        menu.exec(self.mapToGlobal(position))
+
+    def _on_add_clicked(self) -> None:
+        dialog = AddDeviceDialog(
+            self,
+            device_types=self._device_types,
+            title=self._dialog_title,
+            label=self._label,
+        )
+        if dialog.exec() != QDialog.DialogCode.Accepted:
+            return
+
+        self._add_device_card(dialog.device_type, model=None)
+
+    # -----------------------------
+    # Cards / Layout
+    # -----------------------------
+
+    def _add_device_card(self, device_type: str, *, model: T | None) -> None:
+        card_factory = self._card_factories.get(device_type)
+        if card_factory is None:
+            QMessageBox.warning(
+                self,
+                "Unsupported device",
+                f"Unsupported device type: {device_type}",
+            )
+            return
+
+        card = card_factory()
+        if isinstance(card, DeviceCard):
+            if model is not None:
+                card.load_config(model)
+            card.remove_requested.connect(lambda c=card: self._on_remove_requested(c))
+            self._cards.append(card)
+
+        self._mount(card)
+
+    def _on_remove_requested(self, card: DeviceCard[T]) -> None:
+        self._remove_card(card)
+
+    def _remove_card(self, card: DeviceCard[T]) -> None:
+        layout = self.layout()
+        if isinstance(layout, QGridLayout):
+            layout.removeWidget(card)
+        card.setParent(None)
+        card.deleteLater()
+
+        self._reflow_cards()
+
+    def _reflow_cards(self) -> None:
+        layout = self.layout()
+        if not isinstance(layout, QGridLayout):
+            return
+
+        cards: list[DeviceCard[T]] = []
+        for i in range(layout.count()):
+            item = layout.itemAt(i)
+            if item is None:
+                continue
+            widget = item.widget()
+            if isinstance(widget, DeviceCard):
+                cards.append(widget)
+
+        while layout.count() > 0:
+            layout.takeAt(0)
+
+        self._cards = cards
+        for index, widget in enumerate(cards):
+            row, col = divmod(index, self._columns)
+            layout.addWidget(widget, row, col)
+
+    def _mount(self, widget: QWidget) -> None:
+        layout = self.layout()
+        if layout is None:
+            return
+
+        if isinstance(layout, QGridLayout):
+            index = layout.count()
+            row, col = divmod(index, self._columns)
+            layout.addWidget(widget, row, col)
+            return
+
+        layout.addWidget(widget)

mxbiflow/ui/components/dialog/__init__.py

@@ -0,0 +1,3 @@
+from .add_devices_dialog import AddDeviceDialog
+
+__all__ = ["AddDeviceDialog"]

mxbiflow/ui/components/dialog/add_devices_dialog.py

@@ -0,0 +1,64 @@
+from collections.abc import Sequence
+
+from PySide6.QtWidgets import (
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QFormLayout,
+    QLabel,
+    QVBoxLayout,
+)
+
+
+class AddDeviceDialog(QDialog):
+    """
+    Simple picker dialog.
+
+    `device_types` items can be either strings or StrEnum members (since they are `str`).
+    """
+
+    def __init__(
+        self,
+        parent=None,
+        *,
+        device_types: Sequence[str],
+        title: str = "Add device",
+        label: str = "device type:",
+    ):
+        super().__init__(parent)
+        self._device_types = device_types
+        self._title = title
+        self._label = label
+        self._init_ui()
+        self._bind_events()
+
+    def _init_ui(self):
+        self.setWindowTitle(self._title)
+
+        self._main_layout = QVBoxLayout()
+        self.setLayout(self._main_layout)
+
+        self._layout_type = QFormLayout()
+        self._main_layout.addLayout(self._layout_type)
+
+        self._label_device_type = QLabel(self._label)
+        self._comba_device_type = QComboBox()
+        self._comba_device_type.addItems([str(item) for item in self._device_types])
+        self._layout_type.addRow(self._label_device_type, self._comba_device_type)
+
+        self.button_box = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        self._main_layout.addWidget(self.button_box)
+
+    def _bind_events(self):
+        self.button_box.accepted.connect(self.accept)
+        self.button_box.rejected.connect(self.reject)
+
+    @property
+    def device_type(self) -> str:
+        return self._comba_device_type.currentText()
+
+    @property
+    def selected_device(self) -> str:
+        return self.device_type

mxbiflow/ui/components/experiment_groups.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QComboBox,
+    QFormLayout,
+    QGridLayout,
+    QGroupBox,
+    QLabel,
+    QLineEdit,
+    QMenu,
+)
+
+from ...models.animal import AnimalConfig
+from ...models.session import RewardEnum, SessionConfig
+from .animal import AnimalCard
+
+
+class ExperimentConfigGroup(QGroupBox):
+    def __init__(self, parent, experimenters: list[str]):
+        super().__init__("Config", parent)
+
+        layout = QFormLayout(self)
+        self.setLayout(layout)
+
+        lable_experimenter = QLabel("experimenter", self)
+        self.combo_experimenter = QComboBox(self)
+        self.combo_experimenter.addItems(experimenters)
+        layout.addRow(lable_experimenter, self.combo_experimenter)
+
+        lable_reward_type = QLabel("reward type", self)
+        self.combo_reward_type = QComboBox(self)
+        self.combo_reward_type.addItems(list(RewardEnum))
+        layout.addRow(lable_reward_type, self.combo_reward_type)
+
+        lable_notes = QLabel("notes", self)
+        self.line_notes = QLineEdit(self)
+        self.line_notes.setPlaceholderText("Notes")
+        layout.addRow(lable_notes, self.line_notes)
+
+    def load_config(self, config: SessionConfig):
+        self.combo_experimenter.setEditText(config.experimenter)
+        self.combo_reward_type.setEditText(config.reward_type)
+
+    def result(self) -> SessionConfig:
+        return SessionConfig(
+            experimenter=self.combo_experimenter.currentText(),
+            reward_type=RewardEnum(self.combo_reward_type.currentText()),
+            note=self.line_notes.text(),
+        )
+
+
+class ExperimentAnimalsGroup(QGroupBox):
+    def __init__(self, parent=None, *, animals: dict[str, str]):
+        super().__init__("Animals", parent)
+
+        self._animals = animals
+        self.layout_animals = QGridLayout(self)
+        self.setLayout(self.layout_animals)
+
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.customContextMenuRequested.connect(self._on_context_menu)
+
+    def _on_context_menu(self, pos):
+        menu = QMenu(self)
+        action = menu.addAction("Add animal")
+        action.triggered.connect(lambda _checked=False: self._on_add_animal())
+        menu.exec(self.mapToGlobal(pos))
+
+    def _on_add_animal(self):
+        animal_card = AnimalCard(self, self._animals)
+        animal_card.remove_requested.connect(
+            lambda _card=animal_card: self._on_remove_animal(_card)
+        )
+        self._add_animal_card(animal_card)
+
+    def _add_animal_card(self, animal_card: AnimalCard) -> None:
+        index = self.layout_animals.count()
+        row = index // 4
+        col = index % 4
+        self.layout_animals.addWidget(animal_card, row, col)
+
+    def _on_remove_animal(self, animal_card: AnimalCard) -> None:
+        self.layout_animals.removeWidget(animal_card)
+        animal_card.setParent(None)
+        animal_card.deleteLater()
+        self._reflow_animal_cards()
+
+    def _reflow_animal_cards(self) -> None:
+        cards: list[AnimalCard] = []
+        for i in range(self.layout_animals.count()):
+            item = self.layout_animals.itemAt(i)
+            if item:
+                widget = item.widget()
+                if isinstance(widget, AnimalCard):
+                    cards.append(widget)
+
+        while self.layout_animals.count() > 0:
+            self.layout_animals.takeAt(0)
+
+        for card in cards:
+            self._add_animal_card(card)
+
+    def load_config(self, config: SessionConfig):
+        for animal_configs in config.animals:
+            animal_card = AnimalCard(self, self._animals)
+            animal_card.load_config(animal_configs)
+            animal_card.remove_requested.connect(
+                lambda _card=animal_card: self._on_remove_animal(_card)
+            )
+            self._add_animal_card(animal_card)
+
+    def result(self) -> list[AnimalConfig]:
+        results: list[AnimalConfig] = []
+        for i in range(self.layout_animals.count()):
+            item = self.layout_animals.itemAt(i)
+            if not item:
+                continue
+            widget = item.widget()
+            if isinstance(widget, AnimalCard):
+                results.append(widget.result)
+        return results

mxbiflow/ui/experiment_panel.py

@@ -0,0 +1,91 @@
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QMainWindow,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..config_store import ConfigStore
+from ..models.session import Options, SessionConfig
+from ..path import OPTIONS_PATH, SESSION_CONFIG_PATH
+from .components.experiment_groups import ExperimentAnimalsGroup, ExperimentConfigGroup
+
+
+class ExperimentPanel(QMainWindow):
+    accepted = Signal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._config = ConfigStore(SESSION_CONFIG_PATH, SessionConfig)
+        self._options = ConfigStore(OPTIONS_PATH, Options)
+
+        self.setWindowTitle("Experiment Panel")
+
+        central_widget = QWidget(self)
+        self.setCentralWidget(central_widget)
+
+        layout_main = QVBoxLayout(self)
+        central_widget.setLayout(layout_main)
+
+        self.group_config = ExperimentConfigGroup(
+            self, self._options.value.experimenter
+        )
+        layout_main.addWidget(self.group_config)
+
+        self.group_animals = ExperimentAnimalsGroup(
+            self, animals=self._options.value.animals
+        )
+        layout_main.addWidget(self.group_animals)
+
+        self.combo_experimenter = self.group_config.combo_experimenter
+        self.combo_reward_type = self.group_config.combo_reward_type
+        self.line_notes = self.group_config.line_notes
+
+        layout_buttons = QHBoxLayout(self)
+        layout_main.addLayout(layout_buttons)
+        self._button_cancle = QPushButton("Cancel", self)
+        self._button_save = QPushButton("Save", self)
+        self._button_continue = QPushButton("Continue", self)
+        layout_buttons.addWidget(self._button_cancle)
+        layout_buttons.addWidget(self._button_save)
+        layout_buttons.addWidget(self._button_continue)
+
+        self._bind_signals()
+        self.load_config()
+
+    def _bind_signals(self):
+        self._button_cancle.clicked.connect(self._on_cancle)
+        self._button_save.clicked.connect(self._on_save)
+        self._button_continue.clicked.connect(self._on_continue)
+
+    def load_config(self):
+        self.group_config.load_config(self._config.value)
+        self.group_animals.load_config(self._config.value)
+
+    def result(self) -> SessionConfig:
+        session_config = self.group_config.result()
+        session_config.animals = self.group_animals.result()
+        return session_config
+
+    def _on_save(self):
+        self._config.save(self.result())
+
+    def _on_cancle(self):
+        self.close()
+
+    def _on_continue(self):
+        self._on_save()
+        self.close()
+        self.accepted.emit()
+
+
+if __name__ == "__main__":
+    import sys
+
+    app = QApplication(sys.argv)
+    experiment_panel = ExperimentPanel()
+    experiment_panel.show()
+    sys.exit(app.exec())