remoteRF-server 1.0.7__tar.gz → 1.0.8__tar.gz

{remoterf_server-1.0.7 → remoterf_server-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.0.7
+Version: 1.0.8
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{remoterf_server-1.0.7 → remoterf_server-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "1.0.7"
+version = "1.0.8"
 description = "RemoteRF server-side control package"
 requires-python = ">=3.10"
 dependencies = [

{remoterf_server-1.0.7/src/remoteRF_server/drivers/adalm_pluto → remoterf_server-1.0.8/src/remoteRF_server/common/idl}/pluto_schema.py

@@ -8,6 +8,26 @@ import subprocess
 import re
 import adi
 
+
+def _normalize_channels(value):
+    """Restore channel lists after numeric lists cross the legacy RPC codec."""
+    if hasattr(value, "tolist"):
+        value = value.tolist()
+    if isinstance(value, tuple):
+        value = list(value)
+    if not isinstance(value, list):
+        return value
+
+    channels = []
+    for channel in value:
+        if not isinstance(channel, str):
+            integer = int(channel)
+            if channel == integer:
+                channel = integer
+        channels.append(channel)
+    return channels
+
+
 # == PLUTO Connection Logic ==
 
 def connect_pluto(*, serial: str):
@@ -50,7 +70,7 @@ class PlutoSchema(DeviceSchema):
 
     device_type = "adalm_pluto"
     client_class = "Pluto"
-    driver_version = "0.0.1"
+    driver_version = "0.0.2"
 
     @staticmethod
     def make_device(**kwargs):
@@ -85,13 +105,13 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="get")
     def get_rx_hardwaregain_chan0(self):
-        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
-        return self.device.hardwaregain_chan0
+        """RX hardware gain (dB). pyadi-iio attribute: rx_hardwaregain_chan0"""
+        return self.device.rx_hardwaregain_chan0
 
     @idl_expose(kind="set")
     def set_rx_hardwaregain_chan0(self, value):
-        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
-        self.device.hardwaregain_chan0 = value
+        """RX hardware gain (dB). pyadi-iio attribute: rx_hardwaregain_chan0"""
+        self.device.rx_hardwaregain_chan0 = value
 
     @idl_expose(kind="get")
     def get_tx_hardwaregain_chan0(self):
@@ -180,6 +200,109 @@ class PlutoSchema(DeviceSchema):
         """Disable the internal DDS tone generator."""
         self.device.disable_dds()
 
+    # region DDS
+
+    @idl_expose(kind="call")
+    def call_dds_single_tone(self, frequency, scale, channel=0):
+        """Generate one complex DDS tone on the selected TX channel."""
+        self.device.dds_single_tone(frequency, scale, channel)
+
+    @idl_expose(kind="call")
+    def call_dds_dual_tone(
+        self,
+        frequency1,
+        scale1,
+        frequency2,
+        scale2,
+        channel=0,
+    ):
+        """Generate two complex DDS tones on the selected TX channel."""
+        self.device.dds_dual_tone(
+            frequency1,
+            scale1,
+            frequency2,
+            scale2,
+            channel,
+        )
+
+    @idl_expose(kind="get")
+    def get_dds_frequencies(self):
+        return self.device.dds_frequencies
+
+    @idl_expose(kind="set")
+    def set_dds_frequencies(self, value):
+        self.device.dds_frequencies = value
+
+    @idl_expose(kind="get")
+    def get_dds_scales(self):
+        return self.device.dds_scales
+
+    @idl_expose(kind="set")
+    def set_dds_scales(self, value):
+        self.device.dds_scales = value
+
+    @idl_expose(kind="get")
+    def get_dds_phases(self):
+        return self.device.dds_phases
+
+    @idl_expose(kind="set")
+    def set_dds_phases(self, value):
+        self.device.dds_phases = value
+
+    @idl_expose(kind="get")
+    def get_dds_enabled(self):
+        return self.device.dds_enabled
+
+    @idl_expose(kind="set")
+    def set_dds_enabled(self, value):
+        self.device.dds_enabled = value
+
+    # endregion
+
+    # region channel configuration
+
+    @idl_expose(kind="get")
+    def get_rx_enabled_channels(self):
+        return self.device.rx_enabled_channels
+
+    @idl_expose(kind="set")
+    def set_rx_enabled_channels(self, value):
+        self.device.rx_enabled_channels = _normalize_channels(value)
+
+    @idl_expose(kind="get")
+    def get_tx_enabled_channels(self):
+        return self.device.tx_enabled_channels
+
+    @idl_expose(kind="set")
+    def set_tx_enabled_channels(self, value):
+        self.device.tx_enabled_channels = _normalize_channels(value)
+
+    @idl_expose(kind="get")
+    def get_rx_annotated(self):
+        return self.device.rx_annotated
+
+    @idl_expose(kind="set")
+    def set_rx_annotated(self, value):
+        self.device.rx_annotated = value
+
+    @idl_expose(kind="get")
+    def get_rx_output_type(self):
+        return self.device.rx_output_type
+
+    @idl_expose(kind="set")
+    def set_rx_output_type(self, value):
+        self.device.rx_output_type = value
+
+    @idl_expose(kind="get")
+    def get_rx_channel_names(self):
+        return self.device.rx_channel_names
+
+    @idl_expose(kind="get")
+    def get_tx_channel_names(self):
+        return self.device.tx_channel_names
+
+    # endregion
+
     # endregion
 
     # region ip / repr

{remoterf_server-1.0.7/src/remoteRF_server/common/idl → remoterf_server-1.0.8/src/remoteRF_server/drivers/adalm_pluto}/pluto_schema.py

@@ -8,6 +8,26 @@ import subprocess
 import re
 import adi
 
+
+def _normalize_channels(value):
+    """Restore channel lists after numeric lists cross the legacy RPC codec."""
+    if hasattr(value, "tolist"):
+        value = value.tolist()
+    if isinstance(value, tuple):
+        value = list(value)
+    if not isinstance(value, list):
+        return value
+
+    channels = []
+    for channel in value:
+        if not isinstance(channel, str):
+            integer = int(channel)
+            if channel == integer:
+                channel = integer
+        channels.append(channel)
+    return channels
+
+
 # == PLUTO Connection Logic ==
 
 def connect_pluto(*, serial: str):
@@ -50,7 +70,7 @@ class PlutoSchema(DeviceSchema):
 
     device_type = "adalm_pluto"
     client_class = "Pluto"
-    driver_version = "0.0.1"
+    driver_version = "0.0.2"
 
     @staticmethod
     def make_device(**kwargs):
@@ -85,13 +105,13 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="get")
     def get_rx_hardwaregain_chan0(self):
-        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
-        return self.device.hardwaregain_chan0
+        """RX hardware gain (dB). pyadi-iio attribute: rx_hardwaregain_chan0"""
+        return self.device.rx_hardwaregain_chan0
 
     @idl_expose(kind="set")
     def set_rx_hardwaregain_chan0(self, value):
-        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
-        self.device.hardwaregain_chan0 = value
+        """RX hardware gain (dB). pyadi-iio attribute: rx_hardwaregain_chan0"""
+        self.device.rx_hardwaregain_chan0 = value
 
     @idl_expose(kind="get")
     def get_tx_hardwaregain_chan0(self):
@@ -180,6 +200,109 @@ class PlutoSchema(DeviceSchema):
         """Disable the internal DDS tone generator."""
         self.device.disable_dds()
 
+    # region DDS
+
+    @idl_expose(kind="call")
+    def call_dds_single_tone(self, frequency, scale, channel=0):
+        """Generate one complex DDS tone on the selected TX channel."""
+        self.device.dds_single_tone(frequency, scale, channel)
+
+    @idl_expose(kind="call")
+    def call_dds_dual_tone(
+        self,
+        frequency1,
+        scale1,
+        frequency2,
+        scale2,
+        channel=0,
+    ):
+        """Generate two complex DDS tones on the selected TX channel."""
+        self.device.dds_dual_tone(
+            frequency1,
+            scale1,
+            frequency2,
+            scale2,
+            channel,
+        )
+
+    @idl_expose(kind="get")
+    def get_dds_frequencies(self):
+        return self.device.dds_frequencies
+
+    @idl_expose(kind="set")
+    def set_dds_frequencies(self, value):
+        self.device.dds_frequencies = value
+
+    @idl_expose(kind="get")
+    def get_dds_scales(self):
+        return self.device.dds_scales
+
+    @idl_expose(kind="set")
+    def set_dds_scales(self, value):
+        self.device.dds_scales = value
+
+    @idl_expose(kind="get")
+    def get_dds_phases(self):
+        return self.device.dds_phases
+
+    @idl_expose(kind="set")
+    def set_dds_phases(self, value):
+        self.device.dds_phases = value
+
+    @idl_expose(kind="get")
+    def get_dds_enabled(self):
+        return self.device.dds_enabled
+
+    @idl_expose(kind="set")
+    def set_dds_enabled(self, value):
+        self.device.dds_enabled = value
+
+    # endregion
+
+    # region channel configuration
+
+    @idl_expose(kind="get")
+    def get_rx_enabled_channels(self):
+        return self.device.rx_enabled_channels
+
+    @idl_expose(kind="set")
+    def set_rx_enabled_channels(self, value):
+        self.device.rx_enabled_channels = _normalize_channels(value)
+
+    @idl_expose(kind="get")
+    def get_tx_enabled_channels(self):
+        return self.device.tx_enabled_channels
+
+    @idl_expose(kind="set")
+    def set_tx_enabled_channels(self, value):
+        self.device.tx_enabled_channels = _normalize_channels(value)
+
+    @idl_expose(kind="get")
+    def get_rx_annotated(self):
+        return self.device.rx_annotated
+
+    @idl_expose(kind="set")
+    def set_rx_annotated(self, value):
+        self.device.rx_annotated = value
+
+    @idl_expose(kind="get")
+    def get_rx_output_type(self):
+        return self.device.rx_output_type
+
+    @idl_expose(kind="set")
+    def set_rx_output_type(self, value):
+        self.device.rx_output_type = value
+
+    @idl_expose(kind="get")
+    def get_rx_channel_names(self):
+        return self.device.rx_channel_names
+
+    @idl_expose(kind="get")
+    def get_tx_channel_names(self):
+        return self.device.tx_channel_names
+
+    # endregion
+
     # endregion
 
     # region ip / repr

{remoterf_server-1.0.7 → remoterf_server-1.0.8}/src/remoteRF_server/drivers/usrp/usrp_schema.py

@@ -98,6 +98,31 @@ def _payload_type(value):
     return None
 
 
+def _tune_request_policy(value, current):
+    """Translate a portable policy name back to UHD's native enum value."""
+    if not isinstance(value, str):
+        return value
+    name = value.rsplit(".", 1)[-1].upper()
+    policy_types = (
+        type(current),
+        getattr(getattr(uhd, "types", None), "TuneRequestPolicy", None),
+        getattr(getattr(uhd, "types", None), "tune_request_policy", None),
+        getattr(
+            getattr(getattr(uhd, "libpyuhd", None), "types", None),
+            "tune_request_policy",
+            None,
+        ),
+    )
+    for policy_type in policy_types:
+        if policy_type is None:
+            continue
+        for candidate in (name, name.lower(), f"POLICY_{name}"):
+            native = getattr(policy_type, candidate, None)
+            if native is not None:
+                return native
+    return value
+
+
 def _require_dict(value, method):
     if not isinstance(value, dict):
         raise TypeError(
@@ -159,7 +184,16 @@ def _construct(value):
         return uhd.usrp.SubdevSpec(value["spec"])
 
     if kind == "TuneRequest":
-        args = [_construct(item) for item in value.get("args", ())]
+        # Older generated clients used ``args`` for constructor arguments.
+        # Current TuneRequest snapshots use that same key for UHD's DeviceAddr
+        # field, so only sequences may be interpreted as constructor arguments.
+        raw_args = value.get("args", ())
+        legacy_constructor_args = isinstance(raw_args, (list, tuple))
+        args = (
+            [_construct(item) for item in raw_args]
+            if legacy_constructor_args
+            else []
+        )
         kwargs = {
             key: _construct(item)
             for key, item in value.get("kwargs", {}).items()
@@ -174,10 +208,18 @@ def _construct(value):
         obj = constructor(*args, **kwargs)
         for field in (
             "rf_freq", "dsp_freq", "rf_freq_policy", "dsp_freq_policy",
-            "target_freq", "lo_offset", "args",
+            "args",
         ):
+            if field == "args" and legacy_constructor_args:
+                continue
             if field in value and hasattr(obj, field):
-                setattr(obj, field, _construct(value[field]))
+                converted = _construct(value[field])
+                if field in {"rf_freq_policy", "dsp_freq_policy"}:
+                    converted = _tune_request_policy(
+                        converted,
+                        getattr(obj, field),
+                    )
+                setattr(obj, field, converted)
         return obj
 
     if kind == "DeviceAddr":

{remoterf_server-1.0.7 → remoterf_server-1.0.8}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.0.7
+Version: 1.0.8
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{remoterf_server-1.0.7 → remoterf_server-1.0.8}/tests/test_idl_schema.py

@@ -319,6 +319,25 @@ class DeviceSchemaTests(unittest.TestCase):
             def __init__(self, spec):
                 self.spec = spec
 
+        class DeviceAddr:
+            def __init__(self, value=""):
+                self.value = value
+
+        class TuneRequestPolicy:
+            AUTO = object()
+            MANUAL = object()
+            NONE = object()
+
+        class TuneRequest:
+            def __init__(self, target_freq=0.0, lo_offset=None):
+                self.target_freq = float(target_freq)
+                self.lo_offset = lo_offset
+                self.rf_freq = 0.0
+                self.dsp_freq = 0.0
+                self.rf_freq_policy = TuneRequestPolicy.AUTO
+                self.dsp_freq_policy = TuneRequestPolicy.AUTO
+                self.args = DeviceAddr()
+
         class TXMetadata:
             def __init__(self):
                 self.has_time_spec = False
@@ -334,6 +353,9 @@ class DeviceSchemaTests(unittest.TestCase):
 
         fake_uhd.types = types.SimpleNamespace(
             TimeSpec=TimeSpec,
+            DeviceAddr=DeviceAddr,
+            TuneRequest=TuneRequest,
+            TuneRequestPolicy=TuneRequestPolicy,
             TXMetadata=TXMetadata,
             StreamCMD=StreamCMD,
             StreamMode=types.SimpleNamespace(
@@ -403,9 +425,32 @@ class DeviceSchemaTests(unittest.TestCase):
         tune = usrp_schema._construct({
             "__uhd_type__": "TuneRequest",
             "args": [915e6],
-            "kwargs": {"dsp_freq": 0.0},
+            "kwargs": {},
+        })
+        self.assertIsInstance(tune, TuneRequest)
+        self.assertEqual(tune.target_freq, 915e6)
+
+        tune = usrp_schema._construct({
+            "__uhd_type__": "TuneRequest",
+            "target_freq": 100e6,
+            "lo_offset": None,
+            "rf_freq": 99e6,
+            "dsp_freq": 1e6,
+            "rf_freq_policy": "MANUAL",
+            "dsp_freq_policy": "AUTO",
+            "args": {
+                "__uhd_type__": "DeviceAddr",
+                "items": {"mode_n": "integer"},
+            },
         })
-        self.assertEqual(tune, {"args": (915e6,), "kwargs": {"dsp_freq": 0.0}})
+        self.assertIsInstance(tune, TuneRequest)
+        self.assertEqual(tune.target_freq, 100e6)
+        self.assertEqual(tune.rf_freq, 99e6)
+        self.assertEqual(tune.dsp_freq, 1e6)
+        self.assertIs(tune.rf_freq_policy, TuneRequestPolicy.MANUAL)
+        self.assertIs(tune.dsp_freq_policy, TuneRequestPolicy.AUTO)
+        self.assertIsInstance(tune.args, DeviceAddr)
+        self.assertEqual(tune.args.value, "mode_n=integer")
 
         subdev = usrp_schema._construct({"__uhd_type__": "SubdevSpec", "spec": "A:0"})
         self.assertIsInstance(subdev, SubdevSpec)

remoterf_server-1.0.8/tests/test_pluto_compat.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import sys
+import types
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+
+sys.modules.setdefault("adi", types.ModuleType("adi"))
+
+from remoteRF_server.common.idl.pluto_schema import PlutoSchema
+from remoteRF_server.common.utils import map_arg, unmap_arg
+from remoteRF_server.drivers.adalm_pluto.pluto_remote_server import PlutoServer
+from remoteRF_server.server import device_manager
+
+
+class FakePluto:
+    def __init__(self):
+        self.sample_rate = 1_000_000
+        self.rx_hardwaregain_chan0 = 12.5
+        self.dds_frequencies = [100_000, 100_000]
+        self.dds_scales = [0.25, 0.25]
+        self.dds_phases = [0, 90_000]
+        self.dds_enabled = [True, True]
+        self.rx_enabled_channels = [0]
+        self.tx_enabled_channels = [0]
+        self.rx_annotated = False
+        self.rx_output_type = "raw"
+        self.rx_channel_names = ["voltage0", "voltage1"]
+        self.tx_channel_names = ["voltage0", "voltage1"]
+        self.single_tone_args = None
+        self.dual_tone_args = None
+        self.tx_samples = None
+        self.rx_samples = np.array([1 + 2j, 3 + 4j], dtype=np.complex64)
+
+    def rx(self):
+        return self.rx_samples
+
+    def tx(self, samples):
+        self.tx_samples = samples
+
+    def dds_single_tone(self, frequency, scale, channel=0):
+        self.single_tone_args = (frequency, scale, channel)
+
+    def dds_dual_tone(
+        self,
+        frequency1,
+        scale1,
+        frequency2,
+        scale2,
+        channel=0,
+    ):
+        self.dual_tone_args = (
+            frequency1,
+            scale1,
+            frequency2,
+            scale2,
+            channel,
+        )
+
+
+class PlutoCompatTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.device = FakePluto()
+
+    def handle(self, function_name: str, args: dict):
+        with patch(
+            "remoteRF_server.drivers.adalm_pluto.pluto_remote_server.device_pluto",
+            return_value=self.device,
+        ):
+            return PlutoServer.handle_call(function_name=function_name, args=args)
+
+    def test_get_and_set_still_use_legacy_token_paths(self) -> None:
+        response = self.handle("Pluto:sample_rate:GET", {"a": map_arg("token")})
+        self.assertEqual(unmap_arg(response["sample_rate"]), 1_000_000)
+
+        response = self.handle(
+            "Pluto:sample_rate:SET",
+            {"a": map_arg("token"), "sample_rate": map_arg(2_000_000)},
+        )
+        self.assertEqual(response, {})
+        self.assertEqual(self.device.sample_rate, 2_000_000)
+
+    def test_call0_and_call1_still_use_existing_wire_shape(self) -> None:
+        response = self.handle("Pluto:rx:CALL0", {"a": map_arg("token")})
+        np.testing.assert_allclose(unmap_arg(response["rx"]), self.device.rx_samples)
+
+        samples = np.array([5 + 6j, 7 + 8j], dtype=np.complex64)
+        response = self.handle(
+            "Pluto:tx:CALL1",
+            {"a": map_arg("token"), "arg1": map_arg(samples)},
+        )
+        self.assertEqual(unmap_arg(response["tx"]), "None")
+        np.testing.assert_allclose(self.device.tx_samples, samples)
+
+    def test_schema_dispatch_preserves_pluto_get_set_call0_and_call1(self) -> None:
+        schema = PlutoSchema()
+        schema.bind(self.device)
+
+        idl = schema.get_idl()
+        self.assertEqual(idl["calls"]["call_rx"]["args"], [])
+        self.assertEqual(idl["calls"]["call_tx"]["args"][0]["name"], "value")
+        self.assertTrue(idl["calls"]["call_tx"]["args"][0]["required"])
+
+        self.assertEqual(schema.dispatch("get_sample_rate", {}), 1_000_000)
+        schema.dispatch("set_sample_rate", {"value": 2_000_000})
+        self.assertEqual(self.device.sample_rate, 2_000_000)
+
+        np.testing.assert_allclose(schema.dispatch("call_rx", {}), self.device.rx_samples)
+        samples = np.array([9 + 1j, 10 + 2j], dtype=np.complex64)
+        self.assertIsNone(schema.dispatch("call_tx", {"value": samples}))
+        np.testing.assert_allclose(self.device.tx_samples, samples)
+
+    def test_schema_rx_hardware_gain_uses_pyadi_property_name(self) -> None:
+        schema = PlutoSchema()
+        schema.bind(self.device)
+
+        self.assertEqual(schema.dispatch("get_rx_hardwaregain_chan0", {}), 12.5)
+        schema.dispatch("set_rx_hardwaregain_chan0", {"value": 24.0})
+        self.assertEqual(self.device.rx_hardwaregain_chan0, 24.0)
+
+    def test_schema_exposes_dds_generation_and_controls(self) -> None:
+        schema = PlutoSchema()
+        schema.bind(self.device)
+
+        idl = schema.get_idl()
+        single_args = idl["calls"]["call_dds_single_tone"]["args"]
+        dual_args = idl["calls"]["call_dds_dual_tone"]["args"]
+        self.assertEqual(
+            [arg["name"] for arg in single_args],
+            ["frequency", "scale", "channel"],
+        )
+        self.assertEqual(single_args[-1]["default"], 0)
+        self.assertEqual(
+            [arg["name"] for arg in dual_args],
+            ["frequency1", "scale1", "frequency2", "scale2", "channel"],
+        )
+        self.assertEqual(dual_args[-1]["default"], 0)
+
+        schema.dispatch(
+            "call_dds_single_tone",
+            {"frequency": 125_000, "scale": 0.5},
+        )
+        self.assertEqual(self.device.single_tone_args, (125_000, 0.5, 0))
+        schema.dispatch(
+            "call_dds_dual_tone",
+            {
+                "frequency1": 100_000,
+                "scale1": 0.25,
+                "frequency2": -200_000,
+                "scale2": 0.4,
+                "channel": 1,
+            },
+        )
+        self.assertEqual(
+            self.device.dual_tone_args,
+            (100_000, 0.25, -200_000, 0.4, 1),
+        )
+
+        controls = {
+            "dds_frequencies": [200_000, 200_000],
+            "dds_scales": [0.5, 0.5],
+            "dds_phases": [90_000, 0],
+            "dds_enabled": [False, True],
+        }
+        for name, value in controls.items():
+            schema.dispatch(f"set_{name}", {"value": value})
+            self.assertEqual(schema.dispatch(f"get_{name}", {}), value)
+
+    def test_schema_exposes_channel_selection_and_receive_formatting(self) -> None:
+        schema = PlutoSchema()
+        schema.bind(self.device)
+
+        # Numeric lists use ndarray transport in the legacy codec. The schema
+        # restores the integer list shape required by pyadi-iio.
+        encoded_channels = unmap_arg(map_arg([0]))
+        schema.dispatch("set_rx_enabled_channels", {"value": encoded_channels})
+        self.assertEqual(self.device.rx_enabled_channels, [0])
+        self.assertIs(type(self.device.rx_enabled_channels[0]), int)
+
+        schema.dispatch("set_tx_enabled_channels", {"value": ["voltage0"]})
+        self.assertEqual(self.device.tx_enabled_channels, ["voltage0"])
+        schema.dispatch("set_rx_annotated", {"value": True})
+        schema.dispatch("set_rx_output_type", {"value": "SI"})
+        self.assertTrue(schema.dispatch("get_rx_annotated", {}))
+        self.assertEqual(schema.dispatch("get_rx_output_type", {}), "SI")
+
+    def test_schema_exposes_channel_metadata_as_read_only(self) -> None:
+        schema = PlutoSchema()
+        schema.bind(self.device)
+
+        idl = schema.get_idl()
+        self.assertEqual(
+            schema.dispatch("get_rx_channel_names", {}),
+            ["voltage0", "voltage1"],
+        )
+        self.assertEqual(
+            schema.dispatch("get_tx_channel_names", {}),
+            ["voltage0", "voltage1"],
+        )
+        self.assertNotIn("set_rx_channel_names", idl["setters"])
+        self.assertNotIn("set_tx_channel_names", idl["setters"])
+
+    def test_legacy_pluto_inventory_type_resolves_to_packaged_schema(self) -> None:
+        with patch.object(PlutoSchema, "make_device", return_value=self.device):
+            schema, ident, dtype = device_manager._connect_from_record(
+                {
+                    "TYPE": "pluto",
+                    "IDENT": "104473f6",
+                    "INIT": {"serial": "104473f6"},
+                }
+            )
+
+        self.assertIsInstance(schema, PlutoSchema)
+        self.assertEqual(ident, "104473f6")
+        self.assertEqual(dtype, "adalm_pluto")
+
+
+if __name__ == "__main__":
+    unittest.main()

remoterf_server-1.0.7/tests/test_pluto_compat.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import sys
-import types
-import unittest
-from unittest.mock import patch
-
-import numpy as np
-
-sys.modules.setdefault("adi", types.ModuleType("adi"))
-
-from remoteRF_server.common.idl.pluto_schema import PlutoSchema
-from remoteRF_server.common.utils import map_arg, unmap_arg
-from remoteRF_server.drivers.adalm_pluto.pluto_remote_server import PlutoServer
-from remoteRF_server.server import device_manager
-
-
-class FakePluto:
-    def __init__(self):
-        self.sample_rate = 1_000_000
-        self.tx_samples = None
-        self.rx_samples = np.array([1 + 2j, 3 + 4j], dtype=np.complex64)
-
-    def rx(self):
-        return self.rx_samples
-
-    def tx(self, samples):
-        self.tx_samples = samples
-
-
-class PlutoCompatTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.device = FakePluto()
-
-    def handle(self, function_name: str, args: dict):
-        with patch(
-            "remoteRF_server.drivers.adalm_pluto.pluto_remote_server.device_pluto",
-            return_value=self.device,
-        ):
-            return PlutoServer.handle_call(function_name=function_name, args=args)
-
-    def test_get_and_set_still_use_legacy_token_paths(self) -> None:
-        response = self.handle("Pluto:sample_rate:GET", {"a": map_arg("token")})
-        self.assertEqual(unmap_arg(response["sample_rate"]), 1_000_000)
-
-        response = self.handle(
-            "Pluto:sample_rate:SET",
-            {"a": map_arg("token"), "sample_rate": map_arg(2_000_000)},
-        )
-        self.assertEqual(response, {})
-        self.assertEqual(self.device.sample_rate, 2_000_000)
-
-    def test_call0_and_call1_still_use_existing_wire_shape(self) -> None:
-        response = self.handle("Pluto:rx:CALL0", {"a": map_arg("token")})
-        np.testing.assert_allclose(unmap_arg(response["rx"]), self.device.rx_samples)
-
-        samples = np.array([5 + 6j, 7 + 8j], dtype=np.complex64)
-        response = self.handle(
-            "Pluto:tx:CALL1",
-            {"a": map_arg("token"), "arg1": map_arg(samples)},
-        )
-        self.assertEqual(unmap_arg(response["tx"]), "None")
-        np.testing.assert_allclose(self.device.tx_samples, samples)
-
-    def test_schema_dispatch_preserves_pluto_get_set_call0_and_call1(self) -> None:
-        schema = PlutoSchema()
-        schema.bind(self.device)
-
-        idl = schema.get_idl()
-        self.assertEqual(idl["calls"]["call_rx"]["args"], [])
-        self.assertEqual(idl["calls"]["call_tx"]["args"][0]["name"], "value")
-        self.assertTrue(idl["calls"]["call_tx"]["args"][0]["required"])
-
-        self.assertEqual(schema.dispatch("get_sample_rate", {}), 1_000_000)
-        schema.dispatch("set_sample_rate", {"value": 2_000_000})
-        self.assertEqual(self.device.sample_rate, 2_000_000)
-
-        np.testing.assert_allclose(schema.dispatch("call_rx", {}), self.device.rx_samples)
-        samples = np.array([9 + 1j, 10 + 2j], dtype=np.complex64)
-        self.assertIsNone(schema.dispatch("call_tx", {"value": samples}))
-        np.testing.assert_allclose(self.device.tx_samples, samples)
-
-    def test_legacy_pluto_inventory_type_resolves_to_packaged_schema(self) -> None:
-        with patch.object(PlutoSchema, "make_device", return_value=self.device):
-            schema, ident, dtype = device_manager._connect_from_record(
-                {
-                    "TYPE": "pluto",
-                    "IDENT": "104473f6",
-                    "INIT": {"serial": "104473f6"},
-                }
-            )
-
-        self.assertIsInstance(schema, PlutoSchema)
-        self.assertEqual(ident, "104473f6")
-        self.assertEqual(dtype, "adalm_pluto")
-
-
-if __name__ == "__main__":
-    unittest.main()