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

opentrons/hardware_control/backends/simulator.py

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

opentrons/hardware_control/backends/subsystem_manager.py

@@ -91,8 +91,6 @@ 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:
@@ -185,12 +183,11 @@ class SubsystemManager:
             return self._tool_task_state is True
 
     async def _check_devices_after_update(
-        self, devices: Set[SubSystem], timeout_sec: Optional[float] = None
+        self, devices: Set[SubSystem], timeout_sec: float = 10.0
     ) -> None:
         try:
             await asyncio.wait_for(
-                self._do_check_devices_after_update(devices),
-                timeout=timeout_sec or self._check_device_update_timeout,
+                self._do_check_devices_after_update(devices), timeout=timeout_sec
             )
         except asyncio.TimeoutError:
             raise RuntimeError("Device failed to come back after firmware update")

opentrons/hardware_control/emulation/abstract_emulator.py

@@ -10,14 +10,12 @@ class AbstractEmulator(ABC):
         """Handle a command and return a response."""
         ...
 
-    def get_terminator(self) -> bytes:
+    @staticmethod
+    def get_terminator() -> bytes:
         """Get the command terminator for messages coming from PI."""
         return b"\r\n\r\n"
 
-    def get_ack(self) -> bytes:
+    @staticmethod
+    def get_ack() -> 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

opentrons/hardware_control/emulation/connection_handler.py

@@ -27,15 +27,12 @@ class ConnectionHandler:
             try:
                 response = self._emulator.handle(line.decode().strip())
                 if response:
-                    response_bytes = response.encode() + self._emulator.get_terminator()
-                    logger.debug(f"{emulator_name} Sending: {response_bytes!r}")
-                    writer.write(response_bytes)
+                    response = f"{response}\r\n"
+                    logger.debug("%s Sending: %s", emulator_name, response)
+                    writer.write(response.encode())
             except Exception as e:
                 logger.exception("%s exception", emulator_name)
-                writer.write(
-                    f"Error: {str(e)} ".encode() + self._emulator.get_terminator()
-                )
+                writer.write(f"Error: {str(e)}\r\n".encode())
 
-            if self._emulator.get_autoack():
-                writer.write(self._emulator.get_ack())
+            writer.write(self._emulator.get_ack())
             await writer.drain()

opentrons/hardware_control/emulation/heater_shaker.py

