opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a1__py2.py3-none-any.whl

opentrons/protocol_engine/state/commands.py

@@ -228,9 +228,6 @@ class CommandState:
     This value can be used to generate future hashes.
     """
 
-    failed_command_errors: List[ErrorOccurrence]
-    """List of command errors that occurred during run execution."""
-
     has_entered_error_recovery: bool
     """Whether the run has entered error recovery."""
 
@@ -269,7 +266,6 @@ class CommandStore(HasState[CommandState], HandlesActions):
             run_started_at=None,
             latest_protocol_command_hash=None,
             stopped_by_estop=False,
-            failed_command_errors=[],
             error_recovery_policy=error_recovery_policy,
             has_entered_error_recovery=False,
         )
@@ -308,7 +304,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         # TODO(mc, 2021-06-22): mypy has trouble with this automatic
         # request > command mapping, figure out how to type precisely
         # (or wait for a future mypy version that can figure it out).
-        queued_command = action.request._CommandCls.construct(
+        queued_command = action.request._CommandCls.model_construct(  # type: ignore[call-arg]
             id=action.command_id,
             key=(
                 action.request.key
@@ -330,7 +326,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
     def _handle_run_command_action(self, action: RunCommandAction) -> None:
         prev_entry = self._state.command_history.get(action.command_id)
 
-        running_command = prev_entry.command.copy(
+        running_command = prev_entry.command.model_copy(
             update={
                 "status": CommandStatus.RUNNING,
                 "startedAt": action.started_at,
@@ -366,7 +362,6 @@ class CommandStore(HasState[CommandState], HandlesActions):
             notes=action.notes,
         )
         self._state.failed_command = self._state.command_history.get(action.command_id)
-        self._state.failed_command_errors.append(public_error_occurrence)
 
         if (
             prev_entry.command.intent in (CommandIntent.PROTOCOL, None)
@@ -530,7 +525,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
         notes: Optional[List[CommandNote]],
     ) -> None:
         prev_entry = self._state.command_history.get(command_id)
-        failed_command = prev_entry.command.copy(
+        failed_command = prev_entry.command.model_copy(
             update={
                 "completedAt": failed_at,
                 "status": CommandStatus.FAILED,
@@ -584,7 +579,7 @@ class CommandStore(HasState[CommandState], HandlesActions):
             )
 
 
-class CommandView(HasState[CommandState]):
+class CommandView:
     """Read-only command state view."""
 
     _state: CommandState
@@ -684,7 +679,7 @@ class CommandView(HasState[CommandState]):
         finish_error = self._state.finish_error
 
         if run_error and finish_error:
-            combined_error = ErrorOccurrence.construct(
+            combined_error = ErrorOccurrence(
                 id=finish_error.id,
                 createdAt=finish_error.createdAt,
                 errorType="RunAndFinishFailed",
@@ -706,7 +701,12 @@ class CommandView(HasState[CommandState]):
 
     def get_all_errors(self) -> List[ErrorOccurrence]:
         """Get the run's full error list, if there was none, returns an empty list."""
-        return self._state.failed_command_errors
+        failed_commands = self._state.command_history.get_all_failed_commands()
+        return [
+            command_error.error
+            for command_error in failed_commands
+            if command_error.error is not None
+        ]
 
     def get_has_entered_recovery_mode(self) -> bool:
         """Get whether the run has entered recovery mode."""
@@ -916,7 +916,7 @@ class CommandView(HasState[CommandState]):
         fatal error of the overall run coming from anywhere in the Python script,
         including in between commands.
         """
-        failed_command = self.state.failed_command
+        failed_command = self._state.failed_command
         if (
             failed_command
             and failed_command.command.error
@@ -932,12 +932,16 @@ class CommandView(HasState[CommandState]):
 
         The command ID is assumed to point to a failed command.
         """
-        return self.state.command_error_recovery_types[command_id]
+        return self._state.command_error_recovery_types[command_id]
 
     def get_is_stopped(self) -> bool:
         """Get whether an engine stop has completed."""
         return self._state.run_completed_at is not None
 
+    def get_is_stopped_by_estop(self) -> bool:
+        """Return whether the engine was stopped specifically by an E-stop."""
+        return self._state.stopped_by_estop
+
     def has_been_played(self) -> bool:
         """Get whether engine has started."""
         return self._state.run_started_at is not None

opentrons/protocol_engine/state/files.py

@@ -2,12 +2,11 @@
 from dataclasses import dataclass
 from typing import List
 
+from opentrons.protocol_engine.actions.get_state_update import get_state_updates
+from opentrons.protocol_engine.state import update_types
+
 from ._abstract_store import HasState, HandlesActions
-from ..actions import Action, SucceedCommandAction
-from ..commands import (
-    Command,
-    absorbance_reader,
-)
+from ..actions import Action
 
 
 @dataclass
@@ -28,16 +27,15 @@ class FileStore(HasState[FileState], HandlesActions):
 
     def handle_action(self, action: Action) -> None:
         """Modify state in reaction to an action."""
-        if isinstance(action, SucceedCommandAction):
-            self._handle_command(action.command)
+        for state_update in get_state_updates(action):
+            self._handle_state_update(state_update)
 
-    def _handle_command(self, command: Command) -> None:
-        if isinstance(command.result, absorbance_reader.ReadAbsorbanceResult):
-            if command.result.fileIds is not None:
-                self._state.file_ids.extend(command.result.fileIds)
+    def _handle_state_update(self, state_update: update_types.StateUpdate) -> None:
+        if state_update.files_added != update_types.NO_CHANGE:
+            self._state.file_ids.extend(state_update.files_added.file_ids)
 
 
-class FileView(HasState[FileState]):
+class FileView:
     """Read-only engine created file state view."""
 
     _state: FileState

opentrons/protocol_engine/state/fluid_stack.py

@@ -0,0 +1,138 @@
+"""Implements fluid stack tracking for pipettes.
+
+Inside a pipette's tip, there can be a mix of kinds of fluids - here, "fluid" means "liquid" (i.e. a protocol-relevant
+working liquid that is aspirated or dispensed from wells) or "air" (i.e. because there was an air gap). Since sometimes
+you want air gaps in different places - physically-below liquid to prevent dripping, physically-above liquid to provide
+extra room to push the plunger - we need to support some notion of at least phsyical ordinal position of air and liquid,
+and we do so as a logical stack because that's physically relevant.
+"""
+from logging import getLogger
+from numpy import isclose
+from ..types import AspiratedFluid, FluidKind
+
+_LOG = getLogger(__name__)
+
+
+class FluidStack:
+    """A FluidStack data structure is a list of AspiratedFluids, with stack-style (last-in-first-out) ordering.
+
+    The front of the list is the physical-top of the liquid stack (logical-bottom of the stack data structure)
+    and the back of the list is the physical-bottom of the liquid stack (logical-top of the stack data structure).
+    The state is internal and the interaction surface is the methods. This is a mutating API.
+    """
+
+    _FluidStack = list[AspiratedFluid]
+
+    _fluid_stack: _FluidStack
+
+    def __init__(self, _fluid_stack: _FluidStack | None = None) -> None:
+        """Build a FluidStack.
+
+        The argument is provided for testing and shouldn't be generally used.
+        """
+        self._fluid_stack = _fluid_stack or []
+
+    def add_fluid(self, new: AspiratedFluid) -> None:
+        """Add fluid to a stack.
+
+        If the new fluid is of a different kind than what's on the physical-bottom of the stack, add a new record.
+        If the new fluid is of the same kind as what's on the physical-bottom of the stack, add the new volume to
+        the same record.
+        """
+        if len(self._fluid_stack) == 0 or self._fluid_stack[-1].kind != new.kind:
+            # this is a new kind of fluid, append the record
+            self._fluid_stack.append(new)
+        else:
+            # this is more of the same kind of fluid, add the volumes
+            old_fluid = self._fluid_stack.pop(-1)
+            self._fluid_stack.append(
+                AspiratedFluid(kind=new.kind, volume=old_fluid.volume + new.volume)
+            )
+
+    def _alter_fluid_records(
+        self, remove: int, new_last: AspiratedFluid | None
+    ) -> None:
+        if remove >= len(self._fluid_stack) or len(self._fluid_stack) == 0:
+            self._fluid_stack = []
+            return
+        if remove != 0:
+            removed = self._fluid_stack[:-remove]
+        else:
+            removed = self._fluid_stack
+        if new_last:
+            removed[-1] = new_last
+        self._fluid_stack = removed
+
+    def remove_fluid(self, volume: float) -> None:
+        """Remove a specific amount of fluid from the physical-bottom of the stack.
+
+        This will consume records that are wholly included in the provided volume and alter the remaining
+        final records (if any) to decrement the amount of volume removed from it.
+
+        This function is designed to be used inside pipette store action handlers, which are generally not
+        exception-safe, and therefore swallows and logs errors.
+        """
+        self._fluid_stack_iterator = reversed(self._fluid_stack)
+        removed_elements: list[AspiratedFluid] = []
+        while volume > 0:
+            try:
+                last_stack_element = next(self._fluid_stack_iterator)
+            except StopIteration:
+                _LOG.error(
+                    f"Attempting to remove more fluid than present, {volume}uL left over"
+                )
+                self._alter_fluid_records(len(removed_elements), None)
+                return
+            if last_stack_element.volume < volume:
+                removed_elements.append(last_stack_element)
+                volume -= last_stack_element.volume
+            elif isclose(last_stack_element.volume, volume):
+                self._alter_fluid_records(len(removed_elements) + 1, None)
+                return
+            else:
+                self._alter_fluid_records(
+                    len(removed_elements),
+                    AspiratedFluid(
+                        kind=last_stack_element.kind,
+                        volume=last_stack_element.volume - volume,
+                    ),
+                )
+                return
+
+        _LOG.error(f"Failed to handle removing {volume}uL from {self._fluid_stack}")
+
+    def aspirated_volume(self, kind: FluidKind | None = None) -> float:
+        """Measure the total amount of fluid (optionally filtered by kind) in the stack."""
+        volume = 0.0
+        for el in self._fluid_stack:
+            if kind is not None and el.kind != kind:
+                continue
+            volume += el.volume
+        return volume
+
+    def liquid_part_of_dispense_volume(self, volume: float) -> float:
+        """Get the amount of liquid in the specified volume starting at the physical-bottom of the stack."""
+        liquid_volume = 0.0
+        for el in reversed(self._fluid_stack):
+            if el.kind == FluidKind.LIQUID:
+                liquid_volume += min(volume, el.volume)
+            volume -= min(el.volume, volume)
+            if isclose(volume, 0.0):
+                return liquid_volume
+        return liquid_volume
+
+    def __eq__(self, other: object) -> bool:
+        """Equality."""
+        if isinstance(other, type(self)):
+            return other._fluid_stack == self._fluid_stack
+        return False
+
+    def __repr__(self) -> str:
+        """String representation of a fluid stack."""
+        if self._fluid_stack:
+            stringified_stack = (
+                f'(top) {", ".join([str(item) for item in self._fluid_stack])} (bottom)'
+            )
+        else:
+            stringified_stack = "empty"
+        return f"<{self.__class__.__name__}: {stringified_stack}>"

opentrons/protocol_engine/state/frustum_helpers.py

@@ -220,28 +220,40 @@ def _get_segment_capacity(segment: WellSegment) -> float:
     section_height = segment.topHeight - segment.bottomHeight
     match segment:
         case SphericalSegment():
