fastcs-pandablocks 0.2.0a3__py3-none-any.whl

fastcs_pandablocks/panda/client_wrapper.py

@@ -0,0 +1,143 @@
+"""
+This method has a `RawPanda` which handles all the io with the client.
+"""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from pprint import pformat
+
+from fastcs.datatypes import DataType
+from fastcs.logging import bind_logger
+from pandablocks.asyncio import AsyncioClient
+from pandablocks.commands import (
+    Arm,
+    ChangeGroup,
+    Disarm,
+    Get,
+    GetBlockInfo,
+    GetChanges,
+    GetFieldInfo,
+    Put,
+)
+from pandablocks.responses import Data
+
+from fastcs_pandablocks.types import (
+    PandaName,
+    RawBlocksType,
+    RawFieldsType,
+    RawInitialValuesType,
+)
+
+logger = bind_logger(__name__)
+
+
+class RawPanda:
+    """A wrapper for interacting with pandablocks-client."""
+
+    def __init__(self, hostname: str):
+        self._client = AsyncioClient(host=hostname)
+
+    async def connect(self):
+        await self._client.connect()
+
+    async def disconnect(self):
+        await self._client.close()
+
+    async def put_value_to_panda(
+        self,
+        panda_name: PandaName,
+        fastcs_datatype: DataType,
+        value: str | list[str],
+    ) -> None:
+        await self.send(str(panda_name), value)
+
+    async def introspect(
+        self,
+    ) -> tuple[
+        RawBlocksType, RawFieldsType, RawInitialValuesType, RawInitialValuesType
+    ]:
+        blocks, fields, labels, initial_values = {}, [], {}, {}
+
+        raw_blocks = await self._client.send(GetBlockInfo())
+        blocks = {
+            PandaName.from_string(name): block_info
+            for name, block_info in raw_blocks.items()
+        }
+        formatted_blocks = pformat(blocks, indent=4).replace("\n", "\n    ")
+        logger.debug(f"BLOCKS RECEIVED:\n    {formatted_blocks}")
+
+        raw_fields = await asyncio.gather(
+            *[self._client.send(GetFieldInfo(str(block))) for block in blocks]
+        )
+        fields = [
+            {
+                PandaName(field=name): field_info
+                for name, field_info in block_values.items()
+            }
+            for block_values in raw_fields
+        ]
+        logger.debug("FIELDS RECEIVED (TOO VERBOSE TO LOG)")
+
+        field_data = await self.get_changes()
+
+        for field_name, value in field_data.items():
+            if field_name.startswith("*METADATA"):
+                field_name_without_prefix = field_name.removeprefix("*METADATA.")
+                if field_name_without_prefix == "DESIGN":
+                    continue  # TODO: Handle design.
+                elif not field_name_without_prefix.startswith("LABEL_"):
+                    logger.warning(
+                        "Ignoring received metadata not corresponding to a `LABEL_`",
+                        field_name=field_name,
+                        value=value,
+                    )
+                labels[
+                    PandaName.from_string(
+                        field_name_without_prefix.removeprefix("LABEL_")
+                    )
+                ] = value
+            else:  # Field is a default value
+                initial_values[PandaName.from_string(field_name)] = value
+
+        formatted_initial_values = pformat(initial_values, indent=4).replace(
+            "\n", "\n    "
+        )
+        logger.debug(f"INITIAL VALUES:\n    {formatted_initial_values}")
+        formatted_labels = pformat(labels, indent=4).replace("\n", "\n    ")
+        logger.debug(f"LABELS:\n    {formatted_labels}")
+
+        return blocks, fields, labels, initial_values
+
+    async def send(self, name: str, value: str | list[str]):
+        logger.debug(f"SENDING TO PANDA:\n    {name} = {pformat(value, indent=4)}")
+        await self._client.send(Put(name, value))
+
+    async def get(self, name: str) -> str | list[str]:
+        received = await self._client.send(Get(name))
+        formatted_received = pformat(received, indent=4).replace("\n", "\n    ")
+        logger.debug(f"RECEIVED FROM PANDA:\n    {name} = {formatted_received}")
+        return received
+
+    async def get_changes(self) -> dict[str, str | list[str]]:
+        changes = await self._client.send(GetChanges(ChangeGroup.ALL, True))
+        single_and_multiline_changes = {
+            **changes.values,
+            **changes.multiline_values,
+        }
+        formatted_received = pformat(single_and_multiline_changes, indent=4).replace(
+            "\n", "\n    "
+        )
+        logger.debug(f"RECEIVED CHANGES:\n    {formatted_received}")
+        return single_and_multiline_changes
+
+    async def arm(self):
+        await self._client.send(Arm())
+
+    async def disarm(self):
+        await self._client.send(Disarm())
+
+    async def data(
+        self, scaled: bool, flush_period: float
+    ) -> AsyncGenerator[Data, None]:
+        async for data in self._client.data(scaled=scaled, flush_period=flush_period):
+            yield data

