dls-dodal 1.34.1__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/devices/oav/snapshots/grid_overlay.py

@@ -14,7 +14,7 @@ def _add_parallel_lines_to_image(
     start_x: int,
     start_y: int,
     line_length: int,
-    spacing: int,
+    spacing: float,
     num_lines: int,
     orientation=Orientation.horizontal,
 ):
@@ -32,7 +32,7 @@ def _add_parallel_lines_to_image(
         start_x (int): The x coordinate (in pixels) of the start of the initial line.
         start_y (int): The y coordinate (in pixels) of the start of the initial line.
         line_length (int): The length of each of the parallel lines in pixels.
-        spacing (int): The spacing, in pixels, between each parallel line. Strictly, \
+        spacing (float): The spacing, in pixels, between each parallel line. Strictly, \
             there are spacing-1 pixels between each line
         num_lines (int): The total number of parallel lines to draw.
         orientation (Orientation): The orientation (horizontal or vertical) of the \
@@ -40,13 +40,13 @@ def _add_parallel_lines_to_image(
     lines = [
         (
             (
-                (start_x, start_y + i * spacing),
-                (start_x + line_length, start_y + i * spacing),
+                (start_x, start_y + int(i * spacing)),
+                (start_x + line_length, start_y + int(i * spacing)),
             )
             if orientation == Orientation.horizontal
             else (
-                (start_x + i * spacing, start_y),
-                (start_x + i * spacing, start_y + line_length),
+                (start_x + int(i * spacing), start_y),
+                (start_x + int(i * spacing), start_y + line_length),
             )
         )
         for i in range(num_lines)
@@ -70,7 +70,7 @@ def add_grid_border_overlay_to_image(
     image: Image.Image,
     top_left_x: int,
     top_left_y: int,
-    box_width: int,
+    box_width: float,
     num_boxes_x: int,
     num_boxes_y: int,
 ):
@@ -78,16 +78,16 @@ def add_grid_border_overlay_to_image(
         image,
         start_x=top_left_x,
         start_y=top_left_y,
-        line_length=num_boxes_y * box_width,
-        spacing=num_boxes_x * box_width,
+        line_length=int(num_boxes_y * box_width),
+        spacing=int(num_boxes_x * box_width),
         num_lines=2,
     )
     _add_horizontal_parallel_lines_to_image(
         image,
         start_x=top_left_x,
         start_y=top_left_y,
-        line_length=num_boxes_x * box_width,
-        spacing=num_boxes_y * box_width,
+        line_length=int(num_boxes_x * box_width),
+        spacing=int(num_boxes_y * box_width),
         num_lines=2,
     )
 
@@ -96,23 +96,23 @@ def add_grid_overlay_to_image(
     image: Image.Image,
     top_left_x: int,
     top_left_y: int,
-    box_width: int,
+    box_width: float,
     num_boxes_x: int,
     num_boxes_y: int,
 ):
     _add_vertical_parallel_lines_to_image(
         image,
-        start_x=top_left_x + box_width,
+        start_x=int(top_left_x + box_width),
         start_y=top_left_y,
-        line_length=num_boxes_y * box_width,
+        line_length=int(num_boxes_y * box_width),
         spacing=box_width,
         num_lines=num_boxes_x - 1,
     )
     _add_horizontal_parallel_lines_to_image(
         image,
         start_x=top_left_x,
-        start_y=top_left_y + box_width,
-        line_length=num_boxes_x * box_width,
+        start_y=int(top_left_y + box_width),
+        line_length=int(num_boxes_x * box_width),
         spacing=box_width,
         num_lines=num_boxes_y - 1,
     )

dodal/devices/oav/snapshots/snapshot_with_beam_centre.py

@@ -1,4 +1,4 @@
-from ophyd_async.core import SignalR
+from ophyd_async.core import Reference, SignalR
 from PIL import Image, ImageDraw
 
 from dodal.devices.areadetector.plugins.MJPG import MJPG
@@ -52,13 +52,13 @@ class SnapshotWithBeamCentre(MJPG):
         name: str = "",
     ) -> None:
         with self.add_children_as_readables():
-            self.beam_centre_i = beam_x_signal
-            self.beam_centre_j = beam_y_signal
+            self._beam_centre_i_ref = Reference(beam_x_signal)
+            self._beam_centre_j_ref = Reference(beam_y_signal)
         super().__init__(prefix, name)
 
     async def post_processing(self, image: Image.Image):
-        beam_x = await self.beam_centre_i.get_value()
-        beam_y = await self.beam_centre_j.get_value()
+        beam_x = await self._beam_centre_i_ref().get_value()
+        beam_y = await self._beam_centre_j_ref().get_value()
         draw_crosshair(image, beam_x, beam_y)
 
         await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -14,9 +14,9 @@ from dodal.log import LOGGER
 class SnapshotWithGrid(MJPG):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.top_left_x = soft_signal_rw(int)
-            self.top_left_y = soft_signal_rw(int)
-            self.box_width = soft_signal_rw(int)
+            self.top_left_x = soft_signal_rw(float)
+            self.top_left_y = soft_signal_rw(float)
+            self.box_width = soft_signal_rw(float)
             self.num_boxes_x = soft_signal_rw(int)
             self.num_boxes_y = soft_signal_rw(int)
 
@@ -31,7 +31,7 @@ class SnapshotWithGrid(MJPG):
 
         top_left_x = await self.top_left_x.get_value()
         top_left_y = await self.top_left_y.get_value()
-        box_witdh = await self.box_width.get_value()
+        box_width = await self.box_width.get_value()
         num_boxes_x = await self.num_boxes_x.get_value()
         num_boxes_y = await self.num_boxes_y.get_value()
 
@@ -39,7 +39,7 @@ class SnapshotWithGrid(MJPG):
         assert isinstance(directory_str := await self.directory.get_value(), str)
 
         add_grid_border_overlay_to_image(
-            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+            image, int(top_left_x), int(top_left_y), box_width, num_boxes_x, num_boxes_y
         )
 
         path = path_join(directory_str, f"{filename_str}_outer_overlay.{IMG_FORMAT}")
@@ -48,7 +48,7 @@ class SnapshotWithGrid(MJPG):
         await asyncio_save_image(image, path)
 
         add_grid_overlay_to_image(
-            image, top_left_x, top_left_y, box_witdh, num_boxes_x, num_boxes_y
+            image, int(top_left_x), int(top_left_y), box_width, num_boxes_x, num_boxes_y
         )
 
         path = path_join(directory_str, f"{filename_str}_grid_overlay.{IMG_FORMAT}")

dodal/devices/oav/utils.py

@@ -103,8 +103,8 @@ def wait_for_tip_to_be_found(
 ) -> Generator[Msg, None, Pixel]:
     yield from bps.trigger(ophyd_pin_tip_detection, wait=True)
     found_tip = yield from bps.rd(ophyd_pin_tip_detection.triggered_tip)
-    if found_tip == ophyd_pin_tip_detection.INVALID_POSITION:
+    if all(found_tip == ophyd_pin_tip_detection.INVALID_POSITION):
         timeout = yield from bps.rd(ophyd_pin_tip_detection.validity_timeout)
         raise PinNotFoundException(f"No pin found after {timeout} seconds")
 
-    return found_tip  # type: ignore
+    return Pixel((int(found_tip[0]), int(found_tip[1])))

dodal/devices/p99/sample_stage.py

@@ -1,7 +1,5 @@
-from enum import Enum
-
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import Device, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class SampleAngleStage(Device):
@@ -18,7 +16,7 @@ class SampleAngleStage(Device):
         super().__init__(name=name)
 
 
-class p99StageSelections(str, Enum):
+class p99StageSelections(SubsetEnum):
     Empty = "Empty"
     Mn5um = "Mn 5um"
     Fe = "Fe (empty)"

dodal/devices/pgm.py

@@ -1,11 +1,10 @@
-from enum import Enum
-
 from ophyd_async.core import (
-    ConfigSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
 )
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
 class PGM(StandardReadable):
@@ -16,7 +15,7 @@ class PGM(StandardReadable):
     def __init__(
         self,
         prefix: str,
-        grating: type[Enum],
+        grating: type[StrictEnum],
         gratingPv: str,
         name: str = "",
     ) -> None:
@@ -34,7 +33,7 @@ class PGM(StandardReadable):
         """
         with self.add_children_as_readables():
             self.energy = Motor(prefix + "ENERGY")
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.grating = epics_signal_rw(grating, prefix + gratingPv)
             self.cff = epics_signal_rw(float, prefix + "CFF")
 

dodal/devices/qbpm.py

@@ -1,5 +1,5 @@
 from ophyd_async.core import StandardReadable
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 
 class QBPM(StandardReadable):

dodal/devices/robot.py

@@ -1,16 +1,16 @@
 import asyncio
 from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
-from enum import Enum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
 
 from dodal.log import LOGGER
 
@@ -33,7 +33,7 @@ class SampleLocation:
     pin: int
 
 
-class PinMounted(str, Enum):
+class PinMounted(StrictEnum):
     NO_PIN_MOUNTED = "No Pin Mounted"
     PIN_MOUNTED = "Pin Mounted"
 

dodal/devices/smargon.py

@@ -7,8 +7,8 @@ from typing import cast
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
 from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.devices.util.epics_util import SetWhenEnabled
 

dodal/devices/synchrotron.py

@@ -1,7 +1,12 @@
 from enum import Enum
 
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.core import (
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+    soft_signal_r_and_setter,
+)
+from ophyd_async.epics.core import epics_signal_r
 
 
 class Prefix(str, Enum):
@@ -19,7 +24,7 @@ class Suffix(str, Enum):
     END_COUNTDOWN = "ENDCOUNTDN"
 
 
-class SynchrotronMode(str, Enum):
+class SynchrotronMode(StrictEnum):
     SHUTDOWN = "Shutdown"
     INJECTION = "Injection"
     NOBEAM = "No Beam"
@@ -44,7 +49,7 @@ class Synchrotron(StandardReadable):
             self.current = epics_signal_r(float, signal_prefix + Suffix.SIGNAL)
             self.energy = epics_signal_r(float, status_prefix + Suffix.BEAM_ENERGY)
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.probe, _ = soft_signal_r_and_setter(str, initial_value="x-ray")
             self.type, _ = soft_signal_r_and_setter(
                 str, initial_value="Synchrotron X-ray Source"

dodal/devices/tetramm.py

@@ -1,5 +1,4 @@
 import asyncio
-from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
@@ -9,42 +8,43 @@ from ophyd_async.core import (
     Device,
     PathProvider,
     StandardDetector,
+    StrictEnum,
     TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
 from ophyd_async.epics.adcore import ADHDFWriter, NDFileHDFIO, stop_busy_record
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
 )
 
 
-class TetrammRange(str, Enum):
+class TetrammRange(StrictEnum):
     uA = "+- 120 uA"
     nA = "+- 120 nA"
 
 
-class TetrammTrigger(str, Enum):
+class TetrammTrigger(StrictEnum):
     FreeRun = "Free run"
     ExtTrigger = "Ext. trig."
     ExtBulb = "Ext. bulb"
     ExtGate = "Ext. gate"
 
 
-class TetrammChannels(str, Enum):
+class TetrammChannels(StrictEnum):
     One = "1"
     Two = "2"
     Four = "4"
 
 
-class TetrammResolution(str, Enum):
+class TetrammResolution(StrictEnum):
     SixteenBits = "16 bits"
     TwentyFourBits = "24 bits"
 
 
-class TetrammGeometry(str, Enum):
+class TetrammGeometry(StrictEnum):
     Diamond = "Diamond"
     Square = "Square"
 

dodal/devices/thawer.py

@@ -1,36 +1,42 @@
 from asyncio import Task, create_task, sleep
-from enum import Enum
 
 from bluesky.protocols import Stoppable
-from ophyd_async.core import AsyncStatus, Device, SignalRW, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    Reference,
+    SignalRW,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class ThawingException(Exception):
     pass
 
 
-class ThawerStates(str, Enum):
+class ThawerStates(StrictEnum):
     OFF = "Off"
     ON = "On"
 
 
 class ThawingTimer(Device, Stoppable):
     def __init__(self, control_signal: SignalRW[ThawerStates]) -> None:
-        self._control_signal = control_signal
+        self._control_signal_ref = Reference(control_signal)
         self._thawing_task: Task | None = None
         super().__init__("thaw_for_time_s")
 
     @AsyncStatus.wrap
     async def set(self, time_to_thaw_for: float):
-        await self._control_signal.set(ThawerStates.ON)
+        await self._control_signal_ref().set(ThawerStates.ON)
         if self._thawing_task and not self._thawing_task.done():
             raise ThawingException("Thawing task already in progress")
         self._thawing_task = create_task(sleep(time_to_thaw_for))
         try:
             await self._thawing_task
         finally:
-            await self._control_signal.set(ThawerStates.OFF)
+            await self._control_signal_ref().set(ThawerStates.OFF)
 
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):

dodal/devices/undulator.py

@@ -1,17 +1,17 @@
 import os
-from enum import Enum
 
 import numpy as np
 from bluesky.protocols import Movable
 from numpy import argmin, ndarray
 from ophyd_async.core import (
     AsyncStatus,
-    ConfigSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     soft_signal_r_and_setter,
 )
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 from dodal.log import LOGGER
 
@@ -33,7 +33,7 @@ UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
 STATUS_TIMEOUT_S: float = 10.0
 
 
-class UndulatorGapAccess(str, Enum):
+class UndulatorGapAccess(StrictEnum):
     ENABLED = "ENABLED"
     DISABLED = "DISABLED"
 
@@ -75,7 +75,7 @@ class Undulator(StandardReadable, Movable):
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
             self.gap_access = epics_signal_r(UndulatorGapAccess, prefix + "IDBLENA")
 
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
                 float,
                 initial_value=UNDULATOR_DISCREPANCY_THRESHOLD_MM,

dodal/devices/util/epics_util.py

@@ -7,7 +7,7 @@ from ophyd import Device as OphydDevice
 from ophyd.status import Status, StatusBase
 from ophyd_async.core import AsyncStatus, wait_for_value
 from ophyd_async.core import Device as OphydAsyncDevice
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.log import LOGGER
 

dodal/devices/watsonmarlow323_pump.py

@@ -0,0 +1,45 @@
+from ophyd_async.core import StandardReadable, StandardReadableFormat, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class WatsonMarlow323PumpEnable(StrictEnum):
+    DISABLED = "Disabled"
+    ENABLED = "Enabled"
+
+
+class WatsonMarlow323PumpDirection(StrictEnum):
+    CLOCKWISE = "CW"
+    COUNTER_CLOCKWISE = "CCW"
+
+
+class WatsonMarlow323PumpState(StrictEnum):
+    STOPPED = "STOP"
+    STARTED = "START"
+
+
+class WatsonMarlow323Pump(StandardReadable):
+    """Watson Marlow 323 Peristaltic Pump device"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.direction = epics_signal_rw(
+                WatsonMarlow323PumpDirection,
+                read_pv=prefix + "INFO:DIR",
+                write_pv=prefix + "SET:DIR",
+            )
+            self.state = epics_signal_rw(
+                WatsonMarlow323PumpState,
+                read_pv=prefix + "INFO:RUN",
+                write_pv=prefix + "SET:RUN",
+            )
+            self.speed = epics_signal_rw(
+                float, read_pv=prefix + "INFO:SPD", write_pv=prefix + "SET:SPD"
+            )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.enabled = epics_signal_rw(
+                WatsonMarlow323PumpEnable,
+                prefix + "DISABLE",
+            )
+
+        super().__init__(name=name)

dodal/devices/webcam.py

@@ -5,7 +5,12 @@ from pathlib import Path
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_rw,
+)
 from PIL import Image
 
 from dodal.log import LOGGER
@@ -27,7 +32,9 @@ class Webcam(StandardReadable, Triggerable):
         self.directory = soft_signal_rw(str, name="directory")
         self.last_saved_path = soft_signal_rw(str, name="last_saved_path")
 
-        self.add_readables([self.last_saved_path], wrapper=HintedSignal)
+        self.add_readables(
+            [self.last_saved_path], format=StandardReadableFormat.HINTED_SIGNAL
+        )
         super().__init__(name=name)
 
     async def _write_image(self, file_path: str, image: ByteString):

dodal/devices/xbpm_feedback.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
 from bluesky.protocols import Triggerable
-from ophyd_async.core import AsyncStatus, Device, observe_value
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
-class Pause(str, Enum):
+class Pause(StrictEnum):
     PAUSE = "Paused"  # 0
     RUN = "Ok to Run"  # 1
 

dodal/devices/xspress3/xspress3.py

@@ -1,15 +1,14 @@
-from enum import Enum
-
 from bluesky.protocols import Stageable
 from numpy import float64
-from numpy.typing import NDArray
 from ophyd_async.core import (
+    Array1D,
     AsyncStatus,
     Device,
     DeviceVector,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import (
+from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
@@ -23,7 +22,7 @@ from dodal.devices.xspress3.xspress3_channel import (
 from dodal.log import LOGGER
 
 
-class TriggerMode(str, Enum):
+class TriggerMode(StrictEnum):
     SOFTWARE = "Software"
     HARDWARE = "Hardware"
     BURST = "Burst"
@@ -35,17 +34,17 @@ class TriggerMode(str, Enum):
     LVDS_both = "LVDS Both"
 
 
-class UpdateRBV(str, Enum):
+class UpdateRBV(StrictEnum):
     DISABLED = "Disabled"
     ENABLED = "Enabled"
 
 
-class AcquireRBVState(str, Enum):
+class AcquireRBVState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquiring"
 
 
-class DetectorState(str, Enum):
+class DetectorState(StrictEnum):
     IDLE = "Idle"
     ACQUIRE = "Acquire"
     READOUT = "Readout"
@@ -101,7 +100,7 @@ class Xspress3(Device, Stageable):
         """signal for the corrected MCA spectrum (1d array)"""
         self.dt_corrected_latest_mca = DeviceVector(
             {
-                i: epics_signal_r(NDArray[float64], f"{prefix}ARR{i}:ArrayData")
+                i: epics_signal_r(Array1D[float64], f"{prefix}ARR{i}:ArrayData")
                 for i in range(1, num_channels + 1)
             }
         )

dodal/devices/xspress3/xspress3_channel.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import Device, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from ophyd_async.core import Device
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
-
-class AcquireState(str, Enum):
+class AcquireState(StrictEnum):
     DONE = "Done"
     ACQUIRE = "Acquire"
 

dodal/devices/zebra.py

@@ -9,9 +9,10 @@ from ophyd_async.core import (
     DeviceVector,
     SignalRW,
     StandardReadable,
+    StrictEnum,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 # These constants refer to I03's Zebra. See https://github.com/DiamondLightSource/dodal/issues/772
 # Sources
@@ -46,18 +47,18 @@ AUTO_SHUTTER_INPUT_1 = 1
 AUTO_SHUTTER_INPUT_2 = 2
 
 
-class ArmSource(str, Enum):
+class ArmSource(StrictEnum):
     SOFT = "Soft"
     EXTERNAL = "External"
 
 
-class TrigSource(str, Enum):
+class TrigSource(StrictEnum):
     POSITION = "Position"
     TIME = "Time"
     EXTERNAL = "External"
 
 
-class EncEnum(str, Enum):
+class EncEnum(StrictEnum):
     Enc1 = "Enc1"
     Enc2 = "Enc2"
     Enc3 = "Enc3"
@@ -79,7 +80,7 @@ class I24Axes:
     VGON_YH = EncEnum.Enc4
 
 
-class RotationDirection(str, Enum):
+class RotationDirection(StrictEnum):
     POSITIVE = "Positive"
     NEGATIVE = "Negative"
 
@@ -93,7 +94,7 @@ class ArmDemand(Enum):
     DISARM = 0
 
 
-class SoftInState(str, Enum):
+class SoftInState(StrictEnum):
     YES = "Yes"
     NO = "No"