opentrons 8.4.1a2__py2.py3-none-any.whl → 8.5.0__py2.py3-none-any.whl

opentrons/protocol_engine/commands/robot/open_gripper_jaw.py

@@ -1,6 +1,7 @@
 """Command models for opening a gripper jaw."""
+
 from __future__ import annotations
-from typing import Literal, Type, Optional
+from typing import Literal, Type, Optional, TYPE_CHECKING
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.protocol_engine.resources import ensure_ot3_hardware
 
@@ -14,64 +15,72 @@ from ..command import (
 )
 from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
 
+if TYPE_CHECKING:
+    from ...state.state import StateView
+
 
-openGripperJawCommandType = Literal["robot/openGripperJaw"]
+OpenGripperJawCommandType = Literal["robot/openGripperJaw"]
 
 
-class openGripperJawParams(BaseModel):
+class OpenGripperJawParams(BaseModel):
     """Payload required to release a gripper."""
 
     pass
 
 
-class openGripperJawResult(BaseModel):
+class OpenGripperJawResult(BaseModel):
     """Result data from the execution of a openGripperJaw command."""
 
     pass
 
 
-class openGripperJawImplementation(
-    AbstractCommandImpl[openGripperJawParams, SuccessData[openGripperJawResult]]
+class OpenGripperJawImplementation(
+    AbstractCommandImpl[OpenGripperJawParams, SuccessData[OpenGripperJawResult]]
 ):
     """openGripperJaw command implementation."""
 
     def __init__(
         self,
         hardware_api: HardwareControlAPI,
+        state_view: StateView,
         **kwargs: object,
     ) -> None:
         self._hardware_api = hardware_api
+        self._state_view = state_view
 
     async def execute(
-        self, params: openGripperJawParams
-    ) -> SuccessData[openGripperJawResult]:
+        self, params: OpenGripperJawParams
+    ) -> SuccessData[OpenGripperJawResult]:
         """Release the gripper."""
+        if self._state_view.config.use_virtual_gripper:
+            return SuccessData(public=OpenGripperJawResult())
+
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
 
         await ot3_hardware_api.home_gripper_jaw()
         return SuccessData(
-            public=openGripperJawResult(),
+            public=OpenGripperJawResult(),
         )
 
 
-class openGripperJaw(
-    BaseCommand[openGripperJawParams, openGripperJawResult, ErrorOccurrence]
+class OpenGripperJaw(
+    BaseCommand[OpenGripperJawParams, OpenGripperJawResult, ErrorOccurrence]
 ):
     """openGripperJaw command model."""
 
-    commandType: openGripperJawCommandType = "robot/openGripperJaw"
-    params: openGripperJawParams
-    result: Optional[openGripperJawResult] = None
+    commandType: OpenGripperJawCommandType = "robot/openGripperJaw"
+    params: OpenGripperJawParams
+    result: Optional[OpenGripperJawResult] = None
 
     _ImplementationCls: Type[
-        openGripperJawImplementation
-    ] = openGripperJawImplementation
+        OpenGripperJawImplementation
+    ] = OpenGripperJawImplementation
 
 
-class openGripperJawCreate(BaseCommandCreate[openGripperJawParams]):
+class OpenGripperJawCreate(BaseCommandCreate[OpenGripperJawParams]):
     """openGripperJaw command request model."""
 
-    commandType: openGripperJawCommandType = "robot/openGripperJaw"
-    params: openGripperJawParams
+    commandType: OpenGripperJawCommandType = "robot/openGripperJaw"
+    params: OpenGripperJawParams
 
-    _CommandCls: Type[openGripperJaw] = openGripperJaw
+    _CommandCls: Type[OpenGripperJaw] = OpenGripperJaw

opentrons/protocol_engine/commands/seal_pipette_to_tip.py

