New BPM holder API, holder factorization

pyaml/apidoc/gen_api.py

@@ -28,12 +28,7 @@
     "pyaml.common.element",
     "pyaml.common.exception",
     "pyaml.common.holders.element_holder",
-    "pyaml.common.holders.magnet_holder",
-    "pyaml.common.holders.magnets_holder",
-    "pyaml.common.holders.serialized_magnet_holder",
-    "pyaml.common.holders.serialized_magnets_holder",
-    "pyaml.common.holders.combinded_function_magnet_holder",
-    "pyaml.common.holders.combinded_function_magnets_holder",
+    "pyaml.common.holders.sub_holders",
     "pyaml.configuration.factory",
     "pyaml.configuration.fileloader",
     "pyaml.configuration.manager",

pyaml/arrays/bpm.py

@@ -64,4 +64,4 @@ def fill_array(self, holder: ElementHolder):
         holder : ElementHolder
             The element holder to populate the :py:class:`.BPMArray` with.
         """
-        holder.fill_bpm_array(self._name, self._elements)
+        holder.bpms.add(self._name, self._elements)

pyaml/common/holders/element_holder.py

@@ -23,12 +23,16 @@
 from ..abstract_aggregator import ScalarAggregator
 from ..element import Element
 from ..exception import PyAMLException
-from .combinded_function_magnet_holder import CombinedFunctionMagnetHolder
-from .combinded_function_magnets_holder import CombinedFunctionMagnetsHolder
-from .magnet_holder import MagnetHolder
-from .magnets_holder import MagnetsHolder
-from .serialized_magnet_holder import SerializedMagnetHolder
-from .serialized_magnets_holder import SerializedMagnetsHolder
+from .sub_holders import (
+    BPMHolder,
+    BPMsHolder,
+    CombinedFunctionMagnetHolder,
+    CombinedFunctionMagnetsHolder,
+    MagnetHolder,
+    MagnetsHolder,
+    SerializedMagnetHolder,
+    SerializedMagnetsHolder,
+)
 
 if TYPE_CHECKING:
     from ...accelerator import Accelerator
@@ -83,6 +87,8 @@ def __init__(self):
         self._serialized_magnets_holder = SerializedMagnetsHolder(self)
         self._combined_function_magnet_holder = CombinedFunctionMagnetHolder(self)
         self._combined_function_magnets_holder = CombinedFunctionMagnetsHolder(self)
+        self._bpm_holder = BPMHolder(self)
+        self._bpms_holder = BPMsHolder(self)
 
     @property
     def peer(self) -> "Accelerator":
@@ -117,6 +123,14 @@ def combined_function_magnet(self) -> CombinedFunctionMagnetHolder:
     def combined_function_magnets(self) -> CombinedFunctionMagnetsHolder:
         return self._combined_function_magnets_holder
 
+    @property
+    def bpm(self) -> BPMHolder:
+        return self._bpm_holder
+
+    @property
+    def bpms(self) -> BPMsHolder:
+        return self._bpms_holder
+
     def post_init(self):
         """
         Method triggered after all initialisations are done
@@ -219,29 +233,6 @@ def get_elements(self, name: str) -> ElementArray:
     def get_all_elements(self) -> list[Element]:
         return [value for key, value in self._ALL.items()]
 
-    # BPMs
-
-    def fill_bpm_array(self, arrayName: str, elementNames: list[str]):
-        self._fill_array(
-            arrayName,
-            elementNames,
-            self.get_bpm,
-            BPMArray,
-            self._BPM_ARRAYS,
-        )
-
-    def get_bpm(self, name: str) -> BPM:
-        return self._get("BPM", name, self._BPMS)
-
-    def add_bpm(self, bpm: BPM):
-        self._add(self._BPMS, bpm)
-
-    def get_bpms(self, name: str) -> BPMArray:
-        return self._get("BPM array", name, self._BPM_ARRAYS)
-
-    def get_all_bpms(self) -> list[BPM]:
-        return [value for key, value in self._BPMS.items()]
-
     # RF
 
     def get_rf_plant(self, name: str) -> RFPlant:

pyaml/common/holders/generic_array_holder.py

@@ -0,0 +1,67 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from ..element import Element
+
+if TYPE_CHECKING:
+    from .element_holder import ElementHolder
+
+T = TypeVar("T", bound=Element)
+A = TypeVar("A")
+
+
+class GenericArrayHolder(Generic[T, A]):
+    """
+    Generic holder for arrays of elements (e.g. magnet arrays, BPM arrays).
+
+    Concrete holders (:class:`.MagnetsHolder`, :class:`.SerializedMagnetsHolder`,
+    :class:`.CombinedFunctionMagnetsHolder`, ...) subclass this with the
+    element type ``T`` and the array type ``A`` they handle, so callers keep
+    full static typing on :meth:`get`, :meth:`add` and :meth:`__getitem__`.
+    """
+
+    def __init__(
+        self,
+        peer: "ElementHolder",
+        array_store: dict[str, A],
+        all_func: Callable[[], list[T]],
+        get_func: Callable[[str], T],
+        constructor: Callable[[str, list[T]], A],
+        what: str,
+    ):
+        self._peer = peer
+        self._array_store = array_store
+        self._all_func = all_func
+        self._get_func = get_func
+        self._constructor = constructor
+        self._what = what
+
+    def get(self, name: str | None = None) -> A:
+        """
+        Returns the specified array or all elements if no name specified
+
+        Parameters
+        ----------
+        name : str
+            Name of the array
+        """
+        if name is None:
+            return self._constructor("", self._all_func())
+        else:
+            return self._peer._get(self._what, name, self._array_store)
+
+    def add(self, arrayName: str, elementNames: list[str]):
+        """
+        Adds the specified array to the holder
+
+        Parameters
+        ----------
+        arrayName : str
+            Array name
+        elementNames : list[str]
+            List of element names
+        """
+        self._peer._fill_array(arrayName, elementNames, self._get_func, self._constructor, self._array_store)
+
+    def __getitem__(self, key):
+        return self.get().__getitem__(key)

pyaml/common/holders/generic_element_holder.py

@@ -0,0 +1,52 @@
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from ..element import Element
+
+if TYPE_CHECKING:
+    from .element_holder import ElementHolder
+
+T = TypeVar("T", bound=Element)
+
+
+class GenericElementHolder(Generic[T]):
+    """
+    Generic holder for a single kind of element (e.g. magnets, BPMs).
+
+    Concrete holders (:class:`.MagnetHolder`, :class:`.SerializedMagnetHolder`,
+    :class:`.CombinedFunctionMagnetHolder`, ...) subclass this with the
+    element type they handle, so callers keep full static typing on
+    :meth:`all`, :meth:`get` and :meth:`add`.
+    """
+
+    def __init__(self, peer: "ElementHolder", store: dict[str, T], what: str):
+        self._peer = peer
+        self._store = store
+        self._what = what
+
+    def all(self) -> list[T]:
+        """
+        Returns all elements as a list
+        """
+        return [value for key, value in self._store.items()]
+
+    def get(self, name: str) -> T:
+        """
+        Returns the specified element
+
+        Parameters
+        ----------
+        name : str
+            Name of the element
+        """
+        return self._peer._get(self._what, name, self._store)
+
+    def add(self, m: T):
+        """
+        Adds the specified element to the holder
+
+        Parameters
+        ----------
+        m : T
+           Element to be added
+        """
+        self._peer._add(self._store, m)