feat(shared-data,api,robot-server): Use new OT-3 deck slot naming style

api/src/opentrons/protocol_api/core/legacy/deck.py

@@ -258,23 +258,23 @@ def get_slot_center(self, slot_name: str) -> Point:
         )
 
     def resolve_module_location(
-        self, module_type: ModuleType, location: Optional[DeckLocation]
+        self, module_type: ModuleType, slot_id: Optional[str]
     ) -> DeckLocation:
         dn_from_type = {
             ModuleType.MAGNETIC: "Magnetic Module",
             ModuleType.THERMOCYCLER: "Thermocycler",
             ModuleType.TEMPERATURE: "Temperature Module",
             ModuleType.HEATER_SHAKER: "Heater-Shaker",
         }
-        if isinstance(location, str) or isinstance(location, int):
-            slot_def = self.get_slot_definition(str(location))
+        if slot_id is not None:
+            slot_def = self.get_slot_definition(slot_id)
             compatible_modules = slot_def["compatibleModuleTypes"]
             if module_type.value in compatible_modules:
-                return location
+                return slot_id
             else:
                 raise ValueError(
                     f"A {dn_from_type[module_type]} cannot be loaded"
-                    f" into slot {location}"
+                    f" into slot {slot_id}"
                 )
         else:
             valid_slots = [

api/src/opentrons/protocol_engine/commands/command.py

@@ -6,8 +6,9 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar
 
+from opentrons_shared_data.robot.dev_types import RobotType
 from pydantic import BaseModel, Field
 from pydantic.generics import GenericModel
 
@@ -47,6 +48,13 @@ class CommandIntent(str, Enum):
     SETUP = "setup"
 
 
+# Workaround for no Self type in Python 3.7.
+# https://peps.python.org/pep-0673/
+BaseCommandCreateSelfT = TypeVar(
+    "BaseCommandCreateSelfT", bound="BaseCommandCreate[Any]"
+)
+
+
 class BaseCommandCreate(GenericModel, Generic[CommandParamsT]):
     """Base class for command creation requests.
 
@@ -85,6 +93,11 @@ class BaseCommandCreate(GenericModel, Generic[CommandParamsT]):
         ),
     )
 
+    def normalize(
+        self: BaseCommandCreateSelfT, robot_type: RobotType
+    ) -> BaseCommandCreateSelfT:
+        return self
+
 
 class BaseCommand(GenericModel, Generic[CommandParamsT, CommandResultT]):
     """Base command model.

api/src/opentrons/protocol_engine/commands/load_labware.py

@@ -4,9 +4,10 @@
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
 
+from opentrons_shared_data.robot.dev_types import RobotType
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
 
-from ..types import LabwareLocation
+from ..types import DeckSlotLocation, LabwareLocation
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate
 
 if TYPE_CHECKING:
@@ -16,6 +17,17 @@
 LoadLabwareCommandType = Literal["loadLabware"]
 
 
+def canonicalize_location(
+    location: LabwareLocation, robot_type: RobotType
+) -> LabwareLocation:
+    if isinstance(location, DeckSlotLocation):
+        return DeckSlotLocation.construct(
+            slotName=location.slotName.to_equivalent_by_robot_type(robot_type)
+        )
+    else:
+        return location
+
+
 class LoadLabwareParams(BaseModel):
     """Payload required to load a labware into a slot."""
 
@@ -49,6 +61,16 @@ class LoadLabwareParams(BaseModel):
         # TODO: Make sure v6 JSON protocols don't do that.
     )
 
+    def canonicalize(self, robot_type: RobotType) -> LoadLabwareParams:
+        return LoadLabwareParams.construct(
+            location=canonicalize_location(self.location, robot_type),
+            loadName=self.loadName,
+            namespace=self.namespace,
+            version=self.version,
+            labwareId=self.labwareId,
+            displayName=self.displayName,
+        )
+
 
 class LoadLabwareResult(BaseModel):
     """Result data from the execution of a LoadLabware command."""
