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

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

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

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

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

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

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

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

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

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