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

opentrons/protocol_engine/state/labware.py

@@ -13,6 +13,7 @@ from typing import (
     NamedTuple,
     cast,
     Union,
+    overload,
 )
 
 from opentrons.protocol_engine.state import update_types
@@ -81,6 +82,10 @@ _RIGHT_SIDE_SLOTS = {
 }
 
 
+# The max height of the labware that can fit in a plate reader
+_PLATE_READER_MAX_LABWARE_Z_MM = 16
+
+
 class LabwareLoadParams(NamedTuple):
     """Parameters required to load a labware in Protocol Engine."""
 
@@ -227,10 +232,11 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
             if labware_location_update.new_location:
                 new_location = labware_location_update.new_location
 
-                if isinstance(
-                    new_location, AddressableAreaLocation
-                ) and fixture_validation.is_gripper_waste_chute(
-                    new_location.addressableAreaName
+                if isinstance(new_location, AddressableAreaLocation) and (
+                    fixture_validation.is_gripper_waste_chute(
+                        new_location.addressableAreaName
+                    )
+                    or fixture_validation.is_trash(new_location.addressableAreaName)
                 ):
                     # If a labware has been moved into a waste chute it's been chuted away and is now technically off deck
                     new_location = OFF_DECK_LOCATION
@@ -625,10 +631,26 @@ class LabwareView(HasState[LabwareState]):
         definition = self.get_definition(labware_id)
         return definition.parameters.loadName
 
-    def get_dimensions(self, labware_id: str) -> Dimensions:
+    @overload
+    def get_dimensions(self, *, labware_definition: LabwareDefinition) -> Dimensions:
+        pass
+
+    @overload
+    def get_dimensions(self, *, labware_id: str) -> Dimensions:
+        pass
+
+    def get_dimensions(
+        self,
+        *,
+        labware_definition: LabwareDefinition | None = None,
+        labware_id: str | None = None,
+    ) -> Dimensions:
         """Get the labware's dimensions."""
-        definition = self.get_definition(labware_id)
-        dims = definition.dimensions
+        if labware_definition is None:
+            assert labware_id is not None  # From our @overloads.
+            labware_definition = self.get_definition(labware_id)
+
+        dims = labware_definition.dimensions
 
         return Dimensions(
             x=dims.xDimension,
@@ -637,10 +659,9 @@ class LabwareView(HasState[LabwareState]):
         )
 
     def get_labware_overlap_offsets(
-        self, labware_id: str, below_labware_name: str
+        self, definition: LabwareDefinition, below_labware_name: str
     ) -> OverlapOffset:
         """Get the labware's overlap with requested labware's load name."""
-        definition = self.get_definition(labware_id)
         if below_labware_name in definition.stackingOffsetWithLabware.keys():
             stacking_overlap = definition.stackingOffsetWithLabware.get(
                 below_labware_name, OverlapOffset(x=0, y=0, z=0)
@@ -654,10 +675,9 @@ class LabwareView(HasState[LabwareState]):
         )
 
     def get_module_overlap_offsets(
-        self, labware_id: str, module_model: ModuleModel
+        self, definition: LabwareDefinition, module_model: ModuleModel
     ) -> OverlapOffset:
         """Get the labware's overlap with requested module model."""
-        definition = self.get_definition(labware_id)
         stacking_overlap = definition.stackingOffsetWithModule.get(
             str(module_model.value)
         )
@@ -817,6 +837,24 @@ class LabwareView(HasState[LabwareState]):
                     f"Labware {labware.loadName} is already present at {location}."
                 )
 
+    def raise_if_labware_incompatible_with_plate_reader(
+        self,
+        labware_definition: LabwareDefinition,
+    ) -> None:
+        """Raise an error if the labware is not compatible with the plate reader."""
+        load_name = labware_definition.parameters.loadName
+        number_of_wells = len(labware_definition.wells)
+        if number_of_wells != 96:
+            raise errors.LabwareMovementNotAllowedError(
+                f"Cannot move '{load_name}' into plate reader because the"
+                f" labware contains {number_of_wells} wells where 96 wells is expected."
+            )
+        elif labware_definition.dimensions.zDimension > _PLATE_READER_MAX_LABWARE_Z_MM:
+            raise errors.LabwareMovementNotAllowedError(
+                f"Cannot move '{load_name}' into plate reader because the"
+                f" maximum allowed labware height is {_PLATE_READER_MAX_LABWARE_Z_MM}mm."
+            )
+
     def raise_if_labware_cannot_be_stacked(  # noqa: C901
         self, top_labware_definition: LabwareDefinition, bottom_labware_id: str
     ) -> None:
@@ -900,22 +938,60 @@ class LabwareView(HasState[LabwareState]):
             else None
         )
 
-    def get_labware_gripper_offsets(
+    def get_absorbance_reader_lid_definition(self) -> LabwareDefinition:
+        """Return the special labware definition for the plate reader lid.
+
+        See todo comments in `create_protocol_engine().
+        """
+        # NOTE: This needs to stay in sync with create_protocol_engine().
+        return self._state.definitions_by_uri[
+            "opentrons/opentrons_flex_lid_absorbance_plate_reader_module/1"
+        ]
+
+    @overload
+    def get_child_gripper_offsets(
         self,
-        labware_id: str,
+        *,
+        labware_definition: LabwareDefinition,
         slot_name: Optional[DeckSlotName],
     ) -> Optional[LabwareMovementOffsetData]:
-        """Get the labware's gripper offsets of the specified type.
+        pass
+
+    @overload
+    def get_child_gripper_offsets(
+        self, *, labware_id: str, slot_name: Optional[DeckSlotName]
+    ) -> Optional[LabwareMovementOffsetData]:
+        pass
+
+    def get_child_gripper_offsets(
+        self,
+        *,
+        labware_definition: Optional[LabwareDefinition] = None,
+        labware_id: Optional[str] = None,
+        slot_name: Optional[DeckSlotName],
+    ) -> Optional[LabwareMovementOffsetData]:
+        """Get the grip offsets that a labware says should be applied to children stacked atop it.
+
+        Params:
+            labware_id: The ID of a parent labware (atop which another labware, the child, will be stacked).
+            slot_name: The ancestor slot that the parent labware is ultimately loaded into,
+                       perhaps after going through a module in the middle.
 
         Returns:
-            If `slot_name` is provided, returns the gripper offsets that the labware definition
+            If `slot_name` is provided, returns the gripper offsets that the parent labware definition
             specifies just for that slot, or `None` if the labware definition doesn't have an
             exact match.
 
-            If `slot_name` is `None`, returns the gripper offsets that the labware
+            If `slot_name` is `None`, returns the gripper offsets that the parent labware
             definition designates as "default," or `None` if it doesn't designate any as such.
         """
-        parsed_offsets = self.get_definition(labware_id).gripperOffsets
+        if labware_id is not None:
+            labware_definition = self.get_definition(labware_id)
+        else:
+            # Should be ensured by our @overloads.
+            assert labware_definition is not None
+
+        parsed_offsets = labware_definition.gripperOffsets
         offset_key = slot_name.id if slot_name else "default"
 
         if parsed_offsets is None or offset_key not in parsed_offsets:
@@ -930,20 +1006,22 @@ class LabwareView(HasState[LabwareState]):
                 ),
             )
 
-    def get_grip_force(self, labware_id: str) -> float:
+    def get_grip_force(self, labware_definition: LabwareDefinition) -> float:
         """Get the recommended grip force for gripping labware using gripper."""
-        recommended_force = self.get_definition(labware_id).gripForce
+        recommended_force = labware_definition.gripForce
         return (
             recommended_force if recommended_force is not None else LABWARE_GRIP_FORCE
         )
 
-    def get_grip_height_from_labware_bottom(self, labware_id: str) -> float:
+    def get_grip_height_from_labware_bottom(
+        self, labware_definition: LabwareDefinition
+    ) -> float:
         """Get the recommended grip height from labware bottom, if present."""
-        recommended_height = self.get_definition(labware_id).gripHeightFromLabwareBottom
+        recommended_height = labware_definition.gripHeightFromLabwareBottom
         return (
             recommended_height
             if recommended_height is not None
-            else self.get_dimensions(labware_id).z / 2
+            else self.get_dimensions(labware_definition=labware_definition).z / 2
         )
 
     @staticmethod
@@ -986,7 +1064,7 @@ class LabwareView(HasState[LabwareState]):
     def _max_z_of_well(well_defn: WellDefinition) -> float:
         return well_defn.z + well_defn.depth
 
-    def get_well_bbox(self, labware_id: str) -> Dimensions:
+    def get_well_bbox(self, labware_definition: LabwareDefinition) -> Dimensions:
         """Get the bounding box implied by the wells.
 
         The bounding box of the labware that is implied by the wells is that required
@@ -997,14 +1075,13 @@ class LabwareView(HasState[LabwareState]):
         This is used for the specific purpose of finding the reasonable uncertainty bounds of
         where and how a gripper will interact with a labware.
         """
-        defn = self.get_definition(labware_id)
         max_x: Optional[float] = None
         min_x: Optional[float] = None
         max_y: Optional[float] = None
         min_y: Optional[float] = None
         max_z: Optional[float] = None
 
-        for well in defn.wells.values():
+        for well in labware_definition.wells.values():
             well_max_x = self._max_x_of_well(well)
             well_min_x = self._min_x_of_well(well)
             well_max_y = self._max_y_of_well(well)

opentrons/protocol_engine/state/module_substates/absorbance_reader_substate.py

@@ -9,6 +9,9 @@ AbsorbanceReaderLidId = NewType("AbsorbanceReaderLidId", str)
 AbsorbanceReaderMeasureMode = NewType("AbsorbanceReaderMeasureMode", str)
 
 
+# todo(mm, 2024-11-08): frozen=True is getting pretty painful because ModuleStore has
+# no type-safe way to modify just a single attribute. Consider unfreezing this
+# (taking care to ensure that consumers of ModuleView still only get a read-only view).
 @dataclass(frozen=True)
 class AbsorbanceReaderSubState:
     """Absorbance-Plate-Reader-specific state."""
@@ -21,7 +24,6 @@ class AbsorbanceReaderSubState:
     configured_wavelengths: Optional[List[int]]
     measure_mode: Optional[AbsorbanceReaderMeasureMode]
     reference_wavelength: Optional[int]
-    lid_id: Optional[str]
 
     def raise_if_lid_status_not_expected(self, lid_on_expected: bool) -> None:
         """Raise if the lid status is not correct."""

opentrons/protocol_engine/state/modules.py

@@ -26,13 +26,15 @@ from opentrons.motion_planning.adjacent_slots_getters import (
     get_west_slot,
     get_adjacent_staging_slot,
 )
+from opentrons.protocol_engine.actions.get_state_update import get_state_updates
 from opentrons.protocol_engine.commands.calibration.calibrate_module import (
     CalibrateModuleResult,
 )
+from opentrons.protocol_engine.state import update_types
 from opentrons.protocol_engine.state.module_substates.absorbance_reader_substate import (
     AbsorbanceReaderMeasureMode,
 )
-from opentrons.types import DeckSlotName, MountType
+from opentrons.types import DeckSlotName, MountType, StagingSlotName
 from ..errors import ModuleNotConnectedError
 
 from ..types import (
@@ -67,7 +69,6 @@ from ..actions import (
     Action,
     SucceedCommandAction,
     AddModuleAction,
-    AddAbsorbanceReaderLidAction,
 )
 from ._abstract_store import HasState, HandlesActions
 from .module_substates import (
@@ -234,13 +235,14 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 requested_model=None,
                 module_live_data=action.module_live_data,
             )
-        elif isinstance(action, AddAbsorbanceReaderLidAction):
-            self._update_absorbance_reader_lid_id(
-                module_id=action.module_id,
-                lid_id=action.lid_id,
-            )
+
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
 
     def _handle_command(self, command: Command) -> None:
+        # todo(mm, 2024-11-04): Delete this function. Port these isinstance()
+        # checks to the update_types.StateUpdate mechanism.
+
         if isinstance(command.result, LoadModuleResult):
             slot_name = command.params.location.slotName
             self._add_module_substate(
@@ -297,38 +299,40 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         if isinstance(
             command.result,
             (
-                absorbance_reader.CloseLidResult,
-                absorbance_reader.OpenLidResult,
                 absorbance_reader.InitializeResult,
                 absorbance_reader.ReadAbsorbanceResult,
             ),
         ):
             self._handle_absorbance_reader_commands(command)
 
-    def _update_absorbance_reader_lid_id(
-        self,
-        module_id: str,
-        lid_id: str,
-    ) -> None:
-        abs_substate = self._state.substate_by_module_id.get(module_id)
-        assert isinstance(
-            abs_substate, AbsorbanceReaderSubState
-        ), f"{module_id} is not an absorbance plate reader."
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.absorbance_reader_lid != update_types.NO_CHANGE:
+            module_id = state_update.absorbance_reader_lid.module_id
+            is_lid_on = state_update.absorbance_reader_lid.is_lid_on
+
+            # Get current values:
+            absorbance_reader_substate = self._state.substate_by_module_id[module_id]
+            assert isinstance(
+                absorbance_reader_substate, AbsorbanceReaderSubState
+            ), f"{module_id} is not an absorbance plate reader."
+            configured = absorbance_reader_substate.configured
+            measure_mode = absorbance_reader_substate.measure_mode
+            configured_wavelengths = absorbance_reader_substate.configured_wavelengths
+            reference_wavelength = absorbance_reader_substate.reference_wavelength
+            data = absorbance_reader_substate.data
 
-        prev_state: AbsorbanceReaderSubState = abs_substate
-        self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-            module_id=AbsorbanceReaderId(module_id),
-            configured=prev_state.configured,
-            measured=prev_state.measured,
-            is_lid_on=prev_state.is_lid_on,
-            data=prev_state.data,
-            measure_mode=prev_state.measure_mode,
-            configured_wavelengths=prev_state.configured_wavelengths,
-            reference_wavelength=prev_state.reference_wavelength,
-            lid_id=lid_id,
-        )
+            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
+                module_id=AbsorbanceReaderId(module_id),
+                configured=configured,
+                measured=True,
+                is_lid_on=is_lid_on,
+                measure_mode=measure_mode,
+                configured_wavelengths=configured_wavelengths,
+                reference_wavelength=reference_wavelength,
+                data=data,
+            )
 
-    def _add_module_substate(  # noqa: C901
+    def _add_module_substate(
         self,
         module_id: str,
         serial_number: Optional[str],
@@ -387,16 +391,6 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 module_id=MagneticBlockId(module_id)
             )
         elif ModuleModel.is_absorbance_reader(actual_model):
-            lid_labware_id = None
-            slot = self._state.slot_by_module_id[module_id]
-            if slot is not None:
-                reader_addressable_area = f"absorbanceReaderV1{slot.value}"
-                for labware in self._state.deck_fixed_labware:
-                    if labware.location == AddressableAreaLocation(
-                        addressableAreaName=reader_addressable_area
-                    ):
-                        lid_labware_id = labware.labware_id
-                        break
             self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
                 module_id=AbsorbanceReaderId(module_id),
                 configured=False,
@@ -406,7 +400,6 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 measure_mode=None,
                 configured_wavelengths=None,
                 reference_wavelength=None,
-                lid_id=lid_labware_id,
             )
 
     def _update_additional_slots_occupied_by_thermocycler(
@@ -600,8 +593,6 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         command: Union[
             absorbance_reader.Initialize,
             absorbance_reader.ReadAbsorbance,
-            absorbance_reader.CloseLid,
-            absorbance_reader.OpenLid,
         ],
     ) -> None:
         module_id = command.params.moduleId
@@ -616,8 +607,6 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         configured_wavelengths = absorbance_reader_substate.configured_wavelengths
         reference_wavelength = absorbance_reader_substate.reference_wavelength
         is_lid_on = absorbance_reader_substate.is_lid_on
-        lid_id = absorbance_reader_substate.lid_id
-        data = absorbance_reader_substate.data
 
         if isinstance(command.result, absorbance_reader.InitializeResult):
             self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
@@ -625,7 +614,6 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 configured=True,
                 measured=False,
                 is_lid_on=is_lid_on,
-                lid_id=lid_id,
                 measure_mode=AbsorbanceReaderMeasureMode(command.params.measureMode),
                 configured_wavelengths=command.params.sampleWavelengths,
                 reference_wavelength=command.params.referenceWavelength,
@@ -637,39 +625,12 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 configured=configured,
                 measured=True,
                 is_lid_on=is_lid_on,
-                lid_id=lid_id,
                 measure_mode=measure_mode,
                 configured_wavelengths=configured_wavelengths,
                 reference_wavelength=reference_wavelength,
                 data=command.result.data,
             )
 
-        elif isinstance(command.result, absorbance_reader.OpenLidResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=False,
-                lid_id=lid_id,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=data,
-            )
-
-        elif isinstance(command.result, absorbance_reader.CloseLidResult):
-            self._state.substate_by_module_id[module_id] = AbsorbanceReaderSubState(
-                module_id=AbsorbanceReaderId(module_id),
-                configured=configured,
-                measured=True,
-                is_lid_on=True,
-                lid_id=lid_id,
-                measure_mode=measure_mode,
-                configured_wavelengths=configured_wavelengths,
-                reference_wavelength=reference_wavelength,
-                data=data,
-            )
-
 
 class ModuleView(HasState[ModuleState]):
     """Read-only view of computed module state."""
@@ -883,12 +844,21 @@ class ModuleView(HasState[ModuleState]):
         """Get the specified module's dimensions."""
         return self.get_definition(module_id).dimensions
 
-    def get_nominal_module_offset(
+    def get_nominal_offset_to_child(
         self,
         module_id: str,
+        # todo(mm, 2024-11-07): A method of one view taking a sibling view as an argument
+        # is unusual, and may be bug-prone if the order in which the views are updated
+        # matters. If we need to compute something that depends on module info and
+        # addressable area info, can we do that computation in GeometryView instead of
+        # here?
         addressable_areas: AddressableAreaView,
     ) -> LabwareOffsetVector:
-        """Get the module's nominal offset vector computed with slot transform."""
+        """Get the nominal offset from a module's location to its child labware's location.
+
+        Includes the slot-specific transform. Does not include the child's
+        Labware Position Check offset.
+        """
         if (
             self.state.deck_type == DeckType.OT2_STANDARD
             or self.state.deck_type == DeckType.OT2_SHORT_TRASH
@@ -996,7 +966,7 @@ class ModuleView(HasState[ModuleState]):
         default_lw_offset_point = self.get_definition(module_id).labwareOffset.z
         z_difference = module_height - default_lw_offset_point
 
-        nominal_transformed_lw_offset_z = self.get_nominal_module_offset(
+        nominal_transformed_lw_offset_z = self.get_nominal_offset_to_child(
             module_id=module_id, addressable_areas=addressable_areas
         ).z
         calibration_offset = self.get_module_calibration_offset(module_id)
@@ -1124,8 +1094,8 @@ class ModuleView(HasState[ModuleState]):
 
     def should_dodge_thermocycler(
         self,
-        from_slot: DeckSlotName,
-        to_slot: DeckSlotName,
+        from_slot: Union[DeckSlotName, StagingSlotName],
+        to_slot: Union[DeckSlotName, StagingSlotName],
     ) -> bool:
         """Decide if the requested path would cross the thermocycler, if installed.
 

opentrons/protocol_engine/state/motion.py

@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 from typing import List, Optional, Union
 
-from opentrons.types import MountType, Point
+from opentrons.types import MountType, Point, StagingSlotName
 from opentrons.hardware_control.types import CriticalPoint
 from opentrons.motion_planning.adjacent_slots_getters import (
     get_east_west_slots,
@@ -277,9 +277,13 @@ class MotionView:
         current_location = self._pipettes.get_current_location()
         if current_location is not None:
             if isinstance(current_location, CurrentWell):
-                pipette_deck_slot = self._geometry.get_ancestor_slot_name(
+                ancestor = self._geometry.get_ancestor_slot_name(
                     current_location.labware_id
-                ).as_int()
+                )
+                if isinstance(ancestor, StagingSlotName):
+                    # Staging Area Slots cannot intersect with the h/s
+                    return False
+                pipette_deck_slot = ancestor.as_int()
             else:
                 pipette_deck_slot = (
                     self._addressable_areas.get_addressable_area_base_slot(
@@ -299,9 +303,13 @@ class MotionView:
         current_location = self._pipettes.get_current_location()
         if current_location is not None:
             if isinstance(current_location, CurrentWell):
-                pipette_deck_slot = self._geometry.get_ancestor_slot_name(
+                ancestor = self._geometry.get_ancestor_slot_name(
                     current_location.labware_id
-                ).as_int()
+                )
+                if isinstance(ancestor, StagingSlotName):
+                    # Staging Area Slots cannot intersect with the h/s
+                    return False
+                pipette_deck_slot = ancestor.as_int()
             else:
                 pipette_deck_slot = (
                     self._addressable_areas.get_addressable_area_base_slot(
@@ -324,6 +332,10 @@ class MotionView:
         """Get a list of touch points for a touch tip operation."""
         mount = self._pipettes.get_mount(pipette_id)
         labware_slot = self._geometry.get_ancestor_slot_name(labware_id)
+        if isinstance(labware_slot, StagingSlotName):
+            raise errors.LocationIsStagingSlotError(
+                "Cannot perform Touch Tip on labware in Staging Area Slot."
+            )
         next_to_module = self._modules.is_edge_move_unsafe(mount, labware_slot)
         edge_path_type = self._labware.get_edge_path_type(
             labware_id, well_name, mount, labware_slot, next_to_module

opentrons/protocol_engine/state/update_types.py

@@ -205,6 +205,14 @@ class LiquidOperatedUpdate:
     volume_added: float | ClearType
 
 
+@dataclasses.dataclass
+class AbsorbanceReaderLidUpdate:
+    """An update to an absorbance reader's lid location."""
+
+    module_id: str
+    is_lid_on: bool
+
+
 @dataclasses.dataclass
 class StateUpdate:
     """Represents an update to perform on engine state."""
@@ -231,6 +239,8 @@ class StateUpdate:
 
     liquid_operated: LiquidOperatedUpdate | NoChangeType = NO_CHANGE
 
+    absorbance_reader_lid: AbsorbanceReaderLidUpdate | NoChangeType = NO_CHANGE
+
     # These convenience functions let the caller avoid the boilerplate of constructing a
     # complicated dataclass tree.
 
@@ -406,3 +416,9 @@ class StateUpdate:
             well_name=well_name,
             volume_added=volume_added,
         )
+
+    def set_absorbance_reader_lid(self, module_id: str, is_lid_on: bool) -> None:
+        """Update an absorbance reader's lid location. See `AbsorbanceReaderLidUpdate`."""
+        self.absorbance_reader_lid = AbsorbanceReaderLidUpdate(
+            module_id=module_id, is_lid_on=is_lid_on
+        )

opentrons/util/logging_config.py

@@ -5,7 +5,7 @@ from typing import Any, Dict
 
 from opentrons.config import CONFIG, ARCHITECTURE, SystemArchitecture
 
-if ARCHITECTURE is SystemArchitecture.BUILDROOT:
+if ARCHITECTURE is SystemArchitecture.YOCTO:
     from opentrons_hardware.sensors import SENSOR_LOG_NAME
 else:
     # we don't use the sensor log on ot2 or host

{opentrons-8.2.0a0.dist-info → opentrons-8.2.0a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentrons
-Version: 8.2.0a0
+Version: 8.2.0a2
 Summary: The Opentrons API is a simple framework designed to make writing automated biology lab protocols easy.
 Author: Opentrons
 Author-email: engineering@opentrons.com
@@ -21,7 +21,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 License-File: ../LICENSE
-Requires-Dist: opentrons-shared-data ==8.2.0a0
+Requires-Dist: opentrons-shared-data ==8.2.0a2
 Requires-Dist: aionotify ==0.3.1
 Requires-Dist: anyio <4.0.0,>=3.6.1
 Requires-Dist: jsonschema <4.18.0,>=3.0.1
@@ -34,9 +34,9 @@ Requires-Dist: pyusb ==1.2.1
 Requires-Dist: packaging >=21.0
 Requires-Dist: importlib-metadata >=1.0 ; python_version < "3.8"
 Provides-Extra: flex-hardware
-Requires-Dist: opentrons-hardware[flex] ==8.2.0a0 ; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex] ==8.2.0a2 ; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware ==8.2.0a0 ; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware ==8.2.0a2 ; extra == 'ot2-hardware'
 
 .. _Full API Documentation: http://docs.opentrons.com