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

package/python/build/lib/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/build/lib/tests/module/test_typechecks.py

@@ -0,0 +1,34 @@
+import sys
+
+import pytest
+import typeguard
+
+from opentrons_shared_data import module
+from opentrons_shared_data.module import dev_types
+
+from . import list_v2_defs, list_v3_defs
+
+
+pytestmark = pytest.mark.xfail(
+    condition=sys.version_info >= (3, 10),
+    reason="https://github.com/agronholm/typeguard/issues/242",
+)
+
+
+@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", def_dict, dev_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", defdict, dev_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", defdict, dev_types.ModuleDefinitionV1)

package/python/build/lib/tests/pipette/test_load_data.py

@@ -0,0 +1,102 @@
+import pytest
+from typing import Dict, Any, cast
+from opentrons_shared_data.pipette import (
+    load_data,
+    pipette_load_name_conversions,
+    dev_types,
+)
+from opentrons_shared_data.pipette.types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteVersionType,
+    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),
+    )
+
+    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),
+    )
+
+    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(dev_types.PipetteModel, pipette_model)
+    )
+    base_configurations = load_data.load_definition(
+        model_name.pipette_type, model_name.pipette_channels, model_name.pipette_version
+    )
+    updated_configurations = load_data.update_pipette_configuration(
+        base_configurations, v1_configuration_changes, liquid_class
+    )
+
+    updated_configurations_dict = updated_configurations.dict()
+    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/build/lib/tests/pipette/test_mutable_configurations.py

