@opentrons/shared-data 0.0.0-alpha.14

package/python/opentrons_shared_data/protocol/models/protocol_schema_v6.py

@@ -0,0 +1,145 @@
+from pydantic import BaseModel, Field, validator
+from typing import Any, List, Optional, Dict, Union
+from typing_extensions import Literal
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+from .shared_models import (
+    Liquid,
+    Labware,
+    CommandAnnotation,
+    Location,
+    ProfileStep,
+    WellLocation,
+    OffsetVector,
+    Metadata,
+    Module,
+    Pipette,
+    Robot,
+    DesignerApplication,
+)
+
+
+# TODO (tamar 3/15/22): split apart all the command payloads when we tackle #9583
+class Params(BaseModel):
+    slotName: Optional[str]
+    axes: Optional[List[str]]
+    pipetteId: Optional[str]
+    mount: Optional[str]
+    moduleId: Optional[str]
+    location: Optional[Union[Location, Literal["offDeck"]]]
+    labwareId: Optional[str]
+    displayName: Optional[str]
+    liquidId: Optional[str]
+    volumeByWell: Optional[Dict[str, Any]]
+    wellName: Optional[str]
+    volume: Optional[float]
+    flowRate: Optional[float]
+    wellLocation: Optional[Union[WellLocation]]
+    waitForResume: Optional[Literal[True]]
+    seconds: Optional[float]
+    minimumZHeight: Optional[float]
+    forceDirect: Optional[bool]
+    speed: Optional[float]
+    message: Optional[str]
+    coordinates: Optional[OffsetVector]
+    axis: Optional[str]
+    distance: Optional[float]
+    positionId: Optional[str]
+    temperature: Optional[float]
+    celsius: Optional[float]
+    blockMaxVolumeUl: Optional[float]
+    rpm: Optional[float]
+    height: Optional[float]
+    offset: Optional[OffsetVector]
+    profile: Optional[List[ProfileStep]]
+    radius: Optional[float]
+
+
+class Command(BaseModel):
+    commandType: str
+    params: Params
+    key: Optional[str]
+
+
+class ProtocolSchemaV6(BaseModel):
+    otSharedSchema: Literal["#/protocol/schemas/6"] = Field(
+        ...,
+        alias="$otSharedSchema",
+        description="The path to a valid Opentrons shared schema relative to "
+        "the shared-data directory, without its extension.",
+    )
+    schemaVersion: Literal[6]
+    metadata: Metadata
+    robot: Robot
+    pipettes: Dict[str, Pipette]
+    labware: Dict[str, Labware]
+    modules: Optional[Dict[str, Module]]
+    liquids: Optional[Dict[str, Liquid]]
+    labwareDefinitions: Dict[str, LabwareDefinition]
+    # commands must be after pipettes, labware, etc. for its @validator to work.
+    commands: List[Command]
+    commandAnnotations: Optional[List[CommandAnnotation]]
+    designerApplication: Optional[DesignerApplication]
+
+    class Config:
+        # added for constructing the class with field name instead of alias
+        allow_population_by_field_name = True
+
+    @validator("commands")
+    def _validate_commands(
+        cls,
+        value: List[Command],
+        values: Dict[str, Any],
+    ) -> List[Command]:
+        pipette_ids = set(values["pipettes"].keys()) if "pipettes" in values else set()
+        labware_ids = set(values["labware"].keys()) if "labware" in values else set()
+        module_ids = (
+            set(values["modules"].keys())
+            if "modules" in values and values["modules"]
+            else set()
+        )
+        liquid_ids = (
+            set(values["liquids"].keys())
+            if "liquids" in values and values["liquids"]
+            else set()
+        )
+
+        for index, command in enumerate(value):
+            if (
+                command.params.pipetteId is not None
+                and command.params.pipetteId not in pipette_ids
+            ):
+                raise ValueError(
+                    f"{command.commandType} command at index {index}"
+                    f" references ID {command.params.pipetteId},"
+                    f" which doesn't exist."
+                )
+            if (
+                command.params.labwareId is not None
+                and command.params.labwareId not in labware_ids
+            ):
+                raise ValueError(
+                    f"{command.commandType} command at index {index}"
+                    f" references ID {command.params.labwareId},"
+                    f" which doesn't exist."
+                )
+            if (
+                command.params.moduleId is not None
+                and command.params.moduleId not in module_ids
+            ):
+                raise ValueError(
+                    f"{command.commandType} command at index {index}"
+                    f" references ID {command.params.moduleId},"
+                    f" which doesn't exist."
+                )
+            if (
+                command.params.liquidId is not None
+                and command.params.liquidId not in liquid_ids
+            ):
+                raise ValueError(
+                    f"{command.commandType} command at index {index}"
+                    f" references ID {command.params.liquidId},"
+                    f" which doesn't exist."
+                )
+
+        return value

