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

opentrons/protocol_engine/state/module_substates/thermocycler_module_substate.py

@@ -19,6 +19,7 @@ from opentrons.drivers.thermocycler.driver import (
     LID_TARGET_MIN,
     LID_TARGET_MAX,
 )
+from opentrons.hardware_control.modules import ModuleData, ModuleDataValidator
 
 ThermocyclerModuleId = NewType("ThermocyclerModuleId", str)
 
@@ -141,3 +142,22 @@ class ThermocyclerModuleSubState:
                 f"Module {self.module_id} does not have a target block temperature set."
             )
         return target
+
+    @classmethod
+    def from_live_data(
+        cls, module_id: ThermocyclerModuleId, data: ModuleData | None
+    ) -> "ThermocyclerModuleSubState":
+        """Create a ThermocyclerModuleSubState from live data."""
+        if ModuleDataValidator.is_thermocycler_data(data):
+            return cls(
+                module_id=module_id,
+                is_lid_open=data["lid"] == "open",
+                target_block_temperature=data["targetTemp"],
+                target_lid_temperature=data["lidTarget"],
+            )
+        return cls(
+            module_id=module_id,
+            is_lid_open=False,
+            target_block_temperature=None,
+            target_lid_temperature=None,
+        )

opentrons/protocol_engine/state/modules.py

@@ -36,8 +36,9 @@ from opentrons.protocol_engine.state.module_substates.absorbance_reader_substate
     AbsorbanceReaderMeasureMode,
 )
 from opentrons.types import DeckSlotName, MountType, StagingSlotName
-from .update_types import AbsorbanceReaderStateUpdate
-from ..errors import ModuleNotConnectedError
+from .update_types import AbsorbanceReaderStateUpdate, FlexStackerStateUpdate
+from ..errors import ModuleNotConnectedError, AreaNotInDeckConfigurationError
+from ..resources import deck_configuration_provider
 
 from ..types import (
     LoadedModule,
@@ -78,11 +79,13 @@ from .module_substates import (
     TemperatureModuleSubState,
     ThermocyclerModuleSubState,
     AbsorbanceReaderSubState,
+    FlexStackerSubState,
     MagneticModuleId,
     HeaterShakerModuleId,
     TemperatureModuleId,
     ThermocyclerModuleId,
     AbsorbanceReaderId,
+    FlexStackerId,
     MagneticBlockSubState,
     MagneticBlockId,
     ModuleSubStateType,
@@ -147,11 +150,14 @@ class HardwareModule:
 class ModuleState:
     """The internal data to keep track of loaded modules."""
 
-    slot_by_module_id: Dict[str, Optional[DeckSlotName]]
-    """The deck slot that each module has been loaded into.
+    load_location_by_module_id: Dict[str, Optional[str]]
+    """The Cutout ID of the cutout (Flex) or slot (OT-2) that each module has been loaded.
 
     This will be None when the module was added via
     ProtocolEngine.use_attached_modules() instead of an explicit loadModule command.
+    AddressableAreaLocation is used to represent a literal Deck Slot for OT-2 locations.
+    The CutoutID string for a given Cutout that a Module Fixture is loaded into is used
+    for Flex. The type distinction is in place for implementation seperation between the two.
     """
 
     additional_slots_occupied_by_module_id: Dict[str, List[DeckSlotName]]
@@ -211,7 +217,7 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
     ) -> None:
         """Initialize a ModuleStore and its state."""
         self._state = ModuleState(
-            slot_by_module_id={},
+            load_location_by_module_id={},
             additional_slots_occupied_by_module_id={},
             requested_model_by_id={},
             hardware_by_module_id={},
@@ -302,6 +308,8 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             self._handle_absorbance_reader_commands(
                 state_update.absorbance_reader_state_update
             )
+        if state_update.flex_stacker_state_update != update_types.NO_CHANGE:
+            self._handle_flex_stacker_commands(state_update.flex_stacker_state_update)
 
     def _add_module_substate(
         self,
@@ -312,11 +320,19 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
         requested_model: Optional[ModuleModel],
         module_live_data: Optional[LiveData],
     ) -> None:
+        # Loading slot name to Cutout ID (Flex)(OT-2) resolution
+        load_location: Optional[str]
+        if slot_name is not None:
+            load_location = deck_configuration_provider.get_cutout_id_by_deck_slot_name(
+                slot_name
+            )
+        else:
+            load_location = slot_name
+
         actual_model = definition.model
         live_data = module_live_data["data"] if module_live_data else None
-
         self._state.requested_model_by_id[module_id] = requested_model
-        self._state.slot_by_module_id[module_id] = slot_name
+        self._state.load_location_by_module_id[module_id] = load_location
         self._state.hardware_by_module_id[module_id] = HardwareModule(
             serial_number=serial_number,
             definition=definition,
@@ -328,31 +344,24 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 model=actual_model,
             )
         elif ModuleModel.is_heater_shaker_module_model(actual_model):
-            if live_data is None:
-                labware_latch_status = HeaterShakerLatchStatus.UNKNOWN
-            elif live_data["labwareLatchStatus"] == "idle_closed":
-                labware_latch_status = HeaterShakerLatchStatus.CLOSED
-            else:
-                labware_latch_status = HeaterShakerLatchStatus.OPEN
-            self._state.substate_by_module_id[module_id] = HeaterShakerModuleSubState(
+            self._state.substate_by_module_id[
+                module_id
+            ] = HeaterShakerModuleSubState.from_live_data(
                 module_id=HeaterShakerModuleId(module_id),
-                labware_latch_status=labware_latch_status,
-                is_plate_shaking=(
-                    live_data is not None and live_data["targetSpeed"] is not None
-                ),
-                plate_target_temperature=live_data["targetTemp"] if live_data else None,  # type: ignore[arg-type]
+                data=live_data,
             )
         elif ModuleModel.is_temperature_module_model(actual_model):
-            self._state.substate_by_module_id[module_id] = TemperatureModuleSubState(
+            self._state.substate_by_module_id[
+                module_id
+            ] = TemperatureModuleSubState.from_live_data(
                 module_id=TemperatureModuleId(module_id),
-                plate_target_temperature=live_data["targetTemp"] if live_data else None,  # type: ignore[arg-type]
+                data=live_data,
             )
         elif ModuleModel.is_thermocycler_module_model(actual_model):
-            self._state.substate_by_module_id[module_id] = ThermocyclerModuleSubState(
-                module_id=ThermocyclerModuleId(module_id),
-                is_lid_open=live_data is not None and live_data["lid"] == "open",
-                target_block_temperature=live_data["targetTemp"] if live_data else None,  # type: ignore[arg-type]
-                target_lid_temperature=live_data["lidTarget"] if live_data else None,  # type: ignore[arg-type]
+            self._state.substate_by_module_id[
+                module_id
+            ] = ThermocyclerModuleSubState.from_live_data(
+                module_id=ThermocyclerModuleId(module_id), data=live_data
             )
             self._update_additional_slots_occupied_by_thermocycler(
                 module_id=module_id, slot_name=slot_name
@@ -372,6 +381,15 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
                 configured_wavelengths=None,
                 reference_wavelength=None,
             )
+        elif ModuleModel.is_flex_stacker(actual_model):
+            self._state.substate_by_module_id[module_id] = FlexStackerSubState(
+                module_id=FlexStackerId(module_id),
+                pool_primary_definition=None,
+                pool_adapter_definition=None,
+                pool_lid_definition=None,
+                pool_count=0,
+                max_pool_count=0,
+            )
 
     def _update_additional_slots_occupied_by_thermocycler(
         self,
@@ -613,6 +631,20 @@ class ModuleStore(HasState[ModuleState], HandlesActions):
             data=data,
         )
 
+    def _handle_flex_stacker_commands(
+        self, state_update: FlexStackerStateUpdate
+    ) -> None:
+        """Handle Flex Stacker state updates."""
+        module_id = state_update.module_id
+        prev_substate = self._state.substate_by_module_id[module_id]
+        assert isinstance(
+            prev_substate, FlexStackerSubState
+        ), f"{module_id} is not a Flex Stacker."
+
+        self._state.substate_by_module_id[
+            module_id
+        ] = prev_substate.new_from_state_change(state_update)
+
 
 class ModuleView:
     """Read-only view of computed module state."""
@@ -626,12 +658,17 @@ class ModuleView:
     def get(self, module_id: str) -> LoadedModule:
         """Get module data by the module's unique identifier."""
         try:
-            slot_name = self._state.slot_by_module_id[module_id]
+            load_location = self._state.load_location_by_module_id[module_id]
             attached_module = self._state.hardware_by_module_id[module_id]
 
         except KeyError as e:
             raise errors.ModuleNotLoadedError(module_id=module_id) from e
 
+        slot_name = None
+        if isinstance(load_location, str):
+            slot_name = deck_configuration_provider.get_deck_slot_for_cutout_id(
+                load_location
+            )
         location = (
             DeckSlotLocation(slotName=slot_name) if slot_name is not None else None
         )
@@ -645,21 +682,39 @@ class ModuleView:
 
     def get_all(self) -> List[LoadedModule]:
         """Get a list of all module entries in state."""
-        return [self.get(mod_id) for mod_id in self._state.slot_by_module_id.keys()]
+        return [
+            self.get(mod_id) for mod_id in self._state.load_location_by_module_id.keys()
+        ]
 
     def get_by_slot(
         self,
         slot_name: DeckSlotName,
     ) -> Optional[LoadedModule]:
         """Get the module located in a given slot, if any."""
-        slots_by_id = reversed(list(self._state.slot_by_module_id.items()))
+        locations_by_id = reversed(list(self._state.load_location_by_module_id.items()))
 
-        for module_id, module_slot in slots_by_id:
+        for module_id, load_location in locations_by_id:
+            module_slot: Optional[DeckSlotName]
+            if isinstance(load_location, str):
+                module_slot = deck_configuration_provider.get_deck_slot_for_cutout_id(
+                    load_location
+                )
+            else:
+                module_slot = load_location
             if module_slot == slot_name:
                 return self.get(module_id)
 
         return None
 
+    def get_by_addressable_area(
+        self, addressable_area_name: str
+    ) -> Optional[LoadedModule]:
+        """Get the module associated with this addressable area, if any."""
+        for module_id in self._state.load_location_by_module_id.keys():
+            if addressable_area_name == self.get_provided_addressable_area(module_id):
+                return self.get(module_id)
+        return None
+
     def _get_module_substate(
         self, module_id: str, expected_type: Type[ModuleSubStateT], expected_name: str
     ) -> ModuleSubStateT:
@@ -764,6 +819,20 @@ class ModuleView:
             expected_name="Absorbance Reader",
         )
 
+    def get_flex_stacker_substate(self, module_id: str) -> FlexStackerSubState:
+        """Return a `FlexStackerSubState` for the given Flex Stacker.
+
+        Raises:
+           ModuleNotLoadedError: If module_id has not been loaded.
+           WrongModuleTypeError: If module_id has been loaded,
+               but it's not a Flex Stacker.
+        """
+        return self._get_module_substate(
+            module_id=module_id,
+            expected_type=FlexStackerSubState,
+            expected_name="Flex Stacker",
+        )
+
     def get_location(self, module_id: str) -> DeckSlotLocation:
         """Get the slot location of the given module."""
         location = self.get(module_id).location
@@ -773,6 +842,26 @@ class ModuleView:
             )
         return location
 
