opentrons 8.8.0a6__tar.gz → 8.8.0a9__tar.gz

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentrons
-Version: 8.8.0a6
+Version: 8.8.0a9
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Project-URL: opentrons.com, https://www.opentrons.com
 Project-URL: Source Code On Github, https://github.com/Opentrons/opentrons/tree/edge/api
@@ -24,7 +24,7 @@ Requires-Dist: click<9,>=8.0.0
 Requires-Dist: importlib-metadata>=1.0; python_version < '3.8'
 Requires-Dist: jsonschema<4.18.0,>=3.0.1
 Requires-Dist: numpy<2,>=1.20.0
-Requires-Dist: opentrons-shared-data==8.8.0a6
+Requires-Dist: opentrons-shared-data==8.8.0a9
 Requires-Dist: packaging>=21.0
 Requires-Dist: pydantic-settings<3,>=2
 Requires-Dist: pydantic<3,>=2.0.0
@@ -32,6 +32,6 @@ Requires-Dist: pyserial>=3.5
 Requires-Dist: pyusb==1.2.1
 Requires-Dist: typing-extensions<5,>=4.0.0
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex]==8.8.0a6; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex]==8.8.0a9; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware==8.8.0a6; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware==8.8.0a9; extra == 'ot2-hardware'

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '8.8.0a6'
-__version_tuple__ = version_tuple = (8, 8, 0, 'a6')
+__version__ = version = '8.8.0a9'
+__version_tuple__ = version_tuple = (8, 8, 0, 'a9')
 
 __commit_id__ = commit_id = None

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/drivers/asyncio/communication/serial_connection.py

@@ -12,6 +12,8 @@ from .errors import (
     ErrorResponse,
     BaseErrorCode,
     DefaultErrorCodes,
+    UnhandledGcode,
+    GCodeCacheFull,
 )
 from .async_serial import AsyncSerial
 
@@ -555,6 +557,23 @@ class AsyncResponseSerialConnection(SerialConnection):
                 # A read timeout, end
                 yield "empty-unknown", data
 
+    def _raise_on_parser_error(self, data: str, response: bytes) -> None:
+        """Raise an exception if this response contains an error from the gcode parser on the module.
+
+        This has to be treated specially because multiack commands won't get multiple acks if the command
+        fails at the parse stage. The errors handled here should be kept in sync with the module gcode
+        parse code.
+        """
+        try:
+            str_response = self.process_raw_response(
+                command=data, response=response.replace(self._ack, b"").decode()
+            )
+            self.raise_on_error(response=str_response, request=data)
+        except (UnhandledGcode, GCodeCacheFull):
+            raise
+        except Exception:
+            pass
+
     async def _send_one_retry(self, data: str, acks: int) -> list[str]:
         data_encode = data.encode("utf-8")
         log.debug(f"{self._name}: Write -> {data_encode!r}")
@@ -567,8 +586,10 @@ class AsyncResponseSerialConnection(SerialConnection):
         async for response_type, response in self._consume_responses(acks):
             if response_type == "error":
                 async_errors.append(response)
+                self._raise_on_parser_error(data, response)
             elif response_type == "response":
                 command_acks.append(response)
+                self._raise_on_parser_error(data, response)
             else:
                 break
 

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/hardware_control/ot3api.py

@@ -52,6 +52,7 @@ from opentrons_shared_data.errors.exceptions import (
     InvalidActuator,
     FirmwareUpdateFailedError,
     PipetteLiquidNotFoundError,
+    PipetteOverpressureError,
 )
 
 from .util import use_or_initialize_loop, check_motion_bounds
@@ -3088,6 +3089,7 @@ class OT3API(
         volume: float,
         rate: float = 1.0,
         movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3107,7 +3109,7 @@ class OT3API(
         end_position = target_position_from_absolute(
             realmount,
             end_point,
-            self.critical_point_for,
+            partial(self.critical_point_for, cp_override=end_critical_point),
             top_types.Point(*self._config.left_mount_offset),
             top_types.Point(*self._config.right_mount_offset),
             top_types.Point(*self._config.gripper_mount_offset),
@@ -3122,6 +3124,9 @@ class OT3API(
         delay: Optional[Tuple[List[Axis], float]] = None
         if movement_delay is not None:
             delay = ([Axis.X, Axis.Y, Axis.Z_L, Axis.Z_R], movement_delay)
+        self._log.info(
+            f"aspirate_while_tracking: end at {end_point} {end_critical_point}, machine pos {end_position}, with plunger {target_pos}, delay {delay}"
+        )
         try:
             await self._backend.set_active_current(
                 {aspirate_spec.axis: aspirate_spec.current}
@@ -3136,6 +3141,11 @@ class OT3API(
                     home_flagged_axes=False,
                     delay=delay,
                 )
+        except PipetteOverpressureError:
+            self._log.exception("Aspirate failed with overpressure")
+            # refresh positions during an over pressure here so we know where the gantry stopped.
+            await self.refresh_positions()
+            raise
         except Exception:
             self._log.exception("Aspirate failed")
             aspirate_spec.instr.set_current_volume(0)
@@ -3152,6 +3162,7 @@ class OT3API(
         rate: float = 1.0,
         is_full_dispense: bool = False,
         movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
@@ -3171,7 +3182,7 @@ class OT3API(
         end_position = target_position_from_absolute(
             realmount,
             end_point,
-            self.critical_point_for,
+            partial(self.critical_point_for, cp_override=end_critical_point),
             top_types.Point(*self._config.left_mount_offset),
             top_types.Point(*self._config.right_mount_offset),
             top_types.Point(*self._config.gripper_mount_offset),
@@ -3186,7 +3197,9 @@ class OT3API(
         delay: Optional[Tuple[List[Axis], float]] = None
         if movement_delay is not None:
             delay = ([Axis.X, Axis.Y, Axis.Z_L, Axis.Z_R], movement_delay)
-
+        self._log.info(
+            f"dispense_while_tracking: end at {end_point} {end_critical_point}, machine pos {end_position}, with plunger {target_pos}, delay {delay}"
+        )
         try:
             await self._backend.set_active_current(
                 {dispense_spec.axis: dispense_spec.current}
@@ -3201,6 +3214,11 @@ class OT3API(
                     home_flagged_axes=False,
                     delay=delay,
                 )
+        except PipetteOverpressureError:
+            self._log.exception("Aspirate failed with overpressure")
+            # refresh positions during an over pressure here so we know where the gantry stopped.
+            await self.refresh_positions()
+            raise
         except Exception:
             self._log.exception("dispense failed")
             dispense_spec.instr.set_current_volume(0)

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/hardware_control/protocols/liquid_handler.py

@@ -129,15 +129,17 @@ class LiquidHandler(
         volume: float,
         flow_rate: float = 1.0,
         movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Aspirate a volume of liquid (in microliters/uL) while moving the z axis synchronously.
 
         :param mount: A robot mount that the instrument is on.
-        :param z_distance: The distance the z axis will move during apsiration.
+        :param end_point: The deck coordinate point to move the tip to during the aspirate.
         :param volume: The volume of liquid to be aspirated.
         :param flow_rate: The flow rate to aspirate with.
         :param movement_delay: Time to wait after the pipette starts aspirating before x/y/z movement.
+        :param end_critical_point: The critical point for the end_point position.
         """
         ...
 
@@ -172,15 +174,17 @@ class LiquidHandler(
         flow_rate: float = 1.0,
         is_full_dispense: bool = False,
         movement_delay: Optional[float] = None,
+        end_critical_point: Optional[CriticalPoint] = None,
     ) -> None:
         """
         Dispense a volume of liquid (in microliters/uL) while moving the z axis synchronously.
 
         :param mount: A robot mount that the instrument is on.
-        :param z_distance: The distance the z axis will move during dispensing.
+        :param end_point: The deck coordinate point to move the tip to during the dispense.
         :param volume: The volume of liquid to be dispensed.
         :param flow_rate: The flow rate to dispense with.
         :param movement_delay: Time to wait after the pipette starts dispensing before x/y/z movement.
+        :param end_critical_point: The critical point for the end_point position.
         """
         ...
 

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -1,8 +1,8 @@
 """A Protocol-Engine-friendly wrapper for opentrons.motion_planning.deck_conflict."""
+
 from __future__ import annotations
 import logging
 from typing import (
-    Optional,
     Tuple,
     Union,
     List,
@@ -12,7 +12,6 @@ from opentrons_shared_data.errors.exceptions import MotionPlanningFailureError
 from opentrons.protocol_engine.errors import LocationIsStagingSlotError
 from opentrons_shared_data.module import FLEX_TC_LID_COLLISION_ZONE
 
-from opentrons.hardware_control import CriticalPoint
 from opentrons.motion_planning import adjacent_slots_getters
 
 from opentrons.protocol_engine import (
@@ -101,7 +100,9 @@ def check_safe_for_pipette_movement(  # noqa: C901
     )
     primary_nozzle = engine_state.pipettes.get_primary_nozzle(pipette_id)
 
-    destination_cp = _get_critical_point_to_use(engine_state, labware_id)
+    destination_cp = engine_state.motion.get_critical_point_for_wells_in_labware(
+        labware_id
+    )
     pipette_bounds_at_well_location = (
         engine_state.pipettes.get_pipette_bounds_at_specified_move_to_position(
             pipette_id=pipette_id,
@@ -189,21 +190,6 @@ def check_safe_for_pipette_movement(  # noqa: C901
             )
 
 
-def _get_critical_point_to_use(
-    engine_state: StateView, labware_id: str
-) -> Optional[CriticalPoint]:
-    """Return the critical point to use when accessing the given labware."""
-    # TODO (spp, 2024-09-17): looks like Y_CENTER of column is the same as its XY_CENTER.
-    #   I'm using this if-else ladder to be consistent with what we do in
-    #   `MotionPlanning.get_movement_waypoints_to_well()`.
-    #   We should probably use only XY_CENTER in both places.
-    if engine_state.labware.get_should_center_column_on_target_well(labware_id):
-        return CriticalPoint.Y_CENTER
-    elif engine_state.labware.get_should_center_pipette_on_target_well(labware_id):
-        return CriticalPoint.XY_CENTER
-    return None
-
-
 def _slot_has_potential_colliding_object(
     engine_state: StateView,
     pipette_bounds: Tuple[Point, Point, Point, Point],

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_api/labware.py

@@ -822,8 +822,8 @@ class Labware:
     def set_offset(self, x: float, y: float, z: float) -> None:
         """Set the labware's position offset.
 
-        The offset is an x, y, z vector in deck coordinates
-        (see :ref:`protocol-api-deck-coords`).
+        An offset of `(x=0, y=0, z=0)` means the labware's uncalibrated position before
+        any offset from Labware Position Check is applied.
 
         How the motion system applies the offset depends on the API level of the protocol.
 
@@ -882,6 +882,9 @@ class Labware:
     def calibrated_offset(self) -> Point:
         """The front-left-bottom corner of the labware, including its labware offset.
 
+        The offset is an x, y, z vector in deck coordinates
+        (see :ref:`protocol-api-deck-coords`).
+
         When running a protocol in the Opentrons App or on the touchscreen, Labware
         Position Check sets the labware offset.
         """

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_engine/commands/aspirate_while_tracking.py

@@ -147,6 +147,40 @@ class AspirateWhileTrackingImplementation(
             model_utils=self._model_utils,
             movement_delay=params.movement_delay,
         )
+        state_update.append(aspirate_result.state_update)
+        if isinstance(aspirate_result, DefinedErrorData):
+            state_update.set_liquid_operated(
+                labware_id=params.labwareId,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+                volume_added=CLEAR,
+            )
+            if isinstance(aspirate_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=state_update,
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+            elif isinstance(aspirate_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=aspirate_result.public.id,
+                        createdAt=aspirate_result.public.createdAt,
+                        wrappedErrors=aspirate_result.public.wrappedErrors,
+                        errorInfo=aspirate_result.public.errorInfo,
+                    ),
+                    state_update=state_update,
+                    state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
+                )
+
         position_after_aspirate = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -155,27 +189,12 @@ class AspirateWhileTrackingImplementation(
             y=position_after_aspirate.y,
             z=position_after_aspirate.z,
         )
-        if isinstance(aspirate_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=aspirate_result.public,
-                state_update=aspirate_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=AspirateWhileTrackingResult(
                 volume=aspirate_result.public.volume,
                 position=result_deck_point,
             ),
-            state_update=aspirate_result.state_update.set_liquid_operated(
+            state_update=state_update.set_liquid_operated(
                 labware_id=params.labwareId,
                 well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
                     params.labwareId,

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_engine/commands/capture_image.py

@@ -12,7 +12,11 @@ from opentrons.system.camera import (
     CONTRAST_DEFAULT,
     BRIGHTNESS_DEFAULT,
     SATURATION_DEFAULT,
+    ZOOM_MIN,
+    ZOOM_MAX,
     ZOOM_DEFAULT,
+    RESOLUTION_MIN,
+    RESOLUTION_MAX,
     RESOLUTION_DEFAULT,
 )
 from ..types import PreconditionTypes
@@ -161,6 +165,47 @@ def _revert_image_parameters(
     )
 
 
+def _validate_image_params(params: CaptureImageParams) -> None:
+    # Validate the filename param provided to fail analysis
+    if params.fileName is not None and set(SPECIAL_CHARACTERS).intersection(
+        set(params.fileName)
+    ):
+        raise FileNameInvalidError(
+            message=f"Capture image filename cannot contain character(s): {SPECIAL_CHARACTERS.intersection(set(params.fileName))}"
+        )
+
+    # Validate the image filter parameters
+    if params.zoom is not None and (params.zoom < ZOOM_MIN or params.zoom > ZOOM_MAX):
+        raise CameraSettingsInvalidError(
+            message="Capture image zoom must be a valid value from 1.0X to 2.0X zoom."
+        )
+    if params.resolution is not None and (
+        params.resolution[0] < RESOLUTION_MIN[0]
+        or params.resolution[1] < RESOLUTION_MIN[1]
+        or params.resolution[0] > RESOLUTION_MAX[0]
+        or params.resolution[1] > RESOLUTION_MAX[1]
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image resolution must be a valid resolution from 240p through 8K resolutuon."
+        )
+    if params.brightness is not None and (
+        params.brightness < 0 or params.brightness > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image brightness must be a percentage from 0% to 100%."
+        )
+    if params.contrast is not None and (params.contrast < 0 or params.contrast > 100):
+        raise CameraSettingsInvalidError(
+            message="Capture image contrast must be a percentage from 0% to 100%."
+        )
+    if params.saturation is not None and (
+        params.saturation < 0 or params.saturation > 100
+    ):
+        raise CameraSettingsInvalidError(
+            message="Capture image saturation must be a percentage from 0% to 100%."
+        )
+
+
 class CaptureImageImpl(
     AbstractCommandImpl[CaptureImageParams, SuccessData[CaptureImageResult]]
 ):
@@ -186,33 +231,8 @@ class CaptureImageImpl(
             {PreconditionTypes.IS_CAMERA_USED: True}
         )
 
-        # Validate the filename param provided to fail analysis
-        if params.fileName is not None and set(SPECIAL_CHARACTERS).intersection(
-            set(params.fileName)
-        ):
-            raise FileNameInvalidError(
-                message=f"Capture image filename cannot contain character(s): {SPECIAL_CHARACTERS.intersection(set(params.fileName))}"
-            )
-
-        # Validate the image filter parameters
-        if params.brightness is not None and (
-            params.brightness < 0 or params.brightness > 100
-        ):
-            raise CameraSettingsInvalidError(
-                message="Capture image brightness must be a percentage from 0% to 100%."
-            )
-        if params.contrast is not None and (
-            params.contrast < 0 or params.contrast > 100
-        ):
-            raise CameraSettingsInvalidError(
-                message="Capture image contrast must be a percentage from 0% to 100%."
-            )
-        if params.saturation is not None and (
-            params.saturation < 0 or params.saturation > 100
-        ):
-            raise CameraSettingsInvalidError(
-                message="Capture image saturation must be a percentage from 0% to 100%."
-            )
+        # Validate that the provided parameters are all acceptable. We do this here and in system/camera.py to ensure analysis fails properly.
+        _validate_image_params(params)
 
         # Handle capturing an image with the CameraProvider - Engine camera settings take priority
         camera_settings = await self._camera_provider.get_camera_settings()

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_engine/commands/dispense_while_tracking.py

@@ -143,6 +143,40 @@ class DispenseWhileTrackingImplementation(
             model_utils=self._model_utils,
             movement_delay=params.movement_delay,
         )
+        state_update.append(dispense_result.state_update)
+        if isinstance(dispense_result, DefinedErrorData):
+            state_update.set_liquid_operated(
+                labware_id=params.labwareId,
+                well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
+                    params.labwareId,
+                    params.wellName,
+                    params.pipetteId,
+                ),
+                volume_added=CLEAR,
+            )
+            if isinstance(dispense_result.public, OverpressureError):
+                return DefinedErrorData(
+                    public=OverpressureError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=state_update,
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+            elif isinstance(dispense_result.public, StallOrCollisionError):
+                return DefinedErrorData(
+                    public=StallOrCollisionError(
+                        id=dispense_result.public.id,
+                        createdAt=dispense_result.public.createdAt,
+                        wrappedErrors=dispense_result.public.wrappedErrors,
+                        errorInfo=dispense_result.public.errorInfo,
+                    ),
+                    state_update=state_update,
+                    state_update_if_false_positive=dispense_result.state_update_if_false_positive,
+                )
+
         position_after_dispense = await self._gantry_mover.get_position(
             params.pipetteId
         )
@@ -151,28 +185,12 @@ class DispenseWhileTrackingImplementation(
             y=position_after_dispense.y,
             z=position_after_dispense.z,
         )
-
-        if isinstance(dispense_result, DefinedErrorData):
-            return DefinedErrorData(
-                public=dispense_result.public,
-                state_update=dispense_result.state_update.set_liquid_operated(
-                    labware_id=params.labwareId,
-                    well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
-                        params.labwareId,
-                        params.wellName,
-                        params.pipetteId,
-                    ),
-                    volume_added=CLEAR,
-                ),
-                state_update_if_false_positive=dispense_result.state_update_if_false_positive,
-            )
-
         return SuccessData(
             public=DispenseWhileTrackingResult(
                 volume=dispense_result.public.volume,
                 position=result_deck_point,
             ),
-            state_update=dispense_result.state_update.set_liquid_operated(
+            state_update=state_update.set_liquid_operated(
                 labware_id=params.labwareId,
                 well_names=self._state_view.geometry.get_wells_covered_by_pipette_with_active_well(
                     params.labwareId,

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_engine/commands/pipetting_common.py

@@ -9,11 +9,16 @@ from pydantic import BaseModel, Field
 from opentrons_shared_data.errors import ErrorCodes
 from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
 from opentrons.protocol_engine.types import AspiratedFluid, FluidKind
-from opentrons_shared_data.errors.exceptions import PipetteOverpressureError
+from opentrons_shared_data.errors.exceptions import (
+    PipetteOverpressureError,
+    StallOrCollisionDetectedError,
+)
 from .command import DefinedErrorData, SuccessData
 from opentrons.protocol_engine.state.update_types import StateUpdate
 from opentrons.types import Point
 
+from .movement_common import StallOrCollisionError
+
 if TYPE_CHECKING:
     from ..execution.pipetting import PipettingHandler
     from ..resources import ModelUtils
@@ -247,7 +252,9 @@ async def aspirate_while_tracking(
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
     movement_delay: Optional[float] = None,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an aspirate while tracking microoperation."""
     try:
         volume_aspirated = await pipetting.aspirate_while_tracking(
@@ -275,6 +282,21 @@ async def aspirate_while_tracking(
             ),
             state_update=StateUpdate().set_fluid_unknown(pipette_id=pipette_id),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(
@@ -299,7 +321,9 @@ async def dispense_while_tracking(
     pipetting: PipettingHandler,
     model_utils: ModelUtils,
     movement_delay: Optional[float] = None,
-) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[OverpressureError]:
+) -> SuccessData[BaseLiquidHandlingResult] | DefinedErrorData[
+    OverpressureError
+] | DefinedErrorData[StallOrCollisionError]:
     """Execute an dispense while tracking microoperation."""
     # The current volume won't be none since it passed validation
     current_volume = (
@@ -338,6 +362,21 @@ async def dispense_while_tracking(
                 pipette_id=pipette_id, ready_to_aspirate=False
             ),
         )
+    except StallOrCollisionDetectedError as e:
+        return DefinedErrorData(
+            public=StallOrCollisionError(
+                id=model_utils.generate_id(),
+                createdAt=model_utils.get_timestamp(),
+                wrappedErrors=[
+                    ErrorOccurrence.from_failed(
+                        id=model_utils.generate_id(),
+                        createdAt=model_utils.get_timestamp(),
+                        error=e,
+                    )
+                ],
+            ),
+            state_update=StateUpdate().clear_all_pipette_locations(),
+        )
     else:
         return SuccessData(
             public=BaseLiquidHandlingResult(

{opentrons-8.8.0a6 → opentrons-8.8.0a9}/src/opentrons/protocol_engine/execution/pipetting.py

@@ -1,4 +1,5 @@
 """Pipetting command handling."""
+
 from typing import Optional, Iterator, Tuple
 from typing_extensions import Protocol as TypingProtocol
 from contextlib import contextmanager
@@ -208,6 +209,9 @@ class HardwarePipettingHandler(PipettingHandler):
                 end_point=end_point,
                 volume=adjusted_volume,
                 movement_delay=movement_delay,
+                end_critical_point=self.get_state_view().motion.get_critical_point_for_wells_in_labware(
+                    labware_id
+                ),
             )
         return adjusted_volume
 
@@ -239,6 +243,9 @@ class HardwarePipettingHandler(PipettingHandler):
                 push_out=push_out,
                 is_full_dispense=is_full_dispense,
                 movement_delay=movement_delay,
+                end_critical_point=self.get_state_view().motion.get_critical_point_for_wells_in_labware(
+                    labware_id
+                ),
             )
         return adjusted_volume