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

opentrons/protocol_engine/commands/unsafe/unsafe_place_labware.py

@@ -1,12 +1,9 @@
 """Place labware payload, result, and implementaiton."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Type
-from typing_extensions import Literal
-
-from opentrons_shared_data.labware.types import LabwareUri
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from pydantic import BaseModel, Field
+from typing import TYPE_CHECKING, Optional, Type, cast
+from typing_extensions import Literal
 
 from opentrons.hardware_control.types import Axis, OT3Mount
 from opentrons.motion_planning.waypoints import get_gripper_labware_placement_waypoints
@@ -16,14 +13,11 @@ from opentrons.protocol_engine.errors.exceptions import (
 )
 from opentrons.types import Point
 
-from ...types import (
-    DeckSlotLocation,
-    ModuleModel,
-    OnDeckLabwareLocation,
-)
+from ...types import DeckSlotLocation, ModuleModel, OnDeckLabwareLocation
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 from ...resources import ensure_ot3_hardware
+from ...state.update_types import StateUpdate
 
 from opentrons.hardware_control import HardwareControlAPI, OT3HardwareControlAPI
 
@@ -38,7 +32,7 @@ UnsafePlaceLabwareCommandType = Literal["unsafe/placeLabware"]
 class UnsafePlaceLabwareParams(BaseModel):
     """Payload required for an UnsafePlaceLabware command."""
 
-    labwareURI: str = Field(..., description="Labware URI for labware.")
+    labwareId: str = Field(..., description="The id of the labware to place.")
     location: OnDeckLabwareLocation = Field(
         ..., description="Where to place the labware."
     )
@@ -77,8 +71,8 @@ class UnsafePlaceLabwareImplementation(
         is pressed, get into error recovery, etc).
 
         Unlike the `moveLabware` command, where you pick a source and destination
-        location, this command takes the labwareURI of the labware to be moved
-        and location to move it to.
+        location, this command takes the labwareId to be moved and location to
+        move it to.
 
         """
         ot3api = ensure_ot3_hardware(self._hardware_api)
@@ -90,37 +84,23 @@ class UnsafePlaceLabwareImplementation(
                 "Cannot place labware when gripper is not gripping."
             )
 
-        location = self._state_view.geometry.ensure_valid_gripper_location(
-            params.location,
-        )
-
-        definition = self._state_view.labware.get_definition_by_uri(
-            # todo(mm, 2024-11-07): This is an unsafe cast from untrusted input.
-            # We need a str -> LabwareUri parse/validate function.
-            LabwareUri(params.labwareURI)
-        )
-
-        # todo(mm, 2024-11-06): This is only correct in the special case of an
-        # absorbance reader lid. Its definition currently puts the offsets for *itself*
-        # in the property that's normally meant for offsets for its *children.*
-        final_offsets = self._state_view.labware.get_child_gripper_offsets(
-            labware_definition=definition, slot_name=None
-        )
-        drop_offset = (
-            Point(
-                final_offsets.dropOffset.x,
-                final_offsets.dropOffset.y,
-                final_offsets.dropOffset.z,
-            )
-            if final_offsets
-            else None
+        # Allow propagation of LabwareNotLoadedError.
+        labware_id = params.labwareId
+        definition_uri = self._state_view.labware.get(labware_id).definitionUri
+        final_offsets = self._state_view.labware.get_labware_gripper_offsets(
+            labware_id, None
         )
+        drop_offset = cast(Point, final_offsets.dropOffset) if final_offsets else None
 
         if isinstance(params.location, DeckSlotLocation):
             self._state_view.addressable_areas.raise_if_area_not_in_deck_configuration(
                 params.location.slotName.id
             )
 
+        location = self._state_view.geometry.ensure_valid_gripper_location(
+            params.location,
+        )
+
         # This is an absorbance reader, move the lid to its dock (staging area).
         if isinstance(location, DeckSlotLocation):
             module = self._state_view.modules.get_by_slot(location.slotName)
@@ -129,24 +109,30 @@ class UnsafePlaceLabwareImplementation(
                     module.id
                 )
 
-        # NOTE: When the estop is pressed, the gantry loses position, lets use
-        # the encoders to sync position.
-        # Ideally, we'd do a full home, but this command is used when
-        # the gripper is holding the plate reader, and a full home would
-        # bang it into the right window.
-        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
-        await ot3api.engage_axes([Axis.X, Axis.Y])
-        await ot3api.update_axis_position_estimations([Axis.X, Axis.Y])
+        new_offset_id = self._equipment.find_applicable_labware_offset_id(
+            labware_definition_uri=definition_uri,
+            labware_location=location,
+        )
+
+        # NOTE: When the estop is pressed, the gantry loses position,
+        # so the robot needs to home x, y to sync.
+        await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G, Axis.X, Axis.Y])
+        state_update = StateUpdate()
 
         # Place the labware down
-        await self._start_movement(ot3api, definition, location, drop_offset)
+        await self._start_movement(ot3api, labware_id, location, drop_offset)
 
-        return SuccessData(public=UnsafePlaceLabwareResult())
+        state_update.set_labware_location(
+            labware_id=labware_id,
+            new_location=location,
+            new_offset_id=new_offset_id,
+        )
+        return SuccessData(public=UnsafePlaceLabwareResult(), state_update=state_update)
 
     async def _start_movement(
         self,
         ot3api: OT3HardwareControlAPI,
-        labware_definition: LabwareDefinition,
+        labware_id: str,
         location: OnDeckLabwareLocation,
         drop_offset: Optional[Point],
     ) -> None:
@@ -156,7 +142,7 @@ class UnsafePlaceLabwareImplementation(
         )
 
         to_labware_center = self._state_view.geometry.get_labware_grip_point(
-            labware_definition=labware_definition, location=location
+            labware_id=labware_id, location=location
         )
 
         movement_waypoints = get_gripper_labware_placement_waypoints(

opentrons/protocol_engine/commands/unsafe/unsafe_ungrip_labware.py

@@ -1,8 +1,6 @@
 """Ungrip labware payload, result, and implementaiton."""
 
 from __future__ import annotations
-
-from opentrons.hardware_control.types import Axis
 from opentrons.protocol_engine.errors.exceptions import GripperNotAttachedError
 from pydantic import BaseModel
 from typing import Optional, Type
@@ -48,7 +46,7 @@ class UnsafeUngripLabwareImplementation(
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         if not ot3_hardware_api.has_gripper():
             raise GripperNotAttachedError("No gripper found to perform ungrip.")
-        await ot3_hardware_api.home([Axis.G])
+        await ot3_hardware_api.ungrip()
         return SuccessData(
             public=UnsafeUngripLabwareResult(),
         )

opentrons/protocol_engine/commands/unsafe/update_position_estimators.py

@@ -23,11 +23,7 @@ class UpdatePositionEstimatorsParams(BaseModel):
     """Payload required for an UpdatePositionEstimators command."""
 
     axes: List[MotorAxis] = Field(
-        ...,
-        description=(
-            "The axes for which to update the position estimators."
-            " Any axes that are not physically present will be ignored."
-        ),
+        ..., description="The axes for which to update the position estimators."
     )
 
 

opentrons/protocol_engine/create_protocol_engine.py

@@ -8,9 +8,6 @@ from opentrons.hardware_control.types import DoorState
 from opentrons.protocol_engine.execution.error_recovery_hardware_state_synchronizer import (
     ErrorRecoveryHardwareStateSynchronizer,
 )
-from opentrons.protocol_engine.resources.labware_data_provider import (
-    LabwareDataProvider,
-)
 from opentrons.util.async_helpers import async_context_manager_in_thread
 
 from opentrons_shared_data.robot import load as load_robot
@@ -84,7 +81,7 @@ async def create_protocol_engine(
     module_data_provider = ModuleDataProvider()
     file_provider = file_provider or FileProvider()
 
-    pe = ProtocolEngine(
+    return ProtocolEngine(
         hardware_api=hardware_api,
         state_store=state_store,
         action_dispatcher=action_dispatcher,
@@ -96,20 +93,6 @@ async def create_protocol_engine(
         file_provider=file_provider,
     )
 
-    # todo(mm, 2024-11-08): This is a quick hack to support the absorbance reader, which
-    # expects the engine to have this special labware definition available. It would be
-    # cleaner for the `loadModule` command to do this I/O and insert the definition
-    # into state. That gets easier after https://opentrons.atlassian.net/browse/EXEC-756.
-    #
-    # NOTE: This needs to stay in sync with LabwareView.get_absorbance_reader_lid_definition().
-    pe.add_labware_definition(
-        await LabwareDataProvider().get_labware_definition(
-            "opentrons_flex_lid_absorbance_plate_reader_module", "opentrons", 1
-        )
-    )
-
-    return pe
-
 
 @contextlib.contextmanager
 def create_protocol_engine_in_thread(

opentrons/protocol_engine/errors/__init__.py

@@ -55,7 +55,6 @@ from .exceptions import (
     InvalidTargetTemperatureError,
     InvalidBlockVolumeError,
     InvalidHoldTimeError,
-    InvalidWavelengthError,
     CannotPerformModuleAction,
     PauseNotAllowedError,
     ResumeFromRecoveryNotAllowedError,
@@ -138,7 +137,6 @@ __all__ = [
     "InvalidTargetSpeedError",
     "InvalidBlockVolumeError",
     "InvalidHoldTimeError",
-    "InvalidWavelengthError",
     "CannotPerformModuleAction",
     "ResumeFromRecoveryNotAllowedError",
     "PauseNotAllowedError",

opentrons/protocol_engine/errors/error_occurrence.py

@@ -12,6 +12,8 @@ from opentrons_shared_data.errors.exceptions import EnumeratedError
 log = getLogger(__name__)
 
 
+# TODO(mc, 2021-11-12): flesh this model out with structured error data
+# for each error type so client may produce better error messages
 class ErrorOccurrence(BaseModel):
     """An occurrence of a specific error during protocol execution."""
 
@@ -42,15 +44,8 @@ class ErrorOccurrence(BaseModel):
     id: str = Field(..., description="Unique identifier of this error occurrence.")
     createdAt: datetime = Field(..., description="When the error occurred.")
 
-    # Our Python should probably always set this to False--if we want it to be True,
-    # we should probably be using a more specific subclass of ErrorOccurrence anyway.
-    # However, we can't make this Literal[False], because we want this class to be able
-    # to act as a catch-all for parsing defined errors that might be missing some
-    # `errorInfo` fields because they were serialized by older software.
     isDefined: bool = Field(
-        # default=False for database backwards compatibility, so we can parse objects
-        # serialized before isDefined existed.
-        default=False,
+        default=False,  # default=False for database backwards compatibility.
         description=dedent(
             """\
             Whether this error is *defined.*

opentrons/protocol_engine/errors/exceptions.py

@@ -773,19 +773,6 @@ class InvalidBlockVolumeError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
-class InvalidWavelengthError(ProtocolEngineError):
-    """Raised when attempting to set an invalid absorbance wavelength."""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
-        wrapping: Optional[Sequence[EnumeratedError]] = None,
-    ) -> None:
-        """Build a InvalidWavelengthError."""
-        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
-
-
 class InvalidHoldTimeError(ProtocolEngineError):
     """An error raised when attempting to set an invalid temperature hold time."""
 

opentrons/protocol_engine/execution/labware_movement.py

@@ -1,9 +1,7 @@
 """Labware movement command handling."""
 from __future__ import annotations
 
-from typing import Optional, TYPE_CHECKING, overload
-
-from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+from typing import Optional, TYPE_CHECKING
 
 from opentrons.types import Point
 
@@ -81,64 +79,24 @@ class LabwareMovementHandler:
             )
         )
 
-    @overload
     async def move_labware_with_gripper(
         self,
-        *,
         labware_id: str,
         current_location: OnDeckLabwareLocation,
         new_location: OnDeckLabwareLocation,
         user_offset_data: LabwareMovementOffsetData,
         post_drop_slide_offset: Optional[Point],
     ) -> None:
-        ...
-
-    @overload
-    async def move_labware_with_gripper(
-        self,
-        *,
-        labware_definition: LabwareDefinition,
-        current_location: OnDeckLabwareLocation,
-        new_location: OnDeckLabwareLocation,
-        user_offset_data: LabwareMovementOffsetData,
-        post_drop_slide_offset: Optional[Point],
-    ) -> None:
-        ...
-
-    async def move_labware_with_gripper(  # noqa: C901
-        self,
-        *,
-        labware_id: str | None = None,
-        labware_definition: LabwareDefinition | None = None,
-        current_location: OnDeckLabwareLocation,
-        new_location: OnDeckLabwareLocation,
-        user_offset_data: LabwareMovementOffsetData,
-        post_drop_slide_offset: Optional[Point],
-    ) -> None:
-        """Physically move a labware from one location to another using the gripper.
-
-        Generally, provide the `labware_id` of a loaded labware, and this method will
-        automatically look up its labware definition. If you're physically moving
-        something that has not been loaded as a labware (this is not common),
-        provide the `labware_definition` yourself instead.
-        """
+        """Move a loaded labware from one location to another using gripper."""
         use_virtual_gripper = self._state_store.config.use_virtual_gripper
 
-        if labware_definition is None:
-            assert labware_id is not None  # From this method's @typing.overloads.
-            labware_definition = self._state_store.labware.get_definition(labware_id)
-
         if use_virtual_gripper:
-            # todo(mm, 2024-11-07): We should do this collision checking even when we
-            # only have a `labware_definition`, not a `labware_id`. Resolve when
-            # `check_gripper_labware_tip_collision()` can be made independent of `labware_id`.
-            if labware_id is not None:
-                self._state_store.geometry.check_gripper_labware_tip_collision(
-                    # During Analysis we will pass in hard coded estimates for certain positions only accessible during execution
-                    gripper_homed_position_z=_GRIPPER_HOMED_POSITION_Z,
-                    labware_id=labware_id,
-                    current_location=current_location,
-                )
+            # During Analysis we will pass in hard coded estimates for certain positions only accessible during execution
+            self._state_store.geometry.check_gripper_labware_tip_collision(
+                gripper_homed_position_z=_GRIPPER_HOMED_POSITION_Z,
+                labware_id=labware_id,
+                current_location=current_location,
+            )
             return
 
         ot3api = ensure_ot3_hardware(
@@ -161,16 +119,14 @@ class LabwareMovementHandler:
         await ot3api.home(axes=[Axis.Z_L, Axis.Z_R, Axis.Z_G])
         gripper_homed_position = await ot3api.gantry_position(mount=gripper_mount)
 
-        # todo(mm, 2024-11-07): We should do this collision checking even when we
-        # only have a `labware_definition`, not a `labware_id`. Resolve when
-        # `check_gripper_labware_tip_collision()` can be made independent of `labware_id`.
-        if labware_id is not None:
-            self._state_store.geometry.check_gripper_labware_tip_collision(
-                gripper_homed_position_z=gripper_homed_position.z,
-                labware_id=labware_id,
-                current_location=current_location,
-            )
+        # Verify that no tip collisions will occur during the move
+        self._state_store.geometry.check_gripper_labware_tip_collision(
+            gripper_homed_position_z=gripper_homed_position.z,
+            labware_id=labware_id,
+            current_location=current_location,
+        )
 
+        current_labware = self._state_store.labware.get_definition(labware_id)
         async with self._thermocycler_plate_lifter.lift_plate_for_labware_movement(
             labware_location=current_location
         ):
@@ -179,14 +135,14 @@ class LabwareMovementHandler:
                     from_location=current_location,
                     to_location=new_location,
                     additional_offset_vector=user_offset_data,
-                    current_labware=labware_definition,
+                    current_labware=current_labware,
                 )
             )
             from_labware_center = self._state_store.geometry.get_labware_grip_point(
-                labware_definition=labware_definition, location=current_location
+                labware_id=labware_id, location=current_location
             )
             to_labware_center = self._state_store.geometry.get_labware_grip_point(
-                labware_definition=labware_definition, location=new_location
+                labware_id=labware_id, location=new_location
             )
             movement_waypoints = get_gripper_labware_movement_waypoints(
                 from_labware_center=from_labware_center,
@@ -195,9 +151,7 @@ class LabwareMovementHandler:
                 offset_data=final_offsets,
                 post_drop_slide_offset=post_drop_slide_offset,
             )
-            labware_grip_force = self._state_store.labware.get_grip_force(
-                labware_definition
-            )
+            labware_grip_force = self._state_store.labware.get_grip_force(labware_id)
             holding_labware = False
             for waypoint_data in movement_waypoints:
                 if waypoint_data.jaw_open:
@@ -220,11 +174,9 @@ class LabwareMovementHandler:
                     # should be holding labware
                     if holding_labware:
                         labware_bbox = self._state_store.labware.get_dimensions(
-                            labware_definition=labware_definition
-                        )
-                        well_bbox = self._state_store.labware.get_well_bbox(
-                            labware_definition=labware_definition
+                            labware_id
                         )
+                        well_bbox = self._state_store.labware.get_well_bbox(labware_id)
                         # todo(mm, 2024-09-26): This currently raises a lower-level 2015 FailedGripperPickupError.
                         # Convert this to a higher-level 3001 LabwareDroppedError or 3002 LabwareNotPickedUpError,
                         # depending on what waypoint we're at, to propagate a more specific error code to users.

opentrons/protocol_engine/execution/movement.py

@@ -4,10 +4,9 @@ from __future__ import annotations
 import logging
 from typing import Optional, List, Union
 
-from opentrons.types import Point, MountType, StagingSlotName
+from opentrons.types import Point, MountType
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons_shared_data.errors.exceptions import PositionUnknownError
-from opentrons.protocol_engine.errors import LocationIsStagingSlotError
 
 from ..types import (
     WellLocation,
@@ -94,13 +93,9 @@ class MovementHandler:
             self._state_store.modules.get_heater_shaker_movement_restrictors()
         )
 
-        ancestor = self._state_store.geometry.get_ancestor_slot_name(labware_id)
-        if isinstance(ancestor, StagingSlotName):
-            raise LocationIsStagingSlotError(
-                "Cannot move to well on labware in Staging Area Slot."
-            )
-
-        dest_slot_int = ancestor.as_int()
+        dest_slot_int = self._state_store.geometry.get_ancestor_slot_name(
+            labware_id
+        ).as_int()
 
         self._hs_movement_flagger.raise_if_movement_restricted(
             hs_movement_restrictors=hs_movement_restrictors,

opentrons/protocol_engine/protocol_engine.py

@@ -59,6 +59,7 @@ from .actions import (
     HardwareStoppedAction,
     ResetTipsAction,
     SetPipetteMovementSpeedAction,
+    AddAbsorbanceReaderLidAction,
 )
 
 
@@ -576,6 +577,12 @@ class ProtocolEngine:
             AddAddressableAreaAction(addressable_area=area)
         )
 
+    def add_absorbance_reader_lid(self, module_id: str, lid_id: str) -> None:
+        """Add an absorbance reader lid to the module state."""
+        self._action_dispatcher.dispatch(
+            AddAbsorbanceReaderLidAction(module_id=module_id, lid_id=lid_id)
+        )
+
     def reset_tips(self, labware_id: str) -> None:
         """Reset the tip state of a given labware."""
         # TODO(mm, 2023-03-10): Safely raise an error if the given labware isn't a

opentrons/protocol_engine/resources/deck_data_provider.py

@@ -17,9 +17,11 @@ from ..types import (
     DeckSlotLocation,
     DeckType,
     LabwareLocation,
+    AddressableAreaLocation,
     DeckConfigurationType,
 )
 from .labware_data_provider import LabwareDataProvider
+from ..resources import deck_configuration_provider
 
 
 @final
@@ -69,6 +71,43 @@ class DeckDataProvider:
             slot = cast(Optional[str], fixture.get("slot"))
 
             if (
+                deck_configuration is not None
+                and load_name is not None
+                and slot is not None
+                and slot not in DeckSlotName._value2member_map_
+            ):
+                # The provided slot is likely to be an addressable area for Module-required labware Eg: Plate Reader Lid
+                for (
+                    cutout_id,
+                    cutout_fixture_id,
+                    opentrons_module_serial_number,
+                ) in deck_configuration:
+                    provided_addressable_areas = (
+                        deck_configuration_provider.get_provided_addressable_area_names(
+                            cutout_fixture_id=cutout_fixture_id,
+                            cutout_id=cutout_id,
+                            deck_definition=deck_definition,
+                        )
+                    )
+                    if slot in provided_addressable_areas:
+                        addressable_area_location = AddressableAreaLocation(
+                            addressableAreaName=slot
+                        )
+                        definition = await self._labware_data.get_labware_definition(
+                            load_name=load_name,
+                            namespace="opentrons",
+                            version=1,
+                        )
+
+                        labware.append(
+                            DeckFixedLabware(
+                                labware_id=labware_id,
+                                definition=definition,
+                                location=addressable_area_location,
+                            )
+                        )
+
+            elif (
                 load_fixed_trash
                 and load_name is not None
                 and slot is not None

opentrons/protocol_engine/resources/file_provider.py

@@ -66,7 +66,7 @@ class PlateReaderData(BaseModel):
                 row.append(str(measurement.data[f"{plate_alpharows[i]}{j+1}"]))
             rows.append(row)
         for i in range(3):
-            rows.append([])
+            rows.append([""])
         rows.append(["", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"])
         for i in range(8):
             row = [plate_alpharows[i]]
@@ -74,7 +74,7 @@ class PlateReaderData(BaseModel):
                 row.append("")
             rows.append(row)
         for i in range(3):
-            rows.append([])
+            rows.append([""])
         rows.append(
             [
                 "",
@@ -86,7 +86,7 @@ class PlateReaderData(BaseModel):
             ]
         )
         for i in range(3):
-            rows.append([])
+            rows.append([""])
         rows.append(
             [
                 "",
@@ -100,7 +100,7 @@ class PlateReaderData(BaseModel):
         )
         rows.append(["1", "Sample 1", "", "", "", "1", "", "", "", "", "", ""])
         for i in range(3):
-            rows.append([])
+            rows.append([""])
 
         # end of file metadata
         rows.append(["Protocol"])
@@ -109,17 +109,13 @@ class PlateReaderData(BaseModel):
         if self.reference_wavelength is not None:
             rows.append(["Reference Wavelength (nm)", str(self.reference_wavelength)])
         rows.append(["Serial No.", self.serial_number])
-        rows.append(
-            ["Measurement started at", self.start_time.strftime("%m %d %H:%M:%S %Y")]
-        )
-        rows.append(
-            ["Measurement finished at", self.finish_time.strftime("%m %d %H:%M:%S %Y")]
-        )
+        rows.append(["Measurement started at", str(self.start_time)])
+        rows.append(["Measurement finished at", str(self.finish_time)])
 
         # Ensure the filename adheres to ruleset contains the wavelength for a given measurement
         if filename.endswith(".csv"):
             filename = filename[:-4]
-        filename = filename + str(measurement.wavelength) + "nm.csv"
+        filename = filename + "_" + str(measurement.wavelength) + ".csv"
 
         return GenericCsvTransform.build(
             filename=filename,

opentrons/protocol_engine/resources/fixture_validation.py

@@ -29,12 +29,7 @@ def is_drop_tip_waste_chute(addressable_area_name: str) -> bool:
 
 def is_trash(addressable_area_name: str) -> bool:
     """Check if an addressable area is a trash bin."""
-    return any(
-        [
-            s in addressable_area_name
-            for s in {"movableTrash", "fixedTrash", "shortFixedTrash"}
-        ]
-    )
+    return addressable_area_name in {"movableTrash", "fixedTrash", "shortFixedTrash"}
 
 
 def is_staging_slot(addressable_area_name: str) -> bool: