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

opentrons/protocol_engine/commands/robot/move_axes_to.py

@@ -0,0 +1,100 @@
+"""Command models for moving any robot axis to an absolute position."""
+from __future__ import annotations
+from typing import Literal, Optional, Type, TYPE_CHECKING, Any
+
+from pydantic import Field, BaseModel
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.protocol_engine.resources import ensure_ot3_hardware
+
+from .common import MotorAxisMapType, DestinationRobotPositionResult
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from ...errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.execution import GantryMover
+
+
+MoveAxesToCommandType = Literal["robot/moveAxesTo"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class MoveAxesToParams(BaseModel):
+    """Payload required to move axes to absolute position."""
+
+    axis_map: MotorAxisMapType = Field(
+        ..., description="The specified axes to move to an absolute deck position with."
+    )
+    critical_point: MotorAxisMapType | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The critical point to move the mount with.",
+        json_schema_extra=_remove_default,
+    )
+    speed: float | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The max velocity to move the axes at. Will fall to hardware defaults if none provided.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class MoveAxesToResult(DestinationRobotPositionResult):
+    """Result data from the execution of a MoveAxesTo command."""
+
+    pass
+
+
+class MoveAxesToImplementation(
+    AbstractCommandImpl[MoveAxesToParams, SuccessData[MoveAxesToResult]]
+):
+    """MoveAxesTo command implementation."""
+
+    def __init__(
+        self,
+        gantry_mover: GantryMover,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._gantry_mover = gantry_mover
+        self._hardware_api = hardware_api
+
+    async def execute(self, params: MoveAxesToParams) -> SuccessData[MoveAxesToResult]:
+        """Move the axes on a flex an absolute distance."""
+        # TODO (lc 08-16-2024) implement `move_axes` for OT 2 hardware controller
+        # and then we can remove this validation.
+        ensure_ot3_hardware(self._hardware_api)
+        current_position = await self._gantry_mover.move_axes(
+            axis_map=params.axis_map,
+            speed=params.speed,
+            critical_point=params.critical_point,
+        )
+        return SuccessData(
+            public=MoveAxesToResult(position=current_position),
+        )
+
+
+class MoveAxesTo(BaseCommand[MoveAxesToParams, MoveAxesToResult, ErrorOccurrence]):
+    """MoveAxesTo command model."""
+
+    commandType: MoveAxesToCommandType = "robot/moveAxesTo"
+    params: MoveAxesToParams
+    result: Optional[MoveAxesToResult]
+
+    _ImplementationCls: Type[MoveAxesToImplementation] = MoveAxesToImplementation
+
+
+class MoveAxesToCreate(BaseCommandCreate[MoveAxesToParams]):
+    """MoveAxesTo command request model."""
+
+    commandType: MoveAxesToCommandType = "robot/moveAxesTo"
+    params: MoveAxesToParams
+
+    _CommandCls: Type[MoveAxesTo] = MoveAxesTo

opentrons/protocol_engine/commands/robot/move_to.py

@@ -0,0 +1,94 @@
+"""Command models for moving any robot mount to a destination point."""
+from __future__ import annotations
+from typing import Literal, Type, Optional, TYPE_CHECKING, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+
+from opentrons.types import MountType
+
+from ..movement_common import DestinationPositionResult
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from opentrons.protocol_engine.types import DeckPoint
+from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
+
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.execution import MovementHandler
+
+
+MoveToCommandType = Literal["robot/moveTo"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class MoveToParams(BaseModel):
+    """Payload required to move to a destination position."""
+
+    mount: MountType = Field(
+        ...,
+        description="The mount to move to the destination point.",
+    )
+    destination: DeckPoint = Field(
+        ...,
+        description="X, Y and Z coordinates in mm from deck's origin location (left-front-bottom corner of work space)",
+    )
+    speed: float | SkipJsonSchema[None] = Field(
+        default=None,
+        description="The max velocity to move the axes at. Will fall to hardware defaults if none provided.",
+        json_schema_extra=_remove_default,
+    )
+
+
+class MoveToResult(DestinationPositionResult):
+    """Result data from the execution of a MoveTo command."""
+
+    pass
+
+
+class MoveToImplementation(
+    AbstractCommandImpl[MoveToParams, SuccessData[MoveToResult]]
+):
+    """MoveTo command implementation."""
+
+    def __init__(
+        self,
+        movement: MovementHandler,
+        **kwargs: object,
+    ) -> None:
+        self._movement = movement
+
+    async def execute(self, params: MoveToParams) -> SuccessData[MoveToResult]:
+        """Move to a given destination on a flex."""
+        x, y, z = await self._movement.move_mount_to(
+            mount=params.mount, destination=params.destination, speed=params.speed
+        )
+        return SuccessData(
+            public=MoveToResult(position=DeckPoint(x=x, y=y, z=z)),
+        )
+
+
+class MoveTo(BaseCommand[MoveToParams, MoveToResult, ErrorOccurrence]):
+    """MoveTo command model."""
+
+    commandType: MoveToCommandType = "robot/moveTo"
+    params: MoveToParams
+    result: Optional[MoveToResult]
+
+    _ImplementationCls: Type[MoveToImplementation] = MoveToImplementation
+
+
+class MoveToCreate(BaseCommandCreate[MoveToParams]):
+    """MoveTo command request model."""
+
+    commandType: MoveToCommandType = "robot/moveTo"
+    params: MoveToParams
+
+    _CommandCls: Type[MoveTo] = MoveTo

opentrons/protocol_engine/commands/robot/open_gripper_jaw.py

@@ -0,0 +1,77 @@
+"""Command models for opening a gripper jaw."""
+from __future__ import annotations
+from typing import Literal, Type, Optional
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.protocol_engine.resources import ensure_ot3_hardware
+
+from pydantic import BaseModel
+
+from ..command import (
+    AbstractCommandImpl,
+    BaseCommand,
+    BaseCommandCreate,
+    SuccessData,
+)
+from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
+
+
+openGripperJawCommandType = Literal["robot/openGripperJaw"]
+
+
+class openGripperJawParams(BaseModel):
+    """Payload required to release a gripper."""
+
+    pass
+
+
+class openGripperJawResult(BaseModel):
+    """Result data from the execution of a openGripperJaw command."""
+
+    pass
+
+
+class openGripperJawImplementation(
+    AbstractCommandImpl[openGripperJawParams, SuccessData[openGripperJawResult]]
+):
+    """openGripperJaw command implementation."""
+
+    def __init__(
+        self,
+        hardware_api: HardwareControlAPI,
+        **kwargs: object,
+    ) -> None:
+        self._hardware_api = hardware_api
+
+    async def execute(
+        self, params: openGripperJawParams
+    ) -> SuccessData[openGripperJawResult]:
+        """Release the gripper."""
+        ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
+
+        await ot3_hardware_api.home_gripper_jaw()
+        return SuccessData(
+            public=openGripperJawResult(),
+        )
+
+
+class openGripperJaw(
+    BaseCommand[openGripperJawParams, openGripperJawResult, ErrorOccurrence]
+):
+    """openGripperJaw command model."""
+
+    commandType: openGripperJawCommandType = "robot/openGripperJaw"
+    params: openGripperJawParams
+    result: Optional[openGripperJawResult]
+
+    _ImplementationCls: Type[
+        openGripperJawImplementation
+    ] = openGripperJawImplementation
+
+
+class openGripperJawCreate(BaseCommandCreate[openGripperJawParams]):
+    """openGripperJaw command request model."""
+
+    commandType: openGripperJawCommandType = "robot/openGripperJaw"
+    params: openGripperJawParams
+
+    _CommandCls: Type[openGripperJaw] = openGripperJaw

opentrons/protocol_engine/commands/save_position.py

@@ -1,8 +1,10 @@
 """Save pipette position command request, result, and implementation models."""
 
 from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
 from pydantic import BaseModel, Field
-from typing import TYPE_CHECKING, Optional, Type
+from pydantic.json_schema import SkipJsonSchema
 from typing_extensions import Literal
 
 from ..types import DeckPoint
@@ -16,19 +18,26 @@ if TYPE_CHECKING:
 SavePositionCommandType = Literal["savePosition"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class SavePositionParams(BaseModel):
     """Payload needed to save a pipette's current position."""
 
     pipetteId: str = Field(
         ..., description="Unique identifier of the pipette in question."
     )
-    positionId: Optional[str] = Field(
+    positionId: str | SkipJsonSchema[None] = Field(
         None,
         description="An optional ID to assign to this command instance. "
         "Auto-assigned if not defined.",
+        json_schema_extra=_remove_default,
     )
-    failOnNotHomed: Optional[bool] = Field(
-        True, descrption="Require all axes to be homed before saving position."
+    failOnNotHomed: bool | SkipJsonSchema[None] = Field(
+        True,
+        description="Require all axes to be homed before saving position.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -86,7 +95,7 @@ class SavePosition(
 
     commandType: SavePositionCommandType = "savePosition"
     params: SavePositionParams
-    result: Optional[SavePositionResult]
+    result: Optional[SavePositionResult] = None
 
     _ImplementationCls: Type[SavePositionImplementation] = SavePositionImplementation
 

opentrons/protocol_engine/commands/set_rail_lights.py

@@ -53,7 +53,7 @@ class SetRailLights(
 
     commandType: SetRailLightsCommandType = "setRailLights"
     params: SetRailLightsParams
-    result: Optional[SetRailLightsResult]
+    result: Optional[SetRailLightsResult] = None
 
     _ImplementationCls: Type[SetRailLightsImplementation] = SetRailLightsImplementation
 

opentrons/protocol_engine/commands/set_status_bar.py

@@ -75,7 +75,7 @@ class SetStatusBar(
 
     commandType: SetStatusBarCommandType = "setStatusBar"
     params: SetStatusBarParams
-    result: Optional[SetStatusBarResult]
+    result: Optional[SetStatusBarResult] = None
 
     _ImplementationCls: Type[SetStatusBarImplementation] = SetStatusBarImplementation
 

opentrons/protocol_engine/commands/temperature_module/deactivate.py

@@ -72,7 +72,7 @@ class DeactivateTemperature(
     commandType: DeactivateTemperatureCommandType = "temperatureModule/deactivate"
 
     params: DeactivateTemperatureParams
-    result: Optional[DeactivateTemperatureResult]
+    result: Optional[DeactivateTemperatureResult] = None
 
     _ImplementationCls: Type[DeactivateTemperatureImpl] = DeactivateTemperatureImpl
 

opentrons/protocol_engine/commands/temperature_module/set_target_temperature.py

@@ -81,7 +81,7 @@ class SetTargetTemperature(
         "temperatureModule/setTargetTemperature"
     )
     params: SetTargetTemperatureParams
-    result: Optional[SetTargetTemperatureResult]
+    result: Optional[SetTargetTemperatureResult] = None
 
     _ImplementationCls: Type[SetTargetTemperatureImpl] = SetTargetTemperatureImpl
 

opentrons/protocol_engine/commands/temperature_module/wait_for_temperature.py

@@ -1,9 +1,10 @@
 """Command models to wait for target temperature of a Temperature Module."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
-from typing_extensions import Literal, Type
+from typing import Optional, TYPE_CHECKING, Any
 
+from typing_extensions import Literal, Type
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
@@ -15,11 +16,15 @@ if TYPE_CHECKING:
 WaitForTemperatureCommandType = Literal["temperatureModule/waitForTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class WaitForTemperatureParams(BaseModel):
     """Input parameters to wait for a Temperature Module's target temperature."""
 
     moduleId: str = Field(..., description="Unique ID of the Temperature Module.")
-    celsius: Optional[float] = Field(
+    celsius: float | SkipJsonSchema[None] = Field(
         None,
         description="Target temperature in °C. If not specified, will "
         "default to the module's target temperature. "
@@ -27,6 +32,7 @@ class WaitForTemperatureParams(BaseModel):
         "could lead to unpredictable behavior and hence is not "
         "recommended for use. This parameter can be removed in a "
         "future version without prior notice.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -84,7 +90,7 @@ class WaitForTemperature(
 
     commandType: WaitForTemperatureCommandType = "temperatureModule/waitForTemperature"
     params: WaitForTemperatureParams
-    result: Optional[WaitForTemperatureResult]
+    result: Optional[WaitForTemperatureResult] = None
 
     _ImplementationCls: Type[WaitForTemperatureImpl] = WaitForTemperatureImpl
 

opentrons/protocol_engine/commands/thermocycler/close_lid.py

@@ -73,7 +73,7 @@ class CloseLid(BaseCommand[CloseLidParams, CloseLidResult, ErrorOccurrence]):
 
     commandType: CloseLidCommandType = "thermocycler/closeLid"
     params: CloseLidParams
-    result: Optional[CloseLidResult]
+    result: Optional[CloseLidResult] = None
 
     _ImplementationCls: Type[CloseLidImpl] = CloseLidImpl
 

opentrons/protocol_engine/commands/thermocycler/deactivate_block.py

@@ -66,7 +66,7 @@ class DeactivateBlock(
 
     commandType: DeactivateBlockCommandType = "thermocycler/deactivateBlock"
     params: DeactivateBlockParams
-    result: Optional[DeactivateBlockResult]
+    result: Optional[DeactivateBlockResult] = None
 
     _ImplementationCls: Type[DeactivateBlockImpl] = DeactivateBlockImpl
 

opentrons/protocol_engine/commands/thermocycler/deactivate_lid.py

@@ -66,7 +66,7 @@ class DeactivateLid(
 
     commandType: DeactivateLidCommandType = "thermocycler/deactivateLid"
     params: DeactivateLidParams
-    result: Optional[DeactivateLidResult]
+    result: Optional[DeactivateLidResult] = None
 
     _ImplementationCls: Type[DeactivateLidImpl] = DeactivateLidImpl
 

opentrons/protocol_engine/commands/thermocycler/open_lid.py

@@ -73,7 +73,7 @@ class OpenLid(BaseCommand[OpenLidParams, OpenLidResult, ErrorOccurrence]):
 
     commandType: OpenLidCommandType = "thermocycler/openLid"
     params: OpenLidParams
-    result: Optional[OpenLidResult]
+    result: Optional[OpenLidResult] = None
 
     _ImplementationCls: Type[OpenLidImpl] = OpenLidImpl
 

opentrons/protocol_engine/commands/thermocycler/run_extended_profile.py

@@ -1,9 +1,10 @@
 """Command models to execute a Thermocycler profile."""
 from __future__ import annotations
-from typing import List, Optional, TYPE_CHECKING, overload, Union
+from typing import List, Optional, TYPE_CHECKING, overload, Union, Any
 from typing_extensions import Literal, Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.hardware_control.modules.types import ThermocyclerStep, ThermocyclerCycle
 
@@ -21,6 +22,10 @@ if TYPE_CHECKING:
 RunExtendedProfileCommandType = Literal["thermocycler/runExtendedProfile"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class ProfileStep(BaseModel):
     """An individual step in a Thermocycler extended profile."""
 
@@ -45,10 +50,11 @@ class RunExtendedProfileParams(BaseModel):
         ...,
         description="Elements of the profile. Each can be either a step or a cycle.",
     )
-    blockMaxVolumeUl: Optional[float] = Field(
+    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
         None,
         description="Amount of liquid in uL of the most-full well"
         " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
     )
 
 

opentrons/protocol_engine/commands/thermocycler/run_profile.py

@@ -1,9 +1,10 @@
 """Command models to execute a Thermocycler profile."""
 from __future__ import annotations
-from typing import List, Optional, TYPE_CHECKING
+from typing import List, Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from opentrons.hardware_control.modules.types import ThermocyclerStep
 
@@ -18,6 +19,10 @@ if TYPE_CHECKING:
 RunProfileCommandType = Literal["thermocycler/runProfile"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class RunProfileStepParams(BaseModel):
     """Input parameters for an individual Thermocycler profile step."""
 
@@ -35,10 +40,11 @@ class RunProfileParams(BaseModel):
         ...,
         description="Array of profile steps with target temperature and temperature hold time.",
     )
-    blockMaxVolumeUl: Optional[float] = Field(
+    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
         None,
         description="Amount of liquid in uL of the most-full well"
         " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -104,7 +110,7 @@ class RunProfile(BaseCommand[RunProfileParams, RunProfileResult, ErrorOccurrence
 
     commandType: RunProfileCommandType = "thermocycler/runProfile"
     params: RunProfileParams
-    result: Optional[RunProfileResult]
+    result: Optional[RunProfileResult] = None
 
     _ImplementationCls: Type[RunProfileImpl] = RunProfileImpl
 

opentrons/protocol_engine/commands/thermocycler/set_target_block_temperature.py

@@ -1,9 +1,10 @@
 """Command models to start heating a Thermocycler's block."""
 from __future__ import annotations
-from typing import Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING, Any
 from typing_extensions import Literal, Type
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
 from ..command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
 from ...errors.error_occurrence import ErrorOccurrence
@@ -16,21 +17,27 @@ if TYPE_CHECKING:
 SetTargetBlockTemperatureCommandType = Literal["thermocycler/setTargetBlockTemperature"]
 
 
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
 class SetTargetBlockTemperatureParams(BaseModel):
     """Input parameters to set a Thermocycler's target block temperature."""
 
     moduleId: str = Field(..., description="Unique ID of the Thermocycler Module.")
     celsius: float = Field(..., description="Target temperature in °C.")
-    blockMaxVolumeUl: Optional[float] = Field(
+    blockMaxVolumeUl: float | SkipJsonSchema[None] = Field(
         None,
         description="Amount of liquid in uL of the most-full well"
         " in labware loaded onto the thermocycler.",
+        json_schema_extra=_remove_default,
     )
-    holdTimeSeconds: Optional[float] = Field(
+    holdTimeSeconds: float | SkipJsonSchema[None] = Field(
         None,
         description="Amount of time, in seconds, to hold the temperature for."
         " If specified, a waitForBlockTemperature command will block until"
         " the given hold time has elapsed.",
+        json_schema_extra=_remove_default,
     )
 
 
@@ -113,7 +120,7 @@ class SetTargetBlockTemperature(
         "thermocycler/setTargetBlockTemperature"
     )
     params: SetTargetBlockTemperatureParams
-    result: Optional[SetTargetBlockTemperatureResult]
+    result: Optional[SetTargetBlockTemperatureResult] = None
 
     _ImplementationCls: Type[
         SetTargetBlockTemperatureImpl

opentrons/protocol_engine/commands/thermocycler/set_target_lid_temperature.py

@@ -84,7 +84,7 @@ class SetTargetLidTemperature(
         "thermocycler/setTargetLidTemperature"
     )
     params: SetTargetLidTemperatureParams
-    result: Optional[SetTargetLidTemperatureResult]
+    result: Optional[SetTargetLidTemperatureResult] = None
 
     _ImplementationCls: Type[SetTargetLidTemperatureImpl] = SetTargetLidTemperatureImpl
 

opentrons/protocol_engine/commands/thermocycler/wait_for_block_temperature.py

@@ -77,7 +77,7 @@ class WaitForBlockTemperature(
         "thermocycler/waitForBlockTemperature"
     )
     params: WaitForBlockTemperatureParams
-    result: Optional[WaitForBlockTemperatureResult]
+    result: Optional[WaitForBlockTemperatureResult] = None
 
     _ImplementationCls: Type[WaitForBlockTemperatureImpl] = WaitForBlockTemperatureImpl
 

opentrons/protocol_engine/commands/thermocycler/wait_for_lid_temperature.py

@@ -75,7 +75,7 @@ class WaitForLidTemperature(
 
     commandType: WaitForLidTemperatureCommandType = "thermocycler/waitForLidTemperature"
     params: WaitForLidTemperatureParams
-    result: Optional[WaitForLidTemperatureResult]
+    result: Optional[WaitForLidTemperatureResult] = None
 
     _ImplementationCls: Type[WaitForLidTemperatureImpl] = WaitForLidTemperatureImpl