ophyd-async 0.3a6__tar.gz → 0.3.1__tar.gz

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ophyd-async
-Version: 0.3a6
+Version: 0.3.1
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -96,7 +96,7 @@ Requires-Dist: types-pyyaml; extra == "dev"
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/README.md

@@ -5,7 +5,7 @@
 
 # ophyd-async
 
-Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
+Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango.
 
 |    Source     |     <https://github.com/bluesky/ophyd-async>      |
 | :-----------: | :-----------------------------------------------: |

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/docs/how-to/write-tests-for-devices.rst

@@ -41,6 +41,11 @@ In addition this example also utilizes helper functions like ``assert_reading``
    :pyobject: test_sensor_reading_shows_value
 
 
+Given that the mock signal holds a ``unittest.mock.Mock`` object you can retrieve this object and assert that the device has been set correctly using ``get_mock_put``. You are also free to use any other behaviour that ``unittest.mock.Mock`` provides, such as in this example which sets the parent of the mock to allow ordering across signals to be asserted:
+
+.. literalinclude:: ../../tests/epics/demo/test_demo.py
+   :pyobject: test_retrieve_mock_and_assert
+
 There are several other test utility functions:
 
 Use ``callback_on_mock_put``, for hooking in logic when a mock value changes (e.g. because someone puts to it). This can be called directly, or used as a context, with the callbacks ending after exit.

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3a6'
-__version_tuple__ = version_tuple = (0, 3)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/__init__.py

@@ -24,12 +24,10 @@ from .device_save_loader import (
     walk_rw_signals,
 )
 from .flyer import HardwareTriggeredFlyable, TriggerLogic
-from .mock_signal_backend import (
-    MockSignalBackend,
-)
+from .mock_signal_backend import MockSignalBackend
 from .mock_signal_utils import (
-    assert_mock_put_called_with,
     callback_on_mock_put,
+    get_mock_put,
     mock_puts_blocked,
     reset_mock_put_calls,
     set_mock_put_proceeds,
@@ -70,7 +68,7 @@ from .utils import (
 )
 
 __all__ = [
-    "assert_mock_put_called_with",
+    "get_mock_put",
     "callback_on_mock_put",
     "mock_puts_blocked",
     "set_mock_values",

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/detector.py

@@ -63,6 +63,8 @@ class TriggerInfo:
     deadtime: float
     #: What is the maximum high time of the triggers
     livetime: float
+    #: What is the maximum timeout on waiting for a frame
+    frame_timeout: float | None = None
 
 
 class DetectorControl(ABC):
@@ -162,7 +164,6 @@ class StandardDetector(
         writer: DetectorWriter,
         config_sigs: Sequence[AsyncReadable] = (),
         name: str = "",
-        writer_timeout: float = DEFAULT_TIMEOUT,
     ) -> None:
         """
         Constructor
@@ -173,16 +174,11 @@ class StandardDetector(
             config_sigs: Signals to read when describe and read
             configuration are called. Defaults to ().
             name: Device name. Defaults to "".
-            writer_timeout: Timeout for frame writing to start, if the
-            timeout is reached, ophyd-async assumes the detector
-            has a problem and raises an error.
-            Defaults to DEFAULT_TIMEOUT.
         """
         self._controller = controller
         self._writer = writer
         self._describe: Dict[str, DataKey] = {}
         self._config_sigs = list(config_sigs)
-        self._frame_writing_timeout = writer_timeout
         # For prepare
         self._arm_status: Optional[AsyncStatus] = None
         self._trigger_info: Optional[TriggerInfo] = None
@@ -245,17 +241,21 @@ class StandardDetector(
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
+        # set default trigger_info
+        self._trigger_info = TriggerInfo(
+            num=1, trigger=DetectorTrigger.internal, deadtime=0.0, livetime=0.0
+        )
         # Arm the detector and wait for it to finish.
         indices_written = await self.writer.get_indices_written()
         written_status = await self.controller.arm(
-            num=1,
-            trigger=DetectorTrigger.internal,
+            num=self._trigger_info.num,
+            trigger=self._trigger_info.trigger,
         )
         await written_status
         end_observation = indices_written + 1
 
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            DEFAULT_TIMEOUT + self._trigger_info.livetime + self._trigger_info.deadtime
         ):
             if index >= end_observation:
                 break
@@ -309,7 +309,12 @@ class StandardDetector(
         assert self._arm_status, "Prepare not run"
         assert self._trigger_info
         async for index in self.writer.observe_indices_written(
-            self._frame_writing_timeout
+            self._trigger_info.frame_timeout
+            or (
+                DEFAULT_TIMEOUT
+                + self._trigger_info.livetime
+                + self._trigger_info.deadtime
+            )
         ):
             yield WatcherUpdate(
                 name=self.name,

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/device_save_loader.py

@@ -1,6 +1,5 @@
 from enum import Enum
-from functools import partial
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Sequence
 
 import numpy as np
 import numpy.typing as npt
@@ -8,13 +7,10 @@ import yaml
 from bluesky.plan_stubs import abs_set, wait
 from bluesky.protocols import Location
 from bluesky.utils import Msg
-from epicscorelibs.ca.dbr import ca_array, ca_float, ca_int, ca_str
 
 from .device import Device
 from .signal import SignalRW
 
-CaType = Union[ca_float, ca_int, ca_str, ca_array]
-
 
 def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.Node:
     return dumper.represent_sequence(
@@ -22,19 +18,6 @@ def ndarray_representer(dumper: yaml.Dumper, array: npt.NDArray[Any]) -> yaml.No
     )
 
 
-def ca_dbr_representer(dumper: yaml.Dumper, value: CaType) -> yaml.Node:
-    # if it's an array, just call ndarray_representer...
-    represent_array = partial(ndarray_representer, dumper)
-
-    representers: Dict[CaType, Callable[[CaType], yaml.Node]] = {
-        ca_float: dumper.represent_float,
-        ca_int: dumper.represent_int,
-        ca_str: dumper.represent_str,
-        ca_array: represent_array,
-    }
-    return representers[type(value)](value)
-
-
 class OphydDumper(yaml.Dumper):
     def represent_data(self, data: Any) -> Any:
         if isinstance(data, Enum):
@@ -152,11 +135,6 @@ def save_to_yaml(phases: Sequence[Dict[str, Any]], save_path: str) -> None:
 
     yaml.add_representer(np.ndarray, ndarray_representer, Dumper=yaml.Dumper)
 
-    yaml.add_representer(ca_float, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_int, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_str, ca_dbr_representer, Dumper=yaml.Dumper)
-    yaml.add_representer(ca_array, ca_dbr_representer, Dumper=yaml.Dumper)
-
     with open(save_path, "w") as file:
         yaml.dump(phases, file, Dumper=OphydDumper, default_flow_style=False)
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/mock_signal_backend.py

@@ -1,6 +1,6 @@
 import asyncio
 from functools import cached_property
-from typing import Optional, Type
+from typing import Callable, Optional, Type
 from unittest.mock import Mock
 
 from bluesky.protocols import Descriptor, Reading
@@ -10,7 +10,7 @@ from ophyd_async.core.soft_signal_backend import SoftSignalBackend
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, ReadingValueCallback, T
 
 
-class MockSignalBackend(SignalBackend):
+class MockSignalBackend(SignalBackend[T]):
     def __init__(
         self,
         datatype: Optional[Type[T]] = None,
@@ -31,11 +31,11 @@ class MockSignalBackend(SignalBackend):
 
         if not isinstance(self.initial_backend, SoftSignalBackend):
             # If the backend is a hard signal backend, or not provided,
-            # then we create a soft signal to mimick it
+            # then we create a soft signal to mimic it
 
             self.soft_backend = SoftSignalBackend(datatype=datatype)
         else:
-            self.soft_backend = initial_backend
+            self.soft_backend = self.initial_backend
 
     def source(self, name: str) -> str:
         if self.initial_backend:
@@ -47,7 +47,7 @@ class MockSignalBackend(SignalBackend):
 
     @cached_property
     def put_mock(self) -> Mock:
-        return Mock(name="put")
+        return Mock(name="put", spec=Callable)
 
     @cached_property
     def put_proceeds(self) -> asyncio.Event:
@@ -65,9 +65,6 @@ class MockSignalBackend(SignalBackend):
     def set_value(self, value: T):
         self.soft_backend.set_value(value)
 
-    async def get_descriptor(self, source: str) -> Descriptor:
-        return await self.soft_backend.get_descriptor(source)
-
     async def get_reading(self) -> Reading:
         return await self.soft_backend.get_reading()
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/mock_signal_utils.py

@@ -1,6 +1,6 @@
 from contextlib import asynccontextmanager, contextmanager
-from typing import Any, Callable, Iterable, Iterator, List
-from unittest.mock import ANY, Mock
+from typing import Any, Callable, Iterable
+from unittest.mock import Mock
 
 from ophyd_async.core.signal import Signal
 from ophyd_async.core.utils import T
@@ -22,7 +22,7 @@ def set_mock_value(signal: Signal[T], value: T):
     backend.set_value(value)
 
 
-def set_mock_put_proceeds(signal: Signal[T], proceeds: bool):
+def set_mock_put_proceeds(signal: Signal, proceeds: bool):
     """Allow or block a put with wait=True from proceeding"""
     backend = _get_mock_signal_backend(signal)
 
@@ -33,7 +33,7 @@ def set_mock_put_proceeds(signal: Signal[T], proceeds: bool):
 
 
 @asynccontextmanager
-async def mock_puts_blocked(*signals: List[Signal]):
+async def mock_puts_blocked(*signals: Signal):
     for signal in signals:
         set_mock_put_proceeds(signal, False)
     yield
@@ -41,9 +41,9 @@ async def mock_puts_blocked(*signals: List[Signal]):
         set_mock_put_proceeds(signal, True)
 
 
-def assert_mock_put_called_with(signal: Signal, value: Any, wait=ANY, timeout=ANY):
-    backend = _get_mock_signal_backend(signal)
-    backend.put_mock.assert_called_with(value, wait=wait, timeout=timeout)
+def get_mock_put(signal: Signal) -> Mock:
+    """Get the mock associated with the put call on the signal."""
+    return _get_mock_signal_backend(signal).put_mock
 
 
 def reset_mock_put_calls(signal: Signal):
@@ -79,15 +79,29 @@ class _SetValuesIterator:
         return next_value
 
     def __del__(self):
-        if self.require_all_consumed and self.index != len(self.values):
-            raise AssertionError("Not all values have been consumed.")
+        if self.require_all_consumed:
+            # Values is cast to a list here because the user has supplied
+            # require_all_consumed=True, we can therefore assume they
+            # supplied a finite list.
+            # In the case of require_all_consumed=False, an infinite
+            # iterble is permitted
+            values = list(self.values)
+            if self.index != len(values):
+                # Report the values consumed and the values yet to be
+                # consumed
+                consumed = values[0 : self.index]
+                to_be_consumed = values[self.index :]
+                raise AssertionError(
+                    f"{self.signal.name}: {consumed} were consumed "
+                    f"but {to_be_consumed} were not consumed"
+                )
 
 
 def set_mock_values(
     signal: Signal,
     values: Iterable[Any],
     require_all_consumed: bool = False,
-) -> Iterator[Any]:
+) -> _SetValuesIterator:
     """Iterator to set a signal to a sequence of values, optionally repeating the
     sequence.
 
@@ -127,7 +141,7 @@ def _unset_side_effect_cm(put_mock: Mock):
     put_mock.side_effect = None
 
 
-def callback_on_mock_put(signal: Signal, callback: Callable[[T], None]):
+def callback_on_mock_put(signal: Signal[T], callback: Callable[[T], None]):
     """For setting a callback when a backend is put to.
 
     Can either be used in a context, with the callback being

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/signal.py

@@ -57,7 +57,7 @@ class Signal(Device, Generic[T]):
 
     def __init__(
         self,
-        backend: SignalBackend[T],
+        backend: Optional[SignalBackend[T]] = None,
         timeout: Optional[float] = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
@@ -66,13 +66,24 @@ class Signal(Device, Generic[T]):
         super().__init__(name)
 
     async def connect(
-        self, mock=False, timeout=DEFAULT_TIMEOUT, force_reconnect: bool = False
+        self,
+        mock=False,
+        timeout=DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+        backend: Optional[SignalBackend[T]] = None,
     ):
+        if backend:
+            if self._initial_backend and backend is not self._initial_backend:
+                raise ValueError(
+                    "Backend at connection different from initialised one."
+                )
+            self._backend = backend
         if mock and not isinstance(self._backend, MockSignalBackend):
             # Using a soft backend, look to the initial value
-            self._backend = MockSignalBackend(
-                initial_backend=self._initial_backend,
-            )
+            self._backend = MockSignalBackend(initial_backend=self._backend)
+
+        if self._backend is None:
+            raise RuntimeError("`connect` called on signal without backend")
         self.log.debug(f"Connecting to {self.source}")
         await self._backend.connect(timeout=timeout)
 
@@ -283,15 +294,15 @@ def soft_signal_r_and_setter(
 
 
 def _generate_assert_error_msg(
-    name: str, expected_result: str, actuall_result: str
+    name: str, expected_result: str, actual_result: str
 ) -> str:
     WARNING = "\033[93m"
     FAIL = "\033[91m"
     ENDC = "\033[0m"
     return (
         f"Expected {WARNING}{name}{ENDC} to produce"
-        + f"\n{FAIL}{actuall_result}{ENDC}"
-        + f"\nbut actually got \n{FAIL}{expected_result}{ENDC}"
+        + f"\n{FAIL}{expected_result}{ENDC}"
+        + f"\nbut actually got \n{FAIL}{actual_result}{ENDC}"
     )
 
 
@@ -313,7 +324,9 @@ async def assert_value(signal: SignalR[T], value: Any) -> None:
     """
     actual_value = await signal.get_value()
     assert actual_value == value, _generate_assert_error_msg(
-        signal.name, value, actual_value
+        name=signal.name,
+        expected_result=value,
+        actual_result=actual_value,
     )
 
 
@@ -338,7 +351,9 @@ async def assert_reading(
     """
     actual_reading = await readable.read()
     assert expected_reading == actual_reading, _generate_assert_error_msg(
-        readable.name, expected_reading, actual_reading
+        name=readable.name,
+        expected_result=expected_reading,
+        actual_result=actual_reading,
     )
 
 
@@ -364,7 +379,9 @@ async def assert_configuration(
     """
     actual_configurable = await configurable.read_configuration()
     assert configuration == actual_configurable, _generate_assert_error_msg(
-        configurable.name, configuration, actual_configurable
+        name=configurable.name,
+        expected_result=configuration,
+        actual_result=actual_configurable,
     )
 
 
@@ -386,11 +403,15 @@ def assert_emitted(docs: Mapping[str, list[dict]], **numbers: int):
         resource=1, datum=1, event=1, stop=1)
     """
     assert list(docs) == list(numbers), _generate_assert_error_msg(
-        "documents", list(numbers), list(docs)
+        name="documents",
+        expected_result=list(numbers),
+        actual_result=list(docs),
     )
     actual_numbers = {name: len(d) for name, d in docs.items()}
     assert actual_numbers == numbers, _generate_assert_error_msg(
-        "emitted", numbers, actual_numbers
+        name="emitted",
+        expected_result=numbers,
+        actual_result=actual_numbers,
     )
 
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/signal_backend.py

@@ -14,7 +14,7 @@ class SignalBackend(Generic[T]):
 
     #: Like ca://PV_PREFIX:SIGNAL
     @abstractmethod
-    def source(name: str) -> str:
+    def source(self, name: str) -> str:
         """Return source of signal. Signals may pass a name to the backend, which can be
         used or discarded."""
 

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/core/standard_readable.py

@@ -254,6 +254,8 @@ class HintedSignal(HasHints, AsyncReadable):
 
     @property
     def hints(self) -> Hints:
+        if self.signal.name == "":
+            return {"fields": []}
         return {"fields": [self.signal.name]}
 
     @classmethod

{ophyd_async-0.3a6 → ophyd_async-0.3.1}/src/ophyd_async/epics/_backend/_aioca.py

@@ -2,8 +2,10 @@ import logging
 import sys
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, Optional, Sequence, Type, Union
+from math import isnan, nan
+from typing import Any, Dict, List, Optional, Type, Union
 
+import numpy as np
 from aioca import (
     FORMAT_CTRL,
     FORMAT_RAW,
@@ -28,7 +30,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
 
-from .common import get_supported_values
+from .common import LimitPair, Limits, common_meta, get_supported_values
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -40,6 +42,64 @@ dbr_to_dtype: Dict[Dbr, Dtype] = {
 }
 
 
+def _data_key_from_augmented_value(
+    value: AugmentedValue,
+    *,
+    choices: Optional[List[str]] = None,
+    dtype: Optional[str] = None,
+) -> DataKey:
+    """Use the return value of get with FORMAT_CTRL to construct a DataKey
+    describing the signal. See docstring of AugmentedValue for expected
+    value fields by DBR type.
+
+    Args:
+        value (AugmentedValue): Description of the the return type of a DB record
+        choices: Optional list of enum choices to pass as metadata in the datakey
+        dtype: Optional override dtype when AugmentedValue is ambiguous, e.g. booleans
+
+    Returns:
+        DataKey: A rich DataKey describing the DB record
+    """
+    source = f"ca://{value.name}"
+    assert value.ok, f"Error reading {source}: {value}"
+
+    scalar = value.element_count == 1
+    dtype = dtype or dbr_to_dtype[value.datatype]
+
+    d = DataKey(
+        source=source,
+        dtype=dtype if scalar else "array",
+        # strictly value.element_count >= len(value)
+        shape=[] if scalar else [len(value)],
+    )
+    for key in common_meta:
+        attr = getattr(value, key, nan)
+        if isinstance(attr, str) or not isnan(attr):
+            d[key] = attr
+
+    if choices is not None:
+        d["choices"] = choices
+
+    if limits := _limits_from_augmented_value(value):
+        d["limits"] = limits
+
+    return d
+
+
+def _limits_from_augmented_value(value: AugmentedValue) -> Limits:
+    def get_limits(limit: str) -> LimitPair:
+        low = getattr(value, f"lower_{limit}_limit", None)
+        high = getattr(value, f"upper_{limit}_limit", None)
+        return LimitPair(low=low, high=high)
+
+    return Limits(
+        alarm=get_limits("alarm"),
+        control=get_limits("ctrl"),
+        display=get_limits("disp"),
+        warning=get_limits("warning"),
+    )
+
+
 @dataclass
 class CaConverter:
     read_dbr: Optional[Dbr]
@@ -49,7 +109,10 @@ class CaConverter:
         return value
 
     def value(self, value: AugmentedValue):
-        return value
+        # for channel access ca_xxx classes, this
+        # invokes __pos__ operator to return an instance of
+        # the builtin base class
+        return +value
 
     def reading(self, value: AugmentedValue):
         return {
@@ -58,8 +121,8 @@ class CaConverter:
             "alarm_severity": -1 if value.severity > 2 else value.severity,
         }
 
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {"source": source, "dtype": dbr_to_dtype[value.datatype], "shape": []}
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        return _data_key_from_augmented_value(value)
 
 
 class CaLongStrConverter(CaConverter):
@@ -73,12 +136,17 @@ class CaLongStrConverter(CaConverter):
 
 
 class CaArrayConverter(CaConverter):
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {"source": source, "dtype": "array", "shape": [len(value)]}
+    def value(self, value: AugmentedValue):
+        return np.array(value, copy=False)
 
 
 @dataclass
 class CaEnumConverter(CaConverter):
+    """To prevent issues when a signal is restarted and returns with different enum
+    values or orders, we put treat an Enum signal as a string, and cache the
+    choices on this class.
+    """
+
     choices: dict[str, str]
 
     def write_value(self, value: Union[Enum, str]):
@@ -90,13 +158,18 @@ class CaEnumConverter(CaConverter):
     def value(self, value: AugmentedValue):
         return self.choices[value]
 
-    def get_datakey(self, source: str, value: AugmentedValue) -> DataKey:
-        return {
-            "source": source,
-            "dtype": "string",
-            "shape": [],
-            "choices": list(self.choices),
-        }
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        # Sometimes DBR_TYPE returns as String, must pass choices still
+        return _data_key_from_augmented_value(value, choices=list(self.choices.keys()))
+
+
+@dataclass
+class CaBoolConverter(CaConverter):
+    def value(self, value: AugmentedValue) -> bool:
+        return bool(value)
+
+    def get_datakey(self, value: AugmentedValue) -> DataKey:
+        return _data_key_from_augmented_value(value, dtype="bool")
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -115,8 +188,10 @@ def make_converter(
         return CaLongStrConverter()
     elif is_array and pv_dbr == dbr.DBR_STRING:
         # Waveform of strings, check we wanted this
-        if datatype and datatype != Sequence[str]:
-            raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
+        if datatype:
+            datatype_dtype = get_dtype(datatype)
+            if not datatype_dtype or not np.can_cast(datatype_dtype, np.str_):
+                raise TypeError(f"{pv} has type [str] not {datatype.__name__}")
         return CaArrayConverter(pv_dbr, None)
     elif is_array:
         pv_dtype = get_unique({k: v.dtype for k, v in values.items()}, "dtypes")
@@ -136,7 +211,7 @@ def make_converter(
         )
         if pv_choices_len != 2:
             raise TypeError(f"{pv} has {pv_choices_len} choices, can't map to bool")
-        return CaConverter(dbr.DBR_SHORT, dbr.DBR_SHORT)
+        return CaBoolConverter(dbr.DBR_SHORT, dbr.DBR_SHORT)
     elif pv_dbr == dbr.DBR_ENUM:
         # This is an Enum
         pv_choices = get_unique(
@@ -224,7 +299,7 @@ class CaSignalBackend(SignalBackend[T]):
 
     async def get_datakey(self, source: str) -> DataKey:
         value = await self._caget(FORMAT_CTRL)
-        return self.converter.get_datakey(source, value)
+        return self.converter.get_datakey(value)
 
     async def get_reading(self) -> Reading:
         value = await self._caget(FORMAT_TIME)