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

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

@@ -0,0 +1,222 @@
+import pytest
+
+from typing import Union
+from opentrons_shared_data.pipette.types import (
+    PipetteChannelType,
+    PipetteModelType,
+    PipetteVersionType,
+    PipetteGenerationType,
+)
+from opentrons_shared_data.pipette.dev_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),
+            ),
+        ],
+        [
+            "p1000_multi_v1.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(1, 0),
+            ),
+        ],
+        [
+            "p1000_96_v1.0",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(1, 0),
+            ),
+        ],
+    ],
+)
+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),
+            ),
+        ],
+        [
+            "p1000_multi",
+            "3.3",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(3, 3),
+            ),
+        ],
+        [
+            "p1000_96",
+            "1.1",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(1, 1),
+            ),
+        ],
+    ],
+)
+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),
+            ),
+        ],
+        [
+            "p1000_multi_flex",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.EIGHT_CHANNEL,
+                PipetteVersionType(3, 0),
+            ),
+        ],
+        [
+            "p1000_96",
+            pc.PipetteModelVersionType(
+                PipetteModelType.p1000,
+                PipetteChannelType.NINETY_SIX_CHANNEL,
+                PipetteVersionType(1, 0),
+            ),
+        ],
+    ],
+)
+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"],
+    argvalues=[
+        [
+            PipetteModelType.p50,
+            PipetteChannelType.SINGLE_CHANNEL,
+            PipetteGenerationType.GEN2,
+            "p50_single_gen2",
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.EIGHT_CHANNEL,
+            PipetteGenerationType.GEN2,
+            "p1000_multi_gen2",
+        ],
+        [
+            # 96 channel has a unique "name" right now
+            PipetteModelType.p1000,
+            PipetteChannelType.NINETY_SIX_CHANNEL,
+            PipetteGenerationType.FLEX,
+            "p1000_96",
+        ],
+    ],
+)
+def test_model_version_type_string_version(
+    model_type: PipetteModelType,
+    channels: PipetteChannelType,
+    generation: PipetteGenerationType,
+    output: PipetteName,
+) -> None:
+    data = pc.PipetteNameType(
+        pipette_type=model_type,
+        pipette_channels=channels,
+        pipette_generation=generation,
+    )
+    assert output == str(data)
+
+
+@pytest.mark.parametrize(
+    argnames=["model_type", "channels", "version", "output"],
+    argvalues=[
+        [
+            PipetteModelType.p50,
+            PipetteChannelType.SINGLE_CHANNEL,
+            PipetteVersionType(1, 0),
+            "p50_single_v1",
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.EIGHT_CHANNEL,
+            PipetteVersionType(2, 1),
+            "p1000_multi_v2.1",
+        ],
+        [
+            PipetteModelType.p1000,
+            PipetteChannelType.NINETY_SIX_CHANNEL,
+            PipetteVersionType(3, 3),
+            "p1000_96_v3.3",
+        ],
+    ],
+)
+def test_name_type_string_generation(
+    model_type: PipetteModelType,
+    channels: PipetteChannelType,
+    version: PipetteVersionType,
+    output: PipetteModel,
+) -> None:
+    data = pc.PipetteModelVersionType(
+        pipette_type=model_type, pipette_channels=channels, pipette_version=version
+    )
+    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/build/lib/tests/pipette/test_typechecks.py

@@ -0,0 +1,50 @@
+import sys
+
+import pytest
+import typeguard
+
+from opentrons_shared_data.pipette import (
+    model_config,
+    name_config,
+    fuse_specs,
+    dummy_model_for_name,
+)
+from opentrons_shared_data.pipette.dev_types import (
+    PipetteModelSpecs,
+    PipetteNameSpecs,
+    PipetteFusedSpec,
+)
+
+pytestmark = pytest.mark.xfail(
+    condition=sys.version_info >= (3, 10),
+    reason="https://github.com/agronholm/typeguard/issues/242",
+)
+
+
+def test_model_config_check():
+    defdict = model_config()
+    typeguard.check_type("defdict", defdict, PipetteModelSpecs)
+
+
+def test_name_config_check():
+    defdict = name_config()
+    typeguard.check_type("defdict", defdict, PipetteNameSpecs)
+
+
+def build_model_name_pairs():
+    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, name):
+    defdict = fuse_specs(model, name)
+    typeguard.check_type("defdict", defdict, PipetteFusedSpec)
+
+
+@pytest.mark.parametrize("name", list(name_config().keys()))
+def test_model_for_name(name):
+    model = dummy_model_for_name(name)
+    assert model in model_config()["config"]

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

@@ -0,0 +1,36 @@
+import os
+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
+from opentrons_shared_data.pipette.pipette_load_name_conversions import (
+    convert_pipette_model,
+)
+from opentrons_shared_data.pipette.dev_types import PipetteModel
+
+
+def test_check_all_models_are_valid() -> None:
+    paths_to_validate = (
+        get_shared_data_root() / "pipette" / "definitions" / "2" / "general"
+    )
+    _channel_model_str = {
+        "single_channel": "single",
+        "ninety_six_channel": "96",
+        "eight_channel": "multi",
+    }
+    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: PipetteModel = 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,
+                )
+
+                assert isinstance(loaded_model, PipetteConfigurations)

package/python/build/lib/tests/protocol/__init__.py

@@ -0,0 +1,15 @@
+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/build/lib/tests/protocol/test_protocol_schema_v6.py

@@ -0,0 +1,107 @@
+import json
+import pytest
+from typing import Any, Dict
+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):
+    def_data = load_shared_data(defpath)
+    def_model = protocol_schema_v6.ProtocolSchemaV6.parse_raw(def_data)
+    def_dict_from_model = def_model.dict(
+        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/build/lib/tests/protocol/test_protocol_schema_v7.py

@@ -0,0 +1,34 @@
+import json
+import pytest
+from typing import Any, Dict
+
+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):
+    def_data = load_shared_data(defpath)
+    def_model = protocol_schema_v7.ProtocolSchemaV7.parse_raw(def_data)
+    def_dict_from_model = def_model.dict(
+        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/build/lib/tests/protocol/test_typechecks.py

@@ -0,0 +1,36 @@
+import json
+import sys
+import pytest
+import typeguard
+
+from opentrons_shared_data import load_shared_data
+from opentrons_shared_data.protocol.dev_types import (
+    JsonProtocolV3,
+    JsonProtocolV4,
+    JsonProtocolV5,
+)
+from . import list_fixtures
+
+
+pytestmark = pytest.mark.xfail(
+    condition=sys.version_info >= (3, 10),
+    reason="https://github.com/agronholm/typeguard/issues/242",
+)
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(3))
+def test_v3_types(defpath):
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type("defn", defn, JsonProtocolV3)
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(4))
+def test_v4_types(defpath):
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type("defn", defn, JsonProtocolV4)
+
+
+@pytest.mark.parametrize("defpath", list_fixtures(5))
+def test_v5_types(defpath):
+    defn = json.loads(load_shared_data(defpath))
+    typeguard.check_type("defn", defn, JsonProtocolV5)

package/python/build/lib/tests/robot/test_typechecks.py

@@ -0,0 +1,20 @@
+import sys
+
+import pytest
+import typeguard
+
+
+from opentrons_shared_data.robot import load
+from opentrons_shared_data.robot.dev_types import RobotDefinition, RobotType
+
+pytestmark = pytest.mark.xfail(
+    condition=sys.version_info >= (3, 10),
+    reason="https://github.com/agronholm/typeguard/issues/242",
+)
+
+
+@pytest.mark.parametrize("defname", ["OT-2 Standard", "OT-3 Standard"])
+def test_v1_defs(defname: RobotType) -> None:
+    defn = load(robot_type=defname, version=1)
+    typeguard.check_type("defn", defn, RobotDefinition)
+    assert defn["robotType"] == defname