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

package/python/build/lib/tests/module/test_load.py

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

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

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

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

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