opentrons 8.4.0a2__py2.py3-none-any.whl → 8.4.0a4__py2.py3-none-any.whl

opentrons/protocol_engine/state/geometry.py

@@ -31,6 +31,7 @@ from ..errors import (
     LabwareMovementNotAllowedError,
     OperationLocationNotInWellError,
 )
+from ..errors.exceptions import InvalidLiquidHeightFound
 from ..resources import (
     fixture_validation,
     labware_validation,
@@ -79,6 +80,8 @@ from ..types import (
     AreaType,
     labware_location_is_off_deck,
     labware_location_is_system,
+    WellLocationType,
+    WellLocationFunction,
 )
 from ..types.liquid_level_detection import SimulatedProbeResult, LiquidTrackingType
 from .config import Config
@@ -310,7 +313,6 @@ class GeometryView:
             child_definition=self._labware.get_definition(labware_id),
             parent=self._labware.get(labware_id).location,
         )
-
         return Point(
             parent_pos.x + offset_from_parent.x,
             parent_pos.y + offset_from_parent.y,
@@ -455,20 +457,15 @@ class GeometryView:
         """Get the calibrated origin of the labware."""
         origin_pos = self.get_labware_origin_position(labware_id)
         cal_offset = self._labware.get_labware_offset_vector(labware_id)
-
         return Point(
             x=origin_pos.x + cal_offset.x,
             y=origin_pos.y + cal_offset.y,
             z=origin_pos.z + cal_offset.z,
         )
 
-    WellLocations = Union[
-        WellLocation, LiquidHandlingWellLocation, PickUpTipWellLocation
-    ]
-
     def validate_well_position(
         self,
-        well_location: WellLocations,
+        well_location: WellLocationType,
         z_offset: float,
         pipette_id: Optional[str] = None,
     ) -> None:
@@ -477,34 +474,34 @@ class GeometryView:
         Primarily this checks if there is not enough liquid in a well to do meniscus-relative static aspiration.
         """
         if well_location.origin == WellOrigin.MENISCUS:
-            assert pipette_id is not None
+            assert pipette_id is not None, "pipette id is None"
             lld_min_height = self._pipettes.get_current_tip_lld_settings(
                 pipette_id=pipette_id
             )
             if z_offset < lld_min_height:
-                if isinstance(well_location, PickUpTipWellLocation):
+                if isinstance(well_location, LiquidHandlingWellLocation):
                     raise OperationLocationNotInWellError(
-                        f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location that could be below the bottom of the well"
+                        f"Specifying {well_location.origin} with a height offset of {well_location.offset.z} results in a height of {z_offset} mm; the minimum allowed height for liquid tracking is {lld_min_height} mm"
                     )
                 else:
                     raise OperationLocationNotInWellError(
-                        f"Specifying {well_location.origin} with an offset of {well_location.offset} and a volume offset of {well_location.volumeOffset} results in an operation location that could be below the bottom of the well"
+                        f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location that could be below the bottom of the well"
                     )
         elif z_offset < 0:
-            if isinstance(well_location, PickUpTipWellLocation):
+            if isinstance(well_location, LiquidHandlingWellLocation):
                 raise OperationLocationNotInWellError(
-                    f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location below the bottom of the well"
+                    f"Specifying {well_location.origin} with an offset of {well_location.offset} and a volume offset of {well_location.volumeOffset} results in an operation location below the bottom of the well"
                 )
             else:
                 raise OperationLocationNotInWellError(
-                    f"Specifying {well_location.origin} with an offset of {well_location.offset} and a volume offset of {well_location.volumeOffset} results in an operation location below the bottom of the well"
+                    f"Specifying {well_location.origin} with an offset of {well_location.offset} results in an operation location below the bottom of the well"
                 )
 
     def get_well_position(
         self,
         labware_id: str,
         well_name: str,
-        well_location: Optional[WellLocations] = None,
+        well_location: Optional[WellLocationType] = None,
         operation_volume: Optional[float] = None,
         pipette_id: Optional[str] = None,
     ) -> Point:
@@ -530,7 +527,6 @@ class GeometryView:
                     z_offset=offset.z,
                     pipette_id=pipette_id,
                 )
-
         return Point(
             x=labware_pos.x + offset.x + well_def.x,
             y=labware_pos.y + offset.y + well_def.y,
@@ -552,25 +548,14 @@ class GeometryView:
             z=parent_pos.z + origin_offset.z + well_def.z + well_def.depth,
         )
 
-    def get_relative_well_location(
-        self,
-        labware_id: str,
-        well_name: str,
-        absolute_point: Point,
-    ) -> WellLocation:
-        """Given absolute position, get relative location of a well in a labware."""
-        well_absolute_point = self.get_well_position(labware_id, well_name)
-        delta = absolute_point - well_absolute_point
-
-        return WellLocation(offset=WellOffset(x=delta.x, y=delta.y, z=delta.z))
-
-    def get_relative_liquid_handling_well_location(
+    def _get_relative_liquid_handling_well_location(
         self,
         labware_id: str,
         well_name: str,
         absolute_point: Point,
+        delta: Point,
         meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
-    ) -> Tuple[LiquidHandlingWellLocation, bool]:
+    ) -> Tuple[WellLocationType, bool]:
         """Given absolute position, get relative location of a well in a labware."""
         dynamic_liquid_tracking = False
         if meniscus_tracking:
@@ -578,29 +563,50 @@ class GeometryView:
                 origin=WellOrigin.MENISCUS,
                 offset=WellOffset(x=0, y=0, z=absolute_point.z),
             )
+            # TODO(cm): handle operationVolume being a float other than 0
             if meniscus_tracking == MeniscusTrackingTarget.END:
                 location.volumeOffset = "operationVolume"
             elif meniscus_tracking == MeniscusTrackingTarget.DYNAMIC:
                 dynamic_liquid_tracking = True
         else:
-            well_absolute_point = self.get_well_position(labware_id, well_name)
-            delta = absolute_point - well_absolute_point
             location = LiquidHandlingWellLocation(
                 offset=WellOffset(x=delta.x, y=delta.y, z=delta.z)
             )
         return location, dynamic_liquid_tracking
 
-    def get_relative_pick_up_tip_well_location(
+    def get_relative_well_location(
         self,
         labware_id: str,
         well_name: str,
         absolute_point: Point,
-    ) -> PickUpTipWellLocation:
+        location_type: WellLocationFunction,
+        meniscus_tracking: Optional[MeniscusTrackingTarget] = None,
+    ) -> Tuple[WellLocationType, bool]:
         """Given absolute position, get relative location of a well in a labware."""
         well_absolute_point = self.get_well_position(labware_id, well_name)
         delta = absolute_point - well_absolute_point
-
-        return PickUpTipWellLocation(offset=WellOffset(x=delta.x, y=delta.y, z=delta.z))
+        match location_type:
+            case WellLocationFunction.BASE | WellLocationFunction.DROP_TIP:
+                return (
+                    WellLocation(offset=WellOffset(x=delta.x, y=delta.y, z=delta.z)),
+                    False,
+                )
+            case WellLocationFunction.PICK_UP_TIP:
+                return (
+                    PickUpTipWellLocation(
+                        offset=WellOffset(x=delta.x, y=delta.y, z=delta.z)
+                    ),
+                    False,
+                )
+            case WellLocationFunction.LIQUID_HANDLING:
+                return self._get_relative_liquid_handling_well_location(
+                    labware_id=labware_id,
+                    well_name=well_name,
+                    absolute_point=absolute_point,
+                    delta=delta,
+                    meniscus_tracking=meniscus_tracking,
+                )
+        return NotImplemented
 
     def get_well_height(
         self,
@@ -761,7 +767,6 @@ class GeometryView:
         """Get the slot name of the labware or the module that the labware is on."""
         labware = self._labware.get(labware_id)
         slot_name: Union[DeckSlotName, StagingSlotName]
-
         if isinstance(labware.location, DeckSlotLocation):
             slot_name = labware.location.slotName
         elif isinstance(labware.location, ModuleLocation):
@@ -1748,7 +1753,13 @@ class GeometryView:
         labware_location: LabwareLocation,
         labware_pending_load: dict[str, LoadedLabware] | None = None,
     ) -> Optional[LabwareOffsetLocationSequence]:
-        """Get the offset location that a labware loaded into this location would match."""
+        """Get the offset location that a labware loaded into this location would match.
+
+        `None` indicates that the very concept of a labware offset would not make sense
+        for the given location, such as if it's some kind of off-deck location. This
+        is a difference from `get_predicted_location_sequence()`, where off-deck
+        locations are still represented as lists, but with special final elements.
+        """
         return self._recurse_labware_offset_location(
             labware_location, [], labware_pending_load or {}
         )
@@ -1847,15 +1858,19 @@ class GeometryView:
         # this function is only called by
         # HardwarePipetteHandler::aspirate/dispense while_tracking, and shouldn't
         # be reached in the case of a simulated liquid_probe
-        assert not isinstance(initial_handling_height, SimulatedProbeResult)
-        assert not isinstance(final_height, SimulatedProbeResult)
+        assert not isinstance(
+            initial_handling_height, SimulatedProbeResult
+        ), "Initial handling height got SimulatedProbeResult"
+        assert not isinstance(
+            final_height, SimulatedProbeResult
+        ), "final height is SimulatedProbeResult"
         return final_height - initial_handling_height
 
     def get_well_offset_adjustment(
         self,
         labware_id: str,
         well_name: str,
-        well_location: WellLocations,
+        well_location: WellLocationType,
         well_depth: float,
         operation_volume: Optional[float] = None,
     ) -> LiquidTrackingType:
@@ -1878,12 +1893,16 @@ class GeometryView:
             and not well_location.volumeOffset
         ):
             return initial_handling_height
+        volume: Optional[float] = None
         if isinstance(well_location, PickUpTipWellLocation):
             volume = 0.0
-        elif isinstance(well_location.volumeOffset, float):
-            volume = well_location.volumeOffset
-        elif well_location.volumeOffset == "operationVolume":
-            volume = operation_volume or 0.0
+        elif isinstance(well_location, LiquidHandlingWellLocation):
+            if well_location.volumeOffset == "operationVolume":
+                volume = operation_volume or 0.0
+            else:
+                if not isinstance(well_location.volumeOffset, float):
+                    raise ValueError("Invalid volume offset.")
+                volume = well_location.volumeOffset
 
         if volume:
             liquid_height_after = self.get_well_height_after_liquid_handling(
@@ -1991,7 +2010,7 @@ class GeometryView:
         self,
         labware_id: str,
         well_name: str,
-        well_location: WellLocations,
+        well_location: WellLocationType,
         well_depth: float,
     ) -> LiquidTrackingType:
         """Return the handling height for a labware well (with reference to the well bottom)."""
@@ -2020,13 +2039,19 @@ class GeometryView:
         well_geometry = self._labware.get_well_geometry(
             labware_id=labware_id, well_name=well_name
         )
-        initial_volume = find_volume_at_well_height(
-            target_height=initial_height, well_geometry=well_geometry
-        )
-        final_volume = initial_volume + volume
-        return find_height_at_well_volume(
-            target_volume=final_volume, well_geometry=well_geometry
-        )
+        try:
+            initial_volume = find_volume_at_well_height(
+                target_height=initial_height, well_geometry=well_geometry
+            )
+            final_volume = initial_volume + volume
+            return find_height_at_well_volume(
+                target_volume=final_volume, well_geometry=well_geometry
+            )
+        except InvalidLiquidHeightFound as _exception:
+            raise InvalidLiquidHeightFound(
+                message=_exception.message
+                + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+            )
 
     def get_well_height_after_liquid_handling_no_error(
         self,
@@ -2043,25 +2068,37 @@ class GeometryView:
         well_geometry = self._labware.get_well_geometry(
             labware_id=labware_id, well_name=well_name
         )
-        initial_volume = find_volume_at_well_height(
-            target_height=initial_height, well_geometry=well_geometry
-        )
-        final_volume = initial_volume + volume
-        well_volume = find_height_at_well_volume(
-            target_volume=final_volume,
-            well_geometry=well_geometry,
-            raise_error_if_result_invalid=False,
-        )
-        return well_volume
+        try:
+            initial_volume = find_volume_at_well_height(
+                target_height=initial_height, well_geometry=well_geometry
+            )
+            final_volume = initial_volume + volume
+            well_volume = find_height_at_well_volume(
+                target_volume=final_volume,
+                well_geometry=well_geometry,
+                raise_error_if_result_invalid=False,
+            )
+            return well_volume
+        except InvalidLiquidHeightFound as _exception:
+            raise InvalidLiquidHeightFound(
+                message=_exception.message
+                + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+            )
 
     def get_well_height_at_volume(
         self, labware_id: str, well_name: str, volume: LiquidTrackingType
     ) -> LiquidTrackingType:
         """Convert well volume to height."""
         well_geometry = self._labware.get_well_geometry(labware_id, well_name)
-        return find_height_at_well_volume(
-            target_volume=volume, well_geometry=well_geometry
-        )
+        try:
+            return find_height_at_well_volume(
+                target_volume=volume, well_geometry=well_geometry
+            )
+        except InvalidLiquidHeightFound as _exception:
+            raise InvalidLiquidHeightFound(
+                message=_exception.message
+                + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+            )
 
     def get_well_volume_at_height(
         self,
@@ -2071,15 +2108,21 @@ class GeometryView:
     ) -> LiquidTrackingType:
         """Convert well height to volume."""
         well_geometry = self._labware.get_well_geometry(labware_id, well_name)
-        return find_volume_at_well_height(
-            target_height=height, well_geometry=well_geometry
-        )
+        try:
+            return find_volume_at_well_height(
+                target_height=height, well_geometry=well_geometry
+            )
+        except InvalidLiquidHeightFound as _exception:
+            raise InvalidLiquidHeightFound(
+                message=_exception.message
+                + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+            )
 
     def validate_dispense_volume_into_well(
         self,
         labware_id: str,
         well_name: str,
-        well_location: WellLocations,
+        well_location: WellLocationType,
         volume: float,
     ) -> None:
         """Raise InvalidDispenseVolumeError if planned dispense volume will overflow well."""
@@ -2091,9 +2134,15 @@ class GeometryView:
             meniscus_height = self.get_meniscus_height(
                 labware_id=labware_id, well_name=well_name
             )
-            meniscus_volume = find_volume_at_well_height(
-                target_height=meniscus_height, well_geometry=well_geometry
-            )
+            try:
+                meniscus_volume = find_volume_at_well_height(
+                    target_height=meniscus_height, well_geometry=well_geometry
+                )
+            except InvalidLiquidHeightFound as _exception:
+                raise InvalidLiquidHeightFound(
+                    message=_exception.message
+                    + f"for well {well_name} of {self._labware.get_display_name(labware_id)} on slot {self.get_ancestor_slot_name(labware_id)}"
+                )
             # if meniscus volume is a simulated value, comparisons aren't meaningful
             if isinstance(meniscus_volume, SimulatedProbeResult):
                 return

opentrons/protocol_engine/state/update_types.py

@@ -18,8 +18,8 @@ from opentrons.protocol_engine.types import (
     AspiratedFluid,
     LiquidClassRecord,
     ABSMeasureMode,
+    LiquidTrackingType,
 )
-from opentrons.protocol_engine.types.liquid_level_detection import LiquidTrackingType
 from opentrons.types import MountType
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.pipette.types import PipetteNameType

opentrons/protocol_engine/state/wells.py

@@ -116,7 +116,7 @@ class WellStore(HasState[WellState], HandlesActions):
                 del self._state.loaded_volumes[labware_id][well_name]
             else:
                 prev_loaded_vol_info = self._state.loaded_volumes[labware_id][well_name]
-                assert prev_loaded_vol_info.volume is not None
+                assert prev_loaded_vol_info.volume is not None, "volume info not loaded"
                 self._state.loaded_volumes[labware_id][well_name] = LoadedVolumeInfo(
                     volume=prev_loaded_vol_info.volume + volume_added,
                     last_loaded=prev_loaded_vol_info.last_loaded,

opentrons/protocol_engine/types/__init__.py

@@ -117,6 +117,8 @@ from .well_position import (
     LiquidHandlingWellLocation,
     PickUpTipWellLocation,
     DropTipWellLocation,
+    WellLocationType,
+    WellLocationFunction,
 )
 from .instrument import (
     LoadedPipette,
@@ -132,6 +134,7 @@ from .liquid_level_detection import (
     ProbedVolumeInfo,
     WellInfoSummary,
     WellLiquidInfo,
+    LiquidTrackingType,
 )
 from .liquid_handling import FlowRates
 from .labware_movement import LabwareMovementStrategy, LabwareMovementOffsetData
@@ -259,6 +262,8 @@ __all__ = [
     "LiquidHandlingWellLocation",
     "PickUpTipWellLocation",
     "DropTipWellLocation",
+    "WellLocationType",
+    "WellLocationFunction",
     # Execution
     "EngineStatus",
     "PostRunHardwareState",
@@ -274,6 +279,7 @@ __all__ = [
     "ProbedVolumeInfo",
     "WellInfoSummary",
     "WellLiquidInfo",
+    "LiquidTrackingType",
     # Liquid handling
     "FlowRates",
     # Labware movement

opentrons/protocol_engine/types/location.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 from typing import Literal, Union, TypeGuard
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.types import DeckSlotName, StagingSlotName
 
@@ -107,7 +108,7 @@ class OnLabwareLocationSequenceComponent(BaseModel):
 
     kind: Literal["onLabware"] = "onLabware"
     labwareId: str
-    lidId: str | None
+    lidId: str | SkipJsonSchema[None] = Field(None)
 
 
 class OnModuleLocationSequenceComponent(BaseModel):

opentrons/protocol_engine/types/well_position.py

@@ -1,5 +1,5 @@
 """Protocol engine types to do with positions inside wells."""
-from enum import Enum
+from enum import Enum, auto
 from typing import Union, Literal
 
 from pydantic import BaseModel, Field
@@ -52,6 +52,15 @@ class DropTipWellOrigin(str, Enum):
     DEFAULT = "default"
 
 
+class WellLocationFunction(int, Enum):
+    """The type of well location object to be created."""
+
+    BASE = auto()
+    LIQUID_HANDLING = auto()
+    PICK_UP_TIP = auto()
+    DROP_TIP = auto()
+
+
 # This is deliberately a separate type from Vec3f to let components default to 0.
 class WellOffset(BaseModel):
     """An offset vector in (x, y, z)."""
@@ -105,3 +114,11 @@ class DropTipWellLocation(BaseModel):
 
     origin: DropTipWellOrigin = DropTipWellOrigin.DEFAULT
     offset: WellOffset = Field(default_factory=WellOffset)
+
+
+WellLocationType = Union[
+    WellLocation,
+    LiquidHandlingWellLocation,
+    PickUpTipWellLocation,
+    DropTipWellLocation,
+]

opentrons/protocols/advanced_control/transfers/transfer_liquid_utils.py

@@ -48,7 +48,7 @@ def raise_if_location_inside_liquid(
         liquid_height_from_bottom = well_core.current_liquid_height()
     except LiquidHeightUnknownError:
         liquid_height_from_bottom = None
-    if isinstance(liquid_height_from_bottom, (int, float)):
+    if liquid_height_from_bottom is not None:
         if liquid_height_from_bottom + well_core.get_bottom(0).z > location.point.z:
             raise RuntimeError(
                 f"{location_check_descriptors.location_type.capitalize()} location {location} is"

opentrons/protocols/labware.py

@@ -4,7 +4,7 @@ import logging
 import json
 import os
 from pathlib import Path
-from typing import Any, AnyStr, Dict, Mapping, Optional, Union, List, Sequence, Literal
+from typing import Mapping, Optional, Union, List, Sequence, Literal
 
 import jsonschema  # type: ignore
 
@@ -147,46 +147,51 @@ def save_definition(
 
 
 def verify_definition(  # noqa: C901
-    contents: Union[AnyStr, LabwareDefinition, Dict[str, Any]]
+    contents: str | bytes | LabwareDefinition | object,
 ) -> LabwareDefinition:
     """Verify that an input string is a labware definition and return it.
 
-    If the definition is invalid, an exception is raised; otherwise parse the
-    json and return the valid definition.
+    :param contents: The untrusted input to parse and validate. If str or bytes, it's
+        parsed as JSON. Otherwise, it should be the output of json.load().
 
     :raises NotALabwareError:
-    :returns: The parsed definition
+
+    :returns: The parsed and validated definition
     """
     schemata_by_version = {
         2: json.loads(load_shared_data("labware/schemas/2.json").decode("utf-8")),
         3: json.loads(load_shared_data("labware/schemas/3.json").decode("utf-8")),
     }
 
-    if isinstance(contents, dict):
-        to_return = contents
-    else:
-        try:
-            to_return = json.loads(contents)
-        except json.JSONDecodeError as e:
-            raise NotALabwareError("invalid-json", [e]) from e
     try:
-        schema_version = to_return["schemaVersion"]
-    except KeyError as e:
-        raise NotALabwareError("no-schema-id", [e]) from e
+        parsed_json: object = (
+            json.loads(contents) if isinstance(contents, (str, bytes)) else contents
+        )
+    except json.JSONDecodeError as e:
+        raise NotALabwareError("invalid-json", [e]) from e
+
+    if isinstance(parsed_json, dict):
+        try:
+            schema_version: object = parsed_json["schemaVersion"]
+        except KeyError as e:
+            raise NotALabwareError("no-schema-id", [e]) from e
+    else:
+        raise NotALabwareError("no-schema-id", [])
 
     try:
-        schema = schemata_by_version[schema_version]
+        # we can type ignore this because we handle the KeyError below
+        schema = schemata_by_version[schema_version]  # type: ignore[index]
     except KeyError as e:
         raise NotALabwareError("bad-schema-id", [e]) from e
 
     try:
-        jsonschema.validate(to_return, schema)
+        jsonschema.validate(parsed_json, schema)
     except jsonschema.ValidationError as e:
         raise NotALabwareError("schema-mismatch", [e]) from e
 
     # we can type ignore this because if it passes the jsonschema it has
     # the correct structure
-    return to_return  # type: ignore[return-value]
+    return parsed_json  # type: ignore[return-value]
 
 
 def _get_labware_definition_from_bundle(

{opentrons-8.4.0a2.dist-info → opentrons-8.4.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opentrons
-Version: 8.4.0a2
+Version: 8.4.0a4
 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.4.0a2)
+Requires-Dist: opentrons-shared-data (==8.4.0a4)
 Requires-Dist: aionotify (==0.3.1)
 Requires-Dist: anyio (<4.0.0,>=3.6.1)
 Requires-Dist: jsonschema (<4.18.0,>=3.0.1)
@@ -35,9 +35,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.4.0a2) ; extra == 'flex-hardware'
+Requires-Dist: opentrons-hardware[flex] (==8.4.0a4) ; extra == 'flex-hardware'
 Provides-Extra: ot2-hardware
-Requires-Dist: opentrons-hardware (==8.4.0a2) ; extra == 'ot2-hardware'
+Requires-Dist: opentrons-hardware (==8.4.0a4) ; extra == 'ot2-hardware'
 
 .. _Full API Documentation: http://docs.opentrons.com