opentrons 8.7.0a2__py3-none-any.whl → 8.7.0a4__py3-none-any.whl

opentrons/hardware_control/modules/heater_shaker.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, Mapping, Callable
+from typing import Optional, Mapping
 from typing_extensions import Final
 
 from opentrons.drivers.rpi_drivers.types import USBPort
@@ -15,7 +15,6 @@ from opentrons.hardware_control.poller import Reader, Poller
 from opentrons.hardware_control.modules import mod_abc, update
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
-    ModuleErrorCallback,
     ModuleType,
     TemperatureStatus,
     SpeedStatus,
@@ -48,13 +47,12 @@ class HeaterShaker(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,
     ) -> "HeaterShaker":
         """
         Build a HeaterShaker
@@ -69,7 +67,6 @@ class HeaterShaker(mod_abc.AbstractModule):
             loop: Loop
             sim_model: The model name used by simulator
             disconnected_callback: Callback to inform the module controller that the device was disconnected
-            error_callback: Callback to inform the module controller of an asynchronous error
 
         Returns:
             HeaterShaker instance
@@ -94,7 +91,6 @@ class HeaterShaker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
 
         try:
@@ -113,9 +109,8 @@ class HeaterShaker(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,
@@ -123,22 +118,14 @@ class HeaterShaker(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
         self._reader = reader
         self._poller = poller
-        self._unsubscribe_reader = self._reader.register_error_handler(
-            self._handle_error
-        )
-
-    def _handle_error(self, error: Exception) -> None:
-        self.error_callback(error)
 
     async def cleanup(self) -> None:
         """Stop the poller task"""
-        self._unsubscribe_reader()
         await self._poller.stop()
         await self._driver.disconnect()
 
@@ -410,16 +397,6 @@ class HeaterShakerReader(Reader):
         self.labware_latch = HeaterShakerLabwareLatchStatus.IDLE_UNKNOWN
         self.error: Optional[str] = None
         self._driver = driver
-        self._handle_error: Callable[[Exception], None] | None = None
-
-    def register_error_handler(
-        self, handle_error: Callable[[Exception], None]
-    ) -> Callable[[], None]:
-        self._handle_error = handle_error
-        return self._unsubscribe_error_handler
-
-    def _unsubscribe_error_handler(self) -> None:
-        self._handle_error = None
 
     async def read(self) -> None:
         await self.read_temperature()
@@ -443,8 +420,6 @@ class HeaterShakerReader(Reader):
         if exception is None:
             self.error = None
         else:
-            if self._handle_error:
-                self._handle_error(exception)
             try:
                 self.error = str(exception.args[0])
             except Exception:

opentrons/hardware_control/modules/magdeck.py

@@ -49,13 +49,12 @@ class MagDeck(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: types.ModuleDisconnectedCallback,
-        error_callback: types.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: types.ModuleDisconnectedCallback = None,
     ) -> "MagDeck":
         """Factory function."""
         driver: AbstractMagDeckDriver
@@ -74,7 +73,6 @@ class MagDeck(mod_abc.AbstractModule):
             device_info=await driver.get_device_info(),
             driver=driver,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
         return mod
 
@@ -85,9 +83,8 @@ class MagDeck(mod_abc.AbstractModule):
         hw_control_loop: asyncio.AbstractEventLoop,
         driver: AbstractMagDeckDriver,
         device_info: Dict[str, str],
-        execution_manager: ExecutionManager,
-        disconnected_callback: types.ModuleDisconnectedCallback,
-        error_callback: types.ModuleErrorCallback,
+        execution_manager: Optional[ExecutionManager] = None,
+        disconnected_callback: types.ModuleDisconnectedCallback = None,
     ) -> None:
         """Constructor"""
         super().__init__(
@@ -96,7 +93,6 @@ class MagDeck(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

opentrons/hardware_control/modules/mod_abc.py

@@ -11,7 +11,6 @@ from ..execution_manager import ExecutionManager
 from .types import (
     BundledFirmware,
     ModuleDisconnectedCallback,
-    ModuleErrorCallback,
     UploadFunction,
     LiveData,
     ModuleType,
@@ -48,13 +47,12 @@ class AbstractModule(abc.ABC):
         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,
     ) -> "AbstractModule":
         """Modules should always be created using this factory.
 
@@ -67,9 +65,8 @@ class AbstractModule(abc.ABC):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: ExecutionManager,
-        disconnected_callback: ModuleDisconnectedCallback,
-        error_callback: ModuleErrorCallback,
+        execution_manager: Optional[ExecutionManager] = None,
+        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> None:
         self._port = port
         self._usb_port = usb_port
@@ -78,7 +75,6 @@ class AbstractModule(abc.ABC):
         self._bundled_fw: Optional[BundledFirmware] = self.get_bundled_fw()
         self._disconnected_callback = disconnected_callback
         self._updating = False
