ophyd-async 0.2.0__py3-none-any.whl → 0.3a1__py3-none-any.whl

ophyd_async/core/utils.py

@@ -1,5 +1,18 @@
+from __future__ import annotations
+
 import asyncio
-from typing import Awaitable, Callable, Dict, Iterable, List, Optional, Type, TypeVar
+import logging
+from typing import (
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 
 import numpy as np
 from bluesky.protocols import Reading
@@ -11,46 +24,79 @@ Callback = Callable[[T], None]
 #: monitor updates
 ReadingValueCallback = Callable[[Reading, T], None]
 DEFAULT_TIMEOUT = 10.0
+ErrorText = Union[str, Dict[str, Exception]]
 
 
 class NotConnected(Exception):
     """Exception to be raised if a `Device.connect` is cancelled"""
 
-    def __init__(self, *lines: str):
-        self.lines = list(lines)
+    _indent_width = "    "
+
+    def __init__(self, errors: ErrorText):
+        """
+        NotConnected holds a mapping of device/signal names to
+        errors.
+
+        Parameters
+        ----------
+        errors: ErrorText
+            Mapping of device name to Exception or another NotConnected.
+            Alternatively a string with the signal error text.
+        """
+
+        self._errors = errors
+
+    def _format_sub_errors(self, name: str, error: Exception, indent="") -> str:
+        if isinstance(error, NotConnected):
+            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"
+        else:
+            raise RuntimeError(
+                f"Unexpected type `{type(error)}`, expected an Exception"
+            )
+
+        string = f"{indent}{name}: {type(error).__name__}" + error_txt
+        return string
+
+    def format_error_string(self, indent="") -> str:
+        if not isinstance(self._errors, dict) and not isinstance(self._errors, str):
+            raise RuntimeError(
+                f"Unexpected type `{type(self._errors)}` " "expected `str` or `dict`"
+            )
+
+        if isinstance(self._errors, str):
+            return " " + self._errors + "\n"
+
+        string = "\n"
+        for name, error in self._errors.items():
+            string += self._format_sub_errors(name, error, indent=indent)
+        return string
 
     def __str__(self) -> str:
-        return "\n".join(self.lines)
+        return self.format_error_string(indent="")
 
 
 async def wait_for_connection(**coros: Awaitable[None]):
-    """Call many underlying signals, accumulating `NotConnected` exceptions
+    """Call many underlying signals, accumulating exceptions and returning them
 
-    Raises
-    ------
-    `NotConnected` if cancelled
+    Expected kwargs should be a mapping of names to coroutine tasks to execute.
     """
-    ts = {k: asyncio.create_task(c) for (k, c) in coros.items()}  # type: ignore
-    try:
-        done, pending = await asyncio.wait(ts.values())
-    except asyncio.CancelledError:
-        for t in ts.values():
-            t.cancel()
-        lines: List[str] = []
-        for k, t in ts.items():
-            try:
-                await t
-            except NotConnected as e:
-                if len(e.lines) == 1:
-                    lines.append(f"{k}: {e.lines[0]}")
-                else:
-                    lines.append(f"{k}:")
-                    lines += [f"  {line}" for line in e.lines]
-        raise NotConnected(*lines)
-    else:
-        # Wait for everything to foreground the exceptions
-        for f in list(done) + list(pending):
-            await f
+    results = await asyncio.gather(*coros.values(), return_exceptions=True)
+    exceptions = {}
+
+    for name, result in zip(coros, results):
+        if isinstance(result, Exception):
+            exceptions[name] = result
+            if not isinstance(result, NotConnected):
+                logging.exception(
+                    f"device `{name}` raised unexpected exception "
+                    f"{type(result).__name__}",
+                    exc_info=result,
+                )
+
+    if exceptions:
+        raise NotConnected(exceptions)
 
 
 def get_dtype(typ: Type) -> Optional[np.dtype]:

ophyd_async/epics/_backend/_aioca.py

@@ -1,5 +1,5 @@
+import logging
 import sys
-from asyncio import CancelledError
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, Optional, Sequence, Type, Union
@@ -8,6 +8,7 @@ from aioca import (
     FORMAT_CTRL,
     FORMAT_RAW,
     FORMAT_TIME,
+    CANothing,
     Subscription,
     caget,
     camonitor,
@@ -18,7 +19,6 @@ from bluesky.protocols import Descriptor, Dtype, Reading
 from epicscorelibs.ca import dbr
 
 from ophyd_async.core import (
-    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -26,6 +26,9 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
+
+from .common import get_supported_enum_class
 
 dbr_to_dtype: Dict[Dbr, Dtype] = {
     dbr.DBR_STRING: "string",
@@ -89,9 +92,7 @@ class CaEnumConverter(CaConverter):
 
     def descriptor(self, source: str, value: AugmentedValue) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(
-            source=source, dtype="string", shape=[], choices=choices
-        )  # type: ignore
+        return dict(source=source, dtype="string", shape=[], choices=choices)
 
 
 class DisconnectedCaConverter(CaConverter):
@@ -137,19 +138,7 @@ def make_converter(
         pv_choices = get_unique(
             {k: tuple(v.enums) for k, v in values.items()}, "choices"
         )
-        if datatype:
-            if not issubclass(datatype, Enum):
-                raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-            if not issubclass(datatype, str):
-                raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
-            choices = tuple(v.value for v in datatype)
-            if set(choices) != set(pv_choices):
-                raise TypeError(f"{pv} has choices {pv_choices} not {choices}")
-            enum_class = datatype
-        else:
-            enum_class = Enum(  # type: ignore
-                "GeneratedChoices", {x: x for x in pv_choices}, type=str
-            )
+        enum_class = get_supported_enum_class(pv, datatype, pv_choices)
         return CaEnumConverter(dbr.DBR_STRING, None, enum_class)
     else:
         value = list(values.values())[0]
@@ -184,23 +173,26 @@ class CaSignalBackend(SignalBackend[T]):
         self.source = f"ca://{self.read_pv}"
         self.subscription: Optional[Subscription] = None
 
-    async def _store_initial_value(self, pv):
+    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
-            self.initial_values[pv] = await caget(pv, format=FORMAT_CTRL, timeout=None)
-        except CancelledError:
-            raise NotConnected(self.source)
+            self.initial_values[pv] = await caget(
+                pv, format=FORMAT_CTRL, timeout=timeout
+            )
+        except CANothing as exc:
+            logging.debug(f"signal ca://{pv} timed out")
+            raise NotConnected(f"ca://{pv}") from exc
 
-    async def connect(self):
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
         _use_pyepics_context_if_imported()
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
-                read_pv=self._store_initial_value(self.read_pv),
-                write_pv=self._store_initial_value(self.write_pv),
+                read_pv=self._store_initial_value(self.read_pv, timeout=timeout),
+                write_pv=self._store_initial_value(self.write_pv, timeout=timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._store_initial_value(self.read_pv)
+            await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
     async def put(self, value: Optional[T], wait=True, timeout=None):

ophyd_async/epics/_backend/_p4p.py

@@ -1,6 +1,7 @@
 import asyncio
 import atexit
-from asyncio import CancelledError
+import logging
+import time
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Dict, List, Optional, Sequence, Type, Union
@@ -10,7 +11,6 @@ from p4p import Value
 from p4p.client.asyncio import Context, Subscription
 
 from ophyd_async.core import (
-    NotConnected,
     ReadingValueCallback,
     SignalBackend,
     T,
@@ -18,6 +18,9 @@ from ophyd_async.core import (
     get_unique,
     wait_for_connection,
 )
+from ophyd_async.core.utils import DEFAULT_TIMEOUT, NotConnected
+
+from .common import get_supported_enum_class
 
 # https://mdavidsaver.github.io/p4p/values.html
 specifier_to_dtype: Dict[str, Dtype] = {
@@ -119,9 +122,7 @@ class PvaEnumConverter(PvaConverter):
 
     def descriptor(self, source: str, value) -> Descriptor:
         choices = [e.value for e in self.enum_class]
-        return dict(
-            source=source, dtype="string", shape=[], choices=choices
-        )  # type: ignore
+        return dict(source=source, dtype="string", shape=[], choices=choices)
 
 
 class PvaEnumBoolConverter(PvaConverter):
@@ -141,6 +142,32 @@ class PvaTableConverter(PvaConverter):
         return dict(source=source, dtype="object", shape=[])  # type: ignore
 
 
+class PvaDictConverter(PvaConverter):
+    def reading(self, value):
+        ts = time.time()
+        value = value.todict()
+        # Alarm severity is vacuously 0 for a table
+        return dict(value=value, timestamp=ts, alarm_severity=0)
+
+    def value(self, value: Value):
+        return value.todict()
+
+    def descriptor(self, source: str, value) -> Descriptor:
+        raise NotImplementedError("Describing Dict signals not currently supported")
+
+    def metadata_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for metadata.
+        """
+        return []
+
+    def value_fields(self) -> List[str]:
+        """
+        Fields to request from PVA for the value.
+        """
+        return []
+
+
 class DisconnectedPvaConverter(PvaConverter):
     def __getattribute__(self, __name: str) -> Any:
         raise NotImplementedError("No PV has been set as connect() has not been called")
@@ -149,7 +176,9 @@ class DisconnectedPvaConverter(PvaConverter):
 def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConverter:
     pv = list(values)[0]
     typeid = get_unique({k: v.getID() for k, v in values.items()}, "typeids")
-    typ = get_unique({k: type(v["value"]) for k, v in values.items()}, "value types")
+    typ = get_unique(
+        {k: type(v.get("value")) for k, v in values.items()}, "value types"
+    )
     if "NTScalarArray" in typeid and typ == list:
         # Waveform of strings, check we wanted this
         if datatype and datatype != Sequence[str]:
@@ -185,24 +214,15 @@ def make_converter(datatype: Optional[Type], values: Dict[str, Any]) -> PvaConve
         pv_choices = get_unique(
             {k: tuple(v["value"]["choices"]) for k, v in values.items()}, "choices"
         )
-        if datatype:
-            if not issubclass(datatype, Enum):
-                raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
-            choices = tuple(v.value for v in datatype)
-            if set(choices) != set(pv_choices):
-                raise TypeError(f"{pv} has choices {pv_choices} not {choices}")
-            enum_class = datatype
-        else:
-            enum_class = Enum(  # type: ignore
-                "GeneratedChoices", {x or "_": x for x in pv_choices}, type=str
-            )
-        return PvaEnumConverter(enum_class)
+        return PvaEnumConverter(get_supported_enum_class(pv, datatype, pv_choices))
     elif "NTScalar" in typeid:
         if datatype and not issubclass(typ, datatype):
             raise TypeError(f"{pv} has type {typ.__name__} not {datatype.__name__}")
         return PvaConverter()
     elif "NTTable" in typeid:
         return PvaTableConverter()
+    elif "structure" in typeid:
+        return PvaDictConverter()
     else:
         raise TypeError(f"{pv}: Unsupported typeid {typeid}")
 
@@ -233,22 +253,25 @@ class PvaSignalBackend(SignalBackend[T]):
 
         return PvaSignalBackend._ctxt
 
-    async def _store_initial_value(self, pv):
+    async def _store_initial_value(self, pv, timeout: float = DEFAULT_TIMEOUT):
         try:
-            self.initial_values[pv] = await self.ctxt.get(pv)
-        except CancelledError:
-            raise NotConnected(self.source)
+            self.initial_values[pv] = await asyncio.wait_for(
+                self.ctxt.get(pv), timeout=timeout
+            )
+        except asyncio.TimeoutError as exc:
+            logging.debug(f"signal pva://{pv} timed out", exc_info=True)
+            raise NotConnected(f"pva://{pv}") from exc
 
-    async def connect(self):
+    async def connect(self, timeout: float = DEFAULT_TIMEOUT):
         if self.read_pv != self.write_pv:
             # Different, need to connect both
             await wait_for_connection(
-                read_pv=self._store_initial_value(self.read_pv),
-                write_pv=self._store_initial_value(self.write_pv),
+                read_pv=self._store_initial_value(self.read_pv, timeout=timeout),
+                write_pv=self._store_initial_value(self.write_pv, timeout=timeout),
             )
         else:
             # The same, so only need to connect one
-            await self._store_initial_value(self.read_pv)
+            await self._store_initial_value(self.read_pv, timeout=timeout)
         self.converter = make_converter(self.datatype, self.initial_values)
 
     async def put(self, value: Optional[T], wait=True, timeout=None):
@@ -257,7 +280,15 @@ class PvaSignalBackend(SignalBackend[T]):
         else:
             write_value = self.converter.write_value(value)
         coro = self.ctxt.put(self.write_pv, dict(value=write_value), wait=wait)
-        await asyncio.wait_for(coro, timeout)
+        try:
+            await asyncio.wait_for(coro, timeout)
+        except asyncio.TimeoutError as exc:
+            logging.debug(
+                f"signal pva://{self.write_pv} timed out \
+                          put value: {write_value}",
+                exc_info=True,
+            )
+            raise NotConnected(f"pva://{self.write_pv}") from exc
 
     async def get_descriptor(self) -> Descriptor:
         value = await self.ctxt.get(self.read_pv)

ophyd_async/epics/_backend/common.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from typing import Any, Optional, Tuple, Type
+
+
+def get_supported_enum_class(
+    pv: str,
+    datatype: Optional[Type[Enum]],
+    pv_choices: Tuple[Any, ...],
+) -> Type[Enum]:
+    if datatype:
+        if not issubclass(datatype, Enum):
+            raise TypeError(f"{pv} has type Enum not {datatype.__name__}")
+        if not issubclass(datatype, str):
+            raise TypeError(f"{pv} has type Enum but doesn't inherit from String")
+        choices = tuple(v.value for v in datatype)
+        if set(choices).difference(pv_choices):
+            raise TypeError(f"{pv} has choices {pv_choices}: not all in {choices}")
+    return Enum(
+        "GeneratedChoices", {x or "_": x for x in pv_choices}, type=str
+    )  # type: ignore

ophyd_async/epics/areadetector/controllers/ad_sim_controller.py

@@ -30,8 +30,8 @@ class ADSimController(DetectorControl):
 
     async def arm(
         self,
+        num: int,
         trigger: DetectorTrigger = DetectorTrigger.internal,
-        num: int = 0,
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         assert (

ophyd_async/epics/areadetector/controllers/pilatus_controller.py

@@ -32,8 +32,8 @@ class PilatusController(DetectorControl):
 
     async def arm(
         self,
+        num: int,
         trigger: DetectorTrigger = DetectorTrigger.internal,
-        num: int = 0,
         exposure: Optional[float] = None,
     ) -> AsyncStatus:
         await asyncio.gather(

ophyd_async/epics/areadetector/writers/_hdffile.py

@@ -1,19 +1,33 @@
+from pathlib import Path
 from typing import Iterator, List
 
 from event_model import StreamDatum, StreamResource, compose_stream_resource
 
+from ophyd_async.core import DirectoryInfo
+
 from ._hdfdataset import _HDFDataset
 
 
 class _HDFFile:
-    def __init__(self, full_file_name: str, datasets: List[_HDFDataset]) -> None:
+    """
+    :param directory_info: Contains information about how to construct a StreamResource
+    :param full_file_name: Absolute path to the file to be written
+    :param datasets: Datasets to write into the file
+    """
+
+    def __init__(
+        self,
+        directory_info: DirectoryInfo,
+        full_file_name: Path,
+        datasets: List[_HDFDataset],
+    ) -> None:
         self._last_emitted = 0
         self._bundles = [
             compose_stream_resource(
                 spec="AD_HDF5_SWMR_SLICE",
-                root="/",
+                root=str(directory_info.root),
                 data_key=ds.name,
-                resource_path=full_file_name,
+                resource_path=str(full_file_name.relative_to(directory_info.root)),
                 resource_kwargs={
                     "path": ds.path,
                     "multiplier": ds.multiplier,

ophyd_async/epics/areadetector/writers/hdf_writer.py

@@ -1,7 +1,8 @@
 import asyncio
-from typing import AsyncIterator, Dict, List, Optional
+from pathlib import Path
+from typing import AsyncGenerator, AsyncIterator, Dict, List, Optional
 
-from bluesky.protocols import Asset, Descriptor, Hints
+from bluesky.protocols import Descriptor, Hints, StreamAsset
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
@@ -13,6 +14,7 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
+from ophyd_async.core.signal import observe_value
 
 from ._hdfdataset import _HDFDataset
 from ._hdffile import _HDFFile
@@ -45,15 +47,16 @@ class HDFWriter(DetectorWriter):
             self.hdf.num_extra_dims.set(0),
             self.hdf.lazy_open.set(True),
             self.hdf.swmr_mode.set(True),
-            self.hdf.file_path.set(info.directory_path),
-            self.hdf.file_name.set(f"{info.filename_prefix}{self.hdf.name}"),
+            # See https://github.com/bluesky/ophyd-async/issues/122
+            self.hdf.file_path.set(str(info.root / info.resource_dir)),
+            self.hdf.file_name.set(f"{info.prefix}{self.hdf.name}{info.suffix}"),
             self.hdf.file_template.set("%s/%s.h5"),
             self.hdf.file_write_mode.set(FileWriteMode.stream),
         )
 
         assert (
             await self.hdf.file_path_exists.get_value()
-        ), f"File path {info.directory_path} for hdf plugin does not exist"
+        ), f"File path {self.hdf.file_path.get_value()} for hdf plugin does not exist"
 
         # Overwrite num_capture to go forever
         await self.hdf.num_capture.set(0)
@@ -88,26 +91,29 @@ class HDFWriter(DetectorWriter):
         }
         return describe
 
-    async def wait_for_index(
-        self, index: int, timeout: Optional[float] = DEFAULT_TIMEOUT
-    ):
-        def matcher(value: int) -> bool:
-            return value // self._multiplier >= index
-
-        matcher.__name__ = f"index_at_least_{index}"
-        await wait_for_value(self.hdf.num_captured, matcher, timeout=timeout)
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        """Wait until a specific index is ready to be collected"""
+        async for num_captured in observe_value(self.hdf.num_captured, timeout):
+            yield num_captured // self._multiplier
 
     async def get_indices_written(self) -> int:
         num_captured = await self.hdf.num_captured.get_value()
         return num_captured // self._multiplier
 
-    async def collect_stream_docs(self, indices_written: int) -> AsyncIterator[Asset]:
+    async def collect_stream_docs(
+        self, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
         await self.hdf.flush_now.set(True)
         if indices_written:
             if not self._file:
                 self._file = _HDFFile(
-                    await self.hdf.full_file_name.get_value(), self._datasets
+                    self._directory_provider(),
+                    # See https://github.com/bluesky/ophyd-async/issues/122
+                    Path(await self.hdf.full_file_name.get_value()),
+                    self._datasets,
                 )
                 for doc in self._file.stream_resources():
                     yield "stream_resource", doc

ophyd_async/epics/pvi.py

@@ -0,0 +1,70 @@
+from typing import Callable, Dict, FrozenSet, Optional, Type, TypedDict, TypeVar
+
+from ophyd_async.core.signal import Signal
+from ophyd_async.core.signal_backend import SignalBackend
+from ophyd_async.core.utils import DEFAULT_TIMEOUT
+from ophyd_async.epics._backend._p4p import PvaSignalBackend
+from ophyd_async.epics.signal.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_w,
+    epics_signal_x,
+)
+
+T = TypeVar("T")
+
+
+_pvi_mapping: Dict[FrozenSet[str], Callable[..., Signal]] = {
+    frozenset({"r", "w"}): lambda dtype, read_pv, write_pv: epics_signal_rw(
+        dtype, read_pv, write_pv
+    ),
+    frozenset({"rw"}): lambda dtype, read_pv, write_pv: epics_signal_rw(
+        dtype, read_pv, write_pv
+    ),
+    frozenset({"r"}): lambda dtype, read_pv, _: epics_signal_r(dtype, read_pv),
+    frozenset({"w"}): lambda dtype, _, write_pv: epics_signal_w(dtype, write_pv),
+    frozenset({"x"}): lambda _, __, write_pv: epics_signal_x(write_pv),
+}
+
+
+class PVIEntry(TypedDict, total=False):
+    d: str
+    r: str
+    rw: str
+    w: str
+    x: str
+
+
+async def pvi_get(
+    read_pv: str, timeout: float = DEFAULT_TIMEOUT
+) -> Dict[str, PVIEntry]:
+    """Makes a PvaSignalBackend purely to connect to PVI information.
+
+    This backend is simply thrown away at the end of this method. This is useful
+    because the backend handles a CancelledError exception that gets thrown on
+    timeout, and therefore can be used for error reporting."""
+    backend: SignalBackend = PvaSignalBackend(None, read_pv, read_pv)
+    await backend.connect(timeout=timeout)
+    d: Dict[str, Dict[str, Dict[str, str]]] = await backend.get_value()
+    pv_info = d.get("pvi") or {}
+    result = {}
+
+    for attr_name, attr_info in pv_info.items():
+        result[attr_name] = PVIEntry(**attr_info)  # type: ignore
+
+    return result
+
+
+def make_signal(signal_pvi: PVIEntry, dtype: Optional[Type[T]] = None) -> Signal[T]:
+    """Make a signal.
+
+    This assumes datatype is None so it can be used to create dynamic signals.
+    """
+    operations = frozenset(signal_pvi.keys())
+    pvs = [signal_pvi[i] for i in operations]  # type: ignore
+    signal_factory = _pvi_mapping[operations]
+
+    write_pv = "pva://" + pvs[0]
+    read_pv = write_pv if len(pvs) < 2 else "pva://" + pvs[1]
+
+    return signal_factory(dtype, read_pv, write_pv)

ophyd_async/epics/signal/__init__.py

@@ -1,8 +1,6 @@
-from .pvi_get import pvi_get
 from .signal import epics_signal_r, epics_signal_rw, epics_signal_w, epics_signal_x
 
 __all__ = [
-    "pvi_get",
     "epics_signal_r",
     "epics_signal_rw",
     "epics_signal_w",

ophyd_async/panda/__init__.py

@@ -1,4 +1,5 @@
-from .panda import PandA, PcapBlock, PulseBlock, PVIEntry, SeqBlock, SeqTable, pvi
+from .panda import PandA, PcapBlock, PulseBlock, PVIEntry, SeqBlock, SeqTable
+from .panda_controller import PandaPcapController
 from .table import (
     SeqTable,
     SeqTableRow,
@@ -6,6 +7,7 @@ from .table import (
     seq_table_from_arrays,
     seq_table_from_rows,
 )
+from .utils import phase_sorter
 
 __all__ = [
     "PandA",
@@ -18,5 +20,6 @@ __all__ = [
     "SeqTable",
     "SeqTableRow",
     "SeqTrigger",
-    "pvi",
+    "phase_sorter",
+    "PandaPcapController",
 ]