@opentrons/shared-data 0.0.0-alpha.2 → 0.0.1-alpha.1

package/python/build/lib/opentrons_shared_data/pipette/load_data.py

@@ -0,0 +1,256 @@
+import json
+import os
+
+from typing import Dict, Any, Union, Optional
+from typing_extensions import Literal
+from functools import lru_cache
+
+from .. import load_shared_data, get_shared_data_root
+
+from .pipette_definition import (
+    PipetteConfigurations,
+    PipetteLiquidPropertiesDefinition,
+)
+from .model_constants import MOUNT_CONFIG_LOOKUP_TABLE, _MAP_KEY_TO_V2
+from .types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteGenerationType,
+    PipetteVersionType,
+    PipetteModelMajorVersion,
+    PipetteModelMinorVersion,
+    LiquidClasses,
+)
+
+
+LoadedConfiguration = Dict[str, Union[str, Dict[str, Any]]]
+
+
+def _get_configuration_dictionary(
+    config_type: Literal["general", "geometry", "liquid"],
+    channels: PipetteChannelType,
+    model: PipetteModelType,
+    version: PipetteVersionType,
+    liquid_class: Optional[LiquidClasses] = None,
+) -> LoadedConfiguration:
+    if liquid_class:
+        config_path = (
+            get_shared_data_root()
+            / "pipette"
+            / "definitions"
+            / "2"
+            / config_type
+            / channels.name.lower()
+            / model.value
+            / liquid_class.name
+            / f"{version.major}_{version.minor}.json"
+        )
+    else:
+        config_path = (
+            get_shared_data_root()
+            / "pipette"
+            / "definitions"
+            / "2"
+            / config_type
+            / channels.name.lower()
+            / model.value
+            / f"{version.major}_{version.minor}.json"
+        )
+    return json.loads(load_shared_data(config_path))
+
+
+@lru_cache(maxsize=None)
+def _geometry(
+    channels: PipetteChannelType,
+    model: PipetteModelType,
+    version: PipetteVersionType,
+) -> LoadedConfiguration:
+    return _get_configuration_dictionary("geometry", channels, model, version)
+
+
+@lru_cache(maxsize=None)
+def _liquid(
+    channels: PipetteChannelType,
+    model: PipetteModelType,
+    version: PipetteVersionType,
+) -> Dict[str, LoadedConfiguration]:
+    liquid_dict = {}
+    for liquid_class in LiquidClasses:
+        try:
+            liquid_dict[liquid_class.name] = _get_configuration_dictionary(
+                "liquid", channels, model, version, liquid_class
+            )
+        except FileNotFoundError:
+            continue
+
+    return liquid_dict
+
+
+@lru_cache(maxsize=None)
+def _physical(
+    channels: PipetteChannelType,
+    model: PipetteModelType,
+    version: PipetteVersionType,
+) -> LoadedConfiguration:
+    return _get_configuration_dictionary("general", channels, model, version)
+
+
+@lru_cache(maxsize=None)
+def load_serial_lookup_table() -> Dict[str, str]:
+    """Load a serial abbreviation lookup table mapped to model name."""
+    config_path = get_shared_data_root() / "pipette" / "definitions" / "2" / "general"
+    _lookup_table = {}
+    _channel_shorthand = {
+        "eight_channel": "M",
+        "single_channel": "S",
+        "ninety_six_channel": "H",
+    }
+    _channel_model_str = {
+        "single_channel": "single",
+        "ninety_six_channel": "96",
+        "eight_channel": "multi",
+    }
+    _model_shorthand = {"p1000": "p1k", "p300": "p3h"}
+    for channel_dir in os.listdir(config_path):
+        for model_dir in os.listdir(config_path / channel_dir):
+            for version_file in os.listdir(config_path / channel_dir / model_dir):
+                version_list = version_file.split(".json")[0].split("_")
+                built_model = f"{model_dir}_{_channel_model_str[channel_dir]}_v{version_list[0]}.{version_list[1]}"
+
+                model_shorthand = _model_shorthand.get(model_dir, model_dir)
+
+                if (
+                    model_dir == "p300"
+                    and int(version_list[0]) == 1
+                    and int(version_list[1]) == 0
+                ):
+                    # Well apparently, we decided to switch the shorthand of the p300 depending
+                    # on whether it's a "V1" model or not...so...here is the lovely workaround.
+                    model_shorthand = model_dir
+                serial_shorthand = f"{model_shorthand.upper()}{_channel_shorthand[channel_dir]}V{version_list[0]}{version_list[1]}"
+                _lookup_table[serial_shorthand] = built_model
+    return _lookup_table
+
+
+def load_liquid_model(
+    model: PipetteModelType,
+    channels: PipetteChannelType,
+    version: PipetteVersionType,
+) -> Dict[str, PipetteLiquidPropertiesDefinition]:
+    liquid_dict = _liquid(channels, model, version)
+    return {
+        k: PipetteLiquidPropertiesDefinition.parse_obj(v)
+        for k, v in liquid_dict.items()
+    }
+
+
+def _change_to_camel_case(c: str) -> str:
+    # Tiny helper function to convert to camelCase.
+    config_name = c.split("_")
+    if len(config_name) == 1:
+        return config_name[0]
+    return f"{config_name[0]}" + "".join(s.capitalize() for s in config_name[1::])
+
+
+def update_pipette_configuration(  # noqa: C901
+    base_configurations: PipetteConfigurations,
+    v1_configuration_changes: Dict[str, Any],
+    liquid_class: Optional[LiquidClasses] = None,
+) -> PipetteConfigurations:
+    """Helper function to update 'V1' format configurations (left over from PipetteDict).
+
+    #TODO (lc 7-14-2023) Remove once the pipette config dict is eliminated.
+    Given an input of v1 mutable configs, look up the equivalent keyed
+    value of that configuration."""
+    quirks_list = []
+    dict_of_base_model = base_configurations.dict(by_alias=True)
+
+    for c, v in v1_configuration_changes.items():
+        lookup_key = _change_to_camel_case(c)
+        if c == "quirks" and isinstance(v, dict):
+            quirks_list.extend([b.name for b in v.values() if b.value])
+        elif liquid_class:
+            if lookup_key == "tipLength":
+                new_names = _MAP_KEY_TO_V2[lookup_key]
+                top_name = new_names["top_level_name"]
+                nested_name = new_names["nested_name"]
+                # This is only a concern for OT-2 configs and I think we can
+                # be less smart about handling multiple tip types by updating
+                # all tips.
+                for k in dict_of_base_model["liquid_properties"][liquid_class][
+                    new_names["top_level_name"]
+                ].keys():
+                    dict_of_base_model["liquid_properties"][liquid_class][top_name][k][
+                        nested_name
+                    ] = v
+            else:
+                dict_of_base_model["liquid_properties"][liquid_class].pop(lookup_key)
+                dict_of_base_model["liquid_properties"][liquid_class][lookup_key] = v
+        else:
+            try:
+                dict_of_base_model.pop(lookup_key)
+                dict_of_base_model[lookup_key] = v
+            except KeyError:
+                # The name is not the same format as previous so
+                # we need to look it up from the V2 key map
+                new_names = _MAP_KEY_TO_V2[lookup_key]
+                top_name = new_names["top_level_name"]
+                nested_name = new_names["nested_name"]
+                if new_names.get("liquid_class"):
+                    # isinstances are needed for type checking.
+                    liquid_class = LiquidClasses[new_names["liquid_class"]]
+                    dict_of_base_model[top_name][liquid_class][nested_name] = v
+                else:
+                    # isinstances are needed for type checking.
+                    dict_of_base_model[top_name][nested_name] = v
+    dict_of_base_model["quirks"] = list(
+        set(dict_of_base_model["quirks"]) - set(quirks_list)
+    )
+
+    # re-serialization is not great for this nested enum so we need
+    # to perform this workaround.
+    if not liquid_class:
+        liquid_class = LiquidClasses.default
+    dict_of_base_model["liquid_properties"][liquid_class]["supportedTips"] = {
+        k.name: v
+        for k, v in dict_of_base_model["liquid_properties"][liquid_class][
+            "supportedTips"
+        ].items()
+    }
+    dict_of_base_model["liquid_properties"] = {
+        k.name: v for k, v in dict_of_base_model["liquid_properties"].items()
+    }
+    dict_of_base_model["plungerPositionsConfigurations"] = {
+        k.name: v
+        for k, v in dict_of_base_model["plungerPositionsConfigurations"].items()
+    }
+    return PipetteConfigurations.parse_obj(dict_of_base_model)
+
+
+def load_definition(
+    model: PipetteModelType,
+    channels: PipetteChannelType,
+    version: PipetteVersionType,
+) -> PipetteConfigurations:
+    if (
+        version.major not in PipetteModelMajorVersion
+        or version.minor not in PipetteModelMinorVersion
+    ):
+        raise KeyError("Pipette version not found.")
+
+    geometry_dict = _geometry(channels, model, version)
+    physical_dict = _physical(channels, model, version)
+    liquid_dict = _liquid(channels, model, version)
+
+    generation = PipetteGenerationType(physical_dict["displayCategory"])
+    mount_configs = MOUNT_CONFIG_LOOKUP_TABLE[generation][channels]
+
+    return PipetteConfigurations.parse_obj(
+        {
+            **geometry_dict,
+            **physical_dict,
+            "liquid_properties": liquid_dict,
+            "version": version,
+            "mount_configurations": mount_configs,
+        }
+    )