@@ -2,7 +2,6 @@
 
 The purpose is to provide a fake backend that responds to GCODE commands.
 """
-
 import logging
 from time import sleep
 from typing import (
@@ -51,7 +50,6 @@ class HeaterShakerEmulator(AbstractEmulator):
             GCODE.CLOSE_LABWARE_LATCH.value: self._close_labware_latch,
             GCODE.GET_LABWARE_LATCH_STATE.value: self._get_labware_latch_state,
             GCODE.DEACTIVATE_HEATER.value: self._deactivate_heater,
-            GCODE.GET_ERROR_STATE.value: self._get_error_state,
         }
         self.reset()
 
@@ -62,6 +60,7 @@ class HeaterShakerEmulator(AbstractEmulator):
         return None if not joined else joined
 
     def reset(self) -> None:
+
         self._temperature = Temperature(
             per_tick=self._settings.temperature.degrees_per_tick,
             current=self._settings.temperature.starting,
@@ -146,14 +145,6 @@ class HeaterShakerEmulator(AbstractEmulator):
         self._temperature.deactivate(TEMPERATURE_ROOM)
         return "M106"
 
-    def _get_error_state(self, command: Command) -> str:
-        return f"M411 {HS_ACK}M411"
-
-    def get_terminator(self) -> bytes:
+    @staticmethod
+    def get_terminator() -> bytes:
         return b"\n"
-
-    def get_ack(self) -> bytes:
-        return HS_ACK.encode()
-
-    def get_autoack(self) -> bool:
-        return False

opentrons/hardware_control/emulation/settings.py

@@ -90,7 +90,7 @@ class Settings(BaseSettings):
     )
     thermocycler: ThermocyclerSettings = ThermocyclerSettings(
         serial_number="thermocycler_emulator",
-        model="thermocyclerModuleV2",
+        model="v02",
         version="v1.1.0",
         lid_temperature=TemperatureModelSettings(),
         plate_temperature=TemperatureModelSettings(),

opentrons/hardware_control/emulation/thermocycler.py

@@ -5,15 +5,8 @@ The purpose is to provide a fake backend that responds to GCODE commands.
 
 import logging
 from typing import Optional
-from opentrons.drivers.thermocycler.driver import (
-    GCODE,
-    TC_GEN2_ACK,
-    TC_GEN2_SERIAL_ACK,
-    TC_ACK as TC_GEN1_ACK,
-    SERIAL_ACK as TC_GEN1_SERIAL_ACK,
-)
+from opentrons.drivers.thermocycler.driver import GCODE
 from opentrons.drivers.types import ThermocyclerLidStatus
-from opentrons.hardware_control.modules.types import ThermocyclerModuleModel
 from opentrons.hardware_control.emulation.parser import Parser, Command
 from opentrons.hardware_control.emulation.settings import ThermocyclerSettings
 
@@ -36,31 +29,13 @@ class ThermocyclerEmulator(AbstractEmulator):
     def __init__(self, parser: Parser, settings: ThermocyclerSettings) -> None:
         self._parser = parser
         self._settings = settings
-        # I hate this. These modules do not return anything like this for their actual versions
-        # (gen2 returns "Opentrons-thermocycler-gen2" for instance) and this is not what any of
-        # the settings anywhere use.
-        self._model = (
-            ThermocyclerModuleModel.THERMOCYCLER_V1
-            if settings.model in ["thermocyclerModuleV1", "v1", "v01"]
-            else ThermocyclerModuleModel.THERMOCYCLER_V2
-        )
-        self._terminator = (
-            TC_GEN1_SERIAL_ACK
-            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1
-            else TC_GEN2_SERIAL_ACK
-        )
-        self._ack = (
-            TC_GEN1_ACK
-            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1
-            else TC_GEN2_ACK
-        )
         self.reset()
 
     def handle(self, line: str) -> Optional[str]:
         """Handle a line"""
         results = (self._handle(c) for c in self._parser.parse(line))
-        joined = " ".join(f"{r} {self._ack}" for r in results if r)
-        return self._ack if not joined else joined
+        joined = " ".join(r for r in results if r)
+        return None if not joined else joined
 
     def reset(self) -> None:
         self._lid_temperature = Temperature(
@@ -75,12 +50,6 @@ class ThermocyclerEmulator(AbstractEmulator):
         self.plate_volume = util.OptionalValue[float]()
         self.plate_ramp_rate = util.OptionalValue[float]()
 
-    def _pref(self, command: Command) -> str:
-        if self._model is ThermocyclerModuleModel.THERMOCYCLER_V1:
-            return ""
-        else:
-            return f"{command.gcode} "
-
     def _handle(self, command: Command) -> Optional[str]:  # noqa: C901
         """
         Handle a command.
@@ -93,7 +62,7 @@ class ThermocyclerEmulator(AbstractEmulator):
         elif command.gcode == GCODE.CLOSE_LID:
             self.lid_status = ThermocyclerLidStatus.CLOSED
         elif command.gcode == GCODE.GET_LID_STATUS:
-            return self._pref(command) + f"Lid:{self.lid_status}"
+            return f"Lid:{self.lid_status}"
         elif command.gcode == GCODE.SET_LID_TEMP:
             temperature = command.params["S"]
             assert isinstance(
@@ -107,7 +76,7 @@ class ThermocyclerEmulator(AbstractEmulator):
                 f"H:none Total_H:none"
             )
             self._lid_temperature.tick()
-            return self._pref(command) + res
+            return res
         elif command.gcode == GCODE.EDIT_PID_PARAMS:
             pass
         elif command.gcode == GCODE.SET_PLATE_TEMP:
@@ -136,7 +105,7 @@ class ThermocyclerEmulator(AbstractEmulator):
                 f"Total_H:{plate_total_hold_time} "
             )
             self._plate_temperature.tick()
-            return self._pref(command) + res
+            return res
         elif command.gcode == GCODE.SET_RAMP_RATE:
             self.plate_ramp_rate.val = command.params["S"]
         elif command.gcode == GCODE.DEACTIVATE_ALL:
