opentrons 8.3.1a1__py2.py3-none-any.whl → 8.4.0a1__py2.py3-none-any.whl

opentrons/protocol_engine/execution/pipetting.py

@@ -1,5 +1,5 @@
 """Pipetting command handling."""
-from typing import Optional, Iterator
+from typing import Optional, Iterator, Tuple
 from typing_extensions import Protocol as TypingProtocol
 from contextlib import contextmanager
 
@@ -13,8 +13,13 @@ from ..errors.exceptions import (
     InvalidAspirateVolumeError,
     InvalidPushOutVolumeError,
     InvalidDispenseVolumeError,
+    InvalidLiquidHeightFound,
 )
 from opentrons.protocol_engine.types import WellLocation
+from opentrons.protocol_engine.types.liquid_level_detection import (
+    SimulatedProbeResult,
+    LiquidTrackingType,
+)
 
 # 1e-9 µL (1 femtoliter!) is a good value because:
 # * It's large relative to rounding errors that occur in practice in protocols. For
@@ -30,6 +35,9 @@ _VOLUME_ROUNDING_ERROR_TOLERANCE = 1e-9
 class PipettingHandler(TypingProtocol):
     """Liquid handling commands."""
 
+    def get_state_view(self) -> StateView:
+        """Get the stateview associated with this handler."""
+
     def get_is_ready_to_aspirate(self, pipette_id: str) -> bool:
         """Get whether a pipette is ready to aspirate."""
 
@@ -42,15 +50,41 @@ class PipettingHandler(TypingProtocol):
         volume: float,
         flow_rate: float,
         command_note_adder: CommandNoteAdder,
+        correction_volume: float = 0.0,
     ) -> float:
         """Set flow-rate and aspirate."""
 
+    async def aspirate_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
+        flow_rate: float,
+        command_note_adder: CommandNoteAdder,
+    ) -> float:
+        """Set flow-rate and aspirate while tracking."""
+
+    async def dispense_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
+        flow_rate: float,
+        push_out: Optional[float],
+        is_full_dispense: bool = False,
+    ) -> float:
+        """Set flow-rate and dispense while tracking."""
+
     async def dispense_in_place(
         self,
         pipette_id: str,
         volume: float,
         flow_rate: float,
         push_out: Optional[float],
+        is_full_dispense: bool,
+        correction_volume: float = 0.0,
     ) -> float:
         """Set flow-rate and dispense."""
 
@@ -67,18 +101,25 @@ class PipettingHandler(TypingProtocol):
         labware_id: str,
         well_name: str,
         well_location: WellLocation,
-    ) -> float:
+    ) -> LiquidTrackingType:
         """Detect liquid level."""
 
+    async def increase_evo_disp_count(self, pipette_id: str) -> None:
+        """Increase evo tip dispense action count."""
+
 
 class HardwarePipettingHandler(PipettingHandler):
-    """Liquid handling, using the Hardware API.""" ""
+    """Liquid handling, using the Hardware API."""
 
     def __init__(self, state_view: StateView, hardware_api: HardwareControlAPI) -> None:
         """Initialize a PipettingHandler instance."""
         self._state_view = state_view
         self._hardware_api = hardware_api
 