package/python/build/lib/opentrons_shared_data/pipette/model_constants.py

@@ -0,0 +1,151 @@
+from typing import Dict, Union
+
+from .types import (
+    Quirks,
+    RobotMountConfigs,
+    AvailableUnits,
+    PipetteGenerationType,
+    PipetteChannelType,
+)
+
+MOUNT_CONFIG_LOOKUP_TABLE = {
+    PipetteGenerationType.GEN1: {
+        PipetteChannelType.SINGLE_CHANNEL: RobotMountConfigs(768, 220, 30),
+        PipetteChannelType.EIGHT_CHANNEL: RobotMountConfigs(768, 220, 30),
+    },
+    PipetteGenerationType.GEN2: {
+        PipetteChannelType.SINGLE_CHANNEL: RobotMountConfigs(3200, 172.15, 60),
+        PipetteChannelType.EIGHT_CHANNEL: RobotMountConfigs(3200, 155.75, 60),
+    },
+    PipetteGenerationType.FLEX: {
+        PipetteChannelType.SINGLE_CHANNEL: RobotMountConfigs(2133.33, 230.15, 80),
+        PipetteChannelType.EIGHT_CHANNEL: RobotMountConfigs(2133.33, 230.15, 80),
+        PipetteChannelType.NINETY_SIX_CHANNEL: RobotMountConfigs(2133.33, 230.15, 80),
+    },
+}
+
+
+VALID_QUIRKS = [q.value for q in Quirks]
+MUTABLE_CONFIGS_V1 = [
+    "top",
+    "bottom",
+    "blowout",
+    "dropTip",
+    "pickUpCurrent",
+    "pickUpDistance",
+    "pickUpIncrement",
+    "pickUpPresses",
+    "pickUpSpeed",
+    "plungerCurrent",
+    "dropTipCurrent",
+    "dropTipSpeed",
+    "tipLength",
+    "quirks",
+]
+
+# Version 2 Configuration Keys.
+MUTABLE_CONFIGS_V2 = [
+    "plungerPositionsConfigurations",
+    "pickUpTipConfigurations",
+    "dropTipConfigurations",
+    "plungerMotorConfigurations",
+    "tipLength",
+]
+
+RESTRICTED_MUTABLE_CONFIG_KEYS = [*VALID_QUIRKS, "model"]
+
+_MAP_KEY_TO_V2: Dict[str, Dict[str, str]] = {
+    "top": {
+        "top_level_name": "plungerPositionsConfigurations",
+        "nested_name": "top",
+        "liquid_class": "default",
+    },
+    "bottom": {
+        "top_level_name": "plungerPositionsConfigurations",
+        "nested_name": "bottom",
+        "liquid_class": "default",
+    },
+    "blowout": {
+        "top_level_name": "plungerPositionsConfigurations",
+        "nested_name": "blowout",
+        "liquid_class": "default",
+    },
+    "dropTip": {
+        "top_level_name": "plungerPositionsConfigurations",
+        "nested_name": "drop",
+        "liquid_class": "default",
+    },
+    "pickUpCurrent": {
+        "top_level_name": "pickUpTipConfigurations",
+        "nested_name": "current",
+    },
+    "pickUpDistance": {
+        "top_level_name": "pickUpTipConfigurations",
+        "nested_name": "distance",
+    },
+    "pickUpIncrement": {
+        "top_level_name": "pickUpTipConfigurations",
+        "nested_name": "increment",
+    },
+    "pickUpPresses": {
+        "top_level_name": "pickUpTipConfigurations",
+        "nested_name": "presses",
+    },
+    "pickUpSpeed": {
+        "top_level_name": "pickUpTipConfigurations",
+        "nested_name": "speed",
+    },
+    "plungerCurrent": {
+        "top_level_name": "plungerMotorConfigurations",
+        "nested_name": "run",
+    },
+    "dropTipCurrent": {
+        "top_level_name": "dropTipConfigurations",
+        "nested_name": "current",
+    },
+    "dropTipSpeed": {"top_level_name": "dropTipConfigurations", "nested_name": "speed"},
+    "tipLength": {"top_level_name": "supportedTips", "nested_name": "defaultTipLength"},
+}
+
+
+_MIN_MAX_LOOKUP: Dict[str, Dict[str, Union[int, float]]] = {
+    "current": {"min": 0.1, "max": 2.0},
+    "run": {"min": 0.1, "max": 2.0},
+    "speed": {"min": 0.01, "max": 30},
+    "top": {"min": -20, "max": 30},
+    "bottom": {"min": -20, "max": 30},
+    "blowout": {"min": -20, "max": 30},
+    "drop": {"min": -20, "max": 30},
+    "presses": {"min": 0, "max": 15},
+    "increment": {"min": 0, "max": 10},
+    "distance": {"min": 0, "max": 10},
+    "defaultTipLength": {"min": 0, "max": 100},
+}
+
+_TYPE_LOOKUP: Dict[str, str] = {
+    "current": "float",
+    "run": "float",
+    "speed": "float",
+    "top": "float",
+    "bottom": "float",
+    "blowout": "float",
+    "drop": "float",
+    "presses": "int",
+    "increment": "int",
+    "defaultTipLength": "float",
+    "distance": "float",
+}
+
+_UNITS_LOOKUP = {
+    "current": AvailableUnits.amps,
+    "run": AvailableUnits.amps,
+    "speed": AvailableUnits.speed,
+    "top": AvailableUnits.mm,
+    "bottom": AvailableUnits.mm,
+    "blowout": AvailableUnits.mm,
+    "drop": AvailableUnits.mm,
+    "presses": AvailableUnits.presses,
+    "increment": AvailableUnits.mm,
+    "defaultTipLength": AvailableUnits.mm,
+    "distance": AvailableUnits.mm,
+}