Inheco ODTC

pylabrobot/storage/inheco/scila/scila_backend.py

@@ -2,7 +2,7 @@
 from typing import Any, Dict, Literal, Optional
 
 from pylabrobot.machines.backend import MachineBackend
-from pylabrobot.storage.inheco.scila.inheco_sila_interface import InhecoSiLAInterface
+from pylabrobot.storage.inheco.scila.inheco_sila_interface import InhecoSiLAInterface, SiLAState
 
 
 def _parse_scalar(text: Optional[str], tag: str) -> object:
@@ -46,18 +46,17 @@ async def stop(self) -> None:
     await self._sila_interface.close()
 
   async def _reset_and_initialize(self) -> None:
-    event_uri = f"http://{self._sila_interface.client_ip}:{self._sila_interface.bound_port}/"
     await self._sila_interface.send_command(
-      command="Reset", deviceId="MyController", eventReceiverURI=event_uri, simulationMode=False
+      command="Reset",
+      deviceId="MyController",
+      eventReceiverURI=self._sila_interface.event_receiver_uri,
+      simulationMode=False,
     )
 
     await self._sila_interface.send_command("Initialize")
 
-  async def request_status(self) -> str:
-    # GetStatus returns synchronously (return_code 1 = immediate dict), unlike other commands
-    # which return asynchronously (return_code 2 = XML via callback).
-    resp = await self._sila_interface.send_command("GetStatus")
-    return resp.get("GetStatusResponse", {}).get("state", "Unknown")  # type: ignore
+  async def request_status(self) -> SiLAState:
+    return await self._sila_interface.request_status()
 
   async def request_liquid_level(self) -> str:
     root = await self._sila_interface.send_command("GetLiquidLevel")

pylabrobot/storage/inheco/scila/scila_backend_tests.py

@@ -2,7 +2,7 @@
 import xml.etree.ElementTree as ET
 from unittest.mock import AsyncMock, patch
 
-from pylabrobot.storage.inheco.scila.inheco_sila_interface import InhecoSiLAInterface
+from pylabrobot.storage.inheco.scila.inheco_sila_interface import InhecoSiLAInterface, SiLAState
 from pylabrobot.storage.inheco.scila.scila_backend import SCILABackend
 
 
@@ -13,6 +13,7 @@ def setUp(self):
     self.mock_sila_interface = AsyncMock(spec=InhecoSiLAInterface)
     self.mock_sila_interface.bound_port = 80
     self.mock_sila_interface.client_ip = "127.0.0.1"
+    self.mock_sila_interface.event_receiver_uri = "http://127.0.0.1:80/"
     self.MockInhecoSiLAInterface.return_value = self.mock_sila_interface
     self.backend = SCILABackend(scila_ip="127.0.0.1")
 
@@ -35,10 +36,10 @@ async def test_stop(self):
     self.mock_sila_interface.close.assert_called_once()
 
   async def test_request_status(self):
-    self.mock_sila_interface.send_command.return_value = {"GetStatusResponse": {"state": "standBy"}}
+    self.mock_sila_interface.request_status = AsyncMock(return_value=SiLAState.STANDBY)
     status = await self.backend.request_status()