@@ -147,34 +116,13 @@ class ThermocyclerEmulator(AbstractEmulator):
         elif command.gcode == GCODE.DEACTIVATE_BLOCK:
             self._plate_temperature.deactivate(temperature=util.TEMPERATURE_ROOM)
         elif command.gcode == GCODE.DEVICE_INFO:
-            # the gen2 returns a completely different device info format than the
-            # gen1 which is pretty cool
-            if self._model == ThermocyclerModuleModel.THERMOCYCLER_V1:
-                return (
-                    f"serial:{self._settings.serial_number} "
-                    f"model:{self._settings.model} "
-                    f"version:{self._settings.version}"
-                )
-            else:
-                return (
-                    command.gcode
-                    + " "
-                    + (
-                        f"FW:{self._settings.version} "
-                        f"HW:{self._settings.model} "
-                        f"SerialNo:{self._settings.serial_number}"
-                    )
-                )
-        elif command.gcode == GCODE.GET_ERROR_STATE:
-            if self._model is ThermocyclerModuleModel.THERMOCYCLER_V2:
-                return self._pref(command) + self._ack + self._pref(command)
-        return self._pref(command)
-
-    def get_terminator(self) -> bytes:
-        return self._terminator.encode()
-
-    def get_ack(self) -> bytes:
-        return self._ack.encode()
+            return (
+                f"serial:{self._settings.serial_number} "
+                f"model:{self._settings.model} "
+                f"version:{self._settings.version}"
+            )
+        return None
 
-    def get_autoack(self) -> bool:
-        return False
+    @staticmethod
+    def get_terminator() -> bytes:
+        return b"\r\n"

opentrons/hardware_control/module_control.py

@@ -2,11 +2,9 @@ from __future__ import annotations
 import asyncio
 import logging
 import re
-from typing import TYPE_CHECKING, List, Optional, Union, Callable
+from typing import TYPE_CHECKING, List, Optional, Union
 from glob import glob
 
-from opentrons_shared_data.errors.exceptions import EnumeratedError
-
 from opentrons.config import IS_ROBOT, IS_LINUX
 from opentrons.drivers.rpi_drivers import types, interfaces, usb, usb_simulator
 from opentrons.hardware_control.emulation.module_server.helpers import (
@@ -21,16 +19,8 @@ from opentrons.hardware_control.modules.module_calibration import (
 from opentrons.hardware_control.modules.types import ModuleAtPort, ModuleType
 from opentrons.hardware_control.modules import SimulatingModuleAtPort
 
-
 from opentrons.types import Point
-from .types import (
-    AionotifyEvent,
-    BoardRevision,
-    OT3Mount,
-    StatusBarUpdateEvent,
-    HardwareEvent,
-    AsynchronousModuleErrorNotification,
-)
+from .types import AionotifyEvent, BoardRevision, OT3Mount, StatusBarUpdateEvent
 from . import modules
 
 if TYPE_CHECKING:
@@ -61,21 +51,10 @@ class AttachedModulesControl:
         self,
         api: Union["API", "OT3API"],
         usb: interfaces.USBDriverInterface,
-        event_callback: Callable[[HardwareEvent], None],
     ) -> None:
         self._available_modules: List[modules.AbstractModule] = []
         self._api = api
         self._usb = usb
-        self._event_callback = event_callback
-        if not IS_ROBOT and not api.is_simulator:
-            # Start task that registers emulated modules.
-            self._emulation_listen_task: asyncio.Task[
-                None
-            ] | None = api.loop.create_task(
-                listen_module_connection(self.register_modules)
-            )
-        else:
-            self._emulation_listen_task = None
 
     def subscribe_to_api_event(self, module: modules.AbstractModule) -> None:
         self._api.add_status_bar_listener(module.event_listener)
@@ -85,20 +64,22 @@ class AttachedModulesControl:
         cls,
         api_instance: Union["API", "OT3API"],
         board_revision: BoardRevision,
-        event_callback: Callable[[HardwareEvent], None],
     ) -> AttachedModulesControl:
         usb_instance = (
             usb.USBBus(board_revision)
             if not api_instance.is_simulator and IS_ROBOT
             else usb_simulator.USBBusSimulator()
         )
