opentrons-shared-data 8.8.0a12__py3-none-any.whl → 9.0.0a2__py3-none-any.whl

opentrons_shared_data/labware/labware_definition.py

@@ -6,33 +6,34 @@ shared-data. It's been modified by hand to be more friendly.
 from __future__ import annotations
 
 from enum import Enum
-from math import sqrt, asin
-from typing import Final
-from numpy import pi, trapz
 from functools import cached_property
+from math import asin, sqrt
+from typing import Final
 
+from numpy import pi, trapz
 from pydantic import (
-    ConfigDict,
     BaseModel,
+    ConfigDict,
     Discriminator,
     Field,
-    StrictInt,
     StrictFloat,
+    StrictInt,
     TypeAdapter,
 )
 from typing_extensions import Annotated, Literal
 
-from .types import LocatingFeatures
+from ..util import StrEnum
 from .constants import (
+    Circular,
     Conical,
     Cuboidal,
+    Rectangular,
     RoundedCuboid,
-    SquaredCone,
     Spherical,
+    SquaredCone,
     WellShape,
-    Circular,
-    Rectangular,
 )
+from .types import LocatingFeatures
 
 SAFE_STRING_REGEX = "^[a-z0-9._]+$"
 RECURSIVE_SEARCH_VOLUME_TOLERANCE = 0.001
@@ -93,7 +94,7 @@ class BrandData(BaseModel):
     links: list[str] | None = None
 
 
-class DisplayCategory(str, Enum):
+class DisplayCategory(StrEnum):
     tipRack = "tipRack"
     tubeRack = "tubeRack"
     reservoir = "reservoir"
@@ -106,7 +107,7 @@ class DisplayCategory(str, Enum):
     system = "system"
 
 
-class LabwareRole(str, Enum):
+class LabwareRole(StrEnum):
     labware = "labware"
     fixture = "fixture"
     adapter = "adapter"
@@ -587,9 +588,9 @@ class LabwareDefinition2(BaseModel):
     gripHeightFromLabwareBottom: float | None = None
     stackLimit: int | None = None
     compatibleParentLabware: list[str] | None = None
-    innerLabwareGeometry: dict[
-        str, InnerWellGeometry | UserDefinedVolumes
-    ] | None = None
+    innerLabwareGeometry: dict[str, InnerWellGeometry | UserDefinedVolumes] | None = (
+        None
+    )
 
 
 class LabwareDefinition3(BaseModel):

opentrons_shared_data/labware/types.py

@@ -1,10 +1,13 @@
-""" opentrons_shared_data.labware.types: types for labware defs
+"""opentrons_shared_data.labware.types: types for labware defs
 
 types in this file by and large require the use of typing_extensions.
 this module shouldn't be imported unless typing.TYPE_CHECKING is true.
 """
+
 from typing import NewType
-from typing_extensions import Literal, TypedDict, NotRequired
+
+from typing_extensions import Literal, NotRequired, TypedDict
+
 from .constants import (
     CircularType,
     RectangularType,

opentrons_shared_data/liquid_classes/__init__.py

@@ -1,8 +1,9 @@
 """Types and functions for accessing liquid class definitions."""
+
 from pathlib import Path
-from .. import load_shared_data, get_shared_data_root
-from .liquid_class_definition import LiquidClassSchemaV1
 
+from .. import get_shared_data_root, load_shared_data
+from .liquid_class_definition import LiquidClassSchemaV1
 
 DEFAULT_SCHEMA_VERSION = 1
 DEFAULT_LC_VERSION = 1

opentrons_shared_data/liquid_classes/liquid_class_definition.py

@@ -1,23 +1,22 @@
 """Python shared data models for liquid class definitions."""
 
 from enum import Enum
-from typing import Literal, Union, Optional, Sequence, Tuple, Any, Type
+from typing import Any, Literal, Optional, Sequence, Tuple, Type, Union
 
 from pydantic import (
-    ConfigDict,
     BaseModel,
-    field_validator,
-    ValidationInfo,
+    ConfigDict,
     Field,
-    StrictInt,
-    StrictFloat,
     StrictBool,
+    StrictFloat,
+    StrictInt,
+    ValidationInfo,
+    field_validator,
     model_validator,
 )
 from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Annotated
 
-
 _StrictNonNegativeInt = Annotated[int, Field(strict=True, ge=0)]
 _StrictGreaterThanZeroInt = Annotated[int, Field(strict=True, gt=0)]
 _StrictGreaterThanZeroFloat = Annotated[float, Field(strict=True, gt=0.0)]
@@ -70,7 +69,13 @@ class BlowoutLocation(Enum):
     TRASH = "trash"
 
 
-class Coordinate(BaseModel):
+class BaseLiquidClassModel(BaseModel):
+    """Base class for liquid class definitions."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+
+
+class Coordinate(BaseLiquidClassModel):
     """Three-dimensional coordinates."""
 
     x: _Number
@@ -78,12 +83,6 @@ class Coordinate(BaseModel):
     z: _Number
 
 
-class BaseLiquidClassModel(BaseModel):
-    """Base class for liquid class definitions."""
-
-    model_config = ConfigDict(populate_by_name=True, extra="forbid")
-
-
 class TipPosition(BaseLiquidClassModel):
     """Properties for tip position reference and relative offset."""
 
@@ -252,6 +251,12 @@ class BlowoutParams(BaseLiquidClassModel):
         alias="flow_rate",
         description="Flow rate for blow out, in microliters per second.",
     )
+    blowoutPosition: Optional[TipPosition] | SkipJsonSchema[None] = Field(
+        None,
+        alias="blowout_position",
+        description="Position of the tip during blowout.",
+        json_schema_extra=_remove_default,
+    )
 
 
 class BlowoutProperties(BaseLiquidClassModel):
@@ -311,23 +316,43 @@ def reshape_glob(
             data["enable"] = data["enabled"]
             data.pop("enabled")
 
-        params_list = [meta.alias for field, meta in params_model.model_fields.items()]
-        list_of_presence_of_params = [param in data.keys() for param in params_list]
-        if any(list_of_presence_of_params):
-            if not all(list_of_presence_of_params):
+        params_list = [
+            meta.alias for field, meta in params_model.model_fields.items()
+        ]  # List of all params in the *model*, including optional ones
+        required_params = [
+            meta.alias
+            for field, meta in params_model.model_fields.items()
+            if meta.is_required()
+        ]  # List of strictly required params
+
+        # List of booleans specifying if each required param is present in the data
+        required_params_in_data = [param in data.keys() for param in required_params]
+        if any(required_params_in_data):
+            if not all(required_params_in_data):
                 raise ValueError(
                     f"{property_name} should specify either all of the params-"
-                    f"{params_list} - or none of them."
+                    f"{required_params} - or none of them."
                 )
             if data.get("params"):
                 raise ValueError(
                     f"{property_name} should specify either all of"
-                    f" {params_list} or 'params', not both."
+                    f" {required_params} or 'params', not both."
                 )
+            # Get a list of the required params + the optional params in the data.
+            # Then move them all under a new "params" key.
+            # This list purposely skips any extra, non-param keys present in the data so that the model validator
+            # can raise a validation error upon encountering the unexpected keys.
+            all_params_in_data = [
+                param
+                for param in params_list
+                if param in required_params
+                or (param not in required_params and data.get(param) is not None)
+            ]
             data["params"] = params_model.model_validate(
-                {param: data[param] for param in params_list}
+                {param: data[param] for param in all_params_in_data}
             )
-            for param in params_list:
+            # Remove the params from the data dict
+            for param in all_params_in_data:
                 data.pop(param)
     return data
 

opentrons_shared_data/liquid_classes/types.py

@@ -1,9 +1,12 @@
 """Type definitions for liquid classes."""
+
 from typing import Sequence, Tuple, TypedDict
+
 from typing_extensions import NotRequired
+
 from .liquid_class_definition import (
-    POSITION_REFERENCE_VALUE_TYPE,
     BLOWOUT_LOCATION_VALUE_TYPE,
+    POSITION_REFERENCE_VALUE_TYPE,
 )
 
 
@@ -52,6 +55,7 @@ class BlowoutPropertiesDict(TypedDict):
     enabled: bool
     location: NotRequired[BLOWOUT_LOCATION_VALUE_TYPE]
     flow_rate: NotRequired[float]
+    blowout_position: NotRequired[TipPositionDict]
 
 
 class SubmergeDict(TypedDict):

opentrons_shared_data/load.py

@@ -1,8 +1,8 @@
-import typing
 import logging
 import os
-from pathlib import Path
+import typing
 from functools import lru_cache
+from pathlib import Path
 
 log = logging.getLogger(__name__)
 

opentrons_shared_data/module/__init__.py

@@ -1,25 +1,24 @@
-""" opentrons_shared_data.module: functions and types for module defs """
+"""opentrons_shared_data.module: functions and types for module defs"""
 
 import json
 from ast import literal_eval
-from pathlib import Path
-from typing import Union, cast, overload
 from functools import lru_cache
 from itertools import product
+from pathlib import Path
+from typing import Union, cast, overload
 
 from ..load import load_shared_data
 from .types import (
-    SchemaVersions,
-    ModuleSchema,
-    SchemaV1,
-    SchemaV3,
     ModuleDefinitionV1,
     ModuleDefinitionV3,
     ModuleModel,
+    ModuleSchema,
+    SchemaV1,
+    SchemaV3,
+    SchemaVersions,
     TOFSensorBaseline,
 )
 
-
 OLD_TC_GEN2_LABWARE_OFFSET = {"x": 0, "y": 68.06, "z": 98.26}
 
 # TODO (spp, 2023-02-14): these values are measured experimentally, and aren't from
@@ -51,8 +50,7 @@ class ModuleNotFoundError(KeyError):
 
     def __str__(self) -> str:
         return (
-            f"No such version {self.requested_version} module "
-            f"{self.requested_module}"
+            f"No such version {self.requested_version} module {self.requested_module}"
         )
 
     def __repr__(self) -> str:
@@ -68,16 +66,16 @@ def load_schema(version: SchemaVersions) -> ModuleSchema:
 
 
 @overload
-def load_definition(version: SchemaV1, model_or_loadname: str) -> ModuleDefinitionV1:
-    ...
+def load_definition(
+    version: SchemaV1, model_or_loadname: str
+) -> ModuleDefinitionV1: ...
 
 
 @overload
 def load_definition(
     version: SchemaV3,
     model_or_loadname: Union[str, ModuleModel],
-) -> ModuleDefinitionV3:
-    ...
+) -> ModuleDefinitionV3: ...
 
 
 def load_definition(

opentrons_shared_data/module/types.py

@@ -2,11 +2,13 @@
 opentrons_shared_data.module.types: types requiring typing_extensions
 for modules
 """
+
 import enum
 from typing import Any, Dict, List, Union
+
 from typing_extensions import Literal, TypedDict
 
-from opentrons_shared_data.labware.types import LocatingFeatures, Extents
+from opentrons_shared_data.labware.types import Extents, LocatingFeatures
 
 SchemaV1 = Literal["1"]
 SchemaV2 = Literal["2"]
@@ -22,6 +24,7 @@ HeaterShakerModuleType = Literal["heaterShakerModuleType"]
 MagneticBlockType = Literal["magneticBlockType"]
 AbsorbanceReaderType = Literal["absorbanceReaderType"]
 FlexStackerModuleType = Literal["flexStackerModuleType"]
+VacuumModuleType = Literal["vacuumModuleType"]
 
 ModuleType = Union[
     MagneticModuleType,
@@ -31,6 +34,7 @@ ModuleType = Union[
     MagneticBlockType,
     AbsorbanceReaderType,
     FlexStackerModuleType,
+    VacuumModuleType,
 ]
 
 MagneticModuleModel = Literal["magneticModuleV1", "magneticModuleV2"]
@@ -40,6 +44,7 @@ HeaterShakerModuleModel = Literal["heaterShakerModuleV1"]
 MagneticBlockModel = Literal["magneticBlockV1"]
 AbsorbanceReaderModel = Literal["absorbanceReaderV1"]
 FlexStackerModuleModel = Literal["flexStackerModuleV1"]
+VacuumModuleModel = Literal["vacuumModuleMilliporeV1"]
 
 ModuleModel = Union[
     MagneticModuleModel,
@@ -49,6 +54,7 @@ ModuleModel = Union[
     MagneticBlockModel,
     AbsorbanceReaderModel,
     FlexStackerModuleModel,
+    VacuumModuleModel,
 ]
 
 ModuleSlotTransform = TypedDict(

opentrons_shared_data/pipette/__init__.py

@@ -1,23 +1,24 @@
-from __future__ import annotations
-
 """
 opentrons_shared_data.pipette: functions and types for pipette config
 """
+
+from __future__ import annotations
+
 import copy
-from typing import TYPE_CHECKING, Dict, Optional
 import json
 from functools import lru_cache
+from typing import TYPE_CHECKING, Dict, Optional
 
 from .. import load_shared_data
 
 if TYPE_CHECKING:
     from .types import (
-        PipetteNameSpecs,
+        ChannelCount,
+        PipetteFusedSpec,
+        PipetteModel,
         PipetteModelSpecs,
         PipetteName,
-        PipetteModel,
-        PipetteFusedSpec,
-        ChannelCount,
+        PipetteNameSpecs,
     )
 
 
@@ -89,7 +90,7 @@ def _fuse_specs_cached(
 
     if pipette_name not in valid_names:
         raise KeyError(
-            f"pipette name {pipette_name} is not valid for model " f"{pipette_model}"
+            f"pipette name {pipette_name} is not valid for model {pipette_model}"
         )
     name_data = _name_config()[pipette_name]
     # unfortunately, mypy can't verify this way to build typed dicts - we'll

opentrons_shared_data/pipette/dev_types.py

@@ -4,7 +4,7 @@ require typing_extensions.
 
 This module should only be imported if typing.TYPE_CHECKING is True.
 """
-from enum import Enum
+
 from typing import Dict, List, NewType, Union
 
 from typing_extensions import Literal, TypedDict
@@ -12,7 +12,7 @@ from typing_extensions import Literal, TypedDict
 # TODO(mc, 2022-06-16): remove type alias when able
 # and when certain removal will not break any pickling
 from ..labware.types import LabwareUri as LabwareUri
-
+from ..util import StrEnum
 
 PipetteName = Literal[
     "p10_single",
@@ -37,7 +37,7 @@ PipetteName = Literal[
 ]
 
 
-class PipetteNameType(str, Enum):
+class PipetteNameType(StrEnum):
     """Pipette load name values."""
 
     value: PipetteName

opentrons_shared_data/pipette/file_operation_helpers.py

@@ -1,8 +1,8 @@
 import json
 from typing import Any, Dict, Union
-from .types import MutableConfig, QuirkConfig
-from .model_constants import VALID_QUIRKS
 
+from .model_constants import VALID_QUIRKS
+from .types import MutableConfig, QuirkConfig
 
 DecoderType = Union[Dict[str, Any], Dict[str, QuirkConfig], MutableConfig]
 

opentrons_shared_data/pipette/load_data.py

@@ -1,31 +1,29 @@
 import json
-from pathlib import Path
+from functools import lru_cache
 from logging import getLogger
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Union
 
-from typing import Dict, Any, Union, Optional, List, Iterator
 from typing_extensions import Literal
-from functools import lru_cache
-
-from .. import load_shared_data, get_shared_data_root
 
+from .. import get_shared_data_root, load_shared_data
+from .model_constants import _MAP_KEY_TO_V2, MOUNT_CONFIG_LOOKUP_TABLE
 from .pipette_definition import (
     PipetteConfigurations,
     PipetteLiquidPropertiesDefinition,
     ValidNozzleMaps,
 )
-from .model_constants import MOUNT_CONFIG_LOOKUP_TABLE, _MAP_KEY_TO_V2
 from .types import (
+    LiquidClasses,
     PipetteChannelType,
-    PipetteModelType,
     PipetteGenerationType,
-    PipetteVersionType,
     PipetteModelMajorVersion,
     PipetteModelMinorVersion,
-    LiquidClasses,
+    PipetteModelType,
     PipetteOEMType,
+    PipetteVersionType,
 )
 
-
 LoadedConfiguration = Dict[str, Union[str, Dict[str, Any]]]
 
 LOG = getLogger(__name__)

opentrons_shared_data/pipette/model_constants.py

@@ -1,11 +1,11 @@
-from typing import Dict, Union, List
+from typing import Dict, List, Union
 
 from .types import (
-    Quirks,
-    RobotMountConfigs,
     AvailableUnits,
-    PipetteGenerationType,
     PipetteChannelType,
+    PipetteGenerationType,
+    Quirks,
+    RobotMountConfigs,
 )
 
 MOUNT_CONFIG_LOOKUP_TABLE = {

opentrons_shared_data/pipette/mutable_configurations.py

@@ -1,38 +1,38 @@
-import logging
 import json
+import logging
 import re
-from pathlib import Path
-from typing import Optional, List, Dict, Any, cast
 from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, cast
 
-from .pipette_definition import PipetteConfigurations, PipetteModelVersionType
+from .file_operation_helpers import (
+    MutableConfigurationDecoder,
+    MutableConfigurationEncoder,
+)
+from .load_data import load_definition, load_serial_lookup_table
 from .model_constants import (
-    MUTABLE_CONFIGS_V1,
-    VALID_QUIRKS,
     _MAP_KEY_TO_V2,
     _MIN_MAX_LOOKUP,
     _TYPE_LOOKUP,
     _UNITS_LOOKUP,
+    MUTABLE_CONFIGS_V1,
+    VALID_QUIRKS,
 )
-from .load_data import load_definition, load_serial_lookup_table
-from .types import (
-    MutableConfig,
-    Quirks,
-    QuirkConfig,
-    TypeOverrides,
-    OverrideType,
-    LiquidClasses,
-)
+from .pipette_definition import PipetteConfigurations, PipetteModelVersionType
 from .pipette_load_name_conversions import (
     convert_pipette_model,
     convert_to_pipette_name_type,
 )
-from .file_operation_helpers import (
-    MutableConfigurationEncoder,
-    MutableConfigurationDecoder,
+from .types import (
+    LiquidClasses,
+    MutableConfig,
+    OverrideType,
+    PipetteModel,
+    PipetteName,
+    QuirkConfig,
+    Quirks,
+    TypeOverrides,
 )
-from .types import PipetteModel, PipetteName
-
 
 log = logging.getLogger(__name__)
 

opentrons_shared_data/pipette/pipette_definition.py

@@ -1,15 +1,17 @@
 import re
-from typing import List, Dict, Tuple, Optional, Annotated, Literal, TypeVar
+from dataclasses import dataclass
+from typing import Annotated, Dict, List, Literal, Optional, Tuple, TypeVar
+
 from pydantic import (
-    field_validator,
     BaseModel,
-    Field,
     BeforeValidator,
+    Field,
     PlainSerializer,
+    field_validator,
 )
-from dataclasses import dataclass
 
-from . import types as pip_types, types
+from . import types
+from . import types as pip_types
 
 # The highest and lowest existing overlap version values.
 TIP_OVERLAP_VERSION_MINIMUM = 0

opentrons_shared_data/pipette/pipette_load_name_conversions.py

@@ -1,22 +1,23 @@
 import re
 from functools import lru_cache
-from typing import List, Optional, Union, cast, Literal, Tuple
-from opentrons_shared_data import get_shared_data_root
-from .types import PipetteModel, PipetteName
+from typing import List, Literal, Optional, Tuple, Union, cast
 
+from .pipette_definition import (
+    PipetteModelVersionType,
+    PipetteNameType,
+)
 from .types import (
     PipetteChannelType,
-    PipetteModelType,
-    PipetteVersionType,
     PipetteGenerationType,
+    PipetteModel,
     PipetteModelMajorVersionType,
     PipetteModelMinorVersionType,
+    PipetteModelType,
+    PipetteName,
     PipetteOEMType,
+    PipetteVersionType,
 )
-from .pipette_definition import (
-    PipetteNameType,
-    PipetteModelVersionType,
-)
+from opentrons_shared_data import get_shared_data_root
 
 DEFAULT_CALIBRATION_OFFSET = [0.0, 0.0, 0.0]
 DEFAULT_MODEL = PipetteModelType.p1000
@@ -211,7 +212,7 @@ def generation_from_string(pipette_name_list: List[str]) -> PipetteGenerationTyp
 
 
 def convert_to_pipette_name_type(
-    model_or_name: Union[PipetteName, PipetteModel]
+    model_or_name: Union[PipetteName, PipetteModel],
 ) -> PipetteNameType:
     """Convert the py:data:PipetteName to a py:obj:PipetteModelVersionType.