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

opentrons/protocol_engine/errors/error_occurrence.py

@@ -4,7 +4,7 @@ from logging import getLogger
 from datetime import datetime
 from textwrap import dedent
 from typing import Any, Dict, Mapping, List, Type, Union, Optional, Sequence
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ConfigDict
 from opentrons_shared_data.errors.codes import ErrorCodes
 from .exceptions import ProtocolEngineError
 from opentrons_shared_data.errors.exceptions import EnumeratedError
@@ -29,7 +29,7 @@ class ErrorOccurrence(BaseModel):
             wrappedErrors = [
                 cls.from_failed(id, createdAt, err) for err in error.wrapping
             ]
-        return cls.construct(
+        return cls.model_construct(
             id=id,
             createdAt=createdAt,
             errorType=type(error).__name__,
@@ -39,6 +39,21 @@ class ErrorOccurrence(BaseModel):
             wrappedErrors=wrappedErrors,
         )
 
+    @staticmethod
+    def schema_extra(schema: Dict[str, Any], model: object) -> None:
+        """Append the schema to make the errorCode appear required.
+
+        `errorCode`, `wrappedErrors`, and `errorInfo` have defaults because they are not included in earlier
+        versions of this model, _and_ this model is loaded directly from
+        the on-robot store. That means that, without a default, it will
+        fail to parse. Once a default is defined, the automated schema will
+        mark this as a non-required field, which is misleading as this is
+        a response from the server to the client and it will always have an
+        errorCode defined. This hack is required because it informs the client
+        that it does not, in fact, have to account for a missing errorCode, wrappedError, or errorInfo.
+        """
+        schema["required"].extend(["errorCode", "wrappedErrors", "errorInfo"])
+
     id: str = Field(..., description="Unique identifier of this error occurrence.")
     createdAt: datetime = Field(..., description="When the error occurred.")
 
@@ -145,23 +160,7 @@ class ErrorOccurrence(BaseModel):
         default=[], description="Errors that may have caused this one."
     )
 
-    class Config:
-        """Customize configuration for this model."""
-
-        @staticmethod
-        def schema_extra(schema: Dict[str, Any], model: object) -> None:
-            """Append the schema to make the errorCode appear required.
-
-            `errorCode`, `wrappedErrors`, and `errorInfo` have defaults because they are not included in earlier
-            versions of this model, _and_ this model is loaded directly from
-            the on-robot store. That means that, without a default, it will
-            fail to parse. Once a default is defined, the automated schema will
-            mark this as a non-required field, which is misleading as this is
-            a response from the server to the client and it will always have an
-            errorCode defined. This hack is required because it informs the client
-            that it does not, in fact, have to account for a missing errorCode, wrappedError, or errorInfo.
-            """
-            schema["required"].extend(["errorCode", "wrappedErrors", "errorInfo"])
+    model_config = ConfigDict(json_schema_extra=schema_extra)
 
 
 # TODO (tz, 7-12-23): move this to exceptions.py when we stop relaying on ErrorOccurrence.
@@ -180,4 +179,4 @@ class ProtocolCommandFailedError(ProtocolEngineError):
         self.original_error = original_error
 
 
-ErrorOccurrence.update_forward_refs()
+ErrorOccurrence.model_rebuild()

opentrons/protocol_engine/errors/exceptions.py

@@ -244,6 +244,19 @@ class LiquidDoesNotExistError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class InvalidLiquidError(ProtocolEngineError):
+    """Raised when attempting to add a liquid with an invalid property."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build an InvalidLiquidError."""
+        super().__init__(ErrorCodes.INVALID_PROTOCOL_DATA, message, details, wrapping)
+
+
 class LabwareDefinitionDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a labware definition that does not exist."""
 
@@ -270,6 +283,19 @@ class LabwareCannotBeStackedError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class LabwareCannotSitOnDeckError(ProtocolEngineError):
+    """Raised when a labware is incompatible with a deck slot."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a LabwareCannotSitOnDeckError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class LabwareIsInStackError(ProtocolEngineError):
     """Raised when trying to move to or physically interact with a labware that has another labware on top."""
 
@@ -348,6 +374,32 @@ class TouchTipDisabledError(ProtocolEngineError):
         super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
 
 
+class TouchTipIncompatibleArgumentsError(ProtocolEngineError):
+    """Raised when touch tip is used with both a custom radius and a mmFromEdge argument."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a TouchTipIncompatibleArgumentsError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
+class UnsupportedLabwareForActionError(ProtocolEngineError):
+    """Raised when trying to use an unsupported labware for a command."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        """Build a UnsupportedLabwareForActionError."""
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
 class WellDoesNotExistError(ProtocolEngineError):
     """Raised when referencing a well that does not exist."""
 
@@ -1155,3 +1207,27 @@ class StorageLimitReachedError(ProtocolEngineError):
     ) -> None:
         """Build an StorageLimitReached."""
         super().__init__(ErrorCodes.GENERAL_ERROR, message, detail, wrapping)
+
+
+class LiquidClassDoesNotExistError(ProtocolEngineError):
+    """Raised when referencing a liquid class that has not been loaded."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)
+
+
+class LiquidClassRedefinitionError(ProtocolEngineError):
+    """Raised when attempting to load a liquid class that conflicts with a liquid class already loaded."""
+
+    def __init__(
+        self,
+        message: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        wrapping: Optional[Sequence[EnumeratedError]] = None,
+    ) -> None:
+        super().__init__(ErrorCodes.GENERAL_ERROR, message, details, wrapping)

opentrons/protocol_engine/execution/command_executor.py

@@ -188,7 +188,7 @@ class CommandExecutor:
                     "completedAt": self._model_utils.get_timestamp(),
                     "notes": note_tracker.get_notes(),
                 }
-                succeeded_command = running_command.copy(update=update)
+                succeeded_command = running_command.model_copy(update=update)
                 self._action_dispatcher.dispatch(
                     SucceedCommandAction(
                         command=succeeded_command,

opentrons/protocol_engine/execution/equipment.py

@@ -1,6 +1,6 @@
 """Equipment command side-effect logic."""
 from dataclasses import dataclass
-from typing import Optional, overload, Union
+from typing import Optional, overload, Union, List
 
 from opentrons_shared_data.pipette.types import PipetteNameType
 
@@ -152,10 +152,6 @@ class EquipmentHandler:
         Returns:
             A LoadedLabwareData object.
         """
-        labware_id = (
-            labware_id if labware_id is not None else self._model_utils.generate_id()
-        )
-
         definition_uri = uri_from_details(
             load_name=load_name,
             namespace=namespace,
@@ -172,6 +168,10 @@ class EquipmentHandler:
                 version=version,
             )
 
+        labware_id = (
+            labware_id if labware_id is not None else self._model_utils.generate_id()
+        )
+
         # Allow propagation of ModuleNotLoadedError.
         offset_id = self.find_applicable_labware_offset_id(
             labware_definition_uri=definition_uri,
@@ -379,6 +379,74 @@ class EquipmentHandler:
             definition=attached_module.definition,
         )
 
+    async def load_lids(
+        self,
+        load_name: str,
+        namespace: str,
+        version: int,
+        location: LabwareLocation,
+        quantity: int,
+    ) -> List[LoadedLabwareData]:
+        """Load one or many lid labware by assigning an identifier and pulling required data.
+
+        Args:
+            load_name: The lid labware's load name.
+            namespace: The lid labware's namespace.
+            version: The lid labware's version.
+            location: The deck location at which lid(s) will be placed.
+            labware_ids: An optional list of identifiers to assign the labware. If None,
+                an identifier will be generated.
+
+        Raises:
+            ModuleNotLoadedError: If `location` references a module ID
+                that doesn't point to a valid loaded module.
+
+        Returns:
+            A list of LoadedLabwareData objects.
+        """
+        definition_uri = uri_from_details(
+            load_name=load_name,
+            namespace=namespace,
+            version=version,
+        )
+        try:
+            # Try to use existing definition in state.
+            definition = self._state_store.labware.get_definition_by_uri(definition_uri)
+        except LabwareDefinitionDoesNotExistError:
+            definition = await self._labware_data_provider.get_labware_definition(
+                load_name=load_name,
+                namespace=namespace,
+                version=version,
+            )
+
+        stack_limit = definition.stackLimit if definition.stackLimit is not None else 1
+        if quantity > stack_limit:
+            raise ValueError(
+                f"Requested quantity {quantity} is greater than the stack limit of {stack_limit} provided by definition for {load_name}."
+            )
+
+        # Allow propagation of ModuleNotLoadedError.
+        if (
+            isinstance(location, DeckSlotLocation)
+            and definition.parameters.isDeckSlotCompatible is not None
+            and not definition.parameters.isDeckSlotCompatible
+        ):
+            raise ValueError(
+                f"Lid Labware {load_name} cannot be loaded onto a Deck Slot."
+            )
+
+        load_labware_data_list = []
+        for i in range(quantity):
+            load_labware_data_list.append(
+                LoadedLabwareData(
+                    labware_id=self._model_utils.generate_id(),
+                    definition=definition,
+                    offsetId=None,
+                )
+            )
+
+        return load_labware_data_list
+
     async def configure_for_volume(
         self, pipette_id: str, volume: float, tip_overlap_version: Optional[str]
     ) -> LoadedConfigureForVolumeData: