Simplify use of IOCRecordServer by unpacking multiple providers provided through .providers

Author: Monarda

examples/asyncio/ioc_fields_server.py

@@ -5,8 +5,9 @@
 Uses `IOCRecordServer`, which builds "<name>.<FIELD>" sub-PVs for free for
 any base PV in a providers=[] entry -- either an explicit `IOCRecordProvider`
 (needed for per-PV overrides, as for EXAMPLE:PV's dtyp_choices/fields below;
-note it isn't itself a single provider, so it's spread via `*base.providers`
-below), or, for the common case needing no overrides, a plain {name: pv} dict,
+passed directly below, same as any other provider -- `IOCRecordServer`
+unpacks it internally even though it isn't itself a single provider), or,
+for the common case needing no overrides, a plain {name: pv} dict,
 same as any ordinary p4p server (see EXAMPLE:PV2 below). Every sub-PV is built
 lazily, on first client connection, as a plain thread-flavored SharedPV --
 regardless of the base PV's own flavor (the asyncio `SharedPV` imported below,
@@ -47,7 +48,7 @@ async def main():
     )
     pvs = {"EXAMPLE:PV2": SharedPV(nt=NTScalar("i"), initial=0)}
 
-    with IOCRecordServer(providers=[*base.providers, pvs]):
+    with IOCRecordServer(providers=[base, pvs]):
         print("Serving:", list(base.providers[0].keys()) + list(pvs.keys()))
         print("Also serving <PV>.<FIELD> for FIELD in:", ", ".join(sorted(FIELD_NAMES)))
         try:

p4pillon/server/records/server.py

@@ -18,6 +18,13 @@
 __all__ = ("IOCRecordServer",)
 
 
+def _with_order(item: Any, order: int | None) -> Any:
+    # p4p.server.Server's providers= entries are either a bare provider or a
+    # (provider, order) tuple -- reattach whichever `order` this entry came
+    # in with (or none) to each provider it expands to.
+    return (item, order) if order is not None else item
+
+
 def _dynamic_fields_provider(provider: Any) -> _DynamicProvider | None:
     # Builds the *additional* DynamicRecordFields-backed provider for a
     # plain-dict entry's "<name>.<FIELD>" sub-PVs (see the class docstring
@@ -66,13 +73,22 @@ class IOCRecordServer(_Server):
     `StaticRecordProvider`'s `~p4p.server.StaticProvider` -- maintains no
     enumerable list of the names it can serve.
 
+    An `IOCRecordProvider` instance can also be passed directly, same as a
+    plain dict or a `StaticRecordProvider` -- unlike `~p4p.server.Server`
+    itself, which has no concept of a single `providers=` entry backed by two
+    providers underneath (see `IOCRecordProvider`'s docstring for why it
+    isn't itself a `~p4p.server.StaticProvider`/`~p4p.server.DynamicProvider`),
+    `IOCRecordServer` unpacks it into its `.providers` pair automatically, so
+    ``providers=[base, pvs]`` works the same as
+    ``providers=[*base.providers, pvs]``.
+
     For DESC updates after add(), per-PV overrides, matching sub-PV flavor to
     an asyncio base PV, or `pvlist` visibility, build a `StaticRecordProvider`
     explicitly (see its own docstring) and pass that instead of a dict;
-    entries that aren't a plain dict (a provider name string, or an
-    already-constructed provider instance, including a `StaticRecordProvider`)
-    are passed through to `~p4p.server.Server` unchanged, with no extra
-    "<name>.<FIELD>" handling added.
+    entries that aren't a plain dict or an `IOCRecordProvider` (a provider
+    name string, or an already-constructed provider instance, including a
+    `StaticRecordProvider`) are passed through to `~p4p.server.Server`
+    unchanged, with no extra "<name>.<FIELD>" handling added.
     """
 
     def __init__(self, providers: list[Any], isolate: bool = False, **kws: Any) -> None:
@@ -86,9 +102,17 @@ def __init__(self, providers: list[Any], isolate: bool = False, **kws: Any) -> N
         wrapped: list[Any] = []
         for entry in providers:
             provider, order = entry if isinstance(entry, tuple) else (entry, None)
-            wrapped.append((provider, order) if order is not None else provider)
+            sub_providers = getattr(provider, "providers", None)
+            if isinstance(sub_providers, tuple):
+                # Already backed by its own provider pair (e.g.
+                # IOCRecordProvider's static + DynamicRecordFields pair) --
+                # unpack rather than treating it as a single provider (it
+                # isn't one) or a dict (it has no .items()).
+                wrapped.extend(_with_order(sub_provider, order) for sub_provider in sub_providers)
+                continue
+            wrapped.append(_with_order(provider, order))
             fields_provider = _dynamic_fields_provider(provider)
             if fields_provider is not None:
                 self._field_providers.append(fields_provider)
-                wrapped.append((fields_provider, order) if order is not None else fields_provider)
+                wrapped.append(_with_order(fields_provider, order))
         super().__init__(wrapped, isolate=isolate, **kws)

tests/unit/server/test_records.py

@@ -431,6 +431,22 @@ def test_mixed_dict_and_provider_entries(self):
                 assert C.get("EXAMPLE:PV.RTYP") == "ai"
                 assert C.get("EXPLICIT:PV.RTYP") == "ai"
 
+    def test_ioc_record_provider_passed_directly(self):
+        # An IOCRecordProvider isn't itself a single provider (it holds a
+        # StaticProvider + DynamicProvider pair, see its own docstring) --
+        # IOCRecordServer should unpack it automatically, so passing it bare
+        # works the same as spreading it via *base.providers.
+        base = IOCRecordProvider("base")
+        base.add("EXAMPLE:PV", _pv(), dtyp_choices=["Soft Channel", "Raw Soft Channel"])
+        pvs = {"EXAMPLE:PV2": _pv()}
+
+        with IOCRecordServer(providers=[base, pvs], isolate=True) as S:
+            with Context("pva", conf=S.conf(), useenv=False) as C:
+                assert C.get("EXAMPLE:PV") == 1.234
+                assert C.get("EXAMPLE:PV.RTYP") == "ai"
+                assert C.get("EXAMPLE:PV.DTYP").raw["value.choices"] == ["Soft Channel", "Raw Soft Channel"]
+                assert C.get("EXAMPLE:PV2.RTYP") == "ai"
+
 
 class TestDynamicRecordFields:
     def test_unknown_fields_key_warns_eagerly_at_construction(self):