@@ -118,3 +140,7 @@ class LoadLabwareCreate(BaseCommandCreate[LoadLabwareParams]):
     params: LoadLabwareParams
 
     _CommandCls: Type[LoadLabware] = LoadLabware
+
+    def normalize(self, robot_type: RobotType) -> LoadLabwareCreate:
+        canonicalized_params = self.params.canonicalize(robot_type)
+        return self.copy(update={"params": canonicalized_params})

api/src/opentrons/protocol_engine/commands/load_module.py

@@ -1,7 +1,10 @@
 """Implementation, request models, and response models for the load module command."""
 from __future__ import annotations
+
 from typing import TYPE_CHECKING, Optional, Type
 from typing_extensions import Literal
+
+from opentrons_shared_data.robot.dev_types import RobotType
 from pydantic import BaseModel, Field
 
 from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate
@@ -54,6 +57,17 @@ class LoadModuleParams(BaseModel):
         ),
     )
 
+    def canonicalize(self, robot_type: RobotType) -> LoadModuleParams:
+        return self.copy(
+            update={
+                "location": DeckSlotLocation.construct(
+                    slotName=self.location.slotName.to_equivalent_by_robot_type(
+                        robot_type
+                    )
+                )
+            }
+        )
+
 
 class LoadModuleResult(BaseModel):
     """The results of loading a module."""
@@ -138,3 +152,6 @@ class LoadModuleCreate(BaseCommandCreate[LoadModuleParams]):
     params: LoadModuleParams
 
     _CommandCls: Type[LoadModule] = LoadModule
+
+    def normalize(self, robot_type: RobotType) -> LoadModuleCreate:
+        return self.copy(update={"params": self.params.canonicalize(robot_type)})

api/src/opentrons/protocol_engine/protocol_engine.py

@@ -148,6 +148,8 @@ def add_command(self, request: commands.CommandCreate) -> commands.Command:
             RunStoppedError: the run has been stopped, so no new commands
                 may be added.
         """
+        request = request.normalize(robot_type=self.state_view.config.robot_type)
+
         command_id = self._model_utils.generate_id()
         request_hash = commands.hash_command_params(
             create=request,
@@ -281,13 +283,24 @@ def add_labware_offset(self, request: LabwareOffsetCreate) -> LabwareOffset:
 
         To retrieve offsets later, see `.state_view.labware`.
         """
+        normalized_request = request.copy(
+            update={
+                "location": request.location.copy(
+                    update={
+                        "slotName": request.location.slotName.to_equivalent_by_robot_type(
+                            self.state_view.config.robot_type
+                        )
+                    }
+                )
+            }
+        )
         labware_offset_id = self._model_utils.generate_id()
         created_at = self._model_utils.get_timestamp()
         self._action_dispatcher.dispatch(
             AddLabwareOffsetAction(
                 labware_offset_id=labware_offset_id,
                 created_at=created_at,
-                request=request,
+                request=normalized_request,
             )
         )
         return self.state_view.labware.get_labware_offset(

api/src/opentrons/types.py

@@ -3,6 +3,8 @@
 from math import sqrt, isclose
 from typing import TYPE_CHECKING, Any, NamedTuple, Iterable, Union
 
+from opentrons_shared_data.robot.dev_types import RobotType
+
 from .protocols.api_support.labware_like import LabwareLike
 
 if TYPE_CHECKING:
@@ -223,6 +225,19 @@ class DeckSlotName(enum.Enum):
     SLOT_11 = "11"
     FIXED_TRASH = "12"
 
+    SLOT_A1 = "A1"
+    SLOT_A2 = "A2"
+    SLOT_A3 = "A3"
+    SLOT_B1 = "B1"
+    SLOT_B2 = "B2"
+    SLOT_B3 = "B3"
+    SLOT_C1 = "C1"
+    SLOT_C2 = "C2"
+    SLOT_C3 = "C3"
+    SLOT_D1 = "D1"
+    SLOT_D2 = "D2"
+    SLOT_D3 = "D3"
+
     @classmethod
     def from_primitive(cls, value: DeckLocation) -> DeckSlotName:
         str_val = str(value).upper()
@@ -231,7 +246,19 @@ def from_primitive(cls, value: DeckLocation) -> DeckSlotName:
         return cls(str_val)
 
     def as_int(self) -> int:
-        return int(self.value)
+        return int(self.to_ot2_equivalent().value)
+
+    def to_ot3_equivalent(self) -> DeckSlotName:
+        return _ot2_to_ot3.get(self, self)
+
+    def to_ot2_equivalent(self) -> DeckSlotName:
+        return _ot3_to_ot2.get(self, self)
+
+    def to_equivalent_by_robot_type(self, robot_type: RobotType) -> DeckSlotName:
+        if robot_type == "OT-2 Standard":
+            return self.to_ot2_equivalent()
+        elif robot_type == "OT-3 Standard":
+            return self.to_ot3_equivalent()
 
     def as_coordinate(self) -> str:
         return DECK_SLOT_NAME_TO_COORDINATE[self.value]
@@ -254,6 +281,27 @@ def __str__(self) -> str:
         return self.id
 
 
+# fmt: off
+_slot_equivalencies = [
+    (DeckSlotName.SLOT_1,      DeckSlotName.SLOT_D1),
+    (DeckSlotName.SLOT_2,      DeckSlotName.SLOT_D2),
+    (DeckSlotName.SLOT_3,      DeckSlotName.SLOT_D3),
+    (DeckSlotName.SLOT_4,      DeckSlotName.SLOT_C1),
+    (DeckSlotName.SLOT_5,      DeckSlotName.SLOT_C2),
+    (DeckSlotName.SLOT_6,      DeckSlotName.SLOT_C3),
+    (DeckSlotName.SLOT_7,      DeckSlotName.SLOT_B1),
+    (DeckSlotName.SLOT_8,      DeckSlotName.SLOT_B2),
+    (DeckSlotName.SLOT_9,      DeckSlotName.SLOT_B3),
+    (DeckSlotName.SLOT_10,     DeckSlotName.SLOT_A1),
+    (DeckSlotName.SLOT_11,     DeckSlotName.SLOT_A2),
+    (DeckSlotName.FIXED_TRASH, DeckSlotName.SLOT_A3),
+]
+# fmt: on
+
+_ot2_to_ot3 = {ot2: ot3 for ot2, ot3 in _slot_equivalencies}
+_ot3_to_ot2 = {ot3: ot2 for ot2, ot3 in _slot_equivalencies}
+
+
 class TransferTipPolicy(enum.Enum):
     ONCE = enum.auto()
     NEVER = enum.auto()

api/tests/opentrons/protocol_engine/state/test_module_view.py

@@ -333,27 +333,27 @@ def test_get_module_offset_for_ot2_standard(
     argvalues=[
         (
             lazy_fixture("tempdeck_v2_def"),
-            DeckSlotName.SLOT_1,
+            DeckSlotName.SLOT_1.to_ot3_equivalent(),
             LabwareOffsetVector(x=0, y=0, z=9),
         ),
         (
             lazy_fixture("tempdeck_v2_def"),
-            DeckSlotName.SLOT_3,
+            DeckSlotName.SLOT_3.to_ot3_equivalent(),
             LabwareOffsetVector(x=0, y=0, z=9),
         ),
         (
             lazy_fixture("thermocycler_v2_def"),
-            DeckSlotName.SLOT_7,
+            DeckSlotName.SLOT_7.to_ot3_equivalent(),
             LabwareOffsetVector(x=-20.005, y=67.96, z=0.26),
         ),
         (
             lazy_fixture("heater_shaker_v1_def"),
-            DeckSlotName.SLOT_1,
+            DeckSlotName.SLOT_1.to_ot3_equivalent(),
             LabwareOffsetVector(x=0, y=0, z=18.95),
         ),
         (
             lazy_fixture("heater_shaker_v1_def"),
-            DeckSlotName.SLOT_3,
+            DeckSlotName.SLOT_3.to_ot3_equivalent(),
             LabwareOffsetVector(x=0, y=0, z=18.95),
         ),
     ],