-        self._error_callback = error_callback
 
     @staticmethod
     def sort_key(inst: "AbstractModule") -> int:
@@ -107,10 +103,6 @@ class AbstractModule(abc.ABC):
         if self._disconnected_callback is not None:
             self._disconnected_callback(self.port, self.serial_number)
 
-    def error_callback(self, exc: Exception) -> None:
-        """Called from within the module object when an asynchronous hardware error occurrs."""
-        self._error_callback(exc, self.model(), self.port, self.serial_number)
-
     def get_bundled_fw(self) -> Optional[BundledFirmware]:
         """Get absolute path to bundled version of module fw if available."""
         if not IS_ROBOT:

opentrons/hardware_control/modules/tempdeck.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Dict, Optional, Callable
+from typing import Dict, Optional
 
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
-    ModuleErrorCallback,
     TemperatureStatus,
 )
 from opentrons.hardware_control.poller import Reader, Poller
@@ -39,13 +38,12 @@ class TempDeck(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,
     ) -> "TempDeck":
         """
         Build a TempDeck
@@ -85,7 +83,6 @@ class TempDeck(mod_abc.AbstractModule):
             device_info=await driver.get_device_info(),
             hw_control_loop=hw_control_loop,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
 
         try:
@@ -104,9 +101,8 @@ class TempDeck(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Dict[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"""
         super().__init__(
@@ -115,13 +111,11 @@ class TempDeck(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
         self._reader = reader
         self._poller = poller
-        self._reader.set_error_callback(self.error_callback)
 
     async def cleanup(self) -> None:
         """Stop the poller task."""
@@ -299,21 +293,7 @@ class TempDeckReader(Reader):
     def __init__(self, driver: AbstractTempDeckDriver) -> None:
         self.temperature = Temperature(current=25, target=None)
         self._driver = driver
-        self._error_callback: Optional[Callable[[Exception], None]] = None
 
     async def read(self) -> None:
         """Read the module's current and target temperatures."""
         self.temperature = await self._driver.get_temperature()
-
-    def set_error_callback(
-        self, error_callback: Callable[[Exception], None]
-    ) -> Callable[[], None]:
-        self._error_callback = error_callback
-        return self._remove_error_callback
-
-    def _remove_error_callback(self) -> None:
-        self._error_callback = None
-
-    def on_error(self, exception: Exception) -> None:
-        if self._error_callback:
-            self._error_callback(exception)

opentrons/hardware_control/modules/thermocycler.py

@@ -9,7 +9,6 @@ from opentrons.hardware_control.modules.lid_temp_status import LidTemperatureSta
 from opentrons.hardware_control.modules.plate_temp_status import PlateTemperatureStatus
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
-    ModuleErrorCallback,
     TemperatureStatus,
 )
 from opentrons.hardware_control.poller import Reader, Poller
@@ -37,8 +36,6 @@ DFU_PID = "df11"
 _TC_PLATE_LIFT_OPEN_DEGREES = 20
 _TC_PLATE_LIFT_RETURN_DEGREES = 23
 
-_TC_RAMP_RATE_ADDED_VERSION = (1, 0, 8)  # v1.0.8
-
 
 class ThermocyclerError(Exception):
     pass
@@ -65,13 +62,12 @@ class Thermocycler(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,
     ) -> "Thermocycler":
         """
         Build and connect to a Thermocycler
@@ -112,7 +108,6 @@ class Thermocycler(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
-            error_callback=error_callback,
         )
 
         try:
@@ -131,9 +126,8 @@ class Thermocycler(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Dict[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
@@ -156,7 +150,6 @@ class Thermocycler(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
@@ -166,13 +159,10 @@ class Thermocycler(mod_abc.AbstractModule):
         self._total_step_count: Optional[int] = None
         self._current_step_index: Optional[int] = None
         self._error: Optional[str] = None
-        self._unsubscribe_reader = self._reader.register_error_handler(
-            self._enter_error_state
-        )
+        self._reader.register_error_handler(self._enter_error_state)
 
     async def cleanup(self) -> None:
         """Stop the poller task."""
-        self._unsubscribe_reader()
         await self._poller.stop()
         await self._driver.disconnect()
 
@@ -275,19 +265,6 @@ class Thermocycler(mod_abc.AbstractModule):
         await self.open()
         await self._wait_for_lid_status(ThermocyclerLidStatus.OPEN)
 
-    def can_use_ramp_rate(self) -> bool:
-        version_string = self._device_info.get("version", "v")
-        if version_string.startswith("v"):
-            version_string = version_string[1:]
-        try:
-            version_tuple = tuple(int(c) for c in version_string.split("."))
-            return version_tuple >= _TC_RAMP_RATE_ADDED_VERSION
-        except (ValueError, IndexError):
-            log.error(
-                f"Invalid version from device: {self._device_info.get('version', '')}"
-            )
-            return False
-
     async def set_temperature(
         self,
         temperature: float,
@@ -313,11 +290,6 @@ class Thermocycler(mod_abc.AbstractModule):
 
         Returns: None
         """
-        if ramp_rate and not self.can_use_ramp_rate():
-            raise ThermocyclerError(
-                "Ramp rate is not supported by this thermocycler's firmware version, please update."
-            )
-
         await self.wait_for_is_running()
         await self._set_temperature_no_pause(
             temperature=temperature,
@@ -340,13 +312,11 @@ class Thermocycler(mod_abc.AbstractModule):
         total_seconds = seconds + (minutes * 60)
         hold_time = total_seconds if total_seconds > 0 else 0
 
-        if ramp_rate and not self.can_use_ramp_rate():
-            raise ThermocyclerError(
-                "Ramp rate is not supported by this thermocycler's firmware version, please update."
-            )
+        if ramp_rate is not None:
+            await self._driver.set_ramp_rate(ramp_rate=ramp_rate)
 
         await self._driver.set_plate_temperature(
-            temp=temperature, hold_time=hold_time, volume=volume, ramp_rate=ramp_rate
+            temp=temperature, hold_time=hold_time, volume=volume
         )
 
         task = self._loop.create_task(self._wait_for_block_target())
@@ -449,7 +419,6 @@ class Thermocycler(mod_abc.AbstractModule):
         celsius: float,
         hold_time_seconds: Optional[float] = None,
         volume: Optional[float] = None,
-        ramp_rate: Optional[float] = None,
     ) -> None:
         """Set the Thermocycler's target block temperature.
 
@@ -459,17 +428,10 @@ class Thermocycler(mod_abc.AbstractModule):
             celsius: The target block temperature, in degrees celsius.
         """
         await self.wait_for_is_running()
-
-        if ramp_rate and not self.can_use_ramp_rate():
-            raise ThermocyclerError(
-                "Ramp rate is not supported by this thermocycler's firmware version, please update."
-            )
-
         await self._driver.set_plate_temperature(
             temp=celsius,
             hold_time=hold_time_seconds,
             volume=volume,
-            ramp_rate=ramp_rate,
         )
         await self._reader.read_block_temperature()
 
@@ -634,12 +596,11 @@ class Thermocycler(mod_abc.AbstractModule):
         temperature = step.get("temperature")
         hold_time_minutes = step.get("hold_time_minutes", None)
         hold_time_seconds = step.get("hold_time_seconds", None)
-        ramp_rate = step.get("ramp_rate", None)
         await self._set_temperature_no_pause(
             temperature=temperature,  # type: ignore
             hold_time_minutes=hold_time_minutes,
             hold_time_seconds=hold_time_seconds,
-            ramp_rate=ramp_rate,
+            ramp_rate=None,
             volume=volume,
         )
 
@@ -712,7 +673,6 @@ class Thermocycler(mod_abc.AbstractModule):
             f" for troubleshooting."
         )
         asyncio.run_coroutine_threadsafe(self.cleanup(), self._loop)
-        self.error_callback(error)
 
 
 class ThermocyclerReader(Reader):
@@ -750,14 +710,8 @@ class ThermocyclerReader(Reader):
         if self._handle_error is not None:
             self._handle_error(exception)
 
-    def register_error_handler(
-        self, handle_error: Callable[[Exception], None]
-    ) -> Callable[[], None]:
+    def register_error_handler(self, handle_error: Callable[[Exception], None]) -> None:
         self._handle_error = handle_error
-        return self._unsubscribe_error_handler
-
-    def _unsubscribe_error_handler(self) -> None:
-        self._handle_error = None
 
     async def read(self) -> None:
         """Poll the thermocycler."""

opentrons/hardware_control/modules/types.py

@@ -11,7 +11,6 @@ from typing import (
     Awaitable,
     Union,
     Optional,
-    Protocol,
     cast,
     TYPE_CHECKING,
     TypeGuard,
@@ -45,7 +44,6 @@ class ThermocyclerStepBase(TypedDict):
 class ThermocyclerStep(ThermocyclerStepBase, total=False):
     hold_time_seconds: float
     hold_time_minutes: float
-    ramp_rate: Optional[float]
 
 
 class ThermocyclerCycle(TypedDict):
@@ -56,24 +54,7 @@ class ThermocyclerCycle(TypedDict):
 UploadFunction = Callable[[str, str, Dict[str, Any]], Awaitable[Tuple[bool, str]]]
 
 
-class ModuleDisconnectedCallback(Protocol):
-    """Protocol for the callback when the module should be disconnected."""
-
-    def __call__(self, port: str, serial: str | None) -> None:
-        ...
-
-
-class ModuleErrorCallback(Protocol):
-    """Protocol for the callback when the module sees a hardware error."""
-
-    def __call__(
-        self,
-        exc: Exception,
-        model: str,
-        port: str,
-        serial: str | None,
-    ) -> None:
-        ...
+ModuleDisconnectedCallback = Optional[Callable[[str, str | None], None]]
 
 
 class MagneticModuleData(TypedDict):

opentrons/hardware_control/modules/utils.py

@@ -6,12 +6,7 @@ from opentrons.drivers.rpi_drivers.types import USBPort
 
 from ..execution_manager import ExecutionManager
 
-from .types import (
-    ModuleDisconnectedCallback,
-    ModuleType,
-    SpeedStatus,
-    ModuleErrorCallback,
-)
+from .types import ModuleDisconnectedCallback, ModuleType, SpeedStatus
 from .mod_abc import AbstractModule
 from .tempdeck import TempDeck
 from .magdeck import MagDeck
@@ -51,11 +46,10 @@ async def build(
     simulating: bool,
     usb_port: USBPort,
     hw_control_loop: asyncio.AbstractEventLoop,
-    execution_manager: ExecutionManager,
-    disconnected_callback: ModuleDisconnectedCallback,
-    error_callback: ModuleErrorCallback,
+    execution_manager: Optional[ExecutionManager] = None,
     sim_model: Optional[str] = None,
     sim_serial_number: Optional[str] = None,
+    disconnected_callback: ModuleDisconnectedCallback = None,
 ) -> AbstractModule:
     return await _MODULE_CLS_BY_TYPE[type].build(
         port=port,
@@ -63,10 +57,9 @@ async def build(
         simulating=simulating,
         hw_control_loop=hw_control_loop,
         execution_manager=execution_manager,
-        disconnected_callback=disconnected_callback,
-        error_callback=error_callback,
         sim_model=sim_model,
         sim_serial_number=sim_serial_number,
+        disconnected_callback=disconnected_callback,
     )
 
 

opentrons/hardware_control/nozzle_manager.py

@@ -77,8 +77,6 @@ class NozzleMap:
     #: A map of all of the nozzles of an instrument
     full_instrument_rows: Dict[str, List[str]]
     #: A map of all the rows of an instrument
-    full_instrument_columns: Dict[str, List[str]]
-    #: A map of all the columns of an instrument
 
     @classmethod
     def determine_nozzle_configuration(
@@ -301,7 +299,6 @@ class NozzleMap:
             rows=rows,
             full_instrument_map_store=physical_nozzles,
             full_instrument_rows=physical_rows,
-            full_instrument_columns=physical_columns,
             columns=columns,
             configuration=cls.determine_nozzle_configuration(
                 physical_rows, rows, physical_columns, columns

opentrons/hardware_control/ot3api.py

@@ -74,7 +74,6 @@ from .types import (
     DoorStateNotification,
     ErrorMessageNotification,
     HardwareEvent,
-    AsynchronousModuleErrorNotification,
     HardwareEventHandler,
     HardwareAction,
     HepaFanState,
@@ -368,21 +367,6 @@ class OT3API(
 
         return futures
 
-    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
 
@@ -438,9 +422,7 @@ class OT3API(
 
         await api_instance.set_status_bar_enabled(status_bar_enabled)
         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.build_estop_detector()
@@ -502,9 +484,7 @@ class OT3API(
         )
         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(api_instance.loop)
@@ -647,10 +627,9 @@ class OT3API(
             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.LEFT
-            ),
+        return await self._backend.module_controls.build_module(
+            port="",
+            usb_port=USBPort(name="", port_number=1, port_group=PortGroup.LEFT),
             type=modules.ModuleType.from_model(model),
             sim_model=model.value,
         )

opentrons/hardware_control/scripts/update_module_fw.py

@@ -1,5 +1,4 @@
 """Module Firmware update script."""
-
 import argparse
 import asyncio
 from glob import glob
@@ -15,7 +14,6 @@ from opentrons.hardware_control import modules
 from opentrons.hardware_control.modules.mod_abc import AbstractModule
 from opentrons.hardware_control.modules.update import update_firmware
 from opentrons.hardware_control.types import BoardRevision
-from opentrons.hardware_control.execution_manager import ExecutionManager
 
 
 # Constants for checking if module is back online
@@ -86,9 +84,6 @@ async def build_module(
             port=port,
             usb_port=mod.usb_port,
             type=modules.MODULE_TYPE_BY_NAME[mod.name],
-            execution_manager=ExecutionManager(),
-            disconnected_callback=lambda *args: None,
-            error_callback=lambda *args: None,
             simulating=False,
             hw_control_loop=loop,
         )