opentrons 8.3.2__py2.py3-none-any.whl → 8.4.0__py2.py3-none-any.whl

opentrons/protocol_api/core/engine/labware.py

@@ -3,7 +3,8 @@
 from typing import List, Optional, cast, Dict
 
 from opentrons_shared_data.labware.types import (
-    LabwareParameters as LabwareParametersDict,
+    LabwareParameters2 as LabwareParameters2Dict,
+    LabwareParameters3 as LabwareParameters3Dict,
     LabwareDefinition as LabwareDefinitionDict,
 )
 
@@ -29,6 +30,9 @@ from ..labware import AbstractLabware, LabwareLoadParams
 from .well import WellCore
 
 
+_LabwareParametersDict = LabwareParameters2Dict | LabwareParameters3Dict
+
+
 class LabwareCore(AbstractLabware[WellCore]):
     """Labware API core using a ProtocolEngine.
 
@@ -96,9 +100,9 @@ class LabwareCore(AbstractLabware[WellCore]):
             LabwareDefinitionDict, self._definition.model_dump(exclude_none=True)
         )
 
-    def get_parameters(self) -> LabwareParametersDict:
+    def get_parameters(self) -> _LabwareParametersDict:
         return cast(
-            LabwareParametersDict,
+            _LabwareParametersDict,
             self._definition.parameters.model_dump(exclude_none=True),
         )
 
@@ -122,7 +126,7 @@ class LabwareCore(AbstractLabware[WellCore]):
 
         request = LabwareOffsetCreate.model_construct(
             definitionUri=self.get_uri(),
-            location=offset_location,
+            locationSequence=offset_location,
             vector=LabwareOffsetVector(x=delta.x, y=delta.y, z=delta.z),
         )
         self._engine_client.add_labware_offset(request)

opentrons/protocol_api/core/engine/load_labware_params.py

@@ -1,7 +1,6 @@
-from typing import Dict, Tuple, List, Optional
-
 from opentrons.protocols.api_support.constants import OPENTRONS_NAMESPACE
 from opentrons.protocol_engine.state.labware import LabwareLoadParams
+from opentrons.protocols.api_support.types import APIVersion
 
 
 # Default versions of Opentrons standard labware definitions in Python Protocol API
@@ -9,7 +8,7 @@ from opentrons.protocol_engine.state.labware import LabwareLoadParams
 #
 # TODO(jbl 2023-08-01) this needs to be done more holistically, both to find the version and make sure that
 #   it corresponds to the API level is was released with
-_APILEVEL_2_14_OT_DEFAULT_VERSIONS: Dict[str, int] = {
+_APILEVEL_2_14_OT_DEFAULT_VERSIONS: dict[str, int] = {
     # v1 of many labware definitions have wrong `zDimension`s. (Jira RSS-202.)
     # For "opentrons_96_aluminumblock_generic_pcr_strip_200ul" and
     # "opentrons_24_aluminumblock_generic_2ml_screwcap", they're wrong enough to
@@ -34,6 +33,54 @@ _APILEVEL_2_14_OT_DEFAULT_VERSIONS: Dict[str, int] = {
     "corning_24_wellplate_3.4ml_flat": 2,
 }
 
+_APILEVEL_2_23_OT_DEFAULT_VERSIONS: dict[str, int] = {
+    "agilent_1_reservoir_290ml": 2,
+    "appliedbiosystemsmicroamp_384_wellplate_40ul": 2,
+    "armadillo_96_wellplate_200ul_pcr_full_skirt": 3,
+    "axygen_1_reservoir_90ml": 2,
+    "biorad_384_wellplate_50ul": 3,
+    "biorad_96_wellplate_200ul_pcr": 3,
+    "corning_12_wellplate_6.9ml_flat": 3,
+    "corning_24_wellplate_3.4ml_flat": 3,
+    "corning_384_wellplate_112ul_flat": 3,
+    "corning_48_wellplate_1.6ml_flat": 3,
+    "corning_6_wellplate_16.8ml_flat": 3,
+    "corning_96_wellplate_360ul_flat": 3,
+    "nest_12_reservoir_15ml": 2,
+    "nest_1_reservoir_195ml": 3,
+    "nest_1_reservoir_290ml": 2,
+    "nest_96_wellplate_100ul_pcr_full_skirt": 3,
+    "nest_96_wellplate_200ul_flat": 3,
+    "nest_96_wellplate_2ml_deep": 3,
+    "opentrons_10_tuberack_falcon_4x50ml_6x15ml_conical": 2,
+    "opentrons_10_tuberack_nest_4x50ml_6x15ml_conical": 2,
+    "opentrons_15_tuberack_falcon_15ml_conical": 2,
+    "opentrons_15_tuberack_nest_15ml_conical": 2,
+    "opentrons_24_aluminumblock_generic_2ml_screwcap": 3,
+    "opentrons_24_aluminumblock_nest_0.5ml_screwcap": 2,
+    "opentrons_24_aluminumblock_nest_1.5ml_screwcap": 2,
+    "opentrons_24_aluminumblock_nest_1.5ml_snapcap": 2,
+    "opentrons_24_aluminumblock_nest_2ml_screwcap": 2,
+    "opentrons_24_aluminumblock_nest_2ml_snapcap": 2,
+    "opentrons_24_tuberack_eppendorf_1.5ml_safelock_snapcap": 2,
+    "opentrons_24_tuberack_eppendorf_2ml_safelock_snapcap": 2,
+    "opentrons_24_tuberack_generic_2ml_screwcap": 2,
+    "opentrons_24_tuberack_nest_0.5ml_screwcap": 2,
+    "opentrons_24_tuberack_nest_1.5ml_screwcap": 2,
+    "opentrons_24_tuberack_nest_1.5ml_snapcap": 2,
+    "opentrons_24_tuberack_nest_2ml_screwcap": 2,
+    "opentrons_24_tuberack_nest_2ml_snapcap": 2,
+    "opentrons_6_tuberack_falcon_50ml_conical": 2,
+    "opentrons_6_tuberack_nest_50ml_conical": 2,
+    "opentrons_96_aluminumblock_generic_pcr_strip_200ul": 3,
+    "opentrons_96_wellplate_200ul_pcr_full_skirt": 3,
+    "opentrons_tough_pcr_auto_sealing_lid": 2,
+    "thermoscientificnunc_96_wellplate_1300ul": 2,
+    "thermoscientificnunc_96_wellplate_2000ul": 2,
+    "usascientific_12_reservoir_22ml": 2,
+    "usascientific_96_wellplate_2.4ml_deep": 2,
+}
+
 
 class AmbiguousLoadLabwareParamsError(RuntimeError):
     """Error raised when specific labware parameters cannot be found due to multiple matching labware definitions."""
@@ -41,10 +88,11 @@ class AmbiguousLoadLabwareParamsError(RuntimeError):
 
 def resolve(
     load_name: str,
-    namespace: Optional[str],
-    version: Optional[int],
-    custom_load_labware_params: List[LabwareLoadParams],
-) -> Tuple[str, int]:
+    namespace: str | None,
+    version: int | None,
+    custom_load_labware_params: list[LabwareLoadParams],
+    api_version: APIVersion,
+) -> tuple[str, int]:
     """Resolve the load labware parameters that best matches any custom labware, or default to opentrons standards
 
     Args:
@@ -82,7 +130,9 @@ def resolve(
         resolved_version = (
             version
             if version is not None
-            else _get_default_version_for_standard_labware(load_name=load_name)
+            else _get_default_version_for_standard_labware(
+                load_name=load_name, api_version=api_version
+            )
         )
 
     elif len(filtered_custom_params) > 1:
@@ -99,7 +149,15 @@ def resolve(
     return resolved_namespace, resolved_version
 
 
-def _get_default_version_for_standard_labware(load_name: str) -> int:
+def _get_default_version_for_standard_labware(
+    load_name: str, api_version: APIVersion
+) -> int:
     # We know the protocol is running at least apiLevel 2.14 by this point because
     # apiLevel 2.13 and below has its own separate code path for resolving labware.
-    return _APILEVEL_2_14_OT_DEFAULT_VERSIONS.get(load_name, 1)
+    if (
+        api_version >= APIVersion(2, 23)
+        and load_name in _APILEVEL_2_23_OT_DEFAULT_VERSIONS
+    ):
+        return _APILEVEL_2_23_OT_DEFAULT_VERSIONS[load_name]
+    else:
+        return _APILEVEL_2_14_OT_DEFAULT_VERSIONS.get(load_name, 1)

opentrons/protocol_api/core/engine/module_core.py

@@ -1,4 +1,5 @@
 """Protocol API module implementation logic."""
+
 from __future__ import annotations
 
 from typing import Optional, List, Dict, Union
@@ -17,7 +18,7 @@ from opentrons.drivers.types import (
 )
 
 from opentrons.protocol_engine import commands as cmd
-from opentrons.protocol_engine.types import ABSMeasureMode
+from opentrons.protocol_engine.types import ABSMeasureMode, StackerFillEmptyStrategy
 from opentrons.types import DeckSlotName
 from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
 from opentrons.protocol_engine.errors.exceptions import (
@@ -37,9 +38,10 @@ from ..module import (
     AbstractHeaterShakerCore,
     AbstractMagneticBlockCore,
     AbstractAbsorbanceReaderCore,
+    AbstractFlexStackerCore,
 )
 from .exceptions import InvalidMagnetEngageHeightError
-
+from . import load_labware_params
 
 # Valid wavelength range for absorbance reader
 ABS_WAVELENGTH_MIN = 350
@@ -692,3 +694,117 @@ class AbsorbanceReaderCore(ModuleCore, AbstractAbsorbanceReaderCore):
             self.module_id
         )
         return abs_state.is_lid_on
+
+
+class FlexStackerCore(ModuleCore, AbstractFlexStackerCore):
+    """Flex Stacker core logic implementation for Python protocols."""
+
+    _sync_module_hardware: SynchronousAdapter[hw_modules.FlexStacker]
+
+    def retrieve(self) -> None:
+        """Retrieve a labware from the Flex Stacker's hopper."""
+        self._engine_client.execute_command(
+            cmd.flex_stacker.RetrieveParams(
+                moduleId=self.module_id,
+            )
+        )
+
+    def store(self) -> None:
+        """Store a labware into Flex Stacker's hopper."""
+        self._engine_client.execute_command(
+            cmd.flex_stacker.StoreParams(
+                moduleId=self.module_id,
+            )
+        )
+
+    def fill(self, message: str, count: int | None) -> None:
+        """Pause the protocol to add more labware to the Flex Stacker's hopper."""
+        self._engine_client.execute_command(
+            cmd.flex_stacker.FillParams(
+                moduleId=self.module_id,
+                strategy=StackerFillEmptyStrategy.MANUAL_WITH_PAUSE,
+                message=message,
+                count=count,
+            )
+        )
+
+    def empty(self, message: str) -> None:
+        """Pause the protocol to remove labware from the Flex Stacker's hopper."""
+        self._engine_client.execute_command(
+            cmd.flex_stacker.EmptyParams(
+                moduleId=self.module_id,
+                strategy=StackerFillEmptyStrategy.MANUAL_WITH_PAUSE,
+                message=message,
+                count=0,
+            )
+        )
+
+    def set_stored_labware(
+        self,
+        main_load_name: str,
+        main_namespace: str | None,
+        main_version: int | None,
+        lid_load_name: str | None,
+        lid_namespace: str | None,
+        lid_version: int | None,
+        adapter_load_name: str | None,
+        adapter_namespace: str | None,
+        adapter_version: int | None,
+        count: int | None,
+    ) -> None:
+        """Configure the kind of labware that the stacker stores."""
+
+        custom_labware_params = (
+            self._engine_client.state.labware.find_custom_labware_load_params()
+        )
+
+        main_namespace, main_version = load_labware_params.resolve(
+            main_load_name,
+            main_namespace,
+            main_version,
+            custom_labware_params,
+            self._api_version,
+        )
+        main_labware = cmd.flex_stacker.StackerStoredLabwareDetails(
+            loadName=main_load_name, namespace=main_namespace, version=main_version
+        )
+
+        lid_labware: cmd.flex_stacker.StackerStoredLabwareDetails | None = None
+
+        if lid_load_name:
+            lid_namespace, lid_version = load_labware_params.resolve(
+                lid_load_name,
+                lid_namespace,
+                lid_version,
+                custom_labware_params,
+                self._api_version,
+            )
+            lid_labware = cmd.flex_stacker.StackerStoredLabwareDetails(
+                loadName=lid_load_name, namespace=lid_namespace, version=lid_version
+            )
+
+        adapter_labware: cmd.flex_stacker.StackerStoredLabwareDetails | None = None
+
+        if adapter_load_name:
+            adapter_namespace, adapter_version = load_labware_params.resolve(
+                adapter_load_name,
+                adapter_namespace,
+                adapter_version,
+                custom_labware_params,
+                self._api_version,
+            )
+            adapter_labware = cmd.flex_stacker.StackerStoredLabwareDetails(
+                loadName=adapter_load_name,
+                namespace=adapter_namespace,
+                version=adapter_version,
+            )
+
+        self._engine_client.execute_command(
+            cmd.flex_stacker.SetStoredLabwareParams(
+                moduleId=self.module_id,
+                initialCount=count,
+                primaryLabware=main_labware,
+                lidLabware=lid_labware,
+                adapterLabware=adapter_labware,
+            )
+        )

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -19,14 +19,9 @@ from opentrons.protocol_engine import (
     StateView,
     DeckSlotLocation,
     OnLabwareLocation,
-    WellLocation,
-    LiquidHandlingWellLocation,
-    PickUpTipWellLocation,
     DropTipWellLocation,
 )
-from opentrons.protocol_engine.types import (
-    StagingSlotLocation,
-)
+from opentrons.protocol_engine.types import StagingSlotLocation, WellLocationType
 from opentrons.types import DeckSlotName, StagingSlotName, Point
 from . import point_calculations
 
@@ -69,12 +64,7 @@ def check_safe_for_pipette_movement(  # noqa: C901
     pipette_id: str,
     labware_id: str,
     well_name: str,
-    well_location: Union[
-        WellLocation,
-        LiquidHandlingWellLocation,
-        PickUpTipWellLocation,
-        DropTipWellLocation,
-    ],
+    well_location: WellLocationType,
 ) -> None:
     """Check if the labware is safe to move to with a pipette in partial tip configuration.
 
@@ -100,12 +90,14 @@ def check_safe_for_pipette_movement(  # noqa: C901
             partially_configured=True,
         )
     well_location_point = engine_state.geometry.get_well_position(
-        labware_id=labware_id, well_name=well_name, well_location=well_location
+        labware_id=labware_id,
+        well_name=well_name,
+        well_location=well_location,
+        pipette_id=pipette_id,
     )
     primary_nozzle = engine_state.pipettes.get_primary_nozzle(pipette_id)
 
     destination_cp = _get_critical_point_to_use(engine_state, labware_id)
-
     pipette_bounds_at_well_location = (
         engine_state.pipettes.get_pipette_bounds_at_specified_move_to_position(
             pipette_id=pipette_id,