opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/drivers/flex_stacker/utils.py

@@ -0,0 +1,19 @@
+NUMBER_OF_ZONES = 10
+NUMBER_OF_BINS = 128
+
+
+def validate_histogram_frame(data: bytes, next_frame_id: int) -> bool:
+    """Validate Histogram frame, Raise error if invalid."""
+    start_delimn = data[0]
+    assert (
+        start_delimn == 0x81  # histogram start byte
+    ), f"Invalid delimn, {hex(start_delimn)} != 0x81."
+    frame_id = data[4]
+    assert (
+        next_frame_id == frame_id
+    ), f"Invalid frame id, expected {next_frame_id} got {frame_id}."
+    frame_len = data[5]
+    assert (
+        frame_len == 128  # len is always 128
+    ), f"Invalid frame length, expected 128 got {frame_len}."
+    return True

opentrons/execute.py

@@ -23,7 +23,9 @@ from typing import (
     Union,
 )
 
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import (
+    labware_definition_type_adapter,
+)
 from opentrons_shared_data.robot.types import RobotType
 
 from opentrons import protocol_api, __version__, should_use_ot3
@@ -560,7 +562,7 @@ def _create_live_context_pe(
     # Non-async would use call_soon_threadsafe(), which makes the waiting harder.
     async def add_all_extra_labware() -> None:
         for labware_definition_dict in extra_labware.values():
-            labware_definition = LabwareDefinition.model_validate(
+            labware_definition = labware_definition_type_adapter.validate_python(
                 labware_definition_dict
             )
             pe.add_labware_definition(labware_definition)

opentrons/hardware_control/api.py

@@ -58,6 +58,7 @@ from .types import (
     SubSystem,
     SubSystemState,
     HardwareFeatureFlags,
+    TipScrapeType,
 )
 from . import modules
 from .robot_calibration import (
@@ -1040,6 +1041,7 @@ class API(
         mount: top_types.Mount,
         volume: Optional[float] = None,
         rate: float = 1.0,
+        correction_volume: float = 0.0,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) using this pipette.
@@ -1074,6 +1076,8 @@ class API(
         volume: Optional[float] = None,
         rate: float = 1.0,
         push_out: Optional[float] = None,
+        correction_volume: float = 0.0,
+        is_full_dispense: bool = False,
     ) -> None:
         """
         Dispense a volume of liquid in microliters(uL) using this pipette.
@@ -1253,6 +1257,7 @@ class API(
         mount: top_types.Mount,
         home_after: bool = True,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         spec, _ = self.plan_check_drop_tip(mount, home_after)
 

opentrons/hardware_control/backends/flex_protocol.py

@@ -462,3 +462,7 @@ class FlexBackend(Protocol):
 
     async def get_hepa_uv_state(self) -> Optional[HepaUVState]:
         ...
+
+    async def increase_evo_disp_count(self, mount: OT3Mount) -> None:
+        """Tell a pipette to increase it's evo-tip-dispense-count in eeprom."""
+        ...

opentrons/hardware_control/backends/ot3controller.py

@@ -216,6 +216,7 @@ from .types import HWStopCondition
 from .flex_protocol import FlexBackend
 from .status_bar_state import StatusBarStateController
 from opentrons_hardware.sensors.types import SensorDataType
+from opentrons_hardware.sensors.utils import send_evo_dispense_count_increase
 
 log = logging.getLogger(__name__)
 
@@ -1397,7 +1398,11 @@ class OT3Controller(FlexBackend):
             return
 
         if hasattr(self, "_event_watcher"):
-            if loop.is_running() and self._event_watcher:
+            if (
+                loop.is_running()
+                and self._event_watcher
+                and not self._event_watcher.closed
+            ):
                 self._event_watcher.close()
 
         messenger = getattr(self, "_messenger", None)
@@ -1824,3 +1829,9 @@ class OT3Controller(FlexBackend):
         """This is something we only use in the simulator.
         It is required so that PE simulations using ot3api don't break."""
         pass
+
+    async def increase_evo_disp_count(self, mount: OT3Mount) -> None:
+        """Tell a pipette to increase it's evo-tip-dispense-count in eeprom."""
+        await send_evo_dispense_count_increase(
+            self._messenger, sensor_node_for_pipette(OT3Mount(mount.value))
+        )

opentrons/hardware_control/backends/ot3simulator.py

@@ -871,3 +871,6 @@ class OT3Simulator(FlexBackend):
         """This is something we only use in the simulator.
         It is required so that PE simulations using ot3api don't break."""
         self._sim_tip_state[mount] = status
+
+    async def increase_evo_disp_count(self, mount: OT3Mount) -> None:
+        pass

opentrons/hardware_control/backends/subsystem_manager.py

@@ -1,6 +1,7 @@
 """
 Coordinate subsystem detection and updates.
 """
+
 import asyncio
 from contextlib import contextmanager, ExitStack
 from dataclasses import dataclass
@@ -57,7 +58,7 @@ class SubsystemManager:
     _expected_core_targets: Set[FirmwareTarget]
     _present_tools: tools.types.ToolSummary
     _tool_task_condition: asyncio.Condition
-    _tool_task_state: Union[bool, Exception]
+    _tool_task_state: Union[bool, BaseException]
     _updates_required: Dict[FirmwareTarget, FirmwareUpdateRequirements]
     _updates_ongoing: Dict[SubSystem, UpdateStatus]
     _update_bag: FirmwareUpdate
@@ -369,7 +370,8 @@ class SubsystemManager:
     async def _tool_detection_task_main(self) -> None:
         try:
             await self._tool_detection_task_protected()
-        except Exception as e:
+        except BaseException as e:
+            log.exception("Tool reader task failed")
             async with self._tool_task_condition:
                 self._tool_task_state = e
                 self._tool_task_condition.notify_all()
@@ -390,11 +392,12 @@ class SubsystemManager:
                 tool_nodes.add(NodeId.pipette_right)
             if update.gripper != ToolType.nothing_attached:
                 tool_nodes.add(NodeId.gripper)
-            base_nodes: Set[FirmwareTarget] = {
+            base_can_nodes: List[NodeId] = [
                 NodeId.pipette_left,
                 NodeId.pipette_right,
                 NodeId.gripper,
-            }
+            ]
+            base_nodes: Set[FirmwareTarget] = {n for n in base_can_nodes}
             try:
                 self._network_info.mark_absent(base_nodes - tool_nodes)
                 await self._probe_network_and_cache_fw_updates(
@@ -412,6 +415,7 @@ class SubsystemManager:
             )
             self._present_tools = await self._tool_detector.resolve(to_resolve, 10.0)
             log.info(f"Present tools are now {self._present_tools}")
+            await network.log_motor_usage_data(self._can_messenger)
             async with self._tool_task_condition:
                 self._tool_task_state = True
                 self._tool_task_condition.notify_all()

opentrons/hardware_control/instruments/ot2/instrument_calibration.py

@@ -9,12 +9,12 @@ from opentrons.calibration_storage import types, helpers
 from opentrons.types import Mount, Point
 from opentrons.hardware_control.types import OT3Mount
 
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition2
 
 if typing.TYPE_CHECKING:
     from opentrons_shared_data.pipette.types import LabwareUri
     from opentrons_shared_data.labware.types import (
-        LabwareDefinition as TypeDictLabwareDef,
+        LabwareDefinition2 as TypeDictLabwareDef2,
     )
 
 # These type aliases aid typechecking in tests that work the same on this and
@@ -119,12 +119,16 @@ def save_pipette_offset_calibration(
 # TODO (lc 09-26-2022) We should ensure that only LabwareDefinition models are passed
 # into this function instead of a mixture of TypeDicts and BaseModels
 def load_tip_length_for_pipette(
-    pipette_id: str, tiprack: typing.Union["TypeDictLabwareDef", LabwareDefinition]
+    pipette_id: str, tiprack: typing.Union["TypeDictLabwareDef2", LabwareDefinition2]
 ) -> TipLengthCalibration:
-    if isinstance(tiprack, LabwareDefinition):
+    if isinstance(tiprack, LabwareDefinition2):
         tiprack = typing.cast(
-            "TypeDictLabwareDef",
-            tiprack.model_dump(exclude_none=True, exclude_unset=True),
+            "TypeDictLabwareDef2",
+            tiprack.model_dump(
+                exclude_none=True,
+                exclude_unset=True
+                # todo(mm, 2025-02-13): Do we need by_alias=True here?
+            ),
         )
 
     tip_length_data = calibration_storage.load_tip_length_calibration(

opentrons/hardware_control/instruments/ot3/pipette_handler.py

@@ -32,6 +32,7 @@ from opentrons.hardware_control.types import (
     HardwareAction,
     Axis,
     OT3Mount,
+    TipScrapeType,
 )
 from opentrons.hardware_control.constants import (
     SHAKE_OFF_TIPS_SPEED,
@@ -78,6 +79,8 @@ class TipActionMoveSpec:
     speed: Optional[
         float
     ]  # allow speed for a movement to default to its axes' speed settings
+    scrape_axis: Optional[Axis] = None
+    # add a scrape motion in the middle of a tip drop
 
 
 @dataclass(frozen=True)
@@ -502,10 +505,19 @@ class OT3PipetteHandler:
         self._ihp_log.debug(f"{action} on {target.name}")
 
     def plunger_position(
-        self, instr: Pipette, ul: float, action: "UlPerMmAction"
+        self,
+        instr: Pipette,
+        ul: float,
+        action: "UlPerMmAction",
+        correction_volume: float = 0.0,
     ) -> float:
-        mm = ul / instr.ul_per_mm(ul, action)
-        position = instr.plunger_positions.bottom - mm
+        if ul == 0:
+            position = instr.plunger_positions.bottom
+        else:
+            multiplier = 1.0 + (correction_volume / ul)
+            mm_dist_from_bottom = ul / instr.ul_per_mm(ul, action)
+            mm_dist_from_bottom_corrected = mm_dist_from_bottom * multiplier
+            position = instr.plunger_positions.bottom - mm_dist_from_bottom_corrected
         return round(position, 6)
 
     def plunger_speed(
@@ -531,6 +543,7 @@ class OT3PipetteHandler:
         mount: OT3Mount,
         volume: Optional[float],
         rate: float,
+        correction_volume: float = 0.0,
     ) -> Optional[LiquidActionSpec]:
         """Check preconditions for aspirate, parse args, and calculate positions.
 
@@ -566,7 +579,10 @@ class OT3PipetteHandler:
         ), "Cannot aspirate more than pipette max volume"
 
         dist = self.plunger_position(
-            instrument, instrument.current_volume + asp_vol, "aspirate"
+            instr=instrument,
+            ul=instrument.current_volume + asp_vol,
+            action="aspirate",
+            correction_volume=correction_volume,
         )
         speed = self.plunger_speed(
             instrument, instrument.aspirate_flow_rate * rate, "aspirate"
@@ -591,6 +607,8 @@ class OT3PipetteHandler:
         volume: Optional[float],
         rate: float,
         push_out: Optional[float],
+        is_full_dispense: bool,
+        correction_volume: float = 0.0,
     ) -> Optional[LiquidActionSpec]:
         """Check preconditions for dispense, parse args, and calculate positions.
 
@@ -627,7 +645,21 @@ class OT3PipetteHandler:
         # of the OT-2 version of this class. Protocol Engine does its own clamping,
         # so we don't expect this to trigger in practice.
         disp_vol = min(instrument.current_volume, disp_vol)
-        is_full_dispense = numpy.isclose(instrument.current_volume - disp_vol, 0)
+
+        # TODO (Ryan): Remove this check in the future.
+        # we moved this logic up to protocol_engine but replacing with this check to make sure
+        # we don't accidentally call this incorrectly from somewhere else.
+        if not is_full_dispense and numpy.isclose(
+            instrument.current_volume - disp_vol, 0
+        ):
+            raise CommandPreconditionViolated(
+                message="Command created a full-dispense without the full dispense argument",
+                detail={
+                    "command": "dispense",
+                    "current-volume": str(instrument.current_volume),
+                    "dispense-volume": str(disp_vol),
+                },
+            )
 
         if disp_vol == 0:
             return None
@@ -659,7 +691,10 @@ class OT3PipetteHandler:
             )
 
         dist = self.plunger_position(
-            instrument, instrument.current_volume - disp_vol, "dispense"
+            instr=instrument,
+            ul=instrument.current_volume - disp_vol,
+            action="dispense",
+            correction_volume=correction_volume,
         )
         speed = self.plunger_speed(
             instrument, instrument.dispense_flow_rate * rate, "dispense"
@@ -889,6 +924,7 @@ class OT3PipetteHandler:
     def plan_lt_drop_tip(
         self,
         mount: OT3Mount,
+        scrape_tips: TipScrapeType = TipScrapeType.NONE,
     ) -> TipActionSpec:
         instrument = self.get_pipette(mount)
         config = instrument.drop_configurations.plunger_eject
@@ -896,6 +932,20 @@ class OT3PipetteHandler:
             raise CommandPreconditionViolated(
                 f"No plunger-eject drop tip configurations for {instrument.name} on {mount.name}"
             )
+        scrape_move: Optional[TipActionMoveSpec] = None
+        match scrape_tips:
+            case TipScrapeType.LEFT_ONE_COL:
+                scrape_move = TipActionMoveSpec(
+                    distance=-11, currents=None, speed=None, scrape_axis=Axis.X
+                )
+            case TipScrapeType.RIGHT_ONE_COL:
+                scrape_move = TipActionMoveSpec(
+                    distance=11, currents=None, speed=None, scrape_axis=Axis.X
+                )
+            case TipScrapeType.NONE:
+                scrape_move = None
+            case _:
+                scrape_move = None
         drop_seq = [
             TipActionMoveSpec(
                 distance=instrument.plunger_positions.drop_tip,
@@ -914,6 +964,9 @@ class OT3PipetteHandler:
                 },
             ),
         ]
+        if scrape_move:
+            # Add the scrape move before the plunger moves back up
+            drop_seq.insert(1, scrape_move)
 
         return TipActionSpec(
             tip_action_moves=drop_seq,

opentrons/hardware_control/modules/__init__.py

@@ -4,6 +4,7 @@ from .magdeck import MagDeck
 from .thermocycler import Thermocycler
 from .heater_shaker import HeaterShaker
 from .absorbance_reader import AbsorbanceReader
+from .flex_stacker import FlexStacker
 from .update import update_firmware
 from .utils import MODULE_TYPE_BY_NAME, build
 from .types import (
@@ -19,8 +20,13 @@ from .types import (
     MagneticStatus,
     HeaterShakerStatus,
     AbsorbanceReaderStatus,
+    PlatformState,
+    StackerAxisState,
+    FlexStackerStatus,
     SpeedStatus,
     LiveData,
+    ModuleData,
+    ModuleDataValidator,
 )
 from .errors import (
     UpdateError,
@@ -51,8 +57,13 @@ __all__ = [
     "HeaterShakerStatus",
     "SpeedStatus",
     "LiveData",
+    "ModuleData",
+    "ModuleDataValidator",
     "AbsorbanceReader",
     "AbsorbanceReaderStatus",
     "AbsorbanceReaderDisconnectedError",
-    "ModuleDisconnectedCallback",
+    "FlexStacker",
+    "FlexStackerStatus",
+    "PlatformState",
+    "StackerAxisState",
 ]

opentrons/hardware_control/modules/absorbance_reader.py

@@ -24,6 +24,7 @@ from opentrons.hardware_control.modules.types import (
     ModuleType,
     AbsorbanceReaderStatus,
     LiveData,
+    AbsorbanceReaderData,
     UploadFunction,
 )
 from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
@@ -243,17 +244,18 @@ class AbsorbanceReader(mod_abc.AbstractModule):
     def live_data(self) -> LiveData:
         """Return a dict of the module's dynamic information"""
         conf = self._measurement_config.data if self._measurement_config else dict()
+        data: AbsorbanceReaderData = {
+            "uptime": self.uptime,
+            "deviceStatus": self.status.value,
+            "lidStatus": self.lid_status.value,
+            "platePresence": self.plate_presence.value,
+            "measureMode": conf.get("measureMode", ""),
+            "sampleWavelengths": conf.get("sampleWavelengths", []),
+            "referenceWavelength": conf.get("referenceWavelength", 0),
+        }
         return {
             "status": self.status.value,
-            "data": {
-                "uptime": self.uptime,
-                "deviceStatus": self.status.value,
-                "lidStatus": self.lid_status.value,
-                "platePresence": self.plate_presence.value,
-                "measureMode": conf.get("measureMode", ""),
-                "sampleWavelengths": conf.get("sampleWavelengths", []),
-                "referenceWavelength": conf.get("referenceWavelength", 0),
-            },
+            "data": data,
         }
 
     @property