opentrons 8.8.0a7__py3-none-any.whl → 8.8.1__py3-none-any.whl

opentrons/_version.py

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

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/hardware_control/ot3api.py

@@ -3089,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.
@@ -3108,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),
@@ -3123,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}
@@ -3158,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.
@@ -3177,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),
@@ -3192,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}

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/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/protocol_api/instrument_context.py

@@ -242,14 +242,14 @@ class InstrumentContext(publisher.CommandPublisher):
         :param flow_rate: The absolute flow rate in µL/s. If ``flow_rate`` is specified,
                           ``rate`` must not be set.
         :type flow_rate: float
-        :param end_location: Tells the robot to move between location and end_location
-            while aspirating liquid. When this argument is used the location and
-            end_location must both be :py:class:`.Location`.
+        :param end_location: Tells the robot to move from the specified ``location`` to the specified ``end_location``
+            while aspirating liquid. When this argument is used, the ``location`` and
+            ``end_location`` must both be a :py:class:`.Location`.
         :type end_location: :py:class:`.Location`
-        :param movement_delay: Delay the x/y/z movement during a dynamic aspirate.
-            This option is only valid when using end_location. When this argument
-            is used, the x/y/z movement will wait movement_delay seconds after the pipette
-            starts to aspirate before moving. This may help when dispensing very viscous liquids
+        :param movement_delay: Time in seconds to delay after the pipette starts aspirating and before it begins moving from  ``location`` to ``end_location``.
+            This option is only valid when using ``end_location``. When this argument
+            is used, the pipette will wait the specified time after the pipette
+            starts to aspirate before moving. This may help when aspirating very viscous liquids
             that need to build up some pressure before liquid starts to flow.
         :type movement_delay: float
         :returns: This instance.
@@ -263,6 +263,8 @@ class InstrumentContext(publisher.CommandPublisher):
 
         .. versionchanged:: 2.24
             Added the ``flow_rate`` parameter.
+        .. versionchanged:: 2.27
+            Added the ``end_location`` and ``movement_delay`` parameters.
         """
         if flow_rate is not None:
             if self.api_version < APIVersion(2, 24):
@@ -479,13 +481,13 @@ class InstrumentContext(publisher.CommandPublisher):
                           ``rate`` must not be set.
         :type flow_rate: float
 
-        :param end_location: Tells the robot to move between location and end_location
-            while dispensing liquid held in the pipette. When this argument is used
-            the location and end_location must both be a :py:class:`.Location`.
+        :param end_location: Tells the robot to move from the specified ``location`` to the specified ``end_location``
+            while dispensing liquid held in the pipette. When this argument is used,
+            the ``location`` and ``end_location`` must both be a :py:class:`.Location`.
         :type end_location: :py:class:`.Location`
-        :param movement_delay: Delay the x/y/z movement during a dynamic dispense.
-            This option is only valid when using end_location. When this argument
-            is used, the x/y/z movement will wait movement_delay seconds after the pipette
+        :param movement_delay: Time in seconds to delay after the pipette starts dispensing and before it begins moving from  ``location`` to ``end_location``.
+            This option is only valid when using ``end_location``. When this argument
+            is used, the pipette will wait the specified time after the pipette
             starts to dispense before moving. This may help when dispensing very viscous liquids
             that need to build up some pressure before liquid starts to flow.
         :type movement_delay: float
@@ -510,6 +512,9 @@ class InstrumentContext(publisher.CommandPublisher):
         .. versionchanged:: 2.24
             ``location`` is no longer required if the pipette just moved to, dispensed, or blew out
             into a trash bin or waste chute.
+
+        .. versionchanged:: 2.27
+            Added the ``end_location`` and ``movement_delay`` parameters.
         """
         if self.api_version < APIVersion(2, 15) and push_out:
             raise APIVersionError(
@@ -849,7 +854,7 @@ class InstrumentContext(publisher.CommandPublisher):
         """
         Mix a volume of liquid by repeatedly aspirating and dispensing it in a multiple locations.
 
-        See :ref:`dynamic_mix` for examples.
+        See :ref:`dynamic-mix` for examples.
 
         :param repetitions: Number of times to mix (default is 1).
         :param volume: The volume to mix, measured in µL. If unspecified, defaults
@@ -860,13 +865,13 @@ class InstrumentContext(publisher.CommandPublisher):
                        it will behave the same as a volume of ``None``/unspecified: mix
                        the full working volume of the pipette. On API levels at or above 2.16,
                        no liquid will be mixed.
-        :param aspirate_start_location: The :py:class:`~.types.Location` where the pipette will aspirate from.
-        :param aspirate_end_location: The :py:class:`~.types.Location` If this argument is supplied
-                    the pipette will move between aspirate_start_location and aspirate_end_location
+        :param aspirate_start_location: The :py:class:`~.types.Location` where the pipette will start aspirating from.
+        :param aspirate_end_location: A :py:class:`~.types.Location`. If specified,
+                    the pipette will move between the ``aspirate_start_location`` and the ``aspirate_end_location``
                     while performing the aspirate.
-        :param dispense_start_location: The :py:class:`~.types.Location` where the pipette will dispense to.
-        :param dispense_end_location: The :py:class:`~.types.Location` If this argument is supplied
-                    the pipette will move between dispense_start_location and dispense_end_location
+        :param dispense_start_location: The :py:class:`~.types.Location` where the pipette will start dispensing to.
+        :param dispense_end_location: A :py:class:`~.types.Location`. If specified,
+                    the pipette will move between the ``dispense_start_location`` and the ``dispense_end_location``
                     while performing the dispense.
         :param rate: How quickly the pipette aspirates and dispenses liquid while
                      mixing. The aspiration flow rate is calculated as ``rate``
@@ -884,10 +889,10 @@ class InstrumentContext(publisher.CommandPublisher):
                                pipette will not push out after earlier repetitions. If
                                not specified or ``None``, the pipette will push out the
                                default non-zero amount. See :ref:`push-out-dispense`.
-        :param movement_delay: Delay the x/y/z movement during a dynamic mix.
-            This option is only valid when using aspirate_end_location or dispense_end_location.
-            When this argument is used, the x/y/z movement will wait movement_delay seconds
-            after the pipette starts to aspirate/dispense before moving. This may help when mixing
+        :param movement_delay: Time in seconds to delay after the pipette starts aspirating or dispensing and before it begins moving from the ``aspirate_start_location`` or ``dispense_start_location`` to the ``aspirate_end_location`` or ``dispense_end_location``.
+            This option is only valid when using ``aspirate_end_location`` or ``dispense_end_location``.
+            When this argument is used, the pipette will wait the specified time
+            after the pipette starts to aspirate or dispense before moving. This may help when mixing
             very viscous liquids that need to build up some pressure before liquid starts to flow.
         :type movement_delay: float
         :raises: ``UnexpectedTipRemovalError`` -- If no tip is attached to the pipette.
@@ -895,10 +900,7 @@ class InstrumentContext(publisher.CommandPublisher):
 
         .. note::
 
-            All the arguments of ``mix`` are optional. However, if you omit one of them,
-            all subsequent arguments must be passed as keyword arguments. For instance,
-            ``pipette.mix(1, location=wellplate['A1'])`` is a valid call, but
-            ``pipette.mix(1, wellplate['A1'])`` is not.
+            The ``aspirate_start_location`` and ``dispense_start_location`` arguments of ``dynamic_mix`` are required.
 
         """
         _log.debug(
@@ -2267,9 +2269,11 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
-                tips=[tip._core for tip in transfer_args.tips]
-                if transfer_args.tips is not None
-                else None,
+                tips=(
+                    [tip._core for tip in transfer_args.tips]
+                    if transfer_args.tips is not None
+                    else None
+                ),
             )
 
         return self
@@ -2441,9 +2445,11 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
-                tips=[tip._core for tip in transfer_args.tips]
-                if transfer_args.tips is not None
-                else None,
+                tips=(
+                    [tip._core for tip in transfer_args.tips]
+                    if transfer_args.tips is not None
+                    else None
+                ),
             )
 
         return self
@@ -2615,9 +2621,11 @@ class InstrumentContext(publisher.CommandPublisher):
                 trash_location=transfer_args.trash_location,
                 return_tip=return_tip,
                 keep_last_tip=verified_keep_last_tip,
-                tips=[tip._core for tip in transfer_args.tips]
-                if transfer_args.tips is not None
-                else None,
+                tips=(
+                    [tip._core for tip in transfer_args.tips]
+                    if transfer_args.tips is not None
+                    else None
+                ),
             )
 
         return self

opentrons/protocol_api/module_contexts.py

@@ -456,13 +456,14 @@ class TemperatureModuleContext(ModuleContext):
     @publish(command=cmds.tempdeck_set_temp)
     @requires_version(2, 3)
     def start_set_temperature(self, celsius: float) -> Task:
-        """Set the target temperature without waiting for the target to be hit.
+        """Sets the Temperature Module's target temperature and returns immediately without waiting for the module to reach the target. Allows the protocol to proceed while the Temperature Module heats.
 
         .. versionchanged:: 2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
+            Returns a :py:class:`Task` object that represents concurrent heating.
+            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the module to finish heating.
+
+        In API version 2.26 or below, this function returns ``None``.
 
-        On version 2.26 or below, this function returns ``None``.
         :param celsius: A value between 4 and 95, representing the target temperature in °C.
         """
         task = self._core.set_target_temperature(celsius)
@@ -715,9 +716,9 @@ class ThermocyclerContext(ModuleContext):
         ramp_rate: Optional[float] = None,
         block_max_volume: Optional[float] = None,
     ) -> Task:
-        """Starts to set the target temperature for the well block, in °C.
+        """Sets the target temperature for the Thermocycler Module's well block, in °C.
 
-        Returns a task object that represents concurrent preheating.
+        Returns a :py:class:`Task` object that represents concurrent heating.
         Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
         the preheat to complete.
 
@@ -726,10 +727,10 @@ class ThermocyclerContext(ModuleContext):
         :param block_max_volume: The greatest volume of liquid contained in any
                                  individual well of the loaded labware, in µL.
                                  If not specified, the default is 25 µL.
-                                 After API version 2.27 it will attempt to use
-                                 the liquid tracking of the labware first and
-                                 then fall back to the 25 if there is no probed
-                                 or loaded liquid.
+                                 In API version 2.27 and newer, the API will first attempt to use
+                                 the liquid tracking in labware,
+                                 then default to 25 µL if the protocol lacks probed
+                                 or loaded liquid information.
         """
 
         if block_max_volume is None:
@@ -746,10 +747,6 @@ class ThermocyclerContext(ModuleContext):
     def set_lid_temperature(self, temperature: float) -> None:
         """Set the target temperature for the heated lid, in °C.
 
-        Returns a task object that represents concurrent preheating.
-        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-        the preheat to complete.
-
         :param temperature: A value between 37 and 110, representing the target
                             temperature in °C.
 
@@ -765,20 +762,14 @@ class ThermocyclerContext(ModuleContext):
     @publish(command=cmds.thermocycler_start_set_lid_temperature)
     @requires_version(2, 27)
     def start_set_lid_temperature(self, temperature: float) -> Task:
-        """Set the target temperature for the heated lid, in °C.
+        """Sets a target temperature to heat the Thermocycler Module's lid, in °C. Returns a :py:class:`Task` object that represents concurrent heating.
 
-        Returns a task object that represents concurrent preheating.
         Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for
-        the preheat to complete.
+        the lid to reach the target temperature.
 
         :param temperature: A value between 37 and 110, representing the target
                             temperature in °C.
 
-        .. note::
-
-            The Thermocycler will proceed to the next command immediately after
-            ``temperature`` is reached.
-
         """
         task = self._core.start_set_target_lid_temperature(celsius=temperature)
         return Task(api_version=self._api_version, core=task)
@@ -824,11 +815,10 @@ class ThermocyclerContext(ModuleContext):
         repetitions: int,
         block_max_volume: Optional[float] = None,
     ) -> Task:
-        """Start a Thermocycler profile and return a :py:class:`Task` representing its execution.
+        """Starts a defined Thermocycler Module profile and return a :py:class:`Task` representing its concurrent execution.
         Profile is defined as a cycle of ``steps``, for a given number of ``repetitions``.
 
-        Returns a task object that represents concurrent execution of the profile.
-        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
+        Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the profile run to complete.
 
         :param steps: List of steps that make up a single cycle.
                       Each list item should be a dictionary that maps to the parameters
@@ -1104,17 +1094,17 @@ class HeaterShakerContext(ModuleContext):
         """Set target temperature and return immediately.
 
         Sets the Heater-Shaker's target temperature and returns immediately without
-        waiting for the target to be reached. Does not delay the protocol until
-        target temperature has reached.
+        waiting for the target to be reached. Allows the protocol to proceed while the module
+        reaches the target temperature.
         Use :py:meth:`~.HeaterShakerContext.wait_for_temperature` to delay
-        protocol execution for api levels below 2.27.
+        protocol execution for API levels below 2.27.
 
         .. versionchanged:: 2.25
             Removed the minimum temperature limit of 37 °C. Note that temperatures under ambient are
             not achievable.
         .. versionchanged:: 2.27
-            Returns a task object that represents concurrent preheating.
-            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the preheat to complete.
+            Returns a :py:class:`Task` object that represents concurrent heating.
+            Pass the task object to :py:meth:`ProtocolContext.wait_for_tasks` to wait for the module to reach the target temperature.
 
         :param celsius: A value under 95, representing the target temperature in °C.
                         Values are automatically truncated to two decimal places,
@@ -1158,11 +1148,11 @@ class HeaterShakerContext(ModuleContext):
     @requires_version(2, 27)
     @publish(command=cmds.heater_shaker_set_shake_speed)
     def set_shake_speed(self, rpm: int) -> Task:
-        """Set a shake speed in rpm to run in the background.
+        """Sets the Heater-Shaker's shake speed in RPM and returns a :py:class:`Task` that represents concurrent shaking.
 
         .. note::
 
-            Before shaking, this command will retract the pipettes upward if they are parked adjacent to the Heater-Shaker.
+            Before shaking, this command retracts pipettes upward if they are adjacent to the Heater-Shaker Module.
 
         :param rpm: A value between 200 and 3000, representing the target shake speed in revolutions per minute.
         """

opentrons/protocol_api/protocol_context.py

@@ -1289,7 +1289,7 @@ class ProtocolContext(CommandPublisher):
     def wait_for_tasks(self, tasks: list[Task]) -> None:
         """Wait for a list of tasks to complete before executing subsequent commands.
 
-        :param list Task: tasks: A list of Task objects to wait for.
+        :param list Task: tasks: A list of :py:class:`Task` objects to wait for.
 
         Task objects can be commands that are allowed to run concurrently.
         """
@@ -1299,7 +1299,7 @@ class ProtocolContext(CommandPublisher):
     @publish(command=cmds.create_timer)
     @requires_version(2, 27)
     def create_timer(self, seconds: float) -> Task:
-        """Create a timer task that runs in the background.
+        """Create a timer :py:class:`Task` that runs in the background.
 
         :param float seconds: The time to delay in seconds.
 
@@ -1833,17 +1833,15 @@ class ProtocolContext(CommandPublisher):
         brightness: Optional[float] = None,
         saturation: Optional[float] = None,
     ) -> None:
-        """Capture an image using the camera. Captured images get saved as a result of the protocol run.
-
-        :param home_before: Boolean to home the pipette before capturing an image.
-        :param filename: Filename to use when saving the captured image as a file.
-        :param resolution: Width/height tuple to determine the resolution to use when capturing an image.
-        :param zoom: Optional zoom level, with minimum/default of 1x zoom and maximum of 2x zoom.
-        :param contrast: Contrast level to be applied to an image, range is 0% to 100%.
-        :param brightness: Brightness level to be applied to an image, range is 0% to 100%.
-        :param saturation: Saturation level to be applied to an image, range is 0% to 100%.
-
-        .. versionadded:: 2.27
+        """Capture an image using the camera. Captured images are saved as during the protocol run.
+
+        :param home_before: If ``True``, homes the pipette before capturing an image.
+        :param filename: Custom name to use when saving the captured image as a file. The custom name is added as the beginning of the filename, followed by the robot and protocol name, a timestamp for the protocol run, the step number, and a timestamp for the command running when the image was captured.
+        :param resolution: Accepts a width and height (as a tuple) to determine the camera's resolution when capturing the image.
+        :param zoom: Zoom level the camera will use. Defaults to the minimum of 1x zoom (``1.0``) and has a maximum of 2x zoom (``2.0``).
+        :param contrast: The contrast level to be applied to the image. The acceptable range is from 0 to 100; provided as a percentage (``0.0`` to ``100.0``).
+        :param brightness: The brightness level to be applied to the image. The acceptable range is from 0 to 100; provided as a percentage (``0.0`` to ``100.0``).
+        :param saturation: The saturation level to be applied to the image. The acceptable range is from 0 to 100; provided as a percentage (``0.0`` to ``100.0``).
 
         """
         if home_before is True:

opentrons/protocol_engine/commands/aspirate_while_tracking.py

@@ -147,7 +147,17 @@ 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(
@@ -156,15 +166,7 @@ class AspirateWhileTrackingImplementation(
                         wrappedErrors=aspirate_result.public.wrappedErrors,
                         errorInfo=aspirate_result.public.errorInfo,
                     ),
-                    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=state_update,
                     state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
                 )
             elif isinstance(aspirate_result.public, StallOrCollisionError):
@@ -175,15 +177,7 @@ class AspirateWhileTrackingImplementation(
                         wrappedErrors=aspirate_result.public.wrappedErrors,
                         errorInfo=aspirate_result.public.errorInfo,
                     ),
-                    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=state_update,
                     state_update_if_false_positive=aspirate_result.state_update_if_false_positive,
                 )
 
@@ -200,7 +194,7 @@ class AspirateWhileTrackingImplementation(
                 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/protocol_engine/commands/dispense_while_tracking.py

@@ -143,8 +143,17 @@ 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(
@@ -153,15 +162,7 @@ class DispenseWhileTrackingImplementation(
                         wrappedErrors=dispense_result.public.wrappedErrors,
                         errorInfo=dispense_result.public.errorInfo,
                     ),
-                    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=state_update,
                     state_update_if_false_positive=dispense_result.state_update_if_false_positive,
                 )
             elif isinstance(dispense_result.public, StallOrCollisionError):
@@ -172,15 +173,7 @@ class DispenseWhileTrackingImplementation(
                         wrappedErrors=dispense_result.public.wrappedErrors,
                         errorInfo=dispense_result.public.errorInfo,
                     ),
-                    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=state_update,
                     state_update_if_false_positive=dispense_result.state_update_if_false_positive,
                 )
 
@@ -197,7 +190,7 @@ class DispenseWhileTrackingImplementation(
                 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/protocol_engine/execution/command_executor.py

@@ -248,7 +248,7 @@ class CommandExecutor:
             # Only capture photos of errors if the setting to do so is enabled
             if (
                 camera_enablement.cameraEnabled
-                and camera_enablement.errorRecoveryEnabled
+                and camera_enablement.errorRecoveryCameraEnabled
             ):
                 # todo(chb, 2025-10-25): Eventually we will need to pass in client provided global settings here
                 image_data = await self._camera_provider.capture_image(

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
 

opentrons/protocol_engine/resources/camera_provider.py

@@ -27,7 +27,7 @@ class CameraSettings(BaseModel):
     liveStreamEnabled: bool = Field(
         ..., description="Enablement status for the Opentrons Live Stream service."
     )
-    errorRecoveryEnabled: bool = Field(
+    errorRecoveryCameraEnabled: bool = Field(
         ..., description="Enablement status for camera usage with Error Recovery."
     )
 
@@ -83,7 +83,7 @@ class CameraProvider:
             return self._camera_settings_callback()
         # If we are in analysis or simulation, return as if the camera is enabled
         return CameraSettings(
-            cameraEnabled=True, liveStreamEnabled=True, errorRecoveryEnabled=True
+            cameraEnabled=True, liveStreamEnabled=True, errorRecoveryCameraEnabled=True
         )
 
     async def capture_image(

opentrons/protocol_engine/state/motion.py

@@ -1,4 +1,5 @@
 """Motion state store and getters."""
+
 from dataclasses import dataclass
 from typing import List, Optional, Union
 import logging
@@ -78,14 +79,9 @@ class MotionView:
             isinstance(current_location, CurrentWell)
             and current_location.pipette_id == pipette_id
         ):
-            if self._labware.get_should_center_column_on_target_well(
-                current_location.labware_id
-            ):
-                critical_point = CriticalPoint.Y_CENTER
-            elif self._labware.get_should_center_pipette_on_target_well(
+            critical_point = self.get_critical_point_for_wells_in_labware(
                 current_location.labware_id
-            ):
-                critical_point = CriticalPoint.XY_CENTER
+            )
         return PipetteLocationData(mount=mount, critical_point=critical_point)
 
     def _get_pipette_offset_for_reservoirs(
@@ -124,6 +120,17 @@ class MotionView:
             x_offset = -1 * well_x_dim / 24
         return Point(x=x_offset, y=y_offset)
 
+    def get_critical_point_for_wells_in_labware(
+        self, labware_id: str
+    ) -> CriticalPoint | None:
+        """Get the appropriate critical point override for this labware."""
+        if self._labware.get_should_center_column_on_target_well(labware_id):
+            return CriticalPoint.Y_CENTER
+        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
+            return CriticalPoint.XY_CENTER
+        else:
+            return None
+
     def get_movement_waypoints_to_well(
         self,
         pipette_id: str,
@@ -142,11 +149,7 @@ class MotionView:
         """Calculate waypoints to a destination that's specified as a well."""
         location = current_well or self._pipettes.get_current_location()
 
-        destination_cp: Optional[CriticalPoint] = None
-        if self._labware.get_should_center_column_on_target_well(labware_id):
-            destination_cp = CriticalPoint.Y_CENTER
-        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
-            destination_cp = CriticalPoint.XY_CENTER
+        destination_cp = self.get_critical_point_for_wells_in_labware(labware_id)
 
         destination = self._geometry.get_well_position(
             labware_id=labware_id,
@@ -397,12 +400,7 @@ class MotionView:
             mm_from_edge=mm_from_edge,
             edge_path_type=edge_path_type,
         )
-        critical_point: Optional[CriticalPoint] = None
-
-        if self._labware.get_should_center_column_on_target_well(labware_id):
-            critical_point = CriticalPoint.Y_CENTER
-        elif self._labware.get_should_center_pipette_on_target_well(labware_id):
-            critical_point = CriticalPoint.XY_CENTER
+        critical_point = self.get_critical_point_for_wells_in_labware(labware_id)
 
         return [
             motion_planning.Waypoint(position=p, critical_point=critical_point)

opentrons/protocol_runner/legacy_command_mapper.py

@@ -841,8 +841,16 @@ class LegacyCommandMapper:
             # We just set this above, so we know it's not None.
             started_at=succeeded_command.startedAt,  # type: ignore[arg-type]
         )
+        state_update = StateUpdate()
+        state_update.set_load_module(
+            module_id=module_id,
+            definition=loaded_definition,
+            slot_name=module_load_info.deck_slot,
+            requested_model=requested_model,
+            serial_number=module_load_info.module_serial,
+        )
         succeed_action = pe_actions.SucceedCommandAction(
-            command=succeeded_command, state_update=StateUpdate()
+            command=succeeded_command, state_update=state_update
         )
 
         self._command_count["LOAD_MODULE"] = count + 1

opentrons/system/camera.py

@@ -158,7 +158,7 @@ async def update_live_stream_status(
         and camera_enable_settings.liveStreamEnabled
     ):
         # Check to see if the camera device is available
-        raw_device = str(contents["SOURCE"])[1:-1]
+        raw_device = str(contents["SOURCE"])
         if not os.path.exists(raw_device):
             log.error(
                 f"Opentrons Live Stream cannot sample the camera. No video device found with device path: {raw_device}"

{opentrons-8.8.0a7.dist-info → opentrons-8.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentrons
-Version: 8.8.0a7
+Version: 8.8.1
 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.0a7
+Requires-Dist: opentrons-shared-data==8.8.1
 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.0a7; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex]==8.8.1; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware==8.8.0a7; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware==8.8.1; extra == 'ot2-hardware'

{opentrons-8.8.0a7.dist-info → opentrons-8.8.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 opentrons/__init__.py,sha256=TQ_Ca_zzAM3iLzAysWKkFkQHG8-imihxDPQbLCYrf-E,4533
-opentrons/_version.py,sha256=3_09fbZUs-VXMGXA5MWazmEhOw8hSkQkzbw2loEdOUY,712
+opentrons/_version.py,sha256=eQUIXJRYEBbJqcRjwHRZJ0kk0C6ZLf5dDS9zB1kUSBg,704
 opentrons/execute.py,sha256=J7kZFRxpbrj_e5XS37Zc9fsliBqxZBMrITT7jdUgJvw,29478
 opentrons/legacy_broker.py,sha256=XnuEBBlrHCThc31RFW2UR0tGqctqWZ-CZ9vSC4L9whU,1553
 opentrons/ordered_set.py,sha256=g-SB3qA14yxHu9zjGyc2wC7d2TUCBE6fKZlHAtbPzI8,4082
@@ -53,7 +53,7 @@ opentrons/drivers/asyncio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 opentrons/drivers/asyncio/communication/__init__.py,sha256=b-rd_I0ecbexGm6b9T91JLfFUrCyui9V1N1j-fzy0SQ,523
 opentrons/drivers/asyncio/communication/async_serial.py,sha256=Tzv_uXvMYhJF2LXsJWDRA3hdg5_qCo3863zvn7Y66WY,5439
 opentrons/drivers/asyncio/communication/errors.py,sha256=-4pNGVKE83VUPNt1UTBLDzKtty3LxAhUNp-9yLENqyw,2678
-opentrons/drivers/asyncio/communication/serial_connection.py,sha256=eR68U7v1Zn-gYikr8eUAck59iPFv2aeox2nPFGi_a8o,22053
+opentrons/drivers/asyncio/communication/serial_connection.py,sha256=_gBhJxuoGN8Z8qNhOELHDC5PSXHp0G5M-0ZShoWlmrY,22973
 opentrons/drivers/flex_stacker/__init__.py,sha256=LiM0onRlgC-JfFBd0QseQU0-3WuuIxa7GNFj7Douiq8,351
 opentrons/drivers/flex_stacker/abstract.py,sha256=50xrkTC5qI_BsvlBGpdBLwF3GVi7HhKVSgloKwcrzNA,6744
 opentrons/drivers/flex_stacker/driver.py,sha256=m43LDktLtRXSco_SgM-6yfx0GwoxkrV8Gz5aDtLgfN4,31670
@@ -111,7 +111,7 @@ opentrons/hardware_control/module_control.py,sha256=id1W3xqT-W-zyt2PVodo2Abx127t
 opentrons/hardware_control/motion_utilities.py,sha256=aIaT-qzkRpZaSmfTTSqs1wl6m7LBxwKHIhgkFean01o,10274
 opentrons/hardware_control/nozzle_manager.py,sha256=AG4HKrV4n0Bm0UOEsaAYAURtkJwuEyk97e9Nqv2_nD0,17021
 opentrons/hardware_control/ot3_calibration.py,sha256=vHB17U-FBzytvM8QeEu5kRYPo8lFwAo31ZEpiU4yf_0,45000
-opentrons/hardware_control/ot3api.py,sha256=r2CeWSwBcXEUtyyBa3UFW3c_aHja82LpiegKla-i03s,130824
+opentrons/hardware_control/ot3api.py,sha256=TNZnoe-52kobBcc622VAOdPByhw2DWl4H5_eO4fp9ag,131393
 opentrons/hardware_control/pause_manager.py,sha256=wmNmraimE2yZQVqCxX_rtQHUWRzpzyQEaym9fLMgyww,888
 opentrons/hardware_control/poller.py,sha256=6aqR0UM36w-Fk1ozjp-74VHthZTfT8Yurh5Zb4OnZX8,4392
 opentrons/hardware_control/robot_calibration.py,sha256=ilszGjZPspKiEk8MQPaHm2B-ljeisAYflKl8UyQ_D0U,7155
@@ -198,7 +198,7 @@ opentrons/hardware_control/protocols/gripper_controller.py,sha256=EEfL-KUzegZBm_
 opentrons/hardware_control/protocols/hardware_manager.py,sha256=S9BSJ0XsnU5A9nFLMDZfmiizx3T41WhU_91VYj4bUVE,1629
 opentrons/hardware_control/protocols/identifiable.py,sha256=YmhScb4Tr4mxVObL1i7pI-EouTMAmV-2oqKbovhdnrE,575
 opentrons/hardware_control/protocols/instrument_configurer.py,sha256=5zUCAchtoJ6QPFqcGRb7FOsnt2nxjxlRJdt18IidKqQ,7729
-opentrons/hardware_control/protocols/liquid_handler.py,sha256=_I__m4QFDNp1ZXNtanLFbu-LRqJkO7RoyJWyNAa9iF4,10457
+opentrons/hardware_control/protocols/liquid_handler.py,sha256=OvGf1LSPZC3imLO0GsFitXA4GObhT-xUnArChuf-gm8,10765
 opentrons/hardware_control/protocols/module_provider.py,sha256=QDKCWqrW-6IeI91IICBTJClK0C__mgq3A0-M3Wa9ee8,487
 opentrons/hardware_control/protocols/motion_controller.py,sha256=mWUHVDqju9gcMDU9adk6UzueZ9i-x2nU5hmcd_fHHyk,9737
 opentrons/hardware_control/protocols/position_estimator.py,sha256=BrqK5AJn9747c4LX0ZWBJWgWHjyX977CHBI7WVvO-9Q,1922
@@ -239,11 +239,11 @@ opentrons/protocol_api/config.py,sha256=r9lyvXjagTX_g3q5FGURPpcz2IA9sSF7Oa_1mKx-
 opentrons/protocol_api/create_protocol_context.py,sha256=wwsZje0L__oDnu1Yrihau320_f-ASloR9eL1QCtkOh8,7612
 opentrons/protocol_api/deck.py,sha256=94vFceg1SC1bAGd7TvC1ZpYwnJR-VlzurEZ6jkacYeg,8910
 opentrons/protocol_api/disposal_locations.py,sha256=NRiSGmDR0LnbyEkWSOM-o64uR2fUoB1NWJG7Y7SsJSs,7920
-opentrons/protocol_api/instrument_context.py,sha256=IrGvNHuWwQ44kB3Q75dCoDliWDpLLani9a8O9U-19Po,160525
+opentrons/protocol_api/instrument_context.py,sha256=vTHZaNgQYNTDykggobDwbT4ATHC0yan6erCgW3tm86w,161119
 opentrons/protocol_api/labware.py,sha256=ET9dymBh64jGUDlucdrlmBiOCVUJIOj1o2ePYxZ8U4g,63383
-opentrons/protocol_api/module_contexts.py,sha256=lJG9SKZFDrFi78ZeeueafBt1d4AEowOMZdLExHbV-Xc,73743
+opentrons/protocol_api/module_contexts.py,sha256=_O23kVJSQ87JXVWNVoDTrwn2Ou4LsRdZiVvVHxXbqnM,73678
 opentrons/protocol_api/module_validation_and_errors.py,sha256=ljst-M_KK78GnyG3pyZ_6yoYkMY3HORS1QyQyWrme-U,2250
-opentrons/protocol_api/protocol_context.py,sha256=sR6Vul04mgthDptMnJYY2YeXOIZqu48L1hrckM_TSps,79768
+opentrons/protocol_api/protocol_context.py,sha256=t4RMmw57mVuct41gIpgnnmhsrJryC08_cugjw-pPlNs,80261
 opentrons/protocol_api/robot_context.py,sha256=OoxwSNsWkMXVf3SY_r1kUxokMDxIWT0A_9NqSTD37Z8,12962
 opentrons/protocol_api/tasks.py,sha256=aAGXS9yGjdd9NNosf-o8K_DNRuPea9mimfX6L0Y7q38,1390
 opentrons/protocol_api/validation.py,sha256=MZGafzegOBuK7TTXlkkGE2YQSY71RDrdxp4puKQBclc,30995
@@ -268,7 +268,7 @@ opentrons/protocol_api/core/engine/labware.py,sha256=YUkoCogqLQpDee-wlcMPV90ZUi7
 opentrons/protocol_api/core/engine/load_labware_params.py,sha256=CxSbCBXVXHtBszP-3Ko8hsQTjvvogKRo0CCzCmMfIic,3003
 opentrons/protocol_api/core/engine/module_core.py,sha256=SBglcDmhwTrk_IfIgkzHsux9NEDQZ4OgzycAoO0qRdY,43222
 opentrons/protocol_api/core/engine/overlap_versions.py,sha256=PyGvQtQUg1wzNtkuGZtxwXm019PoIjq7em2JiWaxbXc,675
-opentrons/protocol_api/core/engine/pipette_movement_conflict.py,sha256=9BmtG1kg3vyrssBXflCNZrJIukGp6y5UJ_XqhIz73rI,18148
+opentrons/protocol_api/core/engine/pipette_movement_conflict.py,sha256=vjKuEmKU67M43dTTNoRvRwjPFx1a6sDEHNDp-8KuiuI,17386
 opentrons/protocol_api/core/engine/point_calculations.py,sha256=C2eF0fvJQGMqQv3DzNhc1-m8HTAXTyTsHPJEPrEUEmo,2502
 opentrons/protocol_api/core/engine/protocol.py,sha256=nZCWd6vq6PAzZVU_0kl3PPtcgtshN3xgWE2ixhiRK2g,50017
 opentrons/protocol_api/core/engine/robot.py,sha256=bzUt23NG-clD-9-QFsV_6nm3fMgSmvYEG9DyyZI1xgw,5366
@@ -313,7 +313,7 @@ opentrons/protocol_engine/commands/__init__.py,sha256=0RzukdT-cYTbDjx1ZSeVzF-42f
 opentrons/protocol_engine/commands/air_gap_in_place.py,sha256=3O0FnIRgiEYtW1_LjBKElL7iSP5iBQUnNi7tNUlLnyg,5444
 opentrons/protocol_engine/commands/aspirate.py,sha256=DmUHHWQ1NYUv19bjR-o4CawWaNt0eQomlISWG_YI2FQ,7977
 opentrons/protocol_engine/commands/aspirate_in_place.py,sha256=ZHvq8zcgAhDRScwFxCAySSnW0FCtOElSypcSUMom-3k,6587
-opentrons/protocol_engine/commands/aspirate_while_tracking.py,sha256=bMUcgY3Xv9f3HWoi3JAMiE8tvFgu3h1JAXCroE0Xa9c,9083
+opentrons/protocol_engine/commands/aspirate_while_tracking.py,sha256=btThzAABeNqvfRsRwX3SPAZp-2PDHnEYmCk7algxyxE,8642
 opentrons/protocol_engine/commands/blow_out.py,sha256=3gboq4x5S8fq7j4ZZGNClXFDlOjcdW1v2g58GPdhaPI,4338
 opentrons/protocol_engine/commands/blow_out_in_place.py,sha256=jm2XXyJfIP9-AAFwXhD59_13nX18-i6QqpLGb-lK7sI,3391
 opentrons/protocol_engine/commands/capture_image.py,sha256=z2FngPAT345FH7-vPQZv-HwUqRMvF6yopJ-8WmAUcFE,10928
@@ -326,7 +326,7 @@ opentrons/protocol_engine/commands/create_timer.py,sha256=xK2uxexIbIN6gCjci1P7Wb
 opentrons/protocol_engine/commands/custom.py,sha256=vOJc7QSNnYTpLvJm98OfDKjgcvVFRZs1eEKEd9WkPN0,2157
 opentrons/protocol_engine/commands/dispense.py,sha256=dEx24qS1Rhrc5-g_HwuLVqUeNZxpSjevqKX_josj60U,6501
 opentrons/protocol_engine/commands/dispense_in_place.py,sha256=gcj0HXUkPrU3Qz_DbWzP3XZHuB8tXSMTo9CFoGi25lw,6263
-opentrons/protocol_engine/commands/dispense_while_tracking.py,sha256=rxg7jUgihS931NWJy7YuauyttUmS-0a5wrOWc-bBeFk,8493
+opentrons/protocol_engine/commands/dispense_while_tracking.py,sha256=GKwjhY9AzqnjdiQpTourTjEOUwCNj8Mik6qPD1lcZOk,8051
 opentrons/protocol_engine/commands/drop_tip.py,sha256=LpgwnsaHYPCHqewI2mHs9fWFCvhhVgzkPMlCk155Ja0,9077
 opentrons/protocol_engine/commands/drop_tip_in_place.py,sha256=88dPdt48hnURavIE46E7Zaxv-h9YN5Bq8XczCwHlW_I,7262
 opentrons/protocol_engine/commands/generate_command_schema.py,sha256=e88q7DCxjEM1xSrnXV8jBdo6AgMc15_W8cC-i-ESvy0,2312
@@ -437,7 +437,7 @@ opentrons/protocol_engine/errors/__init__.py,sha256=S3JMMqRTT4f36RwwVhyg-Kcqu1M2
 opentrons/protocol_engine/errors/error_occurrence.py,sha256=ODyXHxVO4iXDxpcLaC3uO7ocTOOGPqWwcC1uaiytv0c,7846
 opentrons/protocol_engine/errors/exceptions.py,sha256=TawUeV_qaIPf-U0Rfihnxfz6a4_3Zt7f4klMZyXNl9A,50065
 opentrons/protocol_engine/execution/__init__.py,sha256=9R8ux152aTGKDoZ3x7KyisQAOj6MIZOtrPQmPNIOjKY,1518
-opentrons/protocol_engine/execution/command_executor.py,sha256=JyedeIiZP5t-uSUata8vDS0AYx7hUHBNk1oqzgh23yo,11129
+opentrons/protocol_engine/execution/command_executor.py,sha256=29CMlYbtepfExSVDyWl-mM0oZDtyLBcGVXCyHkQv0C8,11135
 opentrons/protocol_engine/execution/create_queue_worker.py,sha256=JqbMIT7nqwgKdRs86GL5LoA6cC42G3IT_eqOZYVEIhg,3740
 opentrons/protocol_engine/execution/door_watcher.py,sha256=C1CojQj_ddNAC5rS8YMZZbJtfmz2K9zYqllWTg5NKgU,4634
 opentrons/protocol_engine/execution/equipment.py,sha256=Jbg9ZR7vTw3i3WDy0xNe9J5idFuXkdxPSzfWaYH2DyI,30046
@@ -447,7 +447,7 @@ opentrons/protocol_engine/execution/hardware_stopper.py,sha256=ZlhVYEdFfuKqp5slZ
 opentrons/protocol_engine/execution/heater_shaker_movement_flagger.py,sha256=BSFLzSSeELAYZCrCUfJZx5DdlrwU06Ur92TYd0T-hzM,9084
 opentrons/protocol_engine/execution/labware_movement.py,sha256=RJMkWHGvoKc0GXjEZ2ZXWo1v9cvPlmbEdFBs0szROfo,12965
 opentrons/protocol_engine/execution/movement.py,sha256=NJUs1mtC8R8qR1x2RVTI3q9hyVuLkvCvIM1SnD8sPH0,12899
-opentrons/protocol_engine/execution/pipetting.py,sha256=4E-s8_UUEYlkuNwS316yqSihHUeh25rGB0ztRpUqpgs,21756
+opentrons/protocol_engine/execution/pipetting.py,sha256=0hRu_erRItLj_TYfKx-NTibprYKfzros8HWsbZRf_q8,22067
 opentrons/protocol_engine/execution/queue_worker.py,sha256=2cfyplUWdPyxxLbH3H8TbtB9Fvjx__ASluiJXyJBoqU,3537
 opentrons/protocol_engine/execution/rail_lights.py,sha256=eiJT6oI_kFk7rFuFkZzISZiLNnpf7Kkh86Kyk9wQ_Jo,590
 opentrons/protocol_engine/execution/run_control.py,sha256=Wn3FGuBZrYddf7Dzcz5v1hHF0DbzRxCykl6vs15BZP0,1450
@@ -459,7 +459,7 @@ opentrons/protocol_engine/execution/tip_handler.py,sha256=Ouunj3KVqz-UMbkjFIbJJr
 opentrons/protocol_engine/notes/__init__.py,sha256=G0bIQswsov7MrJU0ArrOaWcOTxJU9BCUmNR3LRoNg-Q,311
 opentrons/protocol_engine/notes/notes.py,sha256=A5C9xHExlS9GAK7o_mYiKJgibBm6EEgHQ4PJor0IET0,1993
 opentrons/protocol_engine/resources/__init__.py,sha256=URDW9VirxadLU6tPOQ4-MCDvQBE3nGCnkKzdAJVicyo,952
-opentrons/protocol_engine/resources/camera_provider.py,sha256=UVoGudhS7mMMG6u_ALYVQmeUrPdlCamnNKlfX8Dg3rM,4795
+opentrons/protocol_engine/resources/camera_provider.py,sha256=waidRhgCP0hMOKvineDU-gkIb15G6s70e2gpAAhXaD4,4807
 opentrons/protocol_engine/resources/concurrency_provider.py,sha256=iEi1jOaOTQAFTKSkGex0GRMihKvouftbxuDH8GdVRkI,941
 opentrons/protocol_engine/resources/deck_configuration_provider.py,sha256=8gA5gHaXbTf03-60QSg5qsBHrAIcfvNSaOTcyJJw9EA,9712
 opentrons/protocol_engine/resources/deck_data_provider.py,sha256=63c-Hmwy5IbVSoAL3hYoZxizxwzCqbB2KgJptpLX3Bc,3001
@@ -489,7 +489,7 @@ opentrons/protocol_engine/state/labware.py,sha256=y-vZnirUS84RatzUu960CsbGb2lW9f
 opentrons/protocol_engine/state/liquid_classes.py,sha256=u_z75UYdiFAKG0yB3mr1il4T3qaS0Sotq8sL7KLODP8,2990
 opentrons/protocol_engine/state/liquids.py,sha256=NoesktcQdJUjIVmet1uqqJPf-rzbo4SGemXwQC295W0,2338
 opentrons/protocol_engine/state/modules.py,sha256=rL_Xm7vNQrYsa6F3VYUJZVrehMfAnwvf0wXPyPH19PU,63087
-opentrons/protocol_engine/state/motion.py,sha256=lEBwAeaIYNH38226IWy68m-EPhZvqq-wvQQhGVDCwLo,16983
+opentrons/protocol_engine/state/motion.py,sha256=1pqxThXdUG7TQqYxyxUX3x49CUcdKqAAV-6o4jeKICo,16737
 opentrons/protocol_engine/state/pipettes.py,sha256=Q-aDiVvOVvUXq930vvMvAWhK7aZ06-8FLZB6jO95dwQ,38531
 opentrons/protocol_engine/state/preconditions.py,sha256=Qvv2Mnwdw2SzkVkfV1vcXNT-M9mbnITBPq9qkhZAa2o,2198
 opentrons/protocol_engine/state/state.py,sha256=-Lrag0Az9eh9A4xUcv1qE2sqC6ZX3nXnoElk2a3hZuI,17193
@@ -548,7 +548,7 @@ opentrons/protocol_runner/__init__.py,sha256=Sr0gBDzNv3nuHPapeNy_IWadhohtwmlhfnB
 opentrons/protocol_runner/create_simulating_orchestrator.py,sha256=yqDNIeOaZR20cQTQfQJuzyJKXchJ_-BGbkP2x79qGJo,5245
 opentrons/protocol_runner/json_file_reader.py,sha256=dE9ujq3sWyKF1yFg0AN8h-roGVfvqf1tEcIq5wxHbxE,2341
 opentrons/protocol_runner/json_translator.py,sha256=lrDzHOOkQ19ac4KEdUbfEOnfx-F_QCO-6oGqQZegy4g,12134
-opentrons/protocol_runner/legacy_command_mapper.py,sha256=yUCfnp4sNawFikrujyPo27Ba_aOy-kr-9F3dOK6Zu9Q,37125
+opentrons/protocol_runner/legacy_command_mapper.py,sha256=vg_HlQOdncBFo3u2pTJ6lU3ZfmRCUTuFc0WByDs4LEc,37437
 opentrons/protocol_runner/legacy_context_plugin.py,sha256=G_qpeyaLvsCjb72_n96Luy8CPSfgPZpt0QKVzKc6LKY,4730
 opentrons/protocol_runner/protocol_runner.py,sha256=yK-A4x4Wue7TBAd3CafrbNYEXdoKx-qGSxyIJeOBdKU,22227
 opentrons/protocol_runner/python_protocol_wrappers.py,sha256=KEuM4M7rYD4zLjTqK89T47CiBIZJ42kG0JXWarLUq4E,6511
@@ -602,7 +602,7 @@ opentrons/protocols/parameters/validation.py,sha256=uNwoU3cUlnV5NdvnR6vyxoTNUwos
 opentrons/resources/smoothie-edge-8414642.hex,sha256=1hiY8t0wTnMSLtIVe_lVhgFR6pdEsh4PEPjv99xbVVA,1035222
 opentrons/resources/scripts/lpc21isp,sha256=tioSU5T7a9otaalLK91_jTcgmRRXb10JQGfmGO_iKn8,329864
 opentrons/system/__init__.py,sha256=_0_HR5vwNng4bsxU_gI0KAREkvb1TogdsNmOHR3V71g,307
-opentrons/system/camera.py,sha256=hNftXRlcAaXGLeK9NOWa2P1AuMj1FDNlGysRr8PpUBg,13748
+opentrons/system/camera.py,sha256=1phNw_grGL4419JxMvCnhylzI8dzCJp8Le-OLrQbRQI,13742
 opentrons/system/ffmpeg.py,sha256=BMSICDtviItldSOPZ8kLMBlK1w-Tyjb8CFnYj7Yzm-I,4086
 opentrons/system/log_control.py,sha256=4whbd1AFbRJOByQ6bZaiOQ8Dhi3YceBHYzIBStY38Vw,1535
 opentrons/system/nmcli.py,sha256=OBLIBlP5wwjh-tzO5p2-h7jJ4-1kgI-mCti6NS7589Y,30317
@@ -623,8 +623,8 @@ opentrons/util/linal.py,sha256=IlKAP9HkNBBgULeSf4YVwSKHdx9jnCjSr7nvDvlRALg,5753
 opentrons/util/logging_config.py,sha256=7et4YYuQdWdq_e50U-8vFS_QyNBRgdnqPGAQJm8qrIo,9954
 opentrons/util/logging_queue_handler.py,sha256=ZsSJwy-oV8DXwpYiZisQ1PbYwmK2cOslD46AcyJ1E4I,2484
 opentrons/util/performance_helpers.py,sha256=ew7H8XD20iS6-2TJAzbQeyzStZkkE6PzHt_Adx3wbZQ,5172
-opentrons-8.8.0a7.dist-info/METADATA,sha256=lGSD5Lc1xtgleVQngABrjaNTduCFHlkeit36g7bKeE4,1607
-opentrons-8.8.0a7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-opentrons-8.8.0a7.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
-opentrons-8.8.0a7.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-opentrons-8.8.0a7.dist-info/RECORD,,
+opentrons-8.8.1.dist-info/METADATA,sha256=pXtrtXzADhKNCss5qKplRrffvEXB0Hu9XJ4fPUVhfjs,1599
+opentrons-8.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentrons-8.8.1.dist-info/entry_points.txt,sha256=fTa6eGCYkvOtv0ov-KVE8LLGetgb35LQLF9x85OWPVw,106
+opentrons-8.8.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+opentrons-8.8.1.dist-info/RECORD,,