@opentrons/shared-data 0.0.1-alpha.1 → 0.0.1-alpha.18

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

@@ -1,256 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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,
-}