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

opentrons/protocol_api/validation.py

@@ -11,7 +11,7 @@ from typing import (
     NamedTuple,
     TYPE_CHECKING,
 )
-
+from math import isinf, isnan
 from typing_extensions import TypeGuard
 
 from opentrons_shared_data.labware.labware_definition import LabwareRole
@@ -21,7 +21,16 @@ from opentrons_shared_data.robot.types import RobotType
 from opentrons.protocols.api_support.types import APIVersion, ThermocyclerStep
 from opentrons.protocols.api_support.util import APIVersionError
 from opentrons.protocols.models import LabwareDefinition
-from opentrons.types import Mount, DeckSlotName, StagingSlotName, Location
+from opentrons.protocols.advanced_control.transfers.common import TransferTipPolicyV2
+from opentrons.types import (
+    Mount,
+    DeckSlotName,
+    StagingSlotName,
+    Location,
+    AxisType,
+    AxisMapType,
+    StringAxisMap,
+)
 from opentrons.hardware_control.modules.types import (
     ModuleModel,
     MagneticModuleModel,
@@ -44,6 +53,9 @@ _COORDINATE_DECK_LABEL_VERSION_GATE = APIVersion(2, 15)
 # The first APIVersion where Python protocols can specify staging deck slots (e.g. "D4")
 _STAGING_DECK_SLOT_VERSION_GATE = APIVersion(2, 16)
 
+# The first APIVersion where Python protocols can load lids as stacks and treat them as attributes of a parent labware.
+LID_STACK_VERSION_GATE = APIVersion(2, 23)
+
 # Mapping of public Python Protocol API pipette load names
 # to names used by the internal Opentrons system
 _PIPETTE_NAMES_MAP = {
@@ -65,6 +77,7 @@ _PIPETTE_NAMES_MAP = {
     "flex_8channel_1000": PipetteNameType.P1000_MULTI_FLEX,
     "flex_8channel_1000_em": PipetteNameType.P1000_MULTI_EM,
     "flex_96channel_1000": PipetteNameType.P1000_96,
+    "flex_96channel_200": PipetteNameType.P200_96,
 }
 
 
@@ -76,6 +89,14 @@ class PipetteMountTypeError(TypeError):
     """An error raised when an invalid mount type is used for loading pipettes."""
 
 
+class InstrumentMountTypeError(TypeError):
+    """An error raised when an invalid mount type is used for any available instruments."""
+
+
+class IncorrectAxisError(TypeError):
+    """An error raised when an invalid axis key is provided in an axis map."""
+
+
 class LabwareDefinitionIsNotAdapterError(ValueError):
     """An error raised when an adapter is attempted to be loaded as a labware."""
 
@@ -96,7 +117,7 @@ def ensure_mount_for_pipette(
     mount: Union[str, Mount, None], pipette: PipetteNameType
 ) -> Mount:
     """Ensure that an input value represents a valid mount, and is valid for the given pipette."""
-    if pipette == PipetteNameType.P1000_96:
+    if pipette in [PipetteNameType.P1000_96, PipetteNameType.P200_96]:
         # Always validate the raw mount input, even if the pipette is a 96-channel and we're not going
         # to use the mount value.
         if mount is not None:
@@ -147,6 +168,25 @@ def _ensure_mount(mount: Union[str, Mount]) -> Mount:
     )
 
 
+def ensure_instrument_mount(mount: Union[str, Mount]) -> Mount:
+    """Ensure that an input value represents a valid Mount for all instruments."""
+    if isinstance(mount, Mount):
+        return mount
+
+    if isinstance(mount, str):
+        if mount == "gripper":
+            # TODO (lc 08-02-2024) We should decide on the user facing name for
+            # the gripper mount axis.
+            mount = "extension"
+        try:
+            return Mount[mount.upper()]
+        except KeyError as e:
+            raise InstrumentMountTypeError(
+                "If mount is specified as a string, it must be 'left', 'right', 'gripper', or 'extension';"
+                f" instead, {mount} was given."
+            ) from e
+
+
 def ensure_pipette_name(pipette_name: str) -> PipetteNameType:
     """Ensure that an input value represents a valid pipette name."""
     pipette_name = ensure_lowercase_name(pipette_name)
@@ -159,6 +199,79 @@ def ensure_pipette_name(pipette_name: str) -> PipetteNameType:
         ) from None
 
 
