opentrons 8.1.0a0__py2.py3-none-any.whl → 8.2.0a0__py2.py3-none-any.whl

opentrons/protocol_api/core/engine/module_core.py

@@ -1,14 +1,13 @@
 """Protocol API module implementation logic."""
 from __future__ import annotations
 
-from typing import Optional, List
+from typing import Optional, List, Dict, Union
 
 from opentrons.hardware_control import SynchronousAdapter, modules as hw_modules
 from opentrons.hardware_control.modules.types import (
     ModuleModel,
     TemperatureStatus,
     MagneticStatus,
-    ThermocyclerStep,
     SpeedStatus,
     module_model_from_string,
 )
@@ -16,15 +15,18 @@ from opentrons.drivers.types import (
     HeaterShakerLabwareLatchStatus,
     ThermocyclerLidStatus,
 )
-from opentrons.types import DeckSlotName
+
 from opentrons.protocol_engine import commands as cmd
+from opentrons.protocol_engine.types import ABSMeasureMode
+from opentrons.types import DeckSlotName
 from opentrons.protocol_engine.clients import SyncClient as ProtocolEngineClient
 from opentrons.protocol_engine.errors.exceptions import (
     LabwareNotLoadedOnModuleError,
     NoMagnetEngageHeightError,
+    CannotPerformModuleAction,
 )
 
-from opentrons.protocols.api_support.types import APIVersion
+from opentrons.protocols.api_support.types import APIVersion, ThermocyclerStep
 
 from ... import validation
 from ..module import (
@@ -324,15 +326,13 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore):
             cmd.thermocycler.WaitForLidTemperatureParams(moduleId=self.module_id)
         )
 
-    def execute_profile(
+    def _execute_profile_pre_221(
         self,
         steps: List[ThermocyclerStep],
         repetitions: int,
-        block_max_volume: Optional[float] = None,
+        block_max_volume: Optional[float],
     ) -> None:
-        """Execute a Thermocycler Profile."""
-        self._repetitions = repetitions
-        self._step_count = len(steps)
+        """Execute a thermocycler profile using thermocycler/runProfile and flattened steps."""
         engine_steps = [
             cmd.thermocycler.RunProfileStepParams(
                 celsius=step["temperature"],
@@ -349,6 +349,49 @@ class ThermocyclerModuleCore(ModuleCore, AbstractThermocyclerCore):
             )
         )
 
+    def _execute_profile_post_221(
+        self,
+        steps: List[ThermocyclerStep],
+        repetitions: int,
+        block_max_volume: Optional[float],
+    ) -> None:
+        """Execute a thermocycler profile using thermocycler/runExtendedProfile."""
+        engine_steps: List[
+            Union[cmd.thermocycler.ProfileCycle, cmd.thermocycler.ProfileStep]
+        ] = [
+            cmd.thermocycler.ProfileCycle(
+                repetitions=repetitions,
+                steps=[
+                    cmd.thermocycler.ProfileStep(
+                        celsius=step["temperature"],
+                        holdSeconds=step["hold_time_seconds"],
+                    )
+                    for step in steps
+                ],
+            )
+        ]
+        self._engine_client.execute_command(
+            cmd.thermocycler.RunExtendedProfileParams(
+                moduleId=self.module_id,
+                profileElements=engine_steps,
+                blockMaxVolumeUl=block_max_volume,
+            )
+        )
+
+    def execute_profile(
+        self,
+        steps: List[ThermocyclerStep],
+        repetitions: int,
+        block_max_volume: Optional[float] = None,
+    ) -> None:
+        """Execute a Thermocycler Profile."""
+        self._repetitions = repetitions
+        self._step_count = len(steps)
+        if self.api_version >= APIVersion(2, 21):
+            return self._execute_profile_post_221(steps, repetitions, block_max_volume)
+        else:
+            return self._execute_profile_pre_221(steps, repetitions, block_max_volume)
+
     def deactivate_lid(self) -> None:
         """Turn off the heated lid."""
         self._engine_client.execute_command(
@@ -523,23 +566,92 @@ class AbsorbanceReaderCore(ModuleCore, AbstractAbsorbanceReaderCore):
     """Absorbance Reader core logic implementation for Python protocols."""
 
     _sync_module_hardware: SynchronousAdapter[hw_modules.AbsorbanceReader]
-    _initialized_value: Optional[int] = None
+    _initialized_value: Optional[List[int]] = None
+    _ready_to_initialize: bool = False
 
-    def initialize(self, wavelength: int) -> None:
+    def initialize(
+        self,
+        mode: ABSMeasureMode,
+        wavelengths: List[int],
+        reference_wavelength: Optional[int] = None,
+    ) -> None:
         """Initialize the Absorbance Reader by taking zero reading."""
+        if not self._ready_to_initialize:
+            raise CannotPerformModuleAction(
+                "Cannot perform Initialize action on Absorbance Reader without calling `.close_lid()` first."
+            )
+
+        # TODO: check that the wavelengths are within the supported wavelengths
         self._engine_client.execute_command(
             cmd.absorbance_reader.InitializeParams(
                 moduleId=self.module_id,
-                sampleWavelength=wavelength,
+                measureMode=mode,
+                sampleWavelengths=wavelengths,
+                referenceWavelength=reference_wavelength,
             ),
         )
-        self._initialized_value = wavelength
+        self._initialized_value = wavelengths
 
-    def initiate_read(self) -> None:
-        """Initiate read on the Absorbance Reader."""
+    def read(self, filename: Optional[str] = None) -> Dict[int, Dict[str, float]]:
+        """Initiate a read on the Absorbance Reader, and return the results. During Analysis, this will return a measurement of zero for all wells."""
+        wavelengths = self._engine_client.state.modules.get_absorbance_reader_substate(
+            self.module_id
+        ).configured_wavelengths
+        if wavelengths is None:
+            raise CannotPerformModuleAction(
+                "Cannot perform Read action on Absorbance Reader without calling `.initialize(...)` first."
+            )
         if self._initialized_value:
             self._engine_client.execute_command(
-                cmd.absorbance_reader.MeasureAbsorbanceParams(
-                    moduleId=self.module_id, sampleWavelength=self._initialized_value
+                cmd.absorbance_reader.ReadAbsorbanceParams(
+                    moduleId=self.module_id, fileName=filename
                 )
             )
+        if not self._engine_client.state.config.use_virtual_modules:
+            read_result = (
+                self._engine_client.state.modules.get_absorbance_reader_substate(
+                    self.module_id
+                ).data
+            )
+            if read_result is not None:
+                return read_result
+            raise CannotPerformModuleAction(
+                "Absorbance Reader failed to return expected read result."
+            )
+
+        # When using virtual modules, return all zeroes
+        virtual_asbsorbance_result: Dict[int, Dict[str, float]] = {}
+        for wavelength in wavelengths:
+            converted_values = (
+                self._engine_client.state.modules.convert_absorbance_reader_data_points(
+                    data=[0] * 96
+                )
+            )
+            virtual_asbsorbance_result[wavelength] = converted_values
+        return virtual_asbsorbance_result
+
+    def close_lid(
+        self,
+    ) -> None:
+        """Close the Absorbance Reader's lid."""
+        self._engine_client.execute_command(
+            cmd.absorbance_reader.CloseLidParams(
+                moduleId=self.module_id,
+            )
+        )
+        self._ready_to_initialize = True
+
+    def open_lid(self) -> None:
+        """Close the Absorbance Reader's lid."""
+        self._engine_client.execute_command(
+            cmd.absorbance_reader.OpenLidParams(
+                moduleId=self.module_id,
+            )
+        )
+
+    def is_lid_on(self) -> bool:
+        """Returns True if the Absorbance Reader's lid is currently on the Reader slot."""
+        abs_state = self._engine_client.state.modules.get_absorbance_reader_substate(
+            self.module_id
+        )
+        return abs_state.is_lid_on

opentrons/protocol_api/core/engine/pipette_movement_conflict.py

@@ -0,0 +1,355 @@
+"""A Protocol-Engine-friendly wrapper for opentrons.motion_planning.deck_conflict."""
+from __future__ import annotations
+import logging
+from typing import (
+    Optional,
+    Tuple,
+    Union,
+    List,
+)
+
+from opentrons_shared_data.errors.exceptions import MotionPlanningFailureError
+from opentrons_shared_data.module import FLEX_TC_LID_COLLISION_ZONE
+
+from opentrons.hardware_control import CriticalPoint
+from opentrons.motion_planning import adjacent_slots_getters
+
+from opentrons.protocol_engine import (
+    StateView,
+    DeckSlotLocation,
+    OnLabwareLocation,
+    WellLocation,
+    LiquidHandlingWellLocation,
+    PickUpTipWellLocation,
+    DropTipWellLocation,
+)
+from opentrons.protocol_engine.types import (
+    StagingSlotLocation,
+)
+from opentrons.types import DeckSlotName, StagingSlotName, Point
+from . import point_calculations
+
+
+class PartialTipMovementNotAllowedError(MotionPlanningFailureError):
+    """Error raised when trying to perform a partial tip movement to an illegal location."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message=message,
+        )
+
+
+class UnsuitableTiprackForPipetteMotion(MotionPlanningFailureError):
+    """Error raised when trying to perform a pipette movement to a tip rack, based on adapter status."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message=message,
+        )
+
+
+_log = logging.getLogger(__name__)
+
+_FLEX_TC_LID_BACK_LEFT_PT = Point(
+    x=FLEX_TC_LID_COLLISION_ZONE["back_left"]["x"],
+    y=FLEX_TC_LID_COLLISION_ZONE["back_left"]["y"],
+    z=FLEX_TC_LID_COLLISION_ZONE["back_left"]["z"],
+)
+
+_FLEX_TC_LID_FRONT_RIGHT_PT = Point(
+    x=FLEX_TC_LID_COLLISION_ZONE["front_right"]["x"],
+    y=FLEX_TC_LID_COLLISION_ZONE["front_right"]["y"],
+    z=FLEX_TC_LID_COLLISION_ZONE["front_right"]["z"],
+)
+
+
+def check_safe_for_pipette_movement(
+    engine_state: StateView,
+    pipette_id: str,
+    labware_id: str,
+    well_name: str,
+    well_location: Union[
+        WellLocation,
+        LiquidHandlingWellLocation,
+        PickUpTipWellLocation,
+        DropTipWellLocation,
+    ],
+) -> None:
+    """Check if the labware is safe to move to with a pipette in partial tip configuration.
+
+    Args:
+        engine_state: engine state view
+        pipette_id: ID of the pipette to be moved
+        labware_id: ID of the labware we are moving to
+        well_name: Name of the well to move to
+        well_location: exact location within the well to move to
+    """
+    # TODO (spp, 2023-02-06): remove this check after thorough testing.
+    #  This function is capable of checking for movement conflict regardless of
+    #  nozzle configuration.
+    if not engine_state.pipettes.get_is_partially_configured(pipette_id):
+        return
+
+    if isinstance(well_location, DropTipWellLocation):
+        # convert to WellLocation
+        well_location = engine_state.geometry.get_checked_tip_drop_location(
+            pipette_id=pipette_id,
+            labware_id=labware_id,
+            well_location=well_location,
+            partially_configured=True,
+        )
+    well_location_point = engine_state.geometry.get_well_position(
+        labware_id=labware_id, well_name=well_name, well_location=well_location
+    )
+    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,
+            destination_position=well_location_point,
+            critical_point=destination_cp,
+        )
+    )
+    if not _is_within_pipette_extents(
+        engine_state=engine_state,
+        pipette_id=pipette_id,
+        pipette_bounding_box_at_loc=pipette_bounds_at_well_location,
+    ):
+        raise PartialTipMovementNotAllowedError(
+            f"Requested motion with the {primary_nozzle} nozzle partial configuration"
+            f" is outside of robot bounds for the pipette."
+        )
+
+    labware_slot = engine_state.geometry.get_ancestor_slot_name(labware_id)
+
+    surrounding_slots = adjacent_slots_getters.get_surrounding_slots(
+        slot=labware_slot.as_int(), robot_type=engine_state.config.robot_type
+    )
+
+    if _will_collide_with_thermocycler_lid(
+        engine_state=engine_state,
+        pipette_bounds=pipette_bounds_at_well_location,
+        surrounding_regular_slots=surrounding_slots.regular_slots,
+    ):
+        raise PartialTipMovementNotAllowedError(
+            f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
+            f" {labware_slot} with {primary_nozzle} nozzle partial configuration"
+            f" will result in collision with thermocycler lid in deck slot A1."
+        )
+
+    for regular_slot in surrounding_slots.regular_slots:
+        if _slot_has_potential_colliding_object(
+            engine_state=engine_state,
+            pipette_bounds=pipette_bounds_at_well_location,
+            surrounding_slot=regular_slot,
+        ):
+            raise PartialTipMovementNotAllowedError(
+                f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
+                f" {labware_slot} with {primary_nozzle} nozzle partial configuration"
+                f" will result in collision with items in deck slot {regular_slot}."
+            )
+    for staging_slot in surrounding_slots.staging_slots:
+        if _slot_has_potential_colliding_object(
+            engine_state=engine_state,
+            pipette_bounds=pipette_bounds_at_well_location,
+            surrounding_slot=staging_slot,
+        ):
+            raise PartialTipMovementNotAllowedError(
+                f"Moving to {engine_state.labware.get_display_name(labware_id)} in slot"
+                f" {labware_slot} with {primary_nozzle} nozzle partial configuration"
+                f" will result in collision with items in staging slot {staging_slot}."
+            )
+
+
+def _get_critical_point_to_use(
+    engine_state: StateView, labware_id: str
+) -> Optional[CriticalPoint]:
+    """Return the critical point to use when accessing the given labware."""
+    # TODO (spp, 2024-09-17): looks like Y_CENTER of column is the same as its XY_CENTER.
+    #   I'm using this if-else ladder to be consistent with what we do in
+    #   `MotionPlanning.get_movement_waypoints_to_well()`.
+    #   We should probably use only XY_CENTER in both places.
+    if engine_state.labware.get_should_center_column_on_target_well(labware_id):
+        return CriticalPoint.Y_CENTER
+    elif engine_state.labware.get_should_center_pipette_on_target_well(labware_id):
+        return CriticalPoint.XY_CENTER
+    return None
+
+
+def _slot_has_potential_colliding_object(
+    engine_state: StateView,
+    pipette_bounds: Tuple[Point, Point, Point, Point],
+    surrounding_slot: Union[DeckSlotName, StagingSlotName],
+) -> bool:
+    """Return the slot, if any, that has an item that the pipette might collide into."""
+    # Check if slot overlaps with pipette position
+    slot_pos = engine_state.addressable_areas.get_addressable_area_position(
+        addressable_area_name=surrounding_slot.id,
+        do_compatibility_check=False,
+    )
+    slot_bounds = engine_state.addressable_areas.get_addressable_area_bounding_box(
+        addressable_area_name=surrounding_slot.id,
+        do_compatibility_check=False,
+    )
+    slot_back_left_coords = Point(slot_pos.x, slot_pos.y + slot_bounds.y, slot_pos.z)
+    slot_front_right_coords = Point(slot_pos.x + slot_bounds.x, slot_pos.y, slot_pos.z)
+
+    # If slot overlaps with pipette bounds
+    if point_calculations.are_overlapping_rectangles(
+        rectangle1=(pipette_bounds[0], pipette_bounds[1]),
+        rectangle2=(slot_back_left_coords, slot_front_right_coords),
+    ):
+        # Check z-height of items in overlapping slot
+        if isinstance(surrounding_slot, DeckSlotName):
+            slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
+                DeckSlotLocation(slotName=surrounding_slot)
+            )
+        else:
+            slot_highest_z = engine_state.geometry.get_highest_z_in_slot(
+                StagingSlotLocation(slotName=surrounding_slot)
+            )
+        return slot_highest_z >= pipette_bounds[0].z
+    return False
+
+
+def _will_collide_with_thermocycler_lid(
+    engine_state: StateView,
+    pipette_bounds: Tuple[Point, Point, Point, Point],
+    surrounding_regular_slots: List[DeckSlotName],
+) -> bool:
+    """Return whether the pipette might collide with thermocycler's lid/clips on a Flex.
+
+    If any of the pipette's bounding vertices lie inside the no-go zone of the thermocycler-
+    which is the area that's to the left, back and below the thermocycler's lid's
+    protruding clips, then we will mark the movement for possible collision.
+
+    This could cause false raises for the case where an 8-channel is accessing the
+    thermocycler labware in a location such that the pipette is in the area between
+    the clips but not touching either clips. But that's a tradeoff we'll need to make
+    between a complicated check involving accurate positions of all entities involved
+    and a crude check that disallows all partial tip movements around the thermocycler.
+    """
+    # TODO (spp, 2024-02-27): Improvements:
+    #  - make the check dynamic according to lid state:
+    #     - if lid is open, check if pipette is in no-go zone
+    #     - if lid is closed, use the closed lid height to check for conflict
+    if (
+        DeckSlotName.SLOT_A1 in surrounding_regular_slots
+        and engine_state.modules.is_flex_deck_with_thermocycler()
+    ):
+        return (
+            point_calculations.are_overlapping_rectangles(
+                rectangle1=(_FLEX_TC_LID_BACK_LEFT_PT, _FLEX_TC_LID_FRONT_RIGHT_PT),
+                rectangle2=(pipette_bounds[0], pipette_bounds[1]),
+            )
+            and pipette_bounds[0].z <= _FLEX_TC_LID_BACK_LEFT_PT.z
+        )
+
+    return False
+
+
+def check_safe_for_tip_pickup_and_return(
+    engine_state: StateView,
+    pipette_id: str,
+    labware_id: str,
+) -> None:
+    """Check if the presence or absence of a tiprack adapter might cause any pipette movement issues.
+
+    A 96 channel pipette will pick up tips using cam action when it's configured
+    to use ALL nozzles. For this, the tiprack needs to be on the Flex 96 channel tiprack adapter
+    or similar or the tips will not be picked up.
+
+    On the other hand, if the pipette is configured with partial nozzle configuration,
+    it uses the usual pipette presses to pick the tips up, in which case, having the tiprack
+    on the Flex 96 channel tiprack adapter (or similar) will cause the pipette to
+    crash against the adapter posts.
+
+    In order to check if the 96-channel can move and pickup/drop tips safely, this method
+    checks for the height attribute of the tiprack adapter rather than checking for the
+    specific official adapter since users might create custom labware &/or definitions
+    compatible with the official adapter.
+    """
+    if not engine_state.pipettes.get_channels(pipette_id) == 96:
+        # Adapters only matter to 96 ch.
+        return
+
+    is_partial_config = engine_state.pipettes.get_is_partially_configured(pipette_id)
+    tiprack_name = engine_state.labware.get_display_name(labware_id)
+    tiprack_parent = engine_state.labware.get_location(labware_id)
+    if isinstance(tiprack_parent, OnLabwareLocation):  # tiprack is on an adapter
+        is_96_ch_tiprack_adapter = engine_state.labware.get_has_quirk(
+            labware_id=tiprack_parent.labwareId, quirk="tiprackAdapterFor96Channel"
+        )
+        tiprack_height = engine_state.labware.get_dimensions(labware_id).z
+        adapter_height = engine_state.labware.get_dimensions(tiprack_parent.labwareId).z
+        if is_partial_config and tiprack_height < adapter_height:
+            raise PartialTipMovementNotAllowedError(
+                f"{tiprack_name} cannot be on an adapter taller than the tip rack"
+                f" when picking up fewer than 96 tips."
+            )
+        elif not is_partial_config and not is_96_ch_tiprack_adapter:
+            raise UnsuitableTiprackForPipetteMotion(
+                f"{tiprack_name} must be on an Opentrons Flex 96 Tip Rack Adapter"
+                f" in order to pick up or return all 96 tips simultaneously."
+            )
+
+    elif (
+        not is_partial_config
+    ):  # tiprack is not on adapter and pipette is in full config
+        raise UnsuitableTiprackForPipetteMotion(
+            f"{tiprack_name} must be on an Opentrons Flex 96 Tip Rack Adapter"
+            f" in order to pick up or return all 96 tips simultaneously."
+        )
+
+
+def _is_within_pipette_extents(
+    engine_state: StateView,
+    pipette_id: str,
+    pipette_bounding_box_at_loc: Tuple[Point, Point, Point, Point],
+) -> bool:
+    """Whether a given point is within the extents of a configured pipette on the specified robot."""
+    channels = engine_state.pipettes.get_channels(pipette_id)
+    robot_extents = engine_state.geometry.absolute_deck_extents
+    (
+        pip_back_left_bound,
+        pip_front_right_bound,
+        pip_back_right_bound,
+        pip_front_left_bound,
+    ) = pipette_bounding_box_at_loc
+
+    # Given the padding values accounted for against the deck extents,
+    # a pipette is within extents when all of the following are true:
+
+    # Each corner slot full pickup case:
+    # A1: Front right nozzle is within the rear and left-side padding limits
+    # D1: Back right nozzle is within the front and left-side padding limits
+    # A3 Front left nozzle is within the rear and right-side padding limits
+    # D3: Back left nozzle is within the front and right-side padding limits
+    # Thermocycler Column A2: Front right nozzle is within padding limits
+
+    if channels == 96:
+        return (
+            pip_front_right_bound.y
+            <= robot_extents.deck_extents.y + robot_extents.padding_rear
+            and pip_front_right_bound.x >= robot_extents.padding_left_side
+            and pip_back_right_bound.y >= robot_extents.padding_front
+            and pip_back_right_bound.x >= robot_extents.padding_left_side
+            and pip_front_left_bound.y
+            <= robot_extents.deck_extents.y + robot_extents.padding_rear
+            and pip_front_left_bound.x
+            <= robot_extents.deck_extents.x + robot_extents.padding_right_side
+            and pip_back_left_bound.y >= robot_extents.padding_front
+            and pip_back_left_bound.x
+            <= robot_extents.deck_extents.x + robot_extents.padding_right_side
+        )
+    # For 8ch pipettes we only check the rear and front extents
+    return (
+        pip_front_right_bound.y
+        <= robot_extents.deck_extents.y + robot_extents.padding_rear
+        and pip_back_right_bound.y >= robot_extents.padding_front
+        and pip_front_left_bound.y
+        <= robot_extents.deck_extents.y + robot_extents.padding_rear
+        and pip_back_left_bound.y >= robot_extents.padding_front
+    )

opentrons/protocol_api/core/engine/protocol.py

@@ -2,11 +2,17 @@
 from __future__ import annotations
 from typing import Dict, Optional, Type, Union, List, Tuple, TYPE_CHECKING
 
+from opentrons_shared_data.liquid_classes import LiquidClassDefinitionDoesNotExist
+
 from opentrons.protocol_engine import commands as cmd
 from opentrons.protocol_engine.commands import LoadModuleResult
 from opentrons_shared_data.deck.types import DeckDefinitionV5, SlotDefV3
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 from opentrons_shared_data.labware.types import LabwareDefinition as LabwareDefDict
+from opentrons_shared_data import liquid_classes
+from opentrons_shared_data.liquid_classes.liquid_class_definition import (
+    LiquidClassSchemaV1,
+)
 from opentrons_shared_data.pipette.types import PipetteNameType
 from opentrons_shared_data.robot.types import RobotType
 
@@ -51,7 +57,7 @@ from opentrons.protocol_engine.errors import (
 
 from ... import validation
 from ..._types import OffDeckType
-from ..._liquid import Liquid
+from ..._liquid import Liquid, LiquidClass
 from ...disposal_locations import TrashBin, WasteChute
 from ..protocol import AbstractProtocol
 from ..labware import LabwareLoadParams
@@ -103,6 +109,7 @@ class ProtocolCore(
             str, Union[ModuleCore, NonConnectedModuleCore]
         ] = {}
         self._disposal_locations: List[Union[Labware, TrashBin, WasteChute]] = []
+        self._defined_liquid_class_defs_by_name: Dict[str, LiquidClassSchemaV1] = {}
         self._load_fixed_trash()
 
     @property
@@ -311,7 +318,6 @@ class ProtocolCore(
 
         return labware_core
 
-    # TODO (spp, 2022-12-14): https://opentrons.atlassian.net/browse/RLAB-237
     def move_labware(
         self,
         labware_core: LabwareCore,
@@ -441,10 +447,40 @@ class ProtocolCore(
             existing_module_ids=list(self._module_cores_by_id.keys()),
         )
 
+        # When the protocol engine is created, we add Module Lids as part of the deck fixed labware
+        # If a valid module exists in the deck config. For analysis, we add the labware here since
+        # deck fixed labware is not created under the same conditions. We also need to inject the Module
+        # lids when the module isnt already on the deck config, like when adding a new
+        # module during a protocol setup.
+        self._load_virtual_module_lid(module_core)
+
         self._module_cores_by_id[module_core.module_id] = module_core
 
         return module_core
 
+    def _load_virtual_module_lid(
+        self, module_core: Union[ModuleCore, NonConnectedModuleCore]
+    ) -> None:
+        if isinstance(module_core, AbsorbanceReaderCore):
+            substate = self._engine_client.state.modules.get_absorbance_reader_substate(
+                module_core.module_id
+            )
+            if substate.lid_id is None:
+                lid = self._engine_client.execute_command_without_recovery(
+                    cmd.LoadLabwareParams(
+                        loadName="opentrons_flex_lid_absorbance_plate_reader_module",
+                        location=ModuleLocation(moduleId=module_core.module_id),
+                        namespace="opentrons",
+                        version=1,
+                        displayName="Absorbance Reader Lid",
+                    )
+                )
+
+                self._engine_client.add_absorbance_reader_lid(
+                    module_id=module_core.module_id,
+                    lid_id=lid.labwareId,
+                )
+
     def _create_non_connected_module_core(
         self, load_module_result: LoadModuleResult
     ) -> NonConnectedModuleCore:
@@ -723,6 +759,23 @@ class ProtocolCore(
             ),
         )
 
+    def define_liquid_class(self, name: str) -> LiquidClass:
+        """Define a liquid class for use in transfer functions."""
+        try:
+            # Check if we have already loaded this liquid class' definition
+            liquid_class_def = self._defined_liquid_class_defs_by_name[name]
+        except KeyError:
+            try:
+                # Fetching the liquid class data from file and parsing it
+                # is an expensive operation and should be avoided.
+                # Calling this often will degrade protocol execution performance.
+                liquid_class_def = liquid_classes.load_definition(name)
+                self._defined_liquid_class_defs_by_name[name] = liquid_class_def
+            except LiquidClassDefinitionDoesNotExist:
+                raise ValueError(f"Liquid class definition not found for '{name}'.")
+
+        return LiquidClass.create(liquid_class_def)
+
     def get_labware_location(
         self, labware_core: LabwareCore
     ) -> Union[str, LabwareCore, ModuleCore, NonConnectedModuleCore, OffDeckType]:

opentrons/protocol_api/core/instrument.py

@@ -33,6 +33,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         rate: float,
         flow_rate: float,
         in_place: bool,
+        is_meniscus: Optional[bool] = None,
     ) -> None:
         """Aspirate a given volume of liquid from the specified location.
         Args:
@@ -55,6 +56,7 @@ class AbstractInstrument(ABC, Generic[WellCoreType]):
         flow_rate: float,
         in_place: bool,
         push_out: Optional[float],
+        is_meniscus: Optional[bool] = None,
     ) -> None:
         """Dispense a given volume of liquid into the specified location.
         Args: