ophyd-async 0.13.3__py3-none-any.whl → 0.13.5__py3-none-any.whl

ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.3'
-__version_tuple__ = version_tuple = (0, 13, 3)
+__version__ = version = '0.13.5'
+__version_tuple__ = version_tuple = (0, 13, 5)
 
 __commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -21,6 +21,7 @@ from ._enums import (
     EnableDisable,
     InOut,
     OnOff,
+    YesNo,
 )
 from ._flyer import FlyerController, FlyMotorInfo, StandardFlyer
 from ._hdf_dataset import HDFDatasetDescription, HDFDocumentComposer
@@ -78,7 +79,7 @@ from ._signal_backend import (
 )
 from ._soft_signal_backend import SoftSignalBackend
 from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
-from ._table import Table
+from ._table import Table, TableSubclass
 from ._utils import (
     CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
@@ -87,7 +88,7 @@ from ._utils import (
     ConfinedModel,
     EnumTypes,
     LazyMock,
-    NotConnected,
+    NotConnectedError,
     Reference,
     StrictEnum,
     SubsetEnum,
@@ -103,6 +104,26 @@ from ._utils import (
 )
 from ._yaml_settings import YamlSettingsProvider
 
+
+# Back compat - delete before 1.0
+def __getattr__(name):
+    import warnings
+
+    renames = {
+        "NotConnected": NotConnectedError,
+    }
+    rename = renames.get(name)
+    if rename is not None:
+        warnings.warn(
+            DeprecationWarning(
+                f"{name!r} is deprecated, use {rename.__name__!r} instead"
+            ),
+            stacklevel=2,
+        )
+        return rename
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 __all__ = [
     # Device
     "Device",
@@ -195,7 +216,7 @@ __all__ = [
     "DEFAULT_TIMEOUT",
     "Callback",
     "ConfinedModel",
-    "NotConnected",
+    "NotConnectedError",
     "Reference",
     "error_if_none",
     "gather_dict",
@@ -221,4 +242,6 @@ __all__ = [
     "EnableDisable",
     "InOut",
     "OnOff",
+    "YesNo",
+    "TableSubclass",
 ]

ophyd_async/core/_derived_signal_backend.py

@@ -222,7 +222,8 @@ class SignalTransformer(Generic[TransformT]):
                 # callback
                 self._cached_readings = {}
                 for raw in self.raw_and_transform_subscribables.values():
-                    raw.subscribe(self._update_cached_reading)
+                    # can remove type: ignore when Subscribable protocol updated
+                    raw.subscribe_reading(self._update_cached_reading)  # type: ignore
             elif self._complete_cached_reading():
                 # Callback on the last complete set of readings
                 derived_readings = self._make_derived_readings(self._cached_readings)

ophyd_async/core/_detector.py

@@ -249,11 +249,11 @@ class StandardDetector(
                 )
             try:
                 await signal.get_value()
-            except NotImplementedError as e:
+            except NotImplementedError as exc:
                 raise Exception(
                     f"config signal {signal.name} must be connected before it is "
                     + "passed to the detector"
-                ) from e
+                ) from exc
 
     @AsyncStatus.wrap
     async def unstage(self) -> None:

ophyd_async/core/_device.py

@@ -13,7 +13,7 @@ from bluesky.run_engine import call_in_bluesky_event_loop, in_bluesky_event_loop
 from ._utils import (
     DEFAULT_TIMEOUT,
     LazyMock,
-    NotConnected,
+    NotConnectedError,
     error_if_none,
     wait_for_connection,
 )
@@ -51,10 +51,10 @@ class DeviceConnector:
         for name, child_device in device.children():
             try:
                 await child_device.connect(mock=mock.child(name))
-            except Exception as e:
-                exceptions[name] = e
+            except Exception as exc:
+                exceptions[name] = exc
         if exceptions:
-            raise NotConnected.with_other_exceptions_logged(exceptions)
+            raise NotConnectedError.with_other_exceptions_logged(exceptions)
 
     async def connect_real(self, device: Device, timeout: float, force_reconnect: bool):
         """Use during [](#Device.connect) with `mock=False`.
@@ -62,7 +62,7 @@ class DeviceConnector:
         This is called when there is no cached connect done in `mock=False`
         mode. It connects the Device and all its children in real mode in parallel.
         """
-        # Connect in parallel, gathering up NotConnected errors
+        # Connect in parallel, gathering up NotConnectedErrors
         coros = {
             name: child_device.connect(timeout=timeout, force_reconnect=force_reconnect)
             for name, child_device in device.children()
@@ -334,12 +334,12 @@ class DeviceProcessor:
         self._locals_on_exit = self._caller_locals()
         try:
             fut = call_in_bluesky_event_loop(self._on_exit())
-        except RuntimeError as e:
-            raise NotConnected(
+        except RuntimeError as exc:
+            raise NotConnectedError(
                 "Could not connect devices. Is the bluesky event loop running? See "
                 "https://blueskyproject.io/ophyd-async/main/"
                 "user/explanations/event-loop-choice.html for more info."
-            ) from e
+            ) from exc
         return fut
 
     async def _on_exit(self) -> None:
@@ -372,7 +372,7 @@ def init_devices(
     :param mock: If True, connect Signals in mock mode.
     :param timeout: How long to wait for connect before logging an exception.
     :raises RuntimeError: If used inside a plan, use [](#ensure_connected) instead.
-    :raises NotConnected: If devices could not be connected.
+    :raises NotConnectedError: If devices could not be connected.
 
     For example, to connect and name 2 motors in parallel:
     ```python

ophyd_async/core/_enums.py

@@ -19,3 +19,8 @@ class EnabledDisabled(StrictEnum):
 class InOut(StrictEnum):
     IN = "In"
     OUT = "Out"
+
+
+class YesNo(StrictEnum):
+    YES = "Yes"
+    NO = "No"

ophyd_async/core/_signal.py

@@ -39,8 +39,8 @@ from ._utils import (
 async def _wait_for(coro: Awaitable[T], timeout: float | None, source: str) -> T:
     try:
         return await asyncio.wait_for(coro, timeout)
-    except TimeoutError as e:
-        raise TimeoutError(source) from e
+    except TimeoutError as exc:
+        raise TimeoutError(source) from exc
 
 
 def _add_timeout(func):
@@ -117,17 +117,17 @@ class _SignalCache(Generic[SignalDatatypeT]):
     def __init__(self, backend: SignalBackend[SignalDatatypeT], signal: Signal) -> None:
         self._signal: Signal[Any] = signal
         self._staged = False
-        self._listeners: dict[Callback, bool] = {}
+        self._listeners: set[Callback] = set()
         self._valid = asyncio.Event()
         self._reading: Reading[SignalDatatypeT] | None = None
         self.backend: SignalBackend[SignalDatatypeT] = backend
         try:
             asyncio.get_running_loop()
-        except RuntimeError as e:
+        except RuntimeError as exc:
             raise RuntimeError(
                 "Need a running event loop to subscribe to a signal, "
                 "are you trying to run subscribe outside a plan?"
-            ) from e
+            ) from exc
         signal.log.debug(f"Making subscription on source {signal.source}")
         backend.set_callback(self._callback)
 
@@ -154,29 +154,29 @@ class _SignalCache(Generic[SignalDatatypeT]):
         )
         self._reading = reading
         self._valid.set()
-        items = self._listeners.copy().items()
-        for function, want_value in items:
-            self._notify(function, want_value)
+        # Copy the listeners in case one of the callbacks removes the listener
+        # from the set
+        for callback in list(self._listeners):
+            self._notify(callback)
 
     def _notify(
         self,
-        function: Callback[dict[str, Reading[SignalDatatypeT]] | SignalDatatypeT],
-        want_value: bool,
+        function: Callback[dict[str, Reading[SignalDatatypeT]]],
     ) -> None:
-        function(self._ensure_reading()["value"]) if want_value else function(
-            {self._signal.name: self._ensure_reading()}
-        )
+        function({self._signal.name: self._ensure_reading()})
 
-    def subscribe(self, function: Callback, want_value: bool) -> None:
-        self._listeners[function] = want_value
+    def subscribe(self, function: Callback) -> None:
+        self._listeners.add(function)
         if self._valid.is_set():
-            self._notify(function, want_value)
+            self._notify(function)
 
     def unsubscribe(self, function: Callback) -> bool:
-        _listener = self._listeners.pop(function, None)
-        if not _listener:
+        if function in self._listeners:
+            self._listeners.remove(function)
+        else:
             self._signal.log.warning(
-                f"Unsubscribe failed: subscriber {function} was not found "
+                f"Unsubscribe failed for signal {self._signal.name}:"
+                f" subscriber {function} was not found"
                 f" in listeners list: {list(self._listeners)}"
             )
         return self._staged or bool(self._listeners)
@@ -244,24 +244,19 @@ class SignalR(Signal[SignalDatatypeT], AsyncReadable, AsyncStageable, Subscribab
         self.log.debug(f"get_value() on source {self.source} returned {value}")
         return value
 
-    def subscribe_value(self, function: Callback[SignalDatatypeT]):
-        """Subscribe to updates in value of a device.
-
-        :param function: The callback function to call when the value changes.
-        """
-        self._get_cache().subscribe(function, want_value=True)
-
-    def subscribe(
+    def subscribe_reading(
         self, function: Callback[dict[str, Reading[SignalDatatypeT]]]
     ) -> None:
         """Subscribe to updates in the reading.
 
         :param function: The callback function to call when the reading changes.
         """
-        self._get_cache().subscribe(function, want_value=False)
+        self._get_cache().subscribe(function)
+
+    subscribe = subscribe_reading
 
     def clear_sub(self, function: Callback) -> None:
-        """Remove a subscription passed to `subscribe` or `subscribe_value`.
+        """Remove a subscription passed to `subscribe_reading`.
 
         :param function: The callback function to remove.
         """
@@ -402,7 +397,7 @@ async def observe_value(
     value being yielded, even if it is the same as the previous value.
 
     :param signal:
-        Call subscribe_value on this at the start, and clear_sub on it at the end.
+        Call subscribe_reading on this at the start, and clear_sub on it at the end.
     :param timeout:
         If given, how long to wait for each updated value in seconds. If an
         update is not produced in this time then raise asyncio.TimeoutError.
@@ -454,7 +449,7 @@ async def observe_signals_value(
     value being yielded, even if it is the same as the previous value.
 
     :param signals:
-        Call subscribe_value on all the signals at the start, and clear_sub on
+        Call subscribe_reading on all the signals at the start, and clear_sub on
         it at the end.
     :param timeout:
         If given, how long to wait for ANY updated value from shared queue in seconds.
@@ -486,11 +481,12 @@ async def observe_signals_value(
     # subscribe signal to update queue and fill cbs dict
     for signal in signals:
 
-        def queue_value(value: SignalDatatypeT, signal=signal):
+        def queue_value(reading: dict[str, Reading[SignalDatatypeT]], signal=signal):
+            value = reading[signal.name]["value"]
             q.put_nowait((signal, value))
 
         cbs[signal] = queue_value
-        signal.subscribe_value(queue_value)
+        signal.subscribe_reading(queue_value)
 
     if done_status is not None:
         done_status.add_callback(q.put_nowait)
@@ -543,11 +539,11 @@ class _ValueChecker(Generic[SignalDatatypeT]):
     ):
         try:
             await asyncio.wait_for(self._wait_for_value(signal), timeout)
-        except TimeoutError as e:
+        except TimeoutError as exc:
             raise TimeoutError(
                 f"{signal.name} didn't match {self._matcher_name} in {timeout}s, "
                 f"last value {self._last_value!r}"
-            ) from e
+            ) from exc
 
 
 async def wait_for_value(
@@ -558,7 +554,7 @@ async def wait_for_value(
     """Wait for a signal to have a matching value.
 
     :param signal:
-        Call subscribe_value on this at the start, and clear_sub on it at the
+        Call subscribe_reading on this at the start, and clear_sub on it at the
         end.
     :param match:
         If a callable, it should return True if the value matches. If not
@@ -642,11 +638,11 @@ async def set_and_wait_for_other_value(
             await asyncio.wait_for(_wait_for_value(), timeout)
             if wait_for_set_completion:
                 await status
-        except TimeoutError as e:
+        except TimeoutError as exc:
             raise TimeoutError(
                 f"{match_signal.name} value didn't match value from"
                 f" {matcher.__name__}() in {timeout}s"
-            ) from e
+            ) from exc
 
     return status
 

ophyd_async/core/_signal_backend.py

@@ -184,7 +184,9 @@ def _datakey_shape(value: SignalDatatype) -> list[int | None]:
     elif isinstance(value, Sequence | Table):
         return [len(value)]
     else:
-        raise TypeError(f"Can't make shape for {value}")
+        raise TypeError(
+            f"Can't make shape for {value} with SignalDataType: {type(value)}"
+        )
 
 
 def make_datakey(

ophyd_async/core/_status.py

@@ -55,8 +55,8 @@ class AsyncStatusBase(Status, Awaitable[None]):
         if self.task.done():
             try:
                 return self.task.exception()
-            except asyncio.CancelledError as e:
-                return e
+            except asyncio.CancelledError as exc:
+                return exc
         return None
 
     @property

ophyd_async/core/_table.py

@@ -13,6 +13,7 @@ TableSubclass = TypeVar("TableSubclass", bound="Table")
 
 
 def _concat(value1, value2):
+    """Concatenate two values, supports both NumPy arrays and generic types."""
     if isinstance(value1, np.ndarray):
         return np.concatenate((value1, value2))
     else:
@@ -20,6 +21,8 @@ def _concat(value1, value2):
 
 
 def _make_default_factory(dtype: np.dtype) -> Callable[[], np.ndarray]:
+    """Creates a default factory, returns an empty Numpy array of a specified dtype."""
+
     def numpy_array_default_factory() -> np.ndarray:
         return np.array([], dtype)
 
@@ -91,6 +94,11 @@ class Table(ConfinedModel):
                 raise TypeError(f"Cannot use annotation {anno} in a Table")
             cls.__annotations__[k] = new_anno
 
+    @classmethod
+    def empty(cls: type[TableSubclass]) -> TableSubclass:
+        """Makes an empty table with zero length columns."""
+        return cls()  # type: ignore
+
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
         cls = type(right)

ophyd_async/core/_utils.py

@@ -38,7 +38,7 @@ class UppercaseNameEnumMeta(EnumMeta):
 
 
 class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
-    def __call__(self, value, *args, **kwargs):  # type: ignore
+    def __call__(cls, value, *args, **kwargs):  # type: ignore
         """Return given value if it is a string and not a member of the enum.
 
         If the value is not a string or is an enum member, default enum behavior
@@ -54,7 +54,7 @@ class AnyStringUppercaseNameEnumMeta(UppercaseNameEnumMeta):
             member.
 
         """
-        if isinstance(value, str) and not isinstance(value, self):
+        if isinstance(value, str) and not isinstance(value, cls):
             return value
         return super().__call__(value, *args, **kwargs)
 
@@ -85,11 +85,11 @@ timeout itself
 CalculatableTimeout = float | None | Literal["CALCULATE_TIMEOUT"]
 
 
-class NotConnected(Exception):
+class NotConnectedError(Exception):
     """Exception to be raised if a `Device.connect` is cancelled.
 
     :param errors:
-        Mapping of device name to Exception or another NotConnected.
+        Mapping of device name to Exception or another NotConnectedError.
         Alternatively a string with the signal error text.
     """
 
@@ -106,7 +106,7 @@ class NotConnected(Exception):
             return {}
 
     def _format_sub_errors(self, name: str, error: Exception, indent="") -> str:
-        if isinstance(error, NotConnected):
+        if isinstance(error, NotConnectedError):
             error_txt = ":" + error.format_error_string(indent + self._indent_width)
         elif isinstance(error, Exception):
             error_txt = ": " + err_str + "\n" if (err_str := str(error)) else "\n"
@@ -138,15 +138,15 @@ class NotConnected(Exception):
     @classmethod
     def with_other_exceptions_logged(
         cls, exceptions: Mapping[str, Exception]
-    ) -> NotConnected:
+    ) -> NotConnectedError:
         for name, exception in exceptions.items():
-            if not isinstance(exception, NotConnected):
+            if not isinstance(exception, NotConnectedError):
                 logger.exception(
                     f"device `{name}` raised unexpected exception "
                     f"{type(exception).__name__}",
                     exc_info=exception,
                 )
-        return NotConnected(exceptions)
+        return NotConnectedError(exceptions)
 
 
 @dataclass(frozen=True)
@@ -192,8 +192,8 @@ async def wait_for_connection(**coros: Awaitable[None]):
         name, coro = coros.popitem()
         try:
             await coro
-        except Exception as e:
-            exceptions[name] = e
+        except Exception as exc:
+            exceptions[name] = exc
     else:
         # Use gather to connect in parallel
         results = await asyncio.gather(*coros.values(), return_exceptions=True)
@@ -202,7 +202,7 @@ async def wait_for_connection(**coros: Awaitable[None]):
                 exceptions[name] = result
 
     if exceptions:
-        raise NotConnected.with_other_exceptions_logged(exceptions)
+        raise NotConnectedError.with_other_exceptions_logged(exceptions)
 
 
 def get_dtype(datatype: type) -> np.dtype:

ophyd_async/epics/adcore/_core_logic.py

@@ -34,9 +34,11 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         self,
         driver: ADBaseIOT,
         good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
+        image_mode: ADImageMode = ADImageMode.MULTIPLE,
     ) -> None:
         self.driver: ADBaseIOT = driver
         self.good_states = good_states
+        self.image_mode = image_mode
         self.frame_timeout = DEFAULT_TIMEOUT
         self._arm_status: AsyncStatus | None = None
 
@@ -52,7 +54,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_exposures),
-            self.driver.image_mode.set(ADImageMode.MULTIPLE),
+            self.driver.image_mode.set(self.image_mode),
         )
 
     async def arm(self):

ophyd_async/epics/adcore/_utils.py

@@ -63,8 +63,8 @@ def convert_pv_dtype_to_np(datatype: str) -> str:
     else:
         try:
             np_datatype = convert_ad_dtype_to_np(_pvattribute_to_ad_datatype[datatype])
-        except KeyError as e:
-            raise ValueError(f"Invalid dbr type {datatype}") from e
+        except KeyError as exc:
+            raise ValueError(f"Invalid dbr type {datatype}") from exc
     return np_datatype
 
 
@@ -81,8 +81,8 @@ def convert_param_dtype_to_np(datatype: str) -> str:
             np_datatype = convert_ad_dtype_to_np(
                 _paramattribute_to_ad_datatype[datatype]
             )
-        except KeyError as e:
-            raise ValueError(f"Invalid datatype {datatype}") from e
+        except KeyError as exc:
+            raise ValueError(f"Invalid datatype {datatype}") from exc
     return np_datatype
 
 

ophyd_async/epics/core/_aioca.py

@@ -26,7 +26,7 @@ from event_model import DataKey, Limits, LimitsRange
 from ophyd_async.core import (
     Array1D,
     Callback,
-    NotConnected,
+    NotConnectedError,
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
@@ -272,7 +272,7 @@ class CaSignalBackend(EpicsSignalBackend[SignalDatatypeT]):
             )
         except CANothing as exc:
             logger.debug(f"signal ca://{pv} timed out")
-            raise NotConnected(f"ca://{pv}") from exc
+            raise NotConnectedError(f"ca://{pv}") from exc
 
     async def connect(self, timeout: float):
         _use_pyepics_context_if_imported()

ophyd_async/epics/core/_p4p.py

@@ -18,7 +18,7 @@ from pydantic import BaseModel
 from ophyd_async.core import (
     Array1D,
     Callback,
-    NotConnected,
+    NotConnectedError,
     SignalDatatype,
     SignalDatatypeT,
     SignalMetadata,
@@ -328,7 +328,7 @@ async def pvget_with_timeout(pv: str, timeout: float) -> Any:
         return await asyncio.wait_for(context().get(pv), timeout=timeout)
     except TimeoutError as exc:
         logger.debug(f"signal pva://{pv} timed out", exc_info=True)
-        raise NotConnected(f"pva://{pv}") from exc
+        raise NotConnectedError(f"pva://{pv}") from exc
 
 
 def _pva_request_string(fields: Sequence[str]) -> str:

ophyd_async/epics/motor.py

@@ -32,15 +32,34 @@ from ophyd_async.core import (
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
-__all__ = ["MotorLimitsException", "Motor"]
+__all__ = ["MotorLimitsError", "Motor"]
 
 
-class MotorLimitsException(Exception):
+class MotorLimitsError(Exception):
     """Exception for invalid motor limits."""
 
     pass
 
 
+# Back compat - delete before 1.0
+def __getattr__(name):
+    import warnings
+
+    renames = {
+        "MotorLimitsException": MotorLimitsError,
+    }
+    rename = renames.get(name)
+    if rename is not None:
+        warnings.warn(
+            DeprecationWarning(
+                f"{name!r} is deprecated, use {rename.__name__!r} instead"
+            ),
+            stacklevel=2,
+        )
+        return rename
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 class OffsetMode(StrictEnum):
     VARIABLE = "Variable"
     FROZEN = "Frozen"
@@ -126,7 +145,7 @@ class Motor(
             not motor_upper_limit >= abs_start_pos >= motor_lower_limit
             or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
         ):
-            raise MotorLimitsException(
+            raise MotorLimitsError(
                 f"{self.name} motor trajectory for requested fly/move is from "
                 f"{abs_start_pos}{egu} to "
                 f"{abs_end_pos}{egu} but motor limits are "
@@ -144,7 +163,7 @@ class Motor(
             self.max_velocity.get_value(), self.motor_egu.get_value()
         )
         if abs(value.velocity) > max_speed:
-            raise MotorLimitsException(
+            raise MotorLimitsError(
                 f"Velocity {abs(value.velocity)} {egu}/s was requested for a motor "
                 f" with max speed of {max_speed} {egu}/s"
             )
@@ -242,9 +261,11 @@ class Motor(
         )
         return Location(setpoint=setpoint, readback=readback)
 
-    def subscribe(self, function: Callback[dict[str, Reading[float]]]) -> None:
-        """Subscribe."""
-        self.user_readback.subscribe(function)
+    def subscribe_reading(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        """Subscribe to reading."""
+        self.user_readback.subscribe_reading(function)
+
+    subscribe = subscribe_reading
 
     def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
         """Unsubscribe."""

ophyd_async/epics/pmac/_pmac_io.py

@@ -4,7 +4,7 @@ import numpy as np
 
 from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
 from ophyd_async.epics import motor
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 CS_LETTERS = "ABCUVWXYZ"
 
@@ -40,11 +40,15 @@ class PmacTrajectoryIO(StandardReadable):
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
+        self.total_points = epics_signal_r(int, f"{prefix}TotalPoints_RBV")
         self.points_to_build = epics_signal_rw(int, prefix + "ProfilePointsToBuild")
-        self.build_profile = epics_signal_rw(bool, prefix + "ProfileBuild")
+        self.build_profile = epics_signal_x(prefix + "ProfileBuild")
+        self.append_profile = epics_signal_x(prefix + "ProfileAppend")
+        # This should be a SignalX, but because it is a Busy record, must
+        # be a SignalRW to be waited on in PmacTrajectoryTriggerLogic.
+        # TODO: Change record type to bo from busy (https://github.com/DiamondLightSource/pmac/issues/154)
         self.execute_profile = epics_signal_rw(bool, prefix + "ProfileExecute")
-        self.scan_percent = epics_signal_r(float, prefix + "TscanPercent_RBV")
-        self.abort_profile = epics_signal_rw(bool, prefix + "ProfileAbort")
+        self.abort_profile = epics_signal_x(prefix + "ProfileAbort")
         self.profile_cs_name = epics_signal_rw(str, prefix + "ProfileCsName")
         self.calculate_velocities = epics_signal_rw(bool, prefix + "ProfileCalcVel")