opentrons 8.3.0a0__py2.py3-none-any.whl → 8.3.0a1__py2.py3-none-any.whl

opentrons/hardware_control/emulation/module_server/server.py

@@ -53,7 +53,9 @@ class ModuleStatusServer(ProxyListener):
         self._connections[identifier] = connection
         for c in self._clients:
             c.write(
-                Message(status="connected", connections=[connection]).json().encode()
+                Message(status="connected", connections=[connection])
+                .model_dump_json()
+                .encode()
             )
             c.write(b"\n")
 
@@ -72,7 +74,7 @@ class ModuleStatusServer(ProxyListener):
             for c in self._clients:
                 c.write(
                     Message(status="disconnected", connections=[connection])
-                    .json()
+                    .model_dump_json()
                     .encode()
                 )
                 c.write(MessageDelimiter)
@@ -95,7 +97,7 @@ class ModuleStatusServer(ProxyListener):
         # A client connected. Send a dump of all connected modules.
         m = Message(status="dump", connections=list(self._connections.values()))
 
-        writer.write(m.json().encode())
+        writer.write(m.model_dump_json().encode())
         writer.write(MessageDelimiter)
 
         self._clients.add(writer)

opentrons/hardware_control/emulation/settings.py

@@ -1,7 +1,8 @@
 from typing import List
 from opentrons.hardware_control.emulation.types import ModuleType
 from opentrons.hardware_control.emulation.util import TEMPERATURE_ROOM
-from pydantic import BaseSettings, BaseModel
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class PipetteSettings(BaseModel):
@@ -113,8 +114,6 @@ class Settings(BaseSettings):
         emulator_port=9003, driver_port=9998
     )
     magdeck_proxy: ProxySettings = ProxySettings(emulator_port=9004, driver_port=9999)
-
-    class Config:
-        env_prefix = "OT_EMULATOR_"
+    model_config = SettingsConfigDict(env_prefix="OT_EMULATOR_")
 
     module_server: ModuleServerSettings = ModuleServerSettings()

opentrons/hardware_control/instruments/ot2/instrument_calibration.py

@@ -123,7 +123,8 @@ def load_tip_length_for_pipette(
 ) -> TipLengthCalibration:
     if isinstance(tiprack, LabwareDefinition):
         tiprack = typing.cast(
-            "TypeDictLabwareDef", tiprack.dict(exclude_none=True, exclude_unset=True)
+            "TypeDictLabwareDef",
+            tiprack.model_dump(exclude_none=True, exclude_unset=True),
         )
 
     tip_length_data = calibration_storage.load_tip_length_calibration(

opentrons/hardware_control/instruments/ot2/pipette.py

@@ -28,7 +28,7 @@ from opentrons_shared_data.errors.exceptions import (
     CommandPreconditionViolated,
 )
 from opentrons_shared_data.pipette.ul_per_mm import (
-    piecewise_volume_conversion,
+    calculate_ul_per_mm,
     PIPETTING_FUNCTION_FALLBACK_VERSION,
     PIPETTING_FUNCTION_LATEST_VERSION,
 )
@@ -97,7 +97,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
         use_old_aspiration_functions: bool = False,
     ) -> None:
         self._config = config
-        self._config_as_dict = config.dict()
+        self._config_as_dict = config.model_dump()
         self._pipette_offset = pipette_offset_cal
         self._pipette_type = self._config.pipette_type
         self._pipette_version = self._config.version
@@ -277,7 +277,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
             self._config, elements, liquid_class
         )
         # Update the cached dict representation
-        self._config_as_dict = self._config.dict()
+        self._config_as_dict = self._config.model_dump()
 
     def reload_configurations(self) -> None:
         self._config = load_pipette_data.load_definition(
@@ -286,7 +286,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
             self._pipette_model.pipette_version,
             self._pipette_model.oem_type,
         )
-        self._config_as_dict = self._config.dict()
+        self._config_as_dict = self._config.model_dump()
 
     def reset_state(self) -> None:
         self._current_volume = 0.0
@@ -589,21 +589,9 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
     # want this to unbounded.
     @functools.lru_cache(maxsize=100)
     def ul_per_mm(self, ul: float, action: UlPerMmAction) -> float:
-        if action == "aspirate":
-            fallback = self._active_tip_settings.aspirate.default[
-                PIPETTING_FUNCTION_FALLBACK_VERSION
-            ]
-            sequence = self._active_tip_settings.aspirate.default.get(
-                self._pipetting_function_version, fallback
-            )
-        else:
-            fallback = self._active_tip_settings.dispense.default[
-                PIPETTING_FUNCTION_FALLBACK_VERSION
-            ]
-            sequence = self._active_tip_settings.dispense.default.get(
-                self._pipetting_function_version, fallback
-            )
-        return piecewise_volume_conversion(ul, sequence)
+        return calculate_ul_per_mm(
+            ul, action, self._active_tip_settings, self._pipetting_function_version
+        )
 
     def __str__(self) -> str:
         return "{} current volume {}ul critical point: {} at {}".format(
@@ -673,8 +661,8 @@ def _reload_and_check_skip(
         # Same config, good enough
         return attached_instr, True
     else:
-        newdict = new_config.dict()
-        olddict = attached_instr.config.dict()
+        newdict = new_config.model_dump()
+        olddict = attached_instr.config.model_dump()
         changed: Set[str] = set()
         for k in newdict.keys():
             if newdict[k] != olddict[k]:

opentrons/hardware_control/instruments/ot2/pipette_handler.py

@@ -230,7 +230,7 @@ class PipetteHandlerProvider(Generic[MountType]):
             result["current_nozzle_map"] = instr.nozzle_manager.current_configuration
             result["min_volume"] = instr.liquid_class.min_volume
             result["max_volume"] = instr.liquid_class.max_volume
-            result["channels"] = instr.channels
+            result["channels"] = instr._max_channels.value
             result["has_tip"] = instr.has_tip
             result["tip_length"] = instr.current_tip_length
             result["aspirate_speed"] = self.plunger_speed(
@@ -260,6 +260,13 @@ class PipetteHandlerProvider(Generic[MountType]):
                 "pipette_bounding_box_offsets"
             ] = instr.config.pipette_bounding_box_offsets
             result["lld_settings"] = instr.config.lld_settings
+            result["plunger_positions"] = {
+                "top": instr.plunger_positions.top,
+                "bottom": instr.plunger_positions.bottom,
+                "blow_out": instr.plunger_positions.blow_out,
+                "drop_tip": instr.plunger_positions.drop_tip,
+            }
+            result["shaft_ul_per_mm"] = instr.config.shaft_ul_per_mm
         return cast(PipetteDict, result)
 
     @property

opentrons/hardware_control/instruments/ot3/gripper.py

@@ -318,8 +318,8 @@ def _reload_gripper(
         # Same config, good enough
         return attached_instr, True
     else:
-        newdict = new_config.dict()
-        olddict = attached_instr.config.dict()
+        newdict = new_config.model_dump()
+        olddict = attached_instr.config.model_dump()
         changed: Set[str] = set()
         for k in newdict.keys():
             if newdict[k] != olddict[k]:

opentrons/hardware_control/instruments/ot3/pipette.py

@@ -27,7 +27,7 @@ from opentrons_shared_data.errors.exceptions import (
     InvalidInstrumentData,
 )
 from opentrons_shared_data.pipette.ul_per_mm import (
-    piecewise_volume_conversion,
+    calculate_ul_per_mm,
     PIPETTING_FUNCTION_FALLBACK_VERSION,
     PIPETTING_FUNCTION_LATEST_VERSION,
 )
@@ -80,7 +80,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
         use_old_aspiration_functions: bool = False,
     ) -> None:
         self._config = config
-        self._config_as_dict = config.dict()
+        self._config_as_dict = config.model_dump()
         self._plunger_motor_current = config.plunger_motor_configurations
         self._pick_up_configurations = config.pick_up_tip_configurations
         self._plunger_homing_configurations = config.plunger_homing_configurations
@@ -257,7 +257,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
             self._pipette_model.pipette_version,
             self._pipette_model.oem_type,
         )
-        self._config_as_dict = self._config.dict()
+        self._config_as_dict = self._config.model_dump()
 
     def reset_state(self) -> None:
         self._current_volume = 0.0
@@ -539,23 +539,13 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
     # want this to unbounded.
     @functools.lru_cache(maxsize=100)
     def ul_per_mm(self, ul: float, action: UlPerMmAction) -> float:
-        if action == "aspirate":
-            fallback = self._active_tip_settings.aspirate.default[
-                PIPETTING_FUNCTION_FALLBACK_VERSION
-            ]
-            sequence = self._active_tip_settings.aspirate.default.get(
-                self._pipetting_function_version, fallback
-            )
-        elif action == "blowout":
-            return self._config.shaft_ul_per_mm
-        else:
-            fallback = self._active_tip_settings.dispense.default[
-                PIPETTING_FUNCTION_FALLBACK_VERSION
-            ]
-            sequence = self._active_tip_settings.dispense.default.get(
-                self._pipetting_function_version, fallback
-            )
-        return piecewise_volume_conversion(ul, sequence)
+        return calculate_ul_per_mm(
+            ul,
+            action,
+            self._active_tip_settings,
+            self._pipetting_function_version,
+            self._config.shaft_ul_per_mm,
+        )
 
     def __str__(self) -> str:
         return "{} current volume {}ul critical point: {} at {}".format(
@@ -595,6 +585,7 @@ class Pipette(AbstractInstrument[PipetteConfigurations]):
                 "versioned_tip_overlap": self.tip_overlap,
                 "back_compat_names": self._config.pipette_backcompat_names,
                 "supported_tips": self.liquid_class.supported_tips,
+                "shaft_ul_per_mm": self._config.shaft_ul_per_mm,
             }
         )
         return self._config_as_dict
@@ -785,8 +776,8 @@ def _reload_and_check_skip(
         # Same config, good enough
         return attached_instr, True
     else:
-        newdict = new_config.dict()
-        olddict = attached_instr.config.dict()
+        newdict = new_config.model_dump()
+        olddict = attached_instr.config.model_dump()
         changed: Set[str] = set()
         for k in newdict.keys():
             if newdict[k] != olddict[k]:

opentrons/hardware_control/instruments/ot3/pipette_handler.py

@@ -237,6 +237,7 @@ class OT3PipetteHandler:
                 "back_compat_names",
                 "supported_tips",
                 "lld_settings",
+                "available_sensors",
             ]
 
             instr_dict = instr.as_dict()
@@ -248,7 +249,7 @@ class OT3PipetteHandler:
             result["current_nozzle_map"] = instr.nozzle_manager.current_configuration
             result["min_volume"] = instr.liquid_class.min_volume
             result["max_volume"] = instr.liquid_class.max_volume
-            result["channels"] = instr._max_channels
+            result["channels"] = instr._max_channels.value
             result["has_tip"] = instr.has_tip
             result["tip_length"] = instr.current_tip_length
             result["aspirate_speed"] = self.plunger_speed(
@@ -282,6 +283,14 @@ class OT3PipetteHandler:
                 "pipette_bounding_box_offsets"
             ] = instr.config.pipette_bounding_box_offsets
             result["lld_settings"] = instr.config.lld_settings
+            result["plunger_positions"] = {
+                "top": instr.plunger_positions.top,
+                "bottom": instr.plunger_positions.bottom,
+                "blow_out": instr.plunger_positions.blow_out,
+                "drop_tip": instr.plunger_positions.drop_tip,
+            }
+            result["shaft_ul_per_mm"] = instr.config.shaft_ul_per_mm
+            result["available_sensors"] = instr.config.available_sensors
         return cast(PipetteDict, result)
 
     @property

opentrons/hardware_control/modules/mod_abc.py

@@ -2,7 +2,7 @@ import abc
 import asyncio
 import logging
 import re
-from typing import ClassVar, Mapping, Optional, TypeVar, cast
+from typing import ClassVar, Mapping, Optional, TypeVar
 from packaging.version import InvalidVersion, parse, Version
 from opentrons.config import IS_ROBOT, ROBOT_FIRMWARE_DIR
 from opentrons.drivers.rpi_drivers.types import USBPort
@@ -31,7 +31,7 @@ def parse_fw_version(version: str) -> Version:
             raise InvalidVersion()
     except InvalidVersion:
         device_version = parse("v0.0.0")
-    return cast(Version, device_version)
+    return device_version
 
 
 class AbstractModule(abc.ABC):

opentrons/hardware_control/motion_utilities.py

@@ -1,4 +1,6 @@
 """Utilities for calculating motion correctly."""
+from logging import getLogger
+
 from functools import lru_cache
 from typing import Callable, Dict, Union, Optional, cast
 from collections import OrderedDict
@@ -11,6 +13,7 @@ from opentrons.util import linal
 
 from .types import Axis, OT3Mount
 
+log = getLogger(__name__)
 
 # TODO: The offset_for_mount function should be defined with an overload
 # set, as with other functions in this module. Unfortunately, mypy < 0.920
@@ -36,6 +39,19 @@ from .types import Axis, OT3Mount
 # ) -> Point:
 #     ...
 
+EMPTY_ORDERED_DICT = OrderedDict(
+    (
+        (Axis.X, 0.0),
+        (Axis.Y, 0.0),
+        (Axis.Z_L, 0.0),
+        (Axis.Z_R, 0.0),
+        (Axis.Z_G, 0.0),
+        (Axis.P_L, 0.0),
+        (Axis.P_R, 0.0),
+        (Axis.Q, 0.0),
+    )
+)
+
 
 @lru_cache(4)
 def offset_for_mount(
@@ -68,6 +84,7 @@ def target_position_from_absolute(
     )
     primary_cp = get_critical_point(mount)
     primary_z = Axis.by_mount(mount)
+
     target_position = OrderedDict(
         (
             (Axis.X, abs_position.x - offset.x - primary_cp.x),
@@ -97,6 +114,57 @@ def target_position_from_relative(
     return target_position
 
 
+def target_axis_map_from_absolute(
+    primary_mount: Union[OT3Mount, Mount],
+    axis_map: Dict[Axis, float],
+    get_critical_point: Callable[[Union[Mount, OT3Mount]], Point],
+    left_mount_offset: Point,
+    right_mount_offset: Point,
+    gripper_mount_offset: Optional[Point] = None,
+) -> "OrderedDict[Axis, float]":
+    """Create an absolute target position for all specified machine axes."""
+    keys_for_target_position = list(axis_map.keys())
+
+    offset = offset_for_mount(
+        primary_mount, left_mount_offset, right_mount_offset, gripper_mount_offset
+    )
+    primary_cp = get_critical_point(primary_mount)
+    primary_z = Axis.by_mount(primary_mount)
+    target_position = OrderedDict()
+
+    if Axis.X in keys_for_target_position:
+        target_position[Axis.X] = axis_map[Axis.X] - offset.x - primary_cp.x
+    if Axis.Y in keys_for_target_position:
+        target_position[Axis.Y] = axis_map[Axis.Y] - offset.y - primary_cp.y
+    if primary_z in keys_for_target_position:
+        # Since this function is intended to be used in conjunction with `API.move_axes`
+        # we must leave out the carriage offset subtraction from the target position as
+        # `move_axes` already does this calculation.
+        target_position[primary_z] = axis_map[primary_z] - primary_cp.z
+
+    target_position.update(
+        {ax: val for ax, val in axis_map.items() if ax not in Axis.gantry_axes()}
+    )
+    return target_position
+
+
+def target_axis_map_from_relative(
+    axis_map: Dict[Axis, float],
+    current_position: Dict[Axis, float],
+) -> "OrderedDict[Axis, float]":
+    """Create a target position for all specified machine axes."""
+    target_position = OrderedDict(
+        (
+            (ax, current_position[ax] + axis_map[ax])
+            for ax in EMPTY_ORDERED_DICT.keys()
+            if ax in axis_map.keys()
+        )
+    )
+    log.info(f"Current position {current_position} and axis map delta {axis_map}")
+    log.info(f"Relative move target {target_position}")
+    return target_position
+
+
 def target_position_from_plunger(
     mount: Union[Mount, OT3Mount],
     delta: float,

opentrons/hardware_control/nozzle_manager.py

@@ -1,11 +1,13 @@
 from typing import Dict, List, Optional, Any, Sequence, Iterator, Tuple, cast
 from dataclasses import dataclass
 from collections import OrderedDict
-from enum import Enum
 from itertools import chain
 
 from opentrons.hardware_control.types import CriticalPoint
-from opentrons.types import Point
+from opentrons.types import (
+    Point,
+    NozzleConfigurationType,
+)
 from opentrons_shared_data.pipette.pipette_definition import (
     PipetteGeometryDefinition,
     PipetteRowDefinition,
@@ -41,43 +43,6 @@ def _row_col_indices_for_nozzle(
     )
 
 
-class NozzleConfigurationType(Enum):
-    """
-    Nozzle Configuration Type.
-
-    Represents the current nozzle
-    configuration stored in NozzleMap
-    """
-
-    COLUMN = "COLUMN"
-    ROW = "ROW"
-    SINGLE = "SINGLE"
-    FULL = "FULL"
-    SUBRECT = "SUBRECT"
-
-    @classmethod
-    def determine_nozzle_configuration(
-        cls,
-        physical_rows: "OrderedDict[str, List[str]]",
-        current_rows: "OrderedDict[str, List[str]]",
-        physical_cols: "OrderedDict[str, List[str]]",
-        current_cols: "OrderedDict[str, List[str]]",
-    ) -> "NozzleConfigurationType":
-        """
-        Determine the nozzle configuration based on the starting and
-        ending nozzle.
-        """
-        if physical_rows == current_rows and physical_cols == current_cols:
-            return NozzleConfigurationType.FULL
-        if len(current_rows) == 1 and len(current_cols) == 1:
-            return NozzleConfigurationType.SINGLE
-        if len(current_rows) == 1:
-            return NozzleConfigurationType.ROW
-        if len(current_cols) == 1:
-            return NozzleConfigurationType.COLUMN
-        return NozzleConfigurationType.SUBRECT
-
-
 @dataclass
 class NozzleMap:
     """
@@ -113,6 +78,28 @@ class NozzleMap:
     full_instrument_rows: Dict[str, List[str]]
     #: A map of all the rows of an instrument
 
+    @classmethod
+    def determine_nozzle_configuration(
+        cls,
+        physical_rows: "OrderedDict[str, List[str]]",
+        current_rows: "OrderedDict[str, List[str]]",
+        physical_cols: "OrderedDict[str, List[str]]",
+        current_cols: "OrderedDict[str, List[str]]",
+    ) -> "NozzleConfigurationType":
+        """
+        Determine the nozzle configuration based on the starting and
+        ending nozzle.
+        """
+        if physical_rows == current_rows and physical_cols == current_cols:
+            return NozzleConfigurationType.FULL
+        if len(current_rows) == 1 and len(current_cols) == 1:
+            return NozzleConfigurationType.SINGLE
+        if len(current_rows) == 1:
+            return NozzleConfigurationType.ROW
+        if len(current_cols) == 1:
+            return NozzleConfigurationType.COLUMN
+        return NozzleConfigurationType.SUBRECT
+
     def __str__(self) -> str:
         return f"back_left_nozzle: {self.back_left} front_right_nozzle: {self.front_right} configuration: {self.configuration}"
 
@@ -216,6 +203,16 @@ class NozzleMap:
         """The total number of active nozzles in the configuration, and thus the number of tips that will be picked up."""
         return len(self.map_store)
 
+    @property
+    def physical_nozzle_count(self) -> int:
+        """The number of physical nozzles, regardless of configuration."""
+        return len(self.full_instrument_map_store)
+
+    @property
+    def active_nozzles(self) -> list[str]:
+        """An unstructured list of all nozzles active in the configuration."""
+        return list(self.map_store.keys())
+
     @classmethod
     def build(  # noqa: C901
         cls,
@@ -274,7 +271,7 @@ class NozzleMap:
         )
 
         if (
-            NozzleConfigurationType.determine_nozzle_configuration(
+            cls.determine_nozzle_configuration(
                 physical_rows, rows, physical_columns, columns
             )
             != NozzleConfigurationType.FULL
@@ -289,6 +286,7 @@ class NozzleMap:
             if valid_nozzle_maps.maps[map_key] == list(map_store.keys()):
                 validated_map_key = map_key
                 break
+
         if validated_map_key is None:
             raise IncompatibleNozzleConfiguration(
                 "Attempted Nozzle Configuration does not match any approved map layout for the current pipette."
@@ -302,7 +300,7 @@ class NozzleMap:
             full_instrument_map_store=physical_nozzles,
             full_instrument_rows=physical_rows,
             columns=columns,
-            configuration=NozzleConfigurationType.determine_nozzle_configuration(
+            configuration=cls.determine_nozzle_configuration(
                 physical_rows, rows, physical_columns, columns
             ),
         )

opentrons/hardware_control/ot3_calibration.py

@@ -968,7 +968,7 @@ def load_attitude_matrix(to_default: bool = True) -> DeckCalibration:
         return DeckCalibration(
             attitude=apply_machine_transform(calibration_data.attitude),
             source=calibration_data.source,
-            status=types.CalibrationStatus(**calibration_data.status.dict()),
+            status=types.CalibrationStatus(**calibration_data.status.model_dump()),
             belt_attitude=calibration_data.attitude,
             last_modified=calibration_data.lastModified,
             pipette_calibrated_with=calibration_data.pipetteCalibratedWith,