opentrons 8.7.0a6__py3-none-any.whl → 8.7.0a7__py3-none-any.whl

opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.7.0a6'
-__version_tuple__ = version_tuple = (8, 7, 0, 'a6')
+__version__ = version = '8.7.0a7'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a7')
 
 __commit_id__ = commit_id = None

opentrons/drivers/asyncio/communication/serial_connection.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, List, Type
+from typing import Type, Literal, AsyncIterator
 
 from opentrons.drivers.command_builder import CommandBuilder
 
@@ -25,7 +25,7 @@ class SerialConnection:
         port: str,
         baud_rate: int,
         timeout: float,
-        loop: Optional[asyncio.AbstractEventLoop],
+        loop: asyncio.AbstractEventLoop | None,
         reset_buffer_before_write: bool,
     ) -> AsyncSerial:
         return await AsyncSerial.create(
@@ -43,11 +43,11 @@ class SerialConnection:
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: Optional[str] = None,
+        name: str | None = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-        error_keyword: Optional[str] = None,
-        alarm_keyword: Optional[str] = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        error_keyword: str | None = None,
+        alarm_keyword: str | None = None,
         reset_buffer_before_write: bool = False,
         error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
     ) -> "SerialConnection":
@@ -133,7 +133,7 @@ class SerialConnection:
         self._error_codes = error_codes
 
     async def send_command(
-        self, command: CommandBuilder, retries: int = 0, timeout: Optional[float] = None
+        self, command: CommandBuilder, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send a command and return the response.
@@ -165,7 +165,7 @@ class SerialConnection:
             await self._serial.write(data=encoded_command)
 
     async def send_data(
-        self, data: str, retries: int = 0, timeout: Optional[float] = None
+        self, data: str, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send data and return the response.
@@ -184,7 +184,7 @@ class SerialConnection:
         ):
             return await self._send_data(data=data, retries=retries)
 
-    async def _send_data(self, data: str, retries: int = 0) -> str:
+    async def _send_data(self, data: str, retries: int) -> str:
         """
         Send data and return the response.
 
@@ -351,14 +351,14 @@ class AsyncResponseSerialConnection(SerialConnection):
         baud_rate: int,
         timeout: float,
         ack: str,
-        name: Optional[str] = None,
+        name: str | None = None,
         retry_wait_time_seconds: float = 0.1,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
-        error_keyword: Optional[str] = None,
-        alarm_keyword: Optional[str] = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        error_keyword: str | None = None,
+        alarm_keyword: str | None = None,
         reset_buffer_before_write: bool = False,
         error_codes: Type[BaseErrorCode] = DefaultErrorCodes,
-        async_error_ack: Optional[str] = None,
+        async_error_ack: str | None = None,
         number_of_retries: int = 0,
     ) -> AsyncResponseSerialConnection:
         """
@@ -461,8 +461,29 @@ class AsyncResponseSerialConnection(SerialConnection):
         self._alarm_keyword = alarm_keyword.lower()
         self._async_error_ack = async_error_ack.lower()
 
+    async def send_multiack_command(
+        self,
+        command: CommandBuilder,
+        retries: int = 0,
+        timeout: float | None = None,
+        acks: int = 1,
+    ) -> list[str]:
+        """Send a command and return the responses.
+
+        Some commands result in multiple responses; collate them and return them all.
+
+        Args:
+            command: A command builder.
+            retries: number of times to retry in case of timeout
+            timeout: optional override of default timeout in seconds
+            acks: the number of acks to expect
+        """
+        return await self.send_data_multiack(
+            data=command.build(), retries=retries, timeout=timeout, acks=acks
+        )
+
     async def send_command(
-        self, command: CommandBuilder, retries: int = 0, timeout: Optional[float] = None
+        self, command: CommandBuilder, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send a command and return the response.
@@ -482,8 +503,19 @@ class AsyncResponseSerialConnection(SerialConnection):
             timeout=timeout,
         )
 
+    async def send_data_multiack(
+        self, data: str, retries: int = 0, timeout: float | None = None, acks: int = 1
+    ) -> list[str]:
+        """Send data and return all responses."""
+        async with super().send_data_lock, self._serial.timeout_override(
+            "timeout", timeout
+        ):
+            return await self._send_data_multiack(
+                data=data, retries=retries or self._number_of_retries, acks=acks
+            )
+
     async def send_data(
-        self, data: str, retries: int = 0, timeout: Optional[float] = None
+        self, data: str, retries: int = 0, timeout: float | None = None
     ) -> str:
         """
         Send data and return the response.
@@ -504,54 +536,99 @@ class AsyncResponseSerialConnection(SerialConnection):
                 data=data, retries=retries or self._number_of_retries
             )
 
-    async def _send_data(self, data: str, retries: int = 0) -> str:
+    async def _consume_responses(
+        self, acks: int
+    ) -> AsyncIterator[tuple[Literal["response", "error", "empty-unknown"], bytes]]:
+        while acks > 0:
+            data = await self._serial.read_until(match=self._ack)
+            log.debug(f"{self._name}: Read <- {data!r}")
+            if self._async_error_ack.encode() in data:
+                yield "error", data
+            elif self._ack in data:
+                yield "response", data
+                acks -= 1
+            else:
+                # A read timeout, end
+                yield "empty-unknown", data
+
+    async def _send_one_retry(self, data: str, acks: int) -> list[str]:
+        data_encode = data.encode("utf-8")
+        log.debug(f"{self._name}: Write -> {data_encode!r}")
+        await self._serial.write(data=data_encode)
+
+        command_acks: list[bytes] = []
+        async_errors: list[bytes] = []
+        # consume responses before raising so we don't raise and orphan
+        # a response in the buffer
+        async for response_type, response in self._consume_responses(acks):
+            if response_type == "error":
+                async_errors.append(response)
+            elif response_type == "response":
+                command_acks.append(response)
+            else:
+                break
+
+        for async_error in async_errors:
+            # Remove ack from response
+            ackless_response = async_error.replace(self._ack, b"")
+            str_response = self.process_raw_response(
+                command=data, response=ackless_response.decode()
+            )
+            self.raise_on_error(response=str_response, request=data)
+
+        ackless_responses: list[str] = []
+        for command_ack in command_acks:
+            # Remove ack from response
+            ackless_response = command_ack.replace(self._ack, b"")
+            str_response = self.process_raw_response(
+                command=data, response=ackless_response.decode()
+            )
+            self.raise_on_error(response=str_response, request=data)
+            ackless_responses.append(str_response)
+        return ackless_responses
+
+    async def _send_data_multiack(
+        self, data: str, retries: int, acks: int
+    ) -> list[str]:
         """
-        Send data and return the response.
+        Send data and return the response(s).
 
         Args:
             data: The data to send.
             retries: number of times to retry in case of timeout
+            acks: The number of expected command responses
 
-        Returns: The command response
+        This function retries (resends the command) up to (retries) times, and waits
+        for (acks) responses. It also listens for async errors. These are an older
+        mechanism where at the moment an error occurs, some modules will send a message
+        like async error ERR:202:whatever
 
-        Raises: SerialException
-        """
-        data_encode = data.encode()
-        retries = retries or self._number_of_retries
+        This function will detect async error messages if they were sent before it
+        sent the command or if they are sent before the final ack for the command is
+        sent. It will not catch async errors otherwise.
 
-        for retry in range(retries + 1):
-            log.debug(f"{self._name}: Write -> {data_encode!r}")
-            await self._serial.write(data=data_encode)
+        This function will always try and consume all the acknowledgements specified for
+        its command if it sends the command, even if an async error happens in between.
 
-            response: List[bytes] = []
-            response.append(await self._serial.read_until(match=self._ack))
-            log.debug(f"{self._name}: Read <- {response[-1]!r}")
-
-            while self._async_error_ack.encode() in response[-1].lower():
-                # check for multiple a priori async errors
-                response.append(await self._serial.read_until(match=self._ack))
-                log.debug(f"{self._name}: Read <- {response[-1]!r}")
-
-            for r in response:
-                if self._async_error_ack.encode() in r:
-                    # Remove ack from response
-                    ackless_response = r.replace(self._ack, b"")
-                    str_response = self.process_raw_response(
-                        command=data, response=ackless_response.decode()
-                    )
-                    self.raise_on_error(response=str_response, request=data)
+        This should all work together to make sure that there aren't any leftover acks
+        after the function ends, which could lead to the read/write mechanics getting out
+        of sync.
 
-            if self._ack in response[-1]:
-                # Remove ack from response
-                ackless_response = response[-1].replace(self._ack, b"")
-                str_response = self.process_raw_response(
-                    command=data, response=ackless_response.decode()
-                )
-                self.raise_on_error(response=str_response, request=data)
-                return str_response
+        Returns: The command responses
 
-            log.info(f"{self._name}: retry number {retry}/{retries}")
+        Raises: SerialException from an error ack to this command or an async error.
+        """
+        retries = retries or self._number_of_retries
+        responses: list[str] = []
 
+        for retry in range(retries + 1):
+            responses = await self._send_one_retry(data, acks)
+            if responses:
+                return responses
+            log.info(f"{self._name}: retry number {retry}/{retries}")
             await self.on_retry()
 
         raise NoResponse(port=self._port, command=data)
+
+    async def _send_data(self, data: str, retries: int) -> str:
+        return (await self._send_data_multiack(data, retries, 1))[0]

opentrons/drivers/heater_shaker/abstract.py

@@ -74,3 +74,8 @@ class AbstractHeaterShakerDriver(ABC):
     async def enter_programming_mode(self) -> None:
         """Reboot into programming mode"""
         ...
+
+    @abstractmethod
+    async def get_error_state(self) -> None:
+        """Raise if the module is in an error state."""
+        ...

opentrons/drivers/heater_shaker/driver.py

@@ -27,6 +27,7 @@ class GCODE(str, Enum):
     GET_LABWARE_LATCH_STATE = "M241"
     DEACTIVATE_HEATER = "M106"
     GET_RESET_REASON = "M114"
+    GET_ERROR_STATE = "M411"
 
 
 HS_BAUDRATE = 115200
@@ -202,3 +203,12 @@ class HeaterShakerDriver(AbstractHeaterShakerDriver):
             gcode=GCODE.DEACTIVATE_HEATER
         )
         await self._connection.send_command(command=c, retries=DEFAULT_COMMAND_RETRIES)
+
+    async def get_error_state(self) -> None:
+        """Raise if the module is in an error state."""
+        await self._connection.send_multiack_command(
+            command=CommandBuilder(terminator=HS_COMMAND_TERMINATOR).add_gcode(
+                gcode=GCODE.GET_ERROR_STATE
+            ),
+            acks=2,
+        )

opentrons/drivers/heater_shaker/simulator.py

@@ -92,3 +92,7 @@ class SimulatingDriver(AbstractHeaterShakerDriver):
     @ensure_yield
     async def enter_programming_mode(self) -> None:
         pass
+
+    @ensure_yield
+    async def get_error_state(self) -> None:
+        return

opentrons/drivers/thermocycler/abstract.py

@@ -55,6 +55,7 @@ class AbstractThermocyclerDriver(ABC):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         ...
@@ -97,3 +98,8 @@ class AbstractThermocyclerDriver(ABC):
     async def jog_lid(self, angle: float) -> None:
         """Send the Jog Lid command."""
         ...
+
+    @abstractmethod
+    async def get_error_state(self) -> None:
+        """Raise if the thermocycler is in an error state."""
+        ...

opentrons/drivers/thermocycler/driver.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from enum import Enum
-from typing import Optional, Dict, Union
+from typing import Optional, Dict, Union, TypeVar, Generic
 
 from opentrons.drivers import utils
 from opentrons.drivers.command_builder import CommandBuilder