+    def get_state_view(self) -> StateView:
+        """Get the stateview associated with this handler."""
+        return self._state_view
+
     def get_is_ready_to_aspirate(self, pipette_id: str) -> bool:
         """Get whether a pipette is ready to aspirate."""
         hw_pipette = self._state_view.pipettes.get_hardware_pipette(
@@ -88,6 +129,7 @@ class HardwarePipettingHandler(PipettingHandler):
         return (
             self._state_view.pipettes.get_aspirated_volume(pipette_id) is not None
             and hw_pipette.config["ready_to_aspirate"]
+            and self._state_view.pipettes.get_ready_to_aspirate(pipette_id)
         )
 
     async def prepare_for_aspirate(self, pipette_id: str) -> None:
@@ -99,10 +141,48 @@ class HardwarePipettingHandler(PipettingHandler):
         hw_mount = self._state_view.pipettes.get_mount(pipette_id).to_hw_mount()
         await self._hardware_api.prepare_for_aspirate(mount=hw_mount)
 
-    async def aspirate_in_place(
+    def get_hw_aspirate_params(
+        self,
+        pipette_id: str,
+        volume: float,
+        command_note_adder: CommandNoteAdder,
+    ) -> Tuple[HardwarePipette, float]:
+        """Get params for hardware aspirate."""
+        _adjusted_volume = _validate_aspirate_volume(
+            state_view=self._state_view,
+            pipette_id=pipette_id,
+            aspirate_volume=volume,
+            command_note_adder=command_note_adder,
+        )
+        _hw_pipette = self._state_view.pipettes.get_hardware_pipette(
+            pipette_id=pipette_id,
+            attached_pipettes=self._hardware_api.attached_instruments,
+        )
+        return _hw_pipette, _adjusted_volume
+
+    def get_hw_dispense_params(
         self,
         pipette_id: str,
         volume: float,
+    ) -> Tuple[HardwarePipette, float]:
+        """Get params for hardware dispense."""
+        _adjusted_volume = _validate_dispense_volume(
+            state_view=self._state_view,
+            pipette_id=pipette_id,
+            dispense_volume=volume,
+        )
+        _hw_pipette = self._state_view.pipettes.get_hardware_pipette(
+            pipette_id=pipette_id,
+            attached_pipettes=self._hardware_api.attached_instruments,
+        )
+        return _hw_pipette, _adjusted_volume
+
+    async def aspirate_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
         flow_rate: float,
         command_note_adder: CommandNoteAdder,
     ) -> float:
@@ -112,19 +192,85 @@ class HardwarePipettingHandler(PipettingHandler):
             PipetteOverpressureError, propagated as-is from the hardware controller.
         """
         # get mount and config data from state and hardware controller
-        adjusted_volume = _validate_aspirate_volume(
-            state_view=self._state_view,
-            pipette_id=pipette_id,
-            aspirate_volume=volume,
-            command_note_adder=command_note_adder,
+        hw_pipette, adjusted_volume = self.get_hw_aspirate_params(
+            pipette_id, volume, command_note_adder
         )
-        hw_pipette = self._state_view.pipettes.get_hardware_pipette(
-            pipette_id=pipette_id,
-            attached_pipettes=self._hardware_api.attached_instruments,
+        aspirate_z_distance = self._state_view.geometry.get_liquid_handling_z_change(
+            labware_id=labware_id,
+            well_name=well_name,
+            operation_volume=volume * -1,
+        )
+        if isinstance(aspirate_z_distance, SimulatedProbeResult):
+            raise InvalidLiquidHeightFound(
+                "Aspirate distance must be a float in Hardware pipetting handler."
+            )
+        with self._set_flow_rate(pipette=hw_pipette, aspirate_flow_rate=flow_rate):
+            await self._hardware_api.aspirate_while_tracking(
+                mount=hw_pipette.mount,
+                z_distance=aspirate_z_distance,
+                flow_rate=flow_rate,
+                volume=adjusted_volume,
+            )
+        return adjusted_volume
+
+    async def dispense_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
+        flow_rate: float,
+        push_out: Optional[float],
+        is_full_dispense: bool = False,
+    ) -> float:
+        """Set flow-rate and dispense.
+
+        Raises:
+            PipetteOverpressureError, propagated as-is from the hardware controller.
+        """
+        # get mount and config data from state and hardware controller
+        hw_pipette, adjusted_volume = self.get_hw_dispense_params(pipette_id, volume)
+        dispense_z_distance = self._state_view.geometry.get_liquid_handling_z_change(
+            labware_id=labware_id,
+            well_name=well_name,
+            operation_volume=volume,
+        )
+        if isinstance(dispense_z_distance, SimulatedProbeResult):
+            raise InvalidLiquidHeightFound(
+                "Dispense distance must be a float in Hardware pipetting handler."
+            )
+        with self._set_flow_rate(pipette=hw_pipette, dispense_flow_rate=flow_rate):
+            await self._hardware_api.dispense_while_tracking(
+                mount=hw_pipette.mount,
+                z_distance=dispense_z_distance,
+                flow_rate=flow_rate,
+                volume=adjusted_volume,
+                push_out=push_out,
+            )
+        return adjusted_volume
+
+    async def aspirate_in_place(
+        self,
+        pipette_id: str,
+        volume: float,
+        flow_rate: float,
+        command_note_adder: CommandNoteAdder,
+        correction_volume: float = 0.0,
+    ) -> float:
+        """Set flow-rate and aspirate.
+
+        Raises:
+            PipetteOverpressureError, propagated as-is from the hardware controller.
+        """
+        # get mount and config data from state and hardware controller
+        hw_pipette, adjusted_volume = self.get_hw_aspirate_params(
+            pipette_id, volume, command_note_adder
         )
         with self._set_flow_rate(pipette=hw_pipette, aspirate_flow_rate=flow_rate):
             await self._hardware_api.aspirate(
-                mount=hw_pipette.mount, volume=adjusted_volume
+                mount=hw_pipette.mount,
+                volume=adjusted_volume,
+                correction_volume=correction_volume,
             )
 
         return adjusted_volume
@@ -135,15 +281,11 @@ class HardwarePipettingHandler(PipettingHandler):
         volume: float,
         flow_rate: float,
         push_out: Optional[float],
+        is_full_dispense: bool,
+        correction_volume: float = 0.0,
     ) -> float:
         """Dispense liquid without moving the pipette."""
-        adjusted_volume = _validate_dispense_volume(
-            state_view=self._state_view, pipette_id=pipette_id, dispense_volume=volume
-        )
-        hw_pipette = self._state_view.pipettes.get_hardware_pipette(
-            pipette_id=pipette_id,
-            attached_pipettes=self._hardware_api.attached_instruments,
-        )
+        hw_pipette, adjusted_volume = self.get_hw_dispense_params(pipette_id, volume)
         # TODO (tz, 8-23-23): add a check for push_out not larger that the max volume allowed when working on this https://opentrons.atlassian.net/browse/RSS-329
         if push_out and push_out < 0:
             raise InvalidPushOutVolumeError(
@@ -151,7 +293,11 @@ class HardwarePipettingHandler(PipettingHandler):
             )
         with self._set_flow_rate(pipette=hw_pipette, dispense_flow_rate=flow_rate):
             await self._hardware_api.dispense(
-                mount=hw_pipette.mount, volume=adjusted_volume, push_out=push_out
+                mount=hw_pipette.mount,
+                volume=adjusted_volume,
+                push_out=push_out,
+                correction_volume=correction_volume,
+                is_full_dispense=is_full_dispense,
             )
 
         return adjusted_volume
@@ -176,7 +322,7 @@ class HardwarePipettingHandler(PipettingHandler):
         labware_id: str,
         well_name: str,
         well_location: WellLocation,
-    ) -> float:
+    ) -> LiquidTrackingType:
         """Detect liquid level."""
         hw_pipette = self._state_view.pipettes.get_hardware_pipette(
             pipette_id=pipette_id,
@@ -223,6 +369,14 @@ class HardwarePipettingHandler(PipettingHandler):
                 blow_out=original_blow_out_rate,
             )
 
+    async def increase_evo_disp_count(self, pipette_id: str) -> None:
+        """Increase evo tip dispense action count."""
+        hw_pipette = self._state_view.pipettes.get_hardware_pipette(
+            pipette_id=pipette_id,
+            attached_pipettes=self._hardware_api.attached_instruments,
+        )
+        await self._hardware_api.increase_evo_disp_count(mount=hw_pipette.mount)
+
 
 class VirtualPipettingHandler(PipettingHandler):
     """Liquid handling, using the virtual pipettes.""" ""
@@ -236,12 +390,19 @@ class VirtualPipettingHandler(PipettingHandler):
         """Initialize a PipettingHandler instance."""
         self._state_view = state_view
 
+    def get_state_view(self) -> StateView:
+        """Get the stateview associated with this handler."""
+        return self._state_view
+
     def get_is_ready_to_aspirate(self, pipette_id: str) -> bool:
         """Get whether a pipette is ready to aspirate."""
-        return self._state_view.pipettes.get_aspirated_volume(pipette_id) is not None
+        return self._state_view.pipettes.get_aspirated_volume(
+            pipette_id
+        ) is not None and self._state_view.pipettes.get_ready_to_aspirate(pipette_id)
 
     async def prepare_for_aspirate(self, pipette_id: str) -> None:
         """Virtually prepare to aspirate (no-op)."""
+        self._validate_tip_attached(pipette_id=pipette_id, command_name="aspirate")
 
     async def aspirate_in_place(
         self,
@@ -249,6 +410,7 @@ class VirtualPipettingHandler(PipettingHandler):
         volume: float,
         flow_rate: float,
         command_note_adder: CommandNoteAdder,
+        correction_volume: float = 0.0,
     ) -> float:
         """Virtually aspirate (no-op)."""
         self._validate_tip_attached(pipette_id=pipette_id, command_name="aspirate")
@@ -265,6 +427,8 @@ class VirtualPipettingHandler(PipettingHandler):
         volume: float,
         flow_rate: float,
         push_out: Optional[float],
+        is_full_dispense: bool,
+        correction_volume: float = 0.0,
     ) -> float:
         """Virtually dispense (no-op)."""
         # TODO (tz, 8-23-23): add a check for push_out not larger that the max volume allowed when working on this https://opentrons.atlassian.net/browse/RSS-329
@@ -290,10 +454,9 @@ class VirtualPipettingHandler(PipettingHandler):
         labware_id: str,
         well_name: str,
         well_location: WellLocation,
-    ) -> float:
+    ) -> LiquidTrackingType:
         """Detect liquid level."""
-        well_def = self._state_view.labware.get_well_definition(labware_id, well_name)
-        return well_def.depth
+        return SimulatedProbeResult()
 
     def _validate_tip_attached(self, pipette_id: str, command_name: str) -> None:
         """Validate if there is a tip attached."""
@@ -303,6 +466,50 @@ class VirtualPipettingHandler(PipettingHandler):
                 f"Cannot perform {command_name} without a tip attached"
             )
 
+    async def aspirate_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
+        flow_rate: float,
+        command_note_adder: CommandNoteAdder,
+    ) -> float:
+        """Virtually aspirate (no-op)."""
+        self._validate_tip_attached(pipette_id=pipette_id, command_name="aspirate")
+
+        return _validate_aspirate_volume(
+            state_view=self._state_view,
+            pipette_id=pipette_id,
+            aspirate_volume=volume,
+            command_note_adder=command_note_adder,
+        )
+
+    async def dispense_while_tracking(
+        self,
+        pipette_id: str,
+        labware_id: str,
+        well_name: str,
+        volume: float,
+        flow_rate: float,
+        push_out: Optional[float],
+        is_full_dispense: bool = False,
+    ) -> float:
+        """Virtually dispense (no-op)."""
+        # TODO (tz, 8-23-23): add a check for push_out not larger that the max volume allowed when working on this https://opentrons.atlassian.net/browse/RSS-329
+        if push_out and push_out < 0:
+            raise InvalidPushOutVolumeError(
+                "push out value cannot have a negative value."
+            )
+        self._validate_tip_attached(pipette_id=pipette_id, command_name="dispense")
+        return _validate_dispense_volume(
+            state_view=self._state_view, pipette_id=pipette_id, dispense_volume=volume
+        )
+
+    async def increase_evo_disp_count(self, pipette_id: str) -> None:
+        """Increase evo tip dispense action count."""
+        pass
+
 
 def create_pipetting_handler(
     state_view: StateView, hardware_api: HardwareControlAPI

opentrons/protocol_engine/execution/tip_handler.py

@@ -4,7 +4,11 @@ from typing import Optional, Dict
 from typing_extensions import Protocol as TypingProtocol
 
 from opentrons.hardware_control import HardwareControlAPI
-from opentrons.hardware_control.types import FailedTipStateCheck, InstrumentProbeType
+from opentrons.hardware_control.types import (
+    FailedTipStateCheck,
+    InstrumentProbeType,
+    TipScrapeType,
+)
 from opentrons.protocol_engine.errors.exceptions import PickUpTipTipNotAttachedError
 from opentrons.types import Mount, NozzleConfigurationType
 
@@ -82,6 +86,7 @@ class TipHandler(TypingProtocol):
         home_after: Optional[bool],
         do_not_ignore_tip_presence: bool = True,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         """Drop the attached tip into the current location.
 
@@ -279,19 +284,22 @@ class HardwareTipHandler(TipHandler):
         home_after: Optional[bool],
         do_not_ignore_tip_presence: bool = True,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         """See documentation on abstract base class."""
         hw_mount = self._get_hw_mount(pipette_id)
 
         # Let the hardware controller handle defaulting home_after since its behavior
         # differs between machines
+        kwargs = {}
         if home_after is not None:
-            kwargs = {"home_after": home_after}
-        else:
-            kwargs = {}
+            kwargs["home_after"] = home_after
 
         await self._hardware_api.tip_drop_moves(
-            mount=hw_mount, ignore_plunger=ignore_plunger, **kwargs
+            mount=hw_mount,
+            ignore_plunger=ignore_plunger,
+            scrape_type=scrape_type,
+            **kwargs,
         )
 
         if do_not_ignore_tip_presence:
@@ -445,6 +453,7 @@ class VirtualTipHandler(TipHandler):
         home_after: Optional[bool],
         do_not_ignore_tip_presence: bool = True,
         ignore_plunger: bool = False,
+        scrape_type: TipScrapeType = TipScrapeType.NONE,
     ) -> None:
         """Pick up a tip at the current location using a virtual pipette.
 

opentrons/protocol_engine/labware_offset_standardization.py

@@ -0,0 +1,173 @@
+"""Convert labware offset creation requests and stored elements between legacy and new."""
+
+from opentrons_shared_data.robot.types import RobotType
+from opentrons_shared_data.deck.types import DeckDefinitionV5
+from .errors import (
+    OffsetLocationInvalidError,
+    FixtureDoesNotExistError,
+)
+from .types import (
+    LabwareOffsetCreate,
+    LegacyLabwareOffsetCreate,
+    LabwareOffsetCreateInternal,
+    LegacyLabwareOffsetLocation,
+    LabwareOffsetLocationSequence,
+    OnLabwareOffsetLocationSequenceComponent,
+    OnAddressableAreaOffsetLocationSequenceComponent,
+    OnModuleOffsetLocationSequenceComponent,
+    ModuleModel,
+)
+from .resources import deck_configuration_provider
+
+
+def standardize_labware_offset_create(
+    request: LabwareOffsetCreate | LegacyLabwareOffsetCreate,
+    robot_type: RobotType,
+    deck_definition: DeckDefinitionV5,
+) -> LabwareOffsetCreateInternal:
+    """Turn a union of old and new labware offset create requests into a new one."""
+    location_sequence, legacy_location = _locations_for_create(
+        request, robot_type, deck_definition
+    )
+    return LabwareOffsetCreateInternal(
+        definitionUri=request.definitionUri,
+        locationSequence=location_sequence,
+        legacyLocation=legacy_location,
+        vector=request.vector,
+    )
+
+
+def legacy_offset_location_to_offset_location_sequence(
+    location: LegacyLabwareOffsetLocation, deck_definition: DeckDefinitionV5
+) -> LabwareOffsetLocationSequence:
+    """Convert a legacy location to a new-style sequence."""
+    sequence: LabwareOffsetLocationSequence = []
+    if location.definitionUri:
+        sequence.append(
+            OnLabwareOffsetLocationSequenceComponent(labwareUri=location.definitionUri)
+        )
+    if location.moduleModel:
+        sequence.append(
+            OnModuleOffsetLocationSequenceComponent(moduleModel=location.moduleModel)
+        )
+        cutout_id = deck_configuration_provider.get_cutout_id_by_deck_slot_name(
+            location.slotName
+        )
+        possible_cutout_fixture_id = location.moduleModel.value
+        try:
+            addressable_area = deck_configuration_provider.get_labware_hosting_addressable_area_name_for_cutout_and_cutout_fixture(
+                cutout_id, possible_cutout_fixture_id, deck_definition
+            )
+            sequence.append(
+                OnAddressableAreaOffsetLocationSequenceComponent(
+                    addressableAreaName=addressable_area
+                )
+            )
+        except FixtureDoesNotExistError:
+            # this is an OT-2 (or this module isn't supported in the deck definition) and we should use a
+            # slot addressable area name
+            sequence.append(
+                OnAddressableAreaOffsetLocationSequenceComponent(
+                    addressableAreaName=location.slotName.value
+                )
+            )
+
+    else:
+        # Slight hack: we should have a more formal association here. However, since the slot
+        # name is already standardized, and since the addressable areas for slots are just the
+        # name of the slots, we can rely on this.
+        sequence.append(
+            OnAddressableAreaOffsetLocationSequenceComponent(
+                addressableAreaName=location.slotName.value
+            )
+        )
+    return sequence
+
+
+def _offset_location_sequence_head_to_labware_and_module(
+    location_sequence: LabwareOffsetLocationSequence,
+) -> tuple[ModuleModel | None, str | None]:
+    labware_uri: str | None = None
+    module_model: ModuleModel | None = None
+    for location in location_sequence:
+        if isinstance(location, OnAddressableAreaOffsetLocationSequenceComponent):
+            raise OffsetLocationInvalidError(
+                "Addressable areas may only be the final element of an offset location."
+            )
+        elif isinstance(location, OnLabwareOffsetLocationSequenceComponent):
+            if labware_uri is not None:
+                # We only take the first location
+                continue
+            if module_model is not None:
+                # Labware can't be underneath modules
+                raise OffsetLocationInvalidError(
+                    "Labware must not be underneath a module."
+                )
+            labware_uri = location.labwareUri
+        elif isinstance(location, OnModuleOffsetLocationSequenceComponent):
+            if module_model is not None:
+                # Bad, somebody put more than one module in here
+                raise OffsetLocationInvalidError(
+                    "Only one module location may exist in an offset location."
+                )
+            module_model = location.moduleModel
+        else:
+            raise OffsetLocationInvalidError(
+                f"Invalid location component in offset location: {repr(location)}"
+            )
+    return module_model, labware_uri
+
+
+def _offset_location_sequence_to_legacy_offset_location(
+    location_sequence: LabwareOffsetLocationSequence, deck_definition: DeckDefinitionV5
+) -> LegacyLabwareOffsetLocation:
+    if len(location_sequence) == 0:
+        raise OffsetLocationInvalidError(
+            "Offset locations must contain at least one component."
+        )
+    last_element = location_sequence[-1]
+    if not isinstance(last_element, OnAddressableAreaOffsetLocationSequenceComponent):
+        raise OffsetLocationInvalidError(
+            "Offset locations must end with an addressable area."
+        )
+    module_model, labware_uri = _offset_location_sequence_head_to_labware_and_module(
+        location_sequence[:-1]
+    )
+    (
+        cutout_id,
+        cutout_fixtures,
+    ) = deck_configuration_provider.get_potential_cutout_fixtures(
+        last_element.addressableAreaName, deck_definition
+    )
+    slot_name = deck_configuration_provider.get_deck_slot_for_cutout_id(cutout_id)
+    return LegacyLabwareOffsetLocation(
+        slotName=slot_name, moduleModel=module_model, definitionUri=labware_uri
+    )
+
+
+def _locations_for_create(
+    request: LabwareOffsetCreate | LegacyLabwareOffsetCreate,
+    robot_type: RobotType,
+    deck_definition: DeckDefinitionV5,
+) -> tuple[LabwareOffsetLocationSequence, LegacyLabwareOffsetLocation]:
+    if isinstance(request, LabwareOffsetCreate):
+        return (
+            request.locationSequence,
+            _offset_location_sequence_to_legacy_offset_location(
+                request.locationSequence, deck_definition
+            ),
+        )
+    else:
+        normalized = request.location.model_copy(
+            update={
+                "slotName": request.location.slotName.to_equivalent_for_robot_type(
+                    robot_type
+                )
+            }
+        )
+        return (
+            legacy_offset_location_to_offset_location_sequence(
+                normalized, deck_definition
+            ),
+            normalized,
+        )