ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/epics/demo/_point_detector_channel.py

@@ -0,0 +1,22 @@
+from typing import Annotated as A
+
+from ophyd_async.core import SignalR, SignalRW, StandardReadable, StrictEnum
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+
+class EnergyMode(StrictEnum):
+    """Energy mode for `DemoPointDetectorChannel`."""
+
+    LOW = "Low Energy"
+    """Low energy mode"""
+
+    HIGH = "High Energy"
+    """High energy mode"""
+
+
+class DemoPointDetectorChannel(StandardReadable, EpicsDevice):
+    """A channel for `DemoPointDetector` with int value based on X and Y Motors."""
+
+    value: A[SignalR[int], PvSuffix("Value"), Format.HINTED_UNCACHED_SIGNAL]
+    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]

ophyd_async/epics/demo/_stage.py

@@ -0,0 +1,15 @@
+from ophyd_async.core import StandardReadable
+
+from ._motor import DemoMotor
+
+
+class DemoStage(StandardReadable):
+    """A simulated sample stage with X and Y movables."""
+
+    def __init__(self, prefix: str, name="") -> None:
+        # Define some child Devices
+        with self.add_children_as_readables():
+            self.x = DemoMotor(prefix + "X:")
+            self.y = DemoMotor(prefix + "Y:")
+        # Set name of device and child devices
+        super().__init__(name=name)

ophyd_async/epics/{sim/mover.db → demo/motor.db}

@@ -10,7 +10,8 @@ record(ao, "$(P)Velocity") {
     field(PREC, "$(PREC=3)")
     field(PINI, "YES")
     field(EGU,  "$(EGU=mm)/s")
-    field(VAL,  "$(VELO=100)")
+    field(VAL,  "$(VELO=1)")
+    field(DRVL, "0")
 }
 
 record(calc, "$(P)VelocityDiv") {

ophyd_async/epics/demo/point_detector.db

@@ -0,0 +1,59 @@
+record(ao, "$(P)AcquireTime") {
+    field(DESC, "Time to acquire for")
+    field(VAL, "0.1")
+    field(OUT, "$(P)Start.DLY2")
+    field(PINI, "YES")
+}
+
+record(seq, "$(P)Start") {
+    field(DESC, "Start sequence")
+    # Grab the start time
+    field(LNK0, "$(P)StartTime.PROC")
+    # Set it to be acquiring
+    field(LNK1, "$(P)Acquiring PP")
+    field(DO1, "1")
+    # Set it back to idle
+    field(LNK2, "$(P)Acquiring PP")
+    field(DO2, "0")
+    # Set the elapsed time to the full acquire time
+    field(LNK3, "$(P)Elapsed PP")
+    field(DOL3, "$(P)AcquireTime")
+}
+
+record(ai, "$(P)StartTime") {
+    field(DTYP, "Soft Timestamp")
+}
+
+record(bi, "$(P)Acquiring") {
+    field(DESC, "Currently acquiring")
+    field(ZNAM, "Idle")
+    field(ONAM, "Acquiring")
+    field(PINI, "YES")
+}
+
+record(ai, "$(P)CurrentTime") {
+    field(DTYP, "Soft Timestamp")
+}
+
+record(calcout, "$(P)Process") {
+    field(DESC, "Process elapsed time if acquiring")
+    field(INPA, "$(P)StartTime")
+    field(INPB, "$(P)CurrentTime PP")
+    field(SCAN, ".1 second")
+    field(CALC, "B-A")
+    field(OUT, "$(P)Elapsed PP")
+    field(SDIS, "$(P)Acquiring")
+    field(DISV, "0")
+}
+
+record(ai, "$(P)Elapsed") {
+    field(DESC, "Elapsed time")
+    field(EGU,  "s")
+    field(PREC, "1")
+    field(PINI, "YES")
+}
+
+record(calcout, "$(P)Reset") {
+    field(OUT, "$(P)Elapsed PP")
+    field(CALC, "0")
+}

ophyd_async/epics/demo/point_detector_channel.db

@@ -0,0 +1,21 @@
+record(mbbo, "$(P)$(CHANNEL):Mode") {
+    field(DESC, "Energy sensitivity of the image")
+    field(DTYP, "Raw Soft Channel")
+    field(PINI, "YES")
+    field(ZRVL, "10")
+    field(ZRST, "Low Energy")
+    field(ONVL, "100")
+    field(ONST, "High Energy")
+}
+
+record(calc, "$(P)$(CHANNEL):Value") {
+    field(DESC, "Sensor value simulated from X and Y")
+    field(INPA,  "$(X)Readback")
+    field(INPB,  "$(Y)Readback")
+    field(INPC,  "$(CHANNEL)")
+    field(INPD,  "$(P)$(CHANNEL):Mode.RVAL")
+    field(INPE,  "$(P)Elapsed CP")
+    field(CALC, "FLOOR((SIN(A)**C+COS(A*B+D)+2)*2500*E)")
+    field(EGU,  "cts")
+    field(PREC, "0")
+}

ophyd_async/epics/eiger/_eiger.py

@@ -12,9 +12,7 @@ class EigerTriggerInfo(TriggerInfo):
 
 
 class EigerDetector(StandardDetector):
-    """
-    Ophyd-async implementation of an Eiger Detector.
-    """
+    """Ophyd-async implementation of an Eiger Detector."""
 
     _controller: EigerController
     _writer: Odin

ophyd_async/epics/eiger/_eiger_controller.py

@@ -2,6 +2,7 @@ import asyncio
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
+    AsyncStatus,
     DetectorController,
     DetectorTrigger,
     TriggerInfo,
@@ -19,19 +20,24 @@ EIGER_TRIGGER_MODE_MAP = {
 
 
 class EigerController(DetectorController):
+    """Controller for the Eiger detector."""
+
     def __init__(
         self,
         driver: EigerDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
         return 0.0001
 
     async def set_energy(self, energy: float, tolerance: float = 0.1):
-        """Changing photon energy takes some time so only do so if the current energy is
-        outside the tolerance."""
+        """Change photon energy if outside tolerance.
+
+        It takes some time so don't do it unless it is outside tolerance.
+        """
         current_energy = await self._drv.photon_energy.get_value()
         if abs(current_energy - energy) > tolerance:
             await self._drv.photon_energy.set(energy)
@@ -54,7 +60,7 @@ class EigerController(DetectorController):
 
     async def arm(self):
         # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
-        self._arm_status = set_and_wait_for_other_value(
+        self._arm_status = await set_and_wait_for_other_value(
             self._drv.arm,
             1,
             self._drv.state,
@@ -64,8 +70,9 @@ class EigerController(DetectorController):
         )
 
     async def wait_for_idle(self):
-        if self._arm_status:
+        if self._arm_status and not self._arm_status.done:
             await self._arm_status
+        self._arm_status = None
 
     async def disarm(self):
         await self._drv.disarm.set(1)

ophyd_async/epics/eiger/_eiger_io.py

@@ -9,6 +9,8 @@ class EigerTriggerMode(StrictEnum):
 
 
 class EigerDriverIO(Device):
+    """Contains signals for handling IO on the Eiger detector."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.bit_depth = epics_signal_r(int, f"{prefix}BitDepthReadout")
         self.stale_parameters = epics_signal_r(bool, f"{prefix}StaleParameters")

ophyd_async/epics/eiger/_odin_io.py

@@ -5,7 +5,6 @@ from bluesky.protocols import StreamAsset
 from event_model import DataKey
 
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     DetectorWriter,
     Device,
     DeviceVector,
@@ -110,7 +109,7 @@ class OdinWriter(DetectorWriter):
         }
 
     async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
+        self, timeout: float
     ) -> AsyncGenerator[int, None]:
         async for num_captured in observe_value(self._drv.num_captured, timeout):
             yield num_captured

ophyd_async/epics/motor.py

@@ -1,3 +1,8 @@
+"""Support for EPICS motor record.
+
+https://github.com/epics-modules/motor
+"""
+
 import asyncio
 
 from bluesky.protocols import (
@@ -5,7 +10,9 @@ from bluesky.protocols import (
     Locatable,
     Location,
     Preparable,
+    Reading,
     Stoppable,
+    Subscribable,
 )
 from pydantic import BaseModel, Field
 
@@ -14,7 +21,9 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
+    Callback,
     StandardReadable,
+    StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
@@ -22,41 +31,54 @@ 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", "FlyMotorInfo", "Motor"]
 
-class MotorLimitsException(Exception):
-    pass
 
+class MotorLimitsException(Exception):
+    """Exception for invalid motor limits."""
 
-class InvalidFlyMotorException(Exception):
     pass
 
 
-DEFAULT_MOTOR_FLY_TIMEOUT = 60
-DEFAULT_WATCHER_UPDATE_FREQUENCY = 0.2
-
-
 class FlyMotorInfo(BaseModel):
-    """Minimal set of information required to fly a motor:"""
+    """Minimal set of information required to fly a motor."""
 
-    #: Absolute position of the motor once it finishes accelerating to desired
-    #: velocity, in motor EGUs
     start_position: float = Field(frozen=True)
+    """Absolute position of the motor once it finishes accelerating to desired
+    velocity, in motor EGUs"""
 
-    #: Absolute position of the motor once it begins decelerating from desired
-    #: velocity, in EGUs
     end_position: float = Field(frozen=True)
+    """Absolute position of the motor once it begins decelerating from desired
+    velocity, in EGUs"""
 
-    #: Time taken for the motor to get from start_position to end_position, excluding
-    #: run-up and run-down, in seconds.
     time_for_move: float = Field(frozen=True, gt=0)
+    """Time taken for the motor to get from start_position to end_position, excluding
+    run-up and run-down, in seconds."""
 
-    #: Maximum time for the complete motor move, including run up and run down.
-    #: Defaults to `time_for_move` + run up and run down times + 10s.
     timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
+    """Maximum time for the complete motor move, including run up and run down.
+    Defaults to `time_for_move` + run up and run down times + 10s."""
+
+
+class OffsetMode(StrictEnum):
+    VARIABLE = "Variable"
+    FROZEN = "Frozen"
+
 
+class UseSetMode(StrictEnum):
+    USE = "Use"
+    SET = "Set"
 
-class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
-    """Device that moves a motor record"""
+
+class Motor(
+    StandardReadable,
+    Locatable[float],
+    Stoppable,
+    Flyable,
+    Preparable,
+    Subscribable[float],
+):
+    """Device that moves a motor record."""
 
     def __init__(self, prefix: str, name="") -> None:
         # Define some signals
@@ -76,11 +98,16 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self.motor_done_move = epics_signal_r(int, prefix + ".DMOV")
         self.low_limit_travel = epics_signal_rw(float, prefix + ".LLM")
         self.high_limit_travel = epics_signal_rw(float, prefix + ".HLM")
+        self.offset_freeze_switch = epics_signal_rw(OffsetMode, prefix + ".FOFF")
+        self.high_limit_switch = epics_signal_r(int, prefix + ".HLS")
+        self.low_limit_switch = epics_signal_r(int, prefix + ".LLS")
+        self.set_use_switch = epics_signal_rw(UseSetMode, prefix + ".SET")
 
         # Note:cannot use epics_signal_x here, as the motor record specifies that
         # we must write 1 to stop the motor. Simply processing the record is not
         # sufficient.
         self.motor_stop = epics_signal_w(int, prefix + ".STOP")
+
         # Whether set() should complete successfully or not
         self._set_success = True
 
@@ -96,15 +123,14 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         super().__init__(name=name)
 
     def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
+        """Set name of the motor and its children."""
         super().set_name(name, child_name_separator=child_name_separator)
         # Readback should be named the same as its parent in read()
         self.user_readback.set_name(name)
 
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
-        """Calculate required velocity and run-up distance, then if motor limits aren't
-        breached, move to start position minus run-up distance"""
-
+        """Move to the beginning of a suitable run-up distance ready for a flyscan."""
         self._fly_timeout = value.timeout
 
         # Velocity, at which motor travels from start_position to end_position, in motor
@@ -142,8 +168,10 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
-    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
-        new_position = value
+    async def set(  # type: ignore
+        self, new_position: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT
+    ):
+        """Move motor to the given value."""
         self._set_success = True
         (
             old_position,
@@ -186,6 +214,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             raise RuntimeError("Motor was stopped")
 
     async def stop(self, success=False):
+        """Request to stop moving and return immediately."""
         self._set_success = success
         # Put with completion will never complete as we are waiting for completion on
         # the move above, so need to pass wait=False
@@ -208,11 +237,19 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return fly_velocity
 
     async def locate(self) -> Location[float]:
-        location: Location = {
-            "setpoint": await self.user_setpoint.get_value(),
-            "readback": await self.user_readback.get_value(),
-        }
-        return location
+        """Return the current setpoint and readback of the motor."""
+        setpoint, readback = await asyncio.gather(
+            self.user_setpoint.get_value(), self.user_readback.get_value()
+        )
+        return Location(setpoint=setpoint, readback=readback)
+
+    def subscribe(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        """Subscribe."""
+        self.user_readback.subscribe(function)
+
+    def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
+        """Unsubscribe."""
+        self.user_readback.clear_sub(function)
 
     async def _prepare_motor_path(
         self, fly_velocity: float, start_position: float, end_position: float

ophyd_async/epics/signal.py

@@ -1,4 +1,5 @@
-# back compat
+"""Back compat."""
+
 import warnings
 
 from .core import *  # noqa: F403
@@ -9,3 +10,5 @@ warnings.warn(
     ),
     stacklevel=2,
 )
+
+__all__ = []

ophyd_async/epics/testing/_example_ioc.py

@@ -15,35 +15,43 @@ PVA_RECORDS = Path(__file__).parent / "test_records_pva.db"
 
 
 class EpicsTestEnum(StrictEnum):
+    """For testing strict enum values in test IOCs."""
+
     A = "Aaa"
     B = "Bbb"
     C = "Ccc"
 
 
 class EpicsTestSubsetEnum(SubsetEnum):
+    """For testing subset enum values in test IOCs."""
+
     A = "Aaa"
     B = "Bbb"
 
 
 class EpicsTestTable(Table):
-    bool: Array1D[np.bool_]
-    int: Array1D[np.int32]
-    float: Array1D[np.float64]
-    str: Sequence[str]
-    enum: Sequence[EpicsTestEnum]
+    a_bool: Array1D[np.bool_]
+    a_int: Array1D[np.int32]
+    a_float: Array1D[np.float64]
+    a_str: Sequence[str]
+    a_enum: Sequence[EpicsTestEnum]
 
 
 class EpicsTestCaDevice(EpicsDevice):
-    my_int: A[SignalRW[int], PvSuffix("int")]
-    my_float: A[SignalRW[float], PvSuffix("float")]
+    """Device for use in a channel access test IOC."""
+
+    a_int: A[SignalRW[int], PvSuffix("int")]
+    """A thing"""
+    a_float: A[SignalRW[float], PvSuffix("float")]
     float_prec_0: A[SignalRW[int], PvSuffix("float_prec_0")]
-    my_str: A[SignalRW[str], PvSuffix("str")]
+    a_str: A[SignalRW[str], PvSuffix("str")]
     longstr: A[SignalRW[str], PvSuffix("longstr")]
     longstr2: A[SignalRW[str], PvSuffix("longstr2.VAL$")]
-    my_bool: A[SignalRW[bool], PvSuffix("bool")]
+    a_bool: A[SignalRW[bool], PvSuffix("bool")]
     enum: A[SignalRW[EpicsTestEnum], PvSuffix("enum")]
     enum2: A[SignalRW[EpicsTestEnum], PvSuffix("enum2")]
     subset_enum: A[SignalRW[EpicsTestSubsetEnum], PvSuffix("subset_enum")]
+    enum_str_fallback: A[SignalRW[str], PvSuffix("enum_str_fallback")]
     bool_unnamed: A[SignalRW[bool], PvSuffix("bool_unnamed")]
     partialint: A[SignalRW[int], PvSuffix("partialint")]
     lessint: A[SignalRW[int], PvSuffix("lessint")]
@@ -56,6 +64,8 @@ class EpicsTestCaDevice(EpicsDevice):
 
 
 class EpicsTestPvaDevice(EpicsTestCaDevice):
+    """Device for use in a pv access test IOC."""
+
     # pva can support all signal types that ca can
     int8a: A[SignalRW[Array1D[np.int8]], PvSuffix("int8a")]
     uint16a: A[SignalRW[Array1D[np.uint16]], PvSuffix("uint16a")]
@@ -67,6 +77,8 @@ class EpicsTestPvaDevice(EpicsTestCaDevice):
 
 
 class EpicsTestIocAndDevices:
+    """Test IOC with ca and pva devices."""
+
     def __init__(self):
         self.prefix = generate_random_pv_prefix()
         self.ioc = TestingIOC()

ophyd_async/epics/testing/_utils.py

@@ -7,10 +7,13 @@ from pathlib import Path
 
 
 def generate_random_pv_prefix() -> str:
+    """For generating random PV names in test devices."""
     return "".join(random.choice(string.ascii_lowercase) for _ in range(12)) + ":"
 
 
 class TestingIOC:
+    """For initialising an IOC in tests."""
+
     def __init__(self):
         self._db_macros: list[tuple[Path, dict[str, str]]] = []
         self.output = ""

ophyd_async/epics/testing/test_records.db

@@ -104,6 +104,14 @@ record(mbbo, "$(device)subset_enum") {
   field(PINI, "YES")
 }
 
+record(mbbo, "$(device)enum_str_fallback") {
+  field(ZRST, "Aaa")
+  field(ONST, "Bbb")
+  field(TWST, "Ccc")
+  field(VAL, "1")
+  field(PINI, "YES")
+}
+
 record(waveform, "$(device)uint8a") {
   field(NELM, "3")
   field(FTVL, "UCHAR")

ophyd_async/epics/testing/test_records_pva.db

@@ -1,36 +1,37 @@
 record(waveform, "$(device)int8a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "CHAR")
-  field(INP, {const:[-128, 127]})
+  field(INP, {const:[-128, 127, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint16a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "USHORT")
-  field(INP, {const:[0, 65535]})
+  field(INP, {const:[0, 65535, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint32a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "ULONG")
-  field(INP, {const:[0, 4294967295]})
+  field(INP, {const:[0, 4294967295, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)int64a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "INT64")
-  # Can't do 64-bit int with JSON numbers in a const link...
-  field(INP, {const:[-2147483649, 2147483648]})
+  # limit of range appears to be +/-(2^63 - 1)
+  field(INP, {const:[-9223372036854775807, 9223372036854775807, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
 record(waveform, "$(device)uint64a") {
-  field(NELM, "3")
+  field(NELM, "7")
   field(FTVL, "UINT64")
-  field(INP, {const:[0, 4294967297]})
+  # limit of range appears to be 0 to +(2^63 - 1)
+  field(INP, {const:[0, 9223372036854775807, 0, 1, 2, 3, 4]})
   field(PINI, "YES")
 }
 
@@ -58,7 +59,7 @@ record(waveform, "$(device)table:bool")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.bool": {
+            "value.a_bool": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 1
@@ -75,7 +76,7 @@ record(waveform, "$(device)table:int")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.int": {
+            "value.a_int": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 2
@@ -92,7 +93,7 @@ record(waveform, "$(device)table:float")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.float": {
+            "value.a_float": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 3
@@ -109,7 +110,7 @@ record(waveform, "$(device)table:str")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.str": {
+            "value.a_str": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 4
@@ -126,7 +127,7 @@ record(waveform, "$(device)table:enum")
     field(PINI, "YES")
     info(Q:group, {
         "$(device)table": {
-            "value.enum": {
+            "value.a_enum": {
                 "+type": "plain",
                 "+channel": "VAL",
                 "+putorder": 5,

ophyd_async/fastcs/__init__.py

@@ -0,0 +1 @@
+"""FastCS support for Signals via EPICS or Tango, and Devices that use them."""

ophyd_async/fastcs/core.py

@@ -1,9 +1,15 @@
+"""FastCS core module for ophyd-async."""
+
 from ophyd_async.core import Device, DeviceConnector
 from ophyd_async.epics.core import PviDeviceConnector
 
 
 def fastcs_connector(device: Device, uri: str, error_hint: str = "") -> DeviceConnector:
+    """Create devices and connections on pvi device `Device`."""
     # TODO: add Tango support based on uri scheme
     connector = PviDeviceConnector(uri, error_hint)
     connector.create_children_from_annotations(device)
     return connector
+
+
+__all__ = ["fastcs_connector"]

ophyd_async/fastcs/odin/__init__.py

@@ -0,0 +1 @@
+__all__ = []

ophyd_async/fastcs/panda/__init__.py

@@ -1,13 +1,14 @@
 from ._block import (
-    BitMux,
     CommonPandaBlocks,
     DataBlock,
+    PandaBitMux,
+    PandaCaptureMode,
+    PandaPcompDirection,
+    PandaTimeUnits,
     PcapBlock,
     PcompBlock,
-    PcompDirection,
     PulseBlock,
     SeqBlock,
-    TimeUnits,
 )
 from ._control import PandaPcapController
 from ._hdf_panda import HDFPanda
@@ -28,13 +29,14 @@ from ._writer import PandaHDFWriter
 __all__ = [
     "CommonPandaBlocks",
     "DataBlock",
-    "BitMux",
+    "PandaBitMux",
+    "PandaCaptureMode",
     "PcapBlock",
     "PcompBlock",
-    "PcompDirection",
+    "PandaPcompDirection",
     "PulseBlock",
     "SeqBlock",
-    "TimeUnits",
+    "PandaTimeUnits",
     "HDFPanda",
     "PandaHDFWriter",
     "PandaPcapController",