@opentrons/shared-data 0.0.0-alpha.14

package/python/opentrons_shared_data/pipette/scripts/update_configuration_files.py

@@ -0,0 +1,450 @@
+"""A script for updating pre-existing V2 Pipette configurations."""
+import os
+import json
+import argparse
+
+from pathlib import Path
+from typing import List, Dict, Tuple, Any, Iterator, Type
+
+from pydantic import BaseModel
+from pydantic.main import ModelMetaclass
+from enum import Enum
+
+from opentrons_shared_data import get_shared_data_root
+
+from ..pipette_definition import (
+    PipetteConfigurations,
+    PipetteGeometryDefinition,
+    PipettePhysicalPropertiesDefinition,
+    PipetteLiquidPropertiesDefinition,
+    PipetteModelVersionType,
+    SupportedTipsDefinition,
+)
+from ..types import (
+    PipetteModelType,
+    PipetteChannelType,
+    PipetteVersionType,
+    PipetteTipType,
+    PipetteModelMajorVersion,
+    PipetteModelMinorVersion,
+    LiquidClasses,
+)
+from ..load_data import _geometry, _physical, _liquid
+from ..pipette_load_name_conversions import convert_pipette_model
+from ..dev_types import PipetteModel
+
+"""
+Instructions:
+
+To run this script, you must be in `shared-data/python`. To invoke, use the command:
+
+`pipenv run python -m opentrons_shared_data.pipette.scripts.update_configuration_files`
+
+If you want to update all files, you can simply use the argument `--update_all_models`.
+
+Make sure to run `make format-js` afterwards to ensure formatting of the json files
+is good.
+
+*Note* If you are adding a brand-new key, you MUST update the pydantic models
+found in `python/pipette/pipette_definition.py` before running this script.
+
+*Note* When you are entering in your data, please utilize the exact type. I.e. if it's a
+list, you must input the list like: [1, 2, 3] or if it's a dict, like: {"data": 1}..
+
+For now, we do not support updating pipetting functions in this script.
+"""
+
+ROOT = get_shared_data_root() / "pipette" / "definitions" / "2"
+NOZZLE_LOCATION_CONFIGS = ["nozzle_offset", "nozzle_map"]
+
+
+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 list_configuration_keys() -> Tuple[List[str], Dict[int, str]]:
+    """List out the model keys available to modify at the top level."""
+    lookup = {i: v for (i, v) in enumerate(PipetteConfigurations.__fields__)}
+    return [
+        f"{i}: {v}" for (i, v) in enumerate(PipetteConfigurations.__fields__)
+    ], lookup
+
+
+def list_available_enum(enum_type: Type[Enum]) -> List[str]:
+    """List available pipette models"""
+    return [f"{i}: {v}" for (i, v) in enumerate(enum_type)]  # type: ignore[var-annotated]
+
+
+def handle_subclass_model(
+    top_level_configuration: List[str], base_model: BaseModel, is_basemodel: bool
+) -> List[str]:
+    """Handle sub-classed basemodels and update the top level model as necessary."""
+    if is_basemodel:
+        if base_model.__fields__ == SupportedTipsDefinition.__fields__:
+            # pydantic does something weird with the types in ModelFields so
+            # we cannot use isinstance checks to confirm if the base model
+            # is a supported tips definition
+            print(f"choose {PipetteTipType.__name__}:")
+            for row in list_available_enum(PipetteTipType):
+                print(f"\t{row}")
+            tip_type = list(PipetteTipType)[
+                int(input("select the tip volume size to modify"))
+            ]
+            top_level_configuration.append(tip_type.name)
+
+        lookup = {i: v for (i, v) in enumerate(base_model.__fields__)}
+        config_list = [f"{i}: {v}" for (i, v) in enumerate(base_model.__fields__)]
+        print(f"you selected the basemodel {base_model.__name__}:")  # type: ignore[attr-defined]
+        for row in config_list:
+            print(f"\t{row}")
+
+        configuration_to_update = lookup[
+            int(input("select a specific configuration from above\n"))
+        ]
+        field_type = base_model.__fields__[configuration_to_update].type_
+        is_basemodel = isinstance(field_type, ModelMetaclass)
+
+        top_level_configuration.append(configuration_to_update)
+        return handle_subclass_model(top_level_configuration, field_type, is_basemodel)
+    else:
+        return top_level_configuration
+
+
+def check_from_version(version: str) -> str:
+    """Check that the version requested is supported in the system."""
+    version_int = [int(v) for v in version.split(".")]
+    if version_int[0] not in PipetteModelMajorVersion:
+        raise ValueError(f"Major version {version_int[0]} is not supported.")
+    if version_int[1] not in PipetteModelMinorVersion:
+        raise ValueError(f"Minor version {version_int[1]} is not supported.")
+    return version
+
+
+def save_data_to_file(
+    directorypath: Path,
+    file_name: str,
+    data: Dict[str, Any],
+) -> None:
+    """
+    Function used to save data to a file
+    """
+    directorypath.mkdir(parents=True, exist_ok=True)
+    filepath = directorypath / f"{file_name}.json"
+    with open(filepath, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def update(
+    dict_to_update: Dict[str, Any], iter_of_configs: Iterator[str], value_to_update: Any
+) -> Dict[str, Any]:
+    """
+    Recursively update the given dictionary to ensure no data is lost when updating.
+    """
+    next_key = next(iter_of_configs, None)
+    if next_key and isinstance(dict_to_update.get(next_key), dict):
+        dict_to_update[next_key] = update(
+            dict_to_update.get(next_key, {}), iter_of_configs, value_to_update
+        )
+    elif next_key:
+        dict_to_update[next_key] = value_to_update
+    return dict_to_update
+
+
+def build_nozzle_map(
+    nozzle_offset: List[float], channels: PipetteChannelType
+) -> Dict[str, List[float]]:
+    Y_OFFSET = -9
+    X_OFFSET = 9
+    if channels == PipetteChannelType.SINGLE_CHANNEL:
+        return {"A1": nozzle_offset}
+    elif channels == PipetteChannelType.EIGHT_CHANNEL:
+        return {
+            f"{chr(ord('A') + 1*row)}1": [
+                nozzle_offset[0],
+                nozzle_offset[1] + Y_OFFSET * row,
+                nozzle_offset[2],
+            ]
+            for row in range(8)
+        }
+    elif channels == PipetteChannelType.NINETY_SIX_CHANNEL:
+        return {
+            f"{chr(ord('A') + 1*row)}{1 + 1*col}": [
+                nozzle_offset[0] + X_OFFSET * col,
+                nozzle_offset[1] + Y_OFFSET * row,
+                nozzle_offset[2],
+            ]
+            for row in range(8)
+            for col in range(12)
+        }
+    raise ValueError(f"Unsupported channel type {channels}")
+
+
+def load_and_update_file_from_config(
+    config_to_update: List[str],
+    value_to_update: Any,
+    model_to_update: PipetteModelVersionType,
+) -> None:
+    """Update the requested config and save to disk.
+
+    Load the requested config sub type (physical, geometry or liquid). Then
+    update the current file and save to disk.
+
+    """
+    camel_list_to_update = iter([_change_to_camel_case(i) for i in config_to_update])
+
+    if config_to_update[0] in PipetteGeometryDefinition.__fields__:
+        geometry = _geometry(
+            model_to_update.pipette_channels,
+            model_to_update.pipette_type,
+            model_to_update.pipette_version,
+        )
+        if config_to_update[0] == "nozzle_map":
+            nozzle_to_use = (
+                value_to_update if value_to_update else geometry["nozzleOffset"]
+            )
+            geometry["nozzleMap"] = build_nozzle_map(
+                nozzle_to_use, model_to_update.pipette_channels
+            )
+        elif config_to_update[0] == "nozzle_offset":
+            geometry["nozzleMap"] = build_nozzle_map(
+                value_to_update, model_to_update.pipette_channels
+            )
+            geometry["nozzleOffset"] = value_to_update
+        else:
+            geometry = update(geometry, camel_list_to_update, value_to_update)
+        PipetteGeometryDefinition.parse_obj(geometry)
+
+        filepath = (
+            ROOT
+            / "geometry"
+            / model_to_update.pipette_channels.name.lower()
+            / model_to_update.pipette_type.value
+        )
+        save_data_to_file(
+            filepath,
+            f"{model_to_update.pipette_version.major}_{model_to_update.pipette_version.minor}",
+            geometry,
+        )
+    elif config_to_update[0] in PipettePhysicalPropertiesDefinition.__fields__:
+        physical = _physical(
+            model_to_update.pipette_channels,
+            model_to_update.pipette_type,
+            model_to_update.pipette_version,
+        )
+
+        physical = update(physical, camel_list_to_update, value_to_update)
+
+        PipettePhysicalPropertiesDefinition.parse_obj(physical)
+        filepath = (
+            ROOT
+            / "general"
+            / model_to_update.pipette_channels.name.lower()
+            / model_to_update.pipette_type.value
+        )
+        save_data_to_file(
+            filepath,
+            f"{model_to_update.pipette_version.major}_{model_to_update.pipette_version.minor}",
+            physical,
+        )
+    elif config_to_update[0] == "liquid_properties":
+        next(camel_list_to_update)
+        liquid = _liquid(
+            model_to_update.pipette_channels,
+            model_to_update.pipette_type,
+            model_to_update.pipette_version,
+        )
+
+        print(
+            "Please select what liquid class you wish to update.\n If you want to update all liquid classes then type 'all'.\n"
+        )
+
+        print(f"choose {LiquidClasses.__name__} or type 'all':")
+        for row in list_available_enum(LiquidClasses):
+            print(f"\t{row}")
+        liquid_classes = input("liquid class: ")
+        if liquid_classes == "all":
+            for c in LiquidClasses:
+                liquid = update(
+                    liquid[c.name.lower()], camel_list_to_update, value_to_update
+                )
+
+                PipetteLiquidPropertiesDefinition.parse_obj(liquid)
+                filepath = (
+                    ROOT
+                    / "liquid"
+                    / model_to_update.pipette_channels.name.lower()
+                    / model_to_update.pipette_type.value
+                    / c.name.lower()
+                )
+                save_data_to_file(
+                    filepath,
+                    f"{model_to_update.pipette_version.major}_{model_to_update.pipette_version.minor}",
+                    liquid,
+                )
+        else:
+            lc = list(LiquidClasses)[int(liquid_classes)]
+            liquid = update(
+                liquid[lc.name.lower()], camel_list_to_update, value_to_update
+            )
+            PipetteLiquidPropertiesDefinition.parse_obj(liquid)
+
+            filepath = (
+                ROOT
+                / "liquid"
+                / model_to_update.pipette_channels.name.lower()
+                / model_to_update.pipette_type.value
+                / lc.name.lower()
+            )
+            save_data_to_file(
+                filepath,
+                f"{model_to_update.pipette_version.major}_{model_to_update.pipette_version.minor}",
+                liquid,
+            )
+    else:
+        raise KeyError(
+            f"{config_to_update} is not saved to a file. Check `pipette_definition.py` for more information."
+        )
+
+
+def _update_single_model(configuration_to_update: List[str]) -> None:
+    """Helper function to update single model."""
+    print(f"choose {PipetteModelType.__name__}:")
+    for row in list_available_enum(PipetteModelType):
+        print(f"\t{row}")
+    model = list(PipetteModelType)[int(input("Please select from above\n"))]
+
+    print(f"choose {PipetteChannelType.__name__}:")
+    for row in list_available_enum(PipetteChannelType):
+        print(f"\t{row}")
+    channels = list(PipetteChannelType)[int(input("Please select from above\n"))]
+
+    version = PipetteVersionType.convert_from_float(
+        float(check_from_version(input("Please input the version of the model\n")))
+    )
+
+    built_model: PipetteModel = PipetteModel(
+        f"{model.name}_{str(channels)}_v{version.major}.{version.minor}"
+    )
+
+    if configuration_to_update[0] == NOZZLE_LOCATION_CONFIGS[1]:
+        print(
+            "You selected nozzle_map to edit. If you wish to update the nozzle offset, enter it on the next line.\n"
+        )
+        print("Otherwise, please type 'null' on the next line.\n")
+
+    value_to_update = json.loads(
+        input(
+            f"Please select what you would like to update {configuration_to_update[-1]} to for {built_model}\n"
+        )
+    )
+
+    model_version = convert_pipette_model(built_model)
+
+    load_and_update_file_from_config(
+        configuration_to_update, value_to_update, model_version
+    )
+
+
+def _update_all_models(configuration_to_update: List[str]) -> None:
+    paths_to_validate = ROOT / "general"
+    _channel_model_str = {
+        "single_channel": "single",
+        "ninety_six_channel": "96",
+        "eight_channel": "multi",
+    }
+
+    for channel_dir in os.listdir(paths_to_validate):
+        for model_dir in os.listdir(paths_to_validate / channel_dir):
+            for version_file in os.listdir(paths_to_validate / channel_dir / model_dir):
+                version_list = version_file.split(".json")[0].split("_")
+                built_model: PipetteModel = PipetteModel(
+                    f"{model_dir}_{_channel_model_str[channel_dir]}_v{version_list[0]}.{version_list[1]}"
+                )
+
+                if configuration_to_update[0] == NOZZLE_LOCATION_CONFIGS[1]:
+                    print(
+                        "You selected nozzle_map to edit. If you wish to update the nozzle offset, enter it on the next line.\n"
+                    )
+                    print("Otherwise, please type 'null' on the next line.\n")
+
+                value_to_update = json.loads(
+                    input(
+                        f"Please select what you would like to update {configuration_to_update} to for {built_model}\n"
+                    )
+                )
+
+                model_version = convert_pipette_model(built_model)
+                load_and_update_file_from_config(
+                    configuration_to_update, value_to_update, model_version
+                )
+
+
+def determine_models_to_update(update_all_models: bool) -> None:
+    try:
+        while True:
+            print(f"choose {PipetteConfigurations.__name__}:")
+            config_list, table_lookup = list_configuration_keys()
+            for row in config_list:
+                print(f"\t{row}")
+
+            configuration_to_update = [
+                table_lookup[int(input("select a configuration from above\n"))]
+            ]
+
+            if configuration_to_update[0] == NOZZLE_LOCATION_CONFIGS[0]:
+                print(
+                    f"NOTE: updating the {configuration_to_update[0]} will automatically update the {NOZZLE_LOCATION_CONFIGS[1]}\n"
+                )
+
+            field_type = PipetteConfigurations.__fields__[
+                configuration_to_update[0]
+            ].type_
+            is_basemodel = isinstance(field_type, ModelMetaclass)
+
+            configuration_to_update = handle_subclass_model(
+                configuration_to_update, field_type, is_basemodel
+            )
+            if update_all_models:
+                _update_all_models(configuration_to_update)
+            else:
+                _update_single_model(configuration_to_update)
+    except KeyboardInterrupt:
+        print("Finished updating! Validate that your files updated successfully.")
+
+
+def main() -> None:
+    """Entry point."""
+    parser = argparse.ArgumentParser(
+        description="96 channel tip handling testing script."
+    )
+    parser.add_argument(
+        "--update_all_models",
+        type=bool,
+        help="update all",
+        default=False,
+    )
+
+    args = parser.parse_args()
+
+    determine_models_to_update(args.update_all_models)
+
+
+if __name__ == "__main__":
+    """
+    A script to automate building a pipette configuration definition.
+
+    This script can either perform migrations from a v1 -> v2 schema format
+    or build a brand new script from scratch.
+
+    When building a new pipette configuration model, you will either need
+    to provide CSVs or use command line inputs.
+
+    If you choose CSVs you will need one CSV for the general pipette configuration
+    data (such as pipette model or number of channels) and one for every tip
+    type that this pipette model can support.
+    """
+    main()

package/python/opentrons_shared_data/pipette/types.py

@@ -0,0 +1,193 @@
+import enum
+from dataclasses import dataclass
+from typing import Union, Dict, Mapping, Tuple, cast
+from typing_extensions import Literal
+
+"""Pipette Definition V2 Types"""
+
+# Needed for Int Comparison. Keeping it next to
+# the Literal type for ease of readability
+PipetteModelMajorVersion = [1, 2, 3]
+PipetteModelMinorVersion = [0, 1, 2, 3, 4, 5, 6]
+
+# TODO Literals are only good for writing down
+# exact values. Is there a better typing mechanism
+# so we don't need to keep track of versions in two
+# different places?
+PipetteModelMajorVersionType = Literal[1, 2, 3]
+PipetteModelMinorVersionType = Literal[0, 1, 2, 3, 4, 5, 6]
+
+
+class LiquidClasses(enum.Enum):
+    default = enum.auto()
+    lowVolumeDefault = enum.auto()
+
+
+class PipetteTipType(enum.Enum):
+    t10 = 10
+    t20 = 20
+    t50 = 50
+    t200 = 200
+    t300 = 300
+    t1000 = 1000
+
+    @classmethod
+    def check_and_return_type(
+        cls, working_volume: int, maximum_volume: int
+    ) -> "PipetteTipType":
+        try:
+            return cls(working_volume)
+        except ValueError:
+            return cls(maximum_volume)
+
+
+class PipetteChannelType(int, enum.Enum):
+    SINGLE_CHANNEL = 1
+    EIGHT_CHANNEL = 8
+    NINETY_SIX_CHANNEL = 96
+
+    def __str__(self) -> str:
+        if self.value == 96:
+            return "96"
+        elif self.value == 8:
+            return "multi"
+        else:
+            return "single"
+
+
+class PipetteModelType(enum.Enum):
+    p10 = "p10"
+    p20 = "p20"
+    p50 = "p50"
+    p300 = "p300"
+    p1000 = "p1000"
+
+
+class PipetteGenerationType(enum.Enum):
+    GEN1 = "GEN1"
+    GEN2 = "GEN2"
+    FLEX = "FLEX"
+
+
+@dataclass(frozen=True)
+class PipetteVersionType:
+    major: PipetteModelMajorVersionType
+    minor: PipetteModelMinorVersionType
+
+    @classmethod
+    def convert_from_float(cls, version: float) -> "PipetteVersionType":
+        major = cast(PipetteModelMajorVersionType, int(version // 1))
+        minor = cast(PipetteModelMinorVersionType, int(round((version % 1), 2) * 10))
+        return cls(major=major, minor=minor)
+
+    def __str__(self) -> str:
+        if self.major == 1 and self.minor == 0:
+            # Maintain the format of V1 pipettes that
+            # do not contain a minor version at all.
+            return f"{self.major}"
+        else:
+            return f"{self.major}.{self.minor}"
+
+    @property
+    def as_tuple(
+        self,
+    ) -> Tuple[PipetteModelMajorVersionType, PipetteModelMinorVersionType]:
+        return (self.major, self.minor)
+
+
+"""Mutable Configs Types"""
+
+
+class Quirks(enum.Enum):
+    pickupTipShake = "pickupTipShake"
+    dropTipShake = "dropTipShake"
+    doubleDropTip = "doubleDropTip"
+    needsUnstick = "needsUnstick"
+
+
+class AvailableUnits(enum.Enum):
+    mm = "mm"
+    amps = "amps"
+    speed = "mm/s"
+    presses = "presses"
+
+
+@dataclass
+class RobotMountConfigs:
+    stepsPerMM: float
+    homePosition: float
+    travelDistance: float
+
+
+@dataclass
+class MutableConfig:
+    value: Union[int, float]
+    default: Union[int, float]
+    units: AvailableUnits
+    type: str
+    min: float
+    max: float
+    name: str
+
+    @classmethod
+    def build(
+        cls,
+        value: Union[int, float],
+        default: Union[int, float],
+        units: str,
+        type: str,
+        min: float,
+        max: float,
+        name: str,
+    ) -> "MutableConfig":
+        if units == "mm/sec":
+            units = "mm/s"
+        return cls(
+            value=value,
+            default=default,
+            units=AvailableUnits(units),
+            type=type,
+            min=min,
+            max=max,
+            name=name,
+        )
+
+    def validate_and_add(self, new_value: Union[int, float]) -> None:
+        if new_value < self.min or new_value > self.max:
+            raise ValueError(f"{self.name} out of range with {new_value}")
+        self.value = new_value
+
+    def dict_for_encode(self) -> Dict[str, Union[int, float, str]]:
+        return {
+            "value": self.value,
+            "default": self.default,
+            "units": self.units.value,
+            "type": self.type,
+            "min": self.min,
+            "max": self.max,
+        }
+
+
+@dataclass
+class QuirkConfig:
+    value: bool
+    name: Quirks
+
+    @classmethod
+    def validate_and_build(cls, name: str, value: bool) -> "QuirkConfig":
+        quirk_name = Quirks(name)
+        cls.validate(name, value)
+        return cls(value=value, name=quirk_name)
+
+    @classmethod
+    def validate(cls, name: str, value: bool) -> None:
+        if not isinstance(value, bool):
+            raise ValueError(f"{value} is invalid for {name}")
+
+    def dict_for_encode(self) -> bool:
+        return self.value
+
+
+TypeOverrides = Mapping[str, Union[float, bool, None]]
+
+OverrideType = Dict[str, Union[Dict[str, QuirkConfig], MutableConfig, str]]

package/python/opentrons_shared_data/protocol/__init__.py

@@ -0,0 +1,13 @@
+"""
+opentrons_shared_data.protocol: types and bindings for json protocols
+"""
+import json
+from typing import Any, NewType, Dict
+
+from .. import load_shared_data
+
+Schema = NewType("Schema", Dict[str, Any])
+
+
+def load_schema(version: int) -> "Schema":
+    return json.loads(load_shared_data(f"protocol/schemas/{version}.json"))