opentrons 8.6.0a1__py3-none-any.whl

opentrons/protocol_engine/commands/wait_for_duration.py

@@ -0,0 +1,76 @@
+"""Wait for duration command request, result, and implementation models."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+from typing_extensions import Literal
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ..execution import RunControlHandler
+
+
+WaitForDurationCommandType = Literal["waitForDuration"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class WaitForDurationParams(BaseModel):
+    """Payload required to pause the protocol."""
+
+    seconds: float = Field(..., description="Duration, in seconds, to wait for.")
+    message: str | SkipJsonSchema[None] = Field(
+        None,
+        description="A user-facing message associated with the pause",
+        json_schema_extra=_remove_default,
+    )
+
+
+class WaitForDurationResult(BaseModel):
+    """Result data from the execution of a wait for duration command."""
+
+
+class WaitForDurationImplementation(
+    AbstractCommandImpl[WaitForDurationParams, SuccessData[WaitForDurationResult]]
+):
+    """Wait for duration command implementation."""
+
+    def __init__(self, run_control: RunControlHandler, **kwargs: object) -> None:
+        self._run_control = run_control
+
+    async def execute(
+        self, params: WaitForDurationParams
+    ) -> SuccessData[WaitForDurationResult]:
+        """Wait for a duration of time."""
+        await self._run_control.wait_for_duration(params.seconds)
+        return SuccessData(
+            public=WaitForDurationResult(),
+        )
+
+
+class WaitForDuration(
+    BaseCommand[WaitForDurationParams, WaitForDurationResult, ErrorOccurrence]
+):
+    """Wait for duration command model."""
+
+    commandType: WaitForDurationCommandType = "waitForDuration"
+    params: WaitForDurationParams
+    result: Optional[WaitForDurationResult] = None
+
+    _ImplementationCls: Type[
+        WaitForDurationImplementation
+    ] = WaitForDurationImplementation
+
+
+class WaitForDurationCreate(BaseCommandCreate[WaitForDurationParams]):
+    """Wait for duration command request model."""
+
+    commandType: WaitForDurationCommandType = "waitForDuration"
+    params: WaitForDurationParams
+
+    _CommandCls: Type[WaitForDuration] = WaitForDuration

opentrons/protocol_engine/commands/wait_for_resume.py

@@ -0,0 +1,75 @@
+"""Wait for resume command request, result, and implementation models."""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Type, Any
+
+from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
+from typing_extensions import Literal
+
+from .command import AbstractCommandImpl, BaseCommand, BaseCommandCreate, SuccessData
+from ..errors.error_occurrence import ErrorOccurrence
+
+if TYPE_CHECKING:
+    from ..execution import RunControlHandler
+
+
+# NOTE: multiple values accepted for backwards compatibility
+# with the 6.0.0-beta.0 release, which used `pause`
+WaitForResumeCommandType = Literal["waitForResume", "pause"]
+
+
+def _remove_default(s: dict[str, Any]) -> None:
+    s.pop("default", None)
+
+
+class WaitForResumeParams(BaseModel):
+    """Payload required to pause the protocol."""
+
+    message: str | SkipJsonSchema[None] = Field(
+        None,
+        description="A user-facing message associated with the pause",
+        json_schema_extra=_remove_default,
+    )
+
+
+class WaitForResumeResult(BaseModel):
+    """Result data from the execution of a WaitForResume command."""
+
+
+class WaitForResumeImplementation(
+    AbstractCommandImpl[WaitForResumeParams, SuccessData[WaitForResumeResult]]
+):
+    """Wait for resume command implementation."""
+
+    def __init__(self, run_control: RunControlHandler, **kwargs: object) -> None:
+        self._run_control = run_control
+
+    async def execute(
+        self, params: WaitForResumeParams
+    ) -> SuccessData[WaitForResumeResult]:
+        """Dispatch a PauseAction to the store to pause the protocol."""
+        await self._run_control.wait_for_resume()
+        return SuccessData(
+            public=WaitForResumeResult(),
+        )
+
+
+class WaitForResume(
+    BaseCommand[WaitForResumeParams, WaitForResumeResult, ErrorOccurrence]
+):
+    """Wait for resume command model."""
+
+    commandType: WaitForResumeCommandType = "waitForResume"
+    params: WaitForResumeParams
+    result: Optional[WaitForResumeResult] = None
+
+    _ImplementationCls: Type[WaitForResumeImplementation] = WaitForResumeImplementation
+
+
+class WaitForResumeCreate(BaseCommandCreate[WaitForResumeParams]):
+    """Wait for resume command request model."""
+
+    commandType: WaitForResumeCommandType = "waitForResume"
+    params: WaitForResumeParams
+
+    _CommandCls: Type[WaitForResume] = WaitForResume

opentrons/protocol_engine/create_protocol_engine.py

@@ -0,0 +1,193 @@
+"""Main ProtocolEngine factory."""
+import asyncio
+import contextlib
+import typing
+
+from opentrons.hardware_control import HardwareControlAPI
+from opentrons.hardware_control.types import DoorState
+from opentrons.protocol_engine.execution.error_recovery_hardware_state_synchronizer import (
+    ErrorRecoveryHardwareStateSynchronizer,
+)
+from opentrons.protocol_engine.resources.labware_data_provider import (
+    LabwareDataProvider,
+)
+from opentrons.util.async_helpers import async_context_manager_in_thread
+
+from opentrons_shared_data.robot import load as load_robot
+
+from .actions.action_dispatcher import ActionDispatcher
+from .error_recovery_policy import ErrorRecoveryPolicy
+from .execution.door_watcher import DoorWatcher
+from .execution.hardware_stopper import HardwareStopper
+from .plugins import PluginStarter
+from .protocol_engine import ProtocolEngine
+from .resources import DeckDataProvider, ModuleDataProvider, FileProvider, ModelUtils
+from .state.config import Config
+from .state.state import StateStore
+from .types import PostRunHardwareState, DeckConfigurationType
+
+from .engine_support import create_run_orchestrator
+
+
+# TODO(mm, 2023-06-16): Arguably, this not being a context manager makes us prone to forgetting to
+# clean it up properly, especially in tests. See e.g. https://opentrons.atlassian.net/browse/RSS-222
+async def create_protocol_engine(
+    hardware_api: HardwareControlAPI,
+    config: Config,
+    error_recovery_policy: ErrorRecoveryPolicy,
+    load_fixed_trash: bool = False,
+    deck_configuration: typing.Optional[DeckConfigurationType] = None,
+    file_provider: typing.Optional[FileProvider] = None,
+    notify_publishers: typing.Optional[typing.Callable[[], None]] = None,
+) -> ProtocolEngine:
+    """Create a ProtocolEngine instance.
+
+    Arguments:
+        hardware_api: Hardware control API to pass down to dependencies.
+        config: ProtocolEngine configuration.
+        error_recovery_policy: The error recovery policy to create the engine with.
+            See documentation on `ErrorRecoveryPolicy`.
+        load_fixed_trash: Automatically load fixed trash labware in engine.
+        deck_configuration: The initial deck configuration the engine will be instantiated with.
+        file_provider: Provides access to robot server file writing procedures for protocol output.
+        notify_publishers: Notifies robot server publishers of internal state change.
+    """
+    deck_data = DeckDataProvider(config.deck_type)
+    deck_definition = await deck_data.get_deck_definition()
+    deck_fixed_labware = await deck_data.get_deck_fixed_labware(
+        load_fixed_trash, deck_definition, deck_configuration
+    )
+
+    module_calibration_offsets = ModuleDataProvider.load_module_calibrations()
+    robot_definition = load_robot(config.robot_type)
+
+    state_store = StateStore(
+        config=config,
+        deck_definition=deck_definition,
+        deck_fixed_labware=deck_fixed_labware,
+        robot_definition=robot_definition,
+        is_door_open=hardware_api.door_state is DoorState.OPEN,
+        error_recovery_policy=error_recovery_policy,
+        module_calibration_offsets=module_calibration_offsets,
+        deck_configuration=deck_configuration,
+        notify_publishers=notify_publishers,
+    )
+    hardware_state_synchronizer = ErrorRecoveryHardwareStateSynchronizer(
+        hardware_api, state_store
+    )
+    action_dispatcher = ActionDispatcher(state_store)
+    action_dispatcher.add_handler(hardware_state_synchronizer)
+    plugin_starter = PluginStarter(state_store, action_dispatcher)
+    model_utils = ModelUtils()
+    hardware_stopper = HardwareStopper(hardware_api, state_store)
+    door_watcher = DoorWatcher(state_store, hardware_api, action_dispatcher)
+    module_data_provider = ModuleDataProvider()
+    file_provider = file_provider or FileProvider()
+
+    pe = ProtocolEngine(
+        hardware_api=hardware_api,
+        state_store=state_store,
+        action_dispatcher=action_dispatcher,
+        plugin_starter=plugin_starter,
+        model_utils=model_utils,
+        hardware_stopper=hardware_stopper,
+        door_watcher=door_watcher,
+        module_data_provider=module_data_provider,
+        file_provider=file_provider,
+    )
+
+    # todo(mm, 2024-11-08): This is a quick hack to support the absorbance reader, which
+    # expects the engine to have this special labware definition available. It would be
+    # cleaner for the `loadModule` command to do this I/O and insert the definition
+    # into state. That gets easier after https://opentrons.atlassian.net/browse/EXEC-756.
+    #
+    # NOTE: This needs to stay in sync with LabwareView.get_absorbance_reader_lid_definition().
+    pe.add_labware_definition(
+        await LabwareDataProvider().get_labware_definition(
+            "opentrons_flex_lid_absorbance_plate_reader_module", "opentrons", 1
+        )
+    )
+
+    return pe
+
+
+@contextlib.contextmanager
+def create_protocol_engine_in_thread(
+    hardware_api: HardwareControlAPI,
+    config: Config,
+    deck_configuration: typing.Optional[DeckConfigurationType],
+    file_provider: typing.Optional[FileProvider],
+    error_recovery_policy: ErrorRecoveryPolicy,
+    drop_tips_after_run: bool,
+    post_run_hardware_state: PostRunHardwareState,
+    load_fixed_trash: bool = False,
+) -> typing.Generator[
+    typing.Tuple[ProtocolEngine, asyncio.AbstractEventLoop], None, None
+]:
+    """Run a `ProtocolEngine` in a worker thread.
+
+    When this context manager is entered, it:
+
+    1. Starts a worker thread.
+    2. Starts an asyncio event loop in that worker thread.
+    3. Creates and `.play()`s a `ProtocolEngine` in that event loop.
+    4. Returns the `ProtocolEngine` and the event loop.
+       Use functions like `asyncio.run_coroutine_threadsafe()` to safely interact with
+       the `ProtocolEngine` from your thread.
+
+    When this context manager is exited, it:
+
+    1. Cleans up the `ProtocolEngine`.
+    2. Stops and cleans up the event loop.
+    3. Joins the thread.
+    """
+    with async_context_manager_in_thread(
+        _protocol_engine(
+            hardware_api,
+            file_provider,
+            config,
+            deck_configuration,
+            error_recovery_policy,
+            drop_tips_after_run,
+            post_run_hardware_state,
+            load_fixed_trash,
+        )
+    ) as (
+        protocol_engine,
+        loop,
+    ):
+        yield protocol_engine, loop
+
+
+@contextlib.asynccontextmanager
+async def _protocol_engine(
+    hardware_api: HardwareControlAPI,
+    file_provider: typing.Optional[FileProvider],
+    config: Config,
+    deck_configuration: typing.Optional[DeckConfigurationType],
+    error_recovery_policy: ErrorRecoveryPolicy,
+    drop_tips_after_run: bool,
+    post_run_hardware_state: PostRunHardwareState,
+    load_fixed_trash: bool = False,
+) -> typing.AsyncGenerator[ProtocolEngine, None]:
+    protocol_engine = await create_protocol_engine(
+        hardware_api=hardware_api,
+        file_provider=file_provider,
+        config=config,
+        error_recovery_policy=error_recovery_policy,
+        load_fixed_trash=load_fixed_trash,
+    )
+
+    # TODO(tz, 6-20-2024): This feels like a hack, we should probably return the orchestrator instead of pe.
+    orchestrator = create_run_orchestrator(
+        hardware_api=hardware_api,
+        protocol_engine=protocol_engine,
+    )
+    try:
+        orchestrator.play(deck_configuration)
+        yield protocol_engine
+    finally:
+        await orchestrator.finish(
+            drop_tips_after_run=drop_tips_after_run,
+            post_run_hardware_state=post_run_hardware_state,
+        )

opentrons/protocol_engine/engine_support.py

@@ -0,0 +1,28 @@
+"""Support for create_protocol_engine module."""
+from . import ProtocolEngine
+from ..hardware_control import HardwareControlAPI
+
+from opentrons.protocol_runner import protocol_runner, RunOrchestrator
+
+
+def create_run_orchestrator(
+    hardware_api: HardwareControlAPI,
+    protocol_engine: ProtocolEngine,
+) -> RunOrchestrator:
+    """Create a RunOrchestrator instance."""
+    return RunOrchestrator(
+        protocol_engine=protocol_engine,
+        hardware_api=hardware_api,
+        setup_runner=protocol_runner.LiveRunner(
+            protocol_engine=protocol_engine,
+            hardware_api=hardware_api,
+        ),
+        fixit_runner=protocol_runner.LiveRunner(
+            protocol_engine=protocol_engine,
+            hardware_api=hardware_api,
+        ),
+        protocol_live_runner=protocol_runner.LiveRunner(
+            protocol_engine=protocol_engine,
+            hardware_api=hardware_api,
+        ),
+    )

opentrons/protocol_engine/error_recovery_policy.py

@@ -0,0 +1,81 @@
+# noqa: D100
+
+from __future__ import annotations
+
+import enum
+from typing import Optional, Protocol, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from opentrons.protocol_engine.commands import (
+        Command,
+        CommandDefinedErrorData,
+    )
+    from opentrons.protocol_engine.state.config import Config
+
+
+class ErrorRecoveryType(enum.Enum):
+    """Ways to handle a command failure."""
+
+    FAIL_RUN = enum.auto()
+    """Permanently fail the entire run.
+
+    TODO(mm, 2024-03-18): This might be a misnomer because failing the run is not
+    a decision that's up to Protocol Engine. It's decided by what the caller supplies
+    to `ProtocolEngine.finish()`. For example, a Python protocol can
+    theoretically swallow the exception and continue on.
+    """
+
+    WAIT_FOR_RECOVERY = enum.auto()
+    """Enter interactive error recovery mode."""
+
+    CONTINUE_WITH_ERROR = enum.auto()
+    """Continue without interruption, carrying on from whatever error state the failed
+    command left the engine in.
+
+    This is like `ProtocolEngine.resume_from_recovery(reconcile_false_positive=False)`.
+    """
+
+    ASSUME_FALSE_POSITIVE_AND_CONTINUE = enum.auto()
+    """Continue without interruption, acting as if the underlying error was a false positive.
+
+    This is like `ProtocolEngine.resume_from_recovery(reconcile_false_positive=True)`.
+    """
+
+
+class ErrorRecoveryPolicy(Protocol):
+    """An interface to decide how to handle a command failure.
+
+    This describes a function that Protocol Engine calls after each command failure,
+    with the details of that failure. The implementation should inspect those details
+    and return an appropriate `ErrorRecoveryType`.
+
+    Args:
+        config: The config of the calling `ProtocolEngine`.
+        failed_command: The command that failed, in its final `status=="failed"` state.
+        defined_error_data: If the command failed with a defined error, details about
+            that error. If the command failed with an undefined error, `None`.
+            By design, this callable isn't given details about undefined errors,
+            since it would be fragile to rely on them.
+    """
+
+    @staticmethod
+    def __call__(  # noqa: D102
+        config: Config,
+        failed_command: Command,
+        defined_error_data: Optional[CommandDefinedErrorData],
+    ) -> ErrorRecoveryType:
+        ...
+
+
+def never_recover(
+    config: Config,
+    failed_command: Command,
+    defined_error_data: Optional[CommandDefinedErrorData],
+) -> ErrorRecoveryType:
+    """An error recovery policy where error recovery is never attempted.
+
+    This makes sense for things like the `opentrons_simulate` and `opentrons_execute`
+    CLIs. Those don't expose any way to bring the run out of recovery mode after it's
+    been entered, so we need to avoid entering recovery mode in the first place.
+    """
+    return ErrorRecoveryType.FAIL_RUN

opentrons/protocol_engine/errors/__init__.py

@@ -0,0 +1,191 @@
+"""Protocol engine errors module."""
+
+from .exceptions import (
+    ProtocolEngineError,
+    UnexpectedProtocolError,
+    FailedToLoadPipetteError,
+    PipetteNotAttachedError,
+    InvalidSpecificationForRobotTypeError,
+    InvalidLoadPipetteSpecsError,
+    TipNotAttachedError,
+    PickUpTipTipNotAttachedError,
+    TipAttachedError,
+    CommandDoesNotExistError,
+    UnsupportedLabwareForActionError,
+    LabwareNotLoadedError,
+    LabwareNotLoadedOnModuleError,
+    LabwareNotLoadedOnLabwareError,
+    LabwareNotOnDeckError,
+    LiquidDoesNotExistError,
+    LabwareDefinitionDoesNotExistError,
+    LabwareCannotBeStackedError,
+    LabwareCannotSitOnDeckError,
+    LabwareIsInStackError,
+    LabwareOffsetDoesNotExistError,
+    LabwareIsNotTipRackError,
+    LabwareIsTipRackError,
+    LabwareIsAdapterError,
+    TouchTipDisabledError,
+    TouchTipIncompatibleArgumentsError,
+    WellDoesNotExistError,
+    PipetteNotLoadedError,
+    ModuleNotLoadedError,
+    ModuleNotOnDeckError,
+    ModuleNotConnectedError,
+    SlotDoesNotExistError,
+    CutoutDoesNotExistError,
+    FixtureDoesNotExistError,
+    AddressableAreaDoesNotExistError,
+    FixtureDoesNotProvideAreasError,
+    AreaNotInDeckConfigurationError,
+    IncompatibleAddressableAreaError,
+    FailedToPlanMoveError,
+    MustHomeError,
+    RunStoppedError,
+    SetupCommandNotAllowedError,
+    FixitCommandNotAllowedError,
+    ModuleNotAttachedError,
+    ModuleAlreadyPresentError,
+    WrongModuleTypeError,
+    ThermocyclerNotOpenError,
+    RobotDoorOpenError,
+    PipetteMovementRestrictedByHeaterShakerError,
+    HeaterShakerLabwareLatchNotOpenError,
+    HeaterShakerLabwareLatchStatusUnknown,
+    EngageHeightOutOfRangeError,
+    NoTargetTemperatureSetError,
+    InvalidTargetSpeedError,
+    InvalidTargetTemperatureError,
+    InvalidBlockVolumeError,
+    InvalidHoldTimeError,
+    InvalidWavelengthError,
+    CannotPerformModuleAction,
+    PauseNotAllowedError,
+    ResumeFromRecoveryNotAllowedError,
+    GripperNotAttachedError,
+    CannotPerformGripperAction,
+    HardwareNotSupportedError,
+    LabwareMovementNotAllowedError,
+    LabwareIsNotAllowedInLocationError,
+    LocationIsOccupiedError,
+    LocationNotAccessibleByPipetteError,
+    LocationIsStagingSlotError,
+    LocationIsLidDockSlotError,
+    InvalidAxisForRobotType,
+    NotSupportedOnRobotType,
+    CommandNotAllowedError,
+    InvalidLiquidHeightFound,
+    LiquidHeightUnknownError,
+    LiquidVolumeUnknownError,
+    IncompleteLabwareDefinitionError,
+    InvalidUserDefinedVolumesError,
+    IncompleteWellDefinitionError,
+    OperationLocationNotInWellError,
+    InvalidDispenseVolumeError,
+    StorageLimitReachedError,
+    InvalidLiquidError,
+    LiquidClassDoesNotExistError,
+    LiquidClassRedefinitionError,
+    OffsetLocationInvalidError,
+    FlexStackerLabwarePoolNotYetDefinedError,
+    FlexStackerNotLogicallyEmptyError,
+    InvalidLabwarePositionError,
+)
+
+from .error_occurrence import ErrorOccurrence, ProtocolCommandFailedError
+
+__all__ = [
+    # exceptions
+    "ProtocolEngineError",
+    "UnexpectedProtocolError",
+    "FailedToLoadPipetteError",
+    "PipetteNotAttachedError",
+    "InvalidSpecificationForRobotTypeError",
+    "InvalidLoadPipetteSpecsError",
+    "TipNotAttachedError",
+    "PickUpTipTipNotAttachedError",
+    "TipAttachedError",
+    "CommandDoesNotExistError",
+    "LabwareNotLoadedError",
+    "LabwareNotLoadedOnModuleError",
+    "LabwareNotLoadedOnLabwareError",
+    "LabwareNotOnDeckError",
+    "LiquidDoesNotExistError",
+    "UnsupportedLabwareForActionError",
+    "LabwareDefinitionDoesNotExistError",
+    "LabwareCannotBeStackedError",
+    "LabwareCannotSitOnDeckError",
+    "LabwareIsInStackError",
+    "LabwareOffsetDoesNotExistError",
+    "LabwareIsNotTipRackError",
+    "LabwareIsTipRackError",
+    "LabwareIsAdapterError",
+    "TouchTipDisabledError",
+    "TouchTipIncompatibleArgumentsError",
+    "WellDoesNotExistError",
+    "PipetteNotLoadedError",
+    "ModuleNotLoadedError",
+    "ModuleNotOnDeckError",
+    "ModuleNotConnectedError",
+    "SlotDoesNotExistError",
+    "CutoutDoesNotExistError",
+    "FixtureDoesNotExistError",
+    "AddressableAreaDoesNotExistError",
+    "FixtureDoesNotProvideAreasError",
+    "AreaNotInDeckConfigurationError",
+    "IncompatibleAddressableAreaError",
+    "FailedToPlanMoveError",
+    "MustHomeError",
+    "RunStoppedError",
+    "SetupCommandNotAllowedError",
+    "FixitCommandNotAllowedError",
+    "ModuleNotAttachedError",
+    "ModuleAlreadyPresentError",
+    "WrongModuleTypeError",
+    "ThermocyclerNotOpenError",
+    "RobotDoorOpenError",
+    "PipetteMovementRestrictedByHeaterShakerError",
+    "HeaterShakerLabwareLatchNotOpenError",
+    "HeaterShakerLabwareLatchStatusUnknown",
+    "EngageHeightOutOfRangeError",
+    "NoTargetTemperatureSetError",
+    "InvalidTargetTemperatureError",
+    "InvalidTargetSpeedError",
+    "InvalidBlockVolumeError",
+    "InvalidHoldTimeError",
+    "InvalidLiquidError",
+    "InvalidWavelengthError",
+    "CannotPerformModuleAction",
+    "ResumeFromRecoveryNotAllowedError",
+    "PauseNotAllowedError",
+    "ProtocolCommandFailedError",
+    "GripperNotAttachedError",
+    "CannotPerformGripperAction",
+    "HardwareNotSupportedError",
+    "LabwareMovementNotAllowedError",
+    "LabwareIsNotAllowedInLocationError",
+    "LocationIsOccupiedError",
+    "LocationNotAccessibleByPipetteError",
+    "LocationIsStagingSlotError",
+    "LocationIsLidDockSlotError",
+    "InvalidAxisForRobotType",
+    "NotSupportedOnRobotType",
+    "OffsetLocationInvalidError",
+    "FlexStackerLabwarePoolNotYetDefinedError",
+    "FlexStackerNotLogicallyEmptyError",
+    "InvalidLabwarePositionError",
+    # error occurrence models
+    "ErrorOccurrence",
+    "CommandNotAllowedError",
+    "InvalidLiquidHeightFound",
+    "LiquidHeightUnknownError",
+    "LiquidVolumeUnknownError",
+    "IncompleteLabwareDefinitionError",
+    "InvalidUserDefinedVolumesError",
+    "IncompleteWellDefinitionError",
+    "OperationLocationNotInWellError",
+    "InvalidDispenseVolumeError",
+    "StorageLimitReachedError",
+    "LiquidClassDoesNotExistError",
+    "LiquidClassRedefinitionError",
+]