@@ -273,7 +273,7 @@ class SealPipetteToTipImplementation(
 
         # Begin relative pickup steps for the resin tips
 
-        channels = self._state_view.tips.get_pipette_active_channels(pipette_id)
+        channels = self._state_view.pipettes.get_active_channels(pipette_id)
         mount = self._state_view.pipettes.get_mount(pipette_id)
         tip_pick_up_params = params.tipPickUpParams
 

opentrons/protocol_engine/commands/unsafe/__init__.py

@@ -1,4 +1,20 @@
-"""Commands that will cause inaccuracy or incorrect behavior but are still necessary."""
+"""Commands that are "unsafe".
+
+"Unsafe" means that they can cause inaccuracy or incorrect behavior. They should
+therefore never be used in protocols, and should only be used otherwise as a last
+resort.
+
+These exist as a necessary evil for implementing things like error recovery.
+Even in those narrow contexts, these commands must be used with care.
+e.g. after an `UpdatePositionEstimators` command, there must be a `Home` command,
+or positioning will be subtly wrong. Each unsafe command should document its intended
+use case and its caveats.
+
+Because we don't expect unsafe commands to be used in any protocols whose behavior we
+must preserve, we may change the commands' semantics over time. We may also change
+their shapes if we're confident that it won't break something in robot-server's
+persistent storage.
+"""
 
 from .unsafe_blow_out_in_place import (
     UnsafeBlowOutInPlaceCommandType,

opentrons/protocol_engine/commands/unsafe/unsafe_drop_tip_in_place.py

@@ -81,8 +81,7 @@ class UnsafeDropTipInPlaceImplementation(
             pipette_id=params.pipetteId,
             home_after=params.homeAfter,
             ignore_plunger=(
-                self._state_view.tips.get_pipette_active_channels(params.pipetteId)
-                == 96
+                self._state_view.pipettes.get_active_channels(params.pipetteId) == 96
             ),
         )
 

opentrons/protocol_engine/execution/labware_movement.py

@@ -61,6 +61,7 @@ class LabwareMovementHandler:
         """Initialize a LabwareMovementHandler instance."""
         self._hardware_api = hardware_api
         self._state_store = state_store
+        self._equipment = equipment
         self._thermocycler_plate_lifter = (
             thermocycler_plate_lifter
             or ThermocyclerPlateLifter(
@@ -72,7 +73,13 @@ class LabwareMovementHandler:
         self._tc_movement_flagger = (
             thermocycler_movement_flagger
             or ThermocyclerMovementFlagger(
-                state_store=self._state_store, hardware_api=self._hardware_api
+                state_store=self._state_store,
+                hardware_api=self._hardware_api,
+                equipment=self._equipment
+                or EquipmentHandler(
+                    hardware_api=self._hardware_api,
+                    state_store=self._state_store,
+                ),
             )
         )
         self._hs_movement_flagger = (
@@ -264,7 +271,7 @@ class LabwareMovementHandler:
             )
         for parent in (current_parent, new_location):
             try:
-                await self._tc_movement_flagger.raise_if_labware_in_non_open_thermocycler(
+                await self._tc_movement_flagger.ensure_labware_in_open_thermocycler(
                     labware_parent=parent
                 )
                 await self._hs_movement_flagger.raise_if_labware_latched_on_heater_shaker(

opentrons/protocol_engine/execution/movement.py

@@ -24,6 +24,7 @@ from .thermocycler_movement_flagger import ThermocyclerMovementFlagger
 from .heater_shaker_movement_flagger import HeaterShakerMovementFlagger
 
 from .gantry_mover import GantryMover
+from .equipment import EquipmentHandler
 
 
 log = logging.getLogger(__name__)
@@ -43,6 +44,7 @@ class MovementHandler:
         model_utils: Optional[ModelUtils] = None,
         thermocycler_movement_flagger: Optional[ThermocyclerMovementFlagger] = None,
         heater_shaker_movement_flagger: Optional[HeaterShakerMovementFlagger] = None,
+        equipment: Optional[EquipmentHandler] = None,
     ) -> None:
         """Initialize a MovementHandler instance."""
         self._state_store = state_store
@@ -50,7 +52,13 @@ class MovementHandler:
         self._tc_movement_flagger = (
             thermocycler_movement_flagger
             or ThermocyclerMovementFlagger(
-                state_store=self._state_store, hardware_api=hardware_api
+                state_store=self._state_store,
+                hardware_api=hardware_api,
+                equipment=equipment
+                or EquipmentHandler(
+                    hardware_api=hardware_api,
+                    state_store=state_store,
+                ),
             )
         )
         self._hs_movement_flagger = (
@@ -83,8 +91,7 @@ class MovementHandler:
         self._state_store.labware.raise_if_labware_has_labware_on_top(
             labware_id=labware_id
         )
-
-        await self._tc_movement_flagger.raise_if_labware_in_non_open_thermocycler(
+        await self._tc_movement_flagger.ensure_labware_in_open_thermocycler(
             labware_parent=self._state_store.labware.get_location(labware_id=labware_id)
         )
 
@@ -105,9 +112,7 @@ class MovementHandler:
         self._hs_movement_flagger.raise_if_movement_restricted(
             hs_movement_restrictors=hs_movement_restrictors,
             destination_slot=dest_slot_int,
-            is_multi_channel=(
-                self._state_store.tips.get_pipette_channels(pipette_id) > 1
-            ),
+            is_multi_channel=(self._state_store.pipettes.get_channels(pipette_id) > 1),
             destination_is_tip_rack=self._state_store.labware.is_tiprack(labware_id),
         )
 
@@ -204,9 +209,7 @@ class MovementHandler:
         self._hs_movement_flagger.raise_if_movement_restricted(
             hs_movement_restrictors=hs_movement_restrictors,
             destination_slot=dest_slot_int,
-            is_multi_channel=(
-                self._state_store.tips.get_pipette_channels(pipette_id) > 1
-            ),
+            is_multi_channel=(self._state_store.pipettes.get_channels(pipette_id) > 1),
             destination_is_tip_rack=False,
         )
 

opentrons/protocol_engine/execution/queue_worker.py

@@ -72,7 +72,14 @@ class QueueWorker:
             try:
                 await self._command_executor.execute(command_id=command_id)
             except BaseException:
-                log.exception("Unhandled failure in command executor")
+                log.exception(
+                    # The state can tear if e.g. we've finished updating PipetteStore,
+                    # but the exception came before we could update LabwareStore. Or
+                    # the exception could have interrupted updating a single store.
+                    "Unhandled failure in command executor."
+                    " This is a bug in opentrons.protocol_engine"
+                    " and has probably left the ProtocolEngine in a torn state."
+                )
                 raise
             # Yield to the event loop in case we're executing a long sequence of commands
             # that never yields internally. For example, a long sequence of comment commands.

opentrons/protocol_engine/execution/thermocycler_movement_flagger.py

@@ -1,15 +1,18 @@
 """Helpers for flagging unsafe movements to a Thermocycler Module."""
-
 from typing import Optional
 
 from opentrons.drivers.types import ThermocyclerLidStatus
 from opentrons.hardware_control import HardwareControlAPI
 from opentrons.hardware_control.modules import Thermocycler as HardwareThermocycler
 
+
+from opentrons.protocol_engine.state.module_substates import ThermocyclerModuleId
 from ..types import ModuleLocation, LabwareLocation
 from ..state.state import StateStore
 from ..errors import ThermocyclerNotOpenError, WrongModuleTypeError
 
+from .equipment import EquipmentHandler
+
 
 class ThermocyclerMovementFlagger:
     """A helper for flagging unsafe movements to a Thermocycler Module.
@@ -19,7 +22,10 @@ class ThermocyclerMovementFlagger:
     """
 
     def __init__(
-        self, state_store: StateStore, hardware_api: HardwareControlAPI
+        self,
+        state_store: StateStore,
+        hardware_api: HardwareControlAPI,
+        equipment: EquipmentHandler,
     ) -> None:
         """Initialize the ThermocyclerMovementFlagger.
 
@@ -28,18 +34,59 @@ class ThermocyclerMovementFlagger:
                          which Thermocycler a labware is in, if any.
             hardware_api: The underlying hardware interface. Used to query
                           Thermocyclers' current lid states.
+            equipment: The protocol engine interface to move a present thermocycler to an
+                            operable state if need be.
         """
         self._state_store = state_store
         self._hardware_api = hardware_api
+        self._equipment = equipment
+
+    async def _verify_tc_lid_status(self, module_id: str) -> None:
+        """Ensure the thermocycler's lid state is correct or raise an error."""
+        try:
+            hw_tc_lid_status = await self._get_hardware_thermocycler_lid_status(
+                module_id=module_id
+            )
+        except self._HardwareThermocyclerMissingError as e:
+            raise ThermocyclerNotOpenError(
+                "Thermocycler must be open when moving to labware inside it,"
+                " but can't confirm Thermocycler's current status."
+            ) from e
+
+        if (
+            hw_tc_lid_status == ThermocyclerLidStatus.IN_BETWEEN
+            or hw_tc_lid_status == ThermocyclerLidStatus.UNKNOWN
+        ):
+            # NOTE(cm): due to a potential hardware bug, the thermocycler might lose its position
+            # status when idling in an open position and default to UNKNOWN or IN_BETWEEN.
+            # This tries to recover only from an unexpected known position.
+            await self._open_tc_lid(module_id=module_id)
+            hw_tc_lid_status = await self._get_hardware_thermocycler_lid_status(
+                module_id=module_id
+            )
+        if hw_tc_lid_status != ThermocyclerLidStatus.OPEN:
+            raise ThermocyclerNotOpenError(
+                f"Thermocycler must be open when moving to labware inside it,"
+                f' but Thermocycler is currently "{hw_tc_lid_status}".'
+            )
+
+    async def _open_tc_lid(self, module_id: str) -> None:
+        """Try to open the thermocycler lid."""
+        tc_hardware = self._equipment.get_module_hardware_api(
+            ThermocyclerModuleId(module_id)
+        )
+        if tc_hardware:
+            await tc_hardware.open()
 
-    async def raise_if_labware_in_non_open_thermocycler(
+    async def ensure_labware_in_open_thermocycler(
         self, labware_parent: LabwareLocation
     ) -> None:
         """Flag unsafe movements to a Thermocycler.
 
         If the given labware is in a Thermocycler, and that Thermocycler's lid isn't
         currently open according the engine's thermocycler state as well as
-        the hardware API (for non-virtual modules), raises ThermocyclerNotOpenError.
+        the hardware API (for non-virtual modules), tries to open the thermocycler lid.
+        If this is unsuccessful, raises ThermocyclerNotOpenError.
         If it is a virtual module, checks only for thermocycler lid state in engine.
 
         Otherwise, no-ops.
@@ -81,21 +128,7 @@ class ThermocyclerMovementFlagger:
         # There is a chance that the engine might not have the latest lid status;
         # do a hardware state check just to be sure that the lid is truly open.
         if not self._state_store.config.use_virtual_modules:
-            try:
-                hw_tc_lid_status = await self._get_hardware_thermocycler_lid_status(
-                    module_id=tc_substate.module_id
-                )
-            except self._HardwareThermocyclerMissingError as e:
-                raise ThermocyclerNotOpenError(
-                    "Thermocycler must be open when moving to labware inside it,"
-                    " but can't confirm Thermocycler's current status."
-                ) from e
-
-            if hw_tc_lid_status != ThermocyclerLidStatus.OPEN:
-                raise ThermocyclerNotOpenError(
-                    f"Thermocycler must be open when moving to labware inside it,"
-                    f' but Thermocycler is currently "{hw_tc_lid_status}".'
-                )
+            await self._verify_tc_lid_status(module_id=module_id)
 
     async def _get_hardware_thermocycler_lid_status(
         self,

opentrons/protocol_engine/resources/labware_validation.py

@@ -48,7 +48,13 @@ def validate_labware_can_be_stacked(
     top_labware_definition: LabwareDefinition, below_labware_load_name: str
 ) -> bool:
     """Validate that the labware being loaded onto is in the above labware's stackingOffsetWithLabware definition."""
-    return below_labware_load_name in top_labware_definition.stackingOffsetWithLabware
+    return (
+        below_labware_load_name in top_labware_definition.stackingOffsetWithLabware
+        or (
+            "default" in top_labware_definition.stackingOffsetWithLabware
+            and top_labware_definition.compatibleParentLabware is None
+        )
+    )
 
 
 def validate_labware_can_be_ondeck(definition: LabwareDefinition) -> bool:

opentrons/protocol_engine/state/_well_math.py

@@ -63,7 +63,7 @@ def wells_covered_dense(  # noqa: C901
     row_downsample = len(target_wells_by_column[0]) // 8
     if column_downsample < 1 or row_downsample < 1:
         raise InvalidStoredData(
-            "This labware cannot be used wells_covered_dense because it is less dense than an SBS 96 standard"
+            "This labware cannot be used with wells_covered_dense() because it is less dense than an SBS 96 standard"
         )
 
     for nozzle_column in range(len(nozzle_map.columns)):
@@ -126,7 +126,7 @@ def wells_covered_sparse(  # noqa: C901
     row_upsample = 8 // len(target_wells_by_column[0])
     if column_upsample < 1 or row_upsample < 1:
         raise InvalidStoredData(
-            "This labware cannot be used with wells_covered_sparse because it is more dense than an SBS 96 standard."
+            "This labware cannot be used with wells_covered_sparse() because it is more dense than an SBS 96 standard."
         )
     for nozzle_column in range(max(1, len(nozzle_map.columns) // column_upsample)):
         for nozzle_row in range(max(1, len(nozzle_map.rows) // row_upsample)):

opentrons/protocol_engine/state/commands.py

@@ -611,49 +611,35 @@ class CommandView:
         """Get a subset of commands around a given cursor.
 
         If the cursor is omitted, a cursor will be selected automatically
-        based on the currently running or most recently executed command.
+        based on the currently running or most recently executed command,
+        and the slice of commands returned is the previous `length` commands
+        inclusive of the currently running or most recently executed command.
         """
         command_ids = self._state.command_history.get_filtered_command_ids(
             include_fixit_commands=include_fixit_commands
         )
-        running_command = self._state.command_history.get_running_command()
-        queued_command_ids = self._state.command_history.get_queue_ids()
         total_length = len(command_ids)
 
-        # TODO(mm, 2024-05-17): This looks like it's attempting to do the same thing
-        # as self.get_current(), but in a different way. Can we unify them?
         if cursor is None:
-            if running_command is not None:
-                cursor = running_command.index
-            elif len(queued_command_ids) > 0:
-                # Get the most recently executed command,
-                # which we can find just before the first queued command.
-                cursor = (
-                    self._state.command_history.get(queued_command_ids.head()).index - 1
-                )
-            elif (
-                self._state.run_result
-                and self._state.run_result == RunResult.FAILED
-                and self._state.failed_command
-            ):
-                # Currently, if the run fails, we mark all the commands we didn't
-                # reach as failed. This makes command status alone insufficient to
-                # find the most recent command that actually executed, so we need to
-                # store that separately.
-                cursor = self._state.failed_command.index
+            current_pointer = self.get_current()
+
+            if current_pointer is not None:
+                cursor = current_pointer.index
             else:
-                cursor = total_length - length
+                cursor = total_length - 1
+
+            cursor = max(cursor - length + 1, 0)
 
         # start is inclusive, stop is exclusive
-        actual_cursor = max(0, min(cursor, total_length - 1))
-        stop = min(total_length, actual_cursor + length)
+        start = max(0, min(cursor, total_length - 1))
+        stop = min(total_length, start + length)
         commands = self._state.command_history.get_slice(
-            start=actual_cursor, stop=stop, command_ids=command_ids
+            start=start, stop=stop, command_ids=command_ids
         )
 
         return CommandSlice(
             commands=commands,
-            cursor=actual_cursor,
+            cursor=start,
             total_length=total_length,
         )
 

opentrons/protocol_engine/state/frustum_helpers.py

@@ -88,10 +88,12 @@ def _circular_frustum_polynomial_roots(
 def _volume_from_height_circular(
     target_height: float, segment: ConicalFrustum
 ) -> float:
-    """Find the volume given a height within a circular frustum."""
-    heights = segment.height_to_volume_table.keys()
-    best_fit_height = min(heights, key=lambda x: abs(x - target_height))
-    return segment.height_to_volume_table[best_fit_height]
+    return segment.volume_from_height_circular(
+        top_radius=segment.topDiameter / 2,
+        bottom_radius=segment.bottomDiameter / 2,
+        target_height=target_height,
+        total_height=segment.topHeight - segment.bottomHeight,
+    )
 
 
 def _volume_from_height_rectangular(
@@ -138,9 +140,7 @@ def _height_from_volume_circular(
     target_volume: float, segment: ConicalFrustum
 ) -> float:
     """Find the height given a volume within a squared cone segment."""
-    volumes = segment.volume_to_height_table.keys()
-    best_fit_volume = min(volumes, key=lambda x: abs(x - target_volume))
-    return segment.volume_to_height_table[best_fit_volume]
+    return segment.height_from_volume_search(target_volume)
 
 
 def _height_from_volume_rectangular(
@@ -401,8 +401,12 @@ def _find_height_in_partial_frustum(
 ) -> float:
     """Look through a sorted list of frusta for a target volume, and find the height at that volume."""
     bottom_section_volume = 0.0
+    if target_volume == 0.0:
+        return 0.0
     for section, capacity in zip(sorted_well, volumetric_capacity):
         section_top_height, section_volume = capacity
+        if target_volume == section_volume + bottom_section_volume:
+            return section_top_height
         if (
             bottom_section_volume
             <= target_volume

opentrons/protocol_engine/state/labware.py

@@ -1131,6 +1131,18 @@ class LabwareView:
             raise errors.LabwareCannotBeStackedError(
                 f"Labware {top_labware_definition.parameters.loadName} cannot be loaded onto labware {below_labware.loadName}"
             )
+        elif (
+            labware_validation.validate_definition_is_lid(top_labware_definition)
+            and top_labware_definition.compatibleParentLabware is not None
+            and self.get_load_name(bottom_labware_id)
+            not in top_labware_definition.compatibleParentLabware
+        ):
+            # This parent is assumed to be compatible, unless the lid enumerates
+            # all its compatible parents and this parent is missing from the list.
+            raise ValueError(
+                f"Labware Lid {top_labware_definition.parameters.loadName} may not be loaded on parent labware"
+                f" {self.get_display_name(bottom_labware_id)}."
+            )
         elif isinstance(below_labware.location, ModuleLocation):
             below_definition = self.get_definition(labware_id=below_labware.id)
             if not labware_validation.validate_definition_is_adapter(

opentrons/protocol_engine/state/modules.py

@@ -1361,7 +1361,7 @@ class ModuleView:
                 col = (i % 12) + 1  # Convert index to column (1-12)
                 well_key = f"{row}{col}"
                 # Truncate the value to the third decimal place
-                well_map[well_key] = math.floor(value * 1000) / 1000
+                well_map[well_key] = max(0.0, math.floor(value * 1000) / 1000)
             return well_map
         else:
             raise ValueError(

opentrons/protocol_engine/state/pipettes.py

@@ -650,6 +650,10 @@ class PipetteView:
         """Return the max channels of the pipette."""
         return self.get_config(pipette_id).channels
 
+    def get_active_channels(self, pipette_id: str) -> int:
+        """Get the number of channels being used in the given pipette's configuration."""
+        return self.get_nozzle_configuration(pipette_id).tip_count
+
     def get_minimum_volume(self, pipette_id: str) -> float:
         """Return the given pipette's minimum volume."""
         return self.get_config(pipette_id).min_volume
@@ -727,6 +731,10 @@ class PipetteView:
         nozzle_map = self._state.nozzle_configuration_by_id[pipette_id]
         return nozzle_map.starting_nozzle
 
+    def get_nozzle_configurations(self) -> Dict[str, NozzleMap]:
+        """Get the nozzle maps of all pipettes, keyed by pipette ID."""
+        return self._state.nozzle_configuration_by_id.copy()
+
     def get_nozzle_configuration(self, pipette_id: str) -> NozzleMap:
         """Get the nozzle map of the pipette."""
         return self._state.nozzle_configuration_by_id[pipette_id]