opentrons-shared-data 8.8.0a10__py3-none-any.whl

opentrons_shared_data/gripper/__init__.py

@@ -0,0 +1,63 @@
+"""opentrons_shared_data.gripper: functions and types for gripper config."""
+from typing import cast, Any
+from typing_extensions import Literal
+import json
+from pathlib import Path
+
+from .. import load_shared_data
+from .gripper_definition import (
+    GripperDefinition,
+    GripperSchema,
+    GripperSchemaVersion,
+    GripForceProfile,
+    GripperModel,
+    Geometry,
+)
+
+
+class InvalidGripperDefinition(Exception):
+    """Incorrect gripper definition."""
+
+    pass
+
+
+def generate_schema() -> str:
+    """Create schema."""
+    raw_json_schema = GripperDefinition.schema_json()
+    schema_as_dict = json.loads(raw_json_schema)
+    return json.dumps(schema_as_dict, indent=2)
+
+
+def load_schema(version: Literal[1]) -> GripperSchema:
+    """Load gripper schema."""
+    path = Path("gripper") / "schemas" / f"{version}.json"
+    return cast(GripperSchema, json.loads(load_shared_data(path)))
+
+
+def _load_definition_data(path: Path) -> Any:
+    return
+
+
+def load_definition(
+    model: GripperModel,
+    version: GripperSchemaVersion = 1,
+) -> GripperDefinition:
+    """Load gripper definition based on schema version and gripper model."""
+    try:
+        path = Path("gripper") / "definitions" / f"{version}" / f"{model.value}.json"
+        return GripperDefinition.model_validate(json.loads(load_shared_data(path)))
+    except FileNotFoundError:
+        raise InvalidGripperDefinition(
+            f"Gripper model {model} definition in schema version {version} does not exist."
+        )
+
+
+__all__ = [
+    "GripperDefinition",
+    "GripperSchema",
+    "GripperSchemaVersion",
+    "GripForceProfile",
+    "GripperModel",
+    "Geometry",
+    "generate_schema",
+]

opentrons_shared_data/gripper/constants.py

@@ -0,0 +1,6 @@
+"""Gripper constants and default values."""
+
+LABWARE_GRIP_FORCE = 15.0  # Newtons
+GRIPPER_DECK_DROP_OFFSET = [-0.5, -0.5, -1.5]
+GRIPPER_MODULE_DROP_OFFSET = [0.0, 0.0, 1.5]
+GRIPPER_PADDLE_WIDTH = 36  # mm

opentrons_shared_data/gripper/gripper_definition.py

@@ -0,0 +1,98 @@
+"""Gripper configurations."""
+
+from typing_extensions import Annotated, Literal
+from typing import List, Dict, Tuple, Any, NewType
+from pydantic import ConfigDict, BaseModel, Field
+from enum import Enum
+
+
+def _snake_to_camel_case(snake: str) -> str:
+    """Turns snake_case to camelCase."""
+    return "".join(
+        [s.capitalize() if i > 0 else s.lower() for i, s in enumerate(snake.split("_"))]
+    )
+
+
+GripperModelStr = NewType("GripperModelStr", str)
+
+
+# TODO (spp, 2023-01-31): figure out if we want to keep this a string enum or revert to
+#  a regular enum with custom stringification
+class GripperModel(str, Enum):
+    """Gripper models."""
+
+    v1 = "gripperV1"
+    v1_1 = "gripperV1.1"
+    v1_2 = "gripperV1.2"
+    v1_3 = "gripperV1.3"
+
+    def __str__(self) -> str:
+        """Model name."""
+        enum_to_str = {
+            self.__class__.v1: "gripperV1",
+            self.__class__.v1_1: "gripperV1.1",
+            self.__class__.v1_2: "gripperV1.2",
+            self.__class__.v1_3: "gripperV1.3",
+        }
+        return enum_to_str[self]
+
+
+GripperSchemaVersion = Literal[1]
+
+GripperSchema = Dict[str, Any]
+
+
+_StrictNonNegativeInt = Annotated[int, Field(strict=True, ge=0)]
+_StrictNonNegativeFloat = Annotated[float, Field(strict=True, ge=0.0)]
+
+
+PolynomialTerm = Tuple[_StrictNonNegativeInt, float]
+_Polynomial = Annotated[List[PolynomialTerm], Field(min_length=1)]
+
+
+class GripperBaseModel(BaseModel):
+    """Gripper base model."""
+
+    model_config = ConfigDict(
+        alias_generator=_snake_to_camel_case, populate_by_name=True
+    )
+
+
+Offset = Tuple[float, float, float]
+
+
+class Geometry(GripperBaseModel):
+    """Gripper geometry definition."""
+
+    base_offset_from_mount: Offset
+    jaw_center_offset_from_base: Offset
+    pin_one_offset_from_base: Offset
+    pin_two_offset_from_base: Offset
+    jaw_width: Dict[str, float]
+    max_allowed_grip_error: _StrictNonNegativeFloat
+
+
+class GripForceProfile(GripperBaseModel):
+    """Gripper force profile."""
+
+    polynomial: _Polynomial = Field(
+        ...,
+        description="Polynomial function to convert a grip force in Newton to the jaw motor duty cycle value, which will be read by the gripper firmware.",
+    )
+    default_grip_force: _StrictNonNegativeFloat
+    default_idle_force: _StrictNonNegativeFloat
+    default_home_force: _StrictNonNegativeFloat
+    min: _StrictNonNegativeFloat
+    max: _StrictNonNegativeFloat
+
+
+class GripperDefinition(GripperBaseModel):
+    """Gripper definition."""
+
+    schema_version: GripperSchemaVersion = Field(
+        ..., description="Which schema version a gripper is using"
+    )
+    display_name: str = Field(..., description="Gripper display name.")
+    model: GripperModel
+    geometry: Geometry
+    grip_force_profile: GripForceProfile

opentrons_shared_data/labware/__init__.py

@@ -0,0 +1,59 @@
+"""
+opentrons_shared_data.labware: types and functions for accessing labware defs
+"""
+
+from __future__ import annotations
+
+from functools import lru_cache
+import json
+from itertools import chain
+from typing import Any, Iterable, NewType, TYPE_CHECKING, overload, Literal
+
+from opentrons_shared_data.load import get_shared_data_root
+
+from .. import load_shared_data
+
+if TYPE_CHECKING:
+    from .types import LabwareDefinition, LabwareDefinition2, LabwareDefinition3
+
+Schema = NewType("Schema", dict[str, Any])
+
+
+@overload
+def load_definition(
+    loadname: str, version: int, schema: Literal[2] = 2
+) -> LabwareDefinition2:
+    ...
+
+
+@overload
+def load_definition(
+    loadname: str, version: int, schema: Literal[3]
+) -> LabwareDefinition3:
+    ...
+
+
+def load_definition(loadname: str, version: int, schema: int = 2) -> LabwareDefinition:
+    return json.loads(
+        load_shared_data(f"labware/definitions/{schema}/{loadname}/{version}.json")
+    )
+
+
+def load_schema() -> Schema:
+    return json.loads(load_shared_data("labware/schemas/2.json"))
+
+
+@lru_cache(maxsize=1)
+def list_definitions(schemas: Iterable[int] = [2, 3]) -> set[tuple[str, int, int]]:
+    """Return (load_name, version, schema) for all labware definitions in shared-data."""
+
+    def list_definitions_for_schema(schema: int) -> Iterable[tuple[str, int, int]]:
+        root_for_schema = (
+            get_shared_data_root() / "labware" / "definitions" / str(schema)
+        )
+        files = root_for_schema.glob("*/*.json")
+        return ((file.parent.name, int(file.stem), schema) for file in files)
+
+    return set(
+        chain.from_iterable(list_definitions_for_schema(schema) for schema in schemas)
+    )

opentrons_shared_data/labware/constants.py

@@ -0,0 +1,22 @@
+import re
+from typing_extensions import Final
+from typing import Literal, Union
+
+
+# Regular expression to validate and extract row, column from well name
+# (ie A3, C1)
+WELL_NAME_PATTERN: Final["re.Pattern[str]"] = re.compile(r"^([A-Z]+)([0-9]+)$", re.X)
+
+# These shapes are for wellshape definitions and describe the top of the well
+CircularType = Literal["circular"]
+Circular: CircularType = "circular"
+RectangularType = Literal["rectangular"]
+Rectangular: RectangularType = "rectangular"
+WellShape = Union[Literal["circular"], Literal["rectangular"]]
+
+# These shapes are used to describe the 3D primatives used to build wells
+Conical = Literal["conical"]
+Cuboidal = Literal["cuboidal"]
+SquaredCone = Literal["squaredcone"]
+RoundedCuboid = Literal["roundedcuboid"]
+Spherical = Literal["spherical"]