From 8121fcb6492f121d4a63f3586cd0956de8bc5339 Mon Sep 17 00:00:00 2001 From: hazlamshamin Date: Tue, 26 May 2026 16:13:02 +0800 Subject: [PATCH 1/4] Electroporation: add prepared-run capability --- docs/api/pylabrobot.capabilities.rst | 39 +++ .../capabilities/electroporation.ipynb | 170 +++++++++++ docs/user_guide/capabilities/index.md | 1 + .../capabilities/electroporation/__init__.py | 14 + .../capabilities/electroporation/backend.py | 52 ++++ .../electroporation/chatterbox.py | 192 ++++++++++++ .../electroporation/electroporation.py | 67 ++++ .../electroporation/electroporation_tests.py | 287 ++++++++++++++++++ .../capabilities/electroporation/standard.py | 258 ++++++++++++++++ 9 files changed, 1080 insertions(+) create mode 100644 docs/user_guide/capabilities/electroporation.ipynb create mode 100644 pylabrobot/capabilities/electroporation/__init__.py create mode 100644 pylabrobot/capabilities/electroporation/backend.py create mode 100644 pylabrobot/capabilities/electroporation/chatterbox.py create mode 100644 pylabrobot/capabilities/electroporation/electroporation.py create mode 100644 pylabrobot/capabilities/electroporation/electroporation_tests.py create mode 100644 pylabrobot/capabilities/electroporation/standard.py diff --git a/docs/api/pylabrobot.capabilities.rst b/docs/api/pylabrobot.capabilities.rst index 666ce292e20..7e76be10b6d 100644 --- a/docs/api/pylabrobot.capabilities.rst +++ b/docs/api/pylabrobot.capabilities.rst @@ -220,6 +220,45 @@ Automated Retrieval AutomatedRetrievalBackend +Electroporation +--------------- + +.. currentmodule:: pylabrobot.capabilities.electroporation.electroporation + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + Electroporation + +.. currentmodule:: pylabrobot.capabilities.electroporation.backend + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + ElectroporationBackend + +.. currentmodule:: pylabrobot.capabilities.electroporation.standard + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + ElectroporationProtocol + PreparedElectroporationRun + ElectroporationRunResult + ElectroporationCancellationResult + ElectroporationPreparationDetails + ElectroporationExecutionDetails + ElectroporationCancellationDetails + ElectroporationLogCapture + ElectroporationCleanup + + Plate Reading - Absorbance -------------------------- diff --git a/docs/user_guide/capabilities/electroporation.ipynb b/docs/user_guide/capabilities/electroporation.ipynb new file mode 100644 index 00000000000..2d602454199 --- /dev/null +++ b/docs/user_guide/capabilities/electroporation.ipynb @@ -0,0 +1,170 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro", + "metadata": {}, + "source": [ + "# Electroporation\n", + "\n", + "{class}`~pylabrobot.capabilities.electroporation.electroporation.Electroporation` prepares, starts, and cancels electroporation runs.\n", + "\n", + "The standard workflow is a prepared run: first create a temporary protocol on the device and leave the instrument armed on its run screen, then start that prepared run when the labware and safety interlocks are ready.\n", + "\n", + "## Walkthrough\n", + "\n", + "This example uses a chatterbox backend so the workflow can be run without hardware." + ] + }, + { + "cell_type": "code", + "id": "setup-code", + "metadata": {}, + "source": [ + "from pylabrobot.capabilities.electroporation import (\n", + " Electroporation,\n", + " ElectroporationChatterboxBackend,\n", + " ElectroporationProtocol,\n", + ")\n", + "\n", + "electroporator = Electroporation(backend=ElectroporationChatterboxBackend())\n", + "await electroporator._on_setup()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "protocol-md", + "metadata": {}, + "source": [ + "Define a protocol. Square-wave protocols use `duration_us`; exponential-decay protocols use `resistance_ohms` and `capacitance_uf`." + ] + }, + { + "cell_type": "code", + "id": "protocol-code", + "metadata": {}, + "source": [ + "protocol = ElectroporationProtocol(\n", + " protocol_type=\"square\",\n", + " pulse_amplitude_volts=250,\n", + " gap_mm=2.0,\n", + " pulse_count=1,\n", + " pulse_interval_seconds=0.0,\n", + " duration_us=1000,\n", + ")" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "prepare-md", + "metadata": {}, + "source": [ + "Prepare the run. On real hardware this writes a temporary protocol and leaves the device on the run screen. `plate_columns` is used by high-throughput plate-handler workflows." + ] + }, + { + "cell_type": "code", + "id": "prepare-code", + "metadata": {}, + "source": [ + "prepared = await electroporator.prepare_temporary_protocol(\n", + " protocol=protocol,\n", + " plate_columns=3,\n", + ")\n", + "prepared.protocol_name" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "serialize-md", + "metadata": {}, + "source": [ + "Prepared runs are serializable so a later process can resume from the same armed state." + ] + }, + { + "cell_type": "code", + "id": "serialize-code", + "metadata": {}, + "source": [ + "prepared_payload = prepared.as_dict()\n", + "prepared_payload[\"protocol_name\"]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "start-md", + "metadata": {}, + "source": [ + "Start the prepared run and collect the result. Hardware backends may include device logs and cleanup information in the result." + ] + }, + { + "cell_type": "code", + "id": "start-code", + "metadata": {}, + "source": [ + "result = await electroporator.start_prepared_run(prepared)\n", + "result.log_capture.summary" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "cancel-md", + "metadata": {}, + "source": [ + "To arm a protocol but then stop before pulse delivery, cancel the prepared run." + ] + }, + { + "cell_type": "code", + "id": "cancel-code", + "metadata": {}, + "source": [ + "prepared = await electroporator.prepare_temporary_protocol(protocol=protocol)\n", + "cancelled = await electroporator.cancel_prepared_run(prepared)\n", + "cancelled.cleanup.deleted" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "id": "reference-md", + "metadata": {}, + "source": [ + "## Supported hardware\n", + "\n", + "```{supported-devices} electroporation\n", + "```\n", + "\n", + "## API reference\n", + "\n", + "See {class}`~pylabrobot.capabilities.electroporation.electroporation.Electroporation`, {class}`~pylabrobot.capabilities.electroporation.backend.ElectroporationBackend`, and {class}`~pylabrobot.capabilities.electroporation.standard.ElectroporationProtocol`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user_guide/capabilities/index.md b/docs/user_guide/capabilities/index.md index 2a091c83f64..f1f0bd562e2 100644 --- a/docs/user_guide/capabilities/index.md +++ b/docs/user_guide/capabilities/index.md @@ -57,6 +57,7 @@ weighing barcode-scanning microscopy automated-retrieval +electroporation absorbance fluorescence luminescence diff --git a/pylabrobot/capabilities/electroporation/__init__.py b/pylabrobot/capabilities/electroporation/__init__.py new file mode 100644 index 00000000000..2fd1b64782a --- /dev/null +++ b/pylabrobot/capabilities/electroporation/__init__.py @@ -0,0 +1,14 @@ +from .backend import ElectroporationBackend +from .chatterbox import ElectroporationChatterboxBackend +from .electroporation import Electroporation +from .standard import ( + ElectroporationCancellationDetails, + ElectroporationCancellationResult, + ElectroporationCleanup, + ElectroporationExecutionDetails, + ElectroporationLogCapture, + ElectroporationPreparationDetails, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) diff --git a/pylabrobot/capabilities/electroporation/backend.py b/pylabrobot/capabilities/electroporation/backend.py new file mode 100644 index 00000000000..a97d252b153 --- /dev/null +++ b/pylabrobot/capabilities/electroporation/backend.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +from abc import ABCMeta, abstractmethod +from typing import Any, Dict, Mapping, Optional, Union + +from pylabrobot.capabilities.capability import BackendParams, CapabilityBackend +from pylabrobot.capabilities.electroporation.standard import ( + ElectroporationCancellationResult, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) + + +class ElectroporationBackend(CapabilityBackend, metaclass=ABCMeta): + """Minimal backend contract for electroporators. + + The common surface is built around the real lab workflow: + prepare a temporary protocol before loading the plate, then start or cancel the prepared run. + Device-specific developer helpers belong on concrete vendor backends. + """ + + @abstractmethod + async def prepare_temporary_protocol( + self, + protocol: ElectroporationProtocol, + plate_columns: Optional[int] = None, + prefix: Optional[str] = None, + backend_params: Optional[BackendParams] = None, + ) -> PreparedElectroporationRun: + """Create a temporary protocol and leave the device armed on the pre-run screen.""" + + @abstractmethod + async def start_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> ElectroporationRunResult: + """Verify and start a previously prepared run.""" + + @abstractmethod + async def cancel_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + ) -> ElectroporationCancellationResult: + """Cancel a previously prepared run and remove the temporary protocol.""" + + @abstractmethod + async def get_device_info(self) -> Dict[str, Any]: + """Return device identity and capability information.""" diff --git a/pylabrobot/capabilities/electroporation/chatterbox.py b/pylabrobot/capabilities/electroporation/chatterbox.py new file mode 100644 index 00000000000..5b086f9f2cb --- /dev/null +++ b/pylabrobot/capabilities/electroporation/chatterbox.py @@ -0,0 +1,192 @@ +from __future__ import annotations + +import logging +from datetime import datetime, timezone +from typing import Any, Dict, Mapping, Optional, Union + +from pylabrobot.capabilities.capability import BackendParams + +from .backend import ElectroporationBackend +from .standard import ( + ElectroporationCancellationDetails, + ElectroporationCancellationResult, + ElectroporationCleanup, + ElectroporationExecutionDetails, + ElectroporationLogCapture, + ElectroporationPreparationDetails, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) + +logger = logging.getLogger(__name__) + + +class ElectroporationChatterboxBackend(ElectroporationBackend): + """Chatterbox backend for device-free electroporation workflow tests.""" + + DEFAULT_TEMPORARY_PROTOCOL_PREFIX = "!PLR" + + def __init__( + self, + temporary_protocol_prefix: str = DEFAULT_TEMPORARY_PROTOCOL_PREFIX, + ) -> None: + self.temporary_protocol_prefix = temporary_protocol_prefix + self._counter = 0 + self.prepared_runs: Dict[str, PreparedElectroporationRun] = {} + + async def prepare_temporary_protocol( + self, + protocol: ElectroporationProtocol, + plate_columns: Optional[int] = None, + prefix: Optional[str] = None, + backend_params: Optional[BackendParams] = None, + ) -> PreparedElectroporationRun: + del backend_params + resolved_prefix = self.temporary_protocol_prefix if prefix is None else prefix + protocol_name = self._make_temporary_protocol_name(resolved_prefix) + logger.info( + "Preparing simulated electroporation protocol %s with plate_columns=%s.", + protocol_name, + plate_columns, + ) + + prepared = PreparedElectroporationRun( + protocol_name=protocol_name, + protocol=protocol, + plate_columns=plate_columns, + prefix=resolved_prefix, + prepared_at_utc=self._now_utc_iso(), + baseline_log_paths=(), + prepare_result=ElectroporationPreparationDetails( + prepared_state="protocol_run_view", + protocol_setup={ + "operation": "add_protocol", + "protocol": protocol_name, + "simulated": True, + "exists_after": True, + }, + device_prepare={ + "prepared_verification": {"state": "protocol_run_view"}, + "plate_columns": plate_columns, + "simulated": True, + }, + ), + ) + self.prepared_runs[protocol_name] = prepared + return prepared + + async def start_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> ElectroporationRunResult: + prepared = self._coerce_prepared_run(prepared_run) + logger.info( + "Starting simulated electroporation protocol %s with max_run_seconds=%s.", + prepared.protocol_name, + max_run_seconds, + ) + completed_state = "protocol_finish" + final_state = "main_menu" if home_after else completed_state + + return ElectroporationRunResult( + prepared_run=prepared, + started_at_utc=self._now_utc_iso(), + completed_at_utc=self._now_utc_iso(), + rsi_result=ElectroporationExecutionDetails( + verification_state="protocol_run_view", + completed_state=completed_state, + final_state=final_state, + device_run={ + "verification": {"state": "protocol_run_view"}, + "after_start": {"state": "protocol_run_view"}, + "completed": {"state": completed_state}, + "home": None if not home_after else {"state": "main_menu"}, + "simulated": True, + }, + ), + log_capture=ElectroporationLogCapture( + matched_log_path=None, + summary={ + "protocol": prepared.protocol_name, + "pulse_count": prepared.protocol.pulse_count, + "simulated": True, + }, + details={ + "before_count": 0, + "after_count": 0, + "new_log_paths": [], + "matched_log_path": None, + "matched_log": None, + "simulated": True, + }, + ), + cleanup=self._cleanup_temporary_protocol(prepared.protocol_name), + ) + + async def cancel_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + ) -> ElectroporationCancellationResult: + prepared = self._coerce_prepared_run(prepared_run) + final_state = "main_menu" if home_after else "protocol_run_view" + logger.info("Cancelling simulated electroporation protocol %s.", prepared.protocol_name) + + return ElectroporationCancellationResult( + prepared_run=prepared, + cancelled_at_utc=self._now_utc_iso(), + rsi_result=ElectroporationCancellationDetails( + final_state=final_state, + device_cancel={ + "cancelled": True, + "final_state": {"state": final_state}, + "simulated": True, + }, + ), + cleanup=self._cleanup_temporary_protocol(prepared.protocol_name), + ) + + async def get_device_info(self) -> Dict[str, Any]: + return { + "backend": self.__class__.__name__, + "model": "Chatterbox Electroporator", + "supports_prepared_temporary_runs": True, + "supports_serialized_prepared_runs": True, + "supports_stored_protocol_runs": False, + "supports_plate_columns": True, + "temporary_protocol_prefix": self.temporary_protocol_prefix, + "simulated": True, + } + + def _make_temporary_protocol_name(self, prefix: str) -> str: + self._counter += 1 + return f"{prefix}_{self._counter:06d}" + + def _coerce_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + ) -> PreparedElectroporationRun: + if isinstance(prepared_run, PreparedElectroporationRun): + return prepared_run + return PreparedElectroporationRun.from_dict(prepared_run) + + def _cleanup_temporary_protocol(self, protocol_name: str) -> ElectroporationCleanup: + known_prepared_run = protocol_name in self.prepared_runs + self.prepared_runs.pop(protocol_name, None) + return ElectroporationCleanup( + deleted=True, + retry_used=False, + error=None, + details={ + "operation": "delete_protocol", + "protocol": protocol_name, + "known_prepared_run": known_prepared_run, + "simulated": True, + }, + ) + + def _now_utc_iso(self) -> str: + return datetime.now(timezone.utc).isoformat() diff --git a/pylabrobot/capabilities/electroporation/electroporation.py b/pylabrobot/capabilities/electroporation/electroporation.py new file mode 100644 index 00000000000..c6749fdac3b --- /dev/null +++ b/pylabrobot/capabilities/electroporation/electroporation.py @@ -0,0 +1,67 @@ +from __future__ import annotations + +from typing import Any, Dict, Mapping, Optional, Union + +from pylabrobot.capabilities.capability import BackendParams, Capability, need_capability_ready +from pylabrobot.capabilities.electroporation.backend import ElectroporationBackend +from pylabrobot.capabilities.electroporation.standard import ( + ElectroporationCancellationResult, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) + + +class Electroporation(Capability): + """Electroporation capability. + + This frontend intentionally stays small and exposes the prepared-run workflow shared by + supported electroporators. + """ + + def __init__(self, backend: ElectroporationBackend): + super().__init__(backend=backend) + self.backend: ElectroporationBackend = backend + + @need_capability_ready + async def prepare_temporary_protocol( + self, + protocol: ElectroporationProtocol, + plate_columns: Optional[int] = None, + prefix: Optional[str] = None, + backend_params: Optional[BackendParams] = None, + ) -> PreparedElectroporationRun: + return await self.backend.prepare_temporary_protocol( + protocol=protocol, + plate_columns=plate_columns, + prefix=prefix, + backend_params=backend_params, + ) + + @need_capability_ready + async def start_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> ElectroporationRunResult: + return await self.backend.start_prepared_run( + prepared_run=prepared_run, + home_after=home_after, + max_run_seconds=max_run_seconds, + ) + + @need_capability_ready + async def cancel_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + ) -> ElectroporationCancellationResult: + return await self.backend.cancel_prepared_run( + prepared_run=prepared_run, + home_after=home_after, + ) + + @need_capability_ready + async def get_device_info(self) -> Dict[str, Any]: + return await self.backend.get_device_info() diff --git a/pylabrobot/capabilities/electroporation/electroporation_tests.py b/pylabrobot/capabilities/electroporation/electroporation_tests.py new file mode 100644 index 00000000000..89facf28914 --- /dev/null +++ b/pylabrobot/capabilities/electroporation/electroporation_tests.py @@ -0,0 +1,287 @@ +"""Tests for Electroporation.""" + +import unittest +from typing import Any, Dict, Mapping, Optional, Union + +from pylabrobot.capabilities.capability import BackendParams +from pylabrobot.capabilities.electroporation.backend import ElectroporationBackend +from pylabrobot.capabilities.electroporation.chatterbox import ElectroporationChatterboxBackend +from pylabrobot.capabilities.electroporation.electroporation import Electroporation +from pylabrobot.capabilities.electroporation.standard import ( + ElectroporationCancellationDetails, + ElectroporationCancellationResult, + ElectroporationCleanup, + ElectroporationExecutionDetails, + ElectroporationLogCapture, + ElectroporationPreparationDetails, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) + + +class _Params(BackendParams): + pass + + +def _square_protocol() -> ElectroporationProtocol: + return ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + +def _prepared_run(protocol: Optional[ElectroporationProtocol] = None) -> PreparedElectroporationRun: + protocol = protocol or _square_protocol() + return PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=protocol, + plate_columns=None, + prefix="!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(), + prepare_result=ElectroporationPreparationDetails( + prepared_state="protocol_run_view", + protocol_setup={}, + device_prepare={}, + ), + ) + + +class _RecordingElectroporationBackend(ElectroporationBackend): + def __init__(self) -> None: + self.setup_params: Optional[BackendParams] = None + self.stop_calls = 0 + self.calls: list[dict[str, Any]] = [] + + async def _on_setup(self, backend_params: Optional[BackendParams] = None): + self.setup_params = backend_params + + async def _on_stop(self): + self.stop_calls += 1 + + async def prepare_temporary_protocol( + self, + protocol: ElectroporationProtocol, + plate_columns: Optional[int] = None, + prefix: Optional[str] = None, + backend_params: Optional[BackendParams] = None, + ) -> PreparedElectroporationRun: + self.calls.append( + { + "method": "prepare", + "protocol": protocol, + "plate_columns": plate_columns, + "prefix": prefix, + "backend_params": backend_params, + } + ) + return PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=protocol, + plate_columns=plate_columns, + prefix=prefix or "!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(r"\BTXDATA\baseline.TXT",), + prepare_result=ElectroporationPreparationDetails( + prepared_state="protocol_run_view", + protocol_setup={}, + device_prepare={}, + ), + ) + + async def start_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> ElectroporationRunResult: + prepared = ( + prepared_run + if isinstance(prepared_run, PreparedElectroporationRun) + else PreparedElectroporationRun.from_dict(prepared_run) + ) + self.calls.append( + { + "method": "start", + "prepared_run": prepared, + "home_after": home_after, + "max_run_seconds": max_run_seconds, + } + ) + return ElectroporationRunResult( + prepared_run=prepared, + started_at_utc="2026-03-09T10:01:00+00:00", + completed_at_utc="2026-03-09T10:02:00+00:00", + rsi_result=ElectroporationExecutionDetails( + verification_state="protocol_run_view", + completed_state="protocol_finish", + final_state="main_menu", + device_run={}, + ), + log_capture=ElectroporationLogCapture( + matched_log_path=None, + summary={}, + details={}, + ), + cleanup=ElectroporationCleanup( + deleted=True, + retry_used=False, + error=None, + details={}, + ), + ) + + async def cancel_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + ) -> ElectroporationCancellationResult: + prepared = ( + prepared_run + if isinstance(prepared_run, PreparedElectroporationRun) + else PreparedElectroporationRun.from_dict(prepared_run) + ) + self.calls.append( + { + "method": "cancel", + "prepared_run": prepared, + "home_after": home_after, + } + ) + return ElectroporationCancellationResult( + prepared_run=prepared, + cancelled_at_utc="2026-03-09T10:01:00+00:00", + rsi_result=ElectroporationCancellationDetails( + final_state="main_menu", + device_cancel={}, + ), + cleanup=ElectroporationCleanup( + deleted=True, + retry_used=False, + error=None, + details={}, + ), + ) + + async def get_device_info(self) -> Dict[str, Any]: + self.calls.append({"method": "get_device_info"}) + return {"model": "test electroporator"} + + +class TestElectroporation(unittest.IsolatedAsyncioTestCase): + async def test_prepare_temporary_protocol_forwards_to_backend(self): + backend = _RecordingElectroporationBackend() + cap = Electroporation(backend=backend) + setup_params = _Params() + prepare_params = _Params() + protocol = _square_protocol() + + await cap._on_setup(backend_params=setup_params) + prepared = await cap.prepare_temporary_protocol( + protocol=protocol, + plate_columns=3, + prefix="!TMP", + backend_params=prepare_params, + ) + + self.assertIs(backend.setup_params, setup_params) + self.assertEqual(prepared.protocol_name, "!PLR_123456789") + self.assertEqual(prepared.protocol, protocol) + self.assertEqual(prepared.plate_columns, 3) + self.assertEqual(prepared.prefix, "!TMP") + self.assertEqual( + backend.calls[0], + { + "method": "prepare", + "protocol": protocol, + "plate_columns": 3, + "prefix": "!TMP", + "backend_params": prepare_params, + }, + ) + + async def test_start_and_cancel_prepared_run_forward_to_backend(self): + backend = _RecordingElectroporationBackend() + cap = Electroporation(backend=backend) + prepared = _prepared_run() + + await cap._on_setup() + started = await cap.start_prepared_run( + prepared.as_dict(), + home_after=False, + max_run_seconds=12.0, + ) + cancelled = await cap.cancel_prepared_run(prepared, home_after=False) + + self.assertEqual(started.prepared_run, prepared) + self.assertEqual(cancelled.prepared_run, prepared) + self.assertEqual(backend.calls[0]["method"], "start") + self.assertEqual(backend.calls[0]["prepared_run"], prepared) + self.assertEqual(backend.calls[0]["home_after"], False) + self.assertEqual(backend.calls[0]["max_run_seconds"], 12.0) + self.assertEqual(backend.calls[1]["method"], "cancel") + self.assertEqual(backend.calls[1]["prepared_run"], prepared) + self.assertEqual(backend.calls[1]["home_after"], False) + + async def test_methods_require_setup(self): + backend = _RecordingElectroporationBackend() + cap = Electroporation(backend=backend) + + with self.assertRaisesRegex(RuntimeError, "capability has not been set up"): + await cap.prepare_temporary_protocol(_square_protocol()) + + async def test_get_device_info_forwards_and_stop_resets_setup(self): + backend = _RecordingElectroporationBackend() + cap = Electroporation(backend=backend) + + await cap._on_setup() + info = await cap.get_device_info() + await cap._on_stop() + + self.assertEqual(info, {"model": "test electroporator"}) + self.assertFalse(cap.setup_finished) + self.assertEqual(backend.stop_calls, 1) + + async def test_chatterbox_prepares_and_starts_serialized_run(self): + backend = ElectroporationChatterboxBackend() + cap = Electroporation(backend=backend) + protocol = _square_protocol() + + await cap._on_setup() + prepared = await cap.prepare_temporary_protocol(protocol, plate_columns=3) + started = await cap.start_prepared_run(prepared.as_dict(), home_after=False) + + self.assertEqual(prepared.protocol_name, "!PLR_000001") + self.assertEqual(prepared.protocol, protocol) + self.assertEqual(prepared.plate_columns, 3) + self.assertEqual(started.prepared_run, prepared) + self.assertEqual(started.rsi_result.verification_state, "protocol_run_view") + self.assertEqual(started.rsi_result.completed_state, "protocol_finish") + self.assertEqual(started.rsi_result.final_state, "protocol_finish") + self.assertEqual(started.log_capture.summary["protocol"], prepared.protocol_name) + self.assertTrue(started.cleanup.deleted) + self.assertNotIn(prepared.protocol_name, backend.prepared_runs) + + async def test_chatterbox_cancels_prepared_run_and_reports_info(self): + backend = ElectroporationChatterboxBackend(temporary_protocol_prefix="!SIM") + cap = Electroporation(backend=backend) + + await cap._on_setup() + info = await cap.get_device_info() + prepared = await cap.prepare_temporary_protocol(_square_protocol()) + cancelled = await cap.cancel_prepared_run(prepared, home_after=True) + + self.assertEqual(info["backend"], "ElectroporationChatterboxBackend") + self.assertEqual(info["temporary_protocol_prefix"], "!SIM") + self.assertEqual(prepared.protocol_name, "!SIM_000001") + self.assertEqual(cancelled.prepared_run, prepared) + self.assertEqual(cancelled.rsi_result.final_state, "main_menu") + self.assertTrue(cancelled.cleanup.deleted) + self.assertNotIn(prepared.protocol_name, backend.prepared_runs) + + +if __name__ == "__main__": + unittest.main() diff --git a/pylabrobot/capabilities/electroporation/standard.py b/pylabrobot/capabilities/electroporation/standard.py new file mode 100644 index 00000000000..8f4aeb24663 --- /dev/null +++ b/pylabrobot/capabilities/electroporation/standard.py @@ -0,0 +1,258 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any, Dict, Mapping, Optional + + +@dataclass(frozen=True) +class ElectroporationProtocol: + """Portable protocol definition for electroporation runs. + + Exactly one waveform-specific parameter set must be present: + - `square`: `duration_us` + - `exponential`: `resistance_ohms` and `capacitance_uf` + """ + + protocol_type: str + pulse_amplitude_volts: int + gap_mm: float + pulse_count: int = 1 + pulse_interval_seconds: Optional[float] = None + duration_us: Optional[int] = None + resistance_ohms: Optional[int] = None + capacitance_uf: Optional[int] = None + + def as_parameters(self) -> Dict[str, Any]: + return { + "protocol_type": self.protocol_type, + "pulse_amplitude_volts": self.pulse_amplitude_volts, + "gap_mm": self.gap_mm, + "pulse_count": self.pulse_count, + "pulse_interval_seconds": self.pulse_interval_seconds, + "duration_us": self.duration_us, + "resistance_ohms": self.resistance_ohms, + "capacitance_uf": self.capacitance_uf, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationProtocol": + return cls( + protocol_type=str(data["protocol_type"]), + pulse_amplitude_volts=int(data["pulse_amplitude_volts"]), + gap_mm=float(data["gap_mm"]), + pulse_count=int(data.get("pulse_count", 1)), + pulse_interval_seconds=( + None + if data.get("pulse_interval_seconds") is None + else float(data["pulse_interval_seconds"]) + ), + duration_us=None if data.get("duration_us") is None else int(data["duration_us"]), + resistance_ohms=( + None if data.get("resistance_ohms") is None else int(data["resistance_ohms"]) + ), + capacitance_uf=None if data.get("capacitance_uf") is None else int(data["capacitance_uf"]), + ) + + +@dataclass(frozen=True) +class ElectroporationPreparationDetails: + """Generic preparation details for a prepared electroporation run.""" + + prepared_state: Optional[str] + protocol_setup: Dict[str, Any] + device_prepare: Dict[str, Any] + + def as_dict(self) -> Dict[str, Any]: + return { + "prepared_state": self.prepared_state, + "protocol_setup": self.protocol_setup, + "device_prepare": self.device_prepare, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationPreparationDetails": + return cls( + prepared_state=None if data["prepared_state"] is None else str(data["prepared_state"]), + protocol_setup=dict(data["protocol_setup"]), + device_prepare=dict(data["device_prepare"]), + ) + + +@dataclass(frozen=True) +class ElectroporationExecutionDetails: + """Generic device-run details for a started electroporation run.""" + + verification_state: Optional[str] + completed_state: Optional[str] + final_state: Optional[str] + device_run: Dict[str, Any] + + def as_dict(self) -> Dict[str, Any]: + return { + "verification_state": self.verification_state, + "completed_state": self.completed_state, + "final_state": self.final_state, + "device_run": self.device_run, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationExecutionDetails": + return cls( + verification_state=( + None if data["verification_state"] is None else str(data["verification_state"]) + ), + completed_state=None if data["completed_state"] is None else str(data["completed_state"]), + final_state=None if data["final_state"] is None else str(data["final_state"]), + device_run=dict(data["device_run"]), + ) + + +@dataclass(frozen=True) +class ElectroporationCancellationDetails: + """Generic device-cancel details for a prepared electroporation run.""" + + final_state: Optional[str] + device_cancel: Dict[str, Any] + + def as_dict(self) -> Dict[str, Any]: + return { + "final_state": self.final_state, + "device_cancel": self.device_cancel, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationCancellationDetails": + return cls( + final_state=None if data["final_state"] is None else str(data["final_state"]), + device_cancel=dict(data["device_cancel"]), + ) + + +@dataclass(frozen=True) +class ElectroporationLogCapture: + """Generic log-capture result for an electroporation run.""" + + matched_log_path: Optional[str] + summary: Dict[str, Any] + details: Dict[str, Any] + + def as_dict(self) -> Dict[str, Any]: + return { + "matched_log_path": self.matched_log_path, + "summary": self.summary, + "details": self.details, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationLogCapture": + return cls( + matched_log_path=None if data["matched_log_path"] is None else str(data["matched_log_path"]), + summary=dict(data["summary"]), + details=dict(data["details"]), + ) + + +@dataclass(frozen=True) +class ElectroporationCleanup: + """Generic cleanup result after a prepared or completed electroporation run.""" + + deleted: Optional[bool] + retry_used: bool + error: Optional[str] + details: Dict[str, Any] + + def as_dict(self) -> Dict[str, Any]: + return { + "deleted": self.deleted, + "retry_used": self.retry_used, + "error": self.error, + "details": self.details, + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "ElectroporationCleanup": + return cls( + deleted=None if data["deleted"] is None else bool(data["deleted"]), + retry_used=bool(data["retry_used"]), + error=None if data["error"] is None else str(data["error"]), + details=dict(data["details"]), + ) + + +@dataclass(frozen=True) +class PreparedElectroporationRun: + """Prepared temporary run left armed on the device run screen. + + Serialize with `as_dict()` and restore with `from_dict()` in a later process. + """ + + protocol_name: str + protocol: ElectroporationProtocol + plate_columns: Optional[int] + prefix: str + prepared_at_utc: str + baseline_log_paths: tuple[str, ...] + prepare_result: ElectroporationPreparationDetails + + def as_dict(self) -> Dict[str, Any]: + return { + "protocol_name": self.protocol_name, + "protocol": self.protocol.as_parameters(), + "plate_columns": self.plate_columns, + "prefix": self.prefix, + "prepared_at_utc": self.prepared_at_utc, + "baseline_log_paths": list(self.baseline_log_paths), + "prepare_result": self.prepare_result.as_dict(), + } + + @classmethod + def from_dict(cls, data: Mapping[str, Any]) -> "PreparedElectroporationRun": + return cls( + protocol_name=str(data["protocol_name"]), + protocol=ElectroporationProtocol.from_dict(data["protocol"]), + plate_columns=None if data["plate_columns"] is None else int(data["plate_columns"]), + prefix=str(data["prefix"]), + prepared_at_utc=str(data["prepared_at_utc"]), + baseline_log_paths=tuple(str(path) for path in data["baseline_log_paths"]), + prepare_result=ElectroporationPreparationDetails.from_dict(data["prepare_result"]), + ) + + +@dataclass(frozen=True) +class ElectroporationRunResult: + """Result of starting a previously prepared electroporation run.""" + + prepared_run: PreparedElectroporationRun + started_at_utc: str + completed_at_utc: str + rsi_result: ElectroporationExecutionDetails + log_capture: ElectroporationLogCapture + cleanup: ElectroporationCleanup + + def as_dict(self) -> Dict[str, Any]: + return { + "prepared_run": self.prepared_run.as_dict(), + "started_at_utc": self.started_at_utc, + "completed_at_utc": self.completed_at_utc, + "rsi_result": self.rsi_result.as_dict(), + "log_capture": self.log_capture.as_dict(), + "cleanup": self.cleanup.as_dict(), + } + + +@dataclass(frozen=True) +class ElectroporationCancellationResult: + """Result of cancelling a prepared temporary electroporation run.""" + + prepared_run: PreparedElectroporationRun + cancelled_at_utc: str + rsi_result: ElectroporationCancellationDetails + cleanup: ElectroporationCleanup + + def as_dict(self) -> Dict[str, Any]: + return { + "prepared_run": self.prepared_run.as_dict(), + "cancelled_at_utc": self.cancelled_at_utc, + "rsi_result": self.rsi_result.as_dict(), + "cleanup": self.cleanup.as_dict(), + } From 4c7dcea48b1c7c2cc5e21b21c428c8e44954c354 Mon Sep 17 00:00:00 2001 From: hazlamshamin Date: Tue, 26 May 2026 16:13:10 +0800 Subject: [PATCH 2/4] BTX: add Gemini X2 electroporation backend --- .github/actions/run-tests/action.yml | 4 + .github/workflows/test.yml | 2 +- docs/api/pylabrobot.btx.rst | 45 + docs/api/pylabrobot.rst | 1 + pylabrobot/btx/__init__.py | 4 + pylabrobot/btx/file_transfer_control.py | 993 +++++++++++++++ pylabrobot/btx/file_transfer_control_tests.py | 486 ++++++++ pylabrobot/btx/gemini_x2.py | 740 ++++++++++++ pylabrobot/btx/gemini_x2_tests.py | 637 ++++++++++ pylabrobot/btx/ht200.py | 85 ++ .../gemini_x2/screens/00_main_menu.png | Bin 0 -> 17540 bytes .../screens/01_user_protocols_top.png | Bin 0 -> 36637 bytes .../gemini_x2/screens/02_protocol_summary.png | Bin 0 -> 28035 bytes .../screens/03_run_protocol_prerun.png | Bin 0 -> 26815 bytes .../screens/04_set_plate_columns_open.png | Bin 0 -> 23678 bytes ..._set_plate_columns_after_first_confirm.png | Bin 0 -> 24410 bytes ...6_set_plate_columns_confirmed_run_view.png | Bin 0 -> 27541 bytes .../gemini_x2/screens/07_go_prerun.png | Bin 0 -> 27554 bytes .../screens/08_go_delivering_pulse.png | Bin 0 -> 25178 bytes .../screens/09_go_pulses_delivered.png | Bin 0 -> 26014 bytes .../screens/10_returned_home_after_go.png | Bin 0 -> 17547 bytes .../gemini_x2/screens/contact_sheet.png | Bin 0 -> 236743 bytes .../test_data/gemini_x2/screens/metadata.json | 167 +++ .../user_protocols_double_up_active.png | Bin 0 -> 36865 bytes .../user_protocols_double_up_inactive.png | Bin 0 -> 36637 bytes pylabrobot/btx/the_ghost_touch.py | 1069 +++++++++++++++++ pylabrobot/btx/the_ghost_touch_tests.py | 407 +++++++ pyproject.toml | 3 +- 28 files changed, 4641 insertions(+), 2 deletions(-) create mode 100644 docs/api/pylabrobot.btx.rst create mode 100644 pylabrobot/btx/__init__.py create mode 100644 pylabrobot/btx/file_transfer_control.py create mode 100644 pylabrobot/btx/file_transfer_control_tests.py create mode 100644 pylabrobot/btx/gemini_x2.py create mode 100644 pylabrobot/btx/gemini_x2_tests.py create mode 100644 pylabrobot/btx/ht200.py create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/00_main_menu.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/01_user_protocols_top.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/02_protocol_summary.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/03_run_protocol_prerun.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/04_set_plate_columns_open.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/05_set_plate_columns_after_first_confirm.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/06_set_plate_columns_confirmed_run_view.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/07_go_prerun.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/08_go_delivering_pulse.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/09_go_pulses_delivered.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/10_returned_home_after_go.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/contact_sheet.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/metadata.json create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_active.png create mode 100644 pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_inactive.png create mode 100644 pylabrobot/btx/the_ghost_touch.py create mode 100644 pylabrobot/btx/the_ghost_touch_tests.py diff --git a/.github/actions/run-tests/action.yml b/.github/actions/run-tests/action.yml index f81b4494b8d..6263696599b 100644 --- a/.github/actions/run-tests/action.yml +++ b/.github/actions/run-tests/action.yml @@ -13,6 +13,10 @@ runs: - name: Update packages run: sudo apt-get update shell: bash + - name: Install BTX OCR system dependency + if: ${{ inputs.extra == 'btx' || inputs.extra == 'all' }} + run: sudo apt-get install -y tesseract-ocr + shell: bash - name: Set up Python uses: actions/setup-python@v6 with: diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index a6c4c12d9ac..28a5cfdf9e7 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -33,7 +33,7 @@ jobs: fail-fast: false matrix: os: [ubuntu-latest] - extra: ["", serial, usb, ftdi, hid, modbus, opentrons, sila, cytation-microscopy, pico] + extra: ["", serial, usb, ftdi, hid, btx, modbus, opentrons, sila, cytation-microscopy, pico] name: Tests (${{ matrix.extra }}, py3.12) runs-on: ${{ matrix.os }} diff --git a/docs/api/pylabrobot.btx.rst b/docs/api/pylabrobot.btx.rst new file mode 100644 index 00000000000..2455360fb9c --- /dev/null +++ b/docs/api/pylabrobot.btx.rst @@ -0,0 +1,45 @@ +.. currentmodule:: pylabrobot.btx + +pylabrobot.btx package +====================== + +Gemini X2 +--------- + +.. currentmodule:: pylabrobot.btx.gemini_x2 + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + BTXGeminiX2 + BTXGeminiX2Driver + BTXGeminiX2ElectroporationBackend + +.. currentmodule:: pylabrobot.btx.file_transfer_control + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + FileTransferControl + +.. currentmodule:: pylabrobot.btx.the_ghost_touch + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + TheGhostTouch + +.. currentmodule:: pylabrobot.btx.ht200 + +.. autosummary:: + :toctree: _autosummary + :nosignatures: + :recursive: + + BTXHT200 diff --git a/docs/api/pylabrobot.rst b/docs/api/pylabrobot.rst index 53a04635937..a7ff61980eb 100644 --- a/docs/api/pylabrobot.rst +++ b/docs/api/pylabrobot.rst @@ -36,6 +36,7 @@ Manufacturers pylabrobot.azenta pylabrobot.bmg_labtech pylabrobot.brooks + pylabrobot.btx pylabrobot.byonoy pylabrobot.hamilton pylabrobot.inheco diff --git a/pylabrobot/btx/__init__.py b/pylabrobot/btx/__init__.py new file mode 100644 index 00000000000..b0abb894680 --- /dev/null +++ b/pylabrobot/btx/__init__.py @@ -0,0 +1,4 @@ +from .file_transfer_control import FileTransferControl +from .gemini_x2 import BTXGeminiX2, BTXGeminiX2Driver, BTXGeminiX2ElectroporationBackend +from .ht200 import BTXHT200 +from .the_ghost_touch import TheGhostTouch diff --git a/pylabrobot/btx/file_transfer_control.py b/pylabrobot/btx/file_transfer_control.py new file mode 100644 index 00000000000..f4727e8a277 --- /dev/null +++ b/pylabrobot/btx/file_transfer_control.py @@ -0,0 +1,993 @@ +from __future__ import annotations + +import asyncio +import re +from datetime import datetime, timezone +from math import isfinite +from typing import Any, Dict, Mapping, Optional, Protocol, TypedDict, runtime_checkable + +from pylabrobot.capabilities.electroporation.standard import ElectroporationProtocol +from pylabrobot.io.binary import Reader, Writer +from pylabrobot.io.serial import Serial + +try: + import serial.tools.list_ports + + _HAS_LIST_PORTS = True +except ImportError: + _HAS_LIST_PORTS = False + + +@runtime_checkable +class _SerialLike(Protocol): + async def setup(self) -> None: + pass + + async def stop(self) -> None: + pass + + async def write(self, data: bytes) -> None: + pass + + async def read(self, num_bytes: int = 1) -> bytes: + pass + + async def readline(self) -> bytes: + pass + + +class _ProgramEntry(TypedDict): + name: str + size: int + + +class FileTransferControl: + """Protocol Manager style USB-serial control for the BTX Gemini X2. + + This control owns the PM shell path only: stored user protocols, SD-card access, + log retrieval, and device metadata. It does not drive the RSI touchscreen workflow. + """ + + USB_VID = 0x1FE9 + USB_PID = 0x5101 + SUPPORTED_USB_IDS = { + (0x1FE9, 0x5101), + (0x1FE9, 0x5201), + } + + METHOD_PAYLOAD_BYTES = 104 + METHOD_NAME_BYTES = 28 + UI_PROTOCOL_NAME_BYTES = 15 + METHOD_PROTOCOL_TYPES = {"exponential": 0, "square": 1} + FIELD_TRAILING_RESERVED_BYTES = METHOD_PAYLOAD_BYTES - 76 + + def __init__( + self, + port: Optional[str] = None, + vid: int = USB_VID, + pid: int = USB_PID, + baudrate: int = 9600, + timeout: float = 1.0, + write_timeout: float = 1.0, + supported_usb_ids: Optional[set[tuple[int, int]]] = None, + serial_io: Optional[_SerialLike] = None, + ) -> None: + self._serial: Optional[_SerialLike] = serial_io + self._serial_io_injected = serial_io is not None + self._port = port + self._vid = vid + self._pid = pid + self._baudrate = baudrate + self._timeout = timeout + self._write_timeout = write_timeout + self._supported_usb_ids = ( + set(supported_usb_ids) + if supported_usb_ids is not None + else set(self.SUPPORTED_USB_IDS) | {(vid, pid)} + ) + + @property + def port(self) -> Optional[str]: + return self._port + + async def setup(self) -> None: + """Open the Gemini USB-serial port, autodiscovering it when needed.""" + if not self._serial_io_injected: + if self._port is None: + self._port = self._resolve_port() + self._serial = Serial( + human_readable_device_name="BTX Gemini X2 FileTransferControl", + port=self._port, + baudrate=self._baudrate, + timeout=self._timeout, + write_timeout=self._write_timeout, + ) + + serial_dev = self._require_serial() + await serial_dev.setup() + resolved_port = getattr(serial_dev, "port", None) + if isinstance(resolved_port, str): + self._port = resolved_port + + async def stop(self) -> None: + """Close the Gemini USB-serial port.""" + await self._require_serial().stop() + + async def list_protocols_with_size(self) -> list[_ProgramEntry]: + """List user protocols currently stored on the Gemini.""" + isprog_response = await self.send_text_command("isprog") + isprog_error = self._extract_error(isprog_response) + if isprog_error is not None and "unknown command" not in isprog_response.lower(): + self._require_no_error(isprog_response, "isprog") + + response = await self.send_text_command('cat "*.BTX"') + self._require_no_error(response, 'cat "*.BTX"') + return self._parse_program_table(response) + + async def list_protocols(self) -> list[str]: + """Return only the stored Gemini user protocol names.""" + return [row["name"] for row in await self.list_protocols_with_size()] + + async def get_protocol(self, protocol_name: str) -> Dict[str, Any]: + """Fetch and decode a stored protocol payload by name.""" + name = self._sanitize_protocol_name(protocol_name) + command = f'sendmtd "{name}"' + response = await self.send_text_command(command) + self._require_no_error(response, command) + + payload_hex, payload = self._extract_method_payload(response) + decoded = self._decode_method_payload(payload) + return self._operation_result( + "get_protocol", + name, + payload_hex=payload_hex, + payload_bytes=len(payload), + decoded=decoded, + response=response, + ) + + async def add_protocol( + self, + protocol_name: str, + protocol: ElectroporationProtocol | Mapping[str, Any], + overwrite: bool = False, + ) -> Dict[str, Any]: + """Transfer a new user protocol to the Gemini over the PM serial interface.""" + name = self._sanitize_new_protocol_name(protocol_name) + existing = await self.list_protocols() + exists_before = name in existing + + if exists_before and not overwrite: + raise FileExistsError(f'Protocol "{name}" already exists. Use overwrite=True to replace it.') + if exists_before and overwrite: + await self.delete_protocol(name) + + payload = self._build_method_payload(name, protocol) + payload_hex = payload.hex().upper() + + meth_command = f"meth {payload_hex}" + meth_response = await self.send_text_command(meth_command) + self._require_no_error(meth_response, meth_command) + + mend_response = await self.send_text_command("mend") + self._require_no_error(mend_response, "mend") + + exists_after = name in await self.list_protocols() + if not exists_after: + raise RuntimeError(f'Protocol "{name}" was not visible after transfer.') + + decoded = self._decode_method_payload(payload) + return self._operation_result( + "add_protocol", + name, + overwrite=overwrite, + exists_before=exists_before, + exists_after=exists_after, + payload_hex=payload_hex, + decoded=decoded, + responses={"meth": meth_response, "mend": mend_response}, + ) + + async def delete_protocol(self, protocol_name: str, missing_ok: bool = False) -> Dict[str, Any]: + """Delete a stored user protocol from the Gemini.""" + name = self._sanitize_protocol_name(protocol_name) + exists_before = name in await self.list_protocols() + + if not exists_before: + if not missing_ok: + raise FileNotFoundError(f'Protocol "{name}" is not present on the device.') + return self._operation_result( + "delete_protocol", + name, + deleted=False, + exists_before=False, + exists_after=False, + ) + + command = f'delm "{name}"' + response = "" + for _ in range(8): + response = await self.send_text_command(command) + self._require_no_error(response, command) + if name not in await self.list_protocols(): + break + + exists_after = name in await self.list_protocols() + if exists_after: + raise RuntimeError(f'Protocol "{name}" still exists after repeated delete attempts.') + + return self._operation_result( + "delete_protocol", + name, + deleted=True, + exists_before=True, + exists_after=False, + response=response, + ) + + async def list_sd_dir(self, sd_path: str) -> list[str]: + """List entries in an SD-card directory path.""" + normalized = self._normalize_sd_path(sd_path) + command = f"sddir {normalized}" + response = await self.send_text_command(command) + self._require_no_error(response, command) + return self._parse_sd_dir_listing(response, command) + + async def fetch_sd_file(self, sd_path: str) -> str: + """Read a text file from the Gemini SD card.""" + normalized = self._normalize_sd_path(sd_path) + command = f"sdsend {normalized}" + response = await self.send_text_command(command) + self._require_no_error(response, command) + return self._strip_sd_file_response(response, command) + + async def list_log_files(self, root: str = "\\BTXDATA") -> list[str]: + """Recursively enumerate BTX run log files under ``BTXDATA``.""" + normalized_root = self._normalize_sd_path(root) + log_paths: list[str] = [] + + for month in await self.list_sd_dir(normalized_root): + if not re.fullmatch(r"\d{4}-\d{2}", month): + continue + month_path = self._join_sd_path(normalized_root, month) + for day in await self.list_sd_dir(month_path): + if not re.fullmatch(r"\d{6}", day): + continue + day_path = self._join_sd_path(month_path, day) + for entry in await self.list_sd_dir(day_path): + if re.fullmatch(r"[^\\/:*?\"<>|]+\.(TXT|txt)", entry): + log_paths.append(self._join_sd_path(day_path, entry)) + + log_paths.sort() + return log_paths + + async def get_version(self) -> str: + """Return the Gemini software version string.""" + return await self._read_single_value_command("version") + + async def get_serial_number(self) -> str: + """Return the Gemini serial number.""" + return await self._read_single_value_command("sn") + + async def get_device_time(self) -> str: + """Return the current date/time reported by the Gemini.""" + return await self._read_single_value_command("time") + + async def get_comm_stats(self) -> Dict[str, int]: + """Return the device communication counters from ``status``/``stat``.""" + response = await self.send_text_command("status") + error = self._extract_error(response) + if error is not None and "unknown command" in response.lower(): + response = await self.send_text_command("stat") + self._require_no_error(response, "status/stat") + + stats: Dict[str, int] = {} + for line in self._response_lines(response): + if ":" not in line: + continue + key, value = line.split(":", maxsplit=1) + key = key.strip() + value = value.strip() + if key in {"status", "stat"}: + continue + if value.isdigit(): + stats[key] = int(value) + return stats + + def parse_run_log(self, text: str) -> Dict[str, Any]: + """Parse a BTX run log into the small summary used by the Gemini backend.""" + cleaned = text.replace("\r\n", "\n").replace("\r", "\n") + fields = self._parse_log_fields(cleaned) + + date_text = self._field_text(fields, "date") + time_text = self._field_text(fields, "time") + date_time = self._field_text(fields, "date_time") + if date_time is None and date_text is not None and time_text is not None: + date_time = f"{date_text} {time_text}" + + summary = { + "date_time": date_time, + "protocol_name": self._field_text(fields, "protocol_name"), + "protocol_type": self._field_text(fields, "protocol_type"), + "pulse_amplitude_volts": self._field_number(fields, "pulse_amplitude", cast_type=int), + "plate_columns": self._field_number(fields, "plate_columns", cast_type=int), + "pulse_1_voltage_volts": self._field_number(fields, "pulse_1_voltage", cast_type=float), + "pulse_1_time_constant_us": self._field_number( + fields, "pulse_1_time_constant", cast_type=int + ), + "pulse_1_total_load_ohms": self._field_number(fields, "pulse_1_total_load", cast_type=int), + "protocol_result": self._field_text(fields, "protocol_result"), + "status_code": self._field_hex(fields, "status") or self._field_hex(fields, "status_code"), + "status_message": self._field_text(fields, "status_message") + or self._field_suffix(fields, "status", separator="-"), + } + return {"summary": summary, "text": text} + + async def write_raw(self, data: bytes) -> None: + """Write raw bytes to the Gemini serial interface.""" + await self._require_serial().write(data) + + async def read_raw(self, num_bytes: int = 1) -> bytes: + """Read raw bytes from the Gemini serial interface.""" + return await self._require_serial().read(num_bytes=num_bytes) + + async def readline_raw(self) -> bytes: + """Read one raw line from the Gemini serial interface.""" + return await self._require_serial().readline() + + async def send_text_command(self, command: str) -> str: + """Send one PM shell command and return the prompt-terminated response text.""" + await self.write_raw((command + "\r\n").encode("utf-8")) + response = await self._read_until_prompt() + return response.decode("utf-8", errors="replace") + + def _require_serial(self) -> _SerialLike: + if self._serial is None: + raise RuntimeError("Serial device not initialized. Call setup() first.") + return self._serial + + def _operation_result(self, operation: str, protocol_name: str, **details: Any) -> Dict[str, Any]: + return { + "operation": operation, + "timestamp_utc": self._now_utc_iso(), + "protocol": protocol_name, + **details, + } + + def _resolve_port(self) -> str: + if not _HAS_LIST_PORTS: + raise RuntimeError( + "pyserial is required for BTX port autodiscovery. Install with: pip install pylabrobot[btx]" + ) + + ports = serial.tools.list_ports.comports() + btx_ports = [p for p in ports if (p.vid, p.pid) in self._supported_usb_ids] + if len(btx_ports) == 0: + raise RuntimeError( + "No BTX Gemini found with supported VID:PID pairs: " + f"{sorted(self._supported_usb_ids)}. " + "If connected, provide the serial port explicitly (e.g., /dev/cu.usbmodem...)." + ) + if len(btx_ports) > 1: + available_ports = [f"{p.device} ({hex(p.vid)}:{hex(p.pid)})" for p in btx_ports] + raise RuntimeError( + f"Multiple BTX Gemini devices found: {available_ports}. Please specify the port explicitly." + ) + + detected = btx_ports[0] + if detected.vid is not None: + self._vid = detected.vid + if detected.pid is not None: + self._pid = detected.pid + return str(detected.device) + + async def _read_single_value_command(self, command: str) -> str: + response = await self.send_text_command(command) + self._require_no_error(response, command) + lines = [line for line in self._response_lines(response) if line not in {command, ":"}] + return lines[0] if len(lines) > 0 else "" + + async def _read_until_prompt(self, read_size: int = 512, max_reads: int = 24) -> bytes: + chunks: list[bytes] = [] + got_any = False + for _ in range(max_reads): + chunk = await self.read_raw(num_bytes=read_size) + if len(chunk) == 0: + if got_any: + break + await asyncio.sleep(0.05) + continue + got_any = True + chunks.append(chunk) + if chunk.endswith(b":"): + break + await asyncio.sleep(0.03) + return b"".join(chunks) + + def _response_lines(self, response: str) -> list[str]: + return [line.strip() for line in response.splitlines()] + + def _extract_error(self, response: str) -> Optional[str]: + for line in self._response_lines(response): + line_l = line.lower() + if line_l.startswith("command error:"): + return line + if line_l.startswith("error:"): + return line + if line_l in {"argument error", "delete failed", "get method failed"}: + return line + if line_l.startswith("failed:"): + continue + if "failed" in line_l and "successful" not in line_l: + return line + return None + + def _require_no_error(self, response: str, command: str) -> None: + error = self._extract_error(response) + if error is not None: + raise RuntimeError(f"BTX command failed ({command}): {error}") + + def _parse_program_table(self, response: str) -> list[_ProgramEntry]: + programs: list[_ProgramEntry] = [] + for line in self._response_lines(response): + if ( + line == "" + or line == ":" + or line == "isprog" + or line.startswith('cat "*.BTX"') + or line.startswith("Method name") + or line.startswith("----") + ): + continue + if "file(s) using" in line: + break + if line.startswith("Error:"): + raise RuntimeError(line) + + parts = line.split() + if len(parts) >= 2 and parts[-1].isdigit(): + programs.append({"name": " ".join(parts[:-1]), "size": int(parts[-1])}) + elif len(parts) >= 1: + programs.append({"name": parts[0], "size": 0}) + return programs + + def _normalize_sd_path(self, sd_path: str) -> str: + path = sd_path.strip().replace("/", "\\") + if not path.startswith("\\"): + path = "\\" + path + path = re.sub(r"\\+", r"\\", path) + return path.rstrip("\\") or "\\" + + def _join_sd_path(self, *parts: str) -> str: + cleaned = [part.strip().strip("\\/") for part in parts if part.strip()] + if len(cleaned) == 0: + return "\\" + return "\\" + "\\".join(cleaned) + + def _parse_sd_dir_listing(self, response: str, command: str) -> list[str]: + return [line for line in self._response_lines(response) if line not in {"", ":", command}] + + def _strip_sd_file_response(self, response: str, command: str) -> str: + lines = response.replace("\r\n", "\n").replace("\r", "\n").split("\n") + if len(lines) > 0 and lines[0].strip() == command: + lines = lines[1:] + while len(lines) > 0 and lines[-1].strip() == "": + lines.pop() + if len(lines) > 0 and lines[-1].strip() == ":": + lines.pop() + return "\n".join(lines).strip("\n") + + def _parse_log_fields(self, cleaned: str) -> Dict[str, Any]: + fields: Dict[str, Any] = {} + current_block: list[str] = [] + + for line in cleaned.splitlines(): + stripped = line.rstrip() + if stripped: + current_block.append(stripped) + continue + if len(current_block) > 0: + self._parse_tabular_log_block(current_block, fields) + current_block = [] + if len(current_block) > 0: + self._parse_tabular_log_block(current_block, fields) + + for line in [line.strip() for line in cleaned.splitlines() if line.strip()]: + if "\t" in line: + continue + match = re.match(r"^([^:]+):\s*(.+)$", line) + if match is not None: + self._store_log_field(fields, match.group(1), match.group(2).strip()) + + return fields + + def _normalize_log_key(self, key: str) -> str: + normalized = re.sub(r"[^a-z0-9]+", "_", key.lower()).strip("_") + return { + "date_mm_dd_yyyy": "date", + "time_hhmmss": "time", + "pulse_amplitude_v": "pulse_amplitude", + "pulse_1_voltage_v": "pulse_1_voltage", + "pulse_1_voltage": "pulse_1_voltage", + "pulse_1_time_constant_us": "pulse_1_time_constant", + "pulse_1_time_constant": "pulse_1_time_constant", + "pulse_1_total_load_ohms": "pulse_1_total_load", + "pulse_1_total_load": "pulse_1_total_load", + }.get(normalized, normalized) + + def _store_log_field(self, fields: Dict[str, Any], key: str, value: str) -> None: + normalized_key = self._normalize_log_key(key) + existing = fields.get(normalized_key) + if existing is None: + fields[normalized_key] = value + elif isinstance(existing, list): + existing.append(value) + else: + fields[normalized_key] = [existing, value] + + # BTX emits both verbose "Key: Value" logs and tabular exports; this block parser keeps a + # single normalized summary shape for both. + def _parse_tabular_log_block(self, block: list[str], fields: Dict[str, Any]) -> None: + if len(block) == 0: + return + + idx = 0 + while idx < len(block): + line = block[idx] + if idx + 1 < len(block) and "\t" in line and "\t" in block[idx + 1] and ":" not in line: + headers = [token.strip() for token in line.split("\t") if token.strip()] + values = [token.strip() for token in block[idx + 1].split("\t") if token.strip()] + self._store_tabular_header_rows(fields, headers, values) + idx += 2 + continue + + if "\t" not in line or ":" not in line: + idx += 1 + continue + + tokens = [token.strip() for token in line.split("\t") if token.strip()] + self._store_tabular_inline_pairs(fields, tokens) + idx += 1 + + def _store_tabular_header_rows( + self, + fields: Dict[str, Any], + headers: list[str], + values: list[str], + ) -> None: + if len(headers) == 0 or len(values) == 0: + return + + if headers[0] == "DC Pulses" and values[0].lower().startswith("pulse "): + pulse_label = values[0] + for header, value in zip(headers[1:], values[1:]): + self._store_log_field(fields, f"{pulse_label} {header}", value) + return + + for header, value in zip(headers, values): + self._store_log_field(fields, header, value) + + if headers[:2] == ["Protocol Result", "Status Code"] and len(values) > 2: + self._store_log_field(fields, "Status Message", " ".join(values[2:])) + + def _store_tabular_inline_pairs(self, fields: Dict[str, Any], tokens: list[str]) -> None: + if len(tokens) < 2: + return + + token_idx = 1 if tokens[0].endswith(":") and len(tokens) >= 3 else 0 + while token_idx + 1 < len(tokens): + key = tokens[token_idx] + value = tokens[token_idx + 1] + if not key.endswith(":") or value.endswith(":"): + token_idx += 1 + continue + self._store_log_field(fields, key[:-1], value) + token_idx += 2 + + def _field_text(self, fields: Mapping[str, Any], key: str) -> Optional[str]: + value = fields.get(key) + if isinstance(value, list): + return str(value[-1]) if len(value) > 0 else None + if value is None: + return None + return str(value) + + def _field_number( + self, + fields: Mapping[str, Any], + key: str, + cast_type: type[int] | type[float], + ) -> Optional[int | float]: + value = self._field_text(fields, key) + if value is None: + return None + pattern = r"-?\d+" if cast_type is int else r"-?\d+(?:\.\d+)?" + match = re.search(pattern, value) + if match is None: + return None + return cast_type(match.group(0)) + + def _field_hex(self, fields: Mapping[str, Any], key: str) -> Optional[str]: + value = self._field_text(fields, key) + if value is None: + return None + match = re.search(r"0x[0-9A-Fa-f.]+", value) + if match is None: + return None + return match.group(0) + + def _field_suffix(self, fields: Mapping[str, Any], key: str, separator: str) -> Optional[str]: + value = self._field_text(fields, key) + if value is None or separator not in value: + return None + return value.split(separator, maxsplit=1)[1].strip() + + def _sanitize_protocol_name(self, protocol_name: str) -> str: + name = protocol_name.strip() + if len(name) == 0: + raise ValueError("Protocol name cannot be empty.") + if '"' in name or "\n" in name or "\r" in name: + raise ValueError("Protocol name cannot contain quotes or newlines.") + try: + encoded = name.encode("ascii") + except UnicodeEncodeError as exc: + raise ValueError("Protocol name must be ASCII.") from exc + if len(encoded) > self.METHOD_NAME_BYTES: + raise ValueError( + f"Protocol name must be <= {self.METHOD_NAME_BYTES} ASCII bytes, got {len(encoded)}." + ) + return name + + def _sanitize_new_protocol_name(self, protocol_name: str) -> str: + name = self._sanitize_protocol_name(protocol_name) + encoded = name.encode("ascii") + if len(encoded) > self.UI_PROTOCOL_NAME_BYTES: + raise ValueError( + "New protocol names must be <= " + f"{self.UI_PROTOCOL_NAME_BYTES} ASCII bytes for Gemini UI compatibility, " + f"got {len(encoded)}." + ) + return name + + def _encode_protocol_name(self, protocol_name: str) -> bytes: + return protocol_name.encode("ascii").ljust(self.METHOD_NAME_BYTES, b"\x00") + + def _protocol_parameters( + self, + protocol: ElectroporationProtocol | Mapping[str, Any], + ) -> Mapping[str, Any]: + if isinstance(protocol, ElectroporationProtocol): + return protocol.as_parameters() + return protocol + + def _parameter_value(self, parameters: Mapping[str, Any], *keys: str) -> Any: + for key in keys: + value = parameters.get(key) + if value is not None: + return value + return None + + def _coerce_int_parameter(self, parameters: Mapping[str, Any], *keys: str) -> Optional[int]: + value = self._parameter_value(parameters, *keys) + if value is None: + return None + if isinstance(value, bool): + raise ValueError(f"Parameter {keys[0]} must be numeric, not bool.") + if isinstance(value, float): + if not value.is_integer(): + raise ValueError(f"Parameter {keys[0]} must be an integer value, got {value}.") + return int(value) + return int(value) + + def _coerce_float_parameter(self, parameters: Mapping[str, Any], *keys: str) -> Optional[float]: + value = self._parameter_value(parameters, *keys) + if value is None: + return None + if isinstance(value, bool): + raise ValueError(f"Parameter {keys[0]} must be numeric, not bool.") + result = float(value) + if not isfinite(result): + raise ValueError(f"Parameter {keys[0]} must be finite, got {value}.") + return result + + def _normalize_protocol_parameters( + self, + protocol: ElectroporationProtocol | Mapping[str, Any], + ) -> Dict[str, Any]: + parameters = self._protocol_parameters(protocol) + common = self._normalize_common_protocol_parameters(parameters) + if common["protocol_type"] == "square": + return self._normalize_square_protocol(parameters, common) + return self._normalize_exponential_protocol(parameters, common) + + def _normalize_common_protocol_parameters(self, parameters: Mapping[str, Any]) -> Dict[str, Any]: + protocol_type = str(parameters.get("protocol_type", "exponential")).lower() + if protocol_type not in self.METHOD_PROTOCOL_TYPES: + allowed = ", ".join(sorted(self.METHOD_PROTOCOL_TYPES)) + raise ValueError(f"Unsupported protocol_type={protocol_type!r}. Allowed: {allowed}.") + + amplitude_volts = self._coerce_int_parameter(parameters, "pulse_amplitude_volts", "voltage") + if amplitude_volts is None: + raise ValueError("Missing pulse amplitude. Use pulse_amplitude_volts (or voltage).") + self._validate_amplitude_volts(amplitude_volts) + + pulse_count = self._coerce_int_parameter(parameters, "pulse_count") or 1 + pulse_interval_seconds = self._coerce_float_parameter( + parameters, "pulse_interval_seconds", "pulse_interval_sec", "interval_seconds" + ) + if pulse_interval_seconds is None: + pulse_interval_seconds = 0.0 + + gap_mm = self._coerce_float_parameter(parameters, "gap_mm", "electrode_gap_mm", "electrode_gap") + if gap_mm is None: + raise ValueError("Missing electrode gap. Use gap_mm (or electrode_gap_mm).") + self._validate_gap_mm(gap_mm) + + return { + "protocol_type": protocol_type, + "pulse_amplitude_volts": amplitude_volts, + "pulse_count": pulse_count, + "pulse_interval_seconds": pulse_interval_seconds, + "electrode_gap_mm": gap_mm, + "pulse_interval_ms": 0, + } + + def _normalize_square_protocol( + self, + parameters: Mapping[str, Any], + common: Dict[str, Any], + ) -> Dict[str, Any]: + amplitude_volts = common["pulse_amplitude_volts"] + pulse_count = common["pulse_count"] + pulse_interval_seconds = common["pulse_interval_seconds"] + + self._validate_square_pulse_count(amplitude_volts, pulse_count) + self._validate_square_pulse_interval_seconds(pulse_count, pulse_interval_seconds) + + duration_us = self._coerce_int_parameter(parameters, "duration_us", "pulse_duration_us") + if duration_us is None: + raise ValueError("Square protocols require duration_us (or pulse_duration_us).") + self._validate_square_duration_us(amplitude_volts, duration_us) + + return { + **common, + "pulse_duration_us": duration_us, + "pulse_interval_ms": int(round(pulse_interval_seconds * 1000)), + } + + def _normalize_exponential_protocol( + self, + parameters: Mapping[str, Any], + common: Dict[str, Any], + ) -> Dict[str, Any]: + pulse_count = common["pulse_count"] + pulse_interval_seconds = common["pulse_interval_seconds"] + if pulse_count != 1 or abs(pulse_interval_seconds) > 1e-9: + raise ValueError( + "Exponential protocols currently support only pulse_count=1 in this backend. " + "The Gemini X2 manual mentions up to 2 pulses depending on amplitude limit, " + "but the PM payload/current-limit behavior is not documented well enough to " + "support that safely. Use pulse_count=1 and omit pulse_interval_seconds." + ) + + amplitude_volts = common["pulse_amplitude_volts"] + resistance_ohms = self._coerce_int_parameter(parameters, "resistance_ohms", "resistance") + if resistance_ohms is None: + raise ValueError("Exponential protocols require resistance_ohms.") + self._validate_exponential_resistance_ohms(amplitude_volts, resistance_ohms) + + capacitance_uf = self._coerce_int_parameter(parameters, "capacitance_uf", "capacitance") + if capacitance_uf is None: + raise ValueError("Exponential protocols require capacitance_uf.") + self._validate_exponential_capacitance_uf(amplitude_volts, capacitance_uf) + + return { + **common, + "resistance_ohms": resistance_ohms, + "capacitance_uf": capacitance_uf, + } + + def _validate_amplitude_volts(self, amplitude_volts: int) -> None: + if 5 <= amplitude_volts <= 500: + return + if 505 <= amplitude_volts <= 3000 and (amplitude_volts % 5) == 0: + return + raise ValueError( + "pulse_amplitude_volts must be 5..500 in 1 V steps or 505..3000 in 5 V steps, " + f"got {amplitude_volts}." + ) + + def _validate_gap_mm(self, gap_mm: float) -> None: + if gap_mm <= 0: + raise ValueError(f"gap_mm must be > 0, got {gap_mm}.") + + def _validate_square_duration_us(self, amplitude_volts: int, duration_us: int) -> None: + if duration_us <= 0: + raise ValueError(f"duration_us must be > 0, got {duration_us}.") + if amplitude_volts <= 500: + if 10 <= duration_us <= 999: + return + if 1000 <= duration_us <= 999_000 and (duration_us % 1000) == 0: + return + raise ValueError( + "Square-wave LV duration must be 10..999 us or 1..999 ms in 1 ms steps; " + f"got {duration_us} us." + ) + if 10 <= duration_us <= 600: + return + raise ValueError( + f"Square-wave HV duration must be 10..600 us in 1 us steps; got {duration_us} us." + ) + + def _validate_square_pulse_count(self, amplitude_volts: int, pulse_count: int) -> None: + max_pulses = 10 if amplitude_volts <= 500 else 3 + if 1 <= pulse_count <= max_pulses: + return + raise ValueError( + f"Square-wave pulse_count must be 1..{max_pulses} at {amplitude_volts} V, got {pulse_count}." + ) + + def _validate_square_pulse_interval_seconds( + self, + pulse_count: int, + pulse_interval_seconds: float, + ) -> None: + if pulse_count == 1: + if abs(pulse_interval_seconds) <= 1e-9: + return + raise ValueError( + "Square-wave pulse_interval_seconds must be 0 or omitted when pulse_count=1, " + f"got {pulse_interval_seconds}." + ) + if not 0.1 <= pulse_interval_seconds <= 10.0: + raise ValueError( + "Square-wave pulse_interval_seconds must be 0.1..10.0 s for multiple pulsing, " + f"got {pulse_interval_seconds}." + ) + step_value = round(pulse_interval_seconds * 10) + if abs((step_value / 10.0) - pulse_interval_seconds) > 1e-9: + raise ValueError( + f"Square-wave pulse_interval_seconds must use 0.1 s steps, got {pulse_interval_seconds}." + ) + + def _validate_exponential_resistance_ohms( + self, + amplitude_volts: int, + resistance_ohms: int, + ) -> None: + min_resistance = 25 if amplitude_volts <= 500 else 50 + if resistance_ohms < min_resistance or resistance_ohms > 1575 or (resistance_ohms % 25) != 0: + raise ValueError( + "Exponential resistance_ohms must be " + f"{min_resistance}..1575 in 25 ohm steps at {amplitude_volts} V, " + f"got {resistance_ohms}." + ) + + def _validate_exponential_capacitance_uf(self, amplitude_volts: int, capacitance_uf: int) -> None: + if amplitude_volts <= 500: + if 25 <= capacitance_uf <= 3275 and (capacitance_uf % 25) == 0: + return + raise ValueError( + f"Exponential LV capacitance_uf must be 25..3275 in 25 uF steps; got {capacitance_uf}." + ) + if capacitance_uf in {10, 25, 35, 50, 60, 75, 85}: + return + raise ValueError( + "Exponential HV capacitance_uf must be one of {10, 25, 35, 50, 60, 75, 85}; " + f"got {capacitance_uf}." + ) + + def _build_method_payload( + self, + protocol_name: str, + protocol: ElectroporationProtocol | Mapping[str, Any], + ) -> bytes: + name = self._sanitize_new_protocol_name(protocol_name) + normalized = self._normalize_protocol_parameters(protocol) + + protocol_type_code = self._require_u32( + self.METHOD_PROTOCOL_TYPES[normalized["protocol_type"]], + "protocol_type_code", + ) + pulse_amplitude_volts = self._require_u32( + normalized["pulse_amplitude_volts"], + "pulse_amplitude_volts", + ) + pulse_count = self._require_u32(normalized["pulse_count"], "pulse_count") + pulse_interval_ms = self._require_u32(normalized["pulse_interval_ms"], "pulse_interval_ms") + electrode_gap_mm = self._require_f32(normalized["electrode_gap_mm"], "electrode_gap_mm") + square_duration = 0 + resistance = 0 + capacitance = 0 + + if normalized["protocol_type"] == "square": + square_duration = self._require_u32(normalized["pulse_duration_us"], "pulse_duration_us") + else: + resistance = self._require_u32(normalized["resistance_ohms"], "resistance_ohms") + capacitance = self._require_u32(normalized["capacitance_uf"], "capacitance_uf") + + writer = Writer() + writer.u32(1) + writer.raw_bytes(self._encode_protocol_name(name)) + writer.u32(protocol_type_code) + writer.u32(0) + writer.u32(pulse_amplitude_volts) + writer.u32(0) + writer.u32(square_duration) + writer.u32(0) + writer.u32(resistance) + writer.u32(capacitance) + writer.u32(pulse_count) + writer.u32(pulse_interval_ms) + writer.f32(electrode_gap_mm) + writer.raw_bytes(b"\x00" * self.FIELD_TRAILING_RESERVED_BYTES) + payload = writer.finish() + if len(payload) != self.METHOD_PAYLOAD_BYTES: + raise RuntimeError( + f"Built unexpected method payload length {len(payload)} bytes " + f"(expected {self.METHOD_PAYLOAD_BYTES})." + ) + return payload + + def _decode_method_payload(self, payload: bytes) -> Dict[str, Any]: + if len(payload) != self.METHOD_PAYLOAD_BYTES: + raise ValueError(f"Expected {self.METHOD_PAYLOAD_BYTES} payload bytes, got {len(payload)}.") + + reader = Reader(payload) + version = reader.u32() + name_raw = reader.raw_bytes(self.METHOD_NAME_BYTES) + protocol_type_code = reader.u32() + reader.u32() + pulse_amplitude_volts = reader.u32() + reader.u32() + pulse_duration_us = reader.u32() + reader.u32() + resistance_ohms = reader.u32() + capacitance_uf = reader.u32() + pulse_count = reader.u32() + pulse_interval_ms = reader.u32() + electrode_gap_mm = reader.f32() + + protocol_type = next( + (name for name, code in self.METHOD_PROTOCOL_TYPES.items() if code == protocol_type_code), + f"unknown({protocol_type_code})", + ) + return { + "version": version, + "name": name_raw.split(b"\x00", maxsplit=1)[0].decode("ascii", errors="ignore"), + "protocol_type_code": protocol_type_code, + "protocol_type": protocol_type, + "pulse_amplitude_volts": pulse_amplitude_volts, + "pulse_duration_us": pulse_duration_us, + "resistance_ohms": resistance_ohms, + "capacitance_uf": capacitance_uf, + "pulse_count": pulse_count, + "pulse_interval_ms": pulse_interval_ms, + "pulse_interval_seconds": pulse_interval_ms / 1000.0, + "electrode_gap_mm": electrode_gap_mm, + } + + def _extract_method_payload(self, response: str) -> tuple[str, bytes]: + match = re.search(r"^meth\s+([0-9A-Fa-f]+)$", response, flags=re.MULTILINE) + if match is None: + raise RuntimeError(f"Device response did not contain meth payload: {response}") + payload_hex = match.group(1) + payload = bytes.fromhex(payload_hex) + if len(payload) != self.METHOD_PAYLOAD_BYTES: + raise RuntimeError( + f"Unexpected method payload length {len(payload)} bytes (expected {self.METHOD_PAYLOAD_BYTES})." + ) + return payload_hex.upper(), payload + + def _require_u32(self, value: int, field_name: str) -> int: + if value < 0 or value > 0xFFFFFFFF: + raise ValueError(f"{field_name} must fit in u32, got {value}.") + return value + + def _require_f32(self, value: float, field_name: str) -> float: + if not isfinite(value): + raise ValueError(f"{field_name} must be a finite float32 value, got {value}.") + return value + + def _now_utc_iso(self) -> str: + return datetime.now(timezone.utc).isoformat() diff --git a/pylabrobot/btx/file_transfer_control_tests.py b/pylabrobot/btx/file_transfer_control_tests.py new file mode 100644 index 00000000000..ab457fa5712 --- /dev/null +++ b/pylabrobot/btx/file_transfer_control_tests.py @@ -0,0 +1,486 @@ +import unittest +from collections import deque +import types +from typing import Deque, List, Sequence, Tuple +from unittest.mock import patch + +from pylabrobot.btx.file_transfer_control import FileTransferControl +from pylabrobot.capabilities.electroporation.standard import ElectroporationProtocol + + +def _program_listing(entries: Sequence[Tuple[str, int]]) -> bytes: + rows = [ + "Method name Size", + "--------------- ----", + ] + rows.extend([f"{name:<16} {size}" for name, size in entries]) + rows.append("") + rows.append(f"{len(entries)} file(s) using {sum(size for _, size in entries)} steps") + rows.append(":") + return "\n".join(rows).encode("utf-8") + + +def _sd_listing(command: str, entries: Sequence[str]) -> bytes: + rows = [command] + rows.extend(entries) + rows.append(":") + return "\n".join(rows).encode("utf-8") + + +class _FakeSerial: + def __init__(self) -> None: + self.setup_calls = 0 + self.stop_calls = 0 + self.writes: List[bytes] = [] + self.read_chunks: Deque[bytes] = deque() + self.readline_chunks: Deque[bytes] = deque() + + async def setup(self) -> None: + self.setup_calls += 1 + + async def stop(self) -> None: + self.stop_calls += 1 + + async def write(self, data: bytes) -> None: + self.writes.append(data) + + async def read(self, num_bytes: int = 1) -> bytes: + del num_bytes + if len(self.read_chunks) == 0: + return b"" + return self.read_chunks.popleft() + + async def readline(self) -> bytes: + if len(self.readline_chunks) == 0: + return b"" + return self.readline_chunks.popleft() + + +class _FakePortInfo: + def __init__(self, device: str, vid: int | None, pid: int | None) -> None: + self.device = device + self.vid = vid + self.pid = pid + + +class _ConstructedSerial: + instances: List["_ConstructedSerial"] = [] + + def __init__( + self, + human_readable_device_name: str, + port: str, + baudrate: int, + timeout: float, + write_timeout: float, + ) -> None: + self.human_readable_device_name = human_readable_device_name + self.port = port + self.baudrate = baudrate + self.timeout = timeout + self.write_timeout = write_timeout + self.setup_calls = 0 + self.stop_calls = 0 + _ConstructedSerial.instances.append(self) + + async def setup(self) -> None: + self.setup_calls += 1 + + async def stop(self) -> None: + self.stop_calls += 1 + + async def write(self, data: bytes) -> None: + del data + + async def read(self, num_bytes: int = 1) -> bytes: + del num_bytes + return b"" + + async def readline(self) -> bytes: + return b"" + + +class TestFileTransferControl(unittest.IsolatedAsyncioTestCase): + async def test_setup_stop(self): + fake = _FakeSerial() + control = FileTransferControl(serial_io=fake) + + await control.setup() + await control.stop() + + self.assertEqual(fake.setup_calls, 1) + self.assertEqual(fake.stop_calls, 1) + + async def test_setup_autodiscovers_btx_port_then_uses_shared_serial(self): + _ConstructedSerial.instances.clear() + fake_ports = [_FakePortInfo("/dev/cu.btx", 0x1FE9, 0x5201)] + fake_serial_module = types.SimpleNamespace( + tools=types.SimpleNamespace( + list_ports=types.SimpleNamespace(comports=lambda: fake_ports), + ) + ) + + with ( + patch("pylabrobot.btx.file_transfer_control._HAS_LIST_PORTS", True), + patch( + "pylabrobot.btx.file_transfer_control.serial", + fake_serial_module, + create=True, + ), + patch( + "pylabrobot.btx.file_transfer_control.Serial", + _ConstructedSerial, + ), + ): + control = FileTransferControl() + await control.setup() + await control.stop() + + self.assertEqual(len(_ConstructedSerial.instances), 1) + serial_io = _ConstructedSerial.instances[0] + self.assertEqual(serial_io.port, "/dev/cu.btx") + self.assertEqual(serial_io.baudrate, 9600) + self.assertEqual(serial_io.timeout, 1.0) + self.assertEqual(serial_io.write_timeout, 1.0) + self.assertEqual(serial_io.setup_calls, 1) + self.assertEqual(serial_io.stop_calls, 1) + self.assertEqual(control.port, "/dev/cu.btx") + + async def test_list_protocols_parses_program_table(self): + fake = _FakeSerial() + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("NECATOR", 8)])) + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("NECATOR", 8)])) + control = FileTransferControl(serial_io=fake) + + rows = await control.list_protocols_with_size() + names = await control.list_protocols() + + self.assertEqual(rows, [{"name": "CD", "size": 1}, {"name": "NECATOR", "size": 8}]) + self.assertEqual(names, ["CD", "NECATOR"]) + self.assertEqual( + fake.writes, + [b"isprog\r\n", b'cat "*.BTX"\r\n', b"isprog\r\n", b'cat "*.BTX"\r\n'], + ) + + async def test_add_exponential_protocol_success(self): + fake = _FakeSerial() + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1)])) + fake.read_chunks.append(b":") + fake.read_chunks.append(b":") + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("TESTX", 1)])) + control = FileTransferControl(serial_io=fake) + + result = await control.add_protocol( + "TESTX", + ElectroporationProtocol( + protocol_type="exponential", + pulse_amplitude_volts=2400, + gap_mm=2.0, + resistance_ohms=200, + capacitance_uf=25, + ), + ) + + self.assertEqual(result["operation"], "add_protocol") + self.assertEqual(result["protocol"], "TESTX") + self.assertEqual(result["decoded"]["protocol_type"], "exponential") + self.assertEqual(result["decoded"]["pulse_amplitude_volts"], 2400) + self.assertEqual(result["decoded"]["resistance_ohms"], 200) + self.assertEqual(result["decoded"]["capacitance_uf"], 25) + self.assertEqual(result["decoded"]["pulse_count"], 1) + self.assertAlmostEqual(result["decoded"]["electrode_gap_mm"], 2.0) + self.assertTrue(fake.writes[2].startswith(b"meth ")) + self.assertEqual(fake.writes[3], b"mend\r\n") + + async def test_add_square_protocol_success(self): + fake = _FakeSerial() + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1)])) + fake.read_chunks.append(b":") + fake.read_chunks.append(b":") + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("SQTEST", 1)])) + control = FileTransferControl(serial_io=fake) + + result = await control.add_protocol( + "SQTEST", + ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ), + ) + + self.assertEqual(result["decoded"]["protocol_type"], "square") + self.assertEqual(result["decoded"]["pulse_amplitude_volts"], 250) + self.assertEqual(result["decoded"]["pulse_duration_us"], 1000) + self.assertAlmostEqual(result["decoded"]["electrode_gap_mm"], 1.0) + self.assertEqual(result["decoded"]["pulse_count"], 1) + self.assertEqual(result["decoded"]["pulse_interval_ms"], 0) + self.assertEqual(result["decoded"]["pulse_interval_seconds"], 0.0) + + async def test_add_square_protocol_supports_multiple_pulse_interval(self): + fake = _FakeSerial() + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1)])) + fake.read_chunks.append(b":") + fake.read_chunks.append(b":") + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("SQMP", 1)])) + control = FileTransferControl(serial_io=fake) + + result = await control.add_protocol( + "SQMP", + ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=2400, + gap_mm=2.0, + pulse_count=3, + pulse_interval_seconds=2.0, + duration_us=500, + ), + ) + + self.assertEqual(result["decoded"]["protocol_type"], "square") + self.assertEqual(result["decoded"]["pulse_amplitude_volts"], 2400) + self.assertEqual(result["decoded"]["pulse_duration_us"], 500) + self.assertEqual(result["decoded"]["pulse_count"], 3) + self.assertEqual(result["decoded"]["pulse_interval_ms"], 2000) + self.assertEqual(result["decoded"]["pulse_interval_seconds"], 2.0) + + async def test_add_exponential_protocol_rejects_multiple_pulse_write(self): + control = FileTransferControl(serial_io=_FakeSerial()) + + with self.assertRaisesRegex(ValueError, "currently support only pulse_count=1"): + control._build_method_payload( + "TEST", + ElectroporationProtocol( + protocol_type="exponential", + pulse_amplitude_volts=250, + gap_mm=1.0, + pulse_count=2, + pulse_interval_seconds=5.0, + resistance_ohms=200, + capacitance_uf=25, + ), + ) + + async def test_get_protocol_decodes_payload(self): + fake = _FakeSerial() + fake.read_chunks.append( + ( + b"meth " + b"010000004A4A00000000000000000000000000000000000000000000000000000000000000000000" + b"19000000000000000000000000000000320000002C01000001000000000000000000004000000000" + b"000000000000000000000000000000000000000000000000\nmend\n:" + ) + ) + control = FileTransferControl(serial_io=fake) + + result = await control.get_protocol("JJ") + + self.assertEqual(result["protocol"], "JJ") + self.assertEqual(result["decoded"]["name"], "JJ") + self.assertEqual(result["decoded"]["pulse_amplitude_volts"], 25) + self.assertEqual(result["decoded"]["resistance_ohms"], 50) + self.assertEqual(result["decoded"]["capacitance_uf"], 300) + self.assertEqual(result["decoded"]["pulse_count"], 1) + self.assertEqual(result["decoded"]["pulse_interval_seconds"], 0.0) + self.assertAlmostEqual(result["decoded"]["electrode_gap_mm"], 2.0) + + async def test_decode_manual_square_protocol_includes_interval(self): + control = FileTransferControl(serial_io=_FakeSerial()) + payload = bytes.fromhex( + "01000000544553545351554152450000000000000000000000000000000000000100000000000000" + "6009000000000000F401000000000000000000000000000003000000D00700000000004000000000" + "000000000000000000000000000000000000000000000000" + ) + + decoded = control._decode_method_payload(payload) + + self.assertEqual(decoded["name"], "TESTSQUARE") + self.assertEqual(decoded["protocol_type"], "square") + self.assertEqual(decoded["pulse_amplitude_volts"], 2400) + self.assertEqual(decoded["pulse_duration_us"], 500) + self.assertEqual(decoded["pulse_count"], 3) + self.assertEqual(decoded["pulse_interval_ms"], 2000) + self.assertEqual(decoded["pulse_interval_seconds"], 2.0) + + async def test_build_square_payload_matches_known_manual_payload(self): + control = FileTransferControl(serial_io=_FakeSerial()) + + payload = control._build_method_payload( + "TESTSQUARE", + ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=2400, + gap_mm=2.0, + pulse_count=3, + pulse_interval_seconds=2.0, + duration_us=500, + ), + ) + + self.assertEqual( + payload.hex().upper(), + ( + "01000000544553545351554152450000000000000000000000000000000000000100000000000000" + "6009000000000000F401000000000000000000000000000003000000D00700000000004000000000" + "000000000000000000000000000000000000000000000000" + ), + ) + + async def test_delete_protocol(self): + fake = _FakeSerial() + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1), ("TEST", 1)])) + fake.read_chunks.append(b":") + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1)])) + fake.read_chunks.append(b"Y\n:") + fake.read_chunks.append(_program_listing([("CD", 1)])) + control = FileTransferControl(serial_io=fake) + + result = await control.delete_protocol("TEST") + + self.assertTrue(result["deleted"]) + self.assertFalse(result["exists_after"]) + + async def test_sd_dir_and_file_helpers(self): + fake = _FakeSerial() + fake.read_chunks.append(_sd_listing(r"sddir \BTXDATA", ["2026-03"])) + fake.read_chunks.append( + ( + "sdsend \\BTXDATA\\2026-03\\260309\\153425.TXT\n" + "Protocol Name: H16_C\n" + "Protocol Result: Complete\n" + ":\n" + ).encode("utf-8") + ) + control = FileTransferControl(serial_io=fake) + + entries = await control.list_sd_dir(r"\BTXDATA") + content = await control.fetch_sd_file(r"\BTXDATA\2026-03\260309\153425.TXT") + + self.assertEqual(entries, ["2026-03"]) + self.assertEqual(content, "Protocol Name: H16_C\nProtocol Result: Complete") + + async def test_list_log_files_walks_btxdata_tree(self): + fake = _FakeSerial() + fake.read_chunks.append(_sd_listing(r"sddir \BTXDATA", ["2026-03", "notes"])) + fake.read_chunks.append(_sd_listing(r"sddir \BTXDATA\2026-03", ["260308", "260309"])) + fake.read_chunks.append(_sd_listing(r"sddir \BTXDATA\2026-03\260308", ["113530PP.TXT"])) + fake.read_chunks.append( + _sd_listing(r"sddir \BTXDATA\2026-03\260309", ["153008.TXT", "153425.TXT"]) + ) + control = FileTransferControl(serial_io=fake) + + logs = await control.list_log_files() + + self.assertEqual( + logs, + [ + r"\BTXDATA\2026-03\260308\113530PP.TXT", + r"\BTXDATA\2026-03\260309\153008.TXT", + r"\BTXDATA\2026-03\260309\153425.TXT", + ], + ) + + async def test_device_info_helpers(self): + fake = _FakeSerial() + fake.read_chunks.append(b"BTX Gemini 4.0.4\nSerial number: 1135421\n:") + fake.read_chunks.append(b"1135421\n:") + fake.read_chunks.append(b"03/06/2026 2:36:11 PM\n:") + fake.read_chunks.append( + b"\nSuccessful Tx: 57295\nSuccessful Rx: 57296\nFailed: 0\nRetries: 0\n:" + ) + control = FileTransferControl(serial_io=fake) + + version = await control.get_version() + serial_number = await control.get_serial_number() + device_time = await control.get_device_time() + stats = await control.get_comm_stats() + + self.assertEqual(version, "BTX Gemini 4.0.4") + self.assertEqual(serial_number, "1135421") + self.assertEqual(device_time, "03/06/2026 2:36:11 PM") + self.assertEqual(stats["Successful Tx"], 57295) + self.assertEqual(stats["Successful Rx"], 57296) + + async def test_parse_run_log_extracts_summary_fields(self): + control = FileTransferControl(serial_io=_FakeSerial()) + parsed = control.parse_run_log( + "\n".join( + [ + "Date/Time: 03/09/2026 3:34:25 PM", + "Model: BTX Gemini", + "Mode: Electroporation", + "Serial Number: 1135421", + "GUI Software Version: 4.0.4", + "DC Pulse Generator Firmware Version: 4.0.4", + "Auto-PrePulse: On", + "Protocol Name: !PLR_154635", + "Protocol Type: Exponential", + "Pulse Amplitude: 2300 V", + "Number of Pulses: 1", + "Pulse Interval: 0 sec", + "Electrode Gap: 2.0 mm", + "Plate Columns: 3", + "Resistance: 200 ohms", + "Capacitance: 25 uF", + "PrePulse External Load: 5000 ohms", + "Droop: 0.0%", + "Pulse 1 Voltage: 2303.53 V", + "Pulse 1 Time Constant: 5021 us", + "Pulse 1 Total Load: 199 ohms", + "Protocol Result: Complete", + "Status: 0x00000000.00000000 - No error.", + ] + ) + ) + + self.assertEqual(parsed["summary"]["protocol_name"], "!PLR_154635") + self.assertEqual(parsed["summary"]["protocol_type"], "Exponential") + self.assertEqual(parsed["summary"]["plate_columns"], 3) + self.assertEqual(parsed["summary"]["pulse_amplitude_volts"], 2300) + self.assertEqual(parsed["summary"]["protocol_result"], "Complete") + self.assertEqual(parsed["summary"]["status_code"], "0x00000000.00000000") + self.assertEqual(parsed["summary"]["status_message"], "No error.") + self.assertNotIn("raw_fields", parsed) + self.assertNotIn("line_count", parsed) + + async def test_parse_run_log_extracts_tabular_fields(self): + control = FileTransferControl(serial_io=_FakeSerial()) + parsed = control.parse_run_log( + "\n".join( + [ + "Date (MM/DD/YYYY)\tTime (HHMMSS)\tModel\tMode\tSerial Number\tGUI Firmware\tDC Firmware\tAuto-PrePulse", + "03/09/2026\t3:34:25 PM\tBTX Gemini\tElectroporation\t1135421\t4.0.4\t4.0.4\tOn", + "", + "Protocol Name\tProtocol Type\tPulse Amplitude (V)\t# of Pulses\tPulse Interval (sec)\tGap (mm)\tPlate Columns\tResistance (Ohms)\tCapacitance (uF)", + "!PLR_0309160010\tExponential\t2300\t1\t0\t3.0\t3\t200\t25", + "", + "PrePulse:\tExternal Load (Ohms):\t5000\tDroop (%):\t0.0", + "DC Pulses\tVoltage (V)\tTime Constant (us)\tTotal Load (Ohms)", + "Pulse 1\t2303.53\t5021\t199", + "", + "Protocol Result\tStatus Code", + "Complete\t0x00000000.00000000\t(No error.)", + ] + ) + ) + + self.assertEqual(parsed["summary"]["date_time"], "03/09/2026 3:34:25 PM") + self.assertEqual(parsed["summary"]["protocol_name"], "!PLR_0309160010") + self.assertEqual(parsed["summary"]["pulse_amplitude_volts"], 2300) + self.assertEqual(parsed["summary"]["plate_columns"], 3) + self.assertAlmostEqual(parsed["summary"]["pulse_1_voltage_volts"], 2303.53) + self.assertEqual(parsed["summary"]["pulse_1_time_constant_us"], 5021) + self.assertEqual(parsed["summary"]["pulse_1_total_load_ohms"], 199) + self.assertEqual(parsed["summary"]["status_code"], "0x00000000.00000000") + self.assertEqual(parsed["summary"]["status_message"], "(No error.)") diff --git a/pylabrobot/btx/gemini_x2.py b/pylabrobot/btx/gemini_x2.py new file mode 100644 index 00000000000..5919f9aa722 --- /dev/null +++ b/pylabrobot/btx/gemini_x2.py @@ -0,0 +1,740 @@ +from __future__ import annotations + +import asyncio +from dataclasses import dataclass +from datetime import datetime, timezone +from typing import ( + Any, + Callable, + Dict, + Mapping, + Optional, + Protocol, + TypeVar, + Union, + cast, + runtime_checkable, +) + +from pylabrobot.capabilities.capability import BackendParams +from pylabrobot.capabilities.electroporation import ( + Electroporation, + ElectroporationBackend, + ElectroporationCancellationDetails, + ElectroporationCancellationResult, + ElectroporationCleanup, + ElectroporationExecutionDetails, + ElectroporationLogCapture, + ElectroporationPreparationDetails, + ElectroporationProtocol, + ElectroporationRunResult, + PreparedElectroporationRun, +) +from pylabrobot.device import Device, Driver + +from .file_transfer_control import FileTransferControl +from .ht200 import BTXHT200 +from .the_ghost_touch import ( + CancelledPreparedUserProtocolResult, + PreparedUserProtocolResult, + StartedPreparedUserProtocolResult, + TheGhostTouch, +) + + +@runtime_checkable +class _GhostTouchSession(Protocol): + def __enter__(self) -> "_GhostTouchSession": + pass + + def __exit__(self, exc_type, exc, tb) -> None: + pass + + def ensure_home(self) -> Any: + pass + + def prepare_user_protocol( + self, + protocol_name: str, + plate_columns: Optional[int] = None, + ) -> PreparedUserProtocolResult: + pass + + def start_prepared_user_protocol( + self, + protocol_name: str, + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> StartedPreparedUserProtocolResult: + pass + + def cancel_prepared_user_protocol( + self, home_after: bool = True + ) -> CancelledPreparedUserProtocolResult: + pass + + +GhostTouchFactory = Callable[..., _GhostTouchSession] +GhostTouchResult = TypeVar("GhostTouchResult") + + +def _result_dict(value: Any) -> Dict[str, Any]: + if hasattr(value, "as_dict"): + return cast(Dict[str, Any], value.as_dict()) + return cast(Dict[str, Any], value) + + +def _nested_state(payload: Mapping[str, Any], *path: str) -> Optional[str]: + current: Any = payload + for key in path: + if not isinstance(current, Mapping): + return None + current = current.get(key) + if isinstance(current, str): + return current + return None + + +@dataclass(frozen=True) +class TemporaryProtocolCleanupResult: + delete_result: Any + delete_retry_used: bool + delete_error: Optional[str] + + def as_dict(self) -> Dict[str, Any]: + return { + "delete_result": self.delete_result, + "delete_retry_used": self.delete_retry_used, + "delete_error": self.delete_error, + } + + +@dataclass(frozen=True) +class MatchedRunLogResult: + before_count: int + after_count: int + new_log_paths: tuple[str, ...] + matched_log_path: Optional[str] + matched_log: Any + + def as_dict(self) -> Dict[str, Any]: + return { + "before_count": self.before_count, + "after_count": self.after_count, + "new_log_paths": list(self.new_log_paths), + "matched_log_path": self.matched_log_path, + "matched_log": self.matched_log, + } + + +class BTXGeminiX2Driver(Driver): + """BTX Gemini X2 driver. + + Owns the file-transfer connection lifecycle and the temporary handoff into the RSI touch + control session. + """ + + def __init__( + self, + port: Optional[str] = None, + *, + file_transfer_control: Optional[FileTransferControl] = None, + ghost_touch_factory: Optional[GhostTouchFactory] = None, + ghost_touch_kwargs: Optional[dict[str, Any]] = None, + ) -> None: + super().__init__() + self.port = port or (file_transfer_control.port if file_transfer_control is not None else None) + self.file_transfer_control = file_transfer_control or FileTransferControl(port=port) + self._ghost_touch_factory = ghost_touch_factory or TheGhostTouch + self._ghost_touch_kwargs = dict(ghost_touch_kwargs or {}) + + async def setup(self, backend_params: Optional[BackendParams] = None): + del backend_params + await self.file_transfer_control.setup() + if self.file_transfer_control.port is not None: + self.port = self.file_transfer_control.port + + async def stop(self): + await self.file_transfer_control.stop() + + def serialize(self) -> dict: + return { + **super().serialize(), + "port": self.port, + } + + async def list_protocols(self) -> list[str]: + return await self.file_transfer_control.list_protocols() + + async def get_protocol(self, protocol_name: str) -> Dict[str, Any]: + return await self.file_transfer_control.get_protocol(protocol_name) + + async def add_protocol( + self, + protocol_name: str, + protocol: ElectroporationProtocol, + overwrite: bool = False, + ) -> Dict[str, Any]: + return await self.file_transfer_control.add_protocol( + protocol_name, protocol, overwrite=overwrite + ) + + async def delete_protocol(self, protocol_name: str, missing_ok: bool = False) -> Dict[str, Any]: + return await self.file_transfer_control.delete_protocol(protocol_name, missing_ok=missing_ok) + + async def list_log_files(self, root: str = "\\BTXDATA") -> list[str]: + return await self.file_transfer_control.list_log_files(root=root) + + async def fetch_sd_file(self, sd_path: str) -> str: + return await self.file_transfer_control.fetch_sd_file(sd_path) + + async def get_version(self) -> str: + return await self.file_transfer_control.get_version() + + async def get_serial_number(self) -> str: + return await self.file_transfer_control.get_serial_number() + + async def get_device_time(self) -> str: + return await self.file_transfer_control.get_device_time() + + def parse_run_log(self, text: str) -> Dict[str, Any]: + return self.file_transfer_control.parse_run_log(text) + + async def run_with_ghost_touch( + self, + action: Callable[[_GhostTouchSession], GhostTouchResult], + ) -> GhostTouchResult: + await self.file_transfer_control.stop() + try: + return await asyncio.to_thread(self._run_with_ghost_touch_sync, action) + finally: + await self.file_transfer_control.setup() + if self.file_transfer_control.port is not None: + self.port = self.file_transfer_control.port + + def _run_with_ghost_touch_sync( + self, + action: Callable[[_GhostTouchSession], GhostTouchResult], + ) -> GhostTouchResult: + with self._open_ghost_touch() as ghost_touch: + return action(ghost_touch) + + def _open_ghost_touch(self) -> _GhostTouchSession: + if self.port is None: + raise RuntimeError("Gemini X2 serial port is not resolved. Call setup() first.") + session = self._ghost_touch_factory(port=self.port, **self._ghost_touch_kwargs) + if not isinstance(session, _GhostTouchSession): + session = cast(_GhostTouchSession, session) + return session + + +class BTXGeminiX2ElectroporationBackend(ElectroporationBackend): + """Prepared-run BTX Gemini X2 backend. + + The Gemini X2 uses two separate control paths on the same USB-connected device: + `FileTransferControl` for Protocol Manager style file/protocol access, and `TheGhostTouch` + for the RSI touchscreen workflow that arms and starts a user protocol. + """ + + UI_PROTOCOL_NAME_BYTES = FileTransferControl.UI_PROTOCOL_NAME_BYTES + DEFAULT_TEMPORARY_PROTOCOL_PREFIX = "!PLR" + PLATE_HANDLER_RESET_STATE_UNKNOWN = "unknown" + PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED = "reset_confirmed" + PLATE_HANDLER_RESET_STATE_CONTINUE_CURRENT_POSITION = "continue_current_position" + PLATE_HANDLER_RESET_STATES = { + PLATE_HANDLER_RESET_STATE_UNKNOWN, + PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED, + PLATE_HANDLER_RESET_STATE_CONTINUE_CURRENT_POSITION, + } + + @dataclass(frozen=True) + class PrepareRunParams(BackendParams): + plate_handler_reset_state: str = "unknown" + + def __init__( + self, + driver: BTXGeminiX2Driver, + *, + plate_handler: Optional[BTXHT200] = None, + temporary_protocol_prefix: str = DEFAULT_TEMPORARY_PROTOCOL_PREFIX, + ) -> None: + self.driver = driver + self.plate_handler = plate_handler or BTXHT200() + self._temporary_protocol_prefix = temporary_protocol_prefix + self._is_setup = False + + async def _on_setup(self, backend_params: Optional[BackendParams] = None): + del backend_params + try: + # Setup only enforces ordering safety so a later process can resume an already prepared + # `!PLR_...` run token without being blocked by the existing temp protocol. + await self._ensure_temporary_protocol_prefix_order_safe(self._temporary_protocol_prefix) + self._is_setup = True + except Exception: + self._is_setup = False + raise + + async def _on_stop(self): + self._is_setup = False + + def serialize(self) -> dict: + return { + "temporary_protocol_prefix": self._temporary_protocol_prefix, + "plate_handler": { + "device": self.plate_handler.__class__.__name__, + "model": "HT-200", + "assumed_pulse_count": self.plate_handler.assumed_pulse_count, + "assumed_column_adjust": self.plate_handler.assumed_column_adjust, + }, + } + + async def prepare_temporary_protocol( + self, + protocol: ElectroporationProtocol, + plate_columns: Optional[int] = None, + prefix: Optional[str] = None, + backend_params: Optional[BackendParams] = None, + ) -> PreparedElectroporationRun: + """Create a temporary protocol and leave the Gemini armed on ``Run Protocol``.""" + self._require_setup() + if backend_params is None: + backend_params = self.PrepareRunParams() + if not isinstance(backend_params, self.PrepareRunParams): + raise TypeError( + "backend_params must be BTXGeminiX2ElectroporationBackend.PrepareRunParams or None." + ) + resolved_prefix = self._temporary_protocol_prefix if prefix is None else prefix + resolved_reset_state = self._resolve_plate_handler_reset_state( + plate_columns=plate_columns, + plate_handler_reset_state=backend_params.plate_handler_reset_state, + ) + assumed_plate_handler_pulse_count, assumed_plate_handler_column_adjust = ( + self._resolve_plate_handler_manual_state(plate_columns=plate_columns) + ) + # Preparing a new temp protocol is stricter than setup: earlier-sorting names and same-prefix + # temp leftovers both make the "first user protocol" strategy unsafe. + await self._ensure_temporary_protocol_prefix_available(resolved_prefix) + + # This snapshot lets start_prepared_run() identify the new log by diffing BTXDATA after GO. + baseline_log_paths = tuple(await self.driver.list_log_files()) + protocol_name = self._make_temporary_protocol_name(resolved_prefix) + add_result = await self.driver.add_protocol( + protocol_name=protocol_name, + protocol=protocol, + overwrite=False, + ) + + try: + rsi_result = await self._run_with_ghost_touch( + lambda ghost_touch: ghost_touch.prepare_user_protocol( + protocol_name=protocol_name, + plate_columns=plate_columns, + ) + ) + except Exception: + await self._cleanup_temporary_protocol(protocol_name, missing_ok=True) + raise + + return PreparedElectroporationRun( + protocol_name=protocol_name, + protocol=protocol, + plate_columns=plate_columns, + prefix=resolved_prefix, + prepared_at_utc=self._now_utc_iso(), + baseline_log_paths=baseline_log_paths, + prepare_result=ElectroporationPreparationDetails( + prepared_state=_nested_state(_result_dict(rsi_result), "prepared_verification", "state"), + protocol_setup=_result_dict(add_result), + device_prepare={ + "plate_handler_reset_state": resolved_reset_state, + "assumed_plate_handler_pulse_count": assumed_plate_handler_pulse_count, + "assumed_plate_handler_column_adjust": assumed_plate_handler_column_adjust, + **_result_dict(rsi_result), + }, + ), + ) + + async def start_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> ElectroporationRunResult: + """Verify, start, and collect the result for a previously prepared temporary run.""" + self._require_setup() + prepared = self._coerce_prepared_run(prepared_run) + + started_at_utc = self._now_utc_iso() + rsi_result = await self._run_with_ghost_touch( + lambda ghost_touch: ghost_touch.start_prepared_user_protocol( + protocol_name=prepared.protocol_name, + home_after=home_after, + max_run_seconds=max_run_seconds, + ) + ) + + try: + log_capture = await self._collect_matching_new_log( + before_logs=set(prepared.baseline_log_paths), + protocol_name=prepared.protocol_name, + ) + finally: + cleanup = await self._cleanup_temporary_protocol(prepared.protocol_name, missing_ok=True) + + return ElectroporationRunResult( + prepared_run=prepared, + started_at_utc=started_at_utc, + completed_at_utc=self._now_utc_iso(), + rsi_result=ElectroporationExecutionDetails( + verification_state=_nested_state(_result_dict(rsi_result), "verification", "state"), + completed_state=_nested_state(_result_dict(rsi_result), "completed", "state"), + final_state=( + _nested_state(_result_dict(rsi_result), "home", "state") + or _nested_state(_result_dict(rsi_result), "completed", "state") + ), + device_run=_result_dict(rsi_result), + ), + log_capture=ElectroporationLogCapture( + matched_log_path=cast(Optional[str], _result_dict(log_capture).get("matched_log_path")), + summary=dict( + cast(Mapping[str, Any], _result_dict(log_capture).get("matched_log", {})).get( + "summary", {} + ) + if isinstance(_result_dict(log_capture).get("matched_log"), Mapping) + else {} + ), + details=_result_dict(log_capture), + ), + cleanup=ElectroporationCleanup( + deleted=cast( + Optional[bool], + cast(Mapping[str, Any], _result_dict(cleanup).get("delete_result", {})).get("deleted"), + ) + if isinstance(_result_dict(cleanup).get("delete_result"), Mapping) + else None, + retry_used=bool(_result_dict(cleanup).get("delete_retry_used", False)), + error=cast(Optional[str], _result_dict(cleanup).get("delete_error")), + details=_result_dict(cleanup), + ), + ) + + async def cancel_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + home_after: bool = True, + ) -> ElectroporationCancellationResult: + """Return the Gemini to a safe screen and delete the prepared temporary protocol.""" + self._require_setup() + prepared = self._coerce_prepared_run(prepared_run) + + rsi_result = await self.driver.run_with_ghost_touch( + lambda ghost_touch: ghost_touch.cancel_prepared_user_protocol(home_after=home_after) + ) + cleanup = await self._cleanup_temporary_protocol(prepared.protocol_name, missing_ok=True) + + return ElectroporationCancellationResult( + prepared_run=prepared, + cancelled_at_utc=self._now_utc_iso(), + rsi_result=ElectroporationCancellationDetails( + final_state=_nested_state(_result_dict(rsi_result), "final_state", "state"), + device_cancel=_result_dict(rsi_result), + ), + cleanup=ElectroporationCleanup( + deleted=cast( + Optional[bool], + cast(Mapping[str, Any], _result_dict(cleanup).get("delete_result", {})).get("deleted"), + ) + if isinstance(_result_dict(cleanup).get("delete_result"), Mapping) + else None, + retry_used=bool(_result_dict(cleanup).get("delete_retry_used", False)), + error=cast(Optional[str], _result_dict(cleanup).get("delete_error")), + details=_result_dict(cleanup), + ), + ) + + async def get_device_info(self) -> Dict[str, Any]: + """Return Gemini identity plus the supported electroporation workflow surface.""" + self._require_setup() + version = await self.driver.get_version() + serial_number = await self.driver.get_serial_number() + device_time = await self.driver.get_device_time() + protocols = await self.driver.list_protocols() + plate_handler_info = self.plate_handler.get_device_info() + return { + "backend": self.__class__.__name__, + "model": "Gemini X2", + "port": self.driver.port, + "version": version, + "serial_number": serial_number, + "device_time": device_time, + "protocol_count": len(protocols), + "supports_prepared_temporary_runs": True, + "supports_serialized_prepared_runs": True, + "supports_stored_protocol_runs": False, + "supports_plate_columns": True, + "supports_plate_handler_reset_state": True, + "plate_handler_reset_states": sorted(self.PLATE_HANDLER_RESET_STATES), + "plate_handler": plate_handler_info, + "temporary_protocol_prefix": self._temporary_protocol_prefix, + "protocol_transfer_control": "FileTransferControl", + "touch_control": "TheGhostTouch", + } + + async def list_protocols(self) -> list[str]: + """List all user protocols visible through the PM serial interface.""" + self._require_setup() + return await self.driver.list_protocols() + + async def get_protocol(self, protocol_name: str) -> Dict[str, Any]: + """Fetch one stored user protocol by name.""" + self._require_setup() + return await self.driver.get_protocol(protocol_name) + + async def add_protocol( + self, + protocol_name: str, + protocol: ElectroporationProtocol, + overwrite: bool = False, + ) -> Dict[str, Any]: + """Developer helper: write a user protocol directly through file transfer.""" + self._require_setup() + return await self.driver.add_protocol(protocol_name, protocol, overwrite=overwrite) + + async def delete_protocol(self, protocol_name: str, missing_ok: bool = False) -> Dict[str, Any]: + """Developer helper: delete a stored user protocol.""" + self._require_setup() + return await self.driver.delete_protocol(protocol_name, missing_ok=missing_ok) + + async def list_log_files(self, root: str = "\\BTXDATA") -> list[str]: + """Developer helper: enumerate run logs stored on the Gemini SD card.""" + self._require_setup() + return await self.driver.list_log_files(root=root) + + async def fetch_sd_file(self, sd_path: str) -> str: + """Developer helper: fetch one SD-card file from the Gemini.""" + self._require_setup() + return await self.driver.fetch_sd_file(sd_path) + + def parse_run_log(self, text: str) -> Dict[str, Any]: + """Developer helper: parse a BTX run log into normalized fields.""" + return self.driver.parse_run_log(text) + + def _require_setup(self) -> None: + if not self._is_setup: + raise RuntimeError("Call setup() before using the Gemini X2 backend.") + + def _resolve_plate_handler_reset_state( + self, + *, + plate_columns: Optional[int], + plate_handler_reset_state: str, + ) -> str: + if plate_handler_reset_state not in self.PLATE_HANDLER_RESET_STATES: + allowed = ", ".join(sorted(self.PLATE_HANDLER_RESET_STATES)) + raise ValueError( + f"Unsupported plate_handler_reset_state={plate_handler_reset_state!r}. Allowed: {allowed}." + ) + if plate_columns is None: + if plate_handler_reset_state != self.PLATE_HANDLER_RESET_STATE_UNKNOWN: + raise ValueError("plate_handler_reset_state is only valid when plate_columns is set.") + return plate_handler_reset_state + if plate_handler_reset_state == self.PLATE_HANDLER_RESET_STATE_UNKNOWN: + raise ValueError( + "plate_columns requires an explicit plate_handler_reset_state. Use " + "'reset_confirmed' after manually lid-cycling the HT-200 back to column 1, " + "or 'continue_current_position' to intentionally continue from the current handler position." + ) + return plate_handler_reset_state + + def _resolve_plate_handler_manual_state( + self, + *, + plate_columns: Optional[int], + ) -> tuple[Optional[int], Optional[int]]: + if plate_columns is None: + return None, None + return self.plate_handler.require_manual_state() + + async def _ensure_temporary_protocol_prefix_order_safe(self, prefix: str) -> None: + conflicts = self._temporary_protocol_preceding_conflicts( + await self.driver.list_protocols(), + prefix, + ) + if conflicts: + reserved_anchor = self._temporary_protocol_sort_anchor(prefix) + raise RuntimeError( + "Temporary protocol prefix " + f"{prefix!r} is not safe on this device. These user protocols would sort before " + f"{reserved_anchor!r}: {conflicts}. Remove/rename them before setup or choose " + "a different reserved prefix." + ) + + async def _ensure_temporary_protocol_prefix_available(self, prefix: str) -> None: + protocols = await self.driver.list_protocols() + preceding = self._temporary_protocol_preceding_conflicts(protocols, prefix) + collisions = self._temporary_protocol_prefix_collisions(protocols, prefix) + conflicts = sorted(set(preceding + collisions), key=str.casefold) + if conflicts: + reserved_anchor = self._temporary_protocol_sort_anchor(prefix) + raise RuntimeError( + "Temporary protocol prefix " + f"{prefix!r} is not available on this device. These user protocols would sort before " + f"or collide with {reserved_anchor!r}: {conflicts}. Remove/rename them before " + "preparing a temporary protocol or choose a different reserved prefix." + ) + + def _temporary_protocol_sort_anchor(self, prefix: str) -> str: + prefix_text = prefix.strip() + if len(prefix_text) == 0: + raise ValueError("prefix cannot be empty.") + try: + prefix_text.encode("ascii") + except UnicodeEncodeError as exc: + raise ValueError("prefix must be ASCII.") from exc + return f"{prefix_text}_" + + def _temporary_protocol_preceding_conflicts(self, protocols: list[str], prefix: str) -> list[str]: + reserved_anchor = self._temporary_protocol_sort_anchor(prefix) + anchor_key = reserved_anchor.casefold() + conflicts = [] + for protocol_name in protocols: + protocol_key = protocol_name.casefold() + if protocol_key < anchor_key: + conflicts.append(protocol_name) + return sorted(conflicts, key=str.casefold) + + def _temporary_protocol_prefix_collisions(self, protocols: list[str], prefix: str) -> list[str]: + reserved_anchor = self._temporary_protocol_sort_anchor(prefix) + anchor_key = reserved_anchor.casefold() + collisions = [] + for protocol_name in protocols: + if protocol_name.casefold().startswith(anchor_key): + collisions.append(protocol_name) + return sorted(collisions, key=str.casefold) + + def _coerce_prepared_run( + self, + prepared_run: Union[PreparedElectroporationRun, Mapping[str, Any]], + ) -> PreparedElectroporationRun: + if isinstance(prepared_run, PreparedElectroporationRun): + return prepared_run + return PreparedElectroporationRun.from_dict(prepared_run) + + async def _run_with_ghost_touch( + self, + action: Callable[[_GhostTouchSession], GhostTouchResult], + ) -> GhostTouchResult: + self._require_setup() + return await self.driver.run_with_ghost_touch(action) + + async def _force_home_via_ghost_touch(self) -> None: + await self.driver.run_with_ghost_touch(lambda ghost_touch: ghost_touch.ensure_home()) + + async def _cleanup_temporary_protocol( + self, + protocol_name: str, + *, + missing_ok: bool, + ) -> TemporaryProtocolCleanupResult: + delete_result: Dict[str, Any] | None = None + delete_error: str | None = None + delete_retry_used = False + + try: + delete_result = await self.driver.delete_protocol( + protocol_name, + missing_ok=missing_ok, + ) + except RuntimeError as exc: + if "still exists after repeated delete attempts" not in str(exc): + delete_error = str(exc) + else: + delete_retry_used = True + try: + await self._force_home_via_ghost_touch() + delete_result = await self.driver.delete_protocol( + protocol_name, + missing_ok=missing_ok, + ) + except Exception as retry_exc: # pragma: no cover - hardware-specific recovery + delete_error = str(retry_exc) + except Exception as exc: # pragma: no cover - hardware-specific recovery + delete_error = str(exc) + + return TemporaryProtocolCleanupResult( + delete_result=delete_result, + delete_retry_used=delete_retry_used, + delete_error=delete_error, + ) + + async def _collect_matching_new_log( + self, + before_logs: set[str], + protocol_name: str, + ) -> MatchedRunLogResult: + # Logs are matched by "new since prepare" plus protocol name, rather than by "latest log", + # to avoid picking up unrelated historical runs. + after_logs = set(await self.driver.list_log_files()) + new_logs = sorted(after_logs - before_logs) + + for log_path in new_logs: + text = await self.driver.fetch_sd_file(log_path) + parsed = self.driver.parse_run_log(text) + if parsed["summary"]["protocol_name"] == protocol_name: + return MatchedRunLogResult( + before_count=len(before_logs), + after_count=len(after_logs), + new_log_paths=tuple(new_logs), + matched_log_path=log_path, + matched_log=parsed, + ) + + raise RuntimeError( + f"No new BTXDATA log matched protocol '{protocol_name}'. New logs: {new_logs}" + ) + + def _make_temporary_protocol_name(self, prefix: str) -> str: + reserved_anchor = self._temporary_protocol_sort_anchor(prefix) + timestamp = datetime.now().strftime("%m%d%H%M%S") + name = f"{reserved_anchor}{timestamp}" + if len(name.encode("ascii")) > self.UI_PROTOCOL_NAME_BYTES: + raise ValueError( + f"Generated temp protocol name {name!r} exceeds the " + f"{self.UI_PROTOCOL_NAME_BYTES}-byte Gemini UI limit. Shorten prefix={prefix!r}." + ) + return name + + def _now_utc_iso(self) -> str: + return datetime.now(timezone.utc).isoformat() + + +class BTXGeminiX2(Device): + """BTX Gemini X2 electroporator.""" + + def __init__( + self, + port: Optional[str] = None, + *, + file_transfer_control: Optional[FileTransferControl] = None, + ghost_touch_factory: Optional[GhostTouchFactory] = None, + ghost_touch_kwargs: Optional[dict[str, Any]] = None, + plate_handler: Optional[BTXHT200] = None, + temporary_protocol_prefix: str = BTXGeminiX2ElectroporationBackend.DEFAULT_TEMPORARY_PROTOCOL_PREFIX, + ) -> None: + driver = BTXGeminiX2Driver( + port=port, + file_transfer_control=file_transfer_control, + ghost_touch_factory=ghost_touch_factory, + ghost_touch_kwargs=ghost_touch_kwargs, + ) + super().__init__(driver=driver) + self.driver: BTXGeminiX2Driver = driver + self.plate_handler = plate_handler or BTXHT200() + self.electroporation = Electroporation( + backend=BTXGeminiX2ElectroporationBackend( + driver=driver, + plate_handler=self.plate_handler, + temporary_protocol_prefix=temporary_protocol_prefix, + ) + ) + self._capabilities = [self.electroporation] diff --git a/pylabrobot/btx/gemini_x2_tests.py b/pylabrobot/btx/gemini_x2_tests.py new file mode 100644 index 00000000000..eba634163cc --- /dev/null +++ b/pylabrobot/btx/gemini_x2_tests.py @@ -0,0 +1,637 @@ +import unittest +from typing import Any, Dict, List, Optional, cast + +from pylabrobot.btx.file_transfer_control import FileTransferControl +from pylabrobot.btx.gemini_x2 import ( + BTXGeminiX2Driver, + BTXGeminiX2ElectroporationBackend, + GhostTouchFactory, +) +from pylabrobot.btx.ht200 import BTXHT200 +from pylabrobot.capabilities.electroporation.standard import ( + ElectroporationPreparationDetails, + ElectroporationProtocol, + PreparedElectroporationRun, +) + + +class _DummySerial: + async def setup(self) -> None: + pass + + async def stop(self) -> None: + pass + + async def write(self, data: bytes) -> None: + del data + + async def read(self, num_bytes: int = 1) -> bytes: + del num_bytes + return b"" + + async def readline(self) -> bytes: + return b"" + + +class _FakeFileTransferControl: + def __init__(self) -> None: + self.port = "/dev/fake-btx" + self.setup_calls = 0 + self.stop_calls = 0 + self.protocols = ["CD", "JJ"] + self.log_snapshots: List[List[str]] = [] + self.log_contents: Dict[str, str] = {} + self.add_calls: List[Dict[str, Any]] = [] + self.delete_calls: List[Dict[str, Any]] = [] + self.delete_failures_before_success = 0 + self.version = "BTX Gemini 4.0.4" + self.serial_number = "1135421" + self.device_time = "03/09/2026 5:00:00 PM" + self._parser = FileTransferControl(port=self.port, serial_io=_DummySerial()) + + async def setup(self) -> None: + self.setup_calls += 1 + + async def stop(self) -> None: + self.stop_calls += 1 + + async def list_protocols(self) -> list[str]: + return list(self.protocols) + + async def add_protocol( + self, + protocol_name: str, + protocol: ElectroporationProtocol, + overwrite: bool = False, + ) -> Dict[str, Any]: + self.add_calls.append( + { + "protocol_name": protocol_name, + "protocol": protocol, + "overwrite": overwrite, + } + ) + self.protocols = sorted(self.protocols + [protocol_name]) + return {"operation": "add_protocol", "protocol": protocol_name, "overwrite": overwrite} + + async def delete_protocol(self, protocol_name: str, missing_ok: bool = False) -> Dict[str, Any]: + self.delete_calls.append({"protocol_name": protocol_name, "missing_ok": missing_ok}) + if self.delete_failures_before_success > 0: + self.delete_failures_before_success -= 1 + raise RuntimeError(f'Protocol "{protocol_name}" still exists after repeated delete attempts.') + if protocol_name not in self.protocols: + if missing_ok: + return {"operation": "delete_protocol", "deleted": False, "protocol": protocol_name} + raise FileNotFoundError(protocol_name) + self.protocols = [name for name in self.protocols if name != protocol_name] + return {"operation": "delete_protocol", "deleted": True, "protocol": protocol_name} + + async def list_log_files(self, root: str = "\\BTXDATA") -> list[str]: + del root + if self.log_snapshots: + return list(self.log_snapshots.pop(0)) + return sorted(self.log_contents) + + async def fetch_sd_file(self, sd_path: str) -> str: + return self.log_contents[sd_path] + + async def get_version(self) -> str: + return self.version + + async def get_serial_number(self) -> str: + return self.serial_number + + async def get_device_time(self) -> str: + return self.device_time + + def parse_run_log(self, text: str) -> Dict[str, Any]: + return self._parser.parse_run_log(text) + + +class _FakeGhostTouchSession: + def __init__(self, factory: "_FakeGhostTouchFactory", kwargs: Dict[str, Any]) -> None: + self.factory = factory + self.kwargs = kwargs + + def __enter__(self) -> "_FakeGhostTouchSession": + self.factory.entered += 1 + return self + + def __exit__(self, exc_type, exc, tb) -> None: + del exc_type, exc, tb + self.factory.exited += 1 + + def ensure_home(self) -> Dict[str, Any]: + self.factory.ensure_home_calls += 1 + return {"state": "main_menu"} + + def prepare_user_protocol( + self, + protocol_name: str, + plate_columns: Optional[int] = None, + ) -> dict[str, object]: + if self.factory.prepare_error is not None: + raise self.factory.prepare_error + call = { + "protocol_name": protocol_name, + "plate_columns": plate_columns, + "port": self.kwargs["port"], + } + self.factory.prepare_calls.append(call) + return { + "protocol_name": protocol_name, + "plate_columns": plate_columns, + "run_view": {"state": "protocol_run_view"}, + "prepared_verification": {"state": "protocol_run_view"}, + } + + def start_prepared_user_protocol( + self, + protocol_name: str, + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> dict[str, object]: + if self.factory.start_error is not None: + raise self.factory.start_error + call = { + "protocol_name": protocol_name, + "home_after": home_after, + "max_run_seconds": max_run_seconds, + "port": self.kwargs["port"], + } + self.factory.start_calls.append(call) + return { + "protocol_name": protocol_name, + "verification": {"state": "protocol_run_view"}, + "after_start": {"state": "protocol_run_view"}, + "completed": {"state": "protocol_finish"}, + } + + def cancel_prepared_user_protocol(self, home_after: bool = True) -> dict[str, object]: + if self.factory.cancel_error is not None: + raise self.factory.cancel_error + self.factory.cancel_calls.append({"home_after": home_after, "port": self.kwargs["port"]}) + return { + "cancelled": True, + "final_state": {"state": "main_menu"}, + "home_after": home_after, + } + + +class _FakeGhostTouchFactory: + def __init__(self) -> None: + self.created: List[Dict[str, Any]] = [] + self.prepare_calls: List[Dict[str, Any]] = [] + self.start_calls: List[Dict[str, Any]] = [] + self.cancel_calls: List[Dict[str, Any]] = [] + self.entered = 0 + self.exited = 0 + self.ensure_home_calls = 0 + self.prepare_error: Exception | None = None + self.start_error: Exception | None = None + self.cancel_error: Exception | None = None + + def __call__(self, **kwargs: Any) -> _FakeGhostTouchSession: + self.created.append(dict(kwargs)) + return _FakeGhostTouchSession(self, dict(kwargs)) + + +def _make_backend( + *, + file_transfer_control: Optional[_FakeFileTransferControl] = None, + plate_handler: Optional[BTXHT200] = None, + ghost_touch_factory: Optional[_FakeGhostTouchFactory] = None, + temporary_protocol_prefix: str = ( + BTXGeminiX2ElectroporationBackend.DEFAULT_TEMPORARY_PROTOCOL_PREFIX + ), +) -> BTXGeminiX2ElectroporationBackend: + driver = BTXGeminiX2Driver( + file_transfer_control=cast(Optional[FileTransferControl], file_transfer_control), + ghost_touch_factory=cast(Optional[GhostTouchFactory], ghost_touch_factory), + ) + return BTXGeminiX2ElectroporationBackend( + driver=driver, + plate_handler=plate_handler, + temporary_protocol_prefix=temporary_protocol_prefix, + ) + + +async def _setup_backend(backend: BTXGeminiX2ElectroporationBackend) -> None: + await backend.driver.setup() + await backend._on_setup() + + +def _prepare_params( + backend: BTXGeminiX2ElectroporationBackend, + state: str, +) -> BTXGeminiX2ElectroporationBackend.PrepareRunParams: + return backend.PrepareRunParams(plate_handler_reset_state=state) + + +class TestBTXGeminiX2Backend(unittest.IsolatedAsyncioTestCase): + async def test_prepare_temporary_protocol_adds_protocol_and_arms_run_view(self): + file_control = _FakeFileTransferControl() + file_control.log_snapshots = [[r"\BTXDATA\2026-03\260309\100000.TXT"]] + ghost_factory = _FakeGhostTouchFactory() + backend = _make_backend( + file_transfer_control=file_control, + plate_handler=BTXHT200(assumed_pulse_count=2, assumed_column_adjust=0), + ghost_touch_factory=ghost_factory, + ) + protocol = ElectroporationProtocol( + protocol_type="exponential", + pulse_amplitude_volts=2300, + gap_mm=2.0, + resistance_ohms=200, + capacitance_uf=25, + ) + + await _setup_backend(backend) + prepared = await backend.prepare_temporary_protocol( + protocol, + plate_columns=3, + backend_params=_prepare_params( + backend, + backend.PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED, + ), + ) + + self.assertTrue(prepared.protocol_name.startswith("!PLR_")) + self.assertEqual(prepared.plate_columns, 3) + self.assertEqual(prepared.baseline_log_paths, (r"\BTXDATA\2026-03\260309\100000.TXT",)) + self.assertEqual(file_control.add_calls[0]["protocol"], protocol) + self.assertEqual(ghost_factory.prepare_calls[0]["protocol_name"], prepared.protocol_name) + self.assertEqual(prepared.prepare_result.prepared_state, "protocol_run_view") + self.assertEqual( + prepared.prepare_result.device_prepare["plate_handler_reset_state"], + backend.PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED, + ) + self.assertEqual(prepared.prepare_result.device_prepare["assumed_plate_handler_pulse_count"], 2) + self.assertEqual( + prepared.prepare_result.device_prepare["assumed_plate_handler_column_adjust"], 0 + ) + + async def test_prepare_temporary_protocol_cleans_up_if_ui_prepare_fails(self): + file_control = _FakeFileTransferControl() + file_control.log_snapshots = [[r"\BTXDATA\2026-03\260309\100000.TXT"]] + ghost_factory = _FakeGhostTouchFactory() + ghost_factory.prepare_error = RuntimeError("prepare failed") + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + ) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + with self.assertRaisesRegex(RuntimeError, "prepare failed"): + await backend.prepare_temporary_protocol(protocol) + + self.assertEqual(len(file_control.delete_calls), 1) + self.assertTrue(file_control.delete_calls[0]["missing_ok"]) + + async def test_prepare_temporary_protocol_uses_backend_default_prefix_when_not_overridden(self): + file_control = _FakeFileTransferControl() + ghost_factory = _FakeGhostTouchFactory() + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + temporary_protocol_prefix="!TMP", + ) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + prepared = await backend.prepare_temporary_protocol(protocol) + + self.assertEqual(prepared.prefix, "!TMP") + self.assertTrue(prepared.protocol_name.startswith("!TMP_")) + + async def test_prepare_temporary_protocol_requires_explicit_plate_handler_reset_state(self): + file_control = _FakeFileTransferControl() + backend = _make_backend( + file_transfer_control=file_control, + plate_handler=BTXHT200(assumed_pulse_count=2, assumed_column_adjust=0), + ) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + + with self.assertRaisesRegex(ValueError, "requires an explicit plate_handler_reset_state"): + await backend.prepare_temporary_protocol(protocol, plate_columns=3) + + async def test_prepare_temporary_protocol_requires_assumed_plate_handler_manual_state(self): + file_control = _FakeFileTransferControl() + backend = _make_backend( + file_transfer_control=file_control, + plate_handler=BTXHT200(), + ) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + + with self.assertRaisesRegex( + ValueError, + "Missing: assumed_pulse_count, assumed_column_adjust", + ): + await backend.prepare_temporary_protocol( + protocol, + plate_columns=3, + backend_params=_prepare_params( + backend, + backend.PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED, + ), + ) + + async def test_prepare_temporary_protocol_rejects_plate_handler_reset_state_without_columns(self): + file_control = _FakeFileTransferControl() + backend = _make_backend(file_transfer_control=file_control) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + + with self.assertRaisesRegex(ValueError, "only valid when plate_columns is set"): + await backend.prepare_temporary_protocol( + protocol, + backend_params=_prepare_params( + backend, + backend.PLATE_HANDLER_RESET_STATE_RESET_CONFIRMED, + ), + ) + + async def test_serialize_includes_plate_handler_backend_manual_state(self): + backend = _make_backend( + file_transfer_control=_FakeFileTransferControl(), + plate_handler=BTXHT200(assumed_pulse_count=2, assumed_column_adjust=1), + ) + + serialized_handler = backend.serialize()["plate_handler"] + self.assertEqual(serialized_handler["device"], "BTXHT200") + self.assertEqual(serialized_handler["assumed_pulse_count"], 2) + self.assertEqual(serialized_handler["assumed_column_adjust"], 1) + + async def test_start_prepared_run_verifies_runs_collects_log_and_cleans_up(self): + file_control = _FakeFileTransferControl() + file_control.log_snapshots = [ + [r"\BTXDATA\2026-03\260309\100000.TXT", r"\BTXDATA\2026-03\260309\100100.TXT"], + ] + file_control.log_contents[r"\BTXDATA\2026-03\260309\100100.TXT"] = "\n".join( + [ + "Protocol Name: !PLR_123456789", + "Protocol Result: Complete", + "Status: 0x00000000.00000000 - No error.", + ] + ) + ghost_factory = _FakeGhostTouchFactory() + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + ) + prepared = PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=ElectroporationProtocol( + protocol_type="exponential", + pulse_amplitude_volts=2300, + gap_mm=2.0, + resistance_ohms=200, + capacitance_uf=25, + ), + plate_columns=3, + prefix="!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(r"\BTXDATA\2026-03\260309\100000.TXT",), + prepare_result=ElectroporationPreparationDetails( + prepared_state="protocol_run_view", + protocol_setup={}, + device_prepare={"prepared_verification": {"state": "protocol_run_view"}}, + ), + ) + + await _setup_backend(backend) + file_control.protocols.append("!PLR_123456789") + result = await backend.start_prepared_run(prepared.as_dict(), max_run_seconds=100.0) + + self.assertEqual(result.prepared_run.protocol_name, prepared.protocol_name) + self.assertEqual(ghost_factory.start_calls[0]["protocol_name"], prepared.protocol_name) + self.assertEqual(result.log_capture.matched_log_path, r"\BTXDATA\2026-03\260309\100100.TXT") + self.assertTrue(result.cleanup.deleted) + self.assertIsNone(result.cleanup.error) + + async def test_start_prepared_run_leaves_protocol_for_explicit_cancel_if_verification_fails(self): + file_control = _FakeFileTransferControl() + ghost_factory = _FakeGhostTouchFactory() + ghost_factory.start_error = RuntimeError("verification failed") + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + ) + prepared = PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ), + plate_columns=None, + prefix="!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(), + prepare_result=ElectroporationPreparationDetails( + prepared_state=None, + protocol_setup={}, + device_prepare={}, + ), + ) + + await _setup_backend(backend) + file_control.protocols.append("!PLR_123456789") + with self.assertRaisesRegex(RuntimeError, "verification failed"): + await backend.start_prepared_run(prepared.as_dict()) + + self.assertEqual(file_control.delete_calls, []) + self.assertIn(prepared.protocol_name, file_control.protocols) + + async def test_cancel_prepared_run_homes_and_deletes(self): + file_control = _FakeFileTransferControl() + ghost_factory = _FakeGhostTouchFactory() + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + ) + prepared = PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ), + plate_columns=None, + prefix="!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(), + prepare_result=ElectroporationPreparationDetails( + prepared_state=None, + protocol_setup={}, + device_prepare={}, + ), + ) + + await _setup_backend(backend) + file_control.protocols.append("!PLR_123456789") + result = await backend.cancel_prepared_run(prepared.as_dict()) + + self.assertTrue(result.cleanup.deleted) + self.assertEqual(ghost_factory.cancel_calls[0]["home_after"], True) + self.assertNotIn(prepared.protocol_name, file_control.protocols) + + async def test_setup_rejects_unsafe_default_temp_prefix(self): + file_control = _FakeFileTransferControl() + file_control.protocols = ["!AAA", "CD"] + backend = _make_backend(file_transfer_control=file_control) + + with self.assertRaisesRegex(RuntimeError, r"Temporary protocol prefix '!PLR' is not safe"): + await _setup_backend(backend) + + self.assertEqual(file_control.setup_calls, 1) + self.assertEqual(file_control.stop_calls, 0) + + async def test_setup_allows_existing_reserved_temp_prefix_for_resume(self): + file_control = _FakeFileTransferControl() + file_control.protocols = ["!PLR_OLD", "CD"] + backend = _make_backend(file_transfer_control=file_control) + + await _setup_backend(backend) + + async def test_prepare_temporary_protocol_rejects_unsafe_custom_prefix(self): + file_control = _FakeFileTransferControl() + file_control.protocols = ["!PLX_OLD", "CD"] + backend = _make_backend(file_transfer_control=file_control) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + + with self.assertRaisesRegex(RuntimeError, r"Temporary protocol prefix '!PLY' is not available"): + await backend.prepare_temporary_protocol(protocol, prefix="!PLY") + + async def test_prepare_temporary_protocol_rejects_existing_reserved_temp_prefix(self): + file_control = _FakeFileTransferControl() + file_control.protocols = ["!PLR_OLD", "CD"] + backend = _make_backend(file_transfer_control=file_control) + protocol = ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + + await _setup_backend(backend) + + with self.assertRaisesRegex(RuntimeError, r"not available.*!PLR_OLD"): + await backend.prepare_temporary_protocol(protocol) + + async def test_cancel_prepared_run_retries_delete_after_forcing_home(self): + file_control = _FakeFileTransferControl() + file_control.delete_failures_before_success = 1 + ghost_factory = _FakeGhostTouchFactory() + backend = _make_backend( + file_transfer_control=file_control, + ghost_touch_factory=ghost_factory, + ) + prepared = PreparedElectroporationRun( + protocol_name="!PLR_123456789", + protocol=ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ), + plate_columns=None, + prefix="!PLR", + prepared_at_utc="2026-03-09T10:00:00+00:00", + baseline_log_paths=(), + prepare_result=ElectroporationPreparationDetails( + prepared_state=None, + protocol_setup={}, + device_prepare={}, + ), + ) + + await _setup_backend(backend) + file_control.protocols.append("!PLR_123456789") + result = await backend.cancel_prepared_run(prepared.as_dict()) + + self.assertTrue(result.cleanup.retry_used) + self.assertEqual(ghost_factory.ensure_home_calls, 1) + self.assertEqual(len(file_control.delete_calls), 2) + + async def test_get_device_info(self): + file_control = _FakeFileTransferControl() + backend = _make_backend( + file_transfer_control=file_control, + plate_handler=BTXHT200(assumed_pulse_count=2, assumed_column_adjust=1), + ) + + await _setup_backend(backend) + info = await backend.get_device_info() + + self.assertEqual(info["model"], "Gemini X2") + self.assertEqual(info["serial_number"], "1135421") + self.assertEqual(info["protocol_count"], 2) + self.assertTrue(info["supports_prepared_temporary_runs"]) + self.assertTrue(info["supports_serialized_prepared_runs"]) + self.assertFalse(info["supports_stored_protocol_runs"]) + self.assertTrue(info["supports_plate_handler_reset_state"]) + self.assertIn("reset_confirmed", info["plate_handler_reset_states"]) + self.assertEqual(info["plate_handler"]["model"], "HT-200") + self.assertEqual(info["plate_handler"]["assumed_pulse_count"], 2) + self.assertEqual(info["plate_handler"]["assumed_column_adjust"], 1) + self.assertEqual(info["temporary_protocol_prefix"], "!PLR") + + async def test_requires_setup_before_use(self): + backend = _make_backend(file_transfer_control=_FakeFileTransferControl()) + + with self.assertRaisesRegex(RuntimeError, r"Call setup\(\) before"): + await backend.prepare_temporary_protocol( + ElectroporationProtocol( + protocol_type="square", + pulse_amplitude_volts=250, + gap_mm=1.0, + duration_us=1000, + ) + ) + + async def test_temp_name_rejects_overlong_prefix(self): + backend = _make_backend(file_transfer_control=_FakeFileTransferControl()) + + with self.assertRaisesRegex(ValueError, "exceeds the 15-byte"): + backend._make_temporary_protocol_name("!PLR_TOO_LONG") diff --git a/pylabrobot/btx/ht200.py b/pylabrobot/btx/ht200.py new file mode 100644 index 00000000000..62b5305ecc6 --- /dev/null +++ b/pylabrobot/btx/ht200.py @@ -0,0 +1,85 @@ +from __future__ import annotations + +from typing import Any, Dict, Optional + + +class BTXHT200: + """Manual-state model for the BTX HT-200 plate handler. + + The HT-200 has no separate software control path here. Column handling is driven through the + Gemini X2 UI, so this object owns only the caller's assumed manual handler state. + """ + + def __init__( + self, + *, + assumed_pulse_count: Optional[int] = None, + assumed_column_adjust: Optional[int] = None, + ) -> None: + self._assumed_pulse_count = self._coerce_assumed_pulse_count(assumed_pulse_count) + self._assumed_column_adjust = self._coerce_assumed_column_adjust(assumed_column_adjust) + + @property + def assumed_pulse_count(self) -> Optional[int]: + return self._assumed_pulse_count + + @property + def assumed_column_adjust(self) -> Optional[int]: + return self._assumed_column_adjust + + def configure_manual_state( + self, + *, + pulse_count: Optional[int] = None, + column_adjust: Optional[int] = None, + ) -> None: + """Record the caller's current HT-200 manual configuration assumptions.""" + self._assumed_pulse_count = self._coerce_assumed_pulse_count(pulse_count) + self._assumed_column_adjust = self._coerce_assumed_column_adjust(column_adjust) + + def clear_manual_state(self) -> None: + """Forget the current HT-200 manual configuration assumptions.""" + self._assumed_pulse_count = None + self._assumed_column_adjust = None + + def require_manual_state(self) -> tuple[int, int]: + """Return the configured manual assumptions needed for a Gemini plate-handler run.""" + pulse_count = self._assumed_pulse_count + column_adjust = self._assumed_column_adjust + missing = [] + if pulse_count is None: + missing.append("assumed_pulse_count") + if column_adjust is None: + missing.append("assumed_column_adjust") + if missing: + raise ValueError( + "HT-200 manual state is not fully configured. Missing: " + f"{', '.join(missing)}. Configure the HT-200 before preparing a run " + "that uses plate_columns." + ) + assert pulse_count is not None + assert column_adjust is not None + return pulse_count, column_adjust + + def get_device_info(self) -> Dict[str, Any]: + return { + "device": self.__class__.__name__, + "model": "HT-200", + "access_control_mode": "manual", + "manual_access_effect": "lid_cycle_resets_column_start_to_1", + "assumed_pulse_count": self._assumed_pulse_count, + "assumed_column_adjust": self._assumed_column_adjust, + } + + def _coerce_assumed_pulse_count(self, value: Optional[int]) -> Optional[int]: + if value is None: + return None + pulse_count = int(value) + if pulse_count <= 0: + raise ValueError("assumed_pulse_count must be a positive integer or None.") + return pulse_count + + def _coerce_assumed_column_adjust(self, value: Optional[int]) -> Optional[int]: + if value is None: + return None + return int(value) diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/00_main_menu.png b/pylabrobot/btx/test_data/gemini_x2/screens/00_main_menu.png new file mode 100644 index 0000000000000000000000000000000000000000..d090cda68644547a79c0fb236ba21adef4286a40 GIT binary patch literal 17540 zcmeIZcR1VO+czAvv{j?S9zk1b7p*;tDjjHTf~Zk@)?U$Ctre|RHA`y~F=C4ydz6SE zQq>M08q zk znjH0P#H~7?pSn~GC#VlaS~%ScZT$@YRXy}lZt671>s)?G@AnB|d~Yk(rG}_RT93xx zSNvM!0037A>B9?qGBN<*+pVVnK#27fdeT!CvMZ!_o&)|5K28;lRPbJpCEiB0MI<6Zwe~pxFmc7KoV32P`G9F#&{Ko8!~Hq4t2SCMIvQ#u+-rV+&uiv?3>%f97$0BCH3C zHLitR1n>Bm`E1QlX9ezB9~0+MQ1!te;^D^jfNOB2^rn1%e*SDv0$%{b^Yb<2x!~#a z(3z_A)w|DkbxZ9zX+3f4V2pw)o)jE5yAvIbKaKh#UV*m)ZhJ%oOl{iI^C69u4wH@JaQFi9UCJrvC(8uik(q}-tMhGWT? zIWoA(+sMA*cpw=2?L%`bC+k`|A7$9mP!=79mD7vD(UW~c$bsQK*ji(d;@SRaj=o@W zC9CfyuEDTze5Y|FR~;JV|Mp4udX6iEI5jH>CcHfEl4`zn{+I5Y>vY{#Y0CR+8yn8$ zD4LhfsI+CUxPKh$^7eO=%Y%T)x>a_;&L?rMpc_=EWfAwr0dB0U{@KScc3+WA_4~; z(t{5WtIkteo~=;~E2~-h`htJwQIm^CvGxl^AOynv4xmb{S{xK7Os_a87!l_1<}(b8 z6%Z5gPAH0iQqcjmIHYca)Kklv(?{q@uWW~5qas=KBgLdD{tO} z=E{m~)`0wY<9s519g`~KVC`Kbvy|@L?BF-9ppBz{qoBo3C$9KVA(`JhK_KXK2PK%{ z_(R&a*@^$NO#z$vq~!ML(E0jM8}e)l8LmV~P~taHI-doeb9*-6oSB@F1}flRrSq(- zF~C#?#H7C_V3-mPhVUDd7^Y5oWikV1f{t*h^Uvl8ig6MGnuW}Uw$ZXD>yF30}n)AoV!ic;)qH3>zyTrkW&=IbUKRpY4GVhFmfw!Nv^c^i5$z*!-c7{ zpgLNBU2%mMmxF9z{|&NvvIpmW^lj5o$H&qU_DLs3J#qM5!-mAzXtKEkKJ7M)Ig)lL z(=0Y1RV3|XInA}%xS#n+@s#d?{MlO6D0=ayeWy_d3L3qac*Hfc$NbnbS_At;z~!ja zHK=&xgO6;+>=3-u7I->6@wgE}tbu?|&y+6qlxF+Do9drnkh3-7t*2ecRKa!ZYu)CA!yn}0 z%DX(*nGbuNR!WL1k#P?*Ch~H^qBdhI`#cJ>8t6!50T${A3*nM=tJaVw~g+ zut@FoOt4bo)USWhY4An5*Z`ftmvt9%zLIsmRep1;nfNg9coroA#crKEo{TMU>MZc? zt6z=tQmnugS5|%<|HNwo?0u>qg+zHIS4MR@%E`!Z^1m9LQz)j*EHei|hW#p+;#%QV z+R?WVFC1-K9V|2A%)}Il=n^GB3&N(eW`03xdm*v8@^o2UiS?Xaa3rZc=Cd$xtJ9S* zKW_z5Joohk?4ME5wP6W_4sUpc{OyV^=o3GFi7Zh{PgL(w;%>(W6uq7Rd8_zR>Va(> zbAK0zCkovgNmjV{k@2(eYa5GoB%(p0?B6AfivgWe?uR5ME$P>TH(quIWH?>{OgdG0 zfX*nJO>Skq&q3RS%kE296j22KvsoKI7ev1d{~4M^oV-HiP6DTcCWf{GZjk4dzM04DN4EDwl@%P!2+3 z{21TkiE92J$jNAymOLZoydd{x_r>|v1?M5+sx`LE(B`*qqsR1O_@RL@Gu&S|t+CAS z$kW6aV1enxrbSTq;+hr23hEIusSo1t1^0&1vWmO|#@QU-8k$D_niLkGZHDaj@TnaY zdmI+ma&{Lp!Jao1=|@W~AyC-fB8liu5ik77xLhd3de_=PW!9O{DIx2^?>GZb$e25- z{cB+w;`VjoWCsH|!*mWoE{-6;;8~_%?q7daMU3Vd<|I9JUy21=PkzwMbTrAP2sv}t zC&rA9X{9OHcP&=yVZtB2FPr@7+UL{Lv(ux|_pA{k7WfSBzm(y&HeNc*6Ald8S3aIB zS@E@PY!<7H(f%zjOO37Km|}SuOqvUM%?5b@LO!Wf6Df<~JnM2jeSRE`JdS=>Q#$ec zk}SmoA~Ztl!QerRTJ?DNV1kh39C-y9!ta0`ghx-+KMdKe|75hR#Rr! zmeSl;l0ppstp%SifJG>aQ(EtdtRBxs0wbL5HXb(u0F~&hm4^mZFX66`_3_F$>Ba23 zg3W83&=+_hXyr8HXeMof*SjuiEhN$M6(%PYIj0gel%i0=BPwstPuesAsfmRAz!$F5@ALbTP494mDL3c*0 zcv__Ldsh_o$H)Ge3ms)|(dYpy>F-ZAT-gIT8?=(vGL+_uq?KD$Qpbu1vTMjQmB`1tCjqyI=<9Y=6K^4+u#T^u;dE z1)*J}I%^i_fQ%BHog(@vDJl0FL{?201Up@u4#vxoK_$msJ6H1ahg34bw1WK@7@qw! zNIW2>tq4=2`Kso2n2A}6rK66QX_uRFhm2)SF|$A~<}eqkxGFksbX|Dftjsc{Y)FwP zG+lRxDREs?K;~7T<{B*En{&0}I0kusFgsR{C(ay2Dd7o&J|;Cq4FGb$x?!wOR~}r4 z6?qk=1vfd%3o^b~1L1D~J6)%#igQpex7#Bt$JyVVM<+5JxmwCj{}9#}3+sq~OZyTk zY`SwG607}`9$dNW1@c|DTr918@S*eY{m97<6e4drKQDT*D;iC&V;iIKvfhFWAZ$=6 z`g(x#DO_%RWXD}hGkgOcXxkV;>l?!?@DpWOp|*M zIx8ZW?;62#W;a;-lEv_gu`i5Pz_r`6-l&LYB&|U*PpVK~0}S&R_X*5m-%&<6V>QkK zUnQLf5*G+bU_w%kpn(@}Nv*}Z)o?1*buPfuSJp%}`LMW!1tR;i-Po){rSo~Ewo4Gu zmJbdNR{T)CujkoH4nUM>mU3d_sA9A}eb~R9ZgoeY1TjYAuo`BB?dscYKoT2tfl7*s zv?N1#QH?f+ll&Bm=*ioP6&yD>_*J@!mbC9`Im9*?Rawo6@kpQ|{;@fdrP@r9J!29A z{B5Z>E%p1h{^ry3gxgmWs@HZ2=3YJZwYA@U*Do(>yX*O)YlQRdr+^TOYd{+IM)>ZA zZn>TP8~b01SzCeE2qZWoY+s(_e~7K)e<@S|yW+UCTdvJ*S;VBnx0*+v|E&yGZ-^Mq zUoMTVT|G*SL#1;tA}MK=K$z)|uXd*VNdX9$SP;MuN39A|a|kln&Rm7PA!tf(2A=oG z9Z*;Ok>01d$vl*oWJQc-bos$Z8ppLw{e0WK)WceP1~|^QCwHVOUB}XfjgD6!R%Nv2 zj{fiqUR!f+CeOe(gZwr!gxw;tCs z5RdnxuNb9odj`O|ZBKMsjO6%%Kl=8z zF}VDPNaDjVIoF}dcRiTm>EPC2tiV=lgtZ{kds{n_pX&WMu%uiQ(e_TOEb{dDm(n;F z^5*QiO?T#nokxR_J!jaL)5!t)sGzc=EVjUatfpfp>y*=tBh^~@Eu|xDq#+a^AQi@> z9qoFy=Nq$Dqw0I$l*7P<^pgskpQo>IxnNJR)dk(Sft!y9Lovh1ytYoiYf64%0a?59 z?!?W%{&Nb_N_5!h{Lz{w;`S=Rr3Tz}DsG(xb_UCjZ$!9x26{E_jAsw(hpKVHE?R-K zTQ+cKG0K1D$k$1z#b)m%+az~IH2oiH!r4(-Ce$j_1$TY+r1ZQg$ep!f37&-!qN&ld zCgN`MkRY3;Z}P)wYMOyVO(naTAi2uhTO0{lO*e5+Jbyjqf#8523F3Wz&an{_*hZuG z%1iFkeR{btagXeNoa1K*^1!WD)0;E&rP9NHu1y@f4Rk8YuU8xnPpcp$%H{kB$ev3# zu%9y1<2hG$LZJ&ZLR{+nDq?dR8QTuqBPAAMMc33H}$#V|9jUg+PM=V!29JzF7DqhE~ z&^@1_ARHKN2D=IMa}%Gr)>mZ z8qdbzyR(otu*S%U3^1hf!Z|2VBv=rPcy?1@5dJ3vXhw~ryTIuGt}dxDPmf&R8;aVa zJ^E65i%+U;p#d1a-tME~?dR@AXIZT36vT|*TEw0ES;~lrs)JPL>dNq&H70jUB}G+y zgOg~Z#8KH2-mXy47Pg?)qIU9lb8U(+ngEkOwnDNE`4f*@6$bNi$8oXz0=|p#0#jXI>(* zAjS|VD7c)EG`_yDVlB--q)Z29G-^qT|>9Jx{a6vB=7=HS1G25De z_L~!nFdGmc$_I%%(flZ?_0j!=_Pr)ZVoz|D>q@Wdqs%vofdHwpFy5zqHK`64kg z%Xuk7eh}NKYus3^{BQTkeg$~4i-?M-NXrTYV@}9~L`5r}I~^=9`0b?X1R}NO6VHx1$!x9Y{utpsXCYm`(OW&-KN7yRa= zW8cL;9FkyOdrOQ?y(*R0NY(D9gSBOTm~8Y9#w-tUl@9*R4AcpZK(%g)Nqcsw^wi2a z=H2WIlKfrG2Lo^V@fYA@3}kEacx;``~5WoZ@< zO0Y7gH2eO%-a~)r4pkwF1?k@u-xOTUWk$mZ^lV_A$(r?zlR2_pw2}~*8SORuim#Or z@{tZOw|cqAsw)X)619KTy@|C0r0Od_6r>0A1?BB82Dg%}tFEc*&fYV5G#qHoPl6Z% z2*0k~ckrBtc2`tIlu?f4|~`kjVP3$Ao| zg5};$h@?BEXUEe21bZUR*!-6Bz(4F?b`PyYOl%WU8WxWb( zXYfVo1=>$_F=4wyvU!;>5^`Z{@wXNZSX*&ylJ}T zDi!4JZp}p%7z?EyrRfT~*_XKVlQ=8aPX0bCn7yrf?aYgpQ&EI*Rj|w9=F!T2er2q{ znw#mleflQ^Q#~-)QS0M8;iQz&{l|o5X;keN@El_3XxicS7V)U#>X~KnGnS{l0nA5V zsL3*s>lZT$tRnA?rW2$?6yknFj%xlaS_!{dy__*=R8JdRy_9^2#Yvb}enLp;-W_b$gWbjUla&6Q3xkH?#|I9YJw#eH?vdm}&Smk+lmP>2Hq@=dV;;&aV!-LEv zaXK7yUY3zgHCTf3t8$%Xu{!$%N1qwOItJe|5hNIqlORLXI{`76{hs66PxCo3D~qE% zBF+g}XDJD`y%8GHAO51G%^&QC3)LUp1D$o!Mb5QBV8LT_)c1%s+{AVFZmTujn`WJp zLg>P;`ODU4kC;`>O?}JP1q>P~Lp@Lc-HcMF@xj)G`x~DkyK)2w6k*|;lW}^W;j1~!xBP`9Li%$K*xF%=v*kofh9Y8R&{%xeEi!cp-AV!Es% zqR$O8Gx1y7Z)-qe&ts236t14y{B>KHM9jZUK3a4*S=aAW`Ka3`g$SzNl@UYa>R53W zPQ8$#E~hN`g% z4lv)rjIjt#`AU_v?x9r^F$%%`J4BgNxQ9|PuBo?Ly9;J}d|Y)Zy-+R0sGdH4o3UNn z&)JI1CgbBO8(dEF9{DvudGoJQU;P|nT1Lmso@8L9-sP|bmC3i z6Dmi=`f-)v+wkKa{yW{{57?)+M`Kd`qVp*o@e&5(sF-@N)SEhn7L%r zXdB@b|0MB1z06G6_=dxuQY_aPz0^z=rUwk;U~PuYbM};#o@j@Tf+^NNde>eIGYC!% z^j~t&CpKx+Kx|&SdWMMM9_an9mxmNJc z`5UUIv1>@IeOYL*F1@2tp*C+cew}+m`vFM~!#W^Z;DS(DU!v`t+nT{C>d^IlAkjhg zNuTsvyg5Q#e&%JhDc6^)1A-EEHWH!Tjr8KSY4?S>iJGL`V{*;TI8=7_o)d3im9Vdq zglCDRC0WY@O1~kR`+Zlw7Ne*4Qk8!d((CYnUt=FmSqo}3Tm~Fyrr28=yK+A12B+5z zbO`CS-w{UaKHaT1D`1t~G}(R9-d%52+hy|HfyM$^bW9hjG0*+0-sm03x>V~v`L*@J zr6H|oq${quaw7*od_OHRGdniQ(;{$0qO8ii=H$kdRry+^%|EIo^fan^bcJN14JtB>7S`eHCrJ*iWt6%ggV8F z=sV7=^MZ@z-I-ag-}gJ~^+vc{OZ8};JUC_$JjIeo-Xx34mG~dD)pC7#um<6yYT*Td zG;`Xff3-#BSFFKWx{~p>k=PTb`j6I=J9{({U%zJRdWCA>T2~XefAx!epv&0OFf8HV z3W-V8CleMd*l|r7Td0Ep8U(Tw6~=TJX87ea6||~#B!4f?6t7E5#OMiTjn-Q(7#cqQ zs#2Ec!htTFj*uy~hsr;iC_8NV$Dg!r)Anjg5Z07;BSX~hvw7^s-t5JDi5fG{9NExe zTc>zTu-m&^TA0ThEdcDF739t)4m* zO`X}Ix8K_0{icN36q9A}BGVYZDd#y^shtzyNyr_{`1sLPKsoYCJU_#nJw(#%1t+A; z#js2=Q}iIHbku*O!>jB=rv6ac>LdW5Gjg>!kGGk@yylaUmT|*NpPvZXD%YtgkEXun zl#uqrE;iSg)ALRyu+a4T83cL*l?D4yW`lU;SEiYG7GL5I*1;VaZ{_mFU3A4jlt$w! zm*pF_&u>5N`jw6={Ng3ii<0ze&MWwf7!ufe@OS%lF>@zM@@-*ZKpAiE*nXW(auBf8 zA3W)Sm-0K6I@~_v4q4CM5s?yr`ihdJ85o2t2I+!uE?C!Z#V8I)puttA#@BlSnVMOS zlQKUzHb_G_DeL0JwW)b187g~@Zo3)f>Cem$%`-IW z3xY<+&bk6jQguj~fbd5)*rSmmhILK+5$U*yipE{d%}O^_@Du`3q}iR{lzIw-?4yWf zptr>h7xhaHC%&2~wwSS|^PMC8(W9VAqW4HG)cM3xD|OOnMu6=8&#_7dj^1?*ud>Q7 zE)HwywrC6wx|;0qJA(!1J4MR2m}c&og$mcn;~?YrTqika22ESeuzuv*x@0pyrR!WE zaYdSq;}4aHtOL{0C6G;;q|w2-P{W4oQtHu(%WC@QAbM;Ez!+5ASY#vcbIqXf$9bNd z4VF%AR9J2FeY6Pzgv)D!=WoSI)#En1Hk~q;I`MoMS6X0Sg;3RqES^WS!8POMOiohO z+Ggb-VQ~YwUX7S-E)xeCCBRfOg3{!diUeUpvgT=tS;8aOVy4n_r;mub+S-Dqjhq!n z!<7K!db8Id`2CdEkp5DwW?}|fb@n(|6L(~Tr_+oWCW#-qXtq{#w6(na(CLTrGUyQu zG$24dh&EFWKy$s#D61YYXi`FNBwxQ)oSwgeaT_7pj31N)zyOl=*xp%L3a>O;0Ds@$ zs`pAW1a47+s!C2rjFOYDvkP;TBZax51-APV`4{RW-5XVFdKlyNv2^Z$#mn83+4`F!)3Iz$R1xV^24TJ&|CAh=%n6Js?AXKay{wt z;Y(!GMsv<2gYbraS?sb_B)b;As6SJ5HoW9q|Zv>+|>LiU1RVB90B(|QE zHh}MJrPd>Ei6D)vS_p{CsNwq`20x9L;JoX*msdK4q!*LB=lk^{>ZDlqBST!&WX{G9 z(>g!HL3GDqq$Qe|K6i%g*wfq~b|xbMcArR**#B-(%-;|aTtTMP0JNujttw#vx2Ia# z+U+AFZ`;)elKp*4twgF{*dC1fj0>FJd;+ceqFbXja~yGSFfQ}n^?bCNwyBG-N5lRh znk1HNb7$YeD0f7gZpIT;Wy$#oFLE7QZ!Zzh;auediDA|+_g;N{ tDWX_810~D{MhUHj$JX({*?R}O!9Rxqjot^6H3_BEi- zjO3*6@d-@a)4qAw=Mdb0H-6I&yprg5R4i30ZBxDyqaZaQo#jocap63D6NJ~UN`7t6 zpW03TM5S{q=JB`Jw089VJCn{AZ69&Ef!@c*A!qPI>1gBG+_DFf<}!g!*+St)nS&kB zo|yCxN#u{w8%_qbYfj5Sk2YGLxCSq6H-Fb2CBL0kUW6AQd5I@Lp|)#}+HWw_$D+yB zs)9>yEAm37qrP@U_zBaE>NUq^5jsyJn&IG;@(nwM391+58ZdE-{K`KTA|b6*FPf(z zGk|aXi%Ab?fm5`c`ZmV?*GZONC|-8#4d@%-+mVRM_!r&tg`ZOE_m;w`49@lV&na#z zfkG$}s~5Nmk*}TK9T%*Yu&RuspJm(qW%kf)An#sSu&I?i#qjt7G`pjR7%kE!C(_<^ zWgiYwir#y%rry_%GU2ukE#-QmE%)=`c@@p%ckv3wWcz5c`+XJhs2!jmr#VuQ4(H6$~Qy?~Yi;*@R%P+?0Nbjbjg7P^}gYah{6$m_5P{Z+-KpqOsE1 zl~kZ2Dj9T}n_}Yb>=o7vL;ba%CT!L;!YZ|PO)17qkvnIRa*Cmu4Cr*Gg-A=cn`c+U>|#ygSM5 zjw`Pk4Q9yswB=_7uOi6qY~qo?OGPxV3emgH(^7wh&Is2Tj-3y|#>LI`R|iN?{?hIw z6`j#yQV?bU0N}41DFp&}Do*0CfcO|vmJo3N9*Ncgdj20DgSEVJg!p1Mi_m}Gofua27Co#P41&7Jcp1-9(&@;G)FK+Q9mviLh~ z`v|FN*8y_Y^JMo87^9M*^v_i^E?&LDo09kOld8s)K;}z+Bb|2u6ErOs+36o zGv>4AV4$?<8TxAObajPBNf!`;s~iD{7k_$Vzy(MqzFrwP`$Pe-Ls|=S%_m*qzGAdg zNph4l$N#@97PO#}hj^Quk^xBAb}8xpl+g?aWFr1KzCI{_#CghTL~6SsI0yi6%4DQJ zEK7R>>LmlT+!y8&ayEFSZoC48IMR>-ELerP9_O*jRy_p(9>oGwa;pMK|3F2Igddew zTcoybcpb6mvum{{U2|?U|4*Uj1U6)GHg>B4x&Hc2^|1 zbVBq)?0l(U-xavcmJP{VD=rnG?kWO8B*iFyUCq;{H@r^oCHRBC4b}LeM0Zd#v1uiM z1qiCT;4KqIpOJ`ZB%mU6Rd3Tah#LPayvo$p>U2naAf~qXA?O zT!|MhGLXcuFpV&JH52fB&UNE9cy$0^%KD}TwEz^|e6e7)=hW~Gn;a#z)#IwE^z49)z4#&^8U2-w>hP5$tdEa7r~CMG5qkw>E>YdY~bbQtp(2GYc# z%TY&WUPxKuW|aPxrdNXvd7HqJ{mB8S>gjAw=L5qgLjZuERN?9!$4GCK!ANg0CCt_J z|E|jadx}qbn?0U*wB_1xt>q&`F;J$*7!YD0t)M`ouC5LeQA3Qivneb^co*ka_JnSI zpIM~M;KRGesxHma->2j9>sCczApbLw zRdeBeHQ}xT0tVgw5f~2Gi^Y?;7YCn{Ne_AEI z3>a`5G0uBxH8nozb@JS=)at(7nVoq4*!jBIQoVm=Ulvp;Q5f9)HGlrx?`-aHZqQ3| z6aCOca;pcMHx0e2&F%~6>H8&BtE|RhDdj>xY|wUX-E7;)H(e_>zcPXXRUs^%F{}Ct z<5|I2kd}`77KCtvS!jmzwFqO>mi%);QnL+T; z1{knHv!!ZIaI(WH30c^xpeO@wP(+{8xa=bF)O7eXpi1uz_0nW0JYhio=#xs)LE|iM z6MSnT#qL(O?dhLIiwd1#BQ41_UF0}??+4w|tEw=eX}jM%Px5iI_lyBO0ZiO$9b~S4 z%bgJE&`0FubNMfKvVI+7$=4l3QsJZZ+`lHQQ|Wbj8N=d>P8LK2hhAO%T9-eRW?yHF z+Vj>lQ)?Q zt}Pu#%eRR1TJH@9E0c;o_IXyCcp!H+9BE{oULAk-&NXk^0o=aM(vo)#ST4$Koneqv zKe{`v_;+1JsEOzy*Pl^Zjh_8=J`u^lGs&6;)8PicMrgpG zv|rNXg^9B+{uK6M-G(W}B)<>c#z)5!_zQHM1CWi7+1nof!CTYyxCyP<7b?Q>oUw#X zr?|um+C)ueL%}c`+kaTK8iiOBc~l#q{7$!u1PBchoYpH=ut#qK7Rro&vl45>l$=0! z9D^Rupo=E#cX-oo0tpdu4QeD^FJI!e1}Wb^Xqvn=Rq)1D!1q}j>dz%(Cj+t5!N=g3 z@AcmIK3XRnl|Dd>JhA`XA~s!jo(G}^HcXw6_D%}t1yqx@#kbDhIcd zs~;2z!5HMDD5~-sjG9}mTvJKBgWckqJ8QK?f2-X;wNzT6OPUv3vql&4Yxg()M?%ne1a->=9)E&FK zR5bJvBdHKf@nfKl1$IKuaKmY%!0T9^{RZiciBIzHuCXX7^S`?L>_=Im53Q7uP=yDF z;@buA@x#knm*oC}5m)&zA!!H>*JVSc)8iW2wX4!*5P4b-QYgA~QTy_)e6;4a?jm4h z`X2|Br>lFgm8S8P9c!nH&_%u`$;ZS}$g5-ov7IyO(Zf|d)KT9xTZ(n&TRz9?dNXC3|JDF?z#$_fGUYzy2jZaXYfzZ@+7~Gk_$>>g1#xHjHCHw)1!{n9*?N1n*Ouwz#?eXPFdA}L3 zuaJ~33zQPrz`l!&3<9ZJYhUg%&g26JG~+tY+8eQ%b!QKV;m+@*Lvny!Y~TTI3`jR+ zvPI^asejoGa@fK;z{*HJ?HapurPa#p^2)2TYTcnin>h}ZB;5&%(Y!oS3V0VePxNXo z`AdHjN$=##+nODL*(~@V&Hcc=b~tLpfb_$sQM~jAvk`Sa8(xyuW|YPo|Nc4?@ls-T z&cFSEC(hUJ#E=F9n7mrZIJ4qb0sMD8?f=1MmH&bMnE!vu|Fiu_|5NfNVF9VjDfjAS z1J+{Siq=&CdxiW^q>`;M0$l-^x^zNgSG^l%mye}Ap>b_*$7zhE1j*GIWx3BG%i-~n z=C?F<`{YgkrCfT8rs-LceSNQBlb*4THBcXs0lf0HzTkM)td$l8OBE^CEQCXMoKSS>O(2Uae zYkE5B7qH!>R($A%-`R3T0Y&uABe+@HA@KAircf4`FMQah;dq<9%lqEFJGX6QaYJ6o}~T?-}6&!cZjz|%_Y34@L^z)qR6wGUs%B2=2pcqKxkuihK>{I0gugXza~tm9sE+;fHDx7N z*;pz3uJFD2Ql3s3QPJv%7TQawV+rktg|mqT-V``1{Dcx$zMs6ZuxH!ZZ#>TU5qH@| zCqebYu(Qm7KNNM!<$-=6xX42>_Rh!XGd+O$I*^Z#Z}u0fBBg|J=Qe!zIF9n}Prk)C z<-;%T_ksOC7}|AC&-#Uohy6)#`RLDv0Ijs^t724`M3)|)xcrmnE3azXY}S4rL< zP_d$fO-suqMseoP_FI9zC%06zT<&75O6l$RNQ2RuB{SesD6JZOcmn&Wxp!ovT&$D$ z13n&-uHxTeR1iCmu3mxxy8in3JEzJCHBZ;t7tC*lE0gK~vJi?bf3LA7?*pT{AB4Ct zXb-)|fl;G~89Y0PWHY5LP<*I6&?lUV6~WQZPDd41FU-#E|5SNsHz-;(^nbbvh?HH^ zuK`ujJBbJ0RkkX3vw&zkXH=e<@HC=4MXACt(nRxvb_RS2T^TzYXE%U_AwV)tB8D?KsfAfh;15f+9B*dp47ePzf z!iUG=UH8&%`^Le{2CDQ=gFWxYkqSLHQSUp(zdI0Ax+~wKK6k9eVoKQOIO?@ou&(TJ}QCr4TO>}SY&D&}dU#L0aVx?B-LZCLalbiqkNeAw21k9fF z^c=rneP}DMt@@MN=#s%n(=XIqV2zH7tD#eUs`=M|N9~wqZ@zv1rfoDVGi)d`*u*+= z%4aKV&D~}cp{jaMw+vS)IT8oYtxYJ2iYo>(((P%?ft5+R-KGr>6A{TO`8?zGzDRJ z3(pD8%OlW8h(2d1PWOqH@r{1RD)u-%V~Cb!iHS)KQ&izNE~KqUxZfxnp#M4&4eXz> zPGyt3Th2qOeE%E&_)Ur^g|g|qbnDHw+IMrHrD2~0;_HlC51O53q(nAwMYZKSR< z7EZ-LW*1!jlL}|{mQ3)W?U(?$mMQZu%ME@%!THxA8<%<$;`!r8u#||bw4K&x2rB#v zaJoTCZ1Y|O)Mv&o--yt7SKT5#BZyJ);#BQ;IhU?&W2y$$i&+V4@Y#xBf|)ar`aG6C z_jX>#2>DT<0ORi%g#gm!Eal@Y)H=>*pLN$b!E&@HbsP!9-D`u0iya}mD5%mkAmnt% zVrfSuoYWZ;yM49=fmkQ)Pu#do(Ty!OoITwYZ&XyG8v-{vSa|K%Lej4nD>cDV%Pr)p zNB~xylyq@?6aeKM%vf1nUze9x2%4l5R&)7M%FAu~#QNXtLSNwsR4)6Rs6Qm^zdCWD>tJ?2!ygY`1mu#r?Pm{7`ORWY*;>S zr=U{uMaJHMs7Kue+WmDW_0&(2d8B~yhamn&!d&)s2f z9T|I8wFNn9P%Bt|Z!E1SbA3zE|FL+kK70K6cI(;paXXYsm?M<&>&y7Mz3~j5UooQ3 zn5oK?0uF^t7yZP9U1cJ!Oazfoe7%lT5rr_lD|{V0iHaH}9IBXC>6mtWoLgE_6YL&H zlTtTP*(5coh>#R>zcOF#JE^Gp9Pf&&=iqEUJABsHv$A3jXP(_o7Yn*MPGKByQ{(sb z4&U1owEtPB>7(*HjL^F8f`V4cr?Ud|f#-y!&KP|umuY6~={csE(FIp~D^m%=Vh(N= z5jcmV=NAvw?#$lPY9+3dS_iz!x}x_h)gkl&cQABLDI|j(`Aht}9BqGGrH*j%gl(@2 zsjZp6-cs{U{#u5VjVnLpH#wh~8(B!-nTdYGdlZ`(_I}!uAt57Da;vxV_yk!3X%uJg zaNAj)ZFhS-o&%2}9w80FQdf5{I>tU7{f6b2B4Lj=BExsQeuEDrnwK)h)n95+83#~` zm3hvKnyWmB)E(3EljXHN+l4LK#b{nwAU_LYep4DM0Zx)I4iab92tGPLbF+FW{e@y; zK4gzc)cjIe;`*}>*7qNqny14|%L>;Z-$R*9X8&)HaxyqbyC|8WL8+tKvE}0{i({^D zR}44jCt^`hyeMT3>7?<(c_XphON$$z+1!gg$aBhkRO{l_*$6OvNRjYM`njpZKT>n^ z>`YUD+QTopr_VELHD)cY9#ogf4Yde6n|GlXg+|Hr zkw3ijr(wT014TDMEj_)4y*M+RPVt0Gz7_(h1y3)YpHY!u*JkH6RV;~V9Vh$$x>21+%gN(l4dOtF)tf}fAWZ$ZoOy@WT8+KwZ^{P z2~aZKZzEu_&yI?70`yF~-O3+ZP9GBbD$oBlhi=2ipU{GoPB7F}p`^2>dg!gT>J_Jw zUvLP6KYGWm{_TK?cl{`-SCtR;dX$Y0Pd$q+uCz4O;EyAIHmj-7%163N8m$K!rAIJw zvX`8`-SEHalp;bp`~qBgS;pPs(vxDltdL$Cy=x?oZ*-0w(Fa>cr?1L*fIDn zq;qX@#PMSgiSV|3WO2P(+t_&152gefbCd6m)1QX*%6&g5N?{^33>;8QDqm8b$G23> zvzS78=W4%b(!9hcu4eD$oQef@tQFELW-E}cL3Tmok!^HQSiI#|Qo=R<{N?()U(*X- zfQ|c?bFjKHd`=?tS;AZ3$??e%@n2mGZH}dtvL3?5>Fk&;^?PEU-ostL&~>F{e>G&U zcw07ZmwkyDq*WwDAQECE}*-?NU;=P(}!Bl{*aw$`TYnh#T{Z8@*W)*mzKz$_3}G+d7Pa0x zY^d)SRZ&C?qRJl{$VD35A+hCKd-Xfev}Dt+5}SX_sd=+$9F&d)m@ zJ9kU*!hO6V}YPWGya8uEx{iw$H<4|0z;ql@OKJYyT2Y7I`VD zZ}hSu%dcE0NU5wS(un`9q#bK- literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/01_user_protocols_top.png b/pylabrobot/btx/test_data/gemini_x2/screens/01_user_protocols_top.png new file mode 100644 index 0000000000000000000000000000000000000000..194e265a28cae001b33027f365611e36889e8c1d GIT binary patch literal 36637 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 bNo2kc*DdZ%f;H8Ffl+9x>8O@JwhH@SF^>)! literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/04_set_plate_columns_open.png b/pylabrobot/btx/test_data/gemini_x2/screens/04_set_plate_columns_open.png new file mode 100644 index 0000000000000000000000000000000000000000..86dc18de237b714665891c808f3f432eda3e7b79 GIT binary patch literal 23678 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 RR{8T7SFP==YAihC{~wxHJSG4D literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/06_set_plate_columns_confirmed_run_view.png b/pylabrobot/btx/test_data/gemini_x2/screens/06_set_plate_columns_confirmed_run_view.png new file mode 100644 index 0000000000000000000000000000000000000000..5f5385882999df8d78842f3bf6916f688cd1169c GIT binary patch literal 27541 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 literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/07_go_prerun.png b/pylabrobot/btx/test_data/gemini_x2/screens/07_go_prerun.png new file mode 100644 index 0000000000000000000000000000000000000000..01553f0f7cad15e5b01bf0d9a67c00ca37af324f GIT binary patch literal 27554 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 literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/09_go_pulses_delivered.png b/pylabrobot/btx/test_data/gemini_x2/screens/09_go_pulses_delivered.png new file mode 100644 index 0000000000000000000000000000000000000000..0d583fb6b849c8bb69d2ce1d32dec6942df5cae1 GIT binary patch literal 26014 zcmd3NXH=6x*KO!1AXw-kC{21V(iNrm-U291q=^uE0)hfcZ_=dq-dpG*9YJa+61qS_ zhY%nHZtz{-TK9f;efRhM1@k;JlQZ+ooW0MPJzsRRlqqgA+y(#u6sjsO^#A|@761Tm znUom!1W0lV1pwIDslI$};PZWV(JGQ{4!Ctb*(el8o?X82y6k6WL{aPchjI4}BU*C&0yU%?lq)p65Bc#5mbF?z2PkgICyEc8UD(wAQu!+}- z!873V)P>!4baQXW=A~azbF2~BOL4D)aIU`0jEt1$yt*FT@2@N=9SOhB`J}XTOaQVu zRac@ryIq73_ylb}AC2~5Z2yjofcnRW@*##-=&;Ot` ze$b8LrXfH5mpuY8U1nY-Ktl#X?=6mJIwfoxpGr!&!6Q55WMvJ}`%3}=J5I35l8}&) zKQ^3;Xd(D<2ARS{3URBipZrhawy9JWLO{^#c%@QNuLS&ElD68?-Z>}BM*pGp&>kHfokAgDCjomi}ce9+thtf&n0jh`d@h+m=0u(7@H|mSlqu&>``K@<*wqdmj3p z9pt#4sD(^(P#8H*jc$5uS{LlE4|WW$^D;bCG~1B8$MXIA_m_Biwt5z|+Ey16$>MuX zGjdICOEac?B}GgJGMJsZ3(H~m-Uxw?;srr37Lk|C*Ju6H_qAnmz=_t%zsMqHV(?&C@e-hUf}C?cfIh1z^6rBSXUr zhK#I>M9;C7o>zO1Z(V87@;~l=DWgyizBe8sfH5CezX*cLl67ymTEE7eD?uC!s}nW zlWK_GW-$?l7iB@D+;yOy3Go`A-PitVg3wy1t_jyNHX>0)_qYQ=Nr7xeJKFNXR;AwI zk)f}m;5(I@$@RedsLBuD>%r+V8~}jfV1ipK*>u0$X-ywP0xT13#AI^4HwO%;wSN=u zs&=SU2Q)Hz_II#jctn@6PT%gK$hMCcxb#u~XVLiG54JKYGVc?m=DPclRh^dV2d|08 z(ltI# z?mUF^Yr|-Lah12oKLEf0EB1oI(Ih!_UMzwTAkcoIhmgGc42~4e(|ge~o5}ZXf0Su) z`5Q54BHLS}@`q^Gn)cOh=&^$pSPbps=T$l@F3@=r@9L>;V;;?ps&*(WMM_rY--&OJ zM?PWJE8Kp^zO-~PRg~*u*Q#y0q_}NbC5PSCMyfx?8-R6Qflyzx1KxO(Fj0X>m>r)h$SB0cFsj*!|6E(6i)TPh416oPJUt7Syu|_!SffCloVP#& z17-KvQHy;D;U*>uKuQkLmB;dNJZ9(01^m zqCZoEV;mNLNFRdkFI>US!#WD(uNOM8>3&O?;MnC5=F8<~nkNt6Br`I=0RZy!#l>|k z%|(xR=(WnsG8~I}ZDT>KxAfadE5%i2A{bo5cabFGqI*7jA0l$_MOq}yN`;pX>;BZRf^VGg^cG@|EWu{P>D zjwH(b`be7B_6j21nu{NutS&Fdt^*wU_ohYLaIOth%Qy*&#`=sSIM_{Zr5X;O_A$C4 zV%!4O1oEWXP9`D{)5ccXd?H&H^>a}Jwn96urpP^$h^Sqyu~G3_B9JY!hJxJyT2EV~ zEam%xvsbllGIUTZVfxoEvFb5R;tUwr`PRcIAwH#9&I-PlCjGPcIEZldz1VK{#dj+_ z(L6p~a8tHYXPxJ^53!Y#V?y7NQY^KA6UIPq2}S@d zILy#te%46%JoFCf*N2?DtRaN(OD`alRJ|r7@OwVy&kQnVHxu)g{Z=;Vo-)c1y zVHttouqxD{PS;8PV-w@5YGW-w`+UCx8G7W`yN0hF9lmR!eyojWZ-5M`s=N@F^4IL~ zc5|f5Zx)dgWJhG6vN{pXcsz!$ftUS(QxOzjmo9%T?O+9iN1@h9so1v~srQpjvk@lu z^M>4qMh&KCTJQkN6FTD9^CmlG0$N&RrL4a{$rpl!f^P0L0SjW0JQg<*k-MES!l!GO zmog#*8w`g)|5LLmaK#=MIQ?`zL0hRi>~WpthMi(Q#i@rp+5;hvExOK!po{|zv2$72 zR0bd|Z%;vY>VvnDTxZ3Y0AN$ajb}JMU25>Z1=ymMW@XWCCSY$x3r9(bM{s4Fc(Dtq2nt=jjcZTpk`LbaSivll-E|Buq$MVMVXCd;%N}YF9jPgXU z;3=)!DIPrjqpysG1w6jjV!q9}IX~wBWRoFhiZt}oMg8@L{%Y-j9-oXD68M?PvDJml zDcQfMY@nY!`q3{}7#$s*`|7rp|1LGkbKbL!3vG;_d}c6|UKh*0J3E%W-ULB5dFq_< zbRO|AigflGE75iykacEvob?JQEjH$>zfSK~X2ny93-ti*w}^iN8Zvo||Ao9lGyQ0Z zdbUgm5Pd8g{F^?enu3SIP?mZRxvjrKL!q#9$Wjd3T|nZU2oo5|{BDI{L#3YGvhRyG z9n3HL<|OEY`6VHNuP2*SJDGhP8FwUW{#J006SB%FPFyye8;yhJQp5|SjRJ1_mU`?T z2vG1TUYx2oWpeL@Ia#NKx=kNd?;h7Ajmn=6YP-6y0xNBqs1${P!pFumrYeW)SJ;Y% zm$}P%2Xyg%h1V55R@iB)R|LNkE>E+i_rGp5Vz>~fz`5wZXP*4AIePTAI8YbWz8 z`mHN!!J;^Vs5Fo);REnft?n=1SQ$40(4XN`jCQ^4gKGi-5A9tYjdZP&YQf#xKSPEm;4 zJUIk_ppOS?Zu}AGxkcBL$)j`$RHX7m!Mhd<*PS$2gBnAxwk*nEYRQtJLpXC8-i{eU zC+mjz%E^<qvJB(DS{k8T;;j?oTSz29y=opHk%Bg=Zz zYfD7cHn^H)drPtT?ZuRx2f==tnayEkx$3NEe>Dpi`MeVXz}UvZ9?*z^D%F$cq4bIT z^!zPLN&)!zEe?M>HojFjz@>QTj6EeHW^ky5dK(oZf3+q*^E`Z*E>3)$hz!R;Q*5m0 z`X4DwFgfinE5wk+xtf}4H*Ux}5-!-NtnRBDDfUqfcsWiU4k4e@R^N^=jLa+wd4@@A zKd8}`vJ#Qidg<1AN7AwdrFMUs_dN#MK4x`&0h^AwK8ryDO5ON1izfSl#yDSWZLYOe z@wYL9zW=d48tUERSS&0nYg?-I=oIZhTzXmRX%35sAZwp!DffYscy{Aj$gY7Vw#1z@ z>LJUIi5OlXx4eB{n>n9s@(0ZB&Qcxr$Y1u93fzPQL5~joW=PRqBH3GNth>k23|I&n zbv~GNsk%r#oOw%~hS%ADrCSo83IOnD^z85fdmx?K{=5QyYKh6|yt)?4rB-qu*wR zw^Rmo#LXA;EEebvlgQ4_i(<*!IW)hm^}P?czB_wF7dKV&7-B;oD+(lG`8P1>nT^ub z=WW1SqKGLyYrPh}{g_hqncm*s8K*#;K^2fg+CW{pVcpLLgwIqOGfgnSm%8O=*iZWsM9K1km_(j+6V@$TqVVA z;4adT81X(&Dg$zH6Rzn|w6chz5sdEB9RNUSc4Nrx?JHC!5mP~F0_X=jLnmLf^qAb) z&-NDueK`_>)_>GXmC+G2;!)(dxQkBnU}dRo!+>%>O8eEW>NNsXU>~NIA!`7~E?~)J zINDP;VT+~b#Pxvzzo6dUYt&D5bXHht7jtamIv7}maa%nbNYPk;Et6O*Wx)$~T=;b- zDG(KUw8vG@h#wnD5c8Or29#xsUOTO#~EjYR+p(PwmBxuey2ZoR$TWr2O;S z5}KNt5|ljXG|n(#YTMwy-To_+{`)H#QNT+|uv*E+6QBLjG9)YutXdN0jnWUa8cJd2 z0r>^;kS#M?>LZpFxZD^X+W3A;;rd-jGL$v^jBqm_$eVZ(7PgH^SsOT=JP254;H4Sz z_mS{jaFT%SYZpCd!WJAoDsO^SX%?yNGL;WUID~K@KYbS13|!mTGDEna=wcm0q)e;q z;H|x>Vx#?cUKkB^UJar!!s1(7rFzGC%ky$=MQ!)DHCHxY{p!nt2tINFxCd@r1SgjDd^zw;^&k5n7NI0#2?Y9bwQn)Avmdmtwl%x z1Yutv)fB71PWs@oNG|`qrcsFcRS2-%B6z$7qXN$p@&F%n84}wDL778GPxBh8w66;SC%$B&R_b@UzAAn-q#j~5MQ=TNs~SVwX;hKSHem6 z&&i}r)Mh+mm!mjHAK$Dmg4Dy((JuQW#!tLf0eqxvY-^9TVH>xg5)=$S>V}~ok*ZYp zW`4;-b1yfo#wlFe$L17erS)GjG`S!Bl!Y&gn?9Ia{>FI}p}&zq#OE9cVfQf;*dNsQ zP545}I6AR)iawn_nWn5_tSDUctI>gnNMAIM%f&~f0F8!|E%o7L%=+-7H(&}jB+Fdb z86*rAyrv@iZTOdS_(LbiLt8%2nZG%DoX9N&m??h7Y{NJxd6{ph(pkJ26#KXim?~v! zqJ|dN-}m?Sw11lim$1DTTp;FQbmn1=;6sn?6cLnA5}_~WH8{xblG3zEws9q7=U@ z)`%kNCwL$NcI**GE&e_PFWTT4VFbNSFG_Jw1zF(v0HRAZoB)>lz zPHL}O$44Xe_HgsVSRHrdIUoLh>kc`!iozTd!4)QsbLf*r=!w@aX zh_d`7&-!6M7?W(ZKRKIEWSLTMTUcptZOrL{=wNE=pHq>2el-Pd~%{z7AP94$d?X4wsP{J-?9EPg0!? zlDiZ9g`o0RYHHuKSHLD8c(u*(> zaDHz_arknxd(v-T^r6n~E>RYE@~KAZk#Q%JlccMyeEzs=J2R#2h`a4~r3Wf0YoBan zbEVb?TLk|yyzKtcp#4DSfyufyWoDo_LuYP(Sjyo;;aMPlm@4nnFCL~M?4{^AFXBF1 zBMU?ZHPQL4=i$EK))y2+WN_;cs(+B)D zZLT`mX$j;sfw970aW-YDE^stBZv+I$QY~ul%B{P2wjb>XF`C*+q~4RbI(ktE_~z>5 zAxq)1dMi~!2hsIj`Xbg{7*=ukIIE%2oC_2HJeRPV`{TBD+6>w-gJA^eyc5{Un}&l< z*F$XE;09EyQ4Ts%H-uSX%-~nR)Od^oeE>AzEs=0d%v;{zre~om7ZL1~49Hd6_J^kY zA^b1x`Jz6#%m8CYmXV1sc8gBy@^*y;Uegw$nqz0(ZDXM$XANdt`+p+SRh|j3?s!p0 z^;GvIuJ5%Tn)OjC>b3J-ZItP@PtU0ivWSH=DTX{#dvfE+WQQPA)B&W)uHsx_33KuJ zAGvK5MlR@2S$4LzF&C;}(O68$W=}6#Be^&-A@1Y2UlBfNa*ot=Y}J02eORLoN#Ydp zNkn10=z8Ln6Kl>JhRGSZv5sa-0maeBJ2M4E#YrDdPU^b@$ZSh%;nK2CxJX#iy$X}NuOY@mHu-r?E?4TjBdz12rZ^bB z3rm{MB0*~WX)B;bOxlR$f;qZ98-JLE*__j-27470R&~VczJ6v&r7<8{<5zKe4!v>R zY`OL#m@MISED@HC=QVM9y3A;=7Al>|_P0WcU`<;lA zr#)Ztv*-uPDk(_3v3vLl_*ac)So&5Sp0J`}b4v$Nat~>(f~dRWxsLpVNI$+~tci{Z?xkd{Jy_aaSXdki(DwCq z<+2iHyXU#xV7gNhcVDB8g)Wgro92-yu=hlk6v>AdDQj+usPDYh79B$6rcwOLZ)*dHt?$-ytvt3JD^bcIKrm~~719=wG zcH`lb(;`*cjblO(-qyWS$dwuiH*R`)%YBf^5?VG)%WO=;2rp^_XMbie#fWEvQF|_W z2iSwIW4JWeNB1?xKwV8YJIC4iA(Z#>Mn28e7?~%Km3sqwwPaTu1k@4R7jqcud6zI@ zmO5X-x3>TQQRIlm`FxAq$usTDb~WF!#Eag>CdMrDIxbVbzh@>fXI@5))*f|dHt*_O z$|LleJNi%kPY>T9O@7AI)VLfpFh`+OiqDOf>)XdJOzv-N_cbK-%}N!imb)Ihn%KV& zHT?8!-zW7DNe^}eYPYr~n_}1?a^pzVLz^G%Q#@0gc0bt8gf?l&bXH-dKT`7i$T`LI zqyUc(ZaDJaCHNKL6QG?u#|GTP?4jV};_%+P<_nx)X18!oS63qDFWS?S=ejoXHd*;8 z-9w&R!oo;e4&K}@wpIw-C@8UhoNdO$yZL%$HhCSH>KQzPLf@Y;`Xa7k7Q>#yB27A& zc=yv3Ej#8_{Fv5h?W#lFx3KRDugnXGUu`RYnSR2RchBYT{8vhnCh4gAjzXk!1wt%@ z%(xg+QR2DE+#v&n_-Z=2+|iQ8Z29Vg%ADOffAzvtTk_94JOtZd(~$$Vk$0lAN&Jlr z{$SXe_3G(bU$?vRR91`jeM?R*_3;Gqn;svElT>S zL5>nW<+h8#)~ss*v24;0r5caZJR_u%yH2t=!QEt*pDoqIAyi8>f7*Z-%t3+_0=Nj^ zElt6jgYkr}9yb}fgCAXmyV*8%cT}H$qa99c79m&w;@@@B`#93{u=T|@9+H~j{1LF` zy9kS|JP!Vfyy{pi?%7!@y2E@f#05 zd5%*L8%w9-J!=Wn4wRGXfF6SH)oIRm`1Zf&Ybrl;j~~)3i@-Tcl;8rSDX0WOWhrwBy=vF{}$+tDG1r&g*WCqv0~xQKBl2Fs)Euc%+hW z8k&?kFkASZgUwC{nrs-*{e0Uz9UZ8H@i(AcC%OmxmTsVw^Z__rhH195WvVK}{l+Xi z6AAMQ{w5@Kxksadk#CRoSA%(Md(}wagKM2ZW=$1oqc*KWDO#F6hf3he8;)_=V|_Ge zn|N#bu3ACzw=z3wr`2{+ZAEK5xHjN~?@^|$hu_LZ&3JX|Yu*_=12k}mr_ z4Z;I>mLKkfsUPH|-I5zQy4!o_0Z-|>zHUZW49E#jp+EA4Yg5aU)Hu|;J&uwbb@#ys z&TTufn(xg*1YfgO4f3jVf->7l{C3nnPUsNOhZqSi$A2CuUDBx{16X&tqzli*5C_NXhC0TTE6=$q z^-?x8xRqH%rytVEZOfF|s;on$f8{oehHmBkyvL2QeX&D5i5v=kAezlP@RlH!zmM`~ zjA;WV7Mbk~vuU2GQqj@hbWdnxm&6N_E3T2&+*SBYDi>HOM>9tYTb_wz}Rx9H8DK8{{wFg?{bZ z8nrYf>JMihx^B)daBOe;$1NA^N5Kq%NvC8qH6Lc-F;~a}*L3gfwrtiM{yQMycN z00W$3Xy2b|qF3QSYG!@Q28ajfwP^PAB z(28-RkPa0rRMOQLMGyphd4QLV?4*n$Vwq^(>$!i-O|ekkz;{GLFoGOS1i7T$&OSmo z?4@Gk43-Kj)sw_t;!sbJd>?u26UZ0gzXKzv>w;V;DCE-%?Yp3mPm6bS`3Aosv@RS1Y)UG%~rUG1WeDbwJ5$EWF zrG>@&&v^Os3k&+1j38oM+6kc0dGdxSR=mZtKlkQT*(sSHIN$s*hFN}ek;BQ{A9IG` z@8_-sruVh5k`pc&b;j;|i6ovAUSCV;^V8m@BLVBvMkLUw_Sc&pwj}y=sPeBoJhjd=X zC>_)R>XmGk& zwC67ElH57`FLQa%uHrmSVpu1sFI_!30h)P6BWncrZ7@aGaJ4pSz#)cJ{y=${2`d3E z!}`Ha48HTR#dLw1!g95Lpez9iIFX8;wq5kroEg)ekp(S|85y60k7i3Zbs*9IQmsQF z77Gu_rPpmJK)>Hl4p}A_2FkTq5&R1J{-?7EH9vl6C}#in``V_XRYX0y4}x2{J!|s{ zqYIT=&T=-AMobI)Uu$74+gW4cd;4qn7*8x98%-aZzs!mR;np%>ZN>y}FL2&XE*{Rz z=#g2usd9Rwi)hU~6k<8#f7J@_eG3~4B$vZBT$jqpHcg}*yOp>F?3yDS3(6#e<^9b|uCd8*-A?Zd z>;)$4yx>~9qzOH}RC+ZUi;JPE^+SFG8K9~ZC*p`zDXm_VOqxBchfwDSi8LE zc6}L^cwyC90r^V_uevg7&%46vt6{UQhcWt1=*|8pE6e>8$XY+nsx1)UjRVb5CX}%z5U8Im!hkU&^f42}y&1 zz8T9Wg16h+chJ~~5pa>W<;n~$is*hTN)Z1*!xqF?YgI>(Qrpi|EA+i51-x`9AQ zHI4m_oVL2KhDY$Ftdfl=^M-G!J`Xo=2c}y4n=WM8%#~K1m99%2iy$$;$;p0CHbHEC z==-D*rPMXFYQRn()fiqMWohg6!F8#;&rzpwmAz*t1GFvZ2PA8mfG*S@y;suS{=G8m zv+rliN(1{GO^yvp`4WTk2hn!o?pq!2AzIU21Qmu!!p3uM($v6}GYEm*-aM~~W|@NI&&Muy6&a6}RoG9yU?o2%HGH_WQK?6UwD^c?}Rv)bY*Y^r{mCwzVWF9Y68_ zByjBmF*~=^n!67R>J^I+a(wC}`sqYvE{J`DV)7L2QA_3ZtgyIZVYw=%_Umn}j`9xY z7BI7{TS4Of#?<1lT#=#LbbF!%NGKB{cDkc^dq-l%w0Z{(Y>FylmE=lj*?QuyV=PfF zmvJAEJvPCBdA3j#V9vj#QmQ!b&Jq1FI9V^sCzO-NLxd}p{R4&g5Fu@XncsKn#&IP} zYU!B#qH}YKohXSPSegDJOu}~>2wk=lRo2g7S{4Wy_PZ)3bQ!5FsF2H>uw=pNP5gwzGxQ z+1qUXv?+&Ll%11!v}qwe2qdjew#Pw%eaO~sa=5A;8avHkLR>LnDNU`a(ND=a9*CL^LQZ7PiXVIuO(AlZ*`WbqBX8aF>(y7BM1mCPs&K!df^uDU zG3pZB_W3@j5FAsH!}6;C)0C{7qJ3FBmxq(IN?j*q*`w*A*R~2c^ttvS;A->K1(S6_ z|Du+K#eKA!7kdVSa2qw+xxz8FAuhQt%lEdc?2j1v-Nk|MSss)0>0cGQd9RjNo!B&f z^senlebR3KZlXBtvdWPgdR^(5;{PB6#hs$FSxnBEyPc?(jx-;h&7GGeK z?_EmLYt?2~Re|y&MAFH{P{mHZ;bhcEWPj=WYE-nF_h$f3_r>%9g)jtd7VUciDXgpg z<_oKO>#omDLHm}n5!MblWH=ro{b`v%0T#%7gQ5UHeJHLOZa_}|L($RaW1(10?RLs0 zVCPE$Ca~qk?~`yR8QWbyw#Yj>-)N74_+GZg=r6UNv?g;WnR;C}CgI$4R!&CUIHAerd4tCf3y2;&nkJn2|3%giiF}ZATpYm(SfH+l=*h-1|MEMfD46$lf7aBp z#ylL(zmF~7tzBoz+w#JF@^xT;IeHx>j7ff0R1QvP{+8^?KTAQ#qCjv5vLg&@;4*fr z|KI{_HS1;UYW?$SSPtFhE?`%cJ}l&Q{^$f~#wr4D=ji~#F^&t=CF(}0b}_FdDkn!D z^Y{!%SteaTGyNF{Xm&a9sjRE7(l1V69R*icAs7VDS5rmA8~GY<@C#;Uo;MOfyGL&y zv|2UQyG-nv!o{Cfed%+wtd6VK)Ki>if9ejt$f^&FgHGk_w9w8iq5jlOf%XWQTXBbz zbj8=(ffxaV{3WGYNhh#0=9*c)5OPY{(TU`aQkuB$6&&um_c6k!E9~6_Lmo(+W|!DK z=|kB!oBcYc#UQWqKjX4E+p;^3808DEnCN4bT1JC=_0j7!k9@m>kRXpaegX5(@6rP1 zvy3{NLYjw6h>Z;yH*q--UmLs9M^)R_xs^gJv%nGD$tukx_0wo2mj)#4r73>`e)c7= z)~PZO@$S9E^m~%ucZ6BGvT?YzXu$=V2g!OdcB^7xd|Y{Pv~>4;$U~6LQEgpCJ7+P% z2+|*`i{ER9%Kh33MW}2gb*Slalh*lHVk zPgmewmzRzO<$U@=^imQ3G0-^zPI&;OA|TxU0e4FJGQ@y4J2_u_xF zx?N}g4l@3y?kjw)7)gBpw!|RDtguJ4JTCgS^1khFO@ZOC&XERg|6RcPwJU>ar`4g$ zS7+(MC1aRJnZGokORymgPZiTIwTptrOiGx3RE%??rhEyQI&R%QlAe3z3tshe1$7bw z=qioysbEFMG8?OAc)&Ww)+33*fS*fsa|?D@reXiU9`;Qfhx%MWmINB?B7MNEQ$*SHH1J;qap z5E@Q&XdIN*N=0VWyTu`Q^}N!2e0}A~{$k~>ELtq&&F7yzz_zQ;EARRdv+Xm}z}%@c zWrQM=Q_1tpCgqHAmMRTqkO6O5DsF!{9+>xqOS$yHx&6+iZQ@zs$>;QM z%N~KxTDbMIggd?nI47Kirc-cGaI z?OAGvJe{8{sdG2TUzvWzTCrzSm;|#A5qT7lJwP5dE2-q@~ksUZI2MJ(>Ke?ccT zTDh46udBsSl(t!w)YWBPAZKMp827H5#oSS~^jFc5w6{Mu?3C9*bA6~=E$Y6lKP@_Q z_ovWBb4iGgvxOh{9aPqdUYuowp#u;G@BIXi9!4P54T! zmvY=1hl_Ees|%eCE6H0kcn`@jX8oe+NyQEjYUGId*~F#)XnsXluDhYe%1*~Wj=m9^ z@}(qZ=(~ShSH;L!kb0^wGT3&y2SulewJ>bCll-u9lMa&UFH4+1!a#4j&}{zz0q1vG zf|B$cQ;PoX?9{cp{uXr$W-U2#{|%-G)Csk_;uI zXV@wXiB3gySb4wKZG;#aas|Q|Bo&N#awK&3_$|wXEc1Z+g=3i6(Q!MkyxffjU%tB0 zLC|&0HTje~mVfsQga8rela0g^;pmk8iy>UN)(9%Wq&RL+ptgOjkc&-OW&K1(ubCs@ z(RkYo*cd#(Q+~IKQ0_YF-XmUnKy5_hRr=cfbzu|Eue z^B>4)W2dySi5KI{SY6c5``X3m4s<)v_?AKs9E=8{ZiIZ;NqKC-MQbNUdINK{HxkVL zT-holR&JU|0YfU+Y}C4p>Db3it*qpvX>dTFKZ&C9jbb6BtMXm~8-vlUOVe350(6sW zinH|2b4Kj^s78+y$z$KenANI6(bUnX*Qy5U^xiHm!C|5!*?$xw+YTKWHjP zg&;?*kbPUyaf5nJ+-0fWWfH%!-lhPUyZE`__c_K{;hw>~q&>)BVAe>^I@ zzBqcSDCYknCJovf*oXSg{_a%_(e=%g=JZ z9HK+BM^HGqD6UZ?H^Hh@p8mKJBmh(1mFt{phcH~11lgHbjAdBgWPdbU|Ibyfw)KP# zCkP9A++2?un%h<_Np<^s?0aH1ULvu-)R}bwKRk5*d#bumu;oQlJ~^q6O?C9a19UB? zSm*62gs>3Pg^jja-UngTi{>B=MW!E?OWk|%2pu*z&^iWLw+UiI11EE0cnb~ zya0esdM*Vxncu*^wcNDY0-iAD*^duZzNyD>OUi-~19IRT@B(0!{?%=*45kFIjs?|= zy}~sml{x-%oJTIV11=?I_pHOe_$R(Ac43OGWVklPBR8eVwxYYq;SqB>F;QW_uwC7y z3oge5QUk6Cj5z;4^8{*X3}>#xla2pkfkrUgTTJZd;HaC}?nKEbcKMzH8;Af|>oiOC zvww9KR;IEXYp69|E9m-9r1+WI<#&-w)`{OVOa6dY@pT$IQBZj|KI2XPx9d(B>%jnH z*@~1AXBEF=|CdhJz%0=PGdQ{PA+|Q!H2;e9_l>v|@WsYG%~=N~wwFI36yHbRGSdTz zs^Oph#|;(AYHRO-ykSE_ezrt1{A?$Yjz+uI;ZNo6%7t76mjf@1gf2dRNjiC{w-)o!>9)0r1<723`0oFt8$L{Q_f(@=9? z!q)COx^=I~>Dm?GQVIp+4H4&S)_+W3RTgJVDb3TD4f$p;zME~zuhzfMkIb8F4Fu}gyC`T}ev)OY4+ z?mC=4M;|d*f!}?nHYIsOJLhEi0GQm<@ZHDMFlH_}Qq2k>B$^R}HyD2!6YnICe1feh zi-bLu3YriLpG_(%0)$pLE9lr-cVh7rQ1*>aVPK2lF==}ss=Rb7IAY6`IDcpM76yEr z7NGU6-oYi=v#o9S>s04n`EBhhz>eNQTs~sS9#A^o=P_QcI*tZfmU(nO*?3JzAIn<_ z4o1Q&i_fw#KBpl?egK`F{bFp>1Aw4R`)E)kP!GnNiNI5U3fn0Cmgfgwl|?QHE*Sd0 z02W4r9@5Sdh5QO4*PWlG488;Cs#Hn8#pNXEHi6;aNX)PlcWdN;fdMC?1V0jR3q7== zvacyopUq##(;p_hAoHj?!Y=`jD~+g{fHt}1965idtC?NXc173&IEU5Qv9z{`XlmhK z{aXvxOD@Une$l3GI3ZMr|A3}|z%K0iG_r0$nb?JK7hShk1Gz)T21QK7~@I-nCYsj}^WSx7Exs|J#rciy(fLi+E#Z z8o`GDRy(ef3A95}xy^4UM#qDfokXrO9vC!yrD%nk)f9hVL6B9u0VqyJzQ}onW~{4) z=oI2W?BLA z_>|dl$%T{KHpvtY$9Wa78}OYnp#}hAH&Zt=m;82jPV#?$J_cI_W{z!+J7sRVAAV$7 z3kxLsxxMY^6iD`8;o<)g(OJ`l{6?l7;sg@S(4PhPf^ToU$$v`=1>H!Wn{RjB@h$3E z^1X>6vvJtGfAZ4y5CVIKmQWv z2fLzc86R;_33ZbO9bWHsE__&ieRHX^IsH2@>GK5fb==T~P(fnd`&xG2H|EOx zH!e+rBQH3#HP{cl#-Lz?%w4X2=tXbTQn2`qxTe}hW^B?%wga=cU)uX7r*N`l&yT&E z^dqStWFNfmkD?R2ACSUZeChI*;Kr9pYcM=ox|nHdv~&=Z5|p!4$5X1pkFA27M_e3> zjDbZDF@@0%%?~*{w8yb^L(T{pJkhWvt4LY0c$6Ft7aPu`<>x^PwfJA;l5PPMj7fz7 zo`+4=C&20awC-!XUtlfRd?Noq`f-f!ErPd^-8;0+7#t&+|7Oo)<~y{;Zg- zA`S%sU#=B1Prz~IFW|FxFjx+ZTT#;Phmrg~&56@fFW-Gm7v*bEwj>4}s&JFlVH;qe{0X&-0xXCT7VoC3e85a1I8PYU^q97nn6%G)D3bF8OUtmfH-Ps&B zT8WK)H*ik@V8Lb~7MD1sfXlqm+Jpzc)~5{rtF}v3Fx=a8O?;xUOz-B|Z<3IaAY0Hj zB267UV*Md+faUV6WfFB8_exQ?_%rFQhFX@rKQ|-chMn9hUZ`)o%Cpu?M;xRnbdvMq z1{b?m>JDt=cU-X5tU?}v<8W&UcWL?mV!Xw_3M!0oX^`d)0I|*c|0FkhaQQ`C<^Ol4 z;(vO3+`%m!h#Iykui^jzSYRS!vSWt-eG_yELT?yE_7ZNbF((YNU6^rcU(2tOTpwbW zZ5qs8S%qM9C2kgKP+Y23(K|OcZC|*j$Zsl+!r8BUG8>w*?dMbTGw5W*>go%=p6Sa*%oobLV@@U$V(+O~#8n{d`5fr;Ou#xS0qU_3=r6tR%DcnuxKi ze1J8;DYxxFU4G~*VV3QmaAqcdacLd(z?eu5rZI=5c!lrZW^CYR&GR(O!1U0 z0v5g)7P{54K3DsB31C zBub|B4q(K+-w%ujFrgHs42cmuz!7IcBHe?UQlYc(x}oUkZFA5qRaqFpYX29EP&U8G zp;D=%=$*$RxEcCQBw#VgDp%bW7a0~|$jkZ$YM+XSP=ng;mPC*hT;8o@`hlhMA^wz& zW27t&g*;3F#SlVfabz*hTaG|K3+M$Ks7Do-Nv>3*vW0O$ zoLen0?QO@yeq(Z4ZAjf2-@6B5+fO52J7VR3gBuKXAMuL)$z2-vQ zSpY#o!l^NEVrFqC=kUKp-}{5y<(1;`9N#RzpP9U>k5pi?(W#A2Pi%RrUsMY6{1tw( zVfj;p`Bfiz+&S(T1`Pc2H0n2cxyQsbm8zt*AvFB^SS;+;3WQt|pz5?UGiOrISmYx1 zB5Y#Tr8N_@NY+Yj---{2%*cGsZ4ubB1wM$Q`9ya=wbHvZAkZgdqJ^3DA;HASSxB2Z z30Sv4tMIie!=+vSuxQSnzfhtzWlxfLCXds1TENucLOQv~*}$zA>us0400OGL{^r7! ziq@TaAwtmy;#JC%%{YNVV%F+(u}dKjPv#f=;QYZ7gvIaQw_mJoO5~ULGPW=Sx8|@n zViQhS4F#B71wj|0$F}hMq-(cukEqT($I($f0esntXYFjucWAOy#?4{$JLfv!W8b%EfAguP3Ji2gpMJmB&tl*G!I3SUU&XG_Y1cft zoE!9Eu4+5fU=jV}Q2>tWnD|a64prl?|GuBqepU_x9a*sh(#2VqiKtU;P2AGtA(l z8M3;NqKe~OukBDSaaNf{aY8b?)Ap`h|HOPR4=Zx}46gg(W~Z6trAc8tLkfUe)$soxORM9h6B*4n^l zGE>ZTa~imNUR$^P-tR0s`GUn4jE~PPn3$PL=0?m2bvd86{jDRjX=Q#k$7M&v9CqB| zcRDYIeQbqXxDOdXLH$sYepYhp{0n}NNa{e>(0k#oNm&?X~p-6^C_dQ z<)-ie^G72dV{YwUUVc9)=$frFZZ*usS{O1OKmJ>ndgm!ybG2$?Pe6FFf6O$KGF)0( zTAxx|8^)75+#I_sUx2XRhi!tMziVN>gO^K7EFBi+!Srx`$4MS_I(2xs(g(KSPe$x5 z`Xg3zf3h4!?<>3gixYQ(r7+9Nrnjw1&I1bXP*O?^$;-6nZ`zk^b5GG| z5UYuthTxkH$iedK2cHInJiW_HDL#}KQQAw+q3d=<-y#IfRq|&QjYl1mYVz_jy9uGMOz->qOZ8OTycbpYdl7@q7a$5> z#-i=ZSw(4?p>j`k_$)$;<=S^%DQhrgjM=C5G`I2A30eT4XFiU29jYq?Hy zUgcTUJv%NoXhqvo?=;-s=%RN6$8cZYOVV)yR|@v{udtM}8U+c>WZjLiTMX-T;kh!3 z6|yw-QJPuU-4#xKvL+TNS}UJbRAKu$w|UjnfNxGT#prs)ic;Dwoyf$;N?$LG@qL1V zg{Zk8gCSHDUp7$VFzOKjb6!cyaj&P`?b~>D-N_wyD@fHOWv-4c2}Sw)RT`Iip-Pqj zql~@qE`#OPbJ|+19El`?B`0WHrC`l_<9U`>ko<(CYx$8}x$pV2#0;9>$|PD^J}Q%* z`wc;D^20n)CZi(YjnFJI$tgBODScvo(&4F9{a;mx5))1O^#a-=Ah7iH#L^s8vNkzO z#Y6fHrt7TxEnhVxZ0apebL+_qYI$DcVk0H(nYIRaWh5t9DahUaFf6J`d-8Tr)uB2q zfJk4O)ijD2Lpu8$IeGZNeFn^)n>^n9?;;s0%&KEwz!u09n!)rUr>6DztGyru8AIYF z__$Se&Z4NJ;()_b`m0QPd&acs*I5|!+j9Hg)eM^U`subka+sPVIRMBx@E5v+W8;AS zc#3u^MiXxX$j4?FpKswr>Fp}7LGE|8auj06Q)mF}@hE#{OvvB&{=wr$1 z-5umtZjRgCRd;>EpSZ*m`Eq+#T;JfgWvR-4gr_-or1yg2U#wsb54+}^tjHg~Zo{7Y zC2;q^!OhBokMp;w1PWw1f77!4os*Gr9Qw&%%8mZZpzS@QYDbn#ub?Kwi3|UJHLjHe z-Ybjn8b7sy7kO5nI@&B(-RuUHmmR86X>cf>1!E6F0^z85 z>a^h{_hGib8I9Kdp48rl)|E;RVQr&`jDoM!=4QiViS$)$CCFgqD%&IZ##(Ulb0Nta zF~agA-w&K11_ZSd3~$OY#4NkC7#kVa>;H$_We3wWwqN^ARSCYU6+kFH zuES2&(&aB5HPX1-O~v;8^$yL%D`;eI{0sb=x^afZnCsM+FKhJFeSV+>hqCDn3%S%H z9KLz(L|z~AVOgub5z^Bz$pf#M?ChXr{+eZRxqKzYnPe1sZ??7UoH3qM)qe+txE^wq zUI_QmWBR|FdKCLUzt`%~PnE_)7r^}LL?ci!@MBx@GoF=K(qrjb*UMwi4P3*xaQe55 z*4o`o!5x!`xL;o_W}Iq3`i)J*+tK+f#3PoFaX+xoA5)7TZNRf~BJ}a5IiHF~)j^K2 ziIte)A#QigbbVcKHwVfQHL!eI?qI?9jQV$+$8kwaVDd4GUGL+J3W385@c}+nZC>0u z4#sMZ_4`|zp|@nN+6C78r@8O^XP+qUBuMciPLhLhB55&)5mW%YRcTbq?GN1TF$}ul zKF7*H>%Am#;N^_Y!DUH~)F~&nnI`WxNaI`ldyRVhAcG}rmN~s_y3rbP+rCh+e@>t! z`4Wp(+5|dkZRtN>p+!sY3~aJtG{itq`k$qEoUdSa8TJi+sP&1D9eM#jJ?c=jUC#AB zr?p6ox14!E>djQRAxI;t_--P0$O8U+$06k%>8lF9p3lO%6?mpAT$z|#{)Mb3{n2i~ zb3JOo^sRjok~**yO|U4*DxF~hRT9Hk@r_@h$l5}li*26}%sUl_$TW^St=Su1uIncH z0sE(2rGI?icYjL8$O7dYnUn^*dkRYPM@$(~6omKe1%;m(*%Rg)kt^w@)dCyyduayK zd614Hvl3Ua#ug+73E$AvkS)sZ$78bjS@s02Dw#HDAywqi4*vp;5CrWxTvjTOy_1Wt zG-j(%ksO0VIX8X>wF}LuI5+IugbR%sa_H~n9g(!iXH-u?`nxGtxqZZGk(uM_$oy(3 z-HDbn%gvyWrRtJyRJTZdWia9=GFF7TOgjn-y`Crd@KXi+nOuiYPig@Qe{bX zki?mX4;?=ZV=Hl=fuRk!zhPo@9ON+#V(rX^DOSR&P)8r?nJ}I(@;oGt_+KN}+FsB=tjlXsSxjlCZwoDx9U8^qA%>c^al#VCK7W zISl-fi;puzn0A67M8BVB_ixZp9H^O#Pw9Zwdaq+HY#jOTwq9UXIPCvC^a10}@B*=S z8s2hJotstw9>U9O#z3pHOJ^(x@}z^Dd^PtVEsyzJbv%I% z1;G$FBsVnwkt!(NcVFdH1F3*^sf-vVb=(DwND=et2+bM-c*{U?*&MHzQ)nKJPI21i!P+6(;!gYHm`#Ah9N^{QJ;Dgs5oZd#?S@Vt+hx=(0 zp~dQ1#tWz?l`niDMA1ckA!8M^|B8Na=qJicvs8i!EH7uqgRkDk3d!D9gh}r}`r-NW zVU4^LWXywATZT`XmEI1^@ZfT)gJWJsh9iRb-JN24LNvU(Z-e~P=8#*VSspJ29Js_; zt-@=uwIvi}#|89DV)a=QuoFtqD-T#$L@{h?PHscnU9kh|xVr_;U7YGX>V@aE7=&`=rer3&$rbez- zYKkDk?pdL*uyYiw4m5ms4|;;V2i}7=K~l#H5o{v?+ThZ^f6r5hRZ;L|8C8K38dg0P z8krg46zeDDuiD7sVHybX)zu_qGCB>La*zHG~e#o{(zX9ZwKaS(qnnQ0N)KFmuNBEyGSi7xve($yiblF{o* zl@Zydnkn!U3{r%Q@=~lgT@yw#Xc{lvE1l<<6&3ZkG>ewX?RSzNZO|#P81>!h^YqKm zHQ&qaA^2lOiy3k@dnU=QYm_(Qcou}#){n+Nmgm{&Wf@?$u9=oQnui8nxbOzpPW#MA%5Q(~-Ljr6CF8?Kuga&s zUS#X2X{#^a6rCX3VLWDQgQN~F;T-&P$n}*Oz`3&=I>LP-t4K!Eh<>6>@8HIQFjmii zu&|12t`}kc{v|I;2n<@rfL{_*nEC;b^PMAWQ3|iXISL1@--4*H8WEM~2R&Y%E!RXH zNGR76bb1Mb^3c#-u)XJziVI(~lPKAX1h>8T`A7ID6^9CRo@oA#+v@GEaioF+tUE#U zR!n>ibLGvFop3n|Bxh#H&Q7fgY})-UMRk)zfpixHeO}vm-};7Lw#QEq7fb)GjPK#v z_?@YPAnFlWm1h7K1*uXakN*j#dt*5#o?hI)qgLMrW|Y+0)*mSlLR}B5LuBqw`joNfA|D@8=|ZKjPOWg&~v!2XH*yASOW z_w$}Ow^e22D1wE-D}DmqNej&LVYXxgHzY(R0wAk zn+%3Aace{+^Jm&06tVsG&ad6ObY5}S^EJl#`rdlFXy_XlOkmu?yJL3Y*G~75=Z_xw zsR+#jg85uLi%(~H0_9~$A&`pa$a0jGsfn@|eVIXTPqAK3VY+zw*8cp;ie=ElE=P_) zEg9`qVU0i5@#%4@v*#t>@~tJ*Zzsu$BLco+1_yHXTPR_Eer+iWu(J^MVssJbuyieO zd}IbIYQa#=ab}Noc;EzEG2g4h&FArwEuEQRJ(&?gyw}N&qIlxS5y%(S(5?s zW}4j=6M2b5_)-}NHi%n)u);bl2SC}MqcH4N-Vr;Xqhu!cE5vWUuhUL<-?4Vq?5^v2 z&T2eNcy@4!Sqd!wwiWGBbRc2Jdvk2Ql8q7Mxnv0+=(%smY$EXTUVfJGEQtC!f|H!$ zf2nxL(6g~M@SZb0(ONoj>-M7r84bRVMP(enke=%Rx6Wawxs$&mVMg|09D(mRW{pyO zGGd_pHLfFsp&EMeW3%f?)t76txv*k6zT7^TSPVL-lJCi zZ&400W z9xCnU+qH~O|7e$j1czC@m*1pYL{y>Zoe)Pz zOkQ3;PBJ^_USF6NX0*QV&E4Jv)6M)HkF)-mvS^R>uS3RO?y+Sw0(LvYrR9BJV65BS z_UJd5z{ACqiLI@8V{(}1fS6xT)Oika0uol@~Px|hL;qbuH|Z?<*wclTgJEmR8LzyBa|;ONErlDyHAs)v~FiD0PyRU z6F9?M&VUZ&)$%ui3^JAoGgg`#fFVK$Q*^3!2UW(duJSoS>-%66MY@-n(HXAOkcG1q zD&H_M^~8kranCc~v|_;{F_o|R-#iVvb+0+NSGNE9K@hriAeSr-99_pzf^7s(N2>sr zH#uta=j#G4gMm+5pE#@h8z_0o!M2_~FmO*(Y!km^imG>2Ino{qH`X)=i-Jfn3yM$?nDowKNLBt zKvVJ~BPScFu& zOjZmB?N?!-No++4qnxOsm{LaWev*wSE$jmLz5M1(Wz;b_V-ycacg-R`F4!(zo1Hvt z8n5nY(7R)jQWlyJ##GaQ?~tZ=b!=Ni`ib(A-JN}2LS}o;UJRaY4mWuLZF#0%N`taq z6_MFa;s^|Mmq}lJ6J16fZyV2sh&rb$V2ff;06H;cg&ma~HxzqWxb0Sh{`R~3ZEMjg zw+n6974M`ZeNUG;V2IK2LHJ)~1dZCs5}$g1r?mn{Yj2tbmG=-Go6Ya<(`tMuE*hez z9MJp2Eon$DI)>vL5XzA*dUVZI`8M0;C&#P;TOTuHbc(En*Dq=rjvjhQ*; zaMtQr#$m+WE4&iD9`~ZCh>2-$JkbDDOc{4f#X-`GcxSzzuSuvJnjU1(ngN?S)2J7P zX79s)1e1HoKLR7I8oacpSyo?Xn%O}ZV(C;s01~fx}#C?#50)_Zi z^knOsoz#+!j?XB+#aA1C6a8~}NdLd`de-tJvdgAbZ0`YBb?Pkem|hAHn9c*{dpI zwMjRY&t0v}yAjt)TKIK21BwyThr=x!!h)R7HSy#3xmM>jl1`tn#r@-V zj^D{ssBXRHjJ|y1H`gvVjtG7WnH2SoI|Q&prWoBE%ld|vmQa~^U!qeCjHXM0m9M8z zSmc_!ulEQ2VW#m9OzKN-D1FJ;i4+PS%Rn4v29;aCq6=mxYXLcgcaT;#wUtxdI1}a3 zqN8t{53?(-7{2rPqZ^0)DLwb&{4_L$-|D1e|J~-HJbR6$@c8O#aaLr?xmAq29g#!r zqVjvKHrYd@nT5fTE$tW7kp7r@TtWbI(1TYX!S}`e>AUT)CT8&*I>r>CjUte0V=lepkX^rP zWd~pf5s&*$>xupu@)IPa)66sTCL??QyMSO~T}_FQgtNFof;eAAo2=e(7~^yNY-w&d z`q_tzY=JIyDw)GG9TURMW`_Q(zk74 zWj)@E&Tjd-+?H7Dut=hW{00`(gx0@)yuez~?O$v#8Tm|PdU3*;4kMH!qTME2(U#J* zSG(>9dDTqw=6>xJWo<4Add`*TJ9+pbl8!yLE!>_gHMda;{G)s~MQ0*uM(>%k*<&TK zY3H`V-ht*r+xo#;q#(?taBiek}NDqtcSR5`v?Er0Kx5xO$mQqRdu zgioHuGPV9J4+w_O|kBc3N-(-wep>pusep9#r=LT)KvZ- z%&36o8sEUL`w?1ypg*a2T*;Ljx#PkSWov6IWr_Hs7!S%|LHV@Z zHFXP8-+@r>LZ=qj!+ckXz1eS)DYKKg+19VQwmtS(kXq?Ixly_Z8v)a+M#!pJfw!KGk zp*Kz*PGOOIu1`4(8=WpCbVVMtW)xM0{LMfIbTz=E5SvqG6~#zt`^x$oYHgWnkm*wll9Lw5uW;q(^GAet zFWRUm5-kCjVcjKiVptu#znR!UOy%G2{xYx5U@_)9zWdEab^&{N1{VPrnm|WkWs{PR zSm;xA`8%0ZD`p$3Ia7}d{2Wz(VJn<6v@vrX8AuQq>s*$}GNNEbPX_lWdUf*@EgPGM zlD-oi)s?!;x?L5$5kcw(7QWp;Dio|9gJ*F(yh?9$e{m!^;n8?Seyn!Ct847Ox7 z`!mTJ;6fgIV#sy`U);<)OCxrJ%=wl;r4=AD6|^yO}8NaA&8y zzW?hpqtGcBsNC{`J?ahb0jnC|*S^#N;0z2Mkt{S~9e7j!2Hp>CGd?1V5VZ-(J60kh zld*8gCw{|)*Y?)8_{p>!rA04`{pV+LUPB4)BlewQa2i0eO#Z?<4L}I1cKh?8C|!g& z_uiL372VGdz6T-+rcIY4dLAL%mcLVM01D(8)PF^E2O^kx%hM;I;r5k-m$Lakm3z$D5MI@A`iYv~ zsaFIW{4Bx;|3iH#{MAfQj?_qyji7C_a@CdL9x+tuS*dLb0Mx1CLLA}rF zkuJ6vb?@YRU-m9GaRzoe>$lxOj1!bFHuhn6SbGBnIqmscS%1F1SkG|ORxB0TEPGZf zJF+KMU3#Nlc}*~Ar!*?Zalukyz?m`b@is-M0e^|Qs*s%d$gsO(RrriAG3GRWILu`< z&3IDZs`iWg`YPqM>g!AJy@Slb-5!_mc>!dtuTWd}*=#iOd(A!*XR6k%f#&M_G(N}~ zG>n?OZAWw|>)z6A0odw7A6A%MkBE`YA)ZAvF=Myb(bn=eN-{9o2)7sT;j>}<2MpOO z)YLWH&zR{HBffLXngG%?fd%b6{-%A{}0l%={b4$@mdX-W%76KM+4Lx)fT1ZklM zrGyrcUPA8>AaD5oX5ZPF_uZYHo!y<;nU{Z<+&s@M=id7{=X}mN`SMy@gXSjNO#lEu z^IY?(E&y=tE&xFCkCL3&Vn%V}5CC|p`~0bjo^Qq`R;SR^URCKUm&uPP26SX+2bbh2tBUr`B?7i)ww(N3k~cEkOsA>A$Wwx{{kVZQ^w)zoM6Sb~?7d9qUqu zS0~O#^WRH;ZBhW>ZV2(ib9)jJ0N^WwG5`=_eVv}z%1Uyb_{=lF|A)H*zl+sRjL1`+(^!I(F|#h17ci8On3(9c zGMM=Vg+`;>hYNI$kBp`Lf=aSh=Gr6Mv%$^&j9Cf+@Pmf!nP&DlD3m!XU=r5?E%!5V z_M+CTb^O~R8|HXD#O#(}QDv2!uy0Jj>7LEW`98WmV7r;w+pKAZPVvOT*DSr*soX#7 zq%oPNVUwCd_h6MTu&lj0OPYu z9P(1|d>VaW`ksooh>%cv!5@SJ9l{;O)5S#NIo?M1g|2SteJAb5ZXHZfP{p&tqZW6( z!^vlo`F1)bj!Q0ZJMeNRlB!+f&Mf<`!mVrlEhlR_!E7zZ&D-J4t|VWuU+3!x(Txw2 zrv@Z8PmNGQb)||*+m(K(7k;q|HpY5zP?`OtVu{l=0OA1z!6ldss*FZQGmA#OaD`Rq zciwb_jhG`L&EAIgh?4=x#8;1&-&}0C3_kL(6?8V;H7lp*MZ;$Y2Em60yydv2AjOM= z;T(`)N;RAB78YU9G`8FHCszX+<^Se!_ePFuFn(%I5PbULq)WPm;qo8d<=yiQJEbY_ zgf@1p%W?DrI>XY|!IJ*5370o{%`W!?CL7i{1Unzcxti2Dm6#?1NL#t1lKZN3**jmX z;I~m*PqLkBONc!1ox@(J3Kg;8iskevn7r3b5(dD1^orakxX!L&4@!gqy7D>x! z&56eXF2|*=K_!1Yd}K4{(3PEb!1L*G$);d@U9iddg%V+3X|4~vrSYje_yUJ#Q0_wh z2HT|M!3{<*&0TOX5U^3~;FE}EThEdx#p^gdmI*p?dd&*GRs_7`sGWrMwY-1!erHE;{_CLDriCmT$# zq~fl|M#{33*Rn6SE2y_y@DBq|=1>yQiS0AV z$=E`t&O-0L#`QQa#VTw`b#=nnrw7KsUS&`e67?aaI;zuA?#UA_{+Gk^3MI5zW#%Tq zLw?mOalb2TbfOvH&mHZ4J6LAMnTaXlM`22UR=7=P-NKUe&QelK_4%rX65Az*;Gg97 zn9st%?M~Ozg$1i%#YRa!*w6anfFg2Z~-# zfb_TcO4^}a97}(f2~X5$ZzM_4@<*o6!mn&BHjr?HMA_mMjEe!CQ}2Z&C9i-Q!J98S z12P@2116nnKA2pPw-_^I+vbeggv;(t_+6x=o0m(UpU#DjHd>5UCZu&NU;jGZD}L)= zS0iRXap(hfy;xYQlI*>~IT4f{8L}YT#}HRO{~NW9RAVhBcCvF?Sq65rD9gUquG8@Pfw7sjEOaxmKYV==qx)(k>!qh;(M zsU`hrv>Z}vxYi^v=wDm-_}-X8@FoT#e2$&HFgw|tz1-Z94&Il3w@s>PG+_?UQE&{3 zl`=kL%T*UFmS%mO&sjcj%m~m2IWv5obvqVJ7W5uYt2ANPPnod;%0uM;uHQkJCkr#W zzdoy8LGz&;gv9tUz9-|g{6WEI!`a&MOqk2UTO>6}Q9pz6i8D2Np{!k?twkDD#zMW<&Mdk2iMJH9b6jr=t! zEI`{5yw}60eq8e5sHC2&yM(#?8KM{zExiIqP4pH^M0bjK&7O_Pgi&%esxe zbPe7ZtB#Xd{&7dJ1;+(_J_|HiJI_3xNgsdU-4KNfNwR#2$w@=bt45)-719k~TC*so zWXYGLtp%s=KnW+%c9PZM^Y!ve2L?q;Y4}O_KDkjNL@;#=6GH6S4`X+3GumGv&_q zhb;7fkYqvMiPia_Q5WgXx+OXwlLS|%2q-l*l@}qhZpDqiaR)GwHopkM9FDO8( zW`Su1`!VIS9Opse0WodGm^!VOb+^Kd%~CBLb-hfx+*CTASk{%W2=ro(a-oXrqGN_P zgcr=pEK|$Sig=;vhTF_Z8=?YFUIuF6$^*VS*E)`2ke7#ZBaO58nd2y>+0#KE*Wp>sO1u8sJi{lpFiA>n1m}k@O zE`+&49s7;eNI$G$T>(EPw>{co*C~@=i7#p0{k=dZ^``&6dCO+Ypwi_ov|aS#uP7r) zvGdHTHv;U0Ae!-sOnNhHWmCxuGV>$NhlpvX!bidiORr2$tB?v3uZ2Z=z5D##-QU1G zxeVl8uU%QDDLruAH4)4=O~}02O}4%ivDxL==Z0(G`kgs%RK!!_twFL(s!~w`hIown z1m-5*kw-aCXkG-qOuh`nFP$cXPm^;5^}Qaz>Mh=_hf|<#+yyAVw8pc`hs7-|;W?h} z#bzHVT`nlKU4ej(JOlz!^r$`1^ZZQ;fWx#(xhCQ$VzfVb9NfyVx~%|%kI*=*hZ#Y%o}UM{;vINwqR zgj}Np(r`3Y?rpxUcyIsO{+D9*b|B>`5zbC`u6FW2hOOg&U8n#K#W5MTT$@|6@JWZS zb&ozTt_{|1iWn?hO^vQyBT9@@wR12cIeGo`bf!PP)|ve0H9)}llECax)VeSgry!%< z3|aZ>Q!SaTz{?)FL#mp;G6yu&Ea?1XD||GQ%XcPXKdx;WmpksIAFOp|fMb07a>r^i z4XkYw(eVoSn#|w1!{7ZNIGl3}Y36K;iQi^c9J9rjYr;XxHa>>C@qXhP#>6GnNExOM zZp*_A!dR4h8?ikD@w0yPRm1dcPXQBdJL8=ee-3I(Z|glUM`-6TCD7DHEY97fybEY0 zxB1c)5HmL2NEgSPYVQ*6+Wvdt#JF3>C30iJ4$rB&UT988dh~VHUob2h!z~x^c-Qo( z2j7|f`=f2MVKfoY!K4@7r+oVS zIxfeEXil@2e?j(kG1!8KNc_VvIal=LyBS7 zx4qLYi#$L1r8IUINj{cfyZOY)I`w?>Sgl@u zTj_Wr(f~ReARWf66YYAj?;C@wQ}aD^%3-{V^pg%-SfH6`R8PfOQ#sH^5M6C_oA!@!xC-As*z&hj^s9|{im z5h32^=R7+;k$pINzXEoT?$e89IJK*ejH{>An56ZQLv8~4j zxkp%TrkBl(&xG7kU8RWcgJ$W7woe7KQ~@uL#D{kmseC+5rxWKDJFFDg<+;#rVn~YQ z;j6WXW0&qM#TyfAbkAn4ogNx)LEMCTIosc?4Tk=9ye#Dr(yCjFkKfdyB$5vyoN2qo zJr=_zEUF^Fpb@%Tm7TmqZxyM6ZoG)v>50wxl-@}%{?G)18;B3y56x*a+weHb`Ic$_ zP~Qbb#A=k_w2j~kqq(@*?rh}E2_s}gCOEj7;2abv0ucnmpHd49R{qTdno(it2pCXa zEv(KwBXVOO9kow;{H2tEPr7Xh0Sw=0_fhrsbN8aNEKzd`Vwv4u#$NhaJ`oYsFj1Rt zD4X4?Grm(QC93KRNv4ewNBxlSc8#h+?MOM9v6i|qbMp>*gHqnb^^G@|3LUT6srLLT~kHHO&`|i;Yr1yzjS(-*$spFfaal#tx$*~ddFCiX72Ywj?iglU4b`>jUT); zS*B{D{%3Qo3aIQd({K|6YPbKo0zG|5UP{*&6kO9ee=tnX)dKEMNtr!e9J9lzSK%C*-hKyky@kTu2=~jbPR*?+v>EZj~0d=oLx($2+iI{DP>GA zPWFr&#?_r6yKZiGE*<=<)K&L*Jtu;D?M{EXBVS&gB^dpeRquyugkllkx0Q?Wvb_%%|=PlFF;)D+h1+@fXg<=s&Sr+U+5Aekf!u$F3^HrEF>Q^Zn_= z%Tm+u_)BCgw#mNrC~1y2DqFaGziD;;#>P}V^nN?4#`Uw~A^h7>V8NMFA9jH6`tMoZ^{>Q_Y^jAhQ@q`<9Tj8W@4(I{)i2Ox zqxeHysT)6JY9oJC-G9HFsxo@Ofa;kpkD)ttu|b$q)@?_g&r#&!W1HlM8>_;fEVWDk zeIy2cOnZ^n=qUAMprjd9t1eiRvYeM<0Y%ypp!~`Zh%oiWTYK9N!G7y=z9p1@uI)&1BE{#yvT< zUbd1Dm>KRhOPH;f5b}`;Ft>WK%=T6a$}DRCvU_XdJs=IF@=%Z-&=-_{unhT4vZ034 zcss{y{Aei9oSz6WrzW!-I(=vV+zC@>Mc^!2f#l3y<*oYJZoMiGW0|VK0}+M&-lO>% zCHzQpBsYFXo$|EPB1Uxv%x?YYn%?dv;l$3$uf_6Fmqm5}v}~;Jvkg~_^p{el&e}V} zXxgz!mW|tpPfMk+io`Z5W#RtfrEg4d7 zP5#{lKppTvle}q$);dM-oxM6j4R``dHB8eLMBSIP@)JKN*G_7i4dH03#a(zk;8GM} zS{LkcpgvwZD5#DVz`2=T+Gl)%GdBVuj@lm=PR~l2+`o@omPXZY122OO98Eji-oPJq zkX=}oJY`kx4PZI`LPe5=+#t*-u!-0jPAAHQD8&8zJO$2TMtym^z!W?aBlw+e%fpmW z0nU?z`$iqA{n#`XtZaI1(f*G@aeaZ9Thde#D!pknN6@Gejjg{sPu$(JzzXl)q;$O& z@6ivluq3>3-gI&}keNI#&1}bC*#1V3w?LR7#dW}Yl?O(Afv+aK2PK;>oT2#`V4uot zXMJ2jC(Fm2TkI$mJ?KQVFbA5Vl%%rLqC&@XVg3kf=|8hGT3_sKBUNU&2CVVCGj~^e z(->CYZ1K;lmhpbpiZ~q>x**F$rv{NAPf%&FEYaW?=j=0sTgS|{jt2=wz$b} zn&r*kJxKRCGb@WDKgQ1sS!XK=w!IcYgND8+>F`7Ru%V#geUpn$y2$yq;Bv?a9ThL$ zh8w@(-fe|@OKsLUDKuJ?P_Sx!@rXsu+|;*XLqNZYJoEz!@HVs5X)LK_*xH1a2xK;~ zMgQd-otg9|e(0_DMSCU!*v_2344NMj)E2AByc_VKYje5u1utWR4eWBhd-co6{Y~m! z@s%!_^JwM|MN=@ICuFIFZWe&vqY99*Qz=tg0c8)(Pkrt7*idMYaDW%G$>4hOcrwh; zaCes=@qyKV#BQ>oSB!t@Fa|p%zIewB(Yq;VQ$CaJ(69nJ;mhCRoPq=nBqcmn>*5kE zw>r3W{etg>} z4G*f_dm;wU)wSX(8joXl7G}XZojb07n5qK!u+6=-I$h;>{G6>wY%)KtvscP#@sd&kDq4P(0y9UmN@`{PCA}6);e7zlKEnH| z2d*zC?}#0m98T=Lvk4wl92Qs0%gdGNn%+yc8Wkk5igV(*t2I?9p>I^adq&sQ@(P(P z@oYPFYUS;iKC8=8Mtuq%AKxbIl zy-Y#aiWOkY95+l~;il3kpIrdn+7bMh1jkMc9WZ1nc|+-}QMTDOusg%XdJ*ZPrJZ!- zbr?3juaCku9ub3GK^o`+E7iSG8Qp{L#zs%FtY7~|V+!M;Ve!Tk zCQ4zFX>?VY-E41(UUVz1XY-`;$@}L!-O`F`@1-cE(iPF?;;*QT)E`ay(x=^i^en5F zjh5RZDpB;XW9G`59<>o(^G_BJ)XU0}jYk~)lxC%5@=`ZmnjSESD{nJsnYSme_8fKS zD4b&Zt4H~Kh*5BAp#RDSeQc9X1)Rul*T@tx*f+7=^D>sRrHL?~idoRQQ~h!O$d)s= zsFG?4da4`AdE;Z}JAVU>bPi1k+?OSUb?I%@D)j}!u^Zf*I`@fk7}7PN1uhAd^(EQO zyW#ZDQAe(}fp`bm$9*zyX3gQ^@-r`LP49jo8xWLuZzB=f-9#^Lmwr!}8?Qx-J*L#{ zjzMMTc%2>u)(HDLNqE96ElFDMll!4*?)6fpJPgD6-M6b&Sel_uM%34qpaYZ=L zOmVa}b>)0|3(060=n&Ftzby>kQ{HPdD`b=1GTwXK-rZ%C>iY-iamB}{AfM7yH695kdXD(D^wHvdp(i+ zSHFk{UFNo?0gUr*NK6`tL|CwJ*EM-$si7Qz5Xe?k7|~^%;g{1=(5}^$%3Gc(*^rTl z(G$!bZnRu7Fpx}8Ez5V|94(rTcv4~ym47r|cGSAapS)qy_Hs(FygC17rl{X%^VrS( zIfAW3otbBjZ0L}kQ#=OZ_Ksm}Qi+?y`peB4`oHqWjCV`re73@LlrBb`DIQECgOxI} z27xIJIpI6SFz!#7OlvY|; zj1An(Zq{b2rx-7FAqzV*Cj}TL1HSr>6{t@MvssC|B5g?3vHP2UgUk+RBta>%D-#{K zy44J=R5E}CC#hy=^1nvLI-~zQTTW(S9&fl5xKK))4vUd;2Qy>S^UFL&_eZdGYaV6( zujZ}+#_w1uI}}e{*p2SIv77aq5@uISc`_?9jq#guo|l#0JrkY`zKt0hJ0=5EAg{;s zGtS!wOPM|A3NCXoD3i((Jq#)x_W#r2RpyZeLZ`1!0sy*y$V&1bv@n|2eKOQGLcH+# z374&Lotpa4+}DyC(tgy%?izD`*~ttRnzo&Rk8Yx}%RS0$;4l5kw3063Vg6vIO=(c*q&6 zdya3p8Rmm#7SIcfO&|f|>XD1C0OK@WVk{v1k&wn3mO8UQ@}Juz zjOtCPAyS3{7LojeILvZX&3 zz>ik08jhy4YNc4EtOvX|n9(8aPKnV`le?UTZQ3bd4o>wa@@e#&mHJ!|gMQ1+E$Ol= zH6D+>GCFWqZU5bQYLOGToaP+wozyqUA+Xu!H(vC-mn1h$>>LW5T7wURPN)!t>UeMsMG z1bvqhDgHu#)){mB$2VEAr=wz(99c8R^iu!e;wjMnM-#4 zsE*9~4H+a&JWn3;AkJsiyOhj26LT2*7@o>n5|qRx0UTH|Vn3q&-%M?A=9)*5ZLnZUg;Itr>@chYuFBP$kO8Yk-_LaZa2OHWbB z6=Bofck+ZOxya?XlPlN#bH5?UoguzkbZ z-lwMgeJwBbn?;=)vYq)+WkaN-fPPRN56I^?+-tDXamB$BuU5Gpq`iCTG=G|ZbYa;C z21u$9nQuUR3^8T^xW`NE4$wp7Ndd~@#7X}T&2GwDvqa#UDM@C4*chq!8(G-tsVEdUrj-y(dux1=-zHoj@9@n5w?E7`O zRFht(jLBTl;P;<*)7>{@Ns1&8vZ=xWyAxko-^X?&z?ebg`R5MYp|WqpxWx=CVw{_=r(5KZIHoaTP*kBO}Eq+s8+1F#1R2P`hY! zDq0o-|2Ll5_%Y8#@R^-j=`+NTe3gSm+U`@MV>EM(svh($m&3eGclqF7b}rvD=YfTk z#B!^YL)GqTG8^-{Op!h7vkS1so?G}$N5B`+0QhZ!Z-`X!dBL^u&qm1? zWK-x9ui7E8QtIl#;Ud;MRji#Xu5)Ra55q>4$%QWChIxhP1BeB~;g>!VIy-oPhbo~tRanG(ScBc#-MAxo39i*^jo6q=VeofLV>(6XI zEghb*J%2zUN!jeX2@jrY-Qri23k+<%Gz`e-gzdb+++r{1P?UO|qAH|gH;=M@HrVij zC-*G}QEgRs z<2_o#DdVz&(E052BfFAg2ftTdU{)dVho zVFC2zt9Eu|X`sUCdoh%Fs}m_X#}6kB+LpbalT1Yax>I@RecZUkLwlo{3HTNAF{dkj zi6?Q2awCl;loTJnE~Tl8VB$8dF@I*G6(3kiM!CWnkbJ1JypdkY`l{;AN50vi<J5gih;_D0+W}hfvTk~xj?yXK58t%)J&8*k{7R(cGb|miQ zlnC*^o6P@>gt#=(0@*hyHgji(CUYl?#@$u9@p-ah71Dbrd`QX_yYluD1GHKeN&^sL z_VvH>gGO&cyVXPwZfo-OtbGg`qEesfR$Jxpibf|fqq94oR&9PF0XS3L#pW)!`MEQ+ z{du#C7^AcB^GkS4^s7bD#OLO#m(KeKu7_||?E-EIQmOZ8Q1WvBBIM<{ihNx9-!ou< zjR04ra$yH3WNich@F2Fx?lpy)?pQj2Tu)}MYWRi2K}UVCxvD0hKc!!np%K~9KTY){-+Mu3!6-pf9YlM zA~%`)^fyu)x^~BsZ9a`x9ajyuXk~khTHOQ!l+#(R{Use1_*`=Rb0g!xojI$SCu968 z4|-<~nq#2t`EKdH5EE(l6OW3RQgPZj@z3fasoY4RP zrhbt93Kynm>FL5#0>%xDm5r^N2m}~wOklOv?f<+vMEdppgecG(r9LoZD)X8^$YL5QTqAAynTtn|lYxmz)YB^f@cFn`w+tas*q z|D;cHN+rm=&TE!9a8dK0O>gA*$nSl5(M!b!h{uUxip{(1k)lOmW4(&Ci~P;04rv^Y z!)hYPpjmqV2wanMT16bF7QB>EQr4u1^F@@MU-2}}<9%qR@ucWzDrx3#YpbgdoxZEA zI)2BL=5INSFW}1>!I?omoyEubjaYG#cgg#b7iYr8KivMze=V621cW3JjQ}|fDoU6( z6=lUH6TOu(;Q#TISK96i{BfPx^?$8Oz?O_fA%L=AMpjltZf>q{Dv!zfTx^zy8e(*K zV)3`nD_4)m!Nl$QuAlpElwT?0xhcg)DL}rV%gc-Y$cZ^7NDO z@}bHXdCj)gQYP`obD?sIE zum6l&;>@_u#>*PYMG1(#$0H;D_dhecrAxZgnJ{(WOrCYKuBgzv*!I|)J|i_OvT zUh^S!@(1%u87eF!hP!X`PIPq7ok+YNr}mHAW9fCBs$Nm@+fb=$f-XL!Ca>gu>Yg56 z8K{|tf#bvJT!no573^Z$76q9CbLV)$WkP~mA71}&3b%b~4nbCrG4k_1qCg*m;2}@q)22p5&=^$0VW^I=-TSxWiGO?%~~| z2ix<1lRKWs!6rwG*HWNq1%s)g=xMBXZbasz5ZIA?YfcDvh_XZaHy3ZBYk%~c?IC(k z+QL%k;BycqU$x-M#Ea2Zn?@tyhS`&&T5?YK{lKS)H{~u$Qi8|^n4oMQ(JisD5jrh1C!tZpwTdh-U}qq>_wPb#T( z65>2Lk`uu0bc5BU(SZbWgGVAR(Sn$9)wRChNC9ocmPW7_IG=vL9zROS)7p5QPNt&F zFx`RSJiUwGvINzR#@ZFR7%`@=}da z6oJMXQ8VEoRUe~vp4kQ%d#O)(F|$lJ|ES=<%9p^h(p4Q)8n6^Lf55IaA`Oc>wNL~DouonVZO&$gLZtfl;bvqX;Y7G!5u{=F&a_8P!y{-4tRG&PIHq#fSvl@umI|I zO>!>qCK=E-GyP|bzgUX`%PYZRgJz-R2H2qkdLVI z*}wWn6llSal|S$5;tvAoU$bqC*LsqqOv!h$K(EmP6Nrulhd!kdzR864{uHf{3EiE2 z*q=aMd{r3K>x#;ZaJDLqzEhG=C-a#j<1ya(2Jks6aj%@lKmGaVNcRf7`(s}qbD}ue z{O7OQcUGkl(KIz@i(k+f9-?65HD_Ar#a%JFaEB#BmWj=wKdUM!GS*y2nZ!|Ravxh; zasLvSTJ1;TK;P;3E1aB)OT6LUBeH>9wBf`joK&(Ng~eq5NVUq8@wB%N`D>-Q<6cn>8ukz_~mo zX14=2y2j&6^+s-I)w?J(45;Ki25-~}dydTfyUMyz?h{%K9*ufb)%o-X?NnKMWvM!~ z&$p|^y&iC9rRlFiwAcuyIJ>ls!vpD}>#t#w{`2Md*HYS2%6pMRnDr2WIb#{NtDTZ7 zT$VIq=P+ntPd?hHXm4*R<*nkoTBSy5LmX=GdV*IWi|dh81G41g?~4EuK+Ut3GnaK} zq;u(Uh%~zR%3%($h_$7mqTH(M^7!Yo8u6yHD&GrgdAhIxITq zN@6u|-DbKAc-W0+#LfVvd3%GGmGs>Iqf7liHyr{0tNDM4>i-HO^Z&1Na>XpQUj8BS zQh5LzFsWRyaN(ZXl zYUPyoPHnhE_WG{8MUg>t`_fXL!L_65|J2|(Gm`?wo%#4M?Ylkh_1>Gts|7Lc&HPZU z*{wqyhM0RJpOHz7H$DI8e498pD!Io2+%&c=?!`#lT8_uY~?9YEZx0 zOQ0y1U~szsZ~HgV=nP^tZ}Dd^&%VJ^fg?iHj}(@hF4#uSMs?|uKSO^Aa&*lqJKcRi zf#Ns6Sm?wd=h{l12ZVJfJ3rc_G4MiGKKRnfT3N2bn~^2LW+iXQ617A>Pq}&XO}p|KhL2|Vh#*8|qEO}Hb7ELqo9ndJ-FNWk z2P|7PDkWi8KVd#2HPu+ng5nD5VpNtfZLuth7i zzC-3Ko$Wx>JN`?EZHmx)1tMIsta&q1WYp!2TB(X{Zd)`b{FZFCanuy@DQ7O&cnlJ) zNh2zSJ9E6+Cl8aCzEg7ZNk`!-^(kwv^irfqU)0viP_Y>~2F2y@cwbI+>8jqOX5|3l zQFL2fP>h38VAG;BydMO{ zn^jc+>RF~QqGj+KDpC6G>yxd;^(s^5}F-d87uEi`IlYOHqMF2eK1d z!LW2Qy#0e`G;TmtRN6z)g8yo&@l}jJ0z4&;d|jKxxZVwo3Y29jLI%yb8c`Z^^?&C- ze7LZ#_Yis^y3H4%%@k}N%=T~hV*aqDrHO;ONm@bF=}M3k5A<8*ur6v8#3ejoV_itl zx*?Ckl-W)SK$K)}YE*)FpjHx=j<0G1xfhM9t)9*wcHzcosNiT~qP)x__3+?(4`A-F zoB`f-oi+SXbHLo-=9IdP68RUNjgD|yR9E@|MJr0&)Y<352acB0qh_~@MeFl>G)WR! z1wV(#U{@9#$LGB%f)flsI*Hm``uR2til1`?BX0XQo1d&3=(O4CC<#}!Zz6o!4(rAJ zI*B0wU;OWjo!sGJHwc8mWww!#SlDOcIZUif)b~CA9XU5zVi0;;^6lV!qbL{`L1uFF ztZwSUaw;4E_)8X_h?8aqQtWQ!YRvr(#q&ZlGcym-(la@4+}+(72GQtfXW7gW6`Uw~ zu#EuOZsy65^t-StH@~CAPC+_F3>E-rHHWeBy{|nWm;Un&e!p`kZ`~rqAmo+kn3??+ zN*OPb{|rQsO<5CT1{}J_B{Tzo!%$%0Er_rGWOt=ybax~W!XZMWFY}Wzu8(A$pjTV) zt4Ey>1sX(jax`^5ie+IN9JGs!*pH6RaRf~~c1+>R4!mWa*({LXzD{TBTGb!RdDAdK z#1P=7$yV5x`tfcVo`E1LdRdMEBdmu0iYpE-5KB4d)`kn_HV$!aNj7r>(zDcbKt<|0 z7cAR^6s-kX6ffbxNWv#Vty_7N)RgT0pw;{8-YCmzX(8E}IXNWxI*<#hpXj!*=`6<# z?I>bt;9FRrc@*!X!9hi;?BGkDz=J;&b4Qy~21_{4HY~!YJ=&l=%1gP|CWHGfp!hD7&e+cgL!3G!FlEWO!oE$ zpW~Y~=vD?jy}Z4-va%F6BU5+BX5L!%*!+t-^a3qC1js3@_9gS zqpR19nnFDLKal|fTqcvM)ju1ahKR`s%^;ORK}vxgNW=u_80KFWnd^6$$72mR-f{(k?Mh5P~C^s?KGa5}l2tE*AweGZMzv-S^K9 zzw9s+{0lnTQ16yCSWrKk$W{8>`~^n=Cz|acYPziboD{YwqoNehhJ;NW!e{%AS!Mp0 z;lsi7s=7PZdNSo)!_i=QSEuEY1d?M%T3d=SJ0>AwaBImj@B%!hWX?)!S?_zW^G=4% z@sDBW1s*Ke_UiD&u?Qw-xhyz-B@$XqSct3TgF@GqpmKdG4YR9Tgo%T)(@^g=lF^SV z66;X@4N>RU#1g6E$-`(RQSuB_T6u38Op%rP9x{LcsTaGS(Lq9_?N5ni%vYC1 z!*e8K9{We7JAVkLO1z=N3l{swm#fe=yX-(+4&E}>z12UtZp0#To}>lKVwTEv2~!TUpy3}U2_O(T`2MO{1ym!U-1m2%4cJT=qkCD#*j_S1%JL|6#QXU<-`!j7Fi0sz>!U=5cm4p9R$yztj5o`dU%ZCw?}cj zJ!e$6kMJ*+ekK~^uf;}ghwrS98i|Sgx`PVpC^IoC7@n187xGpV(pICQqt(AG^lm1F zza&=I$c(rcVzi?`m%S+w`H1_;D^V)B?>~MPW(bu^@GavBytC3T<-avfSU<#-FtK3E zEfBBTsQ?t~dsR*e-F(a&j><-VM7!KQ<5W|;qEL;M0s0erm0xz=WS%-K%6^m@BBKJ( z>N(wCg~rOP(`kasrN{KdOgr{XV^`{L-cJUnCmW1iteP3(uNgnPn$08L=v`t~x%V_U z*Xpeqv8-#&pHbB}2%_Kr7c{x#7#j5R3PY>LZ|aJiNEa4vuRF|*K30lC&UpPF?FP-=H?Mim~3GO87^y-z?Q)hXTSewUo@`x?-|J^@n;iSNr>iCIXYV9w)=EP zK6#$&3$G!+H1ARkO027;x1LzJK&ccWX~J#QPR;4CUCm zn;pI9HkF3|3}0%#RO{BPD-jRO$ks_Rz){rv2Zx;eDI4mGN9sH+{JmOFK_}lbJ{X*Y z99^0I41SOa*Bh+VuS5%KgvV$mK49{5t|u3HM}ORJu3ED49C|XOeRUA)?Mtt#ztrS- z`Nx%}LjR#5!{K$y%u_uCI8hwl4bhkt`eh=0yk0?S1esK^3o%{UwSc zBu`ZnwrFQm2Yi}C_RjiA;?G=gmbqAW;G2e!qbnaIZJAaET{RS&e7UhI@IkMwJ0r4d zzjK5Fzc3)$W+QfDx)Ty~m3QSans!(`D{!k_ljDZ?dshC~3t3B{k9Th4y4D~R!Rr~! zZ62Or>3L>&tLRspCCm>QZnd^>P3}3-ZEIN-JBi0oa#jRixhbG`Pgg@Ot`uHu8Z%e%+|%xm_A5y}r{q*VxL-#? m3}vYkd;EXt$2BO6&Iz#{JuqRDzApgc-*a{Cr)8=ZpZ*(VNn+yw literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/contact_sheet.png b/pylabrobot/btx/test_data/gemini_x2/screens/contact_sheet.png new file mode 100644 index 0000000000000000000000000000000000000000..e58ff52f70ab4c228fbe60104ce34a74c3530b28 GIT binary patch literal 236743 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%0AnB}5*!5QMa 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%0DTQ`w?) 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

kerCN~nU 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 literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/metadata.json b/pylabrobot/btx/test_data/gemini_x2/screens/metadata.json new file mode 100644 index 00000000000..96355131d06 --- /dev/null +++ b/pylabrobot/btx/test_data/gemini_x2/screens/metadata.json @@ -0,0 +1,167 @@ +{ + "schema_version": 2, + "description": "Selected BTX Gemini X2 RSI screen fixtures from a physical end-to-end run with GO.", + "device": { + "model": "BTX Gemini X2", + "firmware": "BTX Gemini 4.0.4" + }, + "capture": { + "kind": "physical_device_rsi_capture", + "captured_at_utc": "2026-05-26T07:42:48+00:00", + "go_pressed": true, + "plate_columns": 3, + "temporary_protocol_deleted": true, + "matched_log_path": "\\BTXDATA\\2026-05\\260526\\153650.TXT", + "notes": [ + "Screens were captured from the physical RSI framebuffer at 800x480.", + "Only selected fixture PNGs and this portable manifest are kept in the repository.", + "Raw capture paths and host-specific serial port details are intentionally omitted.", + "The Set Plate Columns flow returns protocol_details after the first confirm and protocol_run_view after the second confirm." + ] + }, + "temporary_protocol": { + "name": "!PLR_0526154053", + "protocol_type": "square", + "pulse_amplitude_volts": 250, + "gap_mm": 2.0, + "pulse_count": 1, + "pulse_interval_seconds": 0.0, + "duration_us": 1000, + "resistance_ohms": null, + "capacitance_uf": null + }, + "run_log_summary": { + "protocol_name": "!PLR_0526154053", + "protocol_type": "Square Wave", + "pulse_amplitude_volts": 250, + "plate_columns": 3, + "pulse_1_voltage_volts": 262.45, + "protocol_result": "Complete", + "status_code": "0x00000000.00000000", + "status_message": "(No error.)" + }, + "screens": [ + { + "label": "00_main_menu", + "state": "main_menu", + "confidence": 1.0, + "image": "00_main_menu.png", + "rgb_sha1": "c4566e00637c64a464d80d0f9df77f51f9b53e65", + "matched": [ + "main menu" + ] + }, + { + "label": "01_user_protocols_top", + "state": "user_protocols", + "confidence": 1.0, + "image": "01_user_protocols_top.png", + "rgb_sha1": "98c19ee5064b42a3d781edc48eccbb3a3172a138", + "matched": [ + "user protocols" + ] + }, + { + "label": "02_protocol_summary", + "state": "unknown", + "confidence": 0.0, + "image": "02_protocol_summary.png", + "rgb_sha1": "5178b2eceefa0501787ec0267ba57390efbd7d11", + "matched": [] + }, + { + "label": "03_run_protocol_prerun", + "state": "protocol_run_view", + "confidence": 0.82, + "image": "03_run_protocol_prerun.png", + "rgb_sha1": "ff5ed097b3fb46c9a3718d9314eded590e45ae9e", + "matched": [ + "run protocol", + "set meas", + "go" + ] + }, + { + "label": "04_set_plate_columns_open", + "state": "protocol_details", + "confidence": 1.0, + "image": "04_set_plate_columns_open.png", + "rgb_sha1": "0ebad043b0e09499d09ec5e54cda28621ae01967", + "matched": [ + "protocol details marker" + ] + }, + { + "label": "05_set_plate_columns_after_first_confirm", + "state": "protocol_details", + "confidence": 1.0, + "image": "05_set_plate_columns_after_first_confirm.png", + "rgb_sha1": "e766c8f9472f95aa75ed0e27deb29e34e6ab5be5", + "matched": [ + "protocol details marker" + ] + }, + { + "label": "06_set_plate_columns_confirmed_run_view", + "state": "protocol_run_view", + "confidence": 0.82, + "image": "06_set_plate_columns_confirmed_run_view.png", + "rgb_sha1": "d048afe888bc0a2f1ca0e82d586757495d652f96", + "matched": [ + "run protocol", + "set meas", + "go" + ] + }, + { + "label": "07_go_prerun", + "state": "protocol_run_view", + "confidence": 0.82, + "image": "07_go_prerun.png", + "rgb_sha1": "65db3191e1be29e0e52296a831ca60f2fe7cc5ce", + "matched": [ + "run protocol", + "set meas", + "go" + ] + }, + { + "label": "08_go_delivering_pulse", + "state": "protocol_run_view", + "confidence": 0.82, + "image": "08_go_delivering_pulse.png", + "rgb_sha1": "a476cc0f193e37a6edd336f32af7138311948376", + "matched": [ + "run protocol", + "set meas", + "delivering pulse" + ] + }, + { + "label": "09_go_pulses_delivered", + "state": "protocol_finish", + "confidence": 1.0, + "image": "09_go_pulses_delivered.png", + "rgb_sha1": "8482a5f644f1fd307b60884efa1efb053d7ced2c", + "matched": [ + "run protocol", + "pulses delivered", + "press to clear message" + ] + }, + { + "label": "10_returned_home_after_go", + "state": "main_menu", + "confidence": 1.0, + "image": "10_returned_home_after_go.png", + "rgb_sha1": "dca38d5e9c5af6fe94796017a09669d72007ef23", + "matched": [ + "main menu" + ] + } + ], + "extra_fixtures": { + "user_protocols_double_up_active": "user_protocols_double_up_active.png", + "user_protocols_double_up_inactive": "user_protocols_double_up_inactive.png" + } +} diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_active.png b/pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_active.png new file mode 100644 index 0000000000000000000000000000000000000000..16cf8cb703ec4b1355898ce44c14ec36746efe1e GIT binary patch literal 36865 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 literal 0 HcmV?d00001 diff --git a/pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_inactive.png b/pylabrobot/btx/test_data/gemini_x2/screens/user_protocols_double_up_inactive.png new file mode 100644 index 0000000000000000000000000000000000000000..194e265a28cae001b33027f365611e36889e8c1d GIT binary patch literal 36637 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 PEs!0au6{1-oD!M np.ndarray: + """Convert one Gemini RSI `scap` framebuffer into opaque RGBA pixels.""" + arr = np.frombuffer(framebuffer, dtype=np.uint8).reshape((FRAME_H, FRAME_W, 4)) + rgba = np.empty((FRAME_H, FRAME_W, 4), dtype=np.uint8) + # Live captures and the original RSI pcap previews decode correctly as BGRX/BGRA. + # The fourth byte is not a usable PNG alpha channel, so snapshots are saved opaque. + rgba[:, :, :3] = arr[:, :, [2, 1, 0]] + rgba[:, :, 3] = 255 + return rgba + + +@dataclass +class Detection: + """OCR-derived interpretation of a Gemini screen snapshot.""" + + state: str + confidence: float + matched: list[str] + text: str + text_norm: str + + +@dataclass +class Snapshot: + """Saved frame plus the screen-state detection produced from it.""" + + frame: FrameCapture + image_path: str + detection: Detection + + +@dataclass(frozen=True) +class ScreenSnapshotResult: + state: str + image_path: str + + def as_dict(self) -> dict[str, str]: + return { + "state": self.state, + "image_path": self.image_path, + } + + +@dataclass(frozen=True) +class PreparedUserProtocolResult: + protocol_name: str + plate_columns: Optional[int] + run_view: ScreenSnapshotResult + after_set_plate_columns: Optional[ScreenSnapshotResult] + prepared_verification: ScreenSnapshotResult + + def as_dict(self) -> dict[str, Any]: + result = { + "protocol_name": self.protocol_name, + "plate_columns": self.plate_columns, + "run_view": self.run_view.as_dict(), + "prepared_verification": self.prepared_verification.as_dict(), + } + if self.after_set_plate_columns is not None: + result["after_set_plate_columns"] = self.after_set_plate_columns.as_dict() + return result + + +@dataclass(frozen=True) +class StartedPreparedUserProtocolResult: + protocol_name: str + verification: ScreenSnapshotResult + after_start: ScreenSnapshotResult + completed: ScreenSnapshotResult + home: Optional[ScreenSnapshotResult] + + def as_dict(self) -> dict[str, Any]: + result = { + "protocol_name": self.protocol_name, + "verification": self.verification.as_dict(), + "after_start": self.after_start.as_dict(), + "completed": self.completed.as_dict(), + } + if self.home is not None: + result["home"] = self.home.as_dict() + return result + + +@dataclass(frozen=True) +class CancelledPreparedUserProtocolResult: + cancelled: bool + home_after: bool + final_state: ScreenSnapshotResult + + def as_dict(self) -> dict[str, Any]: + return { + "cancelled": self.cancelled, + "home_after": self.home_after, + "final_state": self.final_state.as_dict(), + } + + +class TheGhostTouch: + """Verified RSI touchscreen control for the BTX Gemini X2. + + This control intentionally supports only the user-protocol path used by the BTX end-to-end + workflow: Home -> User Protocols -> first sorted protocol -> Run Protocol -> optional plate + columns -> GO -> wait done. + """ + + def __init__( + self, + port: str, + baud: int = 115200, + artifact_dir: Optional[str] = None, + timeout: float = 15.0, + retries: int = 5, + min_conf: float = 0.70, + down_ms: int = 70, + ) -> None: + self.port = port + self.baud = baud + self.timeout = timeout + self.retries = retries + self.min_conf = min_conf + self.down_ms = down_ms + if artifact_dir is None: + artifact_dir = str(Path(tempfile.gettempdir()) / "pylabrobot-btx-the-ghost-touch") + self.artifact_dir = artifact_dir + self._transport = _RSITransport(port=port, baud=baud, timeout=timeout, retries=retries) + self._detector = _GeminiScreenDetector(min_conf=min_conf) + self.ser: serial.Serial | None = None + + def __enter__(self) -> "TheGhostTouch": + """Open the RSI serial session.""" + self._require_dependencies() + self._get_transport().open() + self.ser = self._get_transport().ser + return self + + def __exit__(self, exc_type, exc, tb) -> None: + """Close the RSI serial session.""" + self._get_transport().close() + self.ser = None + + def _require_dependencies(self) -> None: + if not _HAS_SERIAL: + raise RuntimeError( + "pyserial is required for TheGhostTouch. Install with: pip install pylabrobot[btx]. " + f"Import error: {_SERIAL_IMPORT_ERROR}" + ) + if not _HAS_NUMPY: + raise RuntimeError( + "numpy is required for TheGhostTouch frame handling. Install with: pip install pylabrobot[btx]. " + f"Import error: {_NUMPY_IMPORT_ERROR}" + ) + if not _HAS_PIL: + raise RuntimeError( + "Pillow is required for TheGhostTouch image handling. Install with: pip install pylabrobot[btx]. " + f"Import error: {_PIL_IMPORT_ERROR}" + ) + if shutil.which("tesseract") is None: + raise RuntimeError( + "TheGhostTouch requires the external `tesseract` command for OCR. " + "Install the Python dependencies with `pip install pylabrobot[btx]`, then install " + "Tesseract for your operating system and make the `tesseract` command available on PATH." + ) + + def _get_transport(self) -> _RSITransport: + transport = getattr(self, "_transport", None) + if transport is None: + transport = _RSITransport( + port=self.port, + baud=self.baud, + timeout=self.timeout, + retries=self.retries, + ) + self._transport = transport + return cast(_RSITransport, transport) + + def _get_detector(self) -> _GeminiScreenDetector: + detector = getattr(self, "_detector", None) + if detector is None: + detector = _GeminiScreenDetector(min_conf=self.min_conf) + self._detector = detector + return cast(_GeminiScreenDetector, detector) + + def prepare_user_protocol( + self, + protocol_name: str, + plate_columns: Optional[int] = None, + ) -> PreparedUserProtocolResult: + """Navigate to ``Run Protocol`` and optionally configure HT-200 plate columns.""" + run_view = self.goto_user_protocol_run_view(protocol_name) + after_set_plate_columns: ScreenSnapshotResult | None = None + if plate_columns is not None: + after_columns = self.set_plate_columns(plate_columns) + after_set_plate_columns = self._snapshot_result(after_columns) + + verified = self.verify_prepared_user_protocol(protocol_name) + return PreparedUserProtocolResult( + protocol_name=protocol_name, + plate_columns=plate_columns, + run_view=self._snapshot_result(run_view), + after_set_plate_columns=after_set_plate_columns, + prepared_verification=self._snapshot_result(verified), + ) + + def start_prepared_user_protocol( + self, + protocol_name: str, + home_after: bool = True, + max_run_seconds: float = 420.0, + ) -> StartedPreparedUserProtocolResult: + """Verify the armed screen, press ``GO``, wait until done, and optionally return home.""" + verified = self.verify_prepared_user_protocol(protocol_name) + start = self.start_run() + done = self.wait_run_done(max_seconds=max_run_seconds) + home = None if not home_after else self.ensure_home() + + return StartedPreparedUserProtocolResult( + protocol_name=protocol_name, + verification=self._snapshot_result(verified), + after_start=self._snapshot_result(start), + completed=self._snapshot_result(done), + home=None if home is None else self._snapshot_result(home), + ) + + def cancel_prepared_user_protocol( + self, home_after: bool = True + ) -> CancelledPreparedUserProtocolResult: + """Leave the prepared UI state without starting electroporation.""" + home = self.ensure_home() if home_after else self.snapshot("cancel-prepared-current") + return CancelledPreparedUserProtocolResult( + cancelled=True, + home_after=home_after, + final_state=self._snapshot_result(home), + ) + + def ensure_home(self) -> Snapshot: + """Return the Gemini UI to ``Main Menu`` using the fixed Home control.""" + current = self.snapshot("ensure-home-start") + if current.detection.state == STATE_MAIN_MENU and current.detection.confidence >= self.min_conf: + return current + if current.detection.state == STATE_PROTOCOL_DETAILS: + current = self._close_protocol_details(current) + if ( + current.detection.state == STATE_MAIN_MENU and current.detection.confidence >= self.min_conf + ): + return current + + for idx in range(6): + snap = self.tap_and_wait( + HOME_COORD[0], + HOME_COORD[1], + expected_states={STATE_MAIN_MENU}, + timeout=6.0, + interval=0.4, + prefix=f"ensure-home-{idx}", + ) + if snap is not None: + return snap + + raise RuntimeError("Failed to reach Main Menu via Home.") + + def _close_protocol_details(self, current: Snapshot) -> Snapshot: + """Close the protocol-details modal before trying fixed-position Home.""" + if current.detection.state != STATE_PROTOCOL_DETAILS: + return current + + for attempt in range(3): + closed = self.tap_and_wait( + SET_COLUMNS_CHECK_COORD[0], + SET_COLUMNS_CHECK_COORD[1], + expected_states={STATE_PROTOCOL_RUN_VIEW, STATE_PROTOCOL_DETAILS}, + timeout=8.0, + interval=0.45, + prefix=f"close-protocol-details-{attempt}", + down_ms=max(self.down_ms, 90), + initial_delay=0.4, + ) + if closed is None: + raise RuntimeError("Lost screen state while closing Protocol Details.") + current = closed + if current.detection.state == STATE_PROTOCOL_RUN_VIEW: + return current + + raise RuntimeError("Failed to close Protocol Details.") + + def goto_user_protocol_run_view(self, protocol_name: str) -> Snapshot: + """Open the first sorted user protocol and reach its ``Run Protocol`` screen.""" + current = self.snapshot("goto-user-run-start") + if current.detection.state == STATE_PROTOCOL_RUN_VIEW: + if self._run_view_matches_protocol(current.image_path, protocol_name) is not False: + return current + + last_error = "not attempted" + for attempt in range(3): + if current.detection.state != STATE_MAIN_MENU: + current = self.ensure_home() + if current.detection.state != STATE_MAIN_MENU: + raise RuntimeError(f"Expected Main Menu, got {current.detection.state}.") + + try: + current = self._open_user_protocols(attempt) + current = self._select_first_user_protocol(attempt) + current = self._confirm_user_protocol_summary(current, protocol_name, attempt) + self._verify_run_view_protocol(current, protocol_name) + except RuntimeError as exc: + last_error = str(exc) + current = self.ensure_home() + time.sleep(1.0) + continue + return current + + raise RuntimeError(f"Failed to reach Run Protocol for '{protocol_name}': {last_error}") + + def set_plate_columns(self, columns: int) -> Snapshot: + """Open ``Set Plate Columns`` and confirm the requested HT-200 column count.""" + if not 0 <= columns <= 12: + raise RuntimeError("plate_columns must be in the range 0..12.") + + current = self.snapshot("set-cols-start") + if current.detection.state != STATE_PROTOCOL_RUN_VIEW: + raise RuntimeError(f"Expected Run Protocol view, got {current.detection.state}.") + + opened = self.tap_and_wait( + SET_COLUMNS_OPEN_COORD[0], + SET_COLUMNS_OPEN_COORD[1], + expected_states={STATE_PROTOCOL_DETAILS}, + timeout=8.0, + interval=0.45, + prefix="set-cols-open", + down_ms=max(self.down_ms, 80), + ) + if opened is None: + raise RuntimeError("Failed to open Set Plate Columns.") + + self._enter_set_columns_value(columns) + closed = self.tap_and_wait( + SET_COLUMNS_CHECK_COORD[0], + SET_COLUMNS_CHECK_COORD[1], + expected_states={STATE_PROTOCOL_RUN_VIEW, STATE_PROTOCOL_DETAILS}, + timeout=8.0, + interval=0.45, + prefix="set-cols-check", + down_ms=max(self.down_ms, 90), + ) + if closed is not None and closed.detection.state == STATE_PROTOCOL_RUN_VIEW: + return closed + if closed is None or closed.detection.state != STATE_PROTOCOL_DETAILS: + raise RuntimeError("Unexpected state after first Set Plate Columns confirm.") + + confirmed = self.tap_and_wait( + SET_COLUMNS_CHECK_COORD[0], + SET_COLUMNS_CHECK_COORD[1], + expected_states={STATE_PROTOCOL_RUN_VIEW, STATE_PROTOCOL_DETAILS}, + timeout=8.0, + interval=0.45, + prefix="set-cols-check-confirm", + down_ms=max(self.down_ms, 90), + ) + if confirmed is not None and confirmed.detection.state == STATE_PROTOCOL_RUN_VIEW: + return confirmed + raise RuntimeError("Second Set Plate Columns confirm did not return to Run Protocol.") + + def verify_prepared_user_protocol(self, protocol_name: str) -> Snapshot: + """Confirm that the current screen is the expected pre-run view for ``protocol_name``.""" + last_reason = "unknown" + for attempt in range(3): + snap = self.snapshot(f"verify-prepared-{attempt}") + if snap.detection.state != STATE_PROTOCOL_RUN_VIEW: + last_reason = f"Expected Run Protocol view, got {snap.detection.state}." + time.sleep(0.35) + continue + + protocol_match = self._run_view_matches_protocol(snap.image_path, protocol_name) + if protocol_match is False: + header = self._get_detector().run_header_text(snap.image_path).strip() + raise RuntimeError( + f"Prepared run screen does not match protocol '{protocol_name}'. header='{header}'" + ) + if protocol_match is None: + last_reason = "Could not verify the protocol header on the prepared run screen." + time.sleep(0.35) + continue + + if not self._get_detector().looks_prerun(snap.detection): + last_reason = "Run screen is not in the pre-run state." + time.sleep(0.35) + continue + + return snap + + raise RuntimeError(f"Prepared run verification failed for '{protocol_name}': {last_reason}") + + def start_run(self) -> Snapshot: + """Press ``GO`` from the prepared run screen and wait for visible run start feedback.""" + before = self.snapshot("run-start-before-go") + if before.detection.state != STATE_PROTOCOL_RUN_VIEW: + raise RuntimeError(f"Expected Run Protocol view before GO, got {before.detection.state}.") + + self.tap(GO_COORD[0], GO_COORD[1], down_ms=90) + after = self.wait_for_states( + states={STATE_PROTOCOL_RUN_VIEW, STATE_PROTOCOL_RAN, STATE_PROTOCOL_FINISH, STATE_UNKNOWN}, + timeout=8.0, + interval=0.45, + prefix="run-start-after-go", + ) + if after is None: + raise RuntimeError("No visible response after GO.") + if self._get_detector().is_run_done(after.detection): + return after + + if self._get_detector().has_confirm_dialog( + after.detection + ) or self._get_detector().looks_prerun(after.detection): + self.tap(GO_COORD[0], GO_COORD[1], down_ms=90) + after_confirm = self.wait_for_states( + states={STATE_PROTOCOL_RUN_VIEW, STATE_PROTOCOL_RAN, STATE_PROTOCOL_FINISH, STATE_UNKNOWN}, + timeout=8.0, + interval=0.45, + prefix="run-start-after-confirm", + ) + if after_confirm is not None: + return after_confirm + + return after + + def wait_run_done(self, max_seconds: float) -> Snapshot: + """Poll the RSI screen until the run has finished.""" + deadline = time.time() + max_seconds + idx = 0 + while time.time() < deadline: + snap = self.snapshot(f"run-wait-{idx:02d}") + if self._get_detector().is_run_done(snap.detection): + return snap + idx += 1 + time.sleep(0.7) + raise TimeoutError(f"Timed out waiting for run completion after {max_seconds} seconds.") + + def read_frame(self) -> FrameCapture: + """Read one full RGB frame from the RSI ``scap`` stream.""" + return self._get_transport().read_frame() + + def _save_frame(self, frame: FrameCapture, prefix: str) -> str: + os.makedirs(self.artifact_dir, exist_ok=True) + path = os.path.join(self.artifact_dir, f"{prefix}-{time.strftime('%Y%m%d-%H%M%S')}.png") + Image.fromarray(frame.rgba, mode="RGBA").save(path) + return path + + def snapshot(self, prefix: str) -> Snapshot: + """Capture a frame, save it, OCR it, and classify the current screen state.""" + frame = self.read_frame() + image_path = self._save_frame(frame, prefix) + detection = self._get_detector().classify_image(image_path) + return Snapshot(frame=frame, image_path=image_path, detection=detection) + + def tap(self, x: int, y: int, down_ms: Optional[int] = None) -> None: + """Send one touchscreen tap at the given screen coordinate.""" + hold = self.down_ms if down_ms is None else down_ms + self._get_transport().tap(x, y, hold_ms=hold) + + def wait_for_states( + self, + states: set[str], + timeout: float, + interval: float, + prefix: str, + initial_delay: float = 0.0, + ) -> Snapshot | None: + """Poll screenshots until one of the expected screen states is visible.""" + deadline = time.time() + timeout + idx = 0 + if initial_delay > 0: + time.sleep(initial_delay) + while time.time() < deadline: + snap = self.snapshot(f"{prefix}-{idx:02d}") + if snap.detection.state in states and snap.detection.confidence >= self.min_conf: + return snap + idx += 1 + time.sleep(interval) + return None + + def tap_and_wait( + self, + x: int, + y: int, + expected_states: set[str], + timeout: float, + interval: float, + prefix: str, + down_ms: Optional[int] = None, + initial_delay: float = 1.0, + ) -> Snapshot | None: + """Tap a fixed control and wait for one of the expected states.""" + self.tap(x, y, down_ms=down_ms) + return self.wait_for_states( + expected_states, + timeout=timeout, + interval=interval, + prefix=prefix, + initial_delay=initial_delay, + ) + + def _summary_matches_protocol(self, image_path: str, protocol_name: str) -> bool | None: + return self._get_detector().summary_matches_protocol(image_path, protocol_name) + + def _run_view_matches_protocol(self, image_path: str, protocol_name: str) -> bool | None: + return self._get_detector().run_view_matches_protocol(image_path, protocol_name) + + def _scroll_user_protocols_to_top(self, current: Snapshot) -> Snapshot: + if current.detection.state != STATE_USER_PROTOCOLS: + raise RuntimeError(f"Expected User Protocols screen, got {current.detection.state}.") + if self._get_detector().user_protocols_at_top(current): + return current + + for attempt in range(8): + next_snapshot = self.tap_and_wait( + USER_PROTOCOLS_SCROLL_DOUBLE_UP_COORD[0], + USER_PROTOCOLS_SCROLL_DOUBLE_UP_COORD[1], + expected_states={STATE_USER_PROTOCOLS}, + timeout=6.0, + interval=0.45, + prefix=f"user-top-{attempt}", + down_ms=max(self.down_ms, 80), + ) + if next_snapshot is None: + raise RuntimeError("Lost User Protocols screen while scrolling to top.") + current = next_snapshot + if self._get_detector().user_protocols_at_top(current): + return current + + raise RuntimeError("Failed to reach the top of User Protocols.") + + def _open_user_protocols(self, attempt: int) -> Snapshot: + current = self.tap_and_wait( + USER_PROTOCOLS_MENU_COORD[0], + USER_PROTOCOLS_MENU_COORD[1], + expected_states={STATE_USER_PROTOCOLS}, + timeout=8.0, + interval=0.45, + prefix=f"goto-user-protocols-{attempt}", + down_ms=max(self.down_ms, 80), + ) + if current is None: + raise RuntimeError("Failed to open User Protocols.") + return self._scroll_user_protocols_to_top(current) + + def _select_first_user_protocol(self, attempt: int) -> Snapshot: + self.tap( + USER_PROTOCOLS_FIRST_ROW_COORD[0], + USER_PROTOCOLS_FIRST_ROW_COORD[1], + down_ms=max(self.down_ms, 80), + ) + time.sleep(1.0) + current = self.snapshot(f"goto-user-first-row-selected-{attempt}") + detector = self._get_detector() + if current.detection.state == STATE_USER_PROTOCOLS: + self.tap( + DETAIL_CONFIRM_COORD[0], + DETAIL_CONFIRM_COORD[1], + down_ms=max(self.down_ms, 80), + ) + time.sleep(1.0) + current = self.snapshot(f"goto-user-summary-{attempt}-00") + if ( + current.detection.state != STATE_PROTOCOL_RUN_VIEW + and not detector.looks_user_protocol_summary(current.detection) + ): + time.sleep(0.45) + current = self.snapshot(f"goto-user-summary-{attempt}-01") + elif ( + current.detection.state != STATE_PROTOCOL_RUN_VIEW + and not detector.looks_user_protocol_summary(current.detection) + ): + time.sleep(0.45) + current = self.snapshot(f"goto-user-summary-{attempt}-01") + return current + + def _confirm_user_protocol_summary( + self, + current: Snapshot, + protocol_name: str, + attempt: int, + ) -> Snapshot: + detector = self._get_detector() + if ( + current.detection.state != STATE_PROTOCOL_RUN_VIEW + and not detector.looks_user_protocol_summary(current.detection) + ): + raise RuntimeError("Failed to open the selected user protocol summary.") + + if current.detection.state == STATE_PROTOCOL_RUN_VIEW: + return current + + summary_match = self._summary_matches_protocol(current.image_path, protocol_name) + if summary_match is False: + header = detector.summary_header_text(current.image_path).strip() + raise RuntimeError( + f"Summary header does not match target protocol '{protocol_name}'. header='{header}'" + ) + + next_snapshot = self.tap_and_wait( + DETAIL_CONFIRM_COORD[0], + DETAIL_CONFIRM_COORD[1], + expected_states={STATE_PROTOCOL_RUN_VIEW}, + timeout=8.0, + interval=0.45, + prefix=f"goto-user-summary-confirm-{attempt}", + down_ms=max(self.down_ms, 80), + ) + if next_snapshot is None: + raise RuntimeError("Failed to reach Run Protocol from the user protocol summary.") + return next_snapshot + + def _verify_run_view_protocol(self, current: Snapshot, protocol_name: str) -> None: + protocol_match = self._run_view_matches_protocol(current.image_path, protocol_name) + if protocol_match is False: + header = self._get_detector().run_header_text(current.image_path).strip() + raise RuntimeError( + f"Run header does not match target protocol '{protocol_name}'. header='{header}'" + ) + + def _tap_set_columns_key(self, key: str, pause_s: float = 0.08) -> None: + if key not in SET_COLUMNS_KEY_COORDS: + raise RuntimeError(f"Unsupported Set Plate Columns keypad key '{key}'.") + x, y = SET_COLUMNS_KEY_COORDS[key] + self.tap(x, y, down_ms=max(self.down_ms, 70)) + time.sleep(pause_s) + + def _enter_set_columns_value(self, columns: int) -> None: + for _ in range(4): + self._tap_set_columns_key("delete") + for digit in str(columns): + self._tap_set_columns_key(digit) + time.sleep(0.04) + + def _snapshot_result(self, snap: Snapshot) -> ScreenSnapshotResult: + return ScreenSnapshotResult( + state=snap.detection.state, + image_path=snap.image_path, + ) + + +@runtime_checkable +class _AsyncSerialLike(Protocol): + async def setup(self) -> None: + pass + + async def stop(self) -> None: + pass + + async def write(self, data: bytes) -> None: + pass + + async def read(self, num_bytes: int = 1) -> bytes: + pass + + async def reset_input_buffer(self) -> None: + pass + + +class _RSITransport: + """RSI transport built on PLR Serial plus Gemini-specific frame handling.""" + + READ_CHUNK_BYTES = 8192 + + def __init__( + self, + port: str, + baud: int, + timeout: float, + retries: int, + serial_io: Optional[_AsyncSerialLike] = None, + ) -> None: + self.port = port + self.baud = baud + self.timeout = timeout + self.retries = retries + self._serial = serial_io or Serial( + human_readable_device_name="BTX Gemini X2 TheGhostTouch", + port=port, + baudrate=baud, + timeout=0.05, + ) + self._loop: asyncio.AbstractEventLoop | None = None + self._loop_thread: threading.Thread | None = None + self.ser: Any | None = None + + def open(self) -> None: + if self._loop is not None: + return + + ready = threading.Event() + transport = self + + def _loop_main() -> None: + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + transport._loop = loop + ready.set() + loop.run_forever() + pending = asyncio.all_tasks(loop) + for task in pending: + task.cancel() + if pending: + loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True)) + loop.close() + + self._loop_thread = threading.Thread( + target=_loop_main, + name="TheGhostTouch-RSITransport", + daemon=True, + ) + self._loop_thread.start() + ready.wait() + self._run(self._serial.setup()) + self.ser = self._serial + + def close(self) -> None: + if self._loop is None: + self.ser = None + return + + try: + self._run(self._serial.stop()) + finally: + loop = self._loop + thread = self._loop_thread + self._loop = None + self._loop_thread = None + self.ser = None + if loop is not None: + loop.call_soon_threadsafe(loop.stop) + if thread is not None: + thread.join(timeout=2.0) + + def _run(self, awaitable: Any) -> Any: + if self._loop is None: + raise RuntimeError("TheGhostTouch serial session is not open.") + future = asyncio.run_coroutine_threadsafe(awaitable, self._loop) + return future.result() + + def ensure_open(self) -> _AsyncSerialLike: + if self._loop is None: + raise RuntimeError("TheGhostTouch serial session is not open.") + return self._serial + + def drain_input(self, seconds: float = 0.12) -> int: + del seconds + self._run(self.ensure_open().reset_input_buffer()) + return 0 + + def write_line(self, line: str) -> None: + self._run(self.ensure_open().write(line.encode("ascii") + b"\r")) + + def _read_frame_once(self) -> FrameCapture: + self.ensure_open() + self.drain_input(0.12) + self.write_line("echo off") + time.sleep(0.03) + self._run(self._serial.reset_input_buffer()) + self.write_line("scap") + + buf = bytearray() + t0 = time.time() + while time.time() - t0 < self.timeout: + chunk = self._run(self._serial.read(self.READ_CHUNK_BYTES)) + if chunk: + buf.extend(chunk) + else: + time.sleep(0.01) + + if len(buf) < FRAME_BYTES + 1: + continue + + end = buf.rfind(b":") + if end >= FRAME_BYTES: + fb = bytes(buf[end - FRAME_BYTES : end]) + rgba = _decode_rsi_framebuffer(fb) + stable = rgba[0:160, 0:430, :] + return FrameCapture( + rgba=rgba, + raw_len=len(buf), + frame_sha1=hashlib.sha1(fb).hexdigest(), + stable_sha1=hashlib.sha1(stable.tobytes()).hexdigest(), + ) + + raise TimeoutError(f"Failed to read full scap frame, collected {len(buf)} bytes") + + def read_frame(self) -> FrameCapture: + last_err: Exception | None = None + for _ in range(self.retries): + try: + return self._read_frame_once() + except Exception as exc: # pragma: no cover - live hardware path + last_err = exc + self.drain_input(0.15) + time.sleep(0.06) + assert last_err is not None + raise last_err + + def tap(self, x: int, y: int, hold_ms: int) -> None: + self.write_line(f"@key {x} {y}") + time.sleep(hold_ms / 1000.0) + self.write_line("@key") + + +class _GeminiScreenDetector: + """OCR and state classification for Gemini RSI screenshots.""" + + def __init__(self, min_conf: float) -> None: + self.min_conf = min_conf + + def ocr_text(self, image_path: str, psm: int) -> str: + try: + out = subprocess.check_output( + ["tesseract", image_path, "stdout", "--psm", str(psm)], + stderr=subprocess.DEVNULL, + text=True, + ) + except Exception: + return "" + return "\n".join([ln.strip() for ln in out.splitlines() if ln.strip()]) + + def normalize_text(self, text: str) -> str: + lowered = text.lower() + lowered = lowered.replace("geminix2", "gemini x2") + lowered = lowered.replace("protocois", "protocols") + lowered = lowered.replace("protocals", "protocols") + lowered = lowered.replace("protocal", "protocol") + lowered = re.sub(r"[^a-z0-9]+", " ", lowered) + return re.sub(r"\s+", " ", lowered).strip() + + def contains_marker(self, text_norm: str, marker: str) -> bool: + marker_norm = self.normalize_text(marker) + if not marker_norm: + return False + if marker_norm in text_norm: + return True + return marker_norm.replace(" ", "") in text_norm.replace(" ", "") + + def detect_state(self, text: str) -> Detection: + normalized = self.normalize_text(text) + + if self.contains_marker(normalized, "main menu"): + return Detection(STATE_MAIN_MENU, 1.0, ["main menu"], text, normalized) + + if self.contains_marker(normalized, "run protocol"): + if self.contains_marker(normalized, "pulses delivered"): + finish_markers = [] + for marker in ("press to clear message", "run complete", "finished", "completed"): + if self.contains_marker(normalized, marker): + finish_markers.append(marker) + if finish_markers: + return Detection( + STATE_PROTOCOL_FINISH, + 1.0, + ["run protocol", "pulses delivered", *finish_markers], + text, + normalized, + ) + return Detection( + STATE_PROTOCOL_RAN, 0.9, ["run protocol", "pulses delivered"], text, normalized + ) + + markers = ["run protocol"] + for marker in ("set meas", "go", "delivering pulse", "in progress", "current column", "stop"): + if self.contains_marker(normalized, marker): + markers.append(marker) + confidence = min(1.0, 0.70 + 0.06 * (len(markers) - 1)) + return Detection(STATE_PROTOCOL_RUN_VIEW, confidence, markers, text, normalized) + + if ( + self.contains_marker(normalized, "set plate columns") + or self.contains_marker(normalized, "set the plate handler") + or self.contains_marker(normalized, "number of columns") + or self.contains_marker(normalized, "protocol details") + ): + return Detection(STATE_PROTOCOL_DETAILS, 1.0, ["protocol details marker"], text, normalized) + + if self.contains_marker(normalized, "user protocols"): + return Detection(STATE_USER_PROTOCOLS, 1.0, ["user protocols"], text, normalized) + + return Detection(STATE_UNKNOWN, 0.0, [], text, normalized) + + def classify_image(self, image_path: str) -> Detection: + text = self.ocr_text(image_path, psm=6) + detection = self.detect_state(text) + if detection.state == STATE_UNKNOWN or detection.confidence < self.min_conf: + sparse = self.ocr_text(image_path, psm=11) + if sparse: + merged = "\n".join(part for part in [text, sparse] if part) + detection = self.detect_state(merged) + return detection + + def crop_ocr_text(self, image_path: str, bbox: tuple[int, int, int, int], psm: int) -> str: + temp_path = "" + try: + with Image.open(image_path) as img: + crop = img.crop(bbox) + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp: + temp_path = tmp.name + crop.save(temp_path) + return self.ocr_text(temp_path, psm=psm) + finally: + if temp_path and os.path.exists(temp_path): + os.unlink(temp_path) + + def summary_header_text(self, image_path: str) -> str: + return self.crop_ocr_text(image_path, (10, 10, 360, 130), psm=11) + + def run_header_text(self, image_path: str) -> str: + return self.crop_ocr_text(image_path, (10, 80, 350, 170), psm=11) + + def summary_matches_protocol(self, image_path: str, protocol_name: str) -> bool | None: + header_norm = self.normalize_text(self.summary_header_text(image_path)) + if not header_norm: + return None + target_norm = self.normalize_text(protocol_name) + if not target_norm: + return None + return target_norm.replace(" ", "") in header_norm.replace(" ", "") + + def run_view_matches_protocol(self, image_path: str, protocol_name: str) -> bool | None: + header_norm = self.normalize_text(self.run_header_text(image_path)) + if not header_norm: + return None + target_norm = self.normalize_text(protocol_name) + if not target_norm: + return None + return target_norm.replace(" ", "") in header_norm.replace(" ", "") + + def looks_user_protocol_summary(self, detection: Detection) -> bool: + if self.contains_marker(detection.text_norm, "set protocol"): + return False + if self.contains_marker(detection.text_norm, "run protocol"): + return False + markers = ( + "square wave", + "exponential decay", + "voltage", + "duration", + "number of pulses", + "pulse interval", + "electrode gap", + "resistance", + "capacitance", + ) + hits = sum(1 for marker in markers if self.contains_marker(detection.text_norm, marker)) + return hits >= 3 + + def user_protocols_double_up_active(self, image_path: str) -> bool: + with Image.open(image_path) as img: + crop = np.array(img.crop(USER_PROTOCOLS_DOUBLE_UP_BBOX).convert("RGB")) + active_pixels = ((crop[:, :, 1] >= 180) & (crop[:, :, 2] >= 180)).sum() + return int(active_pixels) >= 80 + + def user_protocols_at_top(self, snap: Snapshot) -> bool: + # "New Protocol" stays visible even when scrolled, so top-of-list is keyed off the + # double-up control becoming grey/inactive. + return not self.user_protocols_double_up_active(snap.image_path) + + def has_confirm_dialog(self, detection: Detection) -> bool: + return any( + self.contains_marker(detection.text_norm, marker) + for marker in ("are you sure", "confirm", "yes", "no") + ) + + def looks_prerun(self, detection: Detection) -> bool: + if detection.state != STATE_PROTOCOL_RUN_VIEW: + return False + return ( + self.contains_marker(detection.text_norm, "set meas") + and self.contains_marker(detection.text_norm, "go") + and not self.contains_marker(detection.text_norm, "delivering pulse") + and not self.contains_marker(detection.text_norm, "pulses delivered") + ) + + def is_run_done(self, detection: Detection) -> bool: + return detection.state in {STATE_PROTOCOL_RAN, STATE_PROTOCOL_FINISH} or self.contains_marker( + detection.text_norm, "pulses delivered" + ) diff --git a/pylabrobot/btx/the_ghost_touch_tests.py b/pylabrobot/btx/the_ghost_touch_tests.py new file mode 100644 index 00000000000..08a21520a8a --- /dev/null +++ b/pylabrobot/btx/the_ghost_touch_tests.py @@ -0,0 +1,407 @@ +import json +from pathlib import Path +import shutil +import unittest +from typing import Optional, cast +from unittest.mock import patch + +import pytest + +pytest.importorskip("numpy") +pytest.importorskip("PIL") +pytest.importorskip("serial") + +from pylabrobot.btx.the_ghost_touch import ( + Detection, + FRAME_BYTES, + FRAME_H, + FRAME_W, + FrameCapture, + _RSITransport, + _GeminiScreenDetector, + _decode_rsi_framebuffer, + Snapshot, + STATE_MAIN_MENU, + STATE_PROTOCOL_DETAILS, + STATE_PROTOCOL_FINISH, + STATE_PROTOCOL_RUN_VIEW, + STATE_UNKNOWN, + STATE_USER_PROTOCOLS, + TheGhostTouch, +) + +SCREEN_FIXTURES = Path(__file__).parent / "test_data/gemini_x2/screens" + + +class _FakeAsyncSerial: + def __init__(self, reads: Optional[list[bytes]] = None): + self.reads: list[bytes] = list(reads or []) + self.writes: list[bytes] = [] + self.setup_calls = 0 + self.stop_calls = 0 + self.reset_calls = 0 + + async def setup(self) -> None: + self.setup_calls += 1 + + async def stop(self) -> None: + self.stop_calls += 1 + + async def write(self, data: bytes) -> None: + self.writes.append(data) + + async def read(self, num_bytes: int = 1) -> bytes: + del num_bytes + if not self.reads: + return b"" + return self.reads.pop(0) + + async def reset_input_buffer(self) -> None: + self.reset_calls += 1 + + +class _TestGhostTouch(TheGhostTouch): + def __init__(self) -> None: + self.port = "/dev/test" + self.baud = 115200 + self.timeout = 15.0 + self.retries = 1 + self.min_conf = 0.70 + self.down_ms = 70 + self.artifact_dir = "/tmp" + self.ser = None + self._snapshots: list[Snapshot] = [] + self.taps: list[tuple[int, int, Optional[int]]] = [] + + def queue_snapshot( + self, state: str, text: str = "", text_norm: str = "", image_path: str = "img" + ) -> None: + detection = Detection( + state=state, + confidence=1.0 if state != STATE_UNKNOWN else 0.0, + matched=[], + text=text, + text_norm=text_norm or text, + ) + self._snapshots.append( + Snapshot(frame=cast(FrameCapture, None), image_path=image_path, detection=detection) + ) + + def snapshot(self, prefix: str) -> Snapshot: + del prefix + if not self._snapshots: + raise AssertionError("No queued snapshots left") + return self._snapshots.pop(0) + + def tap(self, x: int, y: int, down_ms=None) -> None: + self.taps.append((x, y, down_ms)) + + def tap_and_wait( + self, + x: int, + y: int, + expected_states, + timeout, + interval, + prefix, + down_ms=None, + initial_delay=1.0, + ): + del expected_states, timeout, interval, prefix, initial_delay + self.taps.append((x, y, down_ms)) + return self.snapshot("tap-and-wait") + + def _scroll_user_protocols_to_top(self, current: Snapshot) -> Snapshot: + return current + + def _summary_matches_protocol(self, image_path: str, protocol_name: str): + del image_path, protocol_name + return True + + def _run_view_matches_protocol(self, image_path: str, protocol_name: str): + del image_path, protocol_name + return True + + +class TestTheGhostTouch(unittest.TestCase): + def _fixture_protocol_name(self) -> str: + metadata = json.loads((SCREEN_FIXTURES / "metadata.json").read_text()) + return str(metadata["temporary_protocol"]["name"]) + + def test_require_dependencies_reports_missing_tesseract(self): + touch = TheGhostTouch(port="/dev/test") + + with patch("pylabrobot.btx.the_ghost_touch.shutil.which", return_value=None): + with self.assertRaisesRegex(RuntimeError, "external `tesseract` command"): + touch._require_dependencies() + + def test_decode_rsi_framebuffer_uses_bgrx_pixels_and_opaque_alpha(self): + framebuffer = bytes((12, 34, 56, 0)) * (FRAME_W * FRAME_H) + + rgba = _decode_rsi_framebuffer(framebuffer) + + self.assertEqual(rgba.shape, (FRAME_H, FRAME_W, 4)) + self.assertEqual(rgba[0, 0].tolist(), [56, 34, 12, 255]) + self.assertEqual(int(rgba[:, :, 3].min()), 255) + self.assertEqual(int(rgba[:, :, 3].max()), 255) + + def test_rsi_transport_reads_bgrx_frame_via_shared_serial_interface(self): + framebuffer = bytes((12, 34, 56, 0)) * (FRAME_W * FRAME_H) + fake = _FakeAsyncSerial(reads=[framebuffer[:900000], framebuffer[900000:] + b":"]) + transport = _RSITransport( + port="/dev/test", + baud=115200, + timeout=0.2, + retries=1, + serial_io=fake, + ) + + transport.open() + try: + frame = transport.read_frame() + finally: + transport.close() + + self.assertEqual(fake.setup_calls, 1) + self.assertEqual(fake.stop_calls, 1) + self.assertGreaterEqual(fake.reset_calls, 2) + self.assertEqual(fake.writes[:2], [b"echo off\r", b"scap\r"]) + self.assertEqual(frame.raw_len, FRAME_BYTES + 1) + self.assertEqual(frame.rgba.shape, (FRAME_H, FRAME_W, 4)) + self.assertEqual(frame.rgba[0, 0].tolist(), [56, 34, 12, 255]) + + def test_user_protocols_top_detector_uses_double_up_arrow_state(self): + detector = _GeminiScreenDetector(min_conf=0.70) + + self.assertTrue( + detector.user_protocols_double_up_active( + str(SCREEN_FIXTURES / "user_protocols_double_up_active.png") + ) + ) + self.assertFalse( + detector.user_protocols_double_up_active( + str(SCREEN_FIXTURES / "user_protocols_double_up_inactive.png") + ) + ) + + @pytest.mark.skipif(shutil.which("tesseract") is None, reason="requires tesseract OCR") + def test_selected_screen_fixtures_match_detector_states(self): + detector = _GeminiScreenDetector(min_conf=0.70) + cases = ( + ("00_main_menu.png", STATE_MAIN_MENU), + ("01_user_protocols_top.png", STATE_USER_PROTOCOLS), + ("02_protocol_summary.png", STATE_UNKNOWN), + ("03_run_protocol_prerun.png", STATE_PROTOCOL_RUN_VIEW), + ("04_set_plate_columns_open.png", STATE_PROTOCOL_DETAILS), + ("05_set_plate_columns_after_first_confirm.png", STATE_PROTOCOL_DETAILS), + ("06_set_plate_columns_confirmed_run_view.png", STATE_PROTOCOL_RUN_VIEW), + ("07_go_prerun.png", STATE_PROTOCOL_RUN_VIEW), + ("08_go_delivering_pulse.png", STATE_PROTOCOL_RUN_VIEW), + ("09_go_pulses_delivered.png", STATE_PROTOCOL_FINISH), + ("10_returned_home_after_go.png", STATE_MAIN_MENU), + ) + + for filename, expected_state in cases: + with self.subTest(filename=filename): + detection = detector.classify_image(str(SCREEN_FIXTURES / filename)) + + self.assertEqual(detection.state, expected_state) + if expected_state != STATE_UNKNOWN: + self.assertGreaterEqual(detection.confidence, 0.70) + + @pytest.mark.skipif(shutil.which("tesseract") is None, reason="requires tesseract OCR") + def test_selected_screen_fixtures_cover_protocol_name_crops(self): + detector = _GeminiScreenDetector(min_conf=0.70) + protocol_name = self._fixture_protocol_name() + + summary = detector.classify_image(str(SCREEN_FIXTURES / "02_protocol_summary.png")) + + self.assertTrue(detector.looks_user_protocol_summary(summary)) + self.assertTrue( + detector.summary_matches_protocol( + str(SCREEN_FIXTURES / "02_protocol_summary.png"), protocol_name + ) + ) + run_view_fixtures = ( + "03_run_protocol_prerun.png", + "06_set_plate_columns_confirmed_run_view.png", + "07_go_prerun.png", + "08_go_delivering_pulse.png", + "09_go_pulses_delivered.png", + ) + for filename in run_view_fixtures: + with self.subTest(filename=filename): + self.assertTrue( + detector.run_view_matches_protocol(str(SCREEN_FIXTURES / filename), protocol_name) + ) + + @pytest.mark.skipif(shutil.which("tesseract") is None, reason="requires tesseract OCR") + def test_selected_screen_fixtures_cover_two_step_plate_columns_confirm(self): + detector = _GeminiScreenDetector(min_conf=0.70) + + opened = detector.classify_image(str(SCREEN_FIXTURES / "04_set_plate_columns_open.png")) + first_confirm = detector.classify_image( + str(SCREEN_FIXTURES / "05_set_plate_columns_after_first_confirm.png") + ) + confirmed = detector.classify_image( + str(SCREEN_FIXTURES / "06_set_plate_columns_confirmed_run_view.png") + ) + + self.assertEqual(opened.state, STATE_PROTOCOL_DETAILS) + self.assertEqual(first_confirm.state, STATE_PROTOCOL_DETAILS) + self.assertEqual(confirmed.state, STATE_PROTOCOL_RUN_VIEW) + + @pytest.mark.skipif(shutil.which("tesseract") is None, reason="requires tesseract OCR") + def test_selected_screen_fixtures_cover_go_to_completion(self): + detector = _GeminiScreenDetector(min_conf=0.70) + + prerun = detector.classify_image(str(SCREEN_FIXTURES / "07_go_prerun.png")) + delivering = detector.classify_image(str(SCREEN_FIXTURES / "08_go_delivering_pulse.png")) + finished = detector.classify_image(str(SCREEN_FIXTURES / "09_go_pulses_delivered.png")) + home = detector.classify_image(str(SCREEN_FIXTURES / "10_returned_home_after_go.png")) + + self.assertTrue(detector.looks_prerun(prerun)) + self.assertEqual(delivering.state, STATE_PROTOCOL_RUN_VIEW) + self.assertIn("delivering pulse", delivering.matched) + self.assertFalse(detector.looks_prerun(delivering)) + self.assertTrue(detector.is_run_done(finished)) + self.assertIn("pulses delivered", finished.matched) + self.assertEqual(home.state, STATE_MAIN_MENU) + + def test_prepare_user_protocol_accepts_direct_summary_after_row_tap(self): + touch = _TestGhostTouch() + touch.queue_snapshot(STATE_MAIN_MENU, text="Main Menu", text_norm="main menu") + touch.queue_snapshot(STATE_USER_PROTOCOLS, text="User Protocols", text_norm="user protocols") + touch.queue_snapshot( + STATE_UNKNOWN, + text="Exponential Decay Voltage Resistance Capacitance Number of Pulses", + text_norm="exponential decay voltage resistance capacitance number of pulses", + image_path="summary", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="run-view", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="verify", + ) + + result = touch.prepare_user_protocol("!PLR_123") + + self.assertEqual(result.run_view.state, STATE_PROTOCOL_RUN_VIEW) + self.assertEqual(result.prepared_verification.state, STATE_PROTOCOL_RUN_VIEW) + self.assertGreaterEqual(len(touch.taps), 3) + + def test_start_prepared_user_protocol_verifies_then_waits_done(self): + touch = _TestGhostTouch() + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="verify", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="before-go", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol delivering pulse", + text_norm="run protocol delivering pulse", + image_path="after-go", + ) + touch.queue_snapshot( + STATE_PROTOCOL_FINISH, + text="Run Protocol pulses delivered completed", + text_norm="run protocol pulses delivered completed", + image_path="done", + ) + touch.queue_snapshot( + STATE_MAIN_MENU, text="Main Menu", text_norm="main menu", image_path="home" + ) + + result = touch.start_prepared_user_protocol("!PLR_123", home_after=True, max_run_seconds=10.0) + + self.assertEqual(result.verification.image_path, "verify") + self.assertEqual(result.completed.state, STATE_PROTOCOL_FINISH) + self.assertIsNotNone(result.home) + assert result.home is not None + self.assertEqual(result.home.state, STATE_MAIN_MENU) + + def test_ensure_home_closes_protocol_details_before_home(self): + touch = _TestGhostTouch() + touch.queue_snapshot( + STATE_PROTOCOL_DETAILS, + text="Set Plate Columns", + text_norm="set plate columns", + image_path="details", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="run-view", + ) + touch.queue_snapshot( + STATE_MAIN_MENU, + text="Main Menu", + text_norm="main menu", + image_path="home", + ) + + result = touch.ensure_home() + + self.assertEqual(result.image_path, "home") + self.assertEqual(touch.taps[0][:2], (739, 414)) + self.assertEqual(touch.taps[1][:2], (726, 326)) + + def test_set_plate_columns_confirms_again_when_details_remains_open(self): + touch = _TestGhostTouch() + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="run-view-start", + ) + touch.queue_snapshot( + STATE_PROTOCOL_DETAILS, + text="Set Plate Columns", + text_norm="set plate columns", + image_path="details-open", + ) + touch.queue_snapshot( + STATE_PROTOCOL_DETAILS, + text="Set Plate Columns", + text_norm="set plate columns", + image_path="details-after-first-confirm", + ) + touch.queue_snapshot( + STATE_PROTOCOL_RUN_VIEW, + text="Run Protocol GO Set Meas", + text_norm="run protocol go set meas", + image_path="run-view-confirmed", + ) + + result = touch.set_plate_columns(3) + + self.assertEqual(result.image_path, "run-view-confirmed") + self.assertEqual(touch.taps[-2][:2], (739, 414)) + self.assertEqual(touch.taps[-1][:2], (739, 414)) + + def test_cancel_prepared_user_protocol_homes(self): + touch = _TestGhostTouch() + touch.queue_snapshot( + STATE_MAIN_MENU, text="Main Menu", text_norm="main menu", image_path="home" + ) + + result = touch.cancel_prepared_user_protocol(home_after=True) + + self.assertTrue(result.cancelled) + self.assertEqual(result.final_state.image_path, "home") diff --git a/pyproject.toml b/pyproject.toml index c873d4096bd..c064d17991f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,13 +16,14 @@ serial = ["pyserial"] usb = ["pyusb", "libusb-package"] ftdi = ["pylibftdi", "pyusb"] hid = ["hid"] +btx = ["pyserial", "numpy>=1.26", "Pillow"] modbus = ["pymodbus>=3.0.0,<3.7.0"] opentrons = ["opentrons-http-api-client==0.2.0"] sila = ["zeroconf>=0.131.0", "grpcio"] cytation-microscopy = ["numpy>=1.26", "opencv-python", "PyGObject"] pico = ["PyLabRobot[sila]", "opencv-python", "numpy"] xarm = ["xarm-python-sdk"] -all = ["PyLabRobot[serial,usb,ftdi,hid,modbus,websockets,visualizer,opentrons,sila,pico,xarm]"] +all = ["PyLabRobot[serial,usb,ftdi,hid,btx,modbus,websockets,visualizer,opentrons,sila,pico,xarm]"] test = [ "pytest", "pytest-timeout", From d5993cebbe211f00be1bb09405192a495c4ef1c7 Mon Sep 17 00:00:00 2001 From: hazlamshamin Date: Tue, 26 May 2026 16:13:18 +0800 Subject: [PATCH 3/4] BTX: document Gemini X2 usage --- docs/_static/devices.json | 12 +- .../_getting-started/installation.md | 14 ++ .../btx/gemini_x2/hello-world.ipynb | 221 ++++++++++++++++++ docs/user_guide/btx/index.md | 14 ++ docs/user_guide/index.md | 1 + docs/user_guide/machines.md | 7 + 6 files changed, 268 insertions(+), 1 deletion(-) create mode 100644 docs/user_guide/btx/gemini_x2/hello-world.ipynb create mode 100644 docs/user_guide/btx/index.md diff --git a/docs/_static/devices.json b/docs/_static/devices.json index f950490f658..20bf0afaf05 100644 --- a/docs/_static/devices.json +++ b/docs/_static/devices.json @@ -441,6 +441,16 @@ "docs": "/user_guide/01_material-handling/sealers/a4s.html", "oem": "https://www.azenta.com/products/automated-roll-heat-sealer-formerly-a4s" }, + { + "vendor": "BTX", + "name": "Gemini X2", + "capabilities": [ + "electroporation" + ], + "status": "Mostly", + "docs": "/user_guide/btx/gemini_x2/hello-world.html", + "oem": "https://support.btxonline.com/hc/en-us/articles/6215664757907-Gemini-Twin-Wave-Electroporators-Manual-and-Quick-Start-guide" + }, { "vendor": "Opentrons", "name": "Thermocycler", @@ -687,4 +697,4 @@ "docs": "/user_guide/02_analytical/scales.html#mettler-toledo-wxs205sdu", "oem": "https://www.mt.com/us/en/home/products/Industrial_Weighing_Solutions/high-precision-weigh-sensors/weigh-module-wxs205sdu-15-11121008.html" } -] \ No newline at end of file +] diff --git a/docs/user_guide/_getting-started/installation.md b/docs/user_guide/_getting-started/installation.md index bca89b7d671..b81294b4bff 100644 --- a/docs/user_guide/_getting-started/installation.md +++ b/docs/user_guide/_getting-started/installation.md @@ -47,6 +47,7 @@ Different machines use different communication modes. Replace `[usb]` with one o | `usb` | pyusb, libusb-package | USB devices: e.g. Hamilton STAR/STARlet, Tecan EVO (firmware) | | `ftdi` | pylibftdi, pyusb | FTDI devices: e.g. BioTek Synergy H1 plate reader | | `hid` | hid | HID devices: e.g. Inheco Incubator/Shaker (HID mode) | +| `btx` | pyserial, numpy, Pillow | BTX Gemini X2 electroporator | | `modbus` | pymodbus | Modbus devices: e.g. Agrow Pump Array | | `opentrons` | opentrons-http-api-client | e.g. Opentrons backend | | `cytation-microscopy` | numpy (1.26), opencv-python | Cytation imager | @@ -171,6 +172,19 @@ If you get a `usb.core.NoBackendError: No backend available` error: [this](https If you are still having trouble, please reach out on [discuss.pylabrobot.org](https://discuss.pylabrobot.org). +## BTX Gemini X2 + +The BTX Gemini X2 support uses serial communication and GhostTouch screenshot OCR. First, install +the Python dependencies: + +```bash +pip install "pylabrobot[btx]" +``` + +GhostTouch also requires the external [Tesseract OCR](https://github.com/tesseract-ocr/tesseract) +executable. Install Tesseract for your operating system and make sure the `tesseract` command is +available on `PATH`. + ## Cytation imager In order to use imaging on the Cytation, you need to: diff --git a/docs/user_guide/btx/gemini_x2/hello-world.ipynb b/docs/user_guide/btx/gemini_x2/hello-world.ipynb new file mode 100644 index 00000000000..2b432e069ed --- /dev/null +++ b/docs/user_guide/btx/gemini_x2/hello-world.ipynb @@ -0,0 +1,221 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro", + "metadata": {}, + "source": [ + "# BTX Gemini X2\n", + "\n", + "The BTX Gemini X2 is a twin-waveform electroporator. PyLabRobot controls it through a USB serial connection: protocol and log transfer use the Gemini file-transfer interface, while run-screen actions use GhostTouch on the instrument touchscreen.\n", + "\n", + "Install the Python extra and make sure the external `tesseract` command is available on `PATH`:\n", + "\n", + "```bash\n", + "pip install \"pylabrobot[btx]\"\n", + "```\n", + "\n", + "For the capability-level API, see [Electroporation](../../capabilities/electroporation)." + ] + }, + { + "cell_type": "markdown", + "id": "setup-md", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Identify the serial port on your control computer and create the device. On macOS this is often `/dev/cu.usbmodem...`; on Windows it is usually a `COM` port." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "setup-code", + "metadata": {}, + "outputs": [], + "source": [ + "from pylabrobot.btx import BTXGeminiX2\n", + "\n", + "gemini = BTXGeminiX2(port=\"/dev/cu.usbmodemXXXX\")\n", + "await gemini.setup()" + ] + }, + { + "cell_type": "markdown", + "id": "info-md", + "metadata": {}, + "source": [ + "## Device information\n", + "\n", + "The electroporation capability exposes Gemini identity, the temporary protocol prefix, and plate-handler support." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "info-code", + "metadata": {}, + "outputs": [], + "source": [ + "info = await gemini.electroporation.get_device_info()\n", + "print(info[\"model\"], info[\"version\"], info[\"serial_number\"])" + ] + }, + { + "cell_type": "markdown", + "id": "protocol-md", + "metadata": {}, + "source": [ + "## Define a protocol\n", + "\n", + "Square-wave protocols use `duration_us`; exponential-decay protocols use `resistance_ohms` and `capacitance_uf`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "protocol-code", + "metadata": {}, + "outputs": [], + "source": [ + "from pylabrobot.capabilities.electroporation import ElectroporationProtocol\n", + "\n", + "protocol = ElectroporationProtocol(\n", + " protocol_type=\"square\",\n", + " pulse_amplitude_volts=250,\n", + " gap_mm=2.0,\n", + " pulse_count=1,\n", + " pulse_interval_seconds=0.0,\n", + " duration_us=1000,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "prepare-md", + "metadata": {}, + "source": [ + "## Prepare a temporary run\n", + "\n", + "`prepare_temporary_protocol` writes a temporary `!PLR_...` user protocol, opens it on the Gemini touchscreen, sets plate-handler columns when requested, and leaves the device on the run screen.\n", + "\n", + "When using the HT-200 plate handler, `plate_columns` requires an explicit `plate_handler_reset_state`. Use `reset_confirmed` only after manually returning the handler to column 1; use `continue_current_position` only when intentionally continuing from the current handler position." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "prepare-code", + "metadata": {}, + "outputs": [], + "source": [ + "from pylabrobot.btx import BTXGeminiX2ElectroporationBackend\n", + "\n", + "prepared = await gemini.electroporation.prepare_temporary_protocol(\n", + " protocol=protocol,\n", + " plate_columns=3,\n", + " backend_params=BTXGeminiX2ElectroporationBackend.PrepareRunParams(\n", + " plate_handler_reset_state=\"reset_confirmed\",\n", + " ),\n", + ")\n", + "prepared.protocol_name" + ] + }, + { + "cell_type": "markdown", + "id": "serialize-md", + "metadata": {}, + "source": [ + "The prepared run can be serialized and passed to a later process. The serialized payload includes the temporary protocol name and baseline log listing used to match the new BTXDATA log after GO." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "serialize-code", + "metadata": {}, + "outputs": [], + "source": [ + "prepared_payload = prepared.as_dict()\n", + "prepared_payload[\"protocol_name\"]" + ] + }, + { + "cell_type": "markdown", + "id": "start-md", + "metadata": {}, + "source": [ + "## Start the prepared run\n", + "\n", + "The next cell presses GO on the prepared run screen and delivers the configured pulse. Confirm that the plate, electrodes, samples, safety cover, and plate-handler state are correct before running it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "start-code", + "metadata": {}, + "outputs": [], + "source": [ + "result = await gemini.electroporation.start_prepared_run(\n", + " prepared_run=prepared,\n", + " home_after=True,\n", + ")\n", + "result.log_capture.summary" + ] + }, + { + "cell_type": "markdown", + "id": "cancel-md", + "metadata": {}, + "source": [ + "## Cancel before pulse delivery\n", + "\n", + "If a run has been prepared but should not be started, cancel it. This returns the Gemini to a safe screen and deletes the temporary protocol." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cancel-code", + "metadata": {}, + "outputs": [], + "source": [ + "# cancelled = await gemini.electroporation.cancel_prepared_run(prepared)\n", + "# cancelled.cleanup.deleted" + ] + }, + { + "cell_type": "markdown", + "id": "teardown-md", + "metadata": {}, + "source": [ + "## Teardown" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "teardown-code", + "metadata": {}, + "outputs": [], + "source": [ + "await gemini.stop()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/user_guide/btx/index.md b/docs/user_guide/btx/index.md new file mode 100644 index 00000000000..cc2d9934e1e --- /dev/null +++ b/docs/user_guide/btx/index.md @@ -0,0 +1,14 @@ +# BTX + +```{toctree} +:maxdepth: 1 + +gemini_x2/hello-world +``` + +## Gemini X2 + +| Model | PLR device | Capabilities | +|---|---|---| +| Gemini X2 | `BTXGeminiX2` | Electroporation | + diff --git a/docs/user_guide/index.md b/docs/user_guide/index.md index bb273f350cf..2f37b04440a 100644 --- a/docs/user_guide/index.md +++ b/docs/user_guide/index.md @@ -34,6 +34,7 @@ agilent/index azenta/index bmg_labtech/index brooks/index +btx/index byonoy/index hamilton/index inheco/index diff --git a/docs/user_guide/machines.md b/docs/user_guide/machines.md index dc057d79b15..205844ab8c5 100644 --- a/docs/user_guide/machines.md +++ b/docs/user_guide/machines.md @@ -33,6 +33,7 @@ tr > td:nth-child(5) { width: 15%; } .badge-absorbance { background: #ffe6cc; } .badge-fluorescence { background: #e0ffcc; } .badge-luminescence { background: #e6e6ff; } +.badge-electroporation { background: #ffe0f0; } .badge-time-resolved-fluo { background: #ddffdd; } .badge-fluo-polarization { background: #ddf2ffff; } @@ -127,6 +128,12 @@ tr > td:nth-child(5) { width: 15%; } |--------------|---------|-------------|--------| | Azenta Life Sciences | a4S | Full | [PLR](01_material-handling/sealers/a4s.ipynb) / [OEM](https://www.azenta.com/products/automated-roll-heat-sealer-formerly-a4s) | +### Electroporators + +| Manufacturer | Machine | Features | PLR-Support | Links | +|--------------|---------|----------|-------------|--------| +| BTX | Gemini X2 | electroporation | Mostly | [PLR](btx/gemini_x2/hello-world.ipynb) / [OEM](https://support.btxonline.com/hc/en-us/articles/6215664757907-Gemini-Twin-Wave-Electroporators-Manual-and-Quick-Start-guide) | + ### Thermocyclers | Manufacturer | Machine | PLR-Support | Links | From 1c282c8a6a10b017931907af54419ad988751b40 Mon Sep 17 00:00:00 2001 From: hazlamshamin Date: Tue, 26 May 2026 16:13:31 +0800 Subject: [PATCH 4/4] Docs: fix bulk dispenser API module paths --- docs/api/pylabrobot.capabilities.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/api/pylabrobot.capabilities.rst b/docs/api/pylabrobot.capabilities.rst index 7e76be10b6d..31146a51909 100644 --- a/docs/api/pylabrobot.capabilities.rst +++ b/docs/api/pylabrobot.capabilities.rst @@ -326,7 +326,7 @@ Devices Bulk Dispensing - Peristaltic ----------------------------- -.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.peristaltic.peristaltic +.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.peristaltic.peristaltic8 .. autosummary:: :toctree: _autosummary @@ -335,7 +335,7 @@ Bulk Dispensing - Peristaltic PeristalticDispensing8 -.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.peristaltic.backend +.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.peristaltic.backend8 .. autosummary:: :toctree: _autosummary @@ -348,7 +348,7 @@ Bulk Dispensing - Peristaltic Bulk Dispensing - Syringe ------------------------- -.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.syringe.syringe +.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.syringe.syringe8 .. autosummary:: :toctree: _autosummary @@ -357,7 +357,7 @@ Bulk Dispensing - Syringe SyringeDispensing8 -.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.syringe.backend +.. currentmodule:: pylabrobot.capabilities.bulk_dispensers.syringe.backend8 .. autosummary:: :toctree: _autosummary