-        mc_instance = cls(
-            api=api_instance, usb=usb_instance, event_callback=event_callback
-        )
+        mc_instance = cls(api=api_instance, usb=usb_instance)
 
         if not api_instance.is_simulator:
             # Do an initial scan of modules.
             await mc_instance.register_modules(mc_instance.scan())
+            if not IS_ROBOT:
+                # Start task that registers emulated modules.
+                api_instance.loop.create_task(
+                    listen_module_connection(mc_instance.register_modules)
+                )
 
         return mc_instance
 
@@ -106,37 +87,6 @@ class AttachedModulesControl:
     def available_modules(self) -> List[modules.AbstractModule]:
         return self._available_modules
 
-    async def clean_up(self) -> None:
-        """Clean up all registered modules and emulator scanning tasks (if any)."""
-        for module in self._available_modules:
-            await module.cleanup()
-        if self._emulation_listen_task is not None:
-            self._emulation_listen_task.cancel("cleanup")
-            try:
-                await self._emulation_listen_task
-            except asyncio.CancelledError:
-                pass
-            except Exception:
-                log.exception("Exception cleaning up emulation listen task")
-            finally:
-                self._emulation_listen_task = None
-
-    async def register_simulated_module(
-        self,
-        simulated_usb_port: types.USBPort,
-        type: modules.ModuleType,
-        sim_model: str,
-    ) -> modules.AbstractModule:
-        """Register a simulated module."""
-        module = await self.build_module(
-            "", simulated_usb_port, type, sim_model, sim_serial_number=None
-        )
-        self._available_modules.append(module)
-        self._available_modules = sorted(
-            self._available_modules, key=modules.AbstractModule.sort_key
-        )
-        return module
-
     async def build_module(
         self,
         port: str,
@@ -155,7 +105,6 @@ class AttachedModulesControl:
             sim_model=sim_model,
             sim_serial_number=sim_serial_number,
             disconnected_callback=self._disconnected_callback,
-            error_callback=self._async_error_callback,
         )
         last_event = StatusBarUpdateEvent(
             self._api.get_status_bar_state(), self._api.get_status_bar_enabled()
@@ -172,29 +121,6 @@ class AttachedModulesControl:
             self._api.loop,
         )
 