-    self.assertEqual(status, "standBy")
-    self.mock_sila_interface.send_command.assert_called_with("GetStatus")
+    self.assertEqual(status, SiLAState.STANDBY)
+    self.mock_sila_interface.request_status.assert_called_once()
 
   async def test_request_liquid_level(self):
     self.mock_sila_interface.send_command.return_value = ET.fromstring(
@@ -232,5 +233,33 @@ def test_deserialize_no_client_ip(self):
     self.MockInhecoSiLAInterface.assert_called_with(client_ip=None, machine_ip="169.254.1.117")
 
 
+class TestInhecoSiLAInterfaceLocking(unittest.IsolatedAsyncioTestCase):
+  """Tests for lock_device / unlock_device on InhecoSiLAInterface."""
+
+  def setUp(self):
+    self.interface = InhecoSiLAInterface(machine_ip="192.168.1.100", client_ip="127.0.0.1")
+
+  async def test_lock_device(self):
+    self.interface.send_command = AsyncMock()  # type: ignore[method-assign]
+    await self.interface.lock_device("my_lock_id")
+    self.interface.send_command.assert_called_once()
+    call_kwargs = self.interface.send_command.call_args[1]
+    self.assertEqual(call_kwargs["lockId"], "my_lock_id")
+    self.assertEqual(self.interface._lock_id, "my_lock_id")
+
+  async def test_unlock_device(self):
+    self.interface._lock_id = "my_lock_id"
+    self.interface.send_command = AsyncMock()  # type: ignore[method-assign]
+    await self.interface.unlock_device()
+    self.interface.send_command.assert_called_once_with("UnlockDevice")
+    self.assertIsNone(self.interface._lock_id)
+
+  async def test_unlock_device_not_locked(self):
+    self.interface._lock_id = None
+    with self.assertRaises(RuntimeError) as cm:
+      await self.interface.unlock_device()
+    self.assertIn("not locked", str(cm.exception))
+
+
 if __name__ == "__main__":
   unittest.main()

pylabrobot/thermocycling/backend.py

@@ -41,14 +41,31 @@ async def deactivate_lid(self):
     """Deactivate thermocycler lid."""
 
   @abstractmethod
-  async def run_protocol(self, protocol: Protocol, block_max_volume: float):
+  async def run_protocol(
+    self,
+    protocol: Protocol,
+    block_max_volume: float,
+  ):
     """Execute thermocycler protocol run.
 
     Args:
       protocol: Protocol object containing stages with steps and repeats.
       block_max_volume: Maximum block volume (µL) for safety.
     """
 
+  async def run_stored_protocol(self, name: str, wait: bool = False):
+    """Execute a stored protocol by name (optional; backends that support it override).
+
+    Args:
+      name: Name of the stored protocol to run.
+      wait: If False (default), start and return an execution handle. If True,
+        block until done then return the (completed) handle.
+
+    Raises:
+      NotImplementedError: This backend does not support running stored protocols by name.
+    """
+    raise NotImplementedError("This backend does not support running stored protocols by name.")
+
   @abstractmethod
   async def get_block_current_temperature(self) -> List[float]:
     """Get the current block temperature zones in °C."""
@@ -79,20 +96,20 @@ async def get_block_status(self) -> BlockStatus:
 
   @abstractmethod
   async def get_hold_time(self) -> float:
-    """Get remaining hold time in seconds."""
+    """Get remaining hold time in seconds. Return 0 when no profile is running."""
 
   @abstractmethod
   async def get_current_cycle_index(self) -> int:
-    """Get the zero-based index of the current cycle."""
+    """Get the zero-based index of the current cycle. Return 0 when no profile is running."""
 
   @abstractmethod
   async def get_total_cycle_count(self) -> int:
-    """Get the total cycle count."""
+    """Get the total cycle count. Return 0 when no profile is running."""
 
   @abstractmethod
   async def get_current_step_index(self) -> int:
-    """Get the zero-based index of the current step within the cycle."""
+    """Get the zero-based index of the current step within the cycle. Return 0 when no profile is running."""
 
   @abstractmethod
   async def get_total_step_count(self) -> int:
-    """Get the total number of steps in the current cycle."""
+    """Get the total number of steps in the current cycle. Return 0 when no profile is running."""

pylabrobot/thermocycling/chatterbox.py

@@ -97,7 +97,7 @@ async def deactivate_lid(self):
     print("Deactivating lid.")
     self._state.lid_target = None
 
-  async def run_protocol(self, protocol: Protocol, block_max_volume: float):
+  async def run_protocol(self, protocol: Protocol, block_max_volume: float, **kwargs):
     """Run a protocol with stages and repeats."""
     print("Running protocol:")