+def _check_ot2_axis_type(
+    robot_type: RobotType, axis_map_keys: Union[List[str], List[AxisType]]
+) -> None:
+    if robot_type == "OT-2 Standard" and isinstance(axis_map_keys[0], AxisType):
+        if any(k not in AxisType.ot2_axes() for k in axis_map_keys):
+            raise IncorrectAxisError(
+                f"An OT-2 Robot only accepts the following axes {AxisType.ot2_axes()}"
+            )
+    if robot_type == "OT-2 Standard" and isinstance(axis_map_keys[0], str):
+        if any(k.upper() not in [axis.value for axis in AxisType.ot2_axes()] for k in axis_map_keys):  # type: ignore [union-attr]
+            raise IncorrectAxisError(
+                f"An OT-2 Robot only accepts the following axes {AxisType.ot2_axes()}"
+            )
+
+
+def _check_96_channel_axis_type(
+    is_96_channel: bool, axis_map_keys: Union[List[str], List[AxisType]]
+) -> None:
+    if is_96_channel and any(
+        key_variation in axis_map_keys for key_variation in ["Z_R", "z_r", AxisType.Z_R]
+    ):
+        raise IncorrectAxisError(
+            "A 96 channel is attached. You cannot move the `Z_R` mount."
+        )
+    if not is_96_channel and any(
+        key_variation in axis_map_keys for key_variation in ["Q", "q", AxisType.Q]
+    ):
+        raise IncorrectAxisError(
+            "A 96 channel is not attached. The clamp `Q` motor does not exist."
+        )
+
+
+def ensure_axis_map_type(
+    axis_map: Union[AxisMapType, StringAxisMap],
+    robot_type: RobotType,
+    is_96_channel: bool = False,
+) -> AxisMapType:
+    """Ensure that the axis map provided is in the correct shape and contains the correct keys."""
+    axis_map_keys: Union[List[str], List[AxisType]] = list(axis_map.keys())  # type: ignore
+    key_type = set(type(k) for k in axis_map_keys)
+
+    if len(key_type) > 1:
+        raise IncorrectAxisError(
+            "Please provide an `axis_map` with only string or only AxisType keys."
+        )
+    _check_ot2_axis_type(robot_type, axis_map_keys)
+    _check_96_channel_axis_type(is_96_channel, axis_map_keys)
+
+    if all(isinstance(k, AxisType) for k in axis_map_keys):
+        return_map: AxisMapType = axis_map  # type: ignore
+        return return_map
+    try:
+        return {AxisType[k.upper()]: v for k, v in axis_map.items()}  # type: ignore [union-attr]
+    except KeyError as e:
+        raise IncorrectAxisError(f"{e} is not a supported `AxisMapType`")
+
+
+def ensure_only_gantry_axis_map_type(
+    axis_map: AxisMapType, robot_type: RobotType
+) -> None:
+    """Ensure that the axis map provided is in the correct shape and matches the gantry axes for the robot."""
+    if robot_type == "OT-2 Standard":
+        if any(k not in AxisType.ot2_gantry_axes() for k in axis_map.keys()):
+            raise IncorrectAxisError(
+                f"A critical point only accepts OT-2 gantry axes which are {AxisType.ot2_gantry_axes()}"
+            )
+    else:
+        if any(k not in AxisType.flex_gantry_axes() for k in axis_map.keys()):
+            raise IncorrectAxisError(
+                f"A critical point only accepts Flex gantry axes which are {AxisType.flex_gantry_axes()}"
+            )
+
+
 # TODO(jbl 11-17-2023) this function's original purpose was ensure a valid deck slot for a given robot type
 #   With deck configuration, the shape of this should change to better represent it checking if a deck slot
 #   (and maybe any addressable area) being valid for that deck configuration
@@ -254,6 +367,27 @@ def ensure_definition_is_labware(definition: LabwareDefinition) -> None:
         )
 
 
