@opentrons/shared-data 0.1.7-alpha.0 → 0.2.0-alpha.0

package/python_tests/pipette/test_pipette_load_name_conversions.py

@@ -0,0 +1,244 @@
+import pytest
+
+from typing import Union
+from opentrons_shared_data.pipette.types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteVersionType,
+    PipetteGenerationType,
+    PipetteOEMType,
+)
+from opentrons_shared_data.pipette.types import PipetteModel, PipetteName
+from opentrons_shared_data.pipette import (
+    pipette_definition as pc,
+    pipette_load_name_conversions as ps,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["model", "output"],
+    argvalues=[
+        [
+            "p50_single_v2.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p50,
+                PipetteChannelType.SINGLE_CHANNEL,
+                PipetteVersionType(2, 0),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_multi_v1.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(1, 0),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_96_v1.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(1, 0),
+                PipetteOEMType.OT,
+            ),
+        ],
+    ],
+)
+def test_convert_pipette_model(
+    model: PipetteModel, output: pc.PipetteModelVersionType
+) -> None:
+    assert output == ps.convert_pipette_model(model)
+
+
+@pytest.mark.parametrize(
+    argnames=["model", "version", "output"],
+    argvalues=[
+        [
+            "p50_single",
+            "2.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p50,
+                PipetteChannelType.SINGLE_CHANNEL,
+                PipetteVersionType(2, 0),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_multi",
+            "3.3",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(3, 3),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_96",
+            "1.1",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(1, 1),
+                PipetteOEMType.OT,
+            ),
+        ],
+    ],
+)
+def test_convert_pipette_model_provided_version(
+    model: PipetteModel, version: str, output: pc.PipetteModelVersionType
+) -> None:
+    assert output == ps.convert_pipette_model(model, version)
+
+
+@pytest.mark.parametrize(
+    argnames=["name", "output"],
+    argvalues=[
+        [
+            "p50_single_gen2",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p50,
+                PipetteChannelType.SINGLE_CHANNEL,
+                PipetteVersionType(2, 0),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_multi_flex",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(3, 5),
+                PipetteOEMType.OT,
+            ),
+        ],
+        [
+            "p1000_96",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(3, 6),
+                PipetteOEMType.OT,
+            ),
+        ],
+    ],
+)
+def test_convert_pipette_name(
+    name: PipetteName, output: pc.PipetteModelVersionType
+) -> None:
+    assert output == ps.convert_pipette_name(name)
+
+
+@pytest.mark.parametrize(
+    argnames=["model_type", "channels", "generation", "output", "oem"],
+    argvalues=[
+        [
+            PipetteModelType.p50,
+            PipetteChannelType.SINGLE_CHANNEL,
+            PipetteGenerationType.GEN2,
+            "p50_single_gen2",
+            PipetteOEMType.OT,
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.EIGHT_CHANNEL,
+            PipetteGenerationType.GEN2,
+            "p1000_multi_gen2",
+            PipetteOEMType.OT,
+        ],
+        [
+            # 96 channel has a unique "name" right now
+            PipetteModelType.p1000,
+            PipetteChannelType.NINETY_SIX_CHANNEL,
+            PipetteGenerationType.FLEX,
+            "p1000_96",
+            PipetteOEMType.OT,
+        ],
+    ],
+)
+def test_model_version_type_string_version(
+    model_type: PipetteModelType,
+    channels: PipetteChannelType,
+    generation: PipetteGenerationType,
+    output: PipetteName,
+    oem: PipetteOEMType,
+) -> None:
+    data = pc.PipetteNameType(
+        pipette_type=model_type,
+        pipette_channels=channels,
+        pipette_generation=generation,
+        oem_type=oem,
+    )
+    assert output == str(data)
+
+
+@pytest.mark.parametrize(
+    argnames=["model_type", "channels", "version", "output", "oem"],
+    argvalues=[
+        [
+            PipetteModelType.p50,
+            PipetteChannelType.SINGLE_CHANNEL,
+            PipetteVersionType(1, 0),
+            "p50_single_v1",
+            PipetteOEMType.OT,
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.EIGHT_CHANNEL,
+            PipetteVersionType(2, 1),
+            "p1000_multi_v2.1",
+            PipetteOEMType.OT,
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.NINETY_SIX_CHANNEL,
+            PipetteVersionType(3, 3),
+            "p1000_96_v3.3",
+            PipetteOEMType.OT,
+        ],
+    ],
+)
+def test_name_type_string_generation(
+    model_type: PipetteModelType,
+    channels: PipetteChannelType,
+    version: PipetteVersionType,
+    output: PipetteModel,
+    oem: PipetteOEMType,
+) -> None:
+    data = pc.PipetteModelVersionType(
+        pipette_type=model_type,
+        pipette_channels=channels,
+        pipette_version=version,
+        oem_type=oem,
+    )
+    assert output == str(data)
+
+
+@pytest.mark.parametrize(
+    argnames=["model_or_name", "valid"],
+    argvalues=[
+        [
+            "p50_single",
+            True,
+        ],
+        [
+            "p50_sing",
+            False,
+        ],
+        [
+            "p100_multi",
+            False,
+        ],
+        [
+            "p1000_multi_v3.3",
+            True,
+        ],
+    ],
+)
+def test_supported_pipette(
+    model_or_name: Union[PipetteName, PipetteModel, None], valid: bool
+) -> None:
+    assert ps.supported_pipette(model_or_name) == valid

package/python_tests/pipette/test_typechecks.py

@@ -0,0 +1,47 @@
+import pytest
+import typeguard
+
+from typing import Generator, Tuple
+
+from opentrons_shared_data.pipette import (
+    model_config,
+    name_config,
+    fuse_specs,
+    dummy_model_for_name,
+)
+from opentrons_shared_data.pipette.types import (
+    PipetteModelSpecs,
+    PipetteNameSpecs,
+    PipetteFusedSpec,
+    PipetteName,
+    PipetteModel,
+)
+
+
+def test_model_config_check() -> None:
+    defdict = model_config()
+    typeguard.check_type(defdict, PipetteModelSpecs)
+
+
+def test_name_config_check() -> None:
+    defdict = name_config()
+    typeguard.check_type(defdict, PipetteNameSpecs)
+
+
+def build_model_name_pairs() -> Generator[Tuple[PipetteModel, PipetteName], None, None]:
+    for model, conf in model_config()["config"].items():
+        yield model, conf["name"]
+        for bcn in conf.get("backCompatNames", []):
+            yield model, bcn
+
+
+@pytest.mark.parametrize("model,name", list(build_model_name_pairs()))
+def test_fuse(model: PipetteModel, name: PipetteName) -> None:
+    defdict = fuse_specs(model, name)
+    typeguard.check_type(defdict, PipetteFusedSpec)
+
+
+@pytest.mark.parametrize("name", list(name_config().keys()))
+def test_model_for_name(name: PipetteName) -> None:
+    model = dummy_model_for_name(name)
+    assert model in model_config()["config"]

package/python_tests/pipette/test_validate_schema.py

@@ -0,0 +1,198 @@
+import os
+import json
+from typing import Iterator
+from opentrons_shared_data import get_shared_data_root
+
+from opentrons_shared_data.pipette.pipette_definition import (
+    PipetteConfigurations,
+)
+from opentrons_shared_data.pipette.load_data import (
+    load_definition,
+    load_valid_nozzle_maps,
+)
+from opentrons_shared_data.pipette.pipette_load_name_conversions import (
+    convert_pipette_model,
+)
+from opentrons_shared_data.pipette import types
+
+
+def iterate_models() -> Iterator[types.PipetteModel]:
+    """Get an iterator of all pipette models."""
+    _channel_model_str = {
+        "single_channel": "single",
+        "ninety_six_channel": "96",
+        "eight_channel": "multi",
+        "eight_channel_em": "multi_em",
+    }
+    defn_root = get_shared_data_root() / "pipette" / "definitions" / "2" / "liquid"
+    assert os.listdir(defn_root), "A path is wrong"
+    for channel_dir in defn_root.iterdir():
+        for model_dir in channel_dir.iterdir():
+            for lc_dir in model_dir.iterdir():
+                for version_file in lc_dir.iterdir():
+                    version_list = version_file.stem.split("_")
+                    yield types.PipetteModel(
+                        f"{model_dir.stem}_{_channel_model_str[channel_dir.stem]}_v{version_list[0]}.{version_list[1]}"
+                    )
+
+
+def test_check_all_models_are_valid() -> None:
+    """Make sure each model can be loaded."""
+    for model in iterate_models():
+        model_version = convert_pipette_model(model)
+        try:
+            loaded_model = load_definition(
+                model_version.pipette_type,
+                model_version.pipette_channels,
+                model_version.pipette_version,
+                model_version.oem_type,
+            )
+        except json.JSONDecodeError:
+            print(
+                f"Failed to parse {model_version.pipette_type} {model_version.pipette_channels} {model_version.pipette_version}"
+            )
+            raise
+
+        assert isinstance(loaded_model, PipetteConfigurations)
+
+
+def test_pick_up_configs_configuration_by_nozzle_map_keys() -> None:
+    """Verify that for every nozzle map the pickUpTipConfigurations have a valid configuration set."""
+    paths_to_validate = (
+        get_shared_data_root() / "pipette" / "definitions" / "2" / "general"
+    )
+    _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 version_file in os.listdir(paths_to_validate / channel_dir / model_dir):
+                print(version_file)
+                version_list = version_file.split(".json")[0].split("_")
+                built_model: types.PipetteModel = types.PipetteModel(
+                    f"{model_dir}_{_channel_model_str[channel_dir]}_v{version_list[0]}.{version_list[1]}"
+                )
+
+                model_version = convert_pipette_model(built_model)
+                loaded_model = load_definition(
+                    model_version.pipette_type,
+                    model_version.pipette_channels,
+                    model_version.pipette_version,
+                    model_version.oem_type,
+                )
+                valid_nozzle_maps = load_valid_nozzle_maps(
+                    model_version.pipette_type,
+                    model_version.pipette_channels,
+                    model_version.pipette_version,
+                    model_version.oem_type,
+                )
+
+                pipette_maps = list(
+                    loaded_model.pick_up_tip_configurations.press_fit.configuration_by_nozzle_map.keys()
+                )
+                if loaded_model.pick_up_tip_configurations.cam_action is not None:
+                    pipette_maps += list(
+                        loaded_model.pick_up_tip_configurations.cam_action.configuration_by_nozzle_map.keys()
+                    )
+                assert pipette_maps == list(valid_nozzle_maps.maps.keys())
+
+
+def test_pick_up_configs_configuration_ordered_from_smallest_to_largest() -> None:
+    """Verify that ValidNozzleMaps and PickUpTipConfigurations are ordered from smallest nozzle configuration to largest, ensuring mutable config compliancy."""
+    paths_to_validate = (
+        get_shared_data_root() / "pipette" / "definitions" / "2" / "general"
+    )
+    _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 version_file in os.listdir(paths_to_validate / channel_dir / model_dir):
+                version_list = version_file.split(".json")[0].split("_")
+                built_model: types.PipetteModel = types.PipetteModel(
+                    f"{model_dir}_{_channel_model_str[channel_dir]}_v{version_list[0]}.{version_list[1]}"
+                )
+
+                model_version = convert_pipette_model(built_model)
+                loaded_model = load_definition(
+                    model_version.pipette_type,
+                    model_version.pipette_channels,
+                    model_version.pipette_version,
+                    model_version.oem_type,
+                )
+                valid_nozzle_maps = load_valid_nozzle_maps(
+                    model_version.pipette_type,
+                    model_version.pipette_channels,
+                    model_version.pipette_version,
+                    model_version.oem_type,
+                )
+
+                map_keys = list(valid_nozzle_maps.maps.keys())
+                for key in map_keys:
+                    for i in range(map_keys.index(key)):
+                        assert len(valid_nozzle_maps.maps[map_keys[i]]) <= len(
+                            valid_nozzle_maps.maps[key]
+                        )
+
+                pipette_maps = list(
+                    loaded_model.pick_up_tip_configurations.press_fit.configuration_by_nozzle_map.keys()
+                )
+                for key in pipette_maps:
+                    for i in range(pipette_maps.index(key)):
+                        assert len(valid_nozzle_maps.maps[pipette_maps[i]]) <= len(
+                            valid_nozzle_maps.maps[key]
+                        )
+
+
+def test_serializer() -> None:
+    """Verify that the serializer works as expected."""
+
+    loaded_model = load_definition(
+        types.PipetteModelType.p1000,
+        types.PipetteChannelType.NINETY_SIX_CHANNEL,
+        types.PipetteVersionType(3, 3),
+        types.PipetteOEMType.OT,
+    )
+    quirk_0 = types.Quirks.pickupTipShake
+    quirk_1 = types.Quirks.dropTipShake
+    loaded_model.quirks = [quirk_0, quirk_1]
+
+    assert loaded_model.pipette_type == types.PipetteModelType.p1000
+    assert loaded_model.display_category == types.PipetteGenerationType.FLEX
+    assert loaded_model.channels == types.PipetteChannelType.NINETY_SIX_CHANNEL
+
+    model_dict = loaded_model.model_dump()
+    # each field should be the value of the enum class
+    assert (
+        isinstance(model_dict["pipette_type"], str)
+        and model_dict["pipette_type"] == loaded_model.pipette_type.value
+    )
+    assert (
+        isinstance(model_dict["display_category"], str)
+        and model_dict["display_category"] == loaded_model.display_category.value
+    )
+    assert (
+        isinstance(model_dict["channels"], int)
+        and model_dict["channels"] == loaded_model.channels.value
+    )
+
+    assert len(model_dict["quirks"]) == 2
+    dict_quirk_0 = model_dict["quirks"][0]
+    dict_quirk_1 = model_dict["quirks"][1]
+    assert isinstance(dict_quirk_0, str) and dict_quirk_0 == quirk_0.value
+    assert isinstance(dict_quirk_1, str) and dict_quirk_1 == quirk_1.value
+
+
+# TODO: (AA, 4/9/2024) we should add a test to validate the dumped json to make
+# sure we can re-load it as the BaseModel class. But we haven't added serializer
+# for other enums yet, such as LiquidClass, and since we haven't been
+# creating the definition files using model_dump/model_dump_json, it is okay to
+# skip this for now.

package/python_tests/protocol/__init__.py

@@ -0,0 +1,7 @@
+from typing import List
+from pathlib import Path
+
+
+def list_fixtures(version: int) -> List[Path]:
+    base = Path(__file__).parent / ".." / ".." / "protocol" / "fixtures" / f"{version}"
+    return list(base.iterdir())

package/python_tests/protocol/test_protocol_schema_v6.py

@@ -0,0 +1,108 @@
+import json
+import pytest
+from typing import Any, Dict
+from pathlib import Path
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.protocol.models import (
+    protocol_schema_v6,
+    Robot,
+    Metadata,
+    Liquid,
+    Module,
+    Pipette,
+    Labware,
+)
+
+from . import list_fixtures
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(6))
+def test_v6_types(defpath: Path) -> None:
+    def_data = load_shared_data(defpath)
+    def_model = protocol_schema_v6.ProtocolSchemaV6.model_validate_json(def_data)
+    def_dict_from_model = def_model.model_dump(
+        exclude_unset=True,
+        # 'schemaVersion' in python is '$schemaVersion' in JSON
+        by_alias=True,
+    )
+    expected_def_dict = json.loads(def_data)
+    delete_unexpected_results(expected_def_dict)
+    assert def_dict_from_model == expected_def_dict
+
+
+# TODO (Tamar and Max 3/16/22):
+# Some of our v6 fixtures accidentally contain command "result" data,
+# which is not part of the schema, and which we don't parse into our models.
+# Here, we delete the extra junk from the fixtures.
+# Remove this when the fixtures are corrected.
+# https://github.com/Opentrons/opentrons/issues/9701
+def delete_unexpected_results(protocol_fixture: Dict[str, Any]) -> None:
+    for command_object_dict in protocol_fixture["commands"]:
+        command_object_dict.pop("result", None)
+        command_object_dict.pop("id", None)
+
+
+@pytest.mark.parametrize(
+    "input_command, missing_id, load_command",
+    [
+        (
+            protocol_schema_v6.Command(
+                commandType="loadLabware",
+                params=protocol_schema_v6.Params(labwareId="labware-id-3"),
+            ),
+            "labware-id-3",
+            "loadLabware",
+        ),
+        (
+            protocol_schema_v6.Command(
+                commandType="loadPipette",
+                params=protocol_schema_v6.Params(pipetteId="pipette-id-3"),
+            ),
+            "pipette-id-3",
+            "loadPipette",
+        ),
+        (
+            protocol_schema_v6.Command(
+                commandType="loadLiquid",
+                params=protocol_schema_v6.Params(liquidId="liquid-id-3"),
+            ),
+            "liquid-id-3",
+            "loadLiquid",
+        ),
+        (
+            protocol_schema_v6.Command(
+                commandType="loadModule",
+                params=protocol_schema_v6.Params(moduleId="module-id-3"),
+            ),
+            "module-id-3",
+            "loadModule",
+        ),
+    ],
+)
+def test_schema_validators(
+    input_command: protocol_schema_v6.Command, missing_id: str, load_command: str
+) -> None:
+    """Should raise an error the keys do not match."""
+    labware = {
+        "labware-id-1": Labware(definitionId="definition-1"),
+        "labware-id-2": Labware(definitionId="definition-2"),
+    }
+    pipettes = {"pipette-id-1": Pipette(name="pipette-1")}
+    liquids = {"liquid-id-1": Liquid(displayName="liquid-1", description="liquid desc")}
+    modules = {"module-id-1": Module(model="model-1")}
+    with pytest.raises(
+        ValueError,
+        match=f"{load_command} command at index 0 references ID {missing_id}, which doesn't exist.",
+    ):
+        protocol_schema_v6.ProtocolSchemaV6(
+            otSharedSchema="#/protocol/schemas/6",
+            schemaVersion=6,
+            metadata=Metadata(),
+            robot=Robot(model="OT-2 Standard", deckId=""),
+            labware=labware,
+            pipettes=pipettes,
+            liquids=liquids,
+            modules=modules,
+            labwareDefinitions={},
+            commands=[input_command],
+        )

package/python_tests/protocol/test_protocol_schema_v7.py

@@ -0,0 +1,35 @@
+import json
+import pytest
+from typing import Any, Dict
+from pathlib import Path
+
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.protocol.models import protocol_schema_v7
+
+from . import list_fixtures
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(7))
+def test_v7_types(defpath: Path) -> None:
+    def_data = load_shared_data(defpath)
+    def_model = protocol_schema_v7.ProtocolSchemaV7.model_validate_json(def_data)
+    def_dict_from_model = def_model.model_dump(
+        exclude_unset=True,
+        # 'schemaVersion' in python is '$schemaVersion' in JSON
+        by_alias=True,
+    )
+    expected_def_dict = json.loads(def_data)
+    delete_unexpected_results(expected_def_dict)
+    assert def_dict_from_model == expected_def_dict
+
+
+# TODO (Tamar and Max 3/16/22):
+# Some of our v7 fixtures accidentally contain command "result" data,
+# which is not part of the schema, and which we don't parse into our models.
+# Here, we delete the extra junk from the fixtures.
+# Remove this when the fixtures are corrected.
+# https://github.com/Opentrons/opentrons/issues/9701
+def delete_unexpected_results(protocol_fixture: Dict[str, Any]) -> None:
+    for command_object_dict in protocol_fixture["commands"]:
+        command_object_dict.pop("result", None)
+        command_object_dict.pop("id", None)

package/python_tests/protocol/test_protocol_schema_v8.py

@@ -0,0 +1,17 @@
+import json
+import pytest
+from pathlib import Path
+
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.protocol.models import protocol_schema_v8
+
+from . import list_fixtures
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(8))
+def test_v8_types(defpath: Path) -> None:
+    def_data = load_shared_data(defpath)
+    def_model = protocol_schema_v8.ProtocolSchemaV8.model_validate_json(def_data)
+    def_dict_from_model = def_model.model_dump(by_alias=True, exclude_unset=True)
+    expected_def_dict = json.loads(def_data)
+    assert def_dict_from_model == expected_def_dict

package/python_tests/protocol/test_typechecks.py

@@ -0,0 +1,30 @@
+import json
+import pytest
+from pathlib import Path
+import typeguard
+
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.protocol.types import (
+    JsonProtocolV3,
+    JsonProtocolV4,
+    JsonProtocolV5,
+)
+from . import list_fixtures
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(3))
+def test_v3_types(defpath: Path) -> None:
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type(defn, JsonProtocolV3)
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(4))
+def test_v4_types(defpath: Path) -> None:
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type(defn, JsonProtocolV4)
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(5))
+def test_v5_types(defpath: Path) -> None:
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type(defn, JsonProtocolV5)