+    def get_provided_addressable_area(self, module_id: str) -> str:
+        """Get the addressable area provided by this module.
+
+        If the current deck does not allow modules to provide locations (i.e., is an OT-2 deck)
+        then return the addressable area underneath the module.
+        """
+        module = self.get(module_id)
+
+        if isinstance(module.location, DeckSlotLocation):
+            location = module.location.slotName
+        elif module.model == ModuleModel.THERMOCYCLER_MODULE_V2:
+            location = DeckSlotName.SLOT_B1
+        else:
+            raise ValueError(
+                "Module location invalid for nominal module offset calculation."
+            )
+        if not self.get_deck_supports_module_fixtures():
+            return location.value
+        return self.ensure_and_convert_module_fixture_location(location, module.model)
+
     def get_requested_model(self, module_id: str) -> Optional[ModuleModel]:
         """Return the model by which this module was requested.
 
@@ -841,10 +930,39 @@ class ModuleView:
         Includes the slot-specific transform. Does not include the child's
         Labware Position Check offset.
         """
-        if (
-            self._state.deck_type == DeckType.OT2_STANDARD
-            or self._state.deck_type == DeckType.OT2_SHORT_TRASH
-        ):
+        base = self.get_nominal_offset_to_child_from_addressable_area(module_id)
+        if self.get_deck_supports_module_fixtures():
+            module_addressable_area = self.get_provided_addressable_area(module_id)
+            module_addressable_area_position = (
+                addressable_areas.get_addressable_area_offsets_from_cutout(
+                    module_addressable_area
+                )
+            )
+            return base + LabwareOffsetVector(
+                x=module_addressable_area_position.x,
+                y=module_addressable_area_position.y,
+                z=module_addressable_area_position.z,
+            )
+        else:
+            return base
+
+    def get_nominal_offset_to_child_from_addressable_area(
+        self, module_id: str
+    ) -> LabwareOffsetVector:
+        """Get the position offset for a child of this module from the nearest AA.
+
+        On the Flex, this is always (0, 0, 0); on the OT-2, since modules load on top
+        of addressable areas rather than providing addressable areas, the offset is
+        the labwareOffset from the module definition, rotated by the module's
+        slotTransform if appropriate.
+        """
+        if self.get_deck_supports_module_fixtures():
+            return LabwareOffsetVector(
+                x=0,
+                y=0,
+                z=0,
+            )
+        else:
             definition = self.get_definition(module_id)
             slot = self.get_location(module_id).slotName.id
 
