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

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -10,6 +10,7 @@ from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import CannotPerformModuleAction
 from opentrons.protocol_engine.types import AddressableAreaLocation
 
+from opentrons.protocol_engine.resources import labware_validation
 from ...state.update_types import StateUpdate
 
 
@@ -52,35 +53,41 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
 
     async def execute(self, params: CloseLidParams) -> SuccessData[CloseLidResult]:
         """Execute the close lid command."""
-        state_update = StateUpdate()
         mod_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
 
+        # lid should currently be on the module
+        assert mod_substate.lid_id is not None
+        loaded_lid = self._state_view.labware.get(mod_substate.lid_id)
+        assert labware_validation.is_absorbance_reader_lid(loaded_lid.loadName)
+
         hardware_lid_status = AbsorbanceReaderLidStatus.OFF
+        # If the lid is closed, if the lid is open No-op out
         if not self._state_view.config.use_virtual_modules:
             abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
             if abs_reader is not None:
-                hardware_lid_status = await abs_reader.get_current_lid_status()
+                result = await abs_reader.get_current_lid_status()
+                hardware_lid_status = result
             else:
                 raise CannotPerformModuleAction(
                     "Could not reach the Hardware API for Opentrons Plate Reader Module."
                 )
 
+        # If the lid is already ON, no-op losing lid
         if hardware_lid_status is AbsorbanceReaderLidStatus.ON:
-            # The lid is already physically ON, so we can no-op physically closing it
-            state_update.set_absorbance_reader_lid(
-                module_id=mod_substate.module_id, is_lid_on=True
+            # The lid is already On, so we can no-op and return the lids current location data
+            assert isinstance(loaded_lid.location, AddressableAreaLocation)
+            new_location = loaded_lid.location
+            new_offset_id = self._equipment.find_applicable_labware_offset_id(
+                labware_definition_uri=loaded_lid.definitionUri,
+                labware_location=loaded_lid.location,
             )
         else:
             # Allow propagation of ModuleNotAttachedError.
             _ = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
-            lid_definition = (
-                self._state_view.labware.get_absorbance_reader_lid_definition()
-            )
-
             current_location = self._state_view.modules.absorbance_reader_dock_location(
                 params.moduleId
             )
@@ -100,29 +107,35 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
                 )
             )
 
-            # The lid's labware definition stores gripper offsets for itself in the
-            # space normally meant for offsets for labware stacked atop it.
-            lid_gripper_offsets = self._state_view.labware.get_child_gripper_offsets(
-                labware_definition=lid_definition,
-                slot_name=None,
+            lid_gripper_offsets = self._state_view.labware.get_labware_gripper_offsets(
+                loaded_lid.id, None
             )
             if lid_gripper_offsets is None:
                 raise ValueError(
                     "Gripper Offset values for Absorbance Reader Lid labware must not be None."
                 )
 
+            # Skips gripper moves when using virtual gripper
             await self._labware_movement.move_labware_with_gripper(
-                labware_definition=lid_definition,
+                labware_id=loaded_lid.id,
                 current_location=current_location,
                 new_location=new_location,
                 user_offset_data=lid_gripper_offsets,
                 post_drop_slide_offset=None,
             )
-            state_update.set_absorbance_reader_lid(
-                module_id=mod_substate.module_id,
-                is_lid_on=True,
+
+            new_offset_id = self._equipment.find_applicable_labware_offset_id(
+                labware_definition_uri=loaded_lid.definitionUri,
+                labware_location=new_location,
             )
 
+        state_update = StateUpdate()
+        state_update.set_labware_location(
+            labware_id=loaded_lid.id,
+            new_location=new_location,
+            new_offset_id=new_offset_id,
+        )
+
         return SuccessData(
             public=CloseLidResult(),
             state_update=state_update,

opentrons/protocol_engine/commands/absorbance_reader/initialize.py

@@ -10,7 +10,6 @@ from opentrons.protocol_engine.types import ABSMeasureMode
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
-from ...errors import InvalidWavelengthError
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
@@ -70,41 +69,30 @@ class InitializeImpl(
             unsupported_wavelengths = sample_wavelengths.difference(
                 supported_wavelengths
             )
-            sample_wl_str = ", ".join([str(w) + "nm" for w in sample_wavelengths])
-            supported_wl_str = ", ".join([str(w) + "nm" for w in supported_wavelengths])
-            unsupported_wl_str = ", ".join(
-                [str(w) + "nm" for w in unsupported_wavelengths]
-            )
             if unsupported_wavelengths:
-                raise InvalidWavelengthError(
-                    f"Unsupported wavelengths: {unsupported_wl_str}. "
-                    f" Use one of {supported_wl_str} instead."
-                )
+                raise ValueError(f"Unsupported wavelengths: {unsupported_wavelengths}")
 
             if params.measureMode == "single":
                 if sample_wavelengths_len != 1:
                     raise ValueError(
-                        f"Measure mode `single` requires one sample wavelength,"
-                        f" {sample_wl_str} provided instead."
+                        f"single requires one sample wavelength, provided {sample_wavelengths}"
                     )
                 if (
                     reference_wavelength is not None
                     and reference_wavelength not in supported_wavelengths
                 ):
-                    raise InvalidWavelengthError(
-                        f"Reference wavelength {reference_wavelength}nm is not supported."
-                        f" Use one of {supported_wl_str} instead."
+                    raise ValueError(
+                        f"Reference wavelength {reference_wavelength} not supported {supported_wavelengths}"
                     )
 
             if params.measureMode == "multi":
                 if sample_wavelengths_len < 1 or sample_wavelengths_len > 6:
                     raise ValueError(
-                        f"Measure mode `multi` requires 1-6 sample wavelengths,"
-                        f" {sample_wl_str} provided instead."
+                        f"multi requires 1-6 sample wavelengths, provided {sample_wavelengths}"
                     )
                 if reference_wavelength is not None:
-                    raise ValueError(
-                        "Reference wavelength cannot be used with Measure mode `multi`."
+                    raise RuntimeError(
+                        "Reference wavelength cannot be used with multi mode."
                     )
 
             await abs_reader.set_sample_wavelength(

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -9,6 +9,7 @@ from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, Succe
 from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import CannotPerformModuleAction
 
+from opentrons.protocol_engine.resources import labware_validation
 from opentrons.protocol_engine.types import AddressableAreaLocation
 
 from opentrons.drivers.types import AbsorbanceReaderLidStatus
@@ -53,35 +54,39 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
 
     async def execute(self, params: OpenLidParams) -> SuccessData[OpenLidResult]:
         """Move the absorbance reader lid from the module to the lid dock."""
-        state_update = StateUpdate()
         mod_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
+        # lid should currently be on the module
+        assert mod_substate.lid_id is not None
+        loaded_lid = self._state_view.labware.get(mod_substate.lid_id)
+        assert labware_validation.is_absorbance_reader_lid(loaded_lid.loadName)
 
         hardware_lid_status = AbsorbanceReaderLidStatus.ON
+        # If the lid is closed, if the lid is open No-op out
         if not self._state_view.config.use_virtual_modules:
             abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
             if abs_reader is not None:
-                hardware_lid_status = await abs_reader.get_current_lid_status()
+                result = await abs_reader.get_current_lid_status()
+                hardware_lid_status = result
             else:
                 raise CannotPerformModuleAction(
                     "Could not reach the Hardware API for Opentrons Plate Reader Module."
                 )
 
+        # If the lid is already OFF, no-op the lid removal
         if hardware_lid_status is AbsorbanceReaderLidStatus.OFF:
-            # The lid is already physically OFF, so we can no-op physically closing it
-            state_update.set_absorbance_reader_lid(
-                module_id=mod_substate.module_id, is_lid_on=False
+            assert isinstance(loaded_lid.location, AddressableAreaLocation)
+            new_location = loaded_lid.location
+            new_offset_id = self._equipment.find_applicable_labware_offset_id(
+                labware_definition_uri=loaded_lid.definitionUri,
+                labware_location=loaded_lid.location,
             )
         else:
             # Allow propagation of ModuleNotAttachedError.
             _ = self._equipment.get_module_hardware_api(mod_substate.module_id)
 
-            lid_definition = (
-                self._state_view.labware.get_absorbance_reader_lid_definition()
-            )
-
             absorbance_model = self._state_view.modules.get_requested_model(
                 params.moduleId
             )
@@ -101,28 +106,35 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
                 mod_substate.module_id
             )
 
-            # The lid's labware definition stores gripper offsets for itself in the
-            # space normally meant for offsets for labware stacked atop it.
-            lid_gripper_offsets = self._state_view.labware.get_child_gripper_offsets(
-                labware_definition=lid_definition,
-                slot_name=None,
+            lid_gripper_offsets = self._state_view.labware.get_labware_gripper_offsets(
+                loaded_lid.id, None
             )
             if lid_gripper_offsets is None:
                 raise ValueError(
                     "Gripper Offset values for Absorbance Reader Lid labware must not be None."
                 )
 
+            # Skips gripper moves when using virtual gripper
             await self._labware_movement.move_labware_with_gripper(
-                labware_definition=lid_definition,
+                labware_id=loaded_lid.id,
                 current_location=current_location,
                 new_location=new_location,
                 user_offset_data=lid_gripper_offsets,
                 post_drop_slide_offset=None,
             )
-            state_update.set_absorbance_reader_lid(
-                module_id=mod_substate.module_id, is_lid_on=False
+            new_offset_id = self._equipment.find_applicable_labware_offset_id(
+                labware_definition_uri=loaded_lid.definitionUri,
+                labware_location=new_location,
             )
 
+        state_update = StateUpdate()
+
+        state_update.set_labware_location(
+            labware_id=loaded_lid.id,
+            new_location=new_location,
+            new_offset_id=new_offset_id,
+        )
+
         return SuccessData(
             public=OpenLidResult(),
             state_update=state_update,

opentrons/protocol_engine/commands/absorbance_reader/read.py

@@ -80,10 +80,6 @@ class ReadAbsorbanceImpl(
             raise CannotPerformModuleAction(
                 "Cannot perform Read action on Absorbance Reader without calling `.initialize(...)` first."
             )
-        if abs_reader_substate.is_lid_on is False:
-            raise CannotPerformModuleAction(
-                "Absorbance Plate Reader can't read a plate with the lid open. Call `close_lid()` first."
-            )
 
         # TODO: we need to return a file ID and increase the file count even when a moduel is not attached
         if (

opentrons/protocol_engine/commands/aspirate_in_place.py

@@ -83,11 +83,10 @@ class AspirateInPlaceImplementation(
             TipNotAttachedError: if no tip is attached to the pipette.
             PipetteNotReadyToAspirateError: pipette plunger is not ready.
         """
-        state_update = StateUpdate()
-
         ready_to_aspirate = self._pipetting.get_is_ready_to_aspirate(
             pipette_id=params.pipetteId,
         )
+
         if not ready_to_aspirate:
             raise PipetteNotReadyToAspirateError(
                 "Pipette cannot aspirate in place because of a previous blow out."
@@ -95,10 +94,11 @@ class AspirateInPlaceImplementation(
                 " so the plunger can be reset in a known safe position."
             )
 
+        state_update = StateUpdate()
         current_location = self._state_view.pipettes.get_current_location()
-        current_position = await self._gantry_mover.get_position(params.pipetteId)
 
         try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
             volume = await self._pipetting.aspirate_in_place(
                 pipette_id=params.pipetteId,
                 volume=params.volume,

opentrons/protocol_engine/commands/command.py

@@ -185,9 +185,7 @@ class BaseCommand(
     )
     error: Union[
         _ErrorT,
-        # ErrorOccurrence here is a catch-all for undefined errors not captured by
-        # _ErrorT, or defined errors that don't parse into _ErrorT because, for example,
-        # they are from an older software version that was missing some fields.
+        # ErrorOccurrence here is for undefined errors not captured by _ErrorT.
         ErrorOccurrence,
         None,
     ] = Field(

opentrons/protocol_engine/commands/dispense_in_place.py

@@ -76,8 +76,8 @@ class DispenseInPlaceImplementation(
         """Dispense without moving the pipette."""
         state_update = StateUpdate()
         current_location = self._state_view.pipettes.get_current_location()
-        current_position = await self._gantry_mover.get_position(params.pipetteId)
         try:
+            current_position = await self._gantry_mover.get_position(params.pipetteId)
             volume = await self._pipetting.dispense_in_place(
                 pipette_id=params.pipetteId,
                 volume=params.volume,

opentrons/protocol_engine/commands/drop_tip.py

@@ -145,7 +145,6 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
                         error=exception,
                     )
                 ],
-                errorInfo={"retryLocation": position},
             )
             state_update_if_false_positive = update_types.StateUpdate()
             state_update_if_false_positive.update_pipette_tip_state(
@@ -166,7 +165,7 @@ class DropTipImplementation(AbstractCommandImpl[DropTipParams, _ExecuteReturn]):
             )
 
 
-class DropTip(BaseCommand[DropTipParams, DropTipResult, TipPhysicallyAttachedError]):
+class DropTip(BaseCommand[DropTipParams, DropTipResult, ErrorOccurrence]):
     """Drop tip command model."""
 
     commandType: DropTipCommandType = "dropTip"

opentrons/protocol_engine/commands/drop_tip_in_place.py

@@ -18,7 +18,7 @@ from ..resources.model_utils import ModelUtils
 from ..state import update_types
 
 if TYPE_CHECKING:
-    from ..execution import TipHandler, GantryMover
+    from ..execution import TipHandler
 
 
 DropTipInPlaceCommandType = Literal["dropTipInPlace"]
@@ -57,19 +57,15 @@ class DropTipInPlaceImplementation(
         self,
         tip_handler: TipHandler,
         model_utils: ModelUtils,
-        gantry_mover: GantryMover,
         **kwargs: object,
     ) -> None:
         self._tip_handler = tip_handler
         self._model_utils = model_utils
-        self._gantry_mover = gantry_mover
 
     async def execute(self, params: DropTipInPlaceParams) -> _ExecuteReturn:
         """Drop a tip using the requested pipette."""
         state_update = update_types.StateUpdate()
 
-        retry_location = await self._gantry_mover.get_position(params.pipetteId)
-
         try:
             await self._tip_handler.drop_tip(
                 pipette_id=params.pipetteId, home_after=params.homeAfter
@@ -89,7 +85,6 @@ class DropTipInPlaceImplementation(
                         error=exception,
                     )
                 ],
-                errorInfo={"retryLocation": retry_location},
             )
             return DefinedErrorData(
                 public=error,
@@ -104,7 +99,7 @@ class DropTipInPlaceImplementation(
 
 
 class DropTipInPlace(
-    BaseCommand[DropTipInPlaceParams, DropTipInPlaceResult, TipPhysicallyAttachedError]
+    BaseCommand[DropTipInPlaceParams, DropTipInPlaceResult, ErrorOccurrence]
 ):
     """Drop tip in place command model."""
 

opentrons/protocol_engine/commands/load_labware.py

@@ -10,8 +10,6 @@ from ..errors import LabwareIsNotAllowedInLocationError
 from ..resources import labware_validation, fixture_validation
 from ..types import (
     LabwareLocation,
-    ModuleLocation,
-    ModuleModel,
     OnLabwareLocation,
     DeckSlotLocation,
     AddressableAreaLocation,
@@ -162,13 +160,6 @@ class LoadLabwareImplementation(
                 top_labware_definition=loaded_labware.definition,
                 bottom_labware_id=verified_location.labwareId,
             )
-        # Validate labware for the absorbance reader
-        elif isinstance(params.location, ModuleLocation):
-            module = self._state_view.modules.get(params.location.moduleId)
-            if module is not None and module.model == ModuleModel.ABSORBANCE_READER_V1:
-                self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
-                    loaded_labware.definition
-                )
 
         return SuccessData(
             public=LoadLabwareResult(

opentrons/protocol_engine/commands/load_module.py

@@ -5,6 +5,7 @@ from typing_extensions import Literal
 from pydantic import BaseModel, Field
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors import ModuleNotLoadedError
 from ..errors.error_occurrence import ErrorOccurrence
 from ..types import (
     DeckSlotLocation,
@@ -16,6 +17,7 @@ from opentrons.types import DeckSlotName
 
 from opentrons.protocol_engine.resources import deck_configuration_provider
 
+from opentrons.drivers.types import AbsorbanceReaderLidStatus
 
 if TYPE_CHECKING:
     from ..state.state import StateView
@@ -150,6 +152,43 @@ class LoadModuleImplementation(
                 module_id=params.moduleId,
             )
 
+        # Handle lid position update for loaded Plate Reader module on deck
+        if (
+            not self._state_view.config.use_virtual_modules
+            and params.model == ModuleModel.ABSORBANCE_READER_V1
+            and params.moduleId is not None
+        ):
+            try:
+                abs_reader = self._equipment.get_module_hardware_api(
+                    self._state_view.modules.get_absorbance_reader_substate(
+                        params.moduleId
+                    ).module_id
+                )
+            except ModuleNotLoadedError:
+                abs_reader = None
+
+            if abs_reader is not None:
+                result = await abs_reader.get_current_lid_status()
+                if (
+                    isinstance(result, AbsorbanceReaderLidStatus)
+                    and result is not AbsorbanceReaderLidStatus.ON
+                ):
+                    reader_area = self._state_view.modules.ensure_and_convert_module_fixture_location(
+                        params.location.slotName,
+                        self._state_view.config.deck_type,
+                        params.model,
+                    )
+                    lid_labware = self._state_view.labware.get_by_addressable_area(
+                        reader_area
+                    )
+
+                    if lid_labware is not None:
+                        self._state_view.labware._state.labware_by_id[
+                            lid_labware.id
+                        ].location = self._state_view.modules.absorbance_reader_dock_location(
+                            params.moduleId
+                        )
+
         return SuccessData(
             public=LoadModuleResult(
                 moduleId=loaded_module.module_id,

opentrons/protocol_engine/commands/move_labware.py

@@ -13,22 +13,16 @@ from typing_extensions import Literal
 from opentrons.protocol_engine.resources.model_utils import ModelUtils
 from opentrons.types import Point
 from ..types import (
-    ModuleModel,
     CurrentWell,
     LabwareLocation,
     DeckSlotLocation,
-    ModuleLocation,
     OnLabwareLocation,
     AddressableAreaLocation,
     LabwareMovementStrategy,
     LabwareOffsetVector,
     LabwareMovementOffsetData,
 )
-from ..errors import (
-    LabwareMovementNotAllowedError,
-    NotSupportedOnRobotType,
-    LabwareOffsetDoesNotExistError,
-)
+from ..errors import LabwareMovementNotAllowedError, NotSupportedOnRobotType
 from ..resources import labware_validation, fixture_validation
 from .command import (
     AbstractCommandImpl,
@@ -136,7 +130,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
         )
         definition_uri = current_labware.definitionUri
         post_drop_slide_offset: Optional[Point] = None
-        trash_lid_drop_offset: Optional[LabwareOffsetVector] = None
 
         if self._state_view.labware.is_fixed_trash(params.labwareId):
             raise LabwareMovementNotAllowedError(
@@ -145,11 +138,9 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
 
         if isinstance(params.newLocation, AddressableAreaLocation):
             area_name = params.newLocation.addressableAreaName
-            if (
-                not fixture_validation.is_gripper_waste_chute(area_name)
-                and not fixture_validation.is_deck_slot(area_name)
-                and not fixture_validation.is_trash(area_name)
-            ):
+            if not fixture_validation.is_gripper_waste_chute(
+                area_name
+            ) and not fixture_validation.is_deck_slot(area_name):
                 raise LabwareMovementNotAllowedError(
                     f"Cannot move {current_labware.loadName} to addressable area {area_name}"
                 )
@@ -171,32 +162,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                     y=0,
                     z=0,
                 )
-            elif fixture_validation.is_trash(area_name):
-                # When dropping labware in the trash bins we want to ensure they are lids
-                # and enforce a y-axis drop offset to ensure they fall within the trash bin
-                if labware_validation.validate_definition_is_lid(
-                    self._state_view.labware.get_definition(params.labwareId)
-                ):
-                    lid_disposable_offfets = (
-                        current_labware_definition.gripperOffsets.get(
-                            "lidDisposalOffsets"
-                        )
-                    )
-                    if lid_disposable_offfets is not None:
-                        trash_lid_drop_offset = LabwareOffsetVector(
-                            x=lid_disposable_offfets.dropOffset.x,
-                            y=lid_disposable_offfets.dropOffset.y,
-                            z=lid_disposable_offfets.dropOffset.z,
-                        )
-                    else:
-                        raise LabwareOffsetDoesNotExistError(
-                            f"Labware Definition {current_labware.loadName} does not contain required field 'lidDisposalOffsets' of 'gripperOffsets'."
-                        )
-                else:
-                    raise LabwareMovementNotAllowedError(
-                        "Can only move labware with allowed role 'Lid' to a Trash Bin."
-                    )
-
         elif isinstance(params.newLocation, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.newLocation.slotName.id
@@ -223,13 +188,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 raise LabwareMovementNotAllowedError(
                     "Cannot move a labware onto itself."
                 )
-        # Validate labware for the absorbance reader
-        elif isinstance(available_new_location, ModuleLocation):
-            module = self._state_view.modules.get(available_new_location.moduleId)
-            if module is not None and module.model == ModuleModel.ABSORBANCE_READER_V1:
-                self._state_view.labware.raise_if_labware_incompatible_with_plate_reader(
-                    current_labware_definition
-                )
 
         # Allow propagation of ModuleNotLoadedError.
         new_offset_id = self._equipment.find_applicable_labware_offset_id(
@@ -274,9 +232,6 @@ class MoveLabwareImplementation(AbstractCommandImpl[MoveLabwareParams, _ExecuteR
                 dropOffset=params.dropOffset or LabwareOffsetVector(x=0, y=0, z=0),
             )
 
-            if trash_lid_drop_offset:
-                user_offset_data.dropOffset += trash_lid_drop_offset
-
             try:
                 # Skips gripper moves when using virtual gripper
                 await self._labware_movement.move_labware_with_gripper(

opentrons/protocol_engine/commands/pick_up_tip.py

@@ -82,7 +82,7 @@ class TipPhysicallyMissingError(ErrorOccurrence):
     isDefined: bool = True
     errorType: Literal["tipPhysicallyMissing"] = "tipPhysicallyMissing"
     errorCode: str = ErrorCodes.TIP_PICKUP_FAILED.value.code
-    detail: str = "No Tip Detected"
+    detail: str = "No tip detected."
 
 
 _ExecuteReturn = Union[

opentrons/protocol_engine/commands/pipetting_common.py

@@ -148,12 +148,7 @@ class DestinationPositionResult(BaseModel):
 
 
 class ErrorLocationInfo(TypedDict):
-    """Holds a retry location for in-place error recovery.
-
-    This is appropriate to pass to a `moveToCoordinates` command,
-    assuming the pipette has not been configured with a different nozzle layout
-    in the meantime.
-    """
+    """Holds a retry location for in-place error recovery."""
 
     retryLocation: Tuple[float, float, float]
 
@@ -206,5 +201,3 @@ class TipPhysicallyAttachedError(ErrorOccurrence):
 
     errorCode: str = ErrorCodes.TIP_DROP_FAILED.value.code
     detail: str = ErrorCodes.TIP_DROP_FAILED.value.detail
-
-    errorInfo: ErrorLocationInfo