@@ -0,0 +1,266 @@
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, cast, Union, Generator
+
+import pytest
+
+from opentrons_shared_data.pipette import (
+    mutable_configurations,
+    types,
+    pipette_definition,
+    pipette_load_name_conversions as pip_conversions,
+    load_data,
+    dev_types,
+)
+
+
+TEST_SERIAL_NUMBER = "P50MV1520200304"
+TestOverrideType = Dict[str, Union[float, int, bool]]
+
+
+@pytest.fixture
+def TMPFILE_DATA() -> Dict[str, Any]:
+    return {
+        "dropTipShake": True,
+        "doubleDropTip": True,
+        "model": "p50_multi_v1.5",
+        "quirks": {"pickUpPresses": True, "dropTipShake": True, "doubleDropTip": True},
+        "pickUpSpeed": {
+            "value": 5.0,
+            "min": 1,
+            "max": 100,
+            "units": "mm/s",
+            "type": "float",
+            "default": 30,
+        },
+    }
+
+
+@pytest.fixture
+def override_configuration_path(tmp_path: Path) -> Generator[Path, None, None]:
+    os.environ["OT_API_CONFIG_DIR"] = str(tmp_path)
+
+    tmp_path.mkdir(parents=True, exist_ok=True)
+    with_pip_path = tmp_path / Path("pipettes")
+    with_pip_path.mkdir(parents=True, exist_ok=True)
+    yield with_pip_path
+
+    del os.environ["OT_API_CONFIG_DIR"]
+
+
+@pytest.fixture
+def overrides_fixture(
+    override_configuration_path: Path, TMPFILE_DATA: Dict[str, Any]
+) -> types.MutableConfig:
+    with open(override_configuration_path / f"{TEST_SERIAL_NUMBER}.json", "w") as f:
+        json.dump(TMPFILE_DATA, f)
+    return types.MutableConfig.build(**TMPFILE_DATA["pickUpSpeed"], name="pickUpSpeed")
+
+
+def test_list_mutable_configs_unknown_pipette_id(
+    override_configuration_path: Path,
+) -> None:
+    """Test unknown pipette id mutable configs.
+
+    Test that a user receives a list of all possible mutable configurations
+    with the default value equal to the regular value.
+    """
+
+    found_configurations = mutable_configurations.list_mutable_configs(
+        TEST_SERIAL_NUMBER, override_configuration_path
+    )
+    for c in found_configurations:
+        if isinstance(c, str):
+            # model string, ignore
+            continue
+        if isinstance(c, types.QuirkConfig):
+            assert isinstance(c.value, bool)
+        else:
+            assert c.default == c.value
+
+
+def test_list_mutable_configs_known_pipette_id(
+    overrides_fixture: types.MutableConfig, override_configuration_path: Path
+) -> None:
+    """Test known pipette id mutable configs.
+
+    Test that a user receives a list of all possible mutable configurations
+    with the expected overrides also listed.
+    """
+    found_configurations = mutable_configurations.list_mutable_configs(
+        TEST_SERIAL_NUMBER, override_configuration_path
+    )
+
+    for c in found_configurations:
+        if isinstance(c, str):
+            # model string, ignore
+            continue
+        if overrides_fixture.name == c.name:
+            assert c.value == overrides_fixture.value
+        elif isinstance(c, types.QuirkConfig):
+            assert isinstance(c.value, bool)
+        else:
+            assert c.default == c.value
+
+
+@pytest.mark.parametrize(
+    argnames=["overrides_dict", "saved_dict"],
+    argvalues=[
+        [
+            {"pickUpCurrent": 0.5, "dropTipSpeed": 5, "dropTipShake": False},
+            {
+                "quirks": {"dropTipShake": False},
+                "pickUpCurrent": {
+                    "value": 0.5,
+                    "default": 0.8,
+                    "units": "amps",
+                    "type": "float",
+                    "min": 0.1,
+                    "max": 2.0,
+                },
+                "model": "p50_multi_v1.5",
+                "dropTipSpeed": {
+                    "value": 5,
+                    "default": 5.0,
+                    "units": "mm/s",
+                    "type": "float",
+                    "min": 0.01,
+                    "max": 30,
+                },
+            },
+        ]
+    ],
+)
+def test_save_new_overrides_new_file(
+    override_configuration_path: Path,
+    overrides_dict: TestOverrideType,
+    saved_dict: Dict[str, Any],
+) -> None:
+    mutable_configurations.save_overrides(
+        TEST_SERIAL_NUMBER, overrides_dict, override_configuration_path
+    )
+    with open(override_configuration_path / f"{TEST_SERIAL_NUMBER}.json") as f:
+        new_file = json.load(f)
+    assert saved_dict == new_file
+
+
+@pytest.mark.parametrize(
+    argnames=["overrides_dict"],
+    argvalues=[
+        [{"pickUpCurrent": 1, "pickUpSpeed": 10, "dropTipShake": False}],
+        [{"pickUpCurrent": 2}],
+    ],
+)
+def test_save_new_overrides_update_file(
+    override_configuration_path: Path,
+    overrides_fixture: types.MutableConfig,
+    overrides_dict: TestOverrideType,
+    TMPFILE_DATA: Dict[str, Any],
+) -> None:
+    mutable_configurations.save_overrides(
+        TEST_SERIAL_NUMBER, overrides_dict, override_configuration_path
+    )
+    with open(override_configuration_path / f"{TEST_SERIAL_NUMBER}.json") as f:
+        new_file = json.load(f)
+
+    for k, v in overrides_dict.items():
+        if isinstance(v, bool):
+            TMPFILE_DATA["quirks"][k] = v
+        elif TMPFILE_DATA.get(k):
+            TMPFILE_DATA[k]["value"] = v
+
+    TMPFILE_DATA["pickUpCurrent"] = {
+        "default": 0.8,
+        "max": 2.0,
+        "min": 0.1,
+        "type": "float",
+        "units": "amps",
+        "value": overrides_dict["pickUpCurrent"],
+    }
+
+    del TMPFILE_DATA["quirks"]["pickUpPresses"]
+    assert TMPFILE_DATA == new_file
+
+
+@pytest.mark.parametrize(
+    argnames=["overrides_dict"],
+    argvalues=[
+        [{"pickUpCurrent": 1231.213, "dropTipSpeed": 121, "dropTipShake": False}],
+        [{"quirk123": True}],
+    ],
+)
+def test_save_invalid_overrides(
+    overrides_fixture: types.MutableConfig,
+    override_configuration_path: Path,
+    overrides_dict: TestOverrideType,
+    TMPFILE_DATA: Dict[str, Any],
+) -> None:
+    with pytest.raises(ValueError):
+        mutable_configurations.save_overrides(
+            TEST_SERIAL_NUMBER, overrides_dict, override_configuration_path
+        )
+    with open(override_configuration_path / f"{TEST_SERIAL_NUMBER}.json") as f:
+        new_file = json.load(f)
+    assert TMPFILE_DATA == new_file
+
+
+@pytest.mark.parametrize(
+    argnames=["pipette_model", "serial_number"],
+    argvalues=[
+        [
+            pip_conversions.convert_pipette_model(
+                cast(dev_types.PipetteModel, "p1000_96_v3.3")
+            ),
+            "P1KHV3320230629",
+        ],
+        [
+            pip_conversions.convert_pipette_model(
+                cast(dev_types.PipetteModel, "p50_multi_v1.5")
+            ),
+            TEST_SERIAL_NUMBER,
+        ],
+    ],
+)
+def test_load_with_overrides(
+    overrides_fixture: types.MutableConfig,
+    pipette_model: pipette_definition.PipetteModelVersionType,
+    serial_number: str,
+    override_configuration_path: Path,
+) -> None:
+    """Test that you can load configurations both with pre-existing overrides and non-pre-existing overrides."""
+    updated_configurations = mutable_configurations.load_with_mutable_configurations(
+        pipette_model, override_configuration_path, serial_number
+    )
+
+    loaded_base_configurations = load_data.load_definition(
+        pipette_model.pipette_type,
+        pipette_model.pipette_channels,
+        pipette_model.pipette_version,
+    )
+
+    if serial_number == TEST_SERIAL_NUMBER:
+        dict_loaded_configs = loaded_base_configurations.dict(by_alias=True)
+        dict_loaded_configs["pickUpTipConfigurations"]["speed"] = 5.0
+        updated_configurations_dict = updated_configurations.dict(by_alias=True)
+        assert set(dict_loaded_configs.pop("quirks")) == set(
+            updated_configurations_dict.pop("quirks")
+        )
+        assert updated_configurations_dict == dict_loaded_configs
+    else:
+        assert updated_configurations == loaded_base_configurations
+
+
+def test_build_mutable_config_using_old_units() -> None:
+    """Test that MutableConfigs can build with old units."""
+    old_units_config = {
+        "value": 5,
+        "default": 5.0,
+        "units": "mm/s",
+        "type": "float",
+        "min": 0.01,
+        "max": 30,
+    }
+    assert (
+        types.MutableConfig.build(**old_units_config, name="dropTipSpeed") is not None  # type: ignore
+    )

package/python/build/lib/tests/pipette/test_pipette_definition.py

@@ -0,0 +1,183 @@
+import pytest
+from typing import cast, List
+from opentrons_shared_data.pipette.types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteVersionType,
+    PipetteModelMajorVersionType,
+    PipetteModelMinorVersionType,
+    LiquidClasses,
+)
+from opentrons_shared_data.pipette.pipette_definition import (
+    liquid_class_for_volume_between_default_and_defaultlowvolume,
+    PipetteLiquidPropertiesDefinition,
+    SupportedTipsDefinition,
+)
+
+
+def get_liquid_definition_for(
+    liquid_class: LiquidClasses,
+) -> PipetteLiquidPropertiesDefinition:
+    if liquid_class == LiquidClasses.lowVolumeDefault:
+        return PipetteLiquidPropertiesDefinition.parse_obj(
+            {
+                "supportedTips": {
+                    "t50": SupportedTipsDefinition.parse_obj(
+                        {
+                            "defaultAspirateFlowRate": {
+                                "default": 5,
+                                "valuesByApiLevel": {"2.0": 5},
+                            },
+                            "defaultDispenseFlowRate": {
+                                "default": 5,
+                                "valuesByApiLevel": {"2.0": 5},
+                            },
+                            "defaultBlowOutFlowRate": {
+                                "default": 10,
+                                "valuesByApiLevel": {"2.0": 10},
+                            },
+                            "defaultFlowAcceleration": 100,
+                            "defaultTipLength": 100,
+                            "defaultReturnTipHeight": 0.5,
+                            "defaultPushOutVolume": 5,
+                            "aspirate": {"default": {"1": [[1, 2, 3]]}},
+                            "dispense": {"default": {"1": [[1, 2, 3]]}},
+                        }
+                    )
+                },
+                "defaultTipOverlapDictionary": {},
+                "maxVolume": 30,
+                "minVolume": 1,
+                "defaultTipracks": [],
+            }
+        )
+    else:
+        return PipetteLiquidPropertiesDefinition.parse_obj(
+            {
+                "supportedTips": {
+                    "t50": SupportedTipsDefinition.parse_obj(
+                        {
+                            "defaultAspirateFlowRate": {
+                                "default": 5,
+                                "valuesByApiLevel": {"2.0": 5},
+                            },
+                            "defaultDispenseFlowRate": {
+                                "default": 5,
+                                "valuesByApiLevel": {"2.0": 5},
+                            },
+                            "defaultBlowOutFlowRate": {
+                                "default": 10,
+                                "valuesByApiLevel": {"2.0": 10},
+                            },
+                            "defaultFlowAcceleration": 100,
+                            "defaultTipLength": 100,
+                            "defaultReturnTipHeight": 0.5,
+                            "defaultPushOutVolume": 5,
+                            "aspirate": {"default": {"1": [[1, 2, 3]]}},
+                            "dispense": {"default": {"1": [[1, 2, 3]]}},
+                        }
+                    )
+                },
+                "defaultTipOverlapDictionary": {},
+                "maxVolume": 100,
+                "minVolume": 5,
+                "defaultTipracks": [],
+            }
+        )
+
+
+@pytest.mark.parametrize(
+    argnames=["model", "expected_enum"],
+    argvalues=[["p50", PipetteModelType.p50], ["p1000", PipetteModelType.p1000]],
+)
+def test_model_enum(model: str, expected_enum: PipetteModelType) -> None:
+    assert expected_enum == PipetteModelType(model)
+
+
+@pytest.mark.parametrize(argnames="channels", argvalues=[1, 8, 96])
+def test_channel_enum(channels: int) -> None:
+    channel_type = PipetteChannelType(channels)
+    assert channels == channel_type
+
+
+def test_incorrect_values() -> None:
+    with pytest.raises(ValueError):
+        PipetteModelType("p100")
+
+    with pytest.raises(ValueError):
+        PipetteChannelType(99)
+
+
+@pytest.mark.parametrize(
+    argnames=["major", "minor"],
+    argvalues=[[1, 0], [1, 3], [3, 9]],
+)
+def test_version_enum(major: int, minor: int) -> None:
+    version_type = PipetteVersionType(
+        cast(PipetteModelMajorVersionType, major),
+        cast(PipetteModelMinorVersionType, minor),
+    )
+    assert version_type.as_tuple == (major, minor)
+
+
+@pytest.mark.parametrize(
+    argnames=[
+        "all_liquid_classes",
+        "volume",
+        "current_liquid_class",
+        "expected_liquid_class",
+    ],
+    argvalues=[
+        [
+            [LiquidClasses.default],
+            1,
+            LiquidClasses.lowVolumeDefault,
+            LiquidClasses.default,
+        ],
+        [
+            [LiquidClasses.lowVolumeDefault, LiquidClasses.default],
+            1,
+            LiquidClasses.lowVolumeDefault,
+            LiquidClasses.lowVolumeDefault,
+        ],
+        [
+            [LiquidClasses.lowVolumeDefault, LiquidClasses.default],
+            1,
+            LiquidClasses.default,
+            LiquidClasses.lowVolumeDefault,
+        ],
+        [
+            [LiquidClasses.lowVolumeDefault, LiquidClasses.default],
+            5,
+            LiquidClasses.default,
+            LiquidClasses.default,
+        ],
+        [
+            [LiquidClasses.lowVolumeDefault, LiquidClasses.default],
+            5,
+            LiquidClasses.lowVolumeDefault,
+            LiquidClasses.default,
+        ],
+        [
+            [LiquidClasses.lowVolumeDefault, LiquidClasses.default],
+            100,
+            LiquidClasses.lowVolumeDefault,
+            LiquidClasses.default,
+        ],
+    ],
+)
+def test_liquid_class_for_volume_between_default_and_defaultlowvolume(
+    all_liquid_classes: List[LiquidClasses],
+    volume: float,
+    current_liquid_class: LiquidClasses,
+    expected_liquid_class: LiquidClasses,
+) -> None:
+    available_liquid_classes = {
+        lc: get_liquid_definition_for(lc) for lc in all_liquid_classes
+    }
+    assert (
+        liquid_class_for_volume_between_default_and_defaultlowvolume(
+            volume, current_liquid_class, available_liquid_classes
+        )
+        == expected_liquid_class
+    )