opentrons 8.7.0a2__py3-none-any.whl → 8.7.0a4__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.0a2'
-__version_tuple__ = version_tuple = (8, 7, 0, 'a2')
+__version__ = version = '8.7.0a4'
+__version_tuple__ = version_tuple = (8, 7, 0, 'a4')
 
 __commit_id__ = commit_id = None

opentrons/drivers/thermocycler/abstract.py

@@ -55,7 +55,6 @@ 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"""
         ...

opentrons/drivers/thermocycler/driver.py

@@ -226,7 +226,6 @@ 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))
@@ -344,38 +343,10 @@ class ThermocyclerDriverV2(ThermocyclerDriver):
         """
         super().__init__(connection)
 
-    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 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 get_device_info(self) -> Dict[str, str]:
         """Send get device info command"""

opentrons/drivers/thermocycler/simulator.py

@@ -67,12 +67,10 @@ 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:

opentrons/hardware_control/api.py

@@ -44,7 +44,6 @@ from .execution_manager import ExecutionManagerProvider
 from .pause_manager import PauseManager
 from .module_control import AttachedModulesControl
 from .types import (
-    AsynchronousModuleErrorNotification,
     Axis,
     CriticalPoint,
     DoorState,
@@ -52,7 +51,6 @@ from .types import (
     ErrorMessageNotification,
     HardwareEventHandler,
     HardwareAction,
-    HardwareEvent,
     MotionChecks,
     PauseType,
     StatusBarState,
@@ -169,18 +167,6 @@ 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
 
@@ -261,9 +247,7 @@ class API(
             )
             await api_instance.cache_instruments()
             module_controls = await AttachedModulesControl.build(
-                api_instance,
-                board_revision=backend.board_revision,
-                event_callback=api_instance._send_module_notification,
+                api_instance, board_revision=backend.board_revision
             )
             backend.module_controls = module_controls
             checked_loop.create_task(backend.watch(loop=checked_loop))
@@ -322,9 +306,7 @@ class API(
         )
         await api_instance.cache_instruments()
         module_controls = await AttachedModulesControl.build(
-            api_instance,
-            board_revision=backend.board_revision,
-            event_callback=api_instance._send_module_notification,
+            api_instance, board_revision=backend.board_revision
         )
         backend.module_controls = module_controls
         await backend.watch()
@@ -1330,10 +1312,9 @@ class API(
             self.is_simulator
         ), "Cannot build simulating module from non-simulating hardware control API"
 
-        return await self._backend.module_controls.register_simulated_module(
-            simulated_usb_port=USBPort(
-                name="", port_number=1, port_group=PortGroup.MAIN
-            ),
+        return await self._backend.module_controls.build_module(
+            port="",
+            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,19 +360,13 @@ 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:  # noqa: C901
+    async def clean_up(self) -> None:
         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
-                and not self._event_watcher.closed
-            ):
+            if loop.is_running() and self._event_watcher:
                 self._event_watcher.close()
         if hasattr(self, "gpio_chardev"):
             try:

opentrons/hardware_control/backends/ot3controller.py

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

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/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: