opentrons 8.2.0a4__py2.py3-none-any.whl → 8.3.0__py2.py3-none-any.whl

opentrons/protocols/advanced_control/transfers/common.py

@@ -0,0 +1,56 @@
+"""Common functions between v1 transfer and liquid-class-based transfer."""
+import enum
+from typing import Iterable, Generator, Tuple, TypeVar, Literal
+
+
+class TransferTipPolicyV2(enum.Enum):
+    ONCE = "once"
+    NEVER = "never"
+    ALWAYS = "always"
+    PER_SOURCE = "per source"
+
+
+TransferTipPolicyV2Type = Literal["once", "always", "per source", "never"]
+
+Target = TypeVar("Target")
+
+
+def check_valid_volume_parameters(
+    disposal_volume: float, air_gap: float, max_volume: float
+) -> None:
+    if air_gap >= max_volume:
+        raise ValueError(
+            "The air gap must be less than the maximum volume of the pipette"
+        )
+    elif disposal_volume >= max_volume:
+        raise ValueError(
+            "The disposal volume must be less than the maximum volume of the pipette"
+        )
+    elif disposal_volume + air_gap >= max_volume:
+        raise ValueError(
+            "The sum of the air gap and disposal volume must be less than"
+            " the maximum volume of the pipette"
+        )
+
+
+def expand_for_volume_constraints(
+    volumes: Iterable[float],
+    targets: Iterable[Target],
+    max_volume: float,
+) -> Generator[Tuple[float, "Target"], None, None]:
+    """Split a sequence of proposed transfers if necessary to keep each
+    transfer under the given max volume.
+    """
+    # A final defense against an infinite loop.
+    # Raising a proper exception with a helpful message is left to calling code,
+    # because it has more context about what the user is trying to do.
+    assert max_volume > 0
+    for volume, target in zip(volumes, targets):
+        while volume > max_volume * 2:
+            yield max_volume, target
+            volume -= max_volume
+
+        if volume > max_volume:
+            volume /= 2
+            yield volume, target
+        yield volume, target

opentrons/protocols/advanced_control/{transfers.py → transfers/transfer.py}

@@ -9,19 +9,18 @@ from typing import (
     Callable,
     Generator,
     Iterator,
-    Iterable,
     Sequence,
     Tuple,
     TypedDict,
     TypeAlias,
     TYPE_CHECKING,
-    TypeVar,
 )
 from opentrons.protocol_api.labware import Labware, Well
 from opentrons import types
 from opentrons.protocols.api_support.types import APIVersion
-from opentrons.hardware_control.nozzle_manager import NozzleConfigurationType
 
+from . import common as tx_commons
+from ..common import Mix, MixOpts, MixStrategy
 
 AdvancedLiquidHandling = Union[
     Well,
@@ -44,13 +43,6 @@ _PARTIAL_TIP_SUPPORT_ADDED = APIVersion(2, 18)
 """The version after which partial tip support and nozzle maps were made available."""
 
 
-class MixStrategy(enum.Enum):
-    BOTH = enum.auto()
-    BEFORE = enum.auto()
-    AFTER = enum.auto()
-    NEVER = enum.auto()
-
-
 class DropTipStrategy(enum.Enum):
     TRASH = enum.auto()
     RETURN = enum.auto()
@@ -239,34 +231,6 @@ PickUpTipOpts.presses.__doc__ = ":py:class:`int`"
 PickUpTipOpts.increment.__doc__ = ":py:class:`int`"
 
 
-class MixOpts(NamedTuple):
-    """
-    Options to customize behavior of mix.
-
-    These options will be passed to
-    :py:meth:`InstrumentContext.mix` when it is called during the
-    transfer.
-    """
-
-    repetitions: Optional[int] = None
-    volume: Optional[float] = None
-    rate: Optional[float] = None
-
-
-MixOpts.repetitions.__doc__ = ":py:class:`int`"
-MixOpts.volume.__doc__ = ":py:class:`float`"
-MixOpts.rate.__doc__ = ":py:class:`float`"
-
-
-class Mix(NamedTuple):
-    """
-    Options to control mix behavior before aspirate and after dispense.
-    """
-
-    mix_before: MixOpts = MixOpts()
-    mix_after: MixOpts = MixOpts()
-
-
 Mix.mix_before.__doc__ = """
     Options applied to mix before aspirate.
     See :py:class:`.Mix.MixOpts`.
@@ -435,7 +399,7 @@ class TransferPlan:
         # then avoid iterating through its Wells.
         # ii. if using single channel pipettes, flatten a multi-dimensional
         # list of Wells into a 1 dimensional list of Wells
-        pipette_configuration_type = NozzleConfigurationType.FULL
+        pipette_configuration_type = types.NozzleConfigurationType.FULL
         normalized_sources: List[Union[Well, types.Location]]
         normalized_dests: List[Union[Well, types.Location]]
         if self._api_version >= _PARTIAL_TIP_SUPPORT_ADDED:
@@ -444,7 +408,7 @@ class TransferPlan:
             )
         if (
             self._instr.channels > 1
-            and pipette_configuration_type == NozzleConfigurationType.FULL
+            and pipette_configuration_type == types.NozzleConfigurationType.FULL
         ):
             normalized_sources, normalized_dests = self._multichannel_transfer(
                 srcs, dsts
@@ -534,12 +498,12 @@ class TransferPlan:
         """
         # reform source target lists
         sources, dests = self._extend_source_target_lists(self._sources, self._dests)
-        self._check_valid_volume_parameters(
+        tx_commons.check_valid_volume_parameters(
             disposal_volume=self._strategy.disposal_volume,
             air_gap=self._strategy.air_gap,
             max_volume=self._instr.max_volume,
         )
-        plan_iter = self._expand_for_volume_constraints(
+        plan_iter = tx_commons.expand_for_volume_constraints(
             self._volumes,
             zip(sources, dests),
             self._instr.max_volume
@@ -626,7 +590,7 @@ class TransferPlan:
 
         """
 
-        self._check_valid_volume_parameters(
+        tx_commons.check_valid_volume_parameters(
             disposal_volume=self._strategy.disposal_volume,
             air_gap=self._strategy.air_gap,
             max_volume=self._instr.max_volume,
@@ -637,7 +601,7 @@ class TransferPlan:
         # recommend users to specify a disposal vol when using distribute.
         # First method keeps distribute consistent with current behavior while
         # the other maintains consistency in default behaviors of all functions
-        plan_iter = self._expand_for_volume_constraints(
+        plan_iter = tx_commons.expand_for_volume_constraints(
             self._volumes,
             self._dests,
             # todo(mm, 2021-03-09): Is it right for this to be
@@ -686,29 +650,6 @@ class TransferPlan:
                 )
         yield from self._new_tip_action()
 
-    Target = TypeVar("Target")
-
-    @staticmethod
-    def _expand_for_volume_constraints(
-        volumes: Iterable[float], targets: Iterable[Target], max_volume: float
-    ) -> Generator[Tuple[float, "Target"], None, None]:
-        """Split a sequence of proposed transfers if necessary to keep each
-        transfer under the given max volume.
-        """
-        # A final defense against an infinite loop.
-        # Raising a proper exception with a helpful message is left to calling code,
-        # because it has more context about what the user is trying to do.
-        assert max_volume > 0
-        for volume, target in zip(volumes, targets):
-            while volume > max_volume * 2:
-                yield max_volume, target
-                volume -= max_volume
-
-            if volume > max_volume:
-                volume /= 2
-                yield volume, target
-            yield volume, target
-
     def _plan_consolidate(self) -> Generator[TransferStep, None, None]:
         """
         * **Source/ Dest:** Many sources to one destination
@@ -752,7 +693,7 @@ class TransferPlan:
         #     air_gap=self._strategy.air_gap,
         #     max_volume=self._instr.max_volume,
         # )
-        plan_iter = self._expand_for_volume_constraints(
+        plan_iter = tx_commons.expand_for_volume_constraints(
             # todo(mm, 2021-03-09): Is it right to use _instr.max_volume here?
             # Why don't we account for tip max volume, disposal volume, or air
             # gap?
@@ -929,8 +870,8 @@ class TransferPlan:
                 )
             return volume
 
+    @staticmethod
     def _create_volume_gradient(
-        self,
         min_v: float,
         max_v: float,
         total: int,
@@ -947,22 +888,6 @@ class TransferPlan:
 
         return [_map_volume(i) for i in range(total)]
 
-    def _check_valid_volume_parameters(
-        self, disposal_volume: float, air_gap: float, max_volume: float
-    ) -> None:
-        if air_gap >= max_volume:
-            raise ValueError(
-                "The air gap must be less than the maximum volume of the pipette"
-            )
-        elif disposal_volume >= max_volume:
-            raise ValueError(
-                "The disposal volume must be less than the maximum volume of the pipette"
-            )
-        elif disposal_volume + air_gap >= max_volume:
-            raise ValueError(
-                "The sum of the air gap and disposal volume must be less than the maximum volume of the pipette"
-            )
-
     def _check_valid_well_list(
         self, well_list: List[Any], id: str, old_well_list: List[Any]
     ) -> None:

opentrons/protocols/api_support/definitions.py

@@ -1,6 +1,6 @@
 from .types import APIVersion
 
-MAX_SUPPORTED_VERSION = APIVersion(2, 21)
+MAX_SUPPORTED_VERSION = APIVersion(2, 22)
 """The maximum supported protocol API version in this release."""
 
 MIN_SUPPORTED_VERSION = APIVersion(2, 0)

opentrons/protocols/api_support/instrument.py

@@ -73,7 +73,7 @@ def tip_length_for(
 
 
 VALID_PIP_TIPRACK_VOL = {
-    "FLEX": {"p50": [50], "p1000": [50, 200, 1000]},
+    "FLEX": {"p50": [50], "p200": [50, 200], "p1000": [50, 200, 1000]},
     "OT2": {
         "p10": [10, 20],
         "p20": [10, 20],

opentrons/protocols/api_support/util.py

@@ -391,3 +391,13 @@ def requires_version(major: int, minor: int) -> Callable[[FuncT], FuncT]:
         return cast(FuncT, _check_version_wrapper)
 
     return _set_version
+
+
+class ModifiedList(list[str]):
+    def __contains__(self, item: object) -> bool:
+        if not isinstance(item, str):
+            return False
+        for name in self:
+            if name == item.replace("-", "_").lower():
+                return True
+        return False

opentrons/protocols/labware.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import logging
 import json
-
+import os
 from pathlib import Path
-from typing import Any, AnyStr, Dict, Optional, Union
+from typing import Any, AnyStr, Dict, Optional, Union, List, Sequence, Literal
 
 import jsonschema  # type: ignore
 
 from opentrons_shared_data import load_shared_data, get_shared_data_root
+from opentrons.protocols.api_support.util import ModifiedList
 from opentrons.protocols.api_support.constants import (
     OPENTRONS_NAMESPACE,
     CUSTOM_NAMESPACE,
@@ -16,10 +17,30 @@ from opentrons.protocols.api_support.constants import (
     USER_DEFS_PATH,
 )
 from opentrons_shared_data.labware.types import LabwareDefinition
+from opentrons_shared_data.errors.exceptions import InvalidProtocolData
 
 
 MODULE_LOG = logging.getLogger(__name__)
 
+LabwareProblem = Literal[
+    "no-schema-id", "bad-schema-id", "schema-mismatch", "invalid-json"
+]
+
+
+class NotALabwareError(InvalidProtocolData):
+    def __init__(
+        self, problem: LabwareProblem, wrapping: Sequence[BaseException]
+    ) -> None:
+        messages: dict[LabwareProblem, str] = {
+            "no-schema-id": "No schema ID present in file",
+            "bad-schema-id": "Bad schema ID in file",
+            "invalid-json": "File does not contain valid JSON",
+            "schema-mismatch": "File does not match labware schema",
+        }
+        super().__init__(
+            message=messages[problem], detail={"kind": problem}, wrapping=wrapping
+        )
+
 
 def get_labware_definition(
     load_name: str,
@@ -61,6 +82,29 @@ def get_labware_definition(
     return _get_standard_labware_definition(load_name, namespace, version)
 
 
+def get_all_labware_definitions(schema_version: str = "2") -> List[str]:
+    """
+    Return a list of standard and custom labware definitions with load_name +
+        name_space + version existing on the robot
+    """
+    labware_list = ModifiedList()
+
+    def _check_for_subdirectories(path: Union[str, Path, os.DirEntry[str]]) -> None:
+        with os.scandir(path) as top_path:
+            for sub_dir in top_path:
+                if sub_dir.is_dir():
+                    labware_list.append(sub_dir.name)
+
+    # check for standard labware
+    _check_for_subdirectories(
+        get_shared_data_root() / STANDARD_DEFS_PATH / schema_version
+    )
+    # check for custom labware
+    for namespace in os.scandir(USER_DEFS_PATH):
+        _check_for_subdirectories(namespace)
+    return labware_list
+
+
 def save_definition(
     labware_def: LabwareDefinition, force: bool = False, location: Optional[Path] = None
 ) -> None:
@@ -102,7 +146,7 @@ def save_definition(
         json.dump(labware_def, f)
 
 
-def verify_definition(
+def verify_definition(  # noqa: C901
     contents: Union[AnyStr, LabwareDefinition, Dict[str, Any]]
 ) -> LabwareDefinition:
     """Verify that an input string is a labware definition and return it.
@@ -114,14 +158,33 @@ def verify_definition(
     :raises jsonschema.ValidationError: If the definition is not valid.
     :returns: The parsed definition
     """
-    schema_body = load_shared_data("labware/schemas/2.json").decode("utf-8")
-    labware_schema_v2 = json.loads(schema_body)
+    schemata_by_version = {
+        2: json.loads(load_shared_data("labware/schemas/2.json").decode("utf-8")),
+        3: json.loads(load_shared_data("labware/schemas/3.json").decode("utf-8")),
+    }
 
     if isinstance(contents, dict):
         to_return = contents
     else:
-        to_return = json.loads(contents)
-    jsonschema.validate(to_return, labware_schema_v2)
+        try:
+            to_return = json.loads(contents)
+        except json.JSONDecodeError as e:
+            raise NotALabwareError("invalid-json", [e]) from e
+    try:
+        schema_version = to_return["schemaVersion"]
+    except KeyError as e:
+        raise NotALabwareError("no-schema-id", [e]) from e
+
+    try:
+        schema = schemata_by_version[schema_version]
+    except KeyError as e:
+        raise NotALabwareError("bad-schema-id", [e]) from e
+
+    try:
+        jsonschema.validate(to_return, schema)
+    except jsonschema.ValidationError as e:
+        raise NotALabwareError("schema-mismatch", [e]) from e
+
     # we can type ignore this because if it passes the jsonschema it has
     # the correct structure
     return to_return  # type: ignore[return-value]
@@ -176,7 +239,6 @@ def _get_labware_definition_from_bundle(
 def _get_standard_labware_definition(
     load_name: str, namespace: Optional[str] = None, version: Optional[int] = None
 ) -> LabwareDefinition:
-
     if version is None:
         checked_version = 1
     else:

opentrons/protocols/models/json_protocol.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, Extra, Field
+from pydantic import ConfigDict, BaseModel, Field
 from typing_extensions import Literal
 
 from opentrons_shared_data.labware.labware_definition import LabwareDefinition
@@ -75,8 +75,7 @@ class Metadata(BaseModel):
     Optional metadata about the protocol
     """
 
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     protocolName: Optional[str] = Field(
         None, description="A short, human-readable name for the protocol"
@@ -574,8 +573,7 @@ class Pipettes(BaseModel):
     Fields describing an individual pipette
     """
 
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     mount: Literal["left", "right"] = Field(
         ..., description="Where the pipette is mounted"
@@ -592,8 +590,7 @@ class Labware(BaseModel):
     Fields describing a single labware on the deck
     """
 
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     slot: str = Field(
         ...,
@@ -616,8 +613,7 @@ class Modules(BaseModel):
     Fields describing a single module on the deck
     """
 
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     slot: str = Field(
         ...,

opentrons/simulate.py

@@ -829,7 +829,9 @@ def _create_live_context_pe(
     # Non-async would use call_soon_threadsafe(), which makes the waiting harder.
     async def add_all_extra_labware() -> None:
         for labware_definition_dict in extra_labware.values():
-            labware_definition = LabwareDefinition.parse_obj(labware_definition_dict)
+            labware_definition = LabwareDefinition.model_validate(
+                labware_definition_dict
+            )
             pe.add_labware_definition(labware_definition)
 
     # Add extra_labware to ProtocolEngine, being careful not to modify ProtocolEngine from this

opentrons/types.py

@@ -1,7 +1,17 @@
 from __future__ import annotations
 import enum
 from math import sqrt, isclose
-from typing import TYPE_CHECKING, Any, NamedTuple, Iterator, Union, List, Optional
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    NamedTuple,
+    Iterator,
+    Union,
+    List,
+    Optional,
+    Protocol,
+    Dict,
+)
 
 from opentrons_shared_data.robot.types import RobotType
 
@@ -150,7 +160,7 @@ class Location:
            point, labware = location
            some_function_taking_both(*location)
         """
-        return iter((self._point, self._labware))  # type: ignore [arg-type]
+        return iter((self._point, self._labware))
 
     def __eq__(self, other: object) -> bool:
         return (
@@ -253,6 +263,75 @@ class OT3MountType(str, enum.Enum):
     GRIPPER = "gripper"
 
 
+class AxisType(enum.Enum):
+    X = "X"  # gantry
+    Y = "Y"
+    Z_L = "Z_L"  # left pipette mount Z
+    Z_R = "Z_R"  # right pipette mount Z
+    Z_G = "Z_G"  # gripper mount Z
+    P_L = "P_L"  # left pipette plunger
+    P_R = "P_R"  # right pipette plunger
+    Q = "Q"  # hi-throughput pipette tiprack grab
+    G = "G"  # gripper grab
+
+    @classmethod
+    def axis_for_mount(cls, mount: Mount) -> "AxisType":
+        map_axis_to_mount = {
+            Mount.LEFT: cls.Z_L,
+            Mount.RIGHT: cls.Z_R,
+            Mount.EXTENSION: cls.Z_G,
+        }
+        return map_axis_to_mount[mount]
+
+    @classmethod
+    def mount_for_axis(cls, axis: "AxisType") -> Mount:
+        map_mount_to_axis = {
+            cls.Z_L: Mount.LEFT,
+            cls.Z_R: Mount.RIGHT,
+            cls.Z_G: Mount.EXTENSION,
+        }
+        return map_mount_to_axis[axis]
+
+    @classmethod
+    def plunger_axis_for_mount(cls, mount: Mount) -> "AxisType":
+        map_plunger_axis_mount = {Mount.LEFT: cls.P_L, Mount.RIGHT: cls.P_R}
+        return map_plunger_axis_mount[mount]
+
+    @classmethod
+    def ot2_axes(cls) -> List["AxisType"]:
+        return [
+            AxisType.X,
+            AxisType.Y,
+            AxisType.Z_L,
+            AxisType.Z_R,
+            AxisType.P_L,
+            AxisType.P_R,
+        ]
+
+    @classmethod
+    def flex_gantry_axes(cls) -> List["AxisType"]:
+        return [
+            AxisType.X,
+            AxisType.Y,
+            AxisType.Z_L,
+            AxisType.Z_R,
+            AxisType.Z_G,
+        ]
+
+    @classmethod
+    def ot2_gantry_axes(cls) -> List["AxisType"]:
+        return [
+            AxisType.X,
+            AxisType.Y,
+            AxisType.Z_L,
+            AxisType.Z_R,
+        ]
+
+
+AxisMapType = Dict[AxisType, float]
+StringAxisMap = Dict[str, float]
+
+
 # TODO(mc, 2020-11-09): this makes sense in shared-data or other common
 # model library
 # https://github.com/Opentrons/opentrons/pull/6943#discussion_r519029833
@@ -426,3 +505,84 @@ class TransferTipPolicy(enum.Enum):
 
 DeckLocation = Union[int, str]
 ALLOWED_PRIMARY_NOZZLES = ["A1", "H1", "A12", "H12"]
+
+
+class NozzleConfigurationType(enum.Enum):
+    """Short names for types of nozzle configurations.
+
+    Represents the current nozzle configuration stored in a NozzleMap.
+    """
+
+    COLUMN = "COLUMN"
+    ROW = "ROW"
+    SINGLE = "SINGLE"
+    FULL = "FULL"
+    SUBRECT = "SUBRECT"
+
+
+class NozzleMapInterface(Protocol):
+    """
+    A NozzleMap instance represents a specific configuration of active nozzles on a pipette.
+
+    It exposes properties of the configuration like the configuration's front-right, front-left,
+    back-left and starting nozzles as well as a map of all the nozzles active in the configuration.
+
+    Because NozzleMaps represent configurations directly, the properties of the NozzleMap may not
+    match the properties of the physical pipette. For instance, a NozzleMap for a single channel
+    configuration of an 8-channel pipette - say, A1 only - will have its front left, front right,
+    and active channels all be A1, while the physical configuration would have the front right
+    channel be H1.
+    """
+
+    @property
+    def starting_nozzle(self) -> str:
+        """The nozzle that automated operations that count nozzles should start at."""
+        ...
+
+    @property
+    def rows(self) -> dict[str, list[str]]:
+        """A map of all the rows active in this configuration."""
+        ...
+
+    @property
+    def columns(self) -> dict[str, list[str]]:
+        """A map of all the columns active in this configuration."""
+        ...
+
+    @property
+    def back_left(self) -> str:
+        """The backest, leftest (i.e. back if it's a column, left if it's a row) nozzle of the configuration.
+
+        Note: This is the value relevant for this particular configuration, and it may not represent the back left nozzle
+        of the underlying physical pipette. For instance, the back-left nozzle of a configuration representing nozzles
+        D7 to H12 of a 96-channel pipette is D7, which is not the back-left nozzle of the physical pipette (A1).
+        """
+        ...
+
+    @property
+    def configuration(self) -> NozzleConfigurationType:
+        """The kind of configuration represented by this nozzle map."""
+        ...
+
+    @property
+    def front_right(self) -> str:
+        """The frontest, rightest (i.e. front if it's a column, right if it's a row) nozzle of the configuration.
+
+        Note: This is the value relevant for this configuration, not the physical pipette. See the note on back_left.
+        """
+        ...
+
+    @property
+    def tip_count(self) -> int:
+        """The total number of active nozzles in the configuration, and thus the number of tips that will be picked up."""
+        ...
+
+    @property
+    def physical_nozzle_count(self) -> int:
+        """The number of actual physical nozzles on the pipette, regardless of configuration."""
+        ...
+
+    @property
+    def active_nozzles(self) -> list[str]:
+        """An unstructured list of all nozzles active in the configuration."""
+        ...

opentrons/util/entrypoint_util.py

@@ -6,7 +6,6 @@ import contextlib
 from dataclasses import dataclass
 import json
 import logging
-from json import JSONDecodeError
 import pathlib
 import subprocess
 import sys
@@ -21,8 +20,6 @@ from typing import (
     TYPE_CHECKING,
 )
 
-from jsonschema import ValidationError  # type: ignore
-
 from opentrons.calibration_storage.deck_configuration import (
     deserialize_deck_configuration,
 )
@@ -32,7 +29,7 @@ from opentrons.config import (
     JUPYTER_NOTEBOOK_LABWARE_DIR,
     SystemArchitecture,
 )
-from opentrons.protocol_api import labware
+from opentrons.protocols import labware
 from opentrons.calibration_storage import helpers
 from opentrons.protocol_engine.errors.error_occurrence import (
     ErrorOccurrence as ProtocolEngineErrorOccurrence,
@@ -79,7 +76,7 @@ def labware_from_paths(
             if child.is_file() and child.suffix.endswith("json"):
                 try:
                     defn = labware.verify_definition(child.read_bytes())
-                except (ValidationError, JSONDecodeError):
+                except labware.NotALabwareError:
                     log.info(f"{child}: invalid labware, ignoring")
                     log.debug(
                         f"{child}: labware invalid because of this exception.",