fastcs_pandablocks/panda/controller.yaml

@@ -0,0 +1,10 @@
+## yaml-language-server: $schema=schema.json
+
+controller:
+  address: "172.23.252.201"
+
+transport:
+  - epicspva:
+      pv_prefix: TEST-PANDA
+    gui:
+      output_path: /workspaces/opi/fastcs-Panda.bob

fastcs_pandablocks/panda/io/arm.py

@@ -0,0 +1,37 @@
+import enum
+import logging
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import (
+    AttributeIO,
+    AttributeIORef,
+    AttrW,
+)
+from fastcs.datatypes import DType_T
+
+
+class ArmCommand(enum.Enum):
+    """Enum class for PandA arm fields."""
+
+    DISARM = "Disarm"
+    ARM = "Arm"
+
+
+@dataclass
+class ArmIORef(AttributeIORef):
+    arm: Callable[[], Coroutine[None, None, None]]
+    disarm: Callable[[], Coroutine[None, None, None]]
+
+
+class ArmIO(AttributeIO[DType_T, ArmIORef]):
+    """A sender for arming and disarming the Pcap."""
+
+    async def send(self, attr: AttrW[DType_T, ArmIORef], value: Any):
+        if value is ArmCommand.ARM:
+            logging.info("Arming PandA.")
+            await attr.io_ref.arm()
+        else:
+            logging.info("Disarming PandA.")
+            await attr.io_ref.disarm()

fastcs_pandablocks/panda/io/bits.py

@@ -0,0 +1,43 @@
+import asyncio
+import enum
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import (
+    AttrRW,
+)
+from fastcs.datatypes import DType_T, Enum
+
+
+async def _set_attr_if_not_already_value(attribute: AttrRW[DType_T], value: DType_T):
+    if attribute.get() != value:
+        await attribute.update(value)
+
+
+@dataclass
+class BitGroupOnUpdate:
+    """Bits are tied together in bit groups so that when one is set for capture,
+    they all are.
+
+    This callback sets all capture attributes in the group when one of them is set.
+    """
+
+    capture_attribute: AttrRW[enum.Enum]
+    bit_attributes: list[AttrRW[bool]]
+
+    async def __call__(self, value: Any):
+        if isinstance(value, enum.Enum):
+            bool_value = bool(self.capture_attribute.datatype.index_of(value))  # type: ignore
+            enum_value = value
+        else:
+            bool_value = value
+            assert isinstance(self.capture_attribute.datatype, Enum)
+            enum_value = self.capture_attribute.datatype.members[int(value)]
+
+        await asyncio.gather(
+            *[
+                _set_attr_if_not_already_value(bit_attr, bool_value)
+                for bit_attr in self.bit_attributes
+            ],
+            _set_attr_if_not_already_value(self.capture_attribute, enum_value),
+        )

fastcs_pandablocks/panda/io/default.py

@@ -0,0 +1,36 @@
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import (
+    AttributeIO,
+    AttributeIORef,
+    AttrW,
+)
+from fastcs.datatypes import DataType, DType_T
+
+from fastcs_pandablocks.panda.utils import (
+    attribute_value_to_panda_value,
+)
+from fastcs_pandablocks.types import PandaName
+
+
+@dataclass
+class DefaultFieldIORef(AttributeIORef):
+    panda_name: PandaName
+    put_value_to_panda: Callable[
+        [PandaName, DataType, Any], Coroutine[None, None, None]
+    ]
+
+
+class DefaultFieldIO(AttributeIO[DType_T, DefaultFieldIORef]):
+    """Default IO for sending and updating introspected attributes."""
+
+    async def send(
+        self, attr: AttrW[DType_T, DefaultFieldIORef], value: DType_T
+    ) -> None:
+        await attr.io_ref.put_value_to_panda(
+            attr.io_ref.panda_name,
+            attr.datatype,
+            attribute_value_to_panda_value(attr.datatype, value),
+        )

fastcs_pandablocks/panda/io/table.py

@@ -0,0 +1,38 @@
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import (
+    AttributeIO,
+    AttributeIORef,
+    AttrW,
+)
+from fastcs.datatypes import DataType, DType_T
+from pandablocks.responses import TableFieldInfo
+from pandablocks.utils import table_to_words
+
+from fastcs_pandablocks.panda.utils import (
+    attribute_value_to_panda_value,
+)
+from fastcs_pandablocks.types import PandaName
+
+
+@dataclass
+class TableFieldIORef(AttributeIORef):
+    panda_name: PandaName
+    field_info: TableFieldInfo
+    put_value_to_panda: Callable[
+        [PandaName, DataType, Any], Coroutine[None, None, None]
+    ]
+
+
+class TableFieldIO(AttributeIO[DType_T, TableFieldIORef]):
+    """An IO for updating Table valued attributes."""
+
+    async def send(self, attr: AttrW[DType_T, TableFieldIORef], value: DType_T) -> None:
+        attr_value = attribute_value_to_panda_value(attr.datatype, value)
+        assert isinstance(attr_value, dict)
+        panda_words = table_to_words(attr_value, attr.io_ref.field_info)
+        await attr.io_ref.put_value_to_panda(
+            attr.io_ref.panda_name, attr.datatype, panda_words
+        )

fastcs_pandablocks/panda/io/units.py

@@ -0,0 +1,49 @@
+import enum
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import (
+    AttributeIO,
+    AttributeIORef,
+    AttrRW,
+    AttrW,
+)
+from fastcs.datatypes import DataType, Float
+
+from fastcs_pandablocks.panda.utils import (
+    attribute_value_to_panda_value,
+)
+from fastcs_pandablocks.types import PandaName
+
+
+class TimeUnit(enum.Enum):
+    """Enum class for PandA time fields."""
+
+    min = "min"
+    s = "s"
+    ms = "ms"
+    us = "us"
+
+
+@dataclass
+class UnitsIORef(AttributeIORef):
+    attribute_to_scale: AttrRW
+    current_scale: TimeUnit
+    panda_name: PandaName
+    put_value_to_panda: Callable[
+        [PandaName, DataType, Any], Coroutine[None, None, None]
+    ]
+
+
+class UnitsIO(AttributeIO[enum.Enum, UnitsIORef]):
+    """A sender for arming and disarming the Pcap."""
+
+    async def send(self, attr: AttrW[enum.Enum, UnitsIORef], value: enum.Enum):
+        await attr.io_ref.put_value_to_panda(
+            attr.io_ref.panda_name,
+            attr.datatype,
+            attribute_value_to_panda_value(attr.datatype, value),
+        )
+
+        attr.io_ref.attribute_to_scale.update_datatype(Float(units=value.name, prec=5))

fastcs_pandablocks/panda/panda_controller.py

@@ -0,0 +1,125 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Any
+
+from fastcs.attributes import Attribute, AttrR
+from fastcs.controllers import Controller
+from fastcs.datatypes import Table
+from fastcs.logging import bind_logger
+from fastcs.methods import scan
+from pandablocks.utils import words_to_table
+
+from fastcs_pandablocks.panda.blocks import Blocks
+from fastcs_pandablocks.panda.client_wrapper import RawPanda
+from fastcs_pandablocks.panda.io.arm import ArmIO
+from fastcs_pandablocks.panda.io.default import DefaultFieldIO
+from fastcs_pandablocks.panda.io.table import TableFieldIO, TableFieldIORef
+from fastcs_pandablocks.panda.io.units import UnitsIO
+from fastcs_pandablocks.panda.utils import panda_value_to_attribute_value
+from fastcs_pandablocks.types import PandaName
+
+logger = bind_logger(__name__)
+
+
+@dataclass
+class PandaControllerSettings:
+    address: str
+
+
+class PandaController(Controller):
+    """Controller for polling data from the panda through pandablocks-client.
+
+    Changes are received at a given poll period and passed to sub-controllers.
+    """
+
+    def __init__(self, settings: PandaControllerSettings) -> None:
+        # TODO https://github.com/DiamondLightSource/FastCS/issues/62
+
+        self._raw_panda = RawPanda(settings.address)
+        self._ios = [ArmIO(), DefaultFieldIO(), TableFieldIO(), UnitsIO()]
+        self._blocks: Blocks = Blocks(self._raw_panda, ios=self._ios)
+        self.connected = False
+
+        super().__init__(ios=self._ios)
+
+    async def connect(self) -> None:
+        if self.connected:
+            # `connect` needs to be called in `initialise`,
+            # then FastCS will attempt to call it again.
+            return
+        await self._raw_panda.connect()
+        await self._blocks.parse_introspected_data()
+        await self._blocks.setup_post_introspection()
+        self.connected = True
+
+    async def initialise(self) -> None:
+        await self.connect()
+
+        for block_name, block in self._blocks.controllers():
+            # Numerically named controllers are registered to
+            # alphabetically named ControllerVectors, so only
+            # alphabetically named controllers
+            # should be registed to top level Controller
+            if str(block_name).isalpha():
+                self.add_sub_controller(block_name.lower(), block)
+                await block.initialise()
+
+    async def update_field_value(self, panda_name: PandaName, value: str | list[str]):
+        """Update a panda field with either a single value or a list of words."""
+
+        attribute = self._blocks.get_attribute(panda_name)
+        assert isinstance(attribute, AttrR)
+        if attribute is None:
+            logger.error(f"Couldn't find panda field for {panda_name}.")
+            return
+
+        try:
+            attribute_value = self._coerce_value_to_panda_type(attribute, value)
+        except ValueError:
+            logger.opt(exception=True).error("Coerce failed")
+            return
+
+        await self.update_attribute(attribute, attribute_value)
+
+    def _coerce_value_to_panda_type(
+        self, attribute: Attribute, value: str | list[str]
+    ) -> Any:
+        """Convert a provided value into an attribute_value for this panda attribute."""
+        match value:
+            case list() as words:
+                if not isinstance(attribute.datatype, Table):
+                    raise ValueError(f"{attribute} is not a Table attribute")
+                io_ref = attribute.io_ref
+                if not isinstance(io_ref, TableFieldIORef):
+                    raise ValueError(
+                        f"AttributeIORef for {attribute} is not TableFieldIORef"
+                    )
+                table_values = words_to_table(
+                    words, io_ref.field_info, convert_enum_indices=True
+                )
+                return panda_value_to_attribute_value(attribute.datatype, table_values)
+            case _:
+                return panda_value_to_attribute_value(attribute.datatype, value)
+
+    async def update_attribute(self, attribute: AttrR, attribute_value: Any) -> None:
+        """Dispatch setting logic based on attribute type."""
+        value = attribute.datatype.validate(attribute_value)
+        await attribute.update(value)
+
+    @scan(0.1)
+    async def update(self):
+        try:
+            changes = await self._raw_panda.get_changes()
+            await asyncio.gather(
+                *[
+                    self.update_field_value(
+                        PandaName.from_string(raw_panda_name), value
+                    )
+                    for raw_panda_name, value in changes.items()
+                ]
+            )
+        # TODO: General exception is not ideal; narrow this dowm.
+        except Exception as e:
+            raise RuntimeError(
+                "Failed to update changes from PandaBlocks client"
+            ) from e

fastcs_pandablocks/panda/utils.py

@@ -0,0 +1,52 @@
+from typing import Any
+
+import numpy as np
+from fastcs.datatypes import Bool, DataType, Enum, Float, Int, String, Table
+
+
+def panda_value_to_attribute_value(fastcs_datatype: DataType, value: str | dict) -> Any:
+    """Converts from a value received from the panda to the attribute value."""
+
+    match fastcs_datatype:
+        case String():
+            return fastcs_datatype.validate(value)
+        case Bool():
+            assert isinstance(value, str)
+            return fastcs_datatype.validate(int(value))
+        case Int() | Float():
+            return fastcs_datatype.validate(value)
+        case Enum():
+            return fastcs_datatype.enum_cls[value]  # type: ignore
+        case Table():
+            assert isinstance(value, dict)
+            num_rows = len(next(iter(value.values())))
+            structured_datatype = fastcs_datatype.structured_dtype
+            attribute_value = np.zeros(num_rows, fastcs_datatype.structured_dtype)
+            for field_name, _ in structured_datatype:
+                attribute_value[field_name] = value[field_name.upper()]
+            return attribute_value
+
+        case _:
+            raise NotImplementedError(f"Unknown datatype {fastcs_datatype}")
+
+
+def attribute_value_to_panda_value(fastcs_datatype: DataType, value: Any) -> str | dict:
+    """Converts from an attribute value to a value that can be sent to the panda."""
+
+    match fastcs_datatype:
+        case String():
+            return value
+        case Bool():
+            return str(int(value))
+        case Int() | Float():
+            return str(value)
+        case Enum():
+            return value.name
+        case Table():
+            assert isinstance(value, np.ndarray)
+            panda_value = {}
+            for field_name, _ in fastcs_datatype.structured_dtype:
+                panda_value[field_name.upper()] = value[field_name].tolist()
+            return panda_value
+        case _:
+            raise NotImplementedError(f"Unknown datatype {fastcs_datatype}")

fastcs_pandablocks/types/__init__.py

@@ -0,0 +1,34 @@
+from enum import Enum
+
+from ._annotations import (
+    RawBlocksType,
+    RawFieldsType,
+    RawInitialValuesType,
+    ResponseType,
+)
+from ._string_types import (
+    PANDA_SEPARATOR,
+    PandaName,
+)
+
+
+class WidgetGroup(Enum):
+    """Group that an attribute will be added to on the screen."""
+
+    NONE = None
+    PARAMETERS = "Parameters"
+    OUTPUTS = "Outputs"
+    INPUTS = "Inputs"
+    READBACKS = "Readbacks"
+    CAPTURE = "Capture"
+
+
+__all__ = [
+    "PANDA_SEPARATOR",
+    "PandaName",
+    "ResponseType",
+    "RawBlocksType",
+    "RawFieldsType",
+    "RawInitialValuesType",
+    "WidgetGroup",
+]

fastcs_pandablocks/types/_annotations.py

@@ -0,0 +1,42 @@
+from typing import Union
+
+from pandablocks.responses import (
+    BitMuxFieldInfo,
+    BitOutFieldInfo,
+    BlockInfo,
+    EnumFieldInfo,
+    ExtOutBitsFieldInfo,
+    ExtOutFieldInfo,
+    FieldInfo,
+    PosMuxFieldInfo,
+    PosOutFieldInfo,
+    ScalarFieldInfo,
+    SubtypeTimeFieldInfo,
+    TableFieldInfo,
+    TimeFieldInfo,
+    UintFieldInfo,
+)
+
+from ._string_types import PandaName
+
+# Pyright gives us variable not allowed in type expression error
+# if we try to use the new (|) syntax
+ResponseType = Union[
+    BitMuxFieldInfo,
+    BitOutFieldInfo,
+    EnumFieldInfo,
+    ExtOutBitsFieldInfo,
+    ExtOutFieldInfo,
+    FieldInfo,
+    PosMuxFieldInfo,
+    PosOutFieldInfo,
+    ScalarFieldInfo,
+    SubtypeTimeFieldInfo,
+    TableFieldInfo,
+    TimeFieldInfo,
+    UintFieldInfo,
+]
+
+RawBlocksType = dict[PandaName, BlockInfo]
+RawFieldsType = list[dict[PandaName, ResponseType]]
+RawInitialValuesType = dict[PandaName, str]