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

opentrons/hardware_control/modules/heater_shaker.py

@@ -2,21 +2,19 @@ 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
 from opentrons.drivers.heater_shaker.driver import HeaterShakerDriver
 from opentrons.drivers.heater_shaker.abstract import AbstractHeaterShakerDriver
 from opentrons.drivers.heater_shaker.simulator import SimulatingDriver
-from opentrons.drivers.asyncio.communication.errors import UnhandledGcode
 from opentrons.drivers.types import Temperature, RPM, HeaterShakerLabwareLatchStatus
 from opentrons.hardware_control.execution_manager import ExecutionManager
 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,
@@ -49,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
@@ -70,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
@@ -95,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:
@@ -114,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,
@@ -124,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()
 
@@ -411,22 +397,11 @@ 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()
         await self.read_rpm()
         await self.read_labware_latch()
-        await self._read_errors()
         self._set_error(None)
 
     def on_error(self, exception: Exception) -> None:
@@ -445,19 +420,7 @@ 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:
                 self.error = repr(exception)
-
-    async def _read_errors(self) -> None:
-        try:
-            await self._driver.get_error_state()
-        except UnhandledGcode:
-            # This device's firmware cannot accept this command, because it
-            # hasn't been updated or because it's a gen1. Ignore the result.
-            pass
-        # If the error is one we should let pass, raise it so the top level
-        # error handler can take it.

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
@@ -22,7 +21,6 @@ from opentrons.drivers.thermocycler import (
     ThermocyclerDriverV2,
     ThermocyclerDriverFactory,
 )
-from opentrons.drivers.asyncio.communication.errors import UnhandledGcode
 
 
 log = logging.getLogger(__name__)
@@ -38,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
@@ -66,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
@@ -113,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:
@@ -132,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
@@ -157,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
@@ -167,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()
 
@@ -276,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,
@@ -314,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,
@@ -341,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())
@@ -450,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.
 
@@ -460,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()
 
@@ -635,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 +672,7 @@ class Thermocycler(mod_abc.AbstractModule):
             f"https://support.opentrons.com/en/articles/3469797-thermocycler-module"
             f" for troubleshooting."
         )
-        self.error_callback(error)
+        asyncio.run_coroutine_threadsafe(self.cleanup(), self._loop)
 
 
 class ThermocyclerReader(Reader):
@@ -750,31 +710,14 @@ 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."""
         await self.read_lid_status()
         await self.read_lid_temperature()
         await self.read_block_temperature()
-        await self._read_errors()
-
-    async def _read_errors(self) -> None:
-        try:
-            await self._driver.get_error_state()
-        except UnhandledGcode:
-            # This device's firmware cannot accept this command, because it
-            # hasn't been updated or because it's a gen1. Ignore the result.
-            pass
-        # If the error is one we should let pass, raise it so the top level
-        # error handler can take it.
 
     async def read_lid_status(self) -> None:
         self.lid_status = await self._driver.get_lid_status()

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