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

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

@@ -0,0 +1,402 @@
+import logging
+import json
+import re
+from pathlib import Path
+from typing import Optional, List, Dict, Any, cast
+
+from .pipette_definition import PipetteConfigurations, PipetteModelVersionType
+from .model_constants import (
+    MUTABLE_CONFIGS_V1,
+    VALID_QUIRKS,
+    _MAP_KEY_TO_V2,
+    _MIN_MAX_LOOKUP,
+    _TYPE_LOOKUP,
+    _UNITS_LOOKUP,
+)
+from .load_data import load_definition, load_serial_lookup_table
+from .types import (
+    MutableConfig,
+    Quirks,
+    QuirkConfig,
+    TypeOverrides,
+    OverrideType,
+    LiquidClasses,
+)
+from .pipette_load_name_conversions import (
+    convert_pipette_model,
+    convert_to_pipette_name_type,
+)
+from .file_operation_helpers import (
+    MutableConfigurationEncoder,
+    MutableConfigurationDecoder,
+)
+from .dev_types import PipetteModel, PipetteName
+
+
+log = logging.getLogger(__name__)
+
+PIPETTE_SERIAL_MODEL_LOOKUP = load_serial_lookup_table()
+SERIAL_STUB_REGEX = re.compile(r"P[0-9]{1,3}[KSMHV]{1,2}V[0-9]{2}")
+LIQUID_CLASS = LiquidClasses.default
+
+
+def _migrate_to_v2_configurations(
+    base_configurations: PipetteConfigurations,
+    v1_mutable_configs: OverrideType,
+) -> PipetteConfigurations:
+    """Helper function to migration V1 Configs to the V2 format.
+
+    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_mutable_configs.items():
+        if isinstance(v, str):
+            # ignore the saved model
+            continue
+        if isinstance(v, bool):
+            # ignore any accidental top level quirks.
+            continue
+        if c == "quirks" and isinstance(v, dict):
+            quirks_list.extend([b.name for b in v.values() if b.value])
+        else:
+            new_names = _MAP_KEY_TO_V2[c]
+            top_name = new_names["top_level_name"]
+            nested_name = new_names["nested_name"]
+            if c == "tipLength" and isinstance(v, MutableConfig):
+                # 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
+            elif new_names.get("liquid_class") and isinstance(v, MutableConfig):
+                _class = LiquidClasses[new_names["liquid_class"]]
+                dict_of_base_model[top_name][_class][nested_name] = v.value
+            elif isinstance(v, MutableConfig):
+                # isinstances are needed for type checking.
+                dict_of_base_model[top_name][nested_name] = v.value
+    dict_of_base_model["quirks"] = list(
+        set(dict_of_base_model["quirks"]).union(set(quirks_list))
+    )
+
+    # re-serialization is not great for this nested enum so we need
+    # to perform this workaround.
+    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_available_overrides(
+    pipette_serial_number: str, pipette_override_path: Path
+) -> OverrideType:
+    """Load the available overrides from disk."""
+    pipette_override = pipette_override_path / f"{pipette_serial_number}.json"
+    try:
+        with open(pipette_override, "r") as f:
+            return json.load(f, cls=MutableConfigurationDecoder)
+    except json.JSONDecodeError as e:
+        log.warning(f"pipette override for {pipette_serial_number} is corrupt: {e}")
+        pipette_override.unlink()
+        raise FileNotFoundError()
+
+
+def _list_all_mutable_configs(
+    on_disk_overrides: OverrideType, base_configurations: Dict[str, Any]
+) -> OverrideType:
+    """Get all available mutable configurations"""
+    all_mutable_configs = set([*MUTABLE_CONFIGS_V1, *VALID_QUIRKS]) - set(["quirks"])
+    on_disk_configs = set(
+        [
+            v.name
+            for v in on_disk_overrides.values()
+            if isinstance(v, MutableConfig) or isinstance(v, QuirkConfig)
+        ]
+    )
+
+    missing_configurations = all_mutable_configs.difference(on_disk_configs)
+
+    default_configurations: OverrideType = {"quirks": {}}
+    for c in missing_configurations:
+        if c in VALID_QUIRKS:
+            if Quirks(c) in base_configurations["quirks"]:
+                default_configurations["quirks"][c] = QuirkConfig.validate_and_build(  # type: ignore
+                    c, True
+                )
+        else:
+            default_configurations[c] = _find_default(c, base_configurations)
+    default_configurations.update(on_disk_overrides)
+    return default_configurations
+
+
+def _find_default(name: str, configs: Dict[str, Any]) -> MutableConfig:
+    """Find the default value from the configs and return it as a mutable config."""
+    lookup_dict = _MAP_KEY_TO_V2[name]
+    nested_name = lookup_dict["nested_name"]
+
+    min_max_dict = _MIN_MAX_LOOKUP[nested_name]
+    type_lookup = _TYPE_LOOKUP[nested_name]
+    units_lookup = _UNITS_LOOKUP[nested_name]
+    if name == "tipLength":
+        # This is only a concern for OT-2 configs and I think we can
+        # be less smart about handling multiple tip types. Instead, just
+        # get the max tip type.
+        tip_list = list(
+            configs["liquid_properties"][LIQUID_CLASS][
+                lookup_dict["top_level_name"]
+            ].keys()
+        )
+        tip_list.sort(key=lambda o: o.value)
+        default_value = configs["liquid_properties"][LIQUID_CLASS][
+            lookup_dict["top_level_name"]
+        ][tip_list[-1]][nested_name]
+    elif lookup_dict.get("liquid_class"):
+        _class = LiquidClasses[lookup_dict["liquid_class"]]
+        default_value = configs[lookup_dict["top_level_name"]][_class][nested_name]
+    else:
+        default_value = configs[lookup_dict["top_level_name"]][nested_name]
+    return MutableConfig(
+        value=default_value,
+        default=default_value,
+        min=min_max_dict["min"],
+        max=min_max_dict["max"],
+        type=type_lookup,
+        units=units_lookup,
+        name=name,
+    )
+
+
+def known_pipettes(pipette_override_path: Path) -> List[str]:
+    """List pipette IDs for which we have known overrides"""
+    return [
+        fi.stem
+        for fi in pipette_override_path.iterdir()
+        if fi.is_file() and ".json" in fi.suffixes
+    ]
+
+
+def _load_full_mutable_configs(
+    pipette_model: PipetteModelVersionType, overrides: OverrideType
+) -> OverrideType:
+    base_configs = load_definition(
+        pipette_model.pipette_type,
+        pipette_model.pipette_channels,
+        pipette_model.pipette_version,
+    )
+    base_configs_dict = base_configs.dict(by_alias=True)
+    full_mutable_configs = _list_all_mutable_configs(overrides, base_configs_dict)
+
+    if not full_mutable_configs.get("name"):
+        full_mutable_configs["name"] = str(
+            convert_to_pipette_name_type(cast(PipetteName, str(pipette_model)))
+        )
+
+    if not full_mutable_configs.get("model"):
+        full_mutable_configs["model"] = str(pipette_model)
+
+    return full_mutable_configs
+
+
+def list_mutable_configs(
+    pipette_serial_number: str, pipette_override_path: Path
+) -> OverrideType:
+    """
+    Returns dict of mutable configs only.
+    """
+
+    mutable_configs: OverrideType = {}
+
+    try:
+        mutable_configs = _load_available_overrides(
+            pipette_serial_number, pipette_override_path
+        )
+    except FileNotFoundError:
+        log.info(f"Pipette id {pipette_serial_number} not found")
+        # This is mimicing behavior from the original file
+        # which returned an empty dict if no on disk value was found.
+        return mutable_configs
+
+    serial_key_match = SERIAL_STUB_REGEX.match(pipette_serial_number)
+
+    if serial_key_match:
+        serial_key = serial_key_match.group(0)
+    else:
+        serial_key = ""
+    pipette_model = convert_pipette_model(
+        cast(PipetteModel, PIPETTE_SERIAL_MODEL_LOOKUP[serial_key])
+    )
+    return _load_full_mutable_configs(pipette_model, mutable_configs)
+
+
+def list_mutable_configs_with_defaults(
+    pipette_model: PipetteModelVersionType,
+    pipette_serial_number: Optional[str],
+    pipette_override_path: Path,
+) -> OverrideType:
+    """
+    Returns dict of mutable configs only, with their defaults.
+    """
+    mutable_configs: OverrideType = {}
+    if pipette_serial_number:
+        try:
+            mutable_configs = _load_available_overrides(
+                pipette_serial_number, pipette_override_path
+            )
+        except FileNotFoundError:
+            pass
+    return _load_full_mutable_configs(pipette_model, mutable_configs)
+
+
+def load_with_mutable_configurations(
+    pipette_model: PipetteModelVersionType,
+    pipette_override_path: Path,
+    pipette_serial_number: Optional[str] = None,
+) -> PipetteConfigurations:
+    """
+    Load pipette config data with any overrides available.
+
+    This function reads from disk each time, so changes to the overrides
+    will be picked up in subsequent calls.
+
+    :param str pipette_model: The pipette model name (i.e. "p10_single_v1.3")
+                              for which to load configuration
+    :param pipette_serial_number: An (optional) unique ID for the pipette to locate
+                       config overrides. If the ID is not specified, the system
+                       assumes this is a simulated pipette and does not
+                       save settings. If the ID is specified but no overrides
+                       corresponding to the ID are found, the system creates a
+                       new overrides file for it.
+    :type pipette_serial_number: str or None
+    :raises KeyError: if ``pipette_model`` is not in the top-level keys of
+                      the pipetteModelSpecs.json file (and therefore not in
+                      :py:attr:`configs`)
+
+    :returns PipetteConfig: The configuration, loaded and checked
+    """
+    base_configurations = load_definition(
+        pipette_model.pipette_type,
+        pipette_model.pipette_channels,
+        pipette_model.pipette_version,
+    )
+    # Load overrides if we have a pipette id
+    if pipette_serial_number:
+        try:
+            override = _load_available_overrides(
+                pipette_serial_number, pipette_override_path
+            )
+        except FileNotFoundError:
+            pass
+        else:
+            base_configurations = _migrate_to_v2_configurations(
+                base_configurations, override
+            )
+    # the ulPerMm functions are structured in pipetteModelSpecs.json as
+    # a list sorted from oldest to newest. That means the latest functions
+    # are always the last element and, as of right now, the older ones are
+    # the first element (for models that only have one function, the first
+    # and last elements are the same, which is fine). If we add more in the
+    # future, we’ll have to change this code to select items more
+    # intelligently
+    # TODO (lc 06/27) Handle versioned ul per mm
+
+    return base_configurations
+
+
+def _add_new_overrides_to_existing(  # noqa: C901
+    base_configs_dict: Dict[str, Any],
+    existing_overrides: OverrideType,
+    overrides: TypeOverrides,
+) -> OverrideType:
+    """Helper function to add new overrides to the existing ones"""
+    # FIXME remove the validation here for the file save and rely
+    # on the validation in the robot server. We unfortunately have
+    # to keep the validation here until we decide to fully wipe/migrate
+    # files saved on disk because some of them have unexpected
+    # data entries.
+    if not existing_overrides.get("quirks"):
+        existing_overrides["quirks"] = {}
+    for key, value in overrides.items():
+        # If an existing override is saved as null from endpoint, remove from
+        # overrides file
+        if value is None and existing_overrides.get(key):
+            del existing_overrides[key]
+        elif isinstance(value, bool):
+            if key in VALID_QUIRKS:
+                existing_overrides["quirks"][key] = QuirkConfig.validate_and_build(  # type: ignore
+                    key, value
+                )
+            elif key not in MUTABLE_CONFIGS_V1:
+                # Unfortunately, some of the files got corrupted,
+                # so we have to check that the key doesn't exist
+                # in mutable configs before throwing an error.
+                raise ValueError(
+                    f"{value} is invalid for {key} or {key} is not a supported quirk."
+                )
+            elif existing_overrides.get(key):
+                del existing_overrides[key]
+        elif value:
+            if existing_overrides.get(key):
+                existing_overrides[key].validate_and_add(value)  # type: ignore
+            else:
+                new_mutable_config = _find_default(key, base_configs_dict)
+                new_mutable_config.validate_and_add(value)
+                existing_overrides[key] = new_mutable_config
+    return existing_overrides
+
+
+def save_overrides(
+    pipette_serial_number: str, overrides: TypeOverrides, pipette_override_path: Path
+) -> None:
+    """
+    Save overrides for the pipette.
+
+    :param pipette_id: The pipette id
+    :param overrides: The incoming values
+    :return: None
+    """
+    # need to load defaults
+    serial_key_match = SERIAL_STUB_REGEX.match(pipette_serial_number)
+    if serial_key_match:
+        serial_key = serial_key_match.group(0)
+    else:
+        serial_key = ""
+    pipette_model = convert_pipette_model(
+        cast(PipetteModel, PIPETTE_SERIAL_MODEL_LOOKUP[serial_key])
+    )
+
+    base_configs = load_definition(
+        pipette_model.pipette_type,
+        pipette_model.pipette_channels,
+        pipette_model.pipette_version,
+    )
+    base_configs_dict = base_configs.dict(by_alias=True)
+    try:
+        existing_overrides = _load_available_overrides(
+            pipette_serial_number, pipette_override_path
+        )
+    except FileNotFoundError:
+        existing_overrides = {"quirks": {}}
+
+    updated_overrides = _add_new_overrides_to_existing(
+        base_configs_dict, existing_overrides, overrides
+    )
+
+    if not updated_overrides.get("model"):
+        updated_overrides["model"] = str(pipette_model)
+
+    with open(pipette_override_path / f"{pipette_serial_number}.json", "w") as file:
+        json.dump(updated_overrides, file, cls=MutableConfigurationEncoder)