-            return _volume_from_height_spherical(
-                target_height=segment.topHeight,
-                radius_of_curvature=segment.radiusOfCurvature,
+            return (
+                _volume_from_height_spherical(
+                    target_height=segment.topHeight,
+                    radius_of_curvature=segment.radiusOfCurvature,
+                )
+                * segment.count
             )
         case CuboidalFrustum():
-            return _volume_from_height_rectangular(
-                target_height=section_height,
-                bottom_length=segment.bottomYDimension,
-                bottom_width=segment.bottomXDimension,
-                top_length=segment.topYDimension,
-                top_width=segment.topXDimension,
-                total_frustum_height=section_height,
+            return (
+                _volume_from_height_rectangular(
+                    target_height=section_height,
+                    bottom_length=segment.bottomYDimension,
+                    bottom_width=segment.bottomXDimension,
+                    top_length=segment.topYDimension,
+                    top_width=segment.topXDimension,
+                    total_frustum_height=section_height,
+                )
+                * segment.count
             )
         case ConicalFrustum():
-            return _volume_from_height_circular(
-                target_height=section_height,
-                total_frustum_height=section_height,
-                bottom_radius=(segment.bottomDiameter / 2),
-                top_radius=(segment.topDiameter / 2),
+            return (
+                _volume_from_height_circular(
+                    target_height=section_height,
+                    total_frustum_height=section_height,
+                    bottom_radius=(segment.bottomDiameter / 2),
+                    top_radius=(segment.topDiameter / 2),
+                )
+                * segment.count
             )
         case SquaredConeSegment():
-            return _volume_from_height_squared_cone(section_height, segment)
+            return (
+                _volume_from_height_squared_cone(section_height, segment)
+                * segment.count
+            )
         case _:
             # TODO: implement volume calculations for truncated circular and rounded rectangular segments
             raise NotImplementedError(
@@ -272,6 +284,7 @@ def height_at_volume_within_section(
     section_height: float,
 ) -> float:
     """Calculate a height within a bounded section according to geometry."""
+    target_volume_relative = target_volume_relative / section.count
     match section:
         case SphericalSegment():
             return _height_from_volume_spherical(
@@ -311,28 +324,40 @@ def volume_at_height_within_section(
     """Calculate a volume within a bounded section according to geometry."""
     match section:
         case SphericalSegment():
-            return _volume_from_height_spherical(
-                target_height=target_height_relative,
-                radius_of_curvature=section.radiusOfCurvature,
+            return (
+                _volume_from_height_spherical(
+                    target_height=target_height_relative,
+                    radius_of_curvature=section.radiusOfCurvature,
+                )
+                * section.count
             )
         case ConicalFrustum():
-            return _volume_from_height_circular(
-                target_height=target_height_relative,
-                total_frustum_height=section_height,
-                bottom_radius=(section.bottomDiameter / 2),
-                top_radius=(section.topDiameter / 2),
+            return (
+                _volume_from_height_circular(
+                    target_height=target_height_relative,
+                    total_frustum_height=section_height,
+                    bottom_radius=(section.bottomDiameter / 2),
+                    top_radius=(section.topDiameter / 2),
+                )
+                * section.count
             )
         case CuboidalFrustum():
-            return _volume_from_height_rectangular(
-                target_height=target_height_relative,
-                total_frustum_height=section_height,
-                bottom_width=section.bottomXDimension,
-                bottom_length=section.bottomYDimension,
-                top_width=section.topXDimension,
-                top_length=section.topYDimension,
+            return (
+                _volume_from_height_rectangular(
+                    target_height=target_height_relative,
+                    total_frustum_height=section_height,
+                    bottom_width=section.bottomXDimension,
+                    bottom_length=section.bottomYDimension,
+                    top_width=section.topXDimension,
+                    top_length=section.topYDimension,
+                )
+                * section.count
             )
         case SquaredConeSegment():
-            return _volume_from_height_squared_cone(target_height_relative, section)
+            return (
+                _volume_from_height_squared_cone(target_height_relative, section)
+                * section.count
+            )
         case _:
             # TODO(cm): this would be the NEST-96 2uL wells referenced in EXEC-712
             # we need to input the math attached to that issue

opentrons/protocol_engine/state/geometry.py

@@ -1,4 +1,5 @@
 """Geometry state getters."""
+
 import enum
 from numpy import array, dot, double as npdouble
 from numpy.typing import NDArray
@@ -8,6 +9,7 @@ from functools import cached_property
 
 from opentrons.types import Point, DeckSlotName, StagingSlotName, MountType
 
+from opentrons_shared_data.errors.exceptions import InvalidStoredData
 from opentrons_shared_data.labware.constants import WELL_NAME_PATTERN
 from opentrons_shared_data.deck.types import CutoutFixture
 from opentrons_shared_data.pipette import PIPETTE_X_SPAN
@@ -61,6 +63,7 @@ from .frustum_helpers import (
     find_volume_at_well_height,
     find_height_at_well_volume,
 )
+from ._well_math import wells_covered_by_pipette_configuration, nozzles_per_well
 
 
 SLOT_WIDTH = 128
@@ -486,7 +489,7 @@ class GeometryView:
                 well_depth=well_depth,
                 operation_volume=operation_volume,
             )
-            offset = offset.copy(update={"z": offset.z + offset_adjustment})
+            offset = offset.model_copy(update={"z": offset.z + offset_adjustment})
             self.validate_well_position(
                 well_location=well_location, z_offset=offset.z, pipette_id=pipette_id
             )
@@ -1559,3 +1562,46 @@ class GeometryView:
                 raise errors.InvalidDispenseVolumeError(
                     f"Attempting to dispense {volume}µL of liquid into a well that can only hold {well_volumetric_capacity}µL (well {well_name} in labware_id: {labware_id})"
                 )
+
+    def get_wells_covered_by_pipette_with_active_well(
+        self, labware_id: str, target_well_name: str, pipette_id: str
+    ) -> list[str]:
+        """Get a flat list of wells that are covered by a pipette when moved to a specified well.
+
+        When you move a pipette in a multichannel configuration  to a specific well - the target well -
+        the pipette will operate on other wells as well.
+
+        For instance, a pipette with a COLUMN configuration with well A1 of an SBS standard labware target
+        will also "cover", under this definition, wells B1-H1. That same pipette, when C5 is the target well, will "cover"
+        wells C5-H5.
+
+        This math only works, and may only be applied, if one of the following is true:
+        - The pipette is in a SINGLE configuration
+        - The pipette is in a non-SINGLE configuration, and the labware is an SBS-format 96 or 384 well plate (and is so
+          marked in its definition's parameters.format key, as 96Standard or 384Standard)
+
+        If all of the following do not apply, regardless of the nozzle configuration of the pipette this function will
+        return only the labware covered by the primary well.
+        """
+        pipette_nozzle_map = self._pipettes.get_nozzle_configuration(pipette_id)
+        labware_columns = [
+            column for column in self._labware.get_definition(labware_id).ordering
+        ]
+        try:
+            return list(
+                wells_covered_by_pipette_configuration(
+                    pipette_nozzle_map, target_well_name, labware_columns
+                )
+            )
+        except InvalidStoredData:
+            return [target_well_name]
+
+    def get_nozzles_per_well(
+        self, labware_id: str, target_well_name: str, pipette_id: str
+    ) -> int:
+        """Get the number of nozzles that will interact with each well."""
+        return nozzles_per_well(
+            self._pipettes.get_nozzle_configuration(pipette_id),
+            target_well_name,
+            self._labware.get_definition(labware_id).ordering,
+        )

opentrons/protocol_engine/state/labware.py

@@ -131,7 +131,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
             for fixed_labware in deck_fixed_labware
         }
         labware_by_id = {
-            fixed_labware.labware_id: LoadedLabware.construct(
+            fixed_labware.labware_id: LoadedLabware.model_construct(
                 id=fixed_labware.labware_id,
                 location=fixed_labware.location,
                 loadName=fixed_labware.definition.parameters.loadName,
@@ -156,10 +156,12 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
         """Modify state in reaction to an action."""
         for state_update in get_state_updates(action):
             self._add_loaded_labware(state_update)
+            self._add_loaded_lid_stack(state_update)
             self._set_labware_location(state_update)
+            self._set_labware_lid(state_update)
 
         if isinstance(action, AddLabwareOffsetAction):
-            labware_offset = LabwareOffset.construct(
+            labware_offset = LabwareOffset.model_construct(
                 id=action.labware_offset_id,
                 createdAt=action.created_at,
                 definitionUri=action.request.definitionUri,
@@ -212,7 +214,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
 
             self._state.labware_by_id[
                 loaded_labware_update.labware_id
-            ] = LoadedLabware.construct(
+            ] = LoadedLabware.model_construct(
                 id=loaded_labware_update.labware_id,
                 location=location,
                 loadName=loaded_labware_update.definition.parameters.loadName,
@@ -221,6 +223,63 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
                 displayName=display_name,
             )
 
+    def _add_loaded_lid_stack(self, state_update: update_types.StateUpdate) -> None:
+        loaded_lid_stack_update = state_update.loaded_lid_stack
+        if loaded_lid_stack_update != update_types.NO_CHANGE:
+            # Add the stack object
+            stack_definition_uri = uri_from_details(
+                namespace=loaded_lid_stack_update.stack_object_definition.namespace,
+                load_name=loaded_lid_stack_update.stack_object_definition.parameters.loadName,
+                version=loaded_lid_stack_update.stack_object_definition.version,
+            )
+            self.state.definitions_by_uri[
+                stack_definition_uri
+            ] = loaded_lid_stack_update.stack_object_definition
+            self._state.labware_by_id[
+                loaded_lid_stack_update.stack_id
+            ] = LoadedLabware.construct(
+                id=loaded_lid_stack_update.stack_id,
+                location=loaded_lid_stack_update.stack_location,
+                loadName=loaded_lid_stack_update.stack_object_definition.parameters.loadName,
+                definitionUri=stack_definition_uri,
+                offsetId=None,
+                displayName=None,
+            )
+
+            # Add the Lids on top of the stack object
+            for i in range(len(loaded_lid_stack_update.labware_ids)):
+                definition_uri = uri_from_details(
+                    namespace=loaded_lid_stack_update.definition.namespace,
+                    load_name=loaded_lid_stack_update.definition.parameters.loadName,
+                    version=loaded_lid_stack_update.definition.version,
+                )
+
+                self._state.definitions_by_uri[
+                    definition_uri
+                ] = loaded_lid_stack_update.definition
+
+                location = loaded_lid_stack_update.new_locations_by_id[
+                    loaded_lid_stack_update.labware_ids[i]
+                ]
+
+                self._state.labware_by_id[
+                    loaded_lid_stack_update.labware_ids[i]
+                ] = LoadedLabware.construct(
+                    id=loaded_lid_stack_update.labware_ids[i],
+                    location=location,
+                    loadName=loaded_lid_stack_update.definition.parameters.loadName,
+                    definitionUri=definition_uri,
+                    offsetId=None,
+                    displayName=None,
+                )
+
+    def _set_labware_lid(self, state_update: update_types.StateUpdate) -> None:
+        labware_lid_update = state_update.labware_lid
+        if labware_lid_update != update_types.NO_CHANGE:
+            parent_labware_id = labware_lid_update.parent_labware_id
+            lid_id = labware_lid_update.lid_id
+            self._state.labware_by_id[parent_labware_id].lid_id = lid_id
+
     def _set_labware_location(self, state_update: update_types.StateUpdate) -> None:
         labware_location_update = state_update.labware_location
         if labware_location_update != update_types.NO_CHANGE:
@@ -244,7 +303,7 @@ class LabwareStore(HasState[LabwareState], HandlesActions):
                 self._state.labware_by_id[labware_id].location = new_location
 
 
-class LabwareView(HasState[LabwareState]):
+class LabwareView:
     """Read-only labware state view."""
 
     _state: LabwareState
@@ -268,7 +327,7 @@ class LabwareView(HasState[LabwareState]):
 
     def get_id_by_module(self, module_id: str) -> str:
         """Return the ID of the labware loaded on the given module."""
-        for labware_id, labware in self.state.labware_by_id.items():
+        for labware_id, labware in self._state.labware_by_id.items():
             if (
                 isinstance(labware.location, ModuleLocation)
                 and labware.location.moduleId == module_id
@@ -281,7 +340,7 @@ class LabwareView(HasState[LabwareState]):
 
     def get_id_by_labware(self, labware_id: str) -> str:
         """Return the ID of the labware loaded on the given labware."""
-        for labware in self.state.labware_by_id.values():
+        for labware in self._state.labware_by_id.values():
             if (
                 isinstance(labware.location, OnLabwareLocation)
                 and labware.location.labwareId == labware_id
@@ -441,21 +500,7 @@ class LabwareView(HasState[LabwareState]):
 
         If not defined within a labware, defaults to one.
         """
-        stacking_quirks = {
-            "stackingMaxFive": 5,
-            "stackingMaxFour": 4,
-            "stackingMaxThree": 3,
-            "stackingMaxTwo": 2,
-            "stackingMaxOne": 1,
-            "stackingMaxZero": 0,
-        }
-        for quirk in stacking_quirks.keys():
-            if (
-                labware.parameters.quirks is not None
-                and quirk in labware.parameters.quirks
-            ):
-                return stacking_quirks[quirk]
-        return 1
+        return labware.stackLimit if labware.stackLimit is not None else 1
 
     def get_should_center_pipette_on_target_well(self, labware_id: str) -> bool:
         """True if a pipette moving to a well of this labware should center its body on the target.
@@ -815,6 +860,11 @@ class LabwareView(HasState[LabwareState]):
             return self.raise_if_labware_inaccessible_by_pipette(
                 labware_location.labwareId
             )
+        elif labware.lid_id is not None:
+            raise errors.LocationNotAccessibleByPipetteError(
+                f"Cannot move pipette to {labware.loadName} "
+                "because labware is currently covered by a lid."
+            )
         elif isinstance(labware_location, AddressableAreaLocation):
             if fixture_validation.is_staging_slot(labware_location.addressableAreaName):
                 raise errors.LocationNotAccessibleByPipetteError(
@@ -998,11 +1048,15 @@ class LabwareView(HasState[LabwareState]):
             return None
         else:
             return LabwareMovementOffsetData(
-                pickUpOffset=cast(
-                    LabwareOffsetVector, parsed_offsets[offset_key].pickUpOffset
+                pickUpOffset=LabwareOffsetVector.model_construct(
+                    x=parsed_offsets[offset_key].pickUpOffset.x,
+                    y=parsed_offsets[offset_key].pickUpOffset.y,
+                    z=parsed_offsets[offset_key].pickUpOffset.z,
                 ),
-                dropOffset=cast(
-                    LabwareOffsetVector, parsed_offsets[offset_key].dropOffset
+                dropOffset=LabwareOffsetVector.model_construct(
+                    x=parsed_offsets[offset_key].dropOffset.x,
+                    y=parsed_offsets[offset_key].dropOffset.y,
+                    z=parsed_offsets[offset_key].dropOffset.z,
                 ),
             )