+def ensure_definition_is_lid(definition: LabwareDefinition) -> None:
+    """Ensure that one of the definition's allowed roles is `lid` or that that field is empty."""
+    if LabwareRole.lid not in definition.allowedRoles:
+        raise LabwareDefinitionIsNotLabwareError(
+            f"Labware {definition.parameters.loadName} is not a lid."
+        )
+
+
+def ensure_definition_is_not_lid_after_api_version(
+    api_version: APIVersion, definition: LabwareDefinition
+) -> None:
+    """Ensure that one of the definition's allowed roles is not `lid` or that the API Version is below the release where lid loading was seperated."""
+    if (
+        LabwareRole.lid in definition.allowedRoles
+        and api_version >= LID_STACK_VERSION_GATE
+    ):
+        raise APIVersionError(
+            f"Labware Lids cannot be loaded like standard labware in Protocols written with an API version greater than {LID_STACK_VERSION_GATE}."
+        )
+
+
 _MODULE_ALIASES: Dict[str, ModuleModel] = {
     "magdeck": MagneticModuleModel.MAGNETIC_V1,
     "magnetic module": MagneticModuleModel.MAGNETIC_V1,
@@ -484,3 +618,127 @@ def validate_location(
         if well is not None
         else PointTarget(location=target_location, in_place=in_place)
     )
+
+
+def ensure_boolean(value: bool) -> bool:
+    """Ensure value is a boolean."""
+    if not isinstance(value, bool):
+        raise ValueError("Value must be a boolean.")
+    return value
+
+
+def ensure_float(value: Union[int, float]) -> float:
+    """Ensure value is a float (or an integer) and return it as a float."""
+    if not isinstance(value, (int, float)):
+        raise ValueError("Value must be a floating point number.")
+    return float(value)
+
+
+def ensure_positive_float(value: Union[int, float]) -> float:
+    """Ensure value is a positive and real float value."""
+    float_value = ensure_float(value)
+    if isnan(float_value) or isinf(float_value):
+        raise ValueError("Value must be a defined, non-infinite number.")
+    if float_value < 0:
+        raise ValueError("Value must be a positive float.")
+    return float_value
+
+
+def ensure_positive_int(value: int) -> int:
+    """Ensure value is a positive integer."""
+    if not isinstance(value, int):
+        raise ValueError("Value must be an integer.")
+    if value < 0:
+        raise ValueError("Value must be a positive integer.")
+    return value
+
+
+def validate_coordinates(value: Sequence[float]) -> Tuple[float, float, float]:
+    """Ensure value is a valid sequence of 3 floats and return a tuple of 3 floats."""
+    if len(value) != 3:
+        raise ValueError("Coordinates must be a sequence of exactly three numbers")
+    if not all(isinstance(v, (float, int)) for v in value):
+        raise ValueError("All values in coordinates must be floats.")
+    return float(value[0]), float(value[1]), float(value[2])
+
+
+def ensure_new_tip_policy(value: str) -> TransferTipPolicyV2:
+    """Ensure that new_tip value is a valid TransferTipPolicy value."""
+    try:
+        return TransferTipPolicyV2(value.lower())
+    except ValueError:
+        raise ValueError(
+            f"'{value}' is invalid value for 'new_tip'."
+            f" Acceptable value is either 'never', 'once', 'always' or 'per source'."
+        )
+
+
+def _verify_each_list_element_is_valid_location(locations: Sequence[Well]) -> None:
+    from .labware import Well
+
+    for loc in locations:
+        if not isinstance(loc, Well):
+            raise ValueError(
+                f"'{loc}' is not a valid location for transfer."
+                f" Location should be a well instance."
+            )
+
+
+def ensure_valid_flat_wells_list_for_transfer_v2(
+    target: Union[Well, Sequence[Well], Sequence[Sequence[Well]]],
+) -> List[Well]:
+    """Ensure that the given target(s) for a liquid transfer are valid and in a flat list."""
+    from .labware import Well
+
+    if isinstance(target, Well):
+        return [target]
+
+    if isinstance(target, (list, tuple)):
+        if len(target) == 0:
+            raise ValueError("No target well(s) specified for transfer.")
+        if isinstance(target[0], (list, tuple)):
+            for sub_sequence in target:
+                _verify_each_list_element_is_valid_location(sub_sequence)
+            return [loc for sub_sequence in target for loc in sub_sequence]
+        else:
+            _verify_each_list_element_is_valid_location(target)
+            return list(target)
+    else:
+        raise ValueError(
+            f"'{target}' is not a valid location for transfer."
+            f" Location should be a well instance, or a 1-dimensional or"
+            f" 2-dimensional sequence of well instances."
+        )
+
+
+def ensure_valid_tip_drop_location_for_transfer_v2(
+    tip_drop_location: Union[Location, Well, TrashBin, WasteChute]
+) -> Union[Location, Well, TrashBin, WasteChute]:
+    """Ensure that the tip drop location is valid for v2 transfer."""
+    from .labware import Well
+
+    if (
+        isinstance(tip_drop_location, Well)
+        or isinstance(tip_drop_location, TrashBin)
+        or isinstance(tip_drop_location, WasteChute)
+    ):
+        return tip_drop_location
+    elif isinstance(tip_drop_location, Location):
+        _, maybe_well = tip_drop_location.labware.get_parent_labware_and_well()
+
+        if maybe_well is None:
+            raise TypeError(
+                "If a location is specified as a `types.Location`"
+                " (for instance, as the result of a call to `Well.top()`),"
+                " it must be a location relative to a well,"
+                " since that is where a tip is dropped."
+                " However, the given location doesn't refer to any well."
+            )
+        return tip_drop_location
+    else:
+        raise TypeError(
+            f"If specified, location should be an instance of"
+            f" `types.Location` (e.g. the return value from `Well.top()`)"
+            f" or `Well` (e.g. `reservoir.wells()[0]`) or an instance of `TrashBin` or `WasteChute`."
+            f" However, it is '{tip_drop_location}'."
+        )

opentrons/protocol_engine/__init__.py

@@ -57,6 +57,8 @@ from .types import (
     ModuleModel,
     ModuleDefinition,
     Liquid,
+    LiquidClassRecord,
+    LiquidClassRecordWithId,
     AllNozzleLayoutConfiguration,
     SingleNozzleLayoutConfiguration,
     RowNozzleLayoutConfiguration,
@@ -122,6 +124,8 @@ __all__ = [
     "ModuleModel",
     "ModuleDefinition",
     "Liquid",
+    "LiquidClassRecord",
+    "LiquidClassRecordWithId",
     "AllNozzleLayoutConfiguration",
     "SingleNozzleLayoutConfiguration",
     "RowNozzleLayoutConfiguration",

opentrons/protocol_engine/actions/actions.py

@@ -27,7 +27,6 @@ from ..types import (
     ModuleDefinition,
     Liquid,
     DeckConfigurationType,
-    AddressableAreaLocation,
 )
 
 
@@ -235,12 +234,12 @@ class SetDeckConfigurationAction:
 class AddAddressableAreaAction:
     """Add a single addressable area to state.
 
-    This differs from the deck configuration in ProvideDeckConfigurationAction which
+    This differs from the deck configuration in SetDeckConfigurationAction which
     sends over a mapping of cutout fixtures. This action will only load one addressable
     area and that should be pre-validated before being sent via the action.
     """
 
-    addressable_area: AddressableAreaLocation
+    addressable_area_name: str
 
 
 @dataclasses.dataclass(frozen=True)

opentrons/protocol_engine/clients/sync_client.py

@@ -77,6 +77,18 @@ class SyncClient:
     ) -> commands.LoadPipetteResult:
         pass
 
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLidStackParams
+    ) -> commands.LoadLidStackResult:
+        pass
+
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLidParams
+    ) -> commands.LoadLidResult:
+        pass
+
     @overload
     def execute_command_without_recovery(
         self, params: commands.LiquidProbeParams
@@ -89,6 +101,12 @@ class SyncClient:
     ) -> commands.TryLiquidProbeResult:
         pass
 