package/python/opentrons_shared_data/protocol/models/protocol_schema_v7.py

@@ -0,0 +1,95 @@
+from pydantic import BaseModel, Field
+from typing import Any, List, Optional, Dict, Union
+from typing_extensions import Literal
+
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+from .shared_models import (
+    Liquid,
+    CommandAnnotation,
+    Location,
+    ProfileStep,
+    WellLocation,
+    OffsetVector,
+    Metadata,
+    Robot,
+    DesignerApplication,
+)
+
+
+# TODO (tamar 3/15/22): split apart all the command payloads when we tackle #9583
+class Params(BaseModel):
+    slotName: Optional[str]
+    axes: Optional[List[str]]
+    pipetteId: Optional[str]
+    mount: Optional[str]
+    moduleId: Optional[str]
+    location: Optional[Union[Location, Literal["offDeck"]]]
+    labwareId: Optional[str]
+    displayName: Optional[str]
+    liquidId: Optional[str]
+    volumeByWell: Optional[Dict[str, Any]]
+    wellName: Optional[str]
+    volume: Optional[float]
+    flowRate: Optional[float]
+    wellLocation: Optional[WellLocation]
+    waitForResume: Optional[Literal[True]]
+    seconds: Optional[float]
+    minimumZHeight: Optional[float]
+    forceDirect: Optional[bool]
+    speed: Optional[float]
+    message: Optional[str]
+    coordinates: Optional[OffsetVector]
+    axis: Optional[str]
+    distance: Optional[float]
+    positionId: Optional[str]
+    temperature: Optional[float]
+    celsius: Optional[float]
+    blockMaxVolumeUl: Optional[float]
+    rpm: Optional[float]
+    height: Optional[float]
+    offset: Optional[OffsetVector]
+    profile: Optional[List[ProfileStep]]
+    radius: Optional[float]
+    # schema v7 add-ons
+    newLocation: Optional[Union[Location, Literal["offDeck"]]]
+    strategy: Optional[str]
+    pickUpOffset: Optional[OffsetVector]
+    dropOffset: Optional[OffsetVector]
+    homeAfter: Optional[bool]
+    alternateDropLocation: Optional[bool]
+    holdTimeSeconds: Optional[float]
+    maintenancePosition: Optional[str]
+    pipetteName: Optional[str]
+    model: Optional[str]
+    loadName: Optional[str]
+    namespace: Optional[str]
+    version: Optional[int]
+    pushOut: Optional[float]
+
+
+class Command(BaseModel):
+    commandType: str
+    params: Params
+    key: Optional[str]
+
+
+class ProtocolSchemaV7(BaseModel):
+    otSharedSchema: Literal["#/protocol/schemas/7"] = Field(
+        ...,
+        alias="$otSharedSchema",
+        description="The path to a valid Opentrons shared schema relative to "
+        "the shared-data directory, without its extension.",
+    )
+    schemaVersion: Literal[7]
+    metadata: Metadata
+    robot: Robot
+    liquids: Optional[Dict[str, Liquid]]
+    labwareDefinitions: Dict[str, LabwareDefinition]
+    commands: List[Command]
+    commandAnnotations: Optional[List[CommandAnnotation]]
+    designerApplication: Optional[DesignerApplication]
+
+    class Config:
+        # added for constructing the class with field name instead of alias
+        allow_population_by_field_name = True

package/python/opentrons_shared_data/protocol/models/protocol_schema_v8.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, Field, Extra
+from typing import Any, List, Optional, Dict, Union
+from typing_extensions import Literal
+
+from opentrons_shared_data.labware.labware_definition import LabwareDefinition
+
+from .shared_models import (
+    Liquid,
+    Location,
+    ProfileStep,
+    WellLocation,
+    OffsetVector,
+    Metadata,
+    DesignerApplication,
+    Robot,
+)
+
+
+# TODO (tamar 3/15/22): split apart all the command payloads when we tackle #9583
+class Params(BaseModel):
+    slotName: Optional[str]
+    axes: Optional[List[str]]
+    pipetteId: Optional[str]
+    mount: Optional[str]
+    moduleId: Optional[str]
+    location: Optional[Union[Location, Literal["offDeck"]]]
+    labwareId: Optional[str]
+    displayName: Optional[str]
+    liquidId: Optional[str]
+    volumeByWell: Optional[Dict[str, Any]]
+    wellName: Optional[str]
+    volume: Optional[float]
+    flowRate: Optional[float]
+    wellLocation: Optional[WellLocation]
+    waitForResume: Optional[Literal[True]]
+    seconds: Optional[float]
+    minimumZHeight: Optional[float]
+    forceDirect: Optional[bool]
+    speed: Optional[float]
+    message: Optional[str]
+    coordinates: Optional[OffsetVector]
+    axis: Optional[str]
+    distance: Optional[float]
+    positionId: Optional[str]
+    temperature: Optional[float]
+    celsius: Optional[float]
+    blockMaxVolumeUl: Optional[float]
+    rpm: Optional[float]
+    height: Optional[float]
+    offset: Optional[OffsetVector]
+    profile: Optional[List[ProfileStep]]
+    radius: Optional[float]
+    newLocation: Optional[Union[Location, Literal["offDeck"]]]
+    strategy: Optional[str]
+    # schema v7 add-ons
+    homeAfter: Optional[bool]
+    alternateDropLocation: Optional[bool]
+    holdTimeSeconds: Optional[float]
+    maintenancePosition: Optional[str]
+    pipetteName: Optional[str]
+    model: Optional[str]
+    loadName: Optional[str]
+    namespace: Optional[str]
+    version: Optional[int]
+    pushOut: Optional[float]
+    pickUpOffset: Optional[OffsetVector]
+    dropOffset: Optional[OffsetVector]
+    # schema v8 add-ons
+    addressableAreaName: Optional[str]
+
+
+class Command(BaseModel):
+    commandType: str
+    params: Params
+    key: Optional[str]
+
+
+class CommandAnnotation(BaseModel):
+    commandKeys: List[str]
+    annotationType: str
+
+    class Config:
+        extra = Extra.allow
+
+
+class ProtocolSchemaV8(BaseModel):
+    otSharedSchema: Literal["#/protocol/schemas/8"] = Field(
+        ...,
+        alias="$otSharedSchema",
+        description="The path to a valid Opentrons shared schema relative to "
+        "the shared-data directory, without its extension.",
+    )
+    schemaVersion: Literal[8]
+    metadata: Metadata
+    robot: Robot
+    liquidSchemaId: Literal["opentronsLiquidSchemaV1"]
+    liquids: Dict[str, Liquid]
+    labwareDefinitionSchemaId: Literal["opentronsLabwareSchemaV2"]
+    labwareDefinitions: Dict[str, LabwareDefinition]
+    commandSchemaId: Literal["opentronsCommandSchemaV8"]
+    commands: List[Command]
+    commandAnnotationSchemaId: Literal["opentronsCommandAnnotationSchemaV1"]
+    commandAnnotations: List[CommandAnnotation]
+    designerApplication: Optional[DesignerApplication]
+
+    class Config:
+        # added for constructing the class with field name instead of alias
+        allow_population_by_field_name = True

package/python/opentrons_shared_data/protocol/models/shared_models.py

@@ -0,0 +1,105 @@
+from typing import Optional, List, Dict, Any
+from typing_extensions import Literal
+from enum import Enum
+from pydantic import BaseModel
+
+
+class Dimensions(BaseModel):
+    xDimension: float
+    yDimension: float
+    zDimension: float
+
+
+class GroupMetadata(BaseModel):
+    pass
+
+
+class Group(BaseModel):
+    metadata: GroupMetadata
+    wells: List[str]
+
+
+class Shape(Enum):
+    circular = "circular"
+    rectangular = "rectangular"
+
+
+class WellDefinition(BaseModel):
+    depth: float
+    totalLiquidVolume: int
+    shape: Shape
+    x: float
+    y: float
+    z: float
+    diameter: Optional[float]
+    yDimension: Optional[float]
+    xDimension: Optional[float]
+
+
+class Metadata(BaseModel):
+    protocolName: Optional[str]
+    author: Optional[str]
+    description: Optional[str]
+    created: Optional[int]
+    lastModified: Optional[int]
+    category: Optional[str]
+    subcategory: Optional[str]
+    tags: Optional[List[str]]
+
+
+class Module(BaseModel):
+    model: str
+
+
+class Pipette(BaseModel):
+    name: str
+
+
+class Robot(BaseModel):
+    model: Literal["OT-2 Standard", "OT-3 Standard"]
+    deckId: str
+
+
+class DesignerApplication(BaseModel):
+    name: Optional[str]
+    version: Optional[str]
+    data: Optional[Dict[str, Any]]
+
+
+class CommandAnnotation(BaseModel):
+    commandIds: List[str]
+    annotationType: str
+
+
+class OffsetVector(BaseModel):
+    x: Optional[float]
+    y: Optional[float]
+    z: Optional[float]
+
+
+class Location(BaseModel):
+    slotName: Optional[str]
+    moduleId: Optional[str]
+    labwareId: Optional[str]
+    addressableAreaName: Optional[str]
+
+
+class ProfileStep(BaseModel):
+    celsius: float
+    holdSeconds: float
+
+
+class WellLocation(BaseModel):
+    origin: Optional[str]
+    offset: Optional[OffsetVector]
+
+
+class Liquid(BaseModel):
+    displayName: str
+    description: str
+    displayColor: Optional[str]
+
+
+class Labware(BaseModel):
+    displayName: Optional[str]
+    definitionId: str

package/python/opentrons_shared_data/robot/__init__.py

@@ -0,0 +1,25 @@
+"""opentrons_shared_data.robot: Submodule for handling robot definition data."""
+from pathlib import Path
+from typing import cast
+from typing_extensions import Final
+
+import json
+
+from .. import get_shared_data_root
+
+from .dev_types import RobotDefinition, RobotType
+
+DEFAULT_ROBOT_DEFINITION_VERSION: Final = 1
+
+
+def load(
+    robot_type: RobotType, version: int = DEFAULT_ROBOT_DEFINITION_VERSION
+) -> RobotDefinition:
+    """Load the definition for the specified robot id."""
+    for fi in Path(
+        get_shared_data_root() / "robot" / "definitions" / f"{version}"
+    ).iterdir():
+        defn = json.load(fi.open("r"))
+        if defn["robotType"] == robot_type:
+            return cast(RobotDefinition, defn)
+    raise KeyError(robot_type)

package/python/opentrons_shared_data/robot/dev_types.py

@@ -0,0 +1,37 @@
+"""opentrons_shared_data.robot.dev_types: types for robot def."""
+import enum
+from typing import NewType, List, Dict, Any
+from typing_extensions import Literal, TypedDict
+
+RobotSchemaVersion1 = Literal[1]
+
+RobotSchema = NewType("RobotSchema", Dict[str, Any])
+
+RobotType = Literal["OT-2 Standard", "OT-3 Standard"]
+
+
+class RobotTypeEnum(enum.Enum):
+    """An enum representing the active robot type."""
+
+    # TODO we should switch over to using Enums fully (if possible)
+    # to represent our robot types in code -- rather than having
+    # to string match everywhere.
+    OT2 = enum.auto()
+    FLEX = enum.auto()
+
+    @classmethod
+    def robot_literal_to_enum(cls, robot_type: RobotType) -> "RobotTypeEnum":
+        """Convert Robot Type Literal to Robot Type Enum."""
+        if robot_type == "OT-2 Standard":
+            return cls.OT2
+        elif robot_type == "OT-3 Standard":
+            return cls.FLEX
+        # No final `else` statement, depend on mypy exhaustiveness checking
+
+
+class RobotDefinition(TypedDict):
+    """A python version of the robot definition type."""
+
+    displayName: str
+    robotType: RobotType
+    models: List[str]

package/python/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+addopts = --color=yes --strict-markers

package/python/setup.cfg

@@ -0,0 +1,5 @@
+[bdist_wheel]
+universal = 1
+
+[metadata]
+license_files = ../../LICENSE