-    def _async_error_callback(
-        self,
-        exc: Exception,
-        model: str,
-        port: str,
-        serial: str | None,
-    ) -> None:
-        """Used by the module to indicate it saw an error from its data poller."""
-        try:
-            self._api.loop.call_soon(
-                self._event_callback,
-                AsynchronousModuleErrorNotification(
-                    exception=EnumeratedError.ensure(exc),
-                    module_serial=serial,
-                    module_model=modules.module_model_from_string(model),
-                    port=port,
-                ),
-            )
-        except Exception:
-            log.exception(
-                f"Async error callback for module {model} {serial} at {port} for exc {exc} failed"
-            )
-
     async def unregister_modules(
         self,
         mods_at_ports: Union[

opentrons/hardware_control/modules/__init__.py

@@ -27,9 +27,7 @@ from .types import (
     LiveData,
     ModuleData,
     ModuleDataValidator,
-    module_model_from_string,
 )
-
 from .errors import (
     UpdateError,
     AbsorbanceReaderDisconnectedError,
@@ -68,5 +66,4 @@ __all__ = [
     "FlexStackerStatus",
     "PlatformState",
     "StackerAxisState",
-    "module_model_from_string",
 ]

opentrons/hardware_control/modules/absorbance_reader.py

@@ -21,7 +21,6 @@ from opentrons.hardware_control.poller import Poller, Reader
 from opentrons.hardware_control.modules import mod_abc
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
-    ModuleErrorCallback,
     ModuleType,
     AbsorbanceReaderStatus,
     LiveData,
@@ -105,13 +104,12 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: ModuleDisconnectedCallback,
-        error_callback: ModuleErrorCallback,
+        execution_manager: Optional[ExecutionManager] = None,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
+        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "AbsorbanceReader":
         """
         Build and connect to an AbsorbanceReader
@@ -154,7 +152,6 @@ class AbsorbanceReader(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
 
         try:
@@ -173,9 +170,8 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Mapping[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: ModuleDisconnectedCallback,
-        error_callback: ModuleErrorCallback,
+        execution_manager: Optional[ExecutionManager] = None,
+        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> None:
         """
         Constructor
@@ -197,7 +193,6 @@ class AbsorbanceReader(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
         self._device_info = device_info
         self._reader = reader
@@ -376,5 +371,3 @@ class AbsorbanceReader(mod_abc.AbstractModule):
         self._error = str(error)
         if isinstance(error, AbsorbanceReaderDisconnectedError):
             self.disconnected_callback()
-        else:
-            self.error_callback(error)

opentrons/hardware_control/modules/flex_stacker.py

@@ -44,7 +44,6 @@ from opentrons.hardware_control.modules.types import (
     FlexStackerStatus,
     HopperDoorState,
     LatchState,
-    ModuleErrorCallback,
     ModuleDisconnectedCallback,
     ModuleType,
     PlatformState,
@@ -216,13 +215,12 @@ class FlexStacker(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: ModuleDisconnectedCallback,
-        error_callback: ModuleErrorCallback,
-        poll_interval_seconds: float | None = None,
+        execution_manager: Optional[ExecutionManager] = None,
+        poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
+        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "FlexStacker":
         """
         Build a FlexStacker
@@ -261,9 +259,11 @@ class FlexStacker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
 
+        # Set initialized callback
+        reader.set_initialized_callback(module._initialized_callback)
+
         # Enable stallguard
         for axis, config in STALLGUARD_CONFIG.items():
             await driver.set_stallguard_threshold(
@@ -286,9 +286,8 @@ class FlexStacker(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Mapping[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: ModuleDisconnectedCallback,
-        error_callback: ModuleErrorCallback,
+        execution_manager: Optional[ExecutionManager] = None,
+        disconnected_callback: ModuleDisconnectedCallback = None,
     ):
         super().__init__(
             port=port,
@@ -296,7 +295,6 @@ class FlexStacker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
         self._device_info = device_info
         self._driver = driver
@@ -306,20 +304,12 @@ class FlexStacker(mod_abc.AbstractModule):
         self._stacker_status = FlexStackerStatus.IDLE
         self._last_status_bar_event: Optional[StatusBarUpdateEvent] = None
         self._should_identify = False
-        # Set initialized callback
-        self._unsubscribe_init = reader.set_initialized_callback(
-            self._initialized_callback
-        )
-        self._unsubscribe_error = reader.set_error_callback(self._async_error_callback)
 
     async def _initialized_callback(self) -> None:
         """Called by the reader once the module is initialized."""
         if self._last_status_bar_event:
             await self._handle_status_bar_event(self._last_status_bar_event)
 
-    def _async_error_callback(self, exception: Exception) -> None:
-        self.error_callback(exception)
-
     async def cleanup(self) -> None:
         """Stop the poller task"""
         await self._poller.stop()
@@ -874,27 +864,10 @@ class FlexStackerReader(Reader):
         self.installation_detected = False
         self._refresh_state = False
         self._initialized_callback: Optional[Callable[[], Awaitable[None]]] = None
-        self._error_callback: Optional[Callable[[Exception], None]] = None
 
-    def set_initialized_callback(
-        self, callback: Callable[[], Awaitable[None]]
-    ) -> Callable[[], None]:
+    def set_initialized_callback(self, callback: Callable[[], Awaitable[None]]) -> None:
         """Sets the callback used when done initializing the module."""
         self._initialized_callback = callback
-        return self._remove_init_callback
-
-    def _remove_init_callback(self) -> None:
-        self._initialized_callback = None
-
-    def set_error_callback(
-        self, error_callback: Callable[[Exception], None]
-    ) -> Callable[[], None]:
-        """Register a handler for asynchronous hardware errors."""
-        self._error_callback = error_callback
-        return self._remove_error_callback
-
-    def _remove_error_callback(self) -> None:
-        self._error_callback = None
 
     async def read(self) -> None:
         await self.get_door_closed()
@@ -969,8 +942,6 @@ class FlexStackerReader(Reader):
         if exception is None:
             self.error = None
         else:
-            if self._error_callback:
-                self._error_callback(exception)
             try:
                 self.error = str(exception.args[0])
             except Exception: