opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0__py2.py3-none-any.whl

opentrons/hardware_control/ot3api.py

@@ -143,7 +143,8 @@ from .backends.types import HWStopCondition
 from .backends.flex_protocol import FlexBackend
 from .backends.ot3simulator import OT3Simulator
 from .backends.errors import SubsystemUpdating
-
+from opentrons_hardware.firmware_bindings.constants import SensorId
+from opentrons_hardware.sensors.types import SensorDataType
 
 mod_log = logging.getLogger(__name__)
 
@@ -164,6 +165,7 @@ def _adjust_high_throughput_z_current(func: Wrapped) -> Wrapped:
     A decorator that temproarily and conditionally changes the active current (based on the axis input)
     before a function is executed and the cleans up afterwards
     """
+
     # only home and retract should be wrappeed by this decorator
     @wraps(func)
     async def wrapper(self: Any, axis: Axis, *args: Any, **kwargs: Any) -> Any:
@@ -306,6 +308,12 @@ class OT3API(
         async with self._backend.restore_system_constraints():
             yield
 
+    @contextlib.asynccontextmanager
+    async def grab_pressure(self, mount: OT3Mount) -> AsyncIterator[None]:
+        instrument = self._pipette_handler.get_pipette(mount)
+        async with self._backend.grab_pressure(instrument.channels, mount):
+            yield
+
     def _update_door_state(self, door_state: DoorState) -> None:
         mod_log.info(f"Updating the window switch status: {door_state}")
         self.door_state = door_state
@@ -767,12 +775,12 @@ class OT3API(
         """
         Function to update motor estimation for a set of axes
         """
+        if axes is None:
+            axes = [ax for ax in Axis]
 
-        if axes:
-            checked_axes = [ax for ax in axes if ax in Axis]
-        else:
-            checked_axes = [ax for ax in Axis]
-        await self._backend.update_motor_estimation(checked_axes)
+        axes = [ax for ax in axes if self._backend.axis_is_present(ax)]
+
+        await self._backend.update_motor_estimation(axes)
 
     # Global actions API
     def pause(self, pause_type: PauseType) -> None:
@@ -933,7 +941,6 @@ class OT3API(
             current_pos_float > self._config.safe_home_distance
             and current_pos_float < max_distance
         ):
-
             # move toward home until a safe distance
             await self._backend.tip_action(
                 origin={Axis.Q: current_pos_float},
@@ -1811,7 +1818,8 @@ class OT3API(
         increment: Optional[float] = None,
     ) -> None:
         """This is a slightly more barebones variation of pick_up_tip. This is only the motor routine
-        directly involved in tip pickup, and leaves any state updates and plunger moves to the caller."""
+        directly involved in tip pickup, and leaves any state updates and plunger moves to the caller.
+        """
         realmount = OT3Mount.from_mount(mount)
         instrument = self._pipette_handler.get_pipette(realmount)
 
@@ -1878,12 +1886,10 @@ class OT3API(
 
         With wet tips, the primary concern is leftover droplets inside the tip.
         These droplets ideally only move down and out of the tip, not up into the tip.
-        Therefore, it is preferable to use the "blow-out" speed when moving the
-        plunger down, and the slower "aspirate" speed when moving the plunger up.
+        Therefore, it is preferable to use the slower "aspirate" speed when
+        moving the plunger up after a blow-out.
 
-        Assume all tips are wet, because we do not differentiate between wet/dry tips.
-
-        When no tip is attached, moving at the max speed is preferable, to save time.
+        All other situations, moving at the max speed is preferable, to save time.
         """
         checked_mount = OT3Mount.from_mount(mount)
         instrument = self._pipette_handler.get_pipette(checked_mount)
@@ -1896,21 +1902,22 @@ class OT3API(
             self._current_position,
         )
         pip_ax = Axis.of_main_tool_actuator(checked_mount)
-        # speed depends on if there is a tip, and which direction to move
-        if instrument.has_tip_length:
+        # save time while moving down by using max speed
+        max_speeds = self.config.motion_settings.default_max_speed
+        speed_down = max_speeds[self.gantry_load][OT3AxisKind.P]
+        # upward moves can be max speed, or aspirate speed
+        # use the (slower) aspirate if there is a tip and we're following a blow-out
+        plunger_is_below_bottom_pos = (
+            self._current_position[pip_ax] > instrument.plunger_positions.bottom
+        )
+        if instrument.has_tip_length and plunger_is_below_bottom_pos:
             # using slower aspirate flow-rate, to avoid pulling droplets up
             speed_up = self._pipette_handler.plunger_speed(
                 instrument, instrument.aspirate_flow_rate, "aspirate"
             )
-            # use blow-out flow-rate, so we can push droplets out
-            speed_down = self._pipette_handler.plunger_speed(
-                instrument, instrument.blow_out_flow_rate, "dispense"
-            )
         else:
-            # save time by using max speed
-            max_speeds = self.config.motion_settings.default_max_speed
+            # either no tip, or plunger just homed, so tip is dry
             speed_up = max_speeds[self.gantry_load][OT3AxisKind.P]
-            speed_down = speed_up
         # IMPORTANT: Here is our backlash compensation.
         #            The plunger is pre-loaded in the "aspirate" direction
         backlash_pos = target_pos.copy()
@@ -2229,15 +2236,6 @@ class OT3API(
             )
             await self.home_gear_motors()
 
-    def cache_tip(
-        self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
-    ) -> None:
-        realmount = OT3Mount.from_mount(mount)
-        instrument = self._pipette_handler.get_pipette(realmount)
-
-        instrument.add_tip(tip_length=tip_length)
-        instrument.set_current_volume(0)
-
     async def pick_up_tip(
         self,
         mount: Union[top_types.Mount, OT3Mount],
@@ -2283,17 +2281,10 @@ class OT3API(
         )
         instrument.working_volume = tip_volume
 
-    async def drop_tip(
+    async def tip_drop_moves(
         self, mount: Union[top_types.Mount, OT3Mount], home_after: bool = False
     ) -> None:
-        """Drop tip at the current location."""
         realmount = OT3Mount.from_mount(mount)
-        instrument = self._pipette_handler.get_pipette(realmount)
-
-        def _remove_tips() -> None:
-            instrument.set_current_volume(0)
-            instrument.current_tiprack_diameter = 0.0
-            instrument.remove_tip()
 
         await self._move_to_plunger_bottom(realmount, rate=1.0, check_current_vol=False)
 
@@ -2320,11 +2311,27 @@ class OT3API(
         if home_after:
             await self._home([Axis.by_mount(mount)])
 
-        _remove_tips()
-        # call this in case we're simulating
+        # call this in case we're simulating:
         if isinstance(self._backend, OT3Simulator):
             self._backend._update_tip_state(realmount, False)
 
+    async def drop_tip(
+        self, mount: Union[top_types.Mount, OT3Mount], home_after: bool = False
+    ) -> None:
+        """Drop tip at the current location."""
+        await self.tip_drop_moves(mount=mount, home_after=home_after)
+
+        # todo(mm, 2024-10-17): Ideally, callers would be able to replicate the behavior
+        # of this method via self.drop_tip_moves() plus other public methods. This
+        # currently prevents that: there is no public equivalent for
+        # instrument.set_current_volume().
+        realmount = OT3Mount.from_mount(mount)
+        instrument = self._pipette_handler.get_pipette(realmount)
+        instrument.set_current_volume(0)
+
+        self.set_current_tiprack_diameter(mount, 0.0)
+        self.remove_tip(mount)
+
     async def clean_up(self) -> None:
         """Get the API ready to stop cleanly."""
         await self._backend.clean_up()
@@ -2592,13 +2599,18 @@ class OT3API(
                 starting_nozzle,
             )
 
-    async def add_tip(
+    def add_tip(
         self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
     ) -> None:
-        await self._pipette_handler.add_tip(OT3Mount.from_mount(mount), tip_length)
+        self._pipette_handler.add_tip(OT3Mount.from_mount(mount), tip_length)
 
-    async def remove_tip(self, mount: Union[top_types.Mount, OT3Mount]) -> None:
-        await self._pipette_handler.remove_tip(OT3Mount.from_mount(mount))
+    def cache_tip(
+        self, mount: Union[top_types.Mount, OT3Mount], tip_length: float
+    ) -> None:
+        self._pipette_handler.cache_tip(OT3Mount.from_mount(mount), tip_length)
+
+    def remove_tip(self, mount: Union[top_types.Mount, OT3Mount]) -> None:
+        self._pipette_handler.remove_tip(OT3Mount.from_mount(mount))
 
     def add_gripper_probe(self, probe: GripperProbe) -> None:
         self._gripper_handler.add_probe(probe)
@@ -2607,17 +2619,17 @@ class OT3API(
         self._gripper_handler.remove_probe()
 
     @staticmethod
-    def liquid_probe_non_responsive_z_distance(z_speed: float) -> float:
+    def liquid_probe_non_responsive_z_distance(
+        z_speed: float, samples_for_baselining: int, sample_time_sec: float
+    ) -> float:
         """Calculate the Z distance travelled where the LLD pass will be unresponsive."""
         # NOTE: (sigler) Here lye some magic numbers.
         #       The Z axis probing motion uses the first 20 samples to calculate
         #       a baseline for all following samples, making the very beginning of
         #       that Z motion unable to detect liquid. The sensor is configured for
         #       4ms sample readings, and so we then assume it takes ~80ms to complete.
-        #       If the Z is moving at 5mm/sec, then ~80ms equates to ~0.4
-        baseline_during_z_sample_num = 20  # FIXME: (sigler) shouldn't be defined here?
-        sample_time_sec = 0.004  # FIXME: (sigler) shouldn't be defined here?
-        baseline_duration_sec = baseline_during_z_sample_num * sample_time_sec
+        #       If the Z is moving at 5mm/sec, then ~80ms equates to ~0.4mm
+        baseline_duration_sec = samples_for_baselining * sample_time_sec
         non_responsive_z_mm = baseline_duration_sec * z_speed
         return non_responsive_z_mm
 
@@ -2628,6 +2640,9 @@ class OT3API(
         probe: InstrumentProbeType,
         p_travel: float,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         plunger_direction = -1 if probe_settings.aspirate_while_sensing else 1
         end_z = await self._backend.liquid_probe(
@@ -2637,10 +2652,10 @@ class OT3API(
             (probe_settings.plunger_speed * plunger_direction),
             probe_settings.sensor_threshold_pascals,
             probe_settings.plunger_impulse_time,
-            probe_settings.output_option,
-            probe_settings.data_files,
+            probe_settings.samples_for_baselining,
             probe=probe,
             force_both_sensors=force_both_sensors,
+            response_queue=response_queue,
         )
         machine_pos = await self._backend.update_position()
         machine_pos[Axis.by_mount(mount)] = end_z
@@ -2654,13 +2669,16 @@ class OT3API(
         cp = self.critical_point_for(mount, None)
         return deck_end_z + offset.z + cp.z
 
-    async def liquid_probe(
+    async def liquid_probe(  # noqa: C901
         self,
         mount: Union[top_types.Mount, OT3Mount],
         max_z_dist: float,
         probe_settings: Optional[LiquidProbeSettings] = None,
         probe: Optional[InstrumentProbeType] = None,
         force_both_sensors: bool = False,
+        response_queue: Optional[
+            asyncio.Queue[Dict[SensorId, List[SensorDataType]]]
+        ] = None,
     ) -> float:
         """Search for and return liquid level height.
 
@@ -2697,7 +2715,6 @@ class OT3API(
             probe_settings = deepcopy(self.config.liquid_sense)
 
         # We need to significatly slow down the 96 channel liquid probe
-        # TODO: (sigler) add LLD plunger-speed to pipette definitions
         if self.gantry_load == GantryLoad.HIGH_THROUGHPUT:
             max_plunger_speed = self.config.motion_settings.max_speed_discontinuity[
                 GantryLoad.HIGH_THROUGHPUT
@@ -2706,59 +2723,79 @@ class OT3API(
                 max_plunger_speed, probe_settings.plunger_speed
             )
 
-        probe_start_pos = await self.gantry_position(checked_mount, refresh=True)
+        starting_position = await self.gantry_position(checked_mount, refresh=True)
 
-        # plunger travel distance is from TOP->BOTTOM (minus the backlash distance + impulse)
-        # FIXME: logic for how plunger moves is divided between here and tool_sensors.py
-        p_impulse_mm = (
+        sensor_baseline_plunger_move_mm = (
             probe_settings.plunger_impulse_time * probe_settings.plunger_speed
         )
-        p_total_mm = (
+        total_plunger_axis_mm = (
             instrument.plunger_positions.bottom - instrument.plunger_positions.top
         )
-
-        p_working_mm = p_total_mm - (instrument.backlash_distance + p_impulse_mm)
-
+        max_allowed_plunger_distance_mm = total_plunger_axis_mm - (
+            instrument.backlash_distance + sensor_baseline_plunger_move_mm
+        )
         # height where probe action will begin
-        # TODO: (sigler) add this to pipette's liquid def (per tip)
-        probe_pass_overlap_mm = 0.1
-        non_responsive_z_mm = OT3API.liquid_probe_non_responsive_z_distance(
-            probe_settings.mount_speed
+        sensor_baseline_z_move_mm = OT3API.liquid_probe_non_responsive_z_distance(
+            probe_settings.mount_speed,
+            probe_settings.samples_for_baselining,
+            probe_settings.sample_time_sec,
+        )
+        z_offset_per_pass = (
+            sensor_baseline_z_move_mm + probe_settings.z_overlap_between_passes_mm
         )
-        probe_pass_z_offset_mm = non_responsive_z_mm + probe_pass_overlap_mm
 
         # height that is considered safe to reset the plunger without disturbing liquid
         # this usually needs to at least 1-2mm from liquid, to avoid splashes from air
-        # TODO: (sigler) add this to pipette's liquid def (per tip)
-        probe_safe_reset_mm = max(2.0, probe_pass_z_offset_mm)
+        z_offset_for_plunger_prep = max(
+            probe_settings.plunger_reset_offset, z_offset_per_pass
+        )
+
+        async def prep_plunger_for_probe_move(
+            position: top_types.Point, aspirate_while_sensing: bool
+        ) -> None:
+            # safe distance so we don't accidentally aspirate liquid if we're already close to liquid
+            mount_pos_for_plunger_prep = top_types.Point(
+                position.x,
+                position.y,
+                position.z + z_offset_for_plunger_prep,
+            )
+            # Prep the plunger
+            await self.move_to(checked_mount, mount_pos_for_plunger_prep)
+            if aspirate_while_sensing:
+                await self._move_to_plunger_bottom(checked_mount, rate=1)
+            else:
+                await self._move_to_plunger_top_for_liquid_probe(checked_mount, rate=1)
 
         error: Optional[PipetteLiquidNotFoundError] = None
-        pos = await self.gantry_position(checked_mount, refresh=True)
-        #  probe_start_pos.z + z_distance of pass - pos.z should be < max_z_dist
+        current_position = await self.gantry_position(checked_mount, refresh=True)
+        #  starting_position.z + z_distance of pass - pos.z should be < max_z_dist
         # due to rounding errors this can get caught in an infinite loop when the distance is almost equal
         # so we check to see if they're within 0.01 which is 1/5th the minimum movement distance from move_utils.py
-        while (probe_start_pos.z - pos.z) < (max_z_dist - 0.01):
-            # safe distance so we don't accidentally aspirate liquid if we're already close to liquid
-            safe_plunger_pos = top_types.Point(
-                pos.x, pos.y, pos.z + probe_safe_reset_mm
+        while (starting_position.z - current_position.z) < (max_z_dist - 0.01):
+            await prep_plunger_for_probe_move(
+                position=current_position,
+                aspirate_while_sensing=probe_settings.aspirate_while_sensing,
             )
+
             # overlap amount we want to use between passes
             pass_start_pos = top_types.Point(
-                pos.x, pos.y, pos.z + probe_pass_z_offset_mm
+                current_position.x,
+                current_position.y,
+                current_position.z + z_offset_per_pass,
             )
-            max_z_time = (
-                max_z_dist - probe_start_pos.z + pass_start_pos.z
-            ) / probe_settings.mount_speed
-            p_travel_required_for_z = max_z_time * probe_settings.plunger_speed
-            p_pass_travel = min(p_travel_required_for_z, p_working_mm)
-            # Prep the plunger
-            await self.move_to(checked_mount, safe_plunger_pos)
-            if probe_settings.aspirate_while_sensing:
-                # TODO(cm, 7/8/24): remove p_prep_speed from the rate at some point
-                await self._move_to_plunger_bottom(checked_mount, rate=1)
-            else:
-                await self._move_to_plunger_top_for_liquid_probe(checked_mount, rate=1)
 
+            total_remaining_z_dist = pass_start_pos.z - (
+                starting_position.z - max_z_dist
+            )
+            finish_probe_move_duration = (
+                total_remaining_z_dist / probe_settings.mount_speed
+            )
+            finish_probe_plunger_distance_mm = (
+                finish_probe_move_duration * probe_settings.plunger_speed
+            )
+            plunger_travel_mm = min(
+                finish_probe_plunger_distance_mm, max_allowed_plunger_distance_mm
+            )
             try:
                 # move to where we want to start a pass and run a pass
                 await self.move_to(checked_mount, pass_start_pos)
@@ -2766,17 +2803,19 @@ class OT3API(
                     checked_mount,
                     probe_settings,
                     checked_probe,
-                    p_pass_travel + p_impulse_mm,
+                    plunger_travel_mm + sensor_baseline_plunger_move_mm,
+                    force_both_sensors,
+                    response_queue,
                 )
                 # if we made it here without an error we found the liquid
                 error = None
                 break
             except PipetteLiquidNotFoundError as lnfe:
                 error = lnfe
-            pos = await self.gantry_position(checked_mount, refresh=True)
-        await self.move_to(checked_mount, probe_start_pos + top_types.Point(z=2))
+            current_position = await self.gantry_position(checked_mount, refresh=True)
+        await self.move_to(checked_mount, starting_position + top_types.Point(z=2))
         await self.prepare_for_aspirate(checked_mount)
-        await self.move_to(checked_mount, probe_start_pos)
+        await self.move_to(checked_mount, starting_position)
         if error is not None:
             # if we never found liquid raise an error
             raise error
@@ -2835,8 +2874,6 @@ class OT3API(
             pass_settings.speed_mm_per_s,
             pass_settings.sensor_threshold_pf,
             probe,
-            pass_settings.output_option,
-            pass_settings.data_files,
         )
         end_pos = await self.gantry_position(mount, refresh=True)
         if retract_after:

opentrons/hardware_control/poller.py

@@ -3,6 +3,7 @@ import contextlib
 import logging
 from abc import ABC, abstractmethod
 from typing import AsyncGenerator, List, Optional
+from opentrons.hardware_control.modules.errors import AbsorbanceReaderDisconnectedError
 from opentrons_shared_data.errors.exceptions import ModuleCommunicationError
 
 
@@ -36,21 +37,20 @@ class Poller:
         self._poll_forever_task: Optional["asyncio.Task[None]"] = None
 
     async def start(self) -> None:
-        assert self._poll_forever_task is None, "Poller already started"
-        self._poll_forever_task = asyncio.create_task(self._poll_forever())
-        await self.wait_next_poll()
+        if self._poll_forever_task is None:
+            self._poll_forever_task = asyncio.create_task(self._poll_forever())
+            await self.wait_next_poll()
 
     async def stop(self) -> None:
         """Stop polling."""
         task = self._poll_forever_task
-
-        assert task is not None, "Poller never started"
-
-        async with self._use_read_lock():
-            task.cancel()
-            await asyncio.gather(task, return_exceptions=True)
-        for waiter in self._poll_waiters:
-            waiter.cancel(msg="Module was removed")
+        if task is not None:
+            async with self._use_read_lock():
+                task.cancel()
+                await asyncio.gather(task, return_exceptions=True)
+            for waiter in self._poll_waiters:
+                waiter.cancel(msg="Module was removed")
+            self._poll_forever_task = None
 
     async def wait_next_poll(self) -> None:
         """Wait for the next poll to complete.
@@ -98,6 +98,10 @@ class Poller:
                 await self._reader.read()
         except asyncio.CancelledError:
             raise
+        except AbsorbanceReaderDisconnectedError as e:
+            for waiter in previous_waiters:
+                Poller._set_waiter_complete(waiter, None)
+            self._reader.on_error(e)
         except Exception as e:
             log.exception("Polling exception")
             self._reader.on_error(e)

opentrons/hardware_control/protocols/__init__.py

@@ -58,9 +58,6 @@ class HardwareControlInterface(
     def get_robot_type(self) -> Type[OT2RobotType]:
         return OT2RobotType
 
-    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
-        ...
-
 
 class FlexHardwareControlInterface(
     PositionEstimator,
@@ -87,12 +84,9 @@ class FlexHardwareControlInterface(
     def get_robot_type(self) -> Type[FlexRobotType]:
         return FlexRobotType
 
-    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
-        ...
-
 
 __all__ = [
-    "HardwareControlAPI",
+    "HardwareControlInterface",
     "FlexHardwareControlInterface",
     "Simulatable",
     "Stoppable",

opentrons/hardware_control/protocols/instrument_configurer.py

@@ -142,15 +142,27 @@ class InstrumentConfigurer(Protocol[MountArgType]):
         """
         ...
 
-    async def add_tip(self, mount: MountArgType, tip_length: float) -> None:
+    # todo(mm, 2024-10-17): Consider deleting this in favor of cache_tip()
+    # if we can do so without breaking anything.
+    def add_tip(self, mount: MountArgType, tip_length: float) -> None:
         """Inform the hardware that a tip is now attached to a pipette.
 
+        If a tip is already attached, this no-ops.
+
         This changes the critical point of the pipette to make sure that
         the end of the tip is what moves around, and allows liquid handling.
         """
         ...
 
-    async def remove_tip(self, mount: MountArgType) -> None:
+    def cache_tip(self, mount: MountArgType, tip_length: float) -> None:
+        """Inform the hardware that a tip is now attached to a pipette.
+
+        This is like `add_tip()`, except that if a tip is already attached,
+        this replaces it instead of no-opping.
+        """
+        ...
+
+    def remove_tip(self, mount: MountArgType) -> None:
         """Inform the hardware that a tip is no longer attached to a pipette.
 
         This changes the critical point of the system to the end of the

opentrons/hardware_control/protocols/liquid_handler.py

@@ -164,6 +164,11 @@ class LiquidHandler(
         """
         ...
 
+    async def tip_drop_moves(
+        self, mount: MountArgType, home_after: bool = True
+    ) -> None:
+        ...
+
     async def drop_tip(
         self,
         mount: MountArgType,

opentrons/hardware_control/protocols/position_estimator.py

@@ -10,7 +10,7 @@ class PositionEstimator(Protocol):
         """Update the specified axes' position estimators from their encoders.
 
         This will allow these axes to make a non-home move even if they do not currently have
-        a position estimation (unless there is no tracked poition from the encoders, as would be
+        a position estimation (unless there is no tracked position from the encoders, as would be
         true immediately after boot).
 
         Axis encoders have less precision than their position estimators. Calling this function will
@@ -19,6 +19,8 @@ class PositionEstimator(Protocol):
 
         This function updates only the requested axes. If other axes have bad position estimation,
         moves that require those axes or attempts to get the position of those axes will still fail.
+        Axes that are not currently available (like a plunger for a pipette that is not connected)
+        will be ignored.
         """
         ...
 

opentrons/hardware_control/types.py

@@ -625,6 +625,8 @@ class GripperJawState(enum.Enum):
     #: the gripper is actively force-control gripping something
     HOLDING = enum.auto()
     #: the gripper is in position-control mode
+    STOPPED = enum.auto()
+    #: the gripper has been homed before but is stopped now
 
 
 class InstrumentProbeType(enum.Enum):

opentrons/legacy_commands/helpers.py

@@ -49,7 +49,9 @@ def stringify_disposal_location(location: Union[TrashBin, WasteChute]) -> str:
 
 
 def _stringify_labware_movement_location(
-    location: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute]
+    location: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ]
 ) -> str:
     if isinstance(location, (int, str)):
         return f"slot {location}"
@@ -61,11 +63,15 @@ def _stringify_labware_movement_location(
         return str(location)
     elif isinstance(location, WasteChute):
         return "Waste Chute"
+    elif isinstance(location, TrashBin):
+        return "Trash Bin " + location.location.name
 
 
 def stringify_labware_movement_command(
     source_labware: Labware,
-    destination: Union[DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute],
+    destination: Union[
+        DeckLocation, OffDeckType, Labware, ModuleContext, WasteChute, TrashBin
+    ],
     use_gripper: bool,
 ) -> str:
     source_labware_text = _stringify_labware_movement_location(source_labware)

opentrons/motion_planning/__init__.py

@@ -6,6 +6,7 @@ from .waypoints import (
     MINIMUM_Z_MARGIN,
     get_waypoints,
     get_gripper_labware_movement_waypoints,
+    get_gripper_labware_placement_waypoints,
 )
 
 from .types import Waypoint, MoveType
@@ -27,4 +28,5 @@ __all__ = [
     "ArcOutOfBoundsError",
     "get_waypoints",
     "get_gripper_labware_movement_waypoints",
+    "get_gripper_labware_placement_waypoints",
 ]

opentrons/motion_planning/waypoints.py

@@ -181,3 +181,35 @@ def get_gripper_labware_movement_waypoints(
             )
         )
     return waypoints_with_jaw_status
+
+
+def get_gripper_labware_placement_waypoints(
+    to_labware_center: Point,
+    gripper_home_z: float,
+    drop_offset: Optional[Point],
+) -> List[GripperMovementWaypointsWithJawStatus]:
+    """Get waypoints for placing labware using a gripper."""
+    drop_offset = drop_offset or Point()
+
+    drop_location = to_labware_center + Point(
+        drop_offset.x, drop_offset.y, drop_offset.z
+    )
+
+    post_drop_home_pos = Point(drop_location.x, drop_location.y, gripper_home_z)
+
+    return [
+        GripperMovementWaypointsWithJawStatus(
+            position=Point(drop_location.x, drop_location.y, gripper_home_z),
+            jaw_open=False,
+            dropping=False,
+        ),
+        GripperMovementWaypointsWithJawStatus(
+            position=drop_location, jaw_open=False, dropping=False
+        ),
+        # Gripper ungrips here
+        GripperMovementWaypointsWithJawStatus(
+            position=post_drop_home_pos,
+            jaw_open=True,
+            dropping=True,
+        ),
+    ]

opentrons/protocol_api/__init__.py

@@ -29,7 +29,7 @@ from .module_contexts import (
     AbsorbanceReaderContext,
 )
 from .disposal_locations import TrashBin, WasteChute
-from ._liquid import Liquid
+from ._liquid import Liquid, LiquidClass
 from ._types import OFF_DECK
 from ._nozzle_layout import (
     COLUMN,
@@ -67,6 +67,7 @@ __all__ = [
     "WasteChute",
     "Well",
     "Liquid",
+    "LiquidClass",
     "Parameters",
     "COLUMN",
     "PARTIAL_COLUMN",