@@ -879,29 +997,6 @@ class ModuleView:
                 y=xformed[1],
                 z=xformed[2],
             )
-        else:
-            module = self.get(module_id)
-            if isinstance(module.location, DeckSlotLocation):
-                location = module.location.slotName
-            elif module.model == ModuleModel.THERMOCYCLER_MODULE_V2:
-                location = DeckSlotName.SLOT_B1
-            else:
-                raise ValueError(
-                    "Module location invalid for nominal module offset calculation."
-                )
-            module_addressable_area = self.ensure_and_convert_module_fixture_location(
-                location, module.model
-            )
-            module_addressable_area_position = (
-                addressable_areas.get_addressable_area_offsets_from_cutout(
-                    module_addressable_area
-                )
-            )
-            return LabwareOffsetVector(
-                x=module_addressable_area_position.x,
-                y=module_addressable_area_position.y,
-                z=module_addressable_area_position.z,
-            )
 
     def get_module_calibration_offset(
         self, module_id: str
@@ -1109,12 +1204,21 @@ class ModuleView:
             else:
                 neighbor_slot = DeckSlotName.from_primitive(neighbor_int)
 
-        return neighbor_slot in self._state.slot_by_module_id.values()
+        # Convert the load location list from addressable areas and cutout IDs to a slot name list
+        load_locations = self._state.load_location_by_module_id.values()
+        module_slots = []
+        for location in load_locations:
+            if isinstance(location, str):
+                module_slots.append(
+                    deck_configuration_provider.get_deck_slot_for_cutout_id(location)
+                )
+
+        return neighbor_slot in module_slots
 
     def select_hardware_module_to_load(  # noqa: C901
         self,
         model: ModuleModel,
-        location: DeckSlotLocation,
+        location: str,
         attached_modules: Sequence[HardwareModule],
         expected_serial_number: Optional[str] = None,
     ) -> HardwareModule:
@@ -1143,10 +1247,13 @@ class ModuleView:
         """
         existing_mod_in_slot = None
 
-        for mod_id, slot in self._state.slot_by_module_id.items():
-            if slot == location.slotName:
+        for (
+            mod_id,
+            load_location,
+        ) in self._state.load_location_by_module_id.items():
+            if isinstance(load_location, str) and location == load_location:
                 existing_mod_in_slot = self._state.hardware_by_module_id.get(mod_id)
-                break
+
         if existing_mod_in_slot:
             existing_def = existing_mod_in_slot.definition
 
@@ -1154,9 +1261,9 @@ class ModuleView:
                 return existing_mod_in_slot
 
             else:
+                _err = f" present in {location}"
                 raise errors.ModuleAlreadyPresentError(
-                    f"A {existing_def.model.value} is already"
-                    f" present in {location.slotName.value}"
+                    f"A {existing_def.model.value} is already" + _err
                 )
 
         for m in attached_modules:
@@ -1168,7 +1275,10 @@ class ModuleView:
                     else:
                         return m
 
-        raise errors.ModuleNotAttachedError(f"No available {model.value} found.")
+        raise errors.ModuleNotAttachedError(
+            f"No available {model.value} with {expected_serial_number or 'any'}"
+            " serial found."
+        )
 
     def get_heater_shaker_movement_restrictors(
         self,
@@ -1258,6 +1368,11 @@ class ModuleView:
                 "Only readings of 96 Well labware are supported for conversion to map of values by well."
             )
 
+    def get_deck_supports_module_fixtures(self) -> bool:
+        """Check if the loaded deck supports modules as fixtures."""
+        deck_type = self._state.deck_type
+        return deck_type not in [DeckType.OT2_STANDARD, DeckType.OT2_SHORT_TRASH]
+
     def ensure_and_convert_module_fixture_location(
         self,
         deck_slot: DeckSlotName,
@@ -1269,8 +1384,8 @@ class ModuleView:
         """
         deck_type = self._state.deck_type
 
-        if deck_type == DeckType.OT2_STANDARD or deck_type == DeckType.OT2_SHORT_TRASH:
-            raise ValueError(
+        if not self.get_deck_supports_module_fixtures():
+            raise AreaNotInDeckConfigurationError(
                 f"Invalid Deck Type: {deck_type.name} - Does not support modules as fixtures."
             )
 
@@ -1296,6 +1411,11 @@ class ModuleView:
             assert deck_slot.value[-1] == "3"
             return f"absorbanceReaderV1{deck_slot.value}"
 
+        elif model == ModuleModel.FLEX_STACKER_MODULE_V1:
+            # loaded to column 3 but the addressable area is in column 4
+            assert deck_slot.value[-1] == "3"
+            return f"flexStackerModuleV1{deck_slot.value[0]}4"
+
         raise ValueError(
             f"Unknown module {model.name} has no addressable areas to provide."
         )
@@ -1311,3 +1431,26 @@ class ModuleView:
             addressableAreaName="absorbanceReaderV1LidDock" + lid_doc_slot.value
         )
         return lid_dock_area
+
+    def get_stacker_max_fill_height(self, module_id: str) -> float:
+        """Get the maximum fill height for the Flex Stacker."""
+        definition = self.get_definition(module_id)
+
+        if (
+            definition.moduleType == ModuleType.FLEX_STACKER
+            and hasattr(definition.dimensions, "maxStackerFillHeight")
+            and definition.dimensions.maxStackerFillHeight is not None
+        ):
+            return definition.dimensions.maxStackerFillHeight
+        else:
+            raise errors.WrongModuleTypeError(
+                f"Cannot get max fill height of {definition.moduleType}"
+            )
+
+    def stacker_max_pool_count_by_height(
+        self, module_id: str, pool_height: float
+    ) -> int:
+        """Get the maximum stack count for the Flex Stacker by stack height."""
+        max_fill_height = self.get_stacker_max_fill_height(module_id)
+        assert max_fill_height > 0
+        return math.floor(max_fill_height / pool_height)

opentrons/protocol_engine/state/pipettes.py

@@ -125,6 +125,8 @@ class PipetteState:
     flow_rates_by_id: Dict[str, FlowRates]
     nozzle_configuration_by_id: Dict[str, NozzleMap]
     liquid_presence_detection_by_id: Dict[str, bool]
+    ready_to_aspirate_by_id: Dict[str, bool]
+    has_clean_tips_by_id: Dict[str, bool]
 
 
 class PipetteStore(HasState[PipetteState], HandlesActions):
@@ -145,6 +147,8 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             flow_rates_by_id={},
             nozzle_configuration_by_id={},
             liquid_presence_detection_by_id={},
+            ready_to_aspirate_by_id={},
+            has_clean_tips_by_id={},
         )
 
     def handle_action(self, action: Action) -> None:
@@ -156,6 +160,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             self._update_pipette_nozzle_map(state_update)
             self._update_tip_state(state_update)
             self._update_volumes(state_update)
+            self._update_ready_for_aspirate(state_update)
 
         if isinstance(action, SetPipetteMovementSpeedAction):
             self._state.movement_speed_by_id[action.pipette_id] = action.speed
@@ -174,6 +179,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             )
             self._state.movement_speed_by_id[pipette_id] = None
             self._state.attached_tip_by_id[pipette_id] = None
+            self._state.ready_to_aspirate_by_id[pipette_id] = False
 
     def _update_tip_state(self, state_update: update_types.StateUpdate) -> None:
         if state_update.pipette_tip_state != update_types.NO_CHANGE:
@@ -209,6 +215,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
             else:
                 pipette_id = state_update.pipette_tip_state.pipette_id
                 self._state.attached_tip_by_id[pipette_id] = None
+                self._state.has_clean_tips_by_id[pipette_id] = False
 
                 static_config = self._state.static_config_by_id.get(pipette_id)
                 if static_config:
@@ -314,9 +321,23 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
                 state_update.pipette_nozzle_map.pipette_id
             ] = state_update.pipette_nozzle_map.nozzle_map
 
+    def _update_ready_for_aspirate(
+        self, state_update: update_types.StateUpdate
+    ) -> None:
+        if state_update.ready_to_aspirate != update_types.NO_CHANGE:
+            self._state.ready_to_aspirate_by_id[
+                state_update.ready_to_aspirate.pipette_id
+            ] = state_update.ready_to_aspirate.ready_to_aspirate
+
     def _update_volumes(self, state_update: update_types.StateUpdate) -> None:
         if state_update.pipette_aspirated_fluid == update_types.NO_CHANGE:
             return
+        # set the tip state to unclean, if an "empty" update has a clean_tip flag
+        # it will set it to true
+        self._state.has_clean_tips_by_id[
+            state_update.pipette_aspirated_fluid.pipette_id
+        ] = False
+
         if state_update.pipette_aspirated_fluid.type == "aspirated":
             self._update_aspirated(state_update.pipette_aspirated_fluid)
         elif state_update.pipette_aspirated_fluid.type == "ejected":
@@ -343,6 +364,7 @@ class PipetteStore(HasState[PipetteState], HandlesActions):
 
     def _update_empty(self, update: update_types.PipetteEmptyFluidUpdate) -> None:
         self._state.pipette_contents_by_id[update.pipette_id] = fluid_stack.FluidStack()
+        self._state.has_clean_tips_by_id[update.pipette_id] = update.clean_tip
 
     def _update_unknown(self, update: update_types.PipetteUnknownFluidUpdate) -> None:
         self._state.pipette_contents_by_id[update.pipette_id] = None
@@ -482,6 +504,29 @@ class PipetteView:
                 f"Pipette {pipette_id} not found; unable to get current volume."
             ) from e
 
+    def get_has_clean_tip(self, pipette_id: str) -> bool:
+        """Get if the tip of a pipette by ID is clean.
+
+        This is only true directly after a pick up tip, once any kind of aspirate happens
+        it is no longer clean
+
+        Returns:
+            True if the tip is clean
+            False if it is unclean
+
+        Raises:
+            PipetteNotLoadedError: pipette ID does not exist.
+            TipNotAttachedError: if no tip is attached to the pipette.
+        """
+        self.validate_tip_state(pipette_id, True)
+
+        try:
+            return self._state.has_clean_tips_by_id[pipette_id]
+        except KeyError as e:
+            raise errors.PipetteNotLoadedError(
+                f"Pipette {pipette_id} not found; unable to get current volume."
+            ) from e
+
     def get_liquid_dispensed_by_ejecting_volume(
         self, pipette_id: str, volume: float
     ) -> Optional[float]:
@@ -822,3 +867,12 @@ class PipetteView:
     ) -> float:
         """Get the plunger position provided for the given pipette id."""
         return self.get_config(pipette_id).plunger_positions[position_name]
+
+    def get_ready_to_aspirate(self, pipette_id: str) -> bool:
+        """Get if the provided pipette is ready to aspirate for the given pipette id."""
+        try:
+            return self._state.ready_to_aspirate_by_id[pipette_id]
+        except KeyError as e:
+            raise errors.PipetteNotLoadedError(
+                f"Pipette {pipette_id} not found; unable to determine if pipette ready to aspirate."
+            ) from e

opentrons/protocol_engine/state/state.py

@@ -374,7 +374,7 @@ class StateStore(StateView, ActionHandler):
         self._addressable_areas = AddressableAreaView(state.addressable_areas)
         self._labware = LabwareView(state.labware)
         self._pipettes = PipetteView(state.pipettes)
-        self._modules = ModuleView(state.modules)
+        self._modules = ModuleView(state=state.modules)
         self._liquid = LiquidView(state.liquids)
         self._liquid_classes = LiquidClassView(state.liquid_classes)
         self._tips = TipView(state.tips)

opentrons/protocol_engine/state/tips.py

@@ -110,6 +110,20 @@ class TipStore(HasState[TipState], HandlesActions):
                 self._state.column_by_labware_id[labware_id] = [
                     column for column in definition.ordering
                 ]
+        if state_update.batch_loaded_labware != update_types.NO_CHANGE:
+            for labware_id in state_update.batch_loaded_labware.new_locations_by_id:
+                definition = state_update.batch_loaded_labware.definitions_by_id[
+                    labware_id
+                ]
+                if definition.parameters.isTiprack:
+                    self._state.tips_by_labware_id[labware_id] = {
+                        well_name: TipRackWellState.CLEAN
+                        for column in definition.ordering
+                        for well_name in column
+                    }
+                    self._state.column_by_labware_id[labware_id] = [
+                        column for column in definition.ordering
+                    ]
 
     def _set_used_tips(self, pipette_id: str, well_name: str, labware_id: str) -> None:
         columns = self._state.column_by_labware_id.get(labware_id, [])