@@ -36,6 +36,7 @@ class GCODE(str, Enum):
     DEVICE_INFO = "M115"
     GET_RESET_REASON = "M114"
     ENTER_PROGRAMMING = "dfu"
+    GET_ERROR_STATE = "M411"
 
 
 LID_TARGET_DEFAULT = 105  # Degree celsius (floats)
@@ -73,7 +74,7 @@ class ThermocyclerDriverFactory:
     @staticmethod
     async def create(
         port: str, loop: Optional[asyncio.AbstractEventLoop]
-    ) -> ThermocyclerDriver:
+    ) -> ThermocyclerDriver | ThermocyclerDriverV2:
         """
         Create a thermocycler driver.
 
@@ -148,10 +149,15 @@ class ThermocyclerDriverFactory:
         return response.startswith(GCODE.DEVICE_INFO)
 
 
-class ThermocyclerDriver(AbstractThermocyclerDriver):
+_ConnectionKind = TypeVar(
+    "_ConnectionKind", SerialConnection, AsyncResponseSerialConnection
+)
+
+
+class _BaseThermocyclerDriver(AbstractThermocyclerDriver, Generic[_ConnectionKind]):
     def __init__(
         self,
-        connection: SerialKind,
+        connection: _ConnectionKind,
     ) -> None:
         """
         Constructor
@@ -159,7 +165,7 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
         Args:
             connection: SerialConnection to the thermocycler
         """
-        self._connection = connection
+        self._connection: _ConnectionKind = connection
 
     async def connect(self) -> None:
         """Connect to thermocycler"""
@@ -226,6 +232,7 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Send set plate temperature command"""
         temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
@@ -328,8 +335,15 @@ class ThermocyclerDriver(AbstractThermocyclerDriver):
             "Gen1 Thermocyclers do not support the Jog Lid command."
         )
 
+    async def get_error_state(self) -> None:
+        """For the gen1, do nothing."""
+        pass
+
+
+ThermocyclerDriver = _BaseThermocyclerDriver[SerialConnection]
 
-class ThermocyclerDriverV2(ThermocyclerDriver):
+
+class ThermocyclerDriverV2(_BaseThermocyclerDriver[AsyncResponseSerialConnection]):
     """
     This driver is for Thermocycler model Gen2.
     """
@@ -343,10 +357,38 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
         """
         super().__init__(connection)
 
-    async def set_ramp_rate(self, ramp_rate: float) -> None:
-        """Send a set ramp rate command"""
-        # This command is fully unsupported on TC Gen2
-        return None
+    async def set_plate_temperature(
+        self,
+        temp: float,
+        hold_time: Optional[float] = None,
+        volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
+    ) -> None:
+        """Send set plate temperature command"""
+        temp = min(BLOCK_TARGET_MAX, max(BLOCK_TARGET_MIN, temp))
+
+        c = (
+            CommandBuilder(terminator=TC_COMMAND_TERMINATOR)
+            .add_gcode(gcode=GCODE.SET_PLATE_TEMP)
+            .add_float(
+                prefix="S", value=temp, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        )
+        if hold_time is not None:
+            c = c.add_float(
+                prefix="H", value=hold_time, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+        if volume is not None:
+            c = c.add_float(
+                prefix="V", value=volume, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        if ramp_rate is not None:
+            c = c.add_float(
+                prefix="R", value=ramp_rate, precision=utils.TC_GCODE_ROUNDING_PRECISION
+            )
+
+        await self._connection.send_command(command=c, retries=DEFAULT_COMMAND_RETRIES)
 
     async def get_device_info(self) -> Dict[str, str]:
         """Send get device info command"""
@@ -393,3 +435,12 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
             .add_element("O")
         )
         await self._connection.send_command(command=c, retries=1)
+
+    async def get_error_state(self) -> None:
+        """Raise an error if the thermocycler is stuck in an error state."""
+        await self._connection.send_multiack_command(
+            command=CommandBuilder(terminator=TC_COMMAND_TERMINATOR).add_gcode(
+                gcode=GCODE.GET_ERROR_STATE
+            ),
+            acks=2,
+        )

opentrons/drivers/thermocycler/simulator.py

@@ -67,10 +67,12 @@ class SimulatingDriver(AbstractThermocyclerDriver):
         temp: float,
         hold_time: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         self._plate_temperature.target = temp
         self._plate_temperature.current = temp
         self._plate_temperature.hold = 0
+        self._ramp_rate = ramp_rate
 
     @ensure_yield
     async def get_plate_temperature(self) -> PlateTemperature:
@@ -124,3 +126,7 @@ class SimulatingDriver(AbstractThermocyclerDriver):
             if angle < 0
             else ThermocyclerLidStatus.OPEN
         )
+
+    @ensure_yield
+    async def get_error_state(self) -> None:
+        return

opentrons/hardware_control/api.py

@@ -44,6 +44,7 @@ from .execution_manager import ExecutionManagerProvider
 from .pause_manager import PauseManager
 from .module_control import AttachedModulesControl
 from .types import (
+    AsynchronousModuleErrorNotification,
     Axis,
     CriticalPoint,
     DoorState,
@@ -51,6 +52,7 @@ from .types import (
     ErrorMessageNotification,
     HardwareEventHandler,
     HardwareAction,
+    HardwareEvent,
     MotionChecks,
     PauseType,
     StatusBarState,
@@ -167,6 +169,18 @@ class API(
             except Exception:
                 mod_log.exception("Errored during door state event callback")
 
+    def _send_module_notification(self, event: HardwareEvent) -> None:
+        if not isinstance(event, AsynchronousModuleErrorNotification):
+            return
+        mod_log.info(
+            f"Forwarding module event {event.event} for {event.module_model} {event.module_serial} at {event.port}"
+        )
+        for cb in self._callbacks:
+            try:
+                cb(event)
+            except Exception:
+                mod_log.exception("Errored during module asynchronous callback")
+
     def _reset_last_mount(self) -> None:
         self._last_moved_mount = None
 
@@ -247,7 +261,9 @@ class API(
             )
             await api_instance.cache_instruments()
             module_controls = await AttachedModulesControl.build(
-                api_instance, board_revision=backend.board_revision
+                api_instance,
+                board_revision=backend.board_revision,
+                event_callback=api_instance._send_module_notification,
             )
             backend.module_controls = module_controls
             checked_loop.create_task(backend.watch(loop=checked_loop))
@@ -306,7 +322,9 @@ class API(
         )
         await api_instance.cache_instruments()
         module_controls = await AttachedModulesControl.build(
-            api_instance, board_revision=backend.board_revision
+            api_instance,
+            board_revision=backend.board_revision,
+            event_callback=api_instance._send_module_notification,
         )
         backend.module_controls = module_controls
         await backend.watch()
@@ -1312,9 +1330,10 @@ class API(
             self.is_simulator
         ), "Cannot build simulating module from non-simulating hardware control API"
 
-        return await self._backend.module_controls.build_module(
-            port="",
-            usb_port=USBPort(name="", port_number=1, port_group=PortGroup.MAIN),
+        return await self._backend.module_controls.register_simulated_module(
+            simulated_usb_port=USBPort(
+                name="", port_number=1, port_group=PortGroup.MAIN
+            ),
             type=modules.ModuleType.from_model(model),
             sim_model=model.value,
         )

opentrons/hardware_control/backends/controller.py

@@ -360,13 +360,19 @@ class Controller:
         """Run a probe and return the new position dict"""
         return await self._smoothie_driver.probe_axis(axis, distance)
 
-    async def clean_up(self) -> None:
+    async def clean_up(self) -> None:  # noqa: C901
         try:
             loop = asyncio.get_event_loop()
         except RuntimeError:
             return
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
         if hasattr(self, "_event_watcher"):
-            if loop.is_running() and self._event_watcher:
+            if (
+                loop.is_running()
+                and self._event_watcher
+                and not self._event_watcher.closed
+            ):
                 self._event_watcher.close()
         if hasattr(self, "gpio_chardev"):
             try:

opentrons/hardware_control/backends/ot3controller.py

@@ -1398,6 +1398,9 @@ class OT3Controller(FlexBackend):
         except RuntimeError:
             return
 
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
+
         if hasattr(self, "_event_watcher"):
             if (
                 loop.is_running()

opentrons/hardware_control/backends/ot3simulator.py

@@ -728,7 +728,8 @@ class OT3Simulator(FlexBackend):
     @ensure_yield
     async def clean_up(self) -> None:
         """Clean up."""
-        pass
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
 
     @staticmethod
     def _get_home_position() -> Dict[Axis, float]:

opentrons/hardware_control/backends/simulator.py

@@ -414,7 +414,8 @@ class Simulator:
 
     @ensure_yield
     async def clean_up(self) -> None:
-        pass
+        if hasattr(self, "_module_controls") and self._module_controls is not None:
+            await self._module_controls.clean_up()
 
     @ensure_yield
     async def configure_mount(

opentrons/hardware_control/backends/subsystem_manager.py

@@ -91,6 +91,8 @@ class SubsystemManager:
         self._present_tools = tools.types.ToolSummary(
             left=None, right=None, gripper=None
         )
+        # This is intended to be an internal variable but is modified in unit tests to avoid long timeouts
+        self._check_device_update_timeout = 10.0
 
     @property
     def ok(self) -> bool:
@@ -183,11 +185,12 @@ class SubsystemManager:
             return self._tool_task_state is True
 
     async def _check_devices_after_update(
-        self, devices: Set[SubSystem], timeout_sec: float = 10.0
+        self, devices: Set[SubSystem], timeout_sec: Optional[float] = None
     ) -> None:
         try:
             await asyncio.wait_for(
-                self._do_check_devices_after_update(devices), timeout=timeout_sec
+                self._do_check_devices_after_update(devices),
+                timeout=timeout_sec or self._check_device_update_timeout,
             )
         except asyncio.TimeoutError:
             raise RuntimeError("Device failed to come back after firmware update")

opentrons/hardware_control/emulation/abstract_emulator.py

@@ -10,12 +10,14 @@ class AbstractEmulator(ABC):
         """Handle a command and return a response."""
         ...
 
-    @staticmethod
-    def get_terminator() -> bytes:
+    def get_terminator(self) -> bytes:
         """Get the command terminator for messages coming from PI."""
         return b"\r\n\r\n"
 
-    @staticmethod
-    def get_ack() -> bytes:
+    def get_ack(self) -> bytes:
         """Get the command ack send to the PI."""
         return b"ok\r\nok\r\n"
+
+    def get_autoack(self) -> bool:
+        """Should this system automatically acknowledge messages?"""
+        return True