opentrons 8.4.1a1__py2.py3-none-any.whl → 8.5.0__py2.py3-none-any.whl

opentrons/protocol_api/labware.py

@@ -346,6 +346,16 @@ class Well:
         """Get the current liquid volume in a well."""
         return self._core.get_liquid_volume()
 
+    @requires_version(2, 24)
+    def volume_from_height(self, height: LiquidTrackingType) -> LiquidTrackingType:
+        """Return the volume contained in a well at any height."""
+        return self._core.volume_from_height(height)
+
+    @requires_version(2, 24)
+    def height_from_volume(self, volume: LiquidTrackingType) -> LiquidTrackingType:
+        """Return the height in a well corresponding to a given volume."""
+        return self._core.height_from_volume(volume)
+
     @requires_version(2, 21)
     def estimate_liquid_height_after_pipetting(
         self,

opentrons/protocol_api/module_contexts.py

@@ -177,7 +177,7 @@ class ModuleContext(CommandPublisher):
 
         labware_core = self._protocol_core.load_labware(
             load_name=name,
-            label=label,
+            label=label if label is None else str(label),
             namespace=namespace,
             version=version,
             location=load_location,
@@ -246,7 +246,10 @@ class ModuleContext(CommandPublisher):
         """
         _log.warning("load_labware_by_name is deprecated. Use load_labware instead.")
         return self.load_labware(
-            name=name, label=label, namespace=namespace, version=version
+            name=name,
+            label=label,
+            namespace=namespace,
+            version=version,
         )
 
     @requires_version(2, 15)

opentrons/protocol_api/protocol_context.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from copy import deepcopy
 from typing import (
     Callable,
     Dict,
@@ -13,6 +14,11 @@ from typing import (
 )
 
 from opentrons_shared_data.labware.types import LabwareDefinition
+from opentrons_shared_data.liquid_classes.liquid_class_definition import (
+    TransferProperties as SharedTransferProperties,
+)
+from opentrons_shared_data.liquid_classes import DEFAULT_LC_VERSION, definition_exists
+from opentrons_shared_data.liquid_classes.types import TransferPropertiesDict
 from opentrons_shared_data.pipette.types import PipetteNameType
 
 from opentrons.types import Mount, Location, DeckLocation, DeckSlotName, StagingSlotName
@@ -48,6 +54,7 @@ from opentrons.protocols.api_support.util import (
 )
 from opentrons_shared_data.errors.exceptions import CommandPreconditionViolated
 from opentrons.protocol_engine.errors import LabwareMovementNotAllowedError
+from ._liquid_properties import build_transfer_properties
 
 from ._types import OffDeckType
 from .core.common import ModuleCore, LabwareCore, ProtocolCore
@@ -196,6 +203,7 @@ class ProtocolContext(CommandPublisher):
                 core=self._core.load_robot(),
                 protocol_core=self._core,
                 api_version=self._api_version,
+                broker=broker,
             )
         except APIVersionError:
             self._robot = None
@@ -491,7 +499,7 @@ class ProtocolContext(CommandPublisher):
         labware_core = self._core.load_labware(
             load_name=load_name,
             location=load_location,
-            label=label,
+            label=label if label is None else str(label),
             namespace=namespace,
             version=version,
         )
@@ -1189,9 +1197,16 @@ class ProtocolContext(CommandPublisher):
         self._core.home()
 
     @property
-    def location_cache(self) -> Optional[Location]:
-        """The cache used by the robot to determine where it last was."""
-        return self._core.get_last_location()
+    def location_cache(self) -> Optional[Union[Location, TrashBin, WasteChute]]:
+        """The cache used by the robot to determine where it last was.
+
+        .. versionchanged:: 2.24
+           Can return a ``TrashBin`` or ``WasteChute`` object.
+        """
+        last_loc = self._core.get_last_location()
+        if isinstance(last_loc, Location) or self._api_version >= APIVersion(2, 24):
+            return last_loc
+        return None
 
     @location_cache.setter
     def location_cache(self, loc: Optional[Location]) -> None:
@@ -1356,19 +1371,69 @@ class ProtocolContext(CommandPublisher):
             display_color=display_color,
         )
 
-    @requires_version(2, 23)
-    def define_liquid_class(
+    @requires_version(2, 24)
+    def get_liquid_class(
         self,
         name: str,
     ) -> LiquidClass:
         """
-        Define a liquid class for use in the protocol.
-        ..
-            This is intended for Opentrons internal use only and is not a guaranteed API.
+        Get an instance of an Opentrons-verified liquid class for use in a Flex protocol.
 
-        :meta private:
+        :param name: Name of an Opentrons-verified liquid class. Must be one of:
+
+            - ``"water"``: an Opentrons-verified liquid class based on deionized water.
+            - ``"glycerol_50"``: an Opentrons-verified liquid class for viscous liquid. Based on 50% glycerol.
+            - ``"ethanol_80"``: an Opentrons-verified liquid class for volatile liquid. Based on 80% ethanol.
+
+        :raises: ``LiquidClassDefinitionDoesNotExist``: if the specified liquid class does not exist.
         """
-        return self._core.define_liquid_class(name=name)
+        return self._core.get_liquid_class(name=name, version=DEFAULT_LC_VERSION)
+
+    @requires_version(2, 24)
+    def define_liquid_class(
+        self,
+        name: str,
+        properties: Dict[str, Dict[str, TransferPropertiesDict]],
+        base_liquid_class: Optional[LiquidClass] = None,
+        display_name: Optional[str] = None,
+    ) -> LiquidClass:
+        """Define a custom liquid class, either based on an existing, Opentrons-verified liquid class, or to create a completely new one.
+
+        :param name: The name to give to the new liquid class. Cannot use the name of an Opentrons-verified liquid class.
+        :param properties: A dict of transfer properties for the Flex pipette and tips to use for liquid class transfers. The nested dictionary must have top-level keys corresponding to pipette load names and second-level keys corresponding to compatible tip rack load names. Further nested key–value pairs should be in the format returned by :py:meth:`.LiquidClass.get_for`. See also the `liquid class JSON schema <https://github.com/Opentrons/opentrons/tree/edge/shared-data/liquid-class/schemas>`_.
+
+        :param base_liquid_class: An Opentrons-verified liquid class to base the newly defined liquid class on. The specified ``transfer_properties`` will override any existing properties for the Flex pipette and tips. All other properties will remain the same as those in the base class.
+
+        :param display_name: An optional name for the liquid class. Defaults to the title-case ``name`` if a display name isn't provided.
+
+        """
+        if definition_exists(name, DEFAULT_LC_VERSION):
+            raise ValueError(
+                f"Liquid class named {name} already exists. Please specify a different name."
+            )
+        new_liquid_class: LiquidClass
+        if base_liquid_class:
+            # If base liquid is provided, copy to new class
+            # and replace the entries mentioned in transfer props arg
+            new_liquid_class = deepcopy(base_liquid_class)
+        else:
+            new_liquid_class = LiquidClass.create_from(
+                name=name,
+                display_name=display_name or name.title(),
+                by_pipette_setting={},
+            )
+        for pipette, by_tiprack_props in properties.items():
+            for tiprack, transfer_props in by_tiprack_props.items():
+                new_liquid_class.update_for(
+                    pipette=pipette,
+                    tip_rack=tiprack,
+                    transfer_properties=build_transfer_properties(
+                        transfer_properties=SharedTransferProperties.model_validate(
+                            transfer_props
+                        )
+                    ),
+                )
+        return new_liquid_class
 
     @property
     @requires_version(2, 5)

opentrons/protocol_api/robot_context.py

@@ -9,6 +9,8 @@ from opentrons.types import (
     AxisType,
     StringAxisMap,
 )
+from opentrons.legacy_broker import LegacyBroker
+from opentrons.legacy_commands import robot_commands as cmds
 from opentrons.legacy_commands import publisher
 from opentrons.hardware_control import SyncHardwareAPI
 from opentrons.protocols.api_support.util import requires_version
@@ -49,8 +51,13 @@ class RobotContext(publisher.CommandPublisher):
     """
 
     def __init__(
-        self, core: RobotCore, protocol_core: ProtocolCore, api_version: APIVersion
+        self,
+        core: RobotCore,
+        protocol_core: ProtocolCore,
+        api_version: APIVersion,
+        broker: Optional[LegacyBroker] = None,
     ) -> None:
+        super().__init__(broker)
         self._hardware = HardwareManager(hardware=protocol_core.get_hardware())
         self._core = core
         self._protocol_core = protocol_core
@@ -87,7 +94,16 @@ class RobotContext(publisher.CommandPublisher):
         :param speed:
         """
         mount = validation.ensure_instrument_mount(mount)
-        self._core.move_to(mount, destination.point, speed)
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.move_to(
+                # This needs to be called from protocol context and not the command for import loop reasons
+                mount=mount,
+                location=destination,
+                speed=speed,
+            ),
+        ):
+            self._core.move_to(mount, destination.point, speed)
 
     @requires_version(2, 22)
     def move_axes_to(
@@ -119,7 +135,15 @@ class RobotContext(publisher.CommandPublisher):
             )
         else:
             critical_point = None
-        self._core.move_axes_to(axis_map, critical_point, speed)
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.move_axis_to(
+                # This needs to be called from protocol context and not the command for import loop reasons
+                axis_map=axis_map,
+                speed=speed,
+            ),
+        ):
+            self._core.move_axes_to(axis_map, critical_point, speed)
 
     @requires_version(2, 22)
     def move_axes_relative(
@@ -142,15 +166,33 @@ class RobotContext(publisher.CommandPublisher):
         axis_map = validation.ensure_axis_map_type(
             axis_map, self._protocol_core.robot_type, is_96_channel
         )
-        self._core.move_axes_relative(axis_map, speed)
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.move_axis_relative(
+                # This needs to be called from protocol context and not the command for import loop reasons
+                axis_map=axis_map,
+                speed=speed,
+            ),
+        ):
+            self._core.move_axes_relative(axis_map, speed)
 
     def close_gripper_jaw(self, force: Optional[float] = None) -> None:
         """Command the gripper closed with some force."""
-        self._core.close_gripper(force)
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.close_gripper(
+                force=force,
+            ),
+        ):
+            self._core.close_gripper(force)
 
     def open_gripper_jaw(self) -> None:
         """Command the gripper open."""
-        self._core.release_grip()
+        with publisher.publish_context(
+            broker=self.broker,
+            command=cmds.open_gripper(),
+        ):
+            self._core.release_grip()
 
     def axis_coordinates_for(
         self,

opentrons/protocol_api/validation.py

@@ -545,6 +545,11 @@ class PointTarget(NamedTuple):
     in_place: bool
 
 
+class DisposalTarget(NamedTuple):
+    location: Union[TrashBin, WasteChute]
+    in_place: bool
+
+
 class NoLocationError(ValueError):
     """Error representing that no location was supplied."""
 
@@ -553,12 +558,12 @@ class LocationTypeError(TypeError):
     """Error representing that the location supplied is of different expected type."""
 
 
-ValidTarget = Union[WellTarget, PointTarget, TrashBin, WasteChute]
+ValidTarget = Union[WellTarget, PointTarget, DisposalTarget]
 
 
 def validate_location(
-    location: Union[Location, Well, TrashBin, WasteChute, None],
-    last_location: Optional[Location],
+    location: Optional[Union[Location, Well, TrashBin, WasteChute]],
+    last_location: Optional[Union[Location, TrashBin, WasteChute]],
 ) -> ValidTarget:
     """Validate a given location for a liquid handling command.
 
@@ -569,9 +574,11 @@ def validate_location(
     Returns:
         A `WellTarget` if the input location represents a well.
         A `PointTarget` if the input location is an x, y, z coordinate.
+        A `TrashBin` if the input location is a trash bin
+        A `WasteChute` if the input location is a waste chute
 
     Raises:
-        NoLocationError: The is no input location and no cached loaction.
+        NoLocationError: There is no input location and no cached location.
         LocationTypeError: The location supplied is of unexpected type.
     """
     from .labware import Well
@@ -586,11 +593,11 @@ def validate_location(
             f"location should be a Well, Location, TrashBin or WasteChute, but it is {location}"
         )
 
-    if isinstance(target_location, (TrashBin, WasteChute)):
-        return target_location
-
     in_place = target_location == last_location
 
+    if isinstance(target_location, (TrashBin, WasteChute)):
+        return DisposalTarget(location=target_location, in_place=in_place)
+
     if isinstance(target_location, Well):
         return WellTarget(well=target_location, location=None, in_place=in_place)
 
@@ -662,7 +669,7 @@ def ensure_new_tip_policy(value: str) -> TransferTipPolicyV2:
     except ValueError:
         raise ValueError(
             f"'{value}' is invalid value for 'new_tip'."
-            f" Acceptable value is either 'never', 'once', 'always' or 'per source'."
+            f" Acceptable value is either 'never', 'once', 'always', 'per source' or 'per destination'."
         )
 
 

opentrons/protocol_engine/commands/command_unions.py

@@ -498,8 +498,8 @@ Command = Annotated[
         robot.MoveTo,
         robot.MoveAxesRelative,
         robot.MoveAxesTo,
-        robot.openGripperJaw,
-        robot.closeGripperJaw,
+        robot.OpenGripperJaw,
+        robot.CloseGripperJaw,
     ],
     Field(discriminator="commandType"),
 ]
@@ -599,8 +599,8 @@ CommandParams = Union[
     robot.MoveAxesRelativeParams,
     robot.MoveAxesToParams,
     robot.MoveToParams,
-    robot.openGripperJawParams,
-    robot.closeGripperJawParams,
+    robot.OpenGripperJawParams,
+    robot.CloseGripperJawParams,
 ]
 
 CommandType = Union[
@@ -698,8 +698,8 @@ CommandType = Union[
     robot.MoveAxesRelativeCommandType,
     robot.MoveAxesToCommandType,
     robot.MoveToCommandType,
-    robot.openGripperJawCommandType,
-    robot.closeGripperJawCommandType,
+    robot.OpenGripperJawCommandType,
+    robot.CloseGripperJawCommandType,
 ]
 
 CommandCreate = Annotated[
@@ -798,8 +798,8 @@ CommandCreate = Annotated[
         robot.MoveAxesRelativeCreate,
         robot.MoveAxesToCreate,
         robot.MoveToCreate,
-        robot.openGripperJawCreate,
-        robot.closeGripperJawCreate,
+        robot.OpenGripperJawCreate,
+        robot.CloseGripperJawCreate,
     ],
     Field(discriminator="commandType"),
 ]
@@ -906,8 +906,8 @@ CommandResult = Union[
     robot.MoveAxesRelativeResult,
     robot.MoveAxesToResult,
     robot.MoveToResult,
-    robot.openGripperJawResult,
-    robot.closeGripperJawResult,
+    robot.OpenGripperJawResult,
+    robot.CloseGripperJawResult,
 ]
 
 

opentrons/protocol_engine/commands/generate_command_schema.py

@@ -11,7 +11,7 @@ from opentrons_shared_data.load import get_shared_data_root
 
 def generate_command_schema(version: str) -> str:
     """Generate a JSON Schema that all valid create commands can validate against."""
-    schema_as_dict = CommandCreateAdapter.json_schema(mode="validation")
+    schema_as_dict = CommandCreateAdapter.json_schema(mode="validation", by_alias=False)
     schema_as_dict["$id"] = f"opentronsCommandSchemaV{version}"
     schema_as_dict["$schema"] = "http://json-schema.org/draft-07/schema#"
     return json.dumps(schema_as_dict, indent=2, sort_keys=True)

opentrons/protocol_engine/commands/get_next_tip.py

@@ -73,8 +73,8 @@ class GetNextTipImplementation(
         pipette_id = params.pipetteId
         starting_tip_name = params.startingTipWell
 
-        num_tips = self._state_view.tips.get_pipette_active_channels(pipette_id)
-        nozzle_map = self._state_view.tips.get_pipette_nozzle_map(pipette_id)
+        num_tips = self._state_view.pipettes.get_active_channels(pipette_id)
+        nozzle_map = self._state_view.pipettes.get_nozzle_configuration(pipette_id)
 
         if (
             starting_tip_name is not None

opentrons/protocol_engine/commands/load_labware.py

@@ -165,25 +165,6 @@ class LoadLabwareImplementation(
                 top_labware_definition=loaded_labware.definition,
                 bottom_labware_id=verified_location.labwareId,
             )
-            # Validate load location is valid for lids
-            if labware_validation.validate_definition_is_lid(
-                definition=loaded_labware.definition
-            ):
-                # This parent is assumed to be compatible, unless the lid enumerates
-                # all its compatible parents and this parent is missing from the list.
-                parent_is_incompatible = (
-                    loaded_labware.definition.compatibleParentLabware is not None
-                    and self._state_view.labware.get_load_name(
-                        verified_location.labwareId
-                    )
-                    not in loaded_labware.definition.compatibleParentLabware
-                )
-
-                if parent_is_incompatible:
-                    raise ValueError(
-                        f"Labware Lid {params.loadName} may not be loaded on parent labware"
-                        f" {self._state_view.labware.get_display_name(verified_location.labwareId)}."
-                    )
 
         # Validate labware for the absorbance reader
         if self._is_loading_to_module(

opentrons/protocol_engine/commands/pick_up_tip.py

@@ -121,6 +121,12 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
         labware_id = params.labwareId
         well_name = params.wellName
 
+        tips_to_mark_as_used = self._state_view.tips.compute_tips_to_mark_as_used(
+            labware_id=labware_id,
+            well_name=well_name,
+            nozzle_map=self._state_view.pipettes.get_nozzle_configuration(pipette_id),
+        )
+
         well_location = self._state_view.geometry.convert_pick_up_tip_well_location(
             well_location=params.wellLocation
         )
@@ -152,7 +158,7 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
                 .mark_tips_as_used(
-                    pipette_id=pipette_id, labware_id=labware_id, well_name=well_name
+                    labware_id=labware_id, well_names=tips_to_mark_as_used
                 )
             )
             state_update = (
@@ -160,7 +166,7 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                     update_types.StateUpdate(), move_result.state_update
                 )
                 .mark_tips_as_used(
-                    pipette_id=pipette_id, labware_id=labware_id, well_name=well_name
+                    labware_id=labware_id, well_names=tips_to_mark_as_used
                 )
                 .set_fluid_unknown(pipette_id=pipette_id)
             )
@@ -186,7 +192,7 @@ class PickUpTipImplementation(AbstractCommandImpl[PickUpTipParams, _ExecuteRetur
                     tip_geometry=tip_geometry,
                 )
                 .mark_tips_as_used(
-                    pipette_id=pipette_id, labware_id=labware_id, well_name=well_name
+                    labware_id=labware_id, well_names=tips_to_mark_as_used
                 )
                 .set_fluid_empty(pipette_id=pipette_id, clean_tip=True)
                 .set_pipette_ready_to_aspirate(

opentrons/protocol_engine/commands/robot/__init__.py

@@ -22,18 +22,18 @@ from .move_axes_relative import (
     MoveAxesRelativeCommandType,
 )
 from .open_gripper_jaw import (
-    openGripperJaw,
-    openGripperJawCreate,
-    openGripperJawParams,
-    openGripperJawResult,
-    openGripperJawCommandType,
+    OpenGripperJaw,
+    OpenGripperJawCreate,
+    OpenGripperJawParams,
+    OpenGripperJawResult,
+    OpenGripperJawCommandType,
 )
 from .close_gripper_jaw import (
-    closeGripperJaw,
-    closeGripperJawCreate,
-    closeGripperJawParams,
-    closeGripperJawResult,
-    closeGripperJawCommandType,
+    CloseGripperJaw,
+    CloseGripperJawCreate,
+    CloseGripperJawParams,
+    CloseGripperJawResult,
+    CloseGripperJawCommandType,
 )
 
 __all__ = [
@@ -56,15 +56,15 @@ __all__ = [
     "MoveAxesRelativeResult",
     "MoveAxesRelativeCommandType",
     # robot/openGripperJaw
-    "openGripperJaw",
-    "openGripperJawCreate",
-    "openGripperJawParams",
-    "openGripperJawResult",
-    "openGripperJawCommandType",
+    "OpenGripperJaw",
+    "OpenGripperJawCreate",
+    "OpenGripperJawParams",
+    "OpenGripperJawResult",
+    "OpenGripperJawCommandType",
     # robot/closeGripperJaw
-    "closeGripperJaw",
-    "closeGripperJawCreate",
-    "closeGripperJawParams",
-    "closeGripperJawResult",
-    "closeGripperJawCommandType",
+    "CloseGripperJaw",
+    "CloseGripperJawCreate",
+    "CloseGripperJawParams",
+    "CloseGripperJawResult",
+    "CloseGripperJawCommandType",
 ]

opentrons/protocol_engine/commands/robot/close_gripper_jaw.py

@@ -1,6 +1,7 @@
 """Command models for opening a gripper jaw."""
+
 from __future__ import annotations
-from typing import Literal, Type, Optional, Any
+from typing import Literal, Type, Optional, Any, TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 from pydantic.json_schema import SkipJsonSchema
@@ -16,15 +17,18 @@ from ..command import (
 )
 from opentrons.protocol_engine.errors.error_occurrence import ErrorOccurrence
 
+if TYPE_CHECKING:
+    from ...state.state import StateView
+
 
-closeGripperJawCommandType = Literal["robot/closeGripperJaw"]
+CloseGripperJawCommandType = Literal["robot/closeGripperJaw"]
 
 
 def _remove_default(s: dict[str, Any]) -> None:
     s.pop("default", None)
 
 
-class closeGripperJawParams(BaseModel):
+class CloseGripperJawParams(BaseModel):
     """Payload required to close a gripper."""
 
     force: float | SkipJsonSchema[None] = Field(
@@ -34,53 +38,59 @@ class closeGripperJawParams(BaseModel):
     )
 
 
-class closeGripperJawResult(BaseModel):
-    """Result data from the execution of a closeGripperJaw command."""
+class CloseGripperJawResult(BaseModel):
+    """Result data from the execution of a CloseGripperJaw command."""
 
     pass
 
 
-class closeGripperJawImplementation(
-    AbstractCommandImpl[closeGripperJawParams, SuccessData[closeGripperJawResult]]
+class CloseGripperJawImplementation(
+    AbstractCommandImpl[CloseGripperJawParams, SuccessData[CloseGripperJawResult]]
 ):
-    """closeGripperJaw command implementation."""
+    """CloseGripperJaw command implementation."""
 
     def __init__(
         self,
         hardware_api: HardwareControlAPI,
+        state_view: StateView,
         **kwargs: object,
     ) -> None:
         self._hardware_api = hardware_api
+        self._state_view = state_view
 
     async def execute(
-        self, params: closeGripperJawParams
-    ) -> SuccessData[closeGripperJawResult]:
+        self, params: CloseGripperJawParams
+    ) -> SuccessData[CloseGripperJawResult]:
         """Release the gripper."""
+        if self._state_view.config.use_virtual_gripper:
+            return SuccessData(
+                public=CloseGripperJawResult(),
+            )
         ot3_hardware_api = ensure_ot3_hardware(self._hardware_api)
         await ot3_hardware_api.grip(force_newtons=params.force)
         return SuccessData(
-            public=closeGripperJawResult(),
+            public=CloseGripperJawResult(),
         )
 
 
-class closeGripperJaw(
-    BaseCommand[closeGripperJawParams, closeGripperJawResult, ErrorOccurrence]
+class CloseGripperJaw(
+    BaseCommand[CloseGripperJawParams, CloseGripperJawResult, ErrorOccurrence]
 ):
-    """closeGripperJaw command model."""
+    """CloseGripperJaw command model."""
 
-    commandType: closeGripperJawCommandType = "robot/closeGripperJaw"
-    params: closeGripperJawParams
-    result: Optional[closeGripperJawResult] = None
+    commandType: CloseGripperJawCommandType = "robot/closeGripperJaw"
+    params: CloseGripperJawParams
+    result: Optional[CloseGripperJawResult] = None
 
     _ImplementationCls: Type[
-        closeGripperJawImplementation
-    ] = closeGripperJawImplementation
+        CloseGripperJawImplementation
+    ] = CloseGripperJawImplementation
 
 
-class closeGripperJawCreate(BaseCommandCreate[closeGripperJawParams]):
-    """closeGripperJaw command request model."""
+class CloseGripperJawCreate(BaseCommandCreate[CloseGripperJawParams]):
+    """CloseGripperJaw command request model."""
 
-    commandType: closeGripperJawCommandType = "robot/closeGripperJaw"
-    params: closeGripperJawParams
+    commandType: CloseGripperJawCommandType = "robot/closeGripperJaw"
+    params: CloseGripperJawParams
 
-    _CommandCls: Type[closeGripperJaw] = closeGripperJaw
+    _CommandCls: Type[CloseGripperJaw] = CloseGripperJaw