feat(api): Support V2 pipette configs in the OT-2 and Protocol Engine

api/src/opentrons/hardware_control/api.py

@@ -20,7 +20,9 @@
     cast,
 )
 
-from opentrons_shared_data.pipette import name_config
+from opentrons_shared_data.pipette import (
+    pipette_load_name_conversions as pipette_load_name,
+)
 from opentrons_shared_data.pipette.dev_types import PipetteName
 from opentrons_shared_data.robot.dev_types import RobotType
 from opentrons import types as top_types
@@ -409,11 +411,10 @@ async def cache_instruments(
         self._log.info("Updating instrument model cache")
         checked_require = require or {}
         for mount, name in checked_require.items():
-            if name not in name_config():
+            if not pipette_load_name.supported_pipette(name):
                 raise RuntimeError(f"{name} is not a valid pipette name")
         async with self._motion_lock:
             found = await self._backend.get_attached_instruments(checked_require)
-
         for mount, instrument_data in found.items():
             config = instrument_data.get("config")
             req_instr = checked_require.get(mount, None)
@@ -428,7 +429,10 @@ async def cache_instruments(
             )
             self._attached_instruments[mount] = p
             if req_instr and p:
-                p.act_as(req_instr)
+                converted_name = pipette_load_name.convert_to_pipette_name_type(
+                    req_instr
+                )
+                p.act_as(converted_name)
 
             if may_skip:
                 self._log.info(f"Skipping configuration on {mount.name}")
@@ -557,14 +561,16 @@ async def _do_plunger_home(
                 await stack.enter_async_context(self._motion_lock)
             with self._backend.save_current():
                 self._backend.set_active_current(
-                    {checked_axis: instr.config.plunger_current}
+                    {checked_axis: instr.plunger_motor_current.run}
                 )
                 await self._backend.home([ot2_axis_to_string(checked_axis)])
                 # either we were passed False for our acquire_lock and we
                 # should pass it on, or we acquired the lock above and
                 # shouldn't do it again
                 target_pos = target_position_from_plunger(
-                    checked_mount, instr.config.bottom, self._current_position
+                    checked_mount,
+                    instr.plunger_positions.bottom,
+                    self._current_position,
                 )
                 await self._move(
                     target_pos,
@@ -929,7 +935,7 @@ async def prepare_for_aspirate(
             speed = self.plunger_speed(
                 instrument, instrument.blow_out_flow_rate, "aspirate"
             )
-            bottom = instrument.config.bottom
+            bottom = instrument.plunger_positions.bottom
             target = target_position_from_plunger(mount, bottom, self._current_position)
             await self._move(
                 target,

api/src/opentrons/hardware_control/backends/controller.py

@@ -13,6 +13,7 @@
     TYPE_CHECKING,
     Union,
     Sequence,
+    cast,
 )
 from typing_extensions import Final
 
@@ -21,10 +22,15 @@
 except (OSError, ModuleNotFoundError):
     aionotify = None
 
+from opentrons_shared_data.pipette import (
+    pipette_load_name_conversions as pipette_load_name,
+    mutable_configurations,
+)
+from opentrons_shared_data.pipette.dev_types import PipetteName
+
 from opentrons.drivers.smoothie_drivers import SmoothieDriver
 from opentrons.drivers.rpi_drivers import build_gpio_chardev
 import opentrons.config
-from opentrons.config import pipette_config
 from opentrons.config.types import RobotConfig
 from opentrons.types import Mount
 
@@ -33,7 +39,7 @@
 from ..util import ot2_axis_to_string
 
 if TYPE_CHECKING:
-    from opentrons_shared_data.pipette.dev_types import PipetteModel, PipetteName
+    from opentrons_shared_data.pipette.dev_types import PipetteModel
     from ..dev_types import (
         AttachedPipette,
         AttachedInstruments,
@@ -180,22 +186,33 @@ async def _query_mount(
         ] = await self._smoothie_driver.read_pipette_model(  # type: ignore
             mount.name.lower()
         )
-        if found_model and found_model not in pipette_config.config_models:
+        if found_model and not pipette_load_name.supported_pipette(found_model):
             # TODO: Consider how to handle this error - it bubbles up now
             # and will cause problems at higher levels
             MODULE_LOG.error(f"Bad model on {mount.name}: {found_model}")
             found_model = None
         found_id = await self._smoothie_driver.read_pipette_id(mount.name.lower())
 
         if found_model:
-            config = pipette_config.load(found_model, found_id)
+            path_to_overrides = opentrons.config.get_opentrons_path(
+                "pipette_config_overrides_dir"
+            )
+            converted_found_model = pipette_load_name.convert_pipette_model(found_model)
+            converted_found_name = pipette_load_name.convert_to_pipette_name_type(
+                found_model
+            )
+            config = mutable_configurations.load_with_mutable_configurations(
+                converted_found_model, path_to_overrides, found_id
+            )
             if expected:
-                acceptable = [config.name] + config.back_compat_names
+                acceptable = [
+                    cast(PipetteName, str(converted_found_name))
+                ] + config.pipette_backcompat_names
                 if expected not in acceptable:
                     raise RuntimeError(
                         f"mount {mount}: instrument"
                         f" {expected} was requested"
-                        f" but {config.model} is present"
+                        f" but {converted_found_model} is present"
                     )
             return {"config": config, "id": found_id}
         else:

api/src/opentrons/hardware_control/backends/ot3controller.py

@@ -157,7 +157,7 @@
 
 if TYPE_CHECKING:
     from ..dev_types import (
-        OT3AttachedPipette,
+        AttachedPipette,
         AttachedGripper,
         OT3AttachedInstruments,
     )
@@ -691,7 +691,7 @@ def _combine_serial_number(pipette_info: ohc_tool_types.PipetteInformation) -> s
     @staticmethod
     def _build_attached_pip(
         attached: ohc_tool_types.PipetteInformation, mount: OT3Mount
-    ) -> OT3AttachedPipette:
+    ) -> AttachedPipette:
         if attached.name == FirmwarePipetteName.unknown:
             raise InvalidPipetteName(name=attached.name_int, mount=mount)
         try:

api/src/opentrons/hardware_control/backends/ot3simulator.py

@@ -75,7 +75,7 @@
     InstrumentHardwareConfigs,
     PipetteSpec,
     GripperSpec,
-    OT3AttachedPipette,
+    AttachedPipette,
     AttachedGripper,
     OT3AttachedInstruments,
 )
@@ -407,7 +407,7 @@ def _attached_pipette_to_mount(
         mount: OT3Mount,
         init_instr: PipetteSpec,
         expected_instr: Optional[PipetteName],
-    ) -> OT3AttachedPipette:
+    ) -> AttachedPipette:
         found_model = init_instr["model"]
 
         # TODO (lc 12-05-2022) When the time comes, we should think about supporting

api/src/opentrons/hardware_control/backends/simulator.py

@@ -3,14 +3,18 @@
 import copy
 import logging
 from threading import Event
-from typing import Dict, Optional, List, Tuple, TYPE_CHECKING, Sequence, Iterator
+from typing import Dict, Optional, List, Tuple, TYPE_CHECKING, Sequence, Iterator, cast
 from contextlib import contextmanager
 
-from opentrons_shared_data.pipette import dummy_model_for_name
+from opentrons_shared_data.pipette import (
+    pipette_load_name_conversions as pipette_load_name,
+    mutable_configurations,
+    pipette_definition,
+)
 
 from opentrons import types
-from opentrons.config.pipette_config import config_models, config_names, configs, load
 from opentrons.config.types import RobotConfig
+from opentrons.config import get_opentrons_path
 from opentrons.drivers.smoothie_drivers import SimulatingDriver
 
 from opentrons.drivers.rpi_drivers.gpio_simulator import SimulatingGPIOCharDev
@@ -22,7 +26,7 @@
 from ..util import ot2_axis_to_string
 
 if TYPE_CHECKING:
-    from opentrons_shared_data.pipette.dev_types import PipetteName
+    from opentrons_shared_data.pipette.dev_types import PipetteName, PipetteModel
     from ..dev_types import (
         AttachedPipette,
         AttachedInstruments,
@@ -119,25 +123,31 @@ def __init__(
         self._gpio_chardev = gpio_chardev
 
         def _sanitize_attached_instrument(
-            passed_ai: Optional[Dict[str, Optional[str]]] = None
+            passed_ai: Optional[PipetteSpec] = None,
         ) -> PipetteSpec:
             if not passed_ai or not passed_ai.get("model"):
                 return {"model": None, "id": None}
-            if passed_ai["model"] in config_models:
-                return passed_ai  # type: ignore
-            if passed_ai["model"] in config_names:
-                return {
-                    "model": dummy_model_for_name(passed_ai["model"]),  # type: ignore
-                    "id": passed_ai.get("id"),
-                }
+            if pipette_load_name.supported_pipette(
+                cast("PipetteName", passed_ai["model"])
+            ):
+                if pipette_load_name.is_model(passed_ai["model"]):
+                    return passed_ai
+                else:
+                    get_pip_model = pipette_load_name.convert_pipette_name(
+                        cast("PipetteName", passed_ai["model"])
+                    )
+                    return {
+                        "model": PipetteModel(str(get_pip_model)),
+                        "id": passed_ai.get("id"),
+                    }
             raise KeyError(
                 "If you specify attached_instruments, the model "
                 "should be pipette names or pipette models, but "
                 f'{passed_ai["model"]} is not'
             )
 
         self._attached_instruments = {
-            m: _sanitize_attached_instrument(attached_instruments.get(m))
+            m: _sanitize_attached_instrument(attached_instruments.get(m))  # type: ignore
             for m in types.Mount.ot2_mounts()
         }
         self._stubbed_attached_modules = attached_modules
@@ -213,18 +223,33 @@ async def fast_home(self, axis: Sequence[str], margin: float) -> Dict[str, float
         return self._position
 
     def _attached_to_mount(
-        self, mount: types.Mount, expected_instr: Optional[PipetteName]
+        self, mount: types.Mount, expected_instr: Optional["PipetteName"]
     ) -> AttachedPipette:
         init_instr = self._attached_instruments.get(mount, {"model": None, "id": None})
         found_model = init_instr["model"]
         back_compat: List["PipetteName"] = []
+
+        path_to_overrides = get_opentrons_path("pipette_config_overrides_dir")
+        found_model_configs: Optional[pipette_definition.PipetteConfigurations] = None
+
+        converted_found_name: Optional[pipette_definition.PipetteNameType] = None
         if found_model:
-            back_compat = configs[found_model].get("backCompatNames", [])
+            converted_found_model = pipette_load_name.convert_pipette_model(found_model)
+            converted_found_name = pipette_load_name.convert_to_pipette_name_type(
+                found_model
+            )
+            found_model_configs = (
+                mutable_configurations.load_with_mutable_configurations(
+                    converted_found_model, path_to_overrides, init_instr["id"]
+                )
+            )
+            back_compat = found_model_configs.pipette_backcompat_names
         if (
             expected_instr
             and found_model
+            and found_model_configs
             and (
-                configs[found_model]["name"] != expected_instr
+                str(converted_found_name) != expected_instr
                 and expected_instr not in back_compat
             )
         ):
@@ -235,34 +260,42 @@ def _attached_to_mount(
                     )
                 )
             else:
+                converted_expected_model = pipette_load_name.convert_pipette_name(
+                    expected_instr
+                )
                 return {
-                    "config": load(dummy_model_for_name(expected_instr)),
+                    "config": mutable_configurations.load_with_mutable_configurations(
+                        converted_expected_model, path_to_overrides
+                    ),
                     "id": None,
                 }
-        elif found_model and expected_instr:
+        elif found_model and found_model_configs:
             # Instrument detected matches instrument expected (note:
             # "instrument detected" means passed as an argument to the
-            # constructor of this class)
-            return {
-                "config": load(found_model, init_instr["id"]),
-                "id": init_instr["id"],
-            }
-        elif found_model:
+            # constructor of this class) OR,
             # Instrument detected and no expected instrument specified
             return {
-                "config": load(found_model, init_instr["id"]),
+                "config": found_model_configs,
                 "id": init_instr["id"],
             }
         elif expected_instr:
             # Expected instrument specified and no instrument detected
-            return {"config": load(dummy_model_for_name(expected_instr)), "id": None}
+            converted_expected_model = pipette_load_name.convert_pipette_name(
+                expected_instr
+            )
+            return {
+                "config": mutable_configurations.load_with_mutable_configurations(
+                    converted_expected_model, path_to_overrides
+                ),
+                "id": None,
+            }
         else:
             # No instrument detected or expected
             return {"config": None, "id": None}
 
     @ensure_yield
     async def get_attached_instruments(
-        self, expected: Dict[types.Mount, PipetteName]
+        self, expected: Dict[types.Mount, "PipetteName"]
     ) -> AttachedInstruments:
         """Update the internal cache of attached instruments.
 

api/src/opentrons/hardware_control/dev_types.py

@@ -23,7 +23,6 @@
 
 from opentrons.drivers.types import MoveSplit
 from opentrons.types import Mount
-from opentrons.config.pipette_config import PipetteConfig
 from opentrons.hardware_control.types import GripperJawState
 
 
@@ -40,11 +39,6 @@ class GripperSpec(InstrumentSpec):
 
 
 class AttachedPipette(TypedDict):
-    config: Optional[PipetteConfig]
-    id: Optional[str]
-
-
-class OT3AttachedPipette(TypedDict):
     config: Optional[PipetteConfigurations]
     id: Optional[str]
 
@@ -56,7 +50,7 @@ class AttachedGripper(TypedDict):
 
 AttachedInstruments = Dict[Mount, AttachedPipette]
 
-OT3AttachedInstruments = Union[OT3AttachedPipette, AttachedGripper]
+OT3AttachedInstruments = Union[AttachedPipette, AttachedGripper]
 
 EIGHT_CHANNELS = Literal[8]
 ONE_CHANNEL = Literal[1]

api/src/opentrons/hardware_control/instruments/instrument_abc.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Optional, Generic, TypeVar
+from typing import Any, Optional, Generic, TypeVar, Dict
 
 from opentrons.types import Point
 from opentrons.hardware_control.types import CriticalPoint
@@ -27,7 +27,7 @@ def reload_configurations(self) -> None:
         ...
 
     @abstractmethod
-    def update_config_item(self, elem_name: str, elem_val: Any) -> None:
+    def update_config_item(self, elements: Dict[str, Any]) -> None:
         """Update instrument config item."""
         ...