+    @overload
+    def execute_command_without_recovery(
+        self, params: commands.LoadLiquidClassParams
+    ) -> commands.LoadLiquidClassResult:
+        pass
+
     def execute_command_without_recovery(
         self, params: commands.CommandParams
     ) -> commands.CommandResult:

opentrons/protocol_engine/commands/__init__.py

@@ -20,6 +20,7 @@ from . import temperature_module
 from . import thermocycler
 from . import calibration
 from . import unsafe
+from . import robot
 
 from .hash_command_params import hash_protocol_command_params
 from .generate_command_schema import generate_command_schema
@@ -34,13 +35,23 @@ from .command import (
 
 from .command_unions import (
     Command,
+    CommandAdapter,
     CommandParams,
     CommandCreate,
+    CommandCreateAdapter,
     CommandResult,
     CommandType,
     CommandDefinedErrorData,
 )
 
+from .air_gap_in_place import (
+    AirGapInPlace,
+    AirGapInPlaceParams,
+    AirGapInPlaceCreate,
+    AirGapInPlaceResult,
+    AirGapInPlaceCommandType,
+)
+
 from .aspirate import (
     Aspirate,
     AspirateParams,
@@ -138,6 +149,15 @@ from .load_liquid import (
     LoadLiquidImplementation,
 )
 
+from .load_liquid_class import (
+    LoadLiquidClass,
+    LoadLiquidClassParams,
+    LoadLiquidClassCreate,
+    LoadLiquidClassResult,
+    LoadLiquidClassCommandType,
+    LoadLiquidClassImplementation,
+)
+
 from .load_module import (
     LoadModule,
     LoadModuleParams,
@@ -154,6 +174,22 @@ from .load_pipette import (
     LoadPipetteCommandType,
 )
 
+from .load_lid_stack import (
+    LoadLidStack,
+    LoadLidStackParams,
+    LoadLidStackCreate,
+    LoadLidStackResult,
+    LoadLidStackCommandType,
+)
+
+from .load_lid import (
+    LoadLid,
+    LoadLidParams,
+    LoadLidCreate,
+    LoadLidResult,
+    LoadLidCommandType,
+)
+
 from .move_labware import (
     MoveLabware,
     MoveLabwareParams,
@@ -323,6 +359,14 @@ from .verify_tip_presence import (
     VerifyTipPresenceCommandType,
 )
 
+from .get_next_tip import (
+    GetNextTip,
+    GetNextTipCreate,
+    GetNextTipParams,
+    GetNextTipResult,
+    GetNextTipCommandType,
+)
+
 from .liquid_probe import (
     LiquidProbe,
     LiquidProbeParams,
@@ -339,8 +383,10 @@ from .liquid_probe import (
 __all__ = [
     # command type unions
     "Command",
+    "CommandAdapter",
     "CommandParams",
     "CommandCreate",
+    "CommandCreateAdapter",
     "CommandResult",
     "CommandType",
     "CommandPrivateResult",
@@ -355,6 +401,12 @@ __all__ = [
     "hash_protocol_command_params",
     # command schema generation
     "generate_command_schema",
+    # air gap command models
+    "AirGapInPlace",
+    "AirGapInPlaceCreate",
+    "AirGapInPlaceParams",
+    "AirGapInPlaceResult",
+    "AirGapInPlaceCommandType",
     # aspirate command models
     "Aspirate",
     "AspirateCreate",
@@ -440,6 +492,20 @@ __all__ = [
     "LoadPipetteResult",
     "LoadPipetteCommandType",
     "LoadPipettePrivateResult",
+    # load lid stack command models
+    "LoadLidStack",
+    "LoadLidStackCreate",
+    "LoadLidStackParams",
+    "LoadLidStackResult",
+    "LoadLidStackCommandType",
+    "LoadLidStackPrivateResult",
+    # load lid command models
+    "LoadLid",
+    "LoadLidCreate",
+    "LoadLidParams",
+    "LoadLidResult",
+    "LoadLidCommandType",
+    "LoadLidPrivateResult",
     # move labware command models
     "MoveLabware",
     "MoveLabwareCreate",
@@ -538,6 +604,14 @@ __all__ = [
     "LoadLiquidParams",
     "LoadLiquidResult",
     "LoadLiquidCommandType",
+    # load liquid class command models
+    "LoadLiquidClass",
+    "LoadLiquidClassParams",
+    "LoadLiquidClassCreate",
+    "LoadLiquidClassResult",
+    "LoadLiquidClassImplementation",
+    "LoadLiquidClassCommandType",
+    # hardware control command models
     # hardware module command bundles
     "absorbance_reader",
     "heater_shaker",
@@ -548,6 +622,7 @@ __all__ = [
     "calibration",
     # unsafe command bundle
     "unsafe",
+    "robot",
     # configure pipette volume command bundle
     "ConfigureForVolume",
     "ConfigureForVolumeCreate",
@@ -578,6 +653,12 @@ __all__ = [
     "VerifyTipPresenceParams",
     "VerifyTipPresenceResult",
     "VerifyTipPresenceCommandType",
+    # get next tip command bundle
+    "GetNextTip",
+    "GetNextTipCreate",
+    "GetNextTipParams",
+    "GetNextTipResult",
+    "GetNextTipCommandType",
     # liquid probe command bundle
     "LiquidProbe",
     "LiquidProbeParams",

opentrons/protocol_engine/commands/absorbance_reader/close_lid.py

@@ -60,7 +60,6 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
         hardware_lid_status = AbsorbanceReaderLidStatus.OFF
         if not self._state_view.config.use_virtual_modules:
             abs_reader = self._equipment.get_module_hardware_api(mod_substate.module_id)
-
             if abs_reader is not None:
                 hardware_lid_status = await abs_reader.get_current_lid_status()
             else:
@@ -95,7 +94,6 @@ class CloseLidImpl(AbstractCommandImpl[CloseLidParams, SuccessData[CloseLidResul
                     deck_slot=self._state_view.modules.get_location(
                         params.moduleId
                     ).slotName,
-                    deck_type=self._state_view.config.deck_type,
                     model=absorbance_model,
                 )
             )

opentrons/protocol_engine/commands/absorbance_reader/initialize.py

@@ -1,9 +1,10 @@
 """Command models to initialize an Absorbance Reader."""
 from __future__ import annotations
-from typing import List, Optional, Literal, TYPE_CHECKING
+from typing import List, Optional, Literal, TYPE_CHECKING, Any
 from typing_extensions import Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.drivers.types import ABSMeasurementMode
 from opentrons.protocol_engine.types import ABSMeasureMode
@@ -11,6 +12,7 @@ from opentrons.protocol_engine.types import ABSMeasureMode
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
 from ...errors import InvalidWavelengthError
+from ...state import update_types
 
 if TYPE_CHECKING:
     from opentrons.protocol_engine.state.state import StateView
@@ -20,6 +22,10 @@ if TYPE_CHECKING:
 InitializeCommandType = Literal["absorbanceReader/initialize"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class InitializeParams(BaseModel):
     """Input parameters to initialize an absorbance reading."""
 
@@ -28,8 +34,10 @@ class InitializeParams(BaseModel):
         ..., description="Initialize single or multi measurement mode."
     )
     sampleWavelengths: List[int] = Field(..., description="Sample wavelengths in nm.")
-    referenceWavelength: Optional[int] = Field(
-        None, description="Optional reference wavelength in nm."
+    referenceWavelength: int | SkipJsonSchema[None] = Field(
+        None,
+        description="Optional reference wavelength in nm.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -53,6 +61,7 @@ class InitializeImpl(
 
     async def execute(self, params: InitializeParams) -> SuccessData[InitializeResult]:
         """Initiate a single absorbance measurement."""
+        state_update = update_types.StateUpdate()
         abs_reader_substate = self._state_view.modules.get_absorbance_reader_substate(
             module_id=params.moduleId
         )
@@ -113,10 +122,15 @@ class InitializeImpl(
                 reference_wavelength=params.referenceWavelength,
             )
 
-        return SuccessData(
-            public=InitializeResult(),
+        state_update.initialize_absorbance_reader(
+            abs_reader_substate.module_id,
+            params.measureMode,
+            params.sampleWavelengths,
+            params.referenceWavelength,
         )
 
+        return SuccessData(public=InitializeResult(), state_update=state_update)
+
 
 class Initialize(BaseCommand[InitializeParams, InitializeResult, ErrorOccurrence]):
     """A command to initialize an Absorbance Reader."""

opentrons/protocol_engine/commands/absorbance_reader/open_lid.py

@@ -91,7 +91,6 @@ class OpenLidImpl(AbstractCommandImpl[OpenLidParams, SuccessData[OpenLidResult]]
                     deck_slot=self._state_view.modules.get_location(
                         params.moduleId
                     ).slotName,
-                    deck_type=self._state_view.config.deck_type,
                     model=absorbance_model,
                 )
             )