@opentrons/shared-data 0.1.7-alpha.1 → 0.2.1-alpha.0

package/python_tests/liquid_classes/test_liquid_class_values.py

@@ -0,0 +1,59 @@
+"""Tests for the default values in built-in liquid class definitions."""
+import pytest
+from typing import List
+
+from opentrons_shared_data import get_shared_data_root
+from opentrons_shared_data.liquid_classes import load_definition
+
+
+def _get_all_liquid_classes() -> List[str]:
+    return [
+        deffile.stem
+        for deffile in (
+            get_shared_data_root() / "liquid-class" / "definitions" / "1"
+        ).iterdir()
+    ]
+
+
+@pytest.mark.parametrize("liquid_class_name", list(_get_all_liquid_classes()))
+def test_correction_values_equal_each_other(liquid_class_name: str) -> None:
+    """The correction volume values for each pipette/tiprack combo should all be equal to one another."""
+    liquid_class_def = load_definition(liquid_class_name, version=1, schema_version=1)
+    incorrect_combos = []
+    for by_pipette in liquid_class_def.byPipette:
+        for liquid_class_props in by_pipette.byTipType:
+            if liquid_class_props.multiDispense is None:
+                continue
+            aspirate_correction = liquid_class_props.aspirate.correctionByVolume
+            dispense_correction = liquid_class_props.singleDispense.correctionByVolume
+            multi_dispense_correction = (
+                liquid_class_props.multiDispense.correctionByVolume
+            )
+            if (
+                aspirate_correction != dispense_correction
+                or dispense_correction != multi_dispense_correction
+            ):
+                incorrect_combos.append(
+                    f"{by_pipette.pipetteModel} {liquid_class_props.tiprack}"
+                )
+    assert incorrect_combos == []
+
+
+@pytest.mark.parametrize("liquid_class_name", list(_get_all_liquid_classes()))
+def test_flow_rates_equal_each_other(liquid_class_name: str) -> None:
+    """The dispense flow rate values for each pipette/tiprack combo should all be equal to one another."""
+    liquid_class_def = load_definition(liquid_class_name, version=1, schema_version=1)
+    incorrect_combos = []
+    for by_pipette in liquid_class_def.byPipette:
+        for liquid_class_props in by_pipette.byTipType:
+            if liquid_class_props.multiDispense is None:
+                continue
+            dispense_flow_rates = liquid_class_props.singleDispense.flowRateByVolume
+            multi_dispense_flow_rates = (
+                liquid_class_props.multiDispense.flowRateByVolume
+            )
+            if dispense_flow_rates != multi_dispense_flow_rates:
+                incorrect_combos.append(
+                    f"{by_pipette.pipetteModel} {liquid_class_props.tiprack}"
+                )
+    assert incorrect_combos == []

package/python_tests/liquid_classes/test_load.py

@@ -0,0 +1,45 @@
+import json
+
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.liquid_classes import load_definition, definition_exists
+from opentrons_shared_data.liquid_classes.liquid_class_definition import (
+    LiquidClassSchemaV1,
+    PositionReference,
+    Coordinate,
+    TipPosition,
+    Submerge,
+    DelayParams,
+    DelayProperties,
+)
+
+
+def test_load_liquid_class_schema_v1() -> None:
+    fixture_data = load_shared_data("liquid-class/definitions/1/water/1.json")
+    liquid_class_model = LiquidClassSchemaV1.model_validate_json(fixture_data)
+    liquid_class_def_from_model = json.loads(
+        liquid_class_model.model_dump_json(exclude_unset=True)
+    )
+    expected_liquid_class_def = json.loads(fixture_data)
+    assert liquid_class_def_from_model == expected_liquid_class_def
+
+
+def test_load_definition() -> None:
+    water_definition = load_definition(name="water", version=1, schema_version=1)
+    assert type(water_definition) is LiquidClassSchemaV1
+    assert water_definition.byPipette[0].pipetteModel == "flex_1channel_50"
+    assert water_definition.byPipette[0].byTipType[0].aspirate.submerge == Submerge(
+        startPosition=TipPosition(
+            positionReference=PositionReference.WELL_TOP,
+            offset=Coordinate(x=0, y=0, z=2),
+        ),
+        speed=100,
+        delay=DelayProperties(enable=False, params=DelayParams(duration=0)),
+    )
+
+
+def test_definition_exists() -> None:
+    """Should return whether specified definition exists in shared data or not."""
+    assert definition_exists(name="water", version=1) is True
+    assert definition_exists(name="glycerol_50", version=1) is True
+    assert definition_exists(name="glycerol_oh_no", version=1) is False
+    assert definition_exists(name="glycerol_50", version=2) is False

package/python_tests/liquid_classes/test_validations.py

@@ -0,0 +1,192 @@
+"""Tests that validate the built-in liquid class definitions."""
+import pytest
+from typing import List, Dict, Any
+
+from opentrons_shared_data import get_shared_data_root
+from opentrons_shared_data.liquid_classes import load_definition
+from opentrons_shared_data.liquid_classes.liquid_class_definition import (
+    DelayProperties,
+    MixProperties,
+    TouchTipProperties,
+    BlowoutProperties,
+    BlowoutLocation,
+    AspirateProperties,
+    PositionReference,
+    SingleDispenseProperties,
+    MultiDispenseProperties,
+    TransferProperties,
+)
+
+
+def _get_all_liquid_classes() -> List[str]:
+    return [
+        deffile.stem
+        for deffile in (
+            get_shared_data_root() / "liquid-class" / "definitions" / "1"
+        ).iterdir()
+    ]
+
+
+@pytest.mark.parametrize("liquid_class_name", list(_get_all_liquid_classes()))
+def test_validate_unique_pipette_keys(liquid_class_name: str) -> None:
+    """A liquid class definition should contain only one set of properties per pipette model."""
+    definition_dict = load_definition(liquid_class_name, version=1, schema_version=1)
+    pipette_models = [prop.pipetteModel for prop in definition_dict.byPipette]
+    assert len(pipette_models) == len(set(pipette_models))
+
+
+@pytest.mark.parametrize("liquid_class_name", list(_get_all_liquid_classes()))
+def test_validate_unique_tip_keys(liquid_class_name: str) -> None:
+    """A liquid class definition should contain only one set of properties per tip type."""
+    definition_dict = load_definition(liquid_class_name, version=1, schema_version=1)
+
+    for by_pip_prop in definition_dict.byPipette:
+        tipracks = [tip_prop.tiprack for tip_prop in by_pip_prop.byTipType]
+        assert len(tipracks) == len(set(tipracks))
+
+
+def test_validate_delay_properties_dict() -> None:
+    """Delay properties model validator should convert valid dict to DelayProperties."""
+    obj = DelayProperties.model_validate({"enable": True, "duration": 2})
+    assert isinstance(obj, DelayProperties)
+    assert obj.enable is True
+    assert obj.params.duration == 2  # type: ignore[union-attr]
+
+    with pytest.raises(
+        ValueError,
+        match="Delay properties should specify either duration or params, not both",
+    ):
+        DelayProperties.model_validate(
+            {"enable": False, "params": {"duration": 2}, "duration": 2}
+        )
+
+
+def test_validate_mix_properties_dict() -> None:
+    """Mix properties model validator should convert valid dict to MixProperties."""
+    obj = MixProperties.model_validate({"enable": True, "repetitions": 2, "volume": 3})
+    assert isinstance(obj, MixProperties)
+    assert obj.enable is True
+    assert obj.params is not None
+    assert obj.params.repetitions == 2
+    assert obj.params.volume == 3
+
+    with pytest.raises(
+        ValueError,
+        match="either all of \\['repetitions', 'volume'\\] or 'params', not both",
+    ):
+        MixProperties.model_validate(
+            {"enable": True, "repetitions": 2, "volume": 3, "params": {"foo": "bar"}}
+        )
+
+
+def test_validate_touchtip_properties_dict() -> None:
+    """Touch tip properties model validator should convert valid dict to TouchTipProperties."""
+    obj = TouchTipProperties.model_validate(
+        {"enable": True, "z_offset": 2, "mm_from_edge": 3, "speed": 4}
+    )
+    assert isinstance(obj, TouchTipProperties)
+    assert obj.enable is True
+    assert obj.params is not None
+    assert obj.params.mmFromEdge == 3
+    assert obj.params.speed == 4
+    assert obj.params.zOffset == 2
+
+    with pytest.raises(
+        ValueError,
+        match="either all of \\['z_offset', 'mm_from_edge', 'speed'\\] or 'params', not both",
+    ):
+        TouchTipProperties.model_validate(
+            {
+                "enable": True,
+                "z_offset": 2,
+                "mm_from_edge": 3,
+                "speed": 4,
+                "params": {"foo": "bar"},
+            }
+        )
+
+
+def test_validate_blowout_properties_dict() -> None:
+    """Blowout properties model validator should convert valid dict to BlowoutProperties."""
+    obj = BlowoutProperties.model_validate(
+        {"enable": True, "location": "source", "flow_rate": 3}
+    )
+    assert isinstance(obj, BlowoutProperties)
+    assert obj.enable is True
+    assert obj.params is not None
+    assert obj.params.location == BlowoutLocation.SOURCE
+    assert obj.params.flowRate == 3
+
+    with pytest.raises(
+        ValueError,
+        match="either all of \\['location', 'flow_rate'\\] or 'params', not both",
+    ):
+        BlowoutProperties.model_validate(
+            {
+                "enable": True,
+                "location": "source",
+                "flow_rate": 3,
+                "params": {"foo": "bar"},
+            }
+        )
+
+
+def test_validate_aspirate_properties_dict(
+    sample_transfer_properties_dict: Dict[str, Dict[str, Any]],
+) -> None:
+    """Aspirate properties model validator should convert valid dict to AspirateProperties."""
+    obj = AspirateProperties.model_validate(
+        sample_transfer_properties_dict["flex_1channel_50"][
+            "opentrons/opentrons_flex_96_tiprack_50ul/1"
+        ]["aspirate"]
+    )
+    assert isinstance(obj, AspirateProperties)
+    assert obj.aspiratePosition.positionReference == PositionReference.WELL_BOTTOM
+    assert obj.mix.enable is False
+
+
+def test_validate_single_dispense_properties_dict(
+    sample_transfer_properties_dict: Dict[str, Dict[str, Any]],
+) -> None:
+    """Single dispense properties model validator should convert valid dict to SingleDispenseProperties."""
+    obj = SingleDispenseProperties.model_validate(
+        sample_transfer_properties_dict["flex_1channel_50"][
+            "opentrons/opentrons_flex_96_tiprack_50ul/1"
+        ]["dispense"]
+    )
+    assert isinstance(obj, SingleDispenseProperties)
+    assert obj.dispensePosition.positionReference == PositionReference.WELL_BOTTOM
+    assert obj.mix.enable is False
+
+
+def test_validate_multi_dispense_properties_dict(
+    sample_transfer_properties_dict: Dict[str, Dict[str, Any]],
+) -> None:
+    """Multi dispense properties model validator should convert valid dict to MultiDispenseProperties."""
+    obj = MultiDispenseProperties.model_validate(
+        sample_transfer_properties_dict["flex_1channel_50"][
+            "opentrons/opentrons_flex_96_tiprack_50ul/1"
+        ]["multi_dispense"]
+    )
+    assert isinstance(obj, MultiDispenseProperties)
+    assert obj.dispensePosition.positionReference == PositionReference.WELL_BOTTOM
+    assert obj.conditioningByVolume == [(0, 0)]
+    assert obj.disposalByVolume == [(0, 5)]
+
+
+def test_validate_transfer_properties_dict(
+    sample_transfer_properties_dict: Dict[str, Dict[str, Any]],
+) -> None:
+    """Transfer properties model validator should convert valid dict to TransferProperties."""
+    obj = TransferProperties.model_validate(
+        sample_transfer_properties_dict["flex_1channel_50"][
+            "opentrons/opentrons_flex_96_tiprack_50ul/1"
+        ]
+    )
+    assert isinstance(obj, TransferProperties)
+    assert (
+        obj.aspirate.aspiratePosition.positionReference == PositionReference.WELL_BOTTOM
+    )
+    assert obj.singleDispense.pushOutByVolume == [(10.0, 7.0), (20.0, 10.0)]
+    assert obj.multiDispense.conditioningByVolume == [(0, 0)]  # type: ignore[union-attr]
+    assert obj.multiDispense.disposalByVolume == [(0, 5)]  # type: ignore[union-attr]

package/python_tests/module/__init__.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import List
+
+
+def list_v2_defs() -> List[str]:
+    return [
+        deffile.stem
+        for deffile in (
+            Path(__file__).parent / ".." / ".." / "module" / "definitions" / "2"
+        ).iterdir()
+    ]
+
+
+def list_v3_defs() -> List[str]:
+    return [
+        deffile.stem
+        for deffile in (
+            Path(__file__).parent / ".." / ".." / "module" / "definitions" / "3"
+        ).iterdir()
+    ]

package/python_tests/module/test_load.py

@@ -0,0 +1,49 @@
+import json
+import pytest
+
+from opentrons_shared_data.module import (
+    load_definition,
+    load_schema,
+    ModuleNotFoundError,
+)
+from opentrons_shared_data import load_shared_data
+
+from . import list_v2_defs, list_v3_defs
+
+
+@pytest.mark.parametrize("def_name", list_v3_defs())
+def test_load_v3_defs(def_name: str) -> None:
+    """Test that all v3 definitions load correctly."""
+    assert load_definition("3", def_name) == json.loads(
+        load_shared_data(f"module/definitions/3/{def_name}.json")
+    )
+
+
+@pytest.mark.parametrize("def_name", list_v2_defs())
+def test_load_v2_defs(def_name: str) -> None:
+    assert load_definition("2", def_name) == json.loads(  # type: ignore [call-overload]
+        load_shared_data(f"module/definitions/2/{def_name}.json")
+    )
+
+
+@pytest.mark.parametrize("def_name", ["magdeck", "tempdeck", "thermocycler"])
+def test_load_v1_defs(def_name: str) -> None:
+    assert (
+        load_definition("1", def_name)
+        == json.loads(load_shared_data("module/definitions/1.json"))[def_name]
+    )
+
+
+def test_bad_module_name_throws() -> None:
+    with pytest.raises(ModuleNotFoundError):
+        load_definition("1", "alsjdag")
+
+    with pytest.raises(ModuleNotFoundError):
+        load_definition("2", "asdasda")  # type: ignore[call-overload]
+
+
+@pytest.mark.parametrize("schema_name", ["1", "2", "3"])
+def test_load_schema(schema_name: str) -> None:
+    assert load_schema(schema_name) == json.loads(  # type: ignore[arg-type]
+        load_shared_data(f"module/schemas/{schema_name}.json")
+    )

package/python_tests/module/test_typechecks.py

@@ -0,0 +1,26 @@
+import pytest
+import typeguard
+
+from opentrons_shared_data import module
+from opentrons_shared_data.module import types
+
+from . import list_v2_defs, list_v3_defs
+
+
+@pytest.mark.parametrize("defname", list_v3_defs())
+def test_v3_definitions_match_types(defname: str) -> None:
+    """Test that V3 module definitions match ModuleDefinitionV3."""
+    def_dict = module.load_definition("3", defname)
+    typeguard.check_type(def_dict, types.ModuleDefinitionV3)
+
+
+@pytest.mark.parametrize("defname", list_v2_defs())
+def test_v2_definitions_match_types(defname: str) -> None:
+    defdict = module.load_definition("2", defname)  # type: ignore [call-overload]
+    typeguard.check_type(defdict, types.ModuleDefinitionV2)
+
+
+@pytest.mark.parametrize("defname", ["magdeck", "tempdeck", "thermocycler"])
+def test_v1_definitions_match_types(defname: str) -> None:
+    defdict = module.load_definition("1", defname)
+    typeguard.check_type(defdict, types.ModuleDefinitionV1)

package/python_tests/pipette/test_load_data.py

@@ -0,0 +1,109 @@
+import pytest
+from typing import Dict, Any, cast
+from opentrons_shared_data.pipette import (
+    load_data,
+    pipette_load_name_conversions,
+    types,
+)
+from opentrons_shared_data.pipette.types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteVersionType,
+    PipetteOEMType,
+    PipetteTipType,
+    Quirks,
+    LiquidClasses,
+)
+
+
+def test_load_pipette_definition() -> None:
+    pipette_config_one = load_data.load_definition(
+        PipetteModelType.p50,
+        PipetteChannelType.SINGLE_CHANNEL,
+        PipetteVersionType(major=3, minor=3),
+        PipetteOEMType.OT,
+    )
+
+    assert pipette_config_one.channels == 1
+    assert pipette_config_one.pipette_type.value == "p50"
+    assert pipette_config_one.nozzle_offset == [-8.0, -22.0, -259.15]
+
+    assert (
+        pipette_config_one.liquid_properties[LiquidClasses.default]
+        .supported_tips[PipetteTipType.t50]
+        .default_aspirate_flowrate.default
+        == 8.0
+    )
+
+    assert pipette_config_one.quirks == []
+    pipette_config_two = load_data.load_definition(
+        PipetteModelType.p50,
+        PipetteChannelType.SINGLE_CHANNEL,
+        PipetteVersionType(major=1, minor=0),
+        PipetteOEMType.OT,
+    )
+
+    assert pipette_config_two.channels == 1
+    assert pipette_config_two.pipette_type.value == "p50"
+    assert pipette_config_two.nozzle_offset == [0.0, 0.0, 25.0]
+    assert (
+        pipette_config_two.liquid_properties[LiquidClasses.default]
+        .supported_tips[PipetteTipType.t200]
+        .default_aspirate_flowrate.default
+        == 25.0
+    )
+    assert pipette_config_two.quirks == [Quirks.dropTipShake]
+
+
+@pytest.mark.parametrize(
+    argnames=["key_spot_check", "value_spot_check"],
+    argvalues=[
+        ["P1KSV10", "p1000_single_v1.0"],
+        ["P1KHV33", "p1000_96_v3.3"],
+        ["P20MV21", "p20_multi_v2.1"],
+        ["P300MV10", "p300_multi_v1.0"],
+        ["P3HMV14", "p300_multi_v1.4"],
+    ],
+)
+def test_build_serial_number_lookup(key_spot_check: str, value_spot_check: str) -> None:
+    lookup_table = load_data.load_serial_lookup_table()
+    assert lookup_table[key_spot_check] == value_spot_check
+
+
+@pytest.mark.parametrize(
+    argnames=["pipette_model", "v1_configuration_changes"],
+    argvalues=[
+        ["p300_multi_v1.4", {"max_volume": 200, "min_volume": 10}],
+        ["p1000_96_v3.3", {"tip_length": 40, "min_volume": 300}],
+    ],
+)
+def test_update_pipette_configuration(
+    pipette_model: str, v1_configuration_changes: Dict[str, Any]
+) -> None:
+
+    liquid_class = LiquidClasses.default
+    model_name = pipette_load_name_conversions.convert_pipette_model(
+        cast(types.PipetteModel, pipette_model)
+    )
+    base_configurations = load_data.load_definition(
+        model_name.pipette_type,
+        model_name.pipette_channels,
+        model_name.pipette_version,
+        model_name.oem_type,
+    )
+
+    updated_configurations = load_data.update_pipette_configuration(
+        base_configurations, v1_configuration_changes, liquid_class
+    )
+
+    updated_configurations_dict = updated_configurations.model_dump()
+    for k, v in v1_configuration_changes.items():
+        if k == "tip_length":
+            for i in updated_configurations_dict["liquid_properties"][liquid_class][
+                "supported_tips"
+            ].values():
+                assert i["default_tip_length"] == v
+        else:
+            assert (
+                updated_configurations_dict["liquid_properties"][liquid_class][k] == v
+            )

package/python_tests/pipette/test_max_flow_rates_per_volume.py

@@ -0,0 +1,112 @@
+import os
+import pytest
+from typing import Iterator
+from opentrons_shared_data import get_shared_data_root
+from opentrons_shared_data.pipette.pipette_load_name_conversions import (
+    convert_pipette_model,
+)
+from opentrons_shared_data.pipette.load_data import load_definition
+from opentrons_shared_data.pipette.ul_per_mm import piecewise_volume_conversion
+
+from opentrons_shared_data.pipette.types import PipetteModel
+from opentrons_shared_data.pipette.pipette_definition import (
+    ulPerMMDefinition,
+)
+
+
+DEFAULT_MAX_SPEED_HIGH_THROUGHPUT_OT3_AXIS_KIND_P = 15
+DEFAULT_MAX_SPEED_LOW_THROUGHPUT_OT3_AXIS_KIND_P = 70
+B_MAX_SPEED = 40
+
+
+def _get_plunger_max_speed(pipette_model: PipetteModel) -> float:
+    if "v2" in pipette_model:
+        return B_MAX_SPEED
+    else:
+        if "96" in pipette_model:
+            return DEFAULT_MAX_SPEED_HIGH_THROUGHPUT_OT3_AXIS_KIND_P
+        else:
+            return DEFAULT_MAX_SPEED_LOW_THROUGHPUT_OT3_AXIS_KIND_P
+
+
+def _get_max_flow_rate_at_volume(
+    ul_per_mm_definition: ulPerMMDefinition,
+    pipette_model: PipetteModel,
+    volume: float,
+) -> float:
+    max_speed = _get_plunger_max_speed(pipette_model)
+    map = list(ul_per_mm_definition.default.values())[-1]
+    ul_per_mm = piecewise_volume_conversion(volume, map)
+    return round(ul_per_mm * max_speed, 1)
+
+
+def get_all_pipette_models() -> Iterator[PipetteModel]:
+    paths_to_validate = (
+        get_shared_data_root() / "pipette" / "definitions" / "2" / "liquid"
+    )
+
+    _channel_model_str = {
+        "single_channel": "single",
+        "ninety_six_channel": "96",
+        "eight_channel": "multi",
+        "eight_channel_em": "multi_em",
+    }
+    assert os.listdir(paths_to_validate), "You have a path wrong"
+    for channel_dir in os.listdir(paths_to_validate):
+        for model_dir in os.listdir(paths_to_validate / channel_dir):
+            for liquid_file in os.listdir(paths_to_validate / channel_dir / model_dir):
+                for version_file in os.listdir(
+                    paths_to_validate / channel_dir / model_dir / liquid_file
+                ):
+                    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 version_list[0] != "1" and version_list[1] != "0":
+                        yield built_model
+
+
+@pytest.mark.parametrize("pipette", list(get_all_pipette_models()))
+@pytest.mark.parametrize("action", ["aspirate", "dispense"])
+def test_max_flow_rates_per_volume(pipette: PipetteModel, action: str) -> None:
+    """Verify the max flow rate values for each pipette's supported tip is in range"""
+    pipette_model_version = convert_pipette_model(pipette)
+    definition = load_definition(
+        pipette_model_version.pipette_type,
+        pipette_model_version.pipette_channels,
+        pipette_model_version.pipette_version,
+        pipette_model_version.oem_type,
+    )
+
+    pipette_model_version_str = f"{pipette_model_version}"
+
+    for liquid_name, liquid_properties in definition.liquid_properties.items():
+        for tip_type, supported_tip in liquid_properties.supported_tips.items():
+
+            """TODO: the following models do not pass the asserts since the uiMaxFlowRate was raised
+            to match the default blowout and dispense flowRates. uiMaxFlowRate will be reevaluated
+            in the future."""
+            if not (
+                (
+                    pipette_model_version_str
+                    in {
+                        "p50_single_v3.4",
+                        "p50_single_v3.5",
+                        "p50_single_v3.6",
+                        "p50_multi_v3.5",
+                        "p50_multi_v3.4",
+                    }
+                    and liquid_properties.min_volume == 5.0
+                )
+                or (
+                    pipette_model_version_str
+                    in {"p200_96_v3.0", "p200_96_v3.1", "p200_96_v3.2"}
+                    and liquid_properties.min_volume == 0.5
+                )
+            ):
+                assert supported_tip.ui_max_flow_rate <= _get_max_flow_rate_at_volume(
+                    supported_tip.aspirate, pipette, liquid_properties.min_volume
+                )
+                assert supported_tip.ui_max_flow_rate <= _get_max_flow_rate_at_volume(
+                    supported_tip.dispense, pipette, liquid_properties.min_volume
+                )