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

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

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

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

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

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/src/remoteRF_server/drivers/usrp/uhd_manifest.py

@@ -1076,6 +1076,8 @@ def _objects() -> list[dict]:
         object_type("uhd", kind="namespace"),
         object_type("uhd.usrp", kind="namespace"),
         object_type("uhd.types", kind="namespace"),
+        object_type("uhd.dsp", kind="namespace"),
+        object_type("uhd.dsp.signals", kind="namespace"),
         object_type("uhd.filters", kind="namespace"),
         object_type("uhd.property", kind="namespace"),
         value(
@@ -1537,7 +1539,7 @@ ERRORS = (
 )
 
 
-def build_usrp_schema_v2(driver_version: str = "0.0.1") -> dict:
+def build_usrp_schema_v2(driver_version: str = "0.0.2") -> dict:
     signatures = _signatures()
     for additions in (
         _control_signatures(),
@@ -1580,6 +1582,11 @@ def build_usrp_schema_v2(driver_version: str = "0.0.1") -> dict:
         coverage[f"{item['owner']}.{item['name']}"] = "implemented"
 
     declared_owners = {item["owner"] for item in methods}
+    coverage.update({
+        "uhd.dsp.signals.get_continuous_tone": "implemented",
+        "uhd.dsp.signals.get_power_dbfs": "implemented",
+        "uhd.dsp.signals.get_usrp_power": "implemented",
+    })
     for item in _objects():
         path = item["python_path"]
         if item["kind"] == "value_class":
@@ -1603,6 +1610,14 @@ def build_usrp_schema_v2(driver_version: str = "0.0.1") -> dict:
                 else "deferred"
             )
 
+    # Remote streamers advertise an efficient RPC batch size rather than the
+    # device transport's packet size.  The server coalesces native RX packets,
+    # while UHD's native TX send already accepts a larger host buffer.
+    for owner in ("uhd.usrp.RXStreamer", "uhd.usrp.TXStreamer"):
+        coverage[f"{owner}.get_max_num_samps"] = (
+            "implemented_with_documented_remote_difference"
+        )
+
     return build_schema(
         device_type="usrp",
         client_class="MultiUSRP",

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

@@ -503,7 +503,7 @@ class UsrpSchema(DeviceSchema):
     device_type = "usrp"
     client_class = "MultiUSRP"
     client_objects = _uhd_client_objects()
-    driver_version = "0.0.1"
+    driver_version = "0.0.2"
     session_scoped = True
 
     def __init__(self):

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/src/remoteRF_server/server/device_manager.py

@@ -502,8 +502,19 @@ def _seed_default_driver(
     except OSError as e:
         print(f"Warning: could not create default driver config {target}: {e}")
 
+_LEGACY_PLUTO_SCHEMA_HASHES = (
+    # Built-in 0.0.1 schema shipped before managed-driver markers existed.
+    # An exact hash match is safe to upgrade; locally edited copies differ.
+    "a3697eeef55827e0db7705685f8fe64b615468dd26057211de8b5805b9ecf583",
+)
+
+
 def _seed_default_pluto_drivers() -> None:
-    _seed_default_driver("pluto_schema.py", "adalm_pluto")
+    _seed_default_driver(
+        "pluto_schema.py",
+        "adalm_pluto",
+        legacy_hashes=_LEGACY_PLUTO_SCHEMA_HASHES,
+    )
     _seed_default_driver("pluto_mimo_schema.py", "adalm_pluto_mimo")
 
 def _seed_default_usrp_driver() -> None:

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/src/remoteRF_server/server/dynamic_v2.py

@@ -1346,14 +1346,50 @@ class SampleDataV1Servicer(grpc_pb2_grpc.SampleDataV1Servicer):
                                 "UHD 4.10 Python RXStreamer.recv binding"
                             )
                         timeout = _sample_timeout(request.timeout_sec)
+                        deadline = time.monotonic() + timeout
+                        count = 0
+                        metadata_snapshot = snapshot_native(metadata)
                         with entry.lock:
-                            count = entry.value.recv(
-                                buffer,
-                                metadata,
-                                timeout,
-                            )
+                            while count < int(request.sample_count):
+                                remaining = max(0.0, deadline - time.monotonic())
+                                if count and remaining <= 0.0:
+                                    break
+                                current_metadata = (
+                                    metadata
+                                    if count == 0
+                                    else self._metadata_object(
+                                        session.schema,
+                                        "RXMetadata",
+                                        request.metadata_json,
+                                    )
+                                )
+                                target = buffer[..., count:]
+                                received = int(
+                                    entry.value.recv(
+                                        target,
+                                        current_metadata,
+                                        timeout if count == 0 else remaining,
+                                    )
+                                )
+                                if received < 0 or received > target.shape[-1]:
+                                    raise RemoteRFProtocolError(
+                                        "native RX returned an invalid sample count"
+                                    )
+                                current_snapshot = snapshot_native(current_metadata)
+                                error_code = str(
+                                    current_snapshot.get("error_code", "none")
+                                ).rsplit(".", 1)[-1].lower()
+                                has_error = error_code not in {
+                                    "none",
+                                    "error_code_none",
+                                }
+                                if count == 0 or has_error:
+                                    metadata = current_metadata
+                                    metadata_snapshot = current_snapshot
+                                count += received
+                                if received == 0 or has_error:
+                                    break
                         session_manager.get(session.session_id)
-                        count = int(count)
                         if count < 0 or count > int(request.sample_count):
                             raise RemoteRFProtocolError(
                                 "native RX returned an invalid sample count"
@@ -1381,7 +1417,7 @@ class SampleDataV1Servicer(grpc_pb2_grpc.SampleDataV1Servicer):
                             sample_count=count,
                             payload=payload,
                             metadata_json=json.dumps(
-                                snapshot_native(metadata),
+                                metadata_snapshot,
                                 sort_keys=True,
                                 separators=(",", ":"),
                             ),

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

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

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/tests/test_dynamic_v2.py

@@ -173,6 +173,16 @@ class DynamicV2ServerTests(unittest.TestCase):
         self.assertIn("uhd.filters.AnalogFilterLP", object_paths)
         self.assertIn("uhd.filters.DigitalFilterFIRI16", object_paths)
         self.assertIn("uhd.filters.FilterType", object_paths)
+        self.assertIn("uhd.dsp", object_paths)
+        self.assertIn("uhd.dsp.signals", object_paths)
+        self.assertEqual(
+            schema["coverage"]["uhd.dsp.signals.get_continuous_tone"],
+            "implemented",
+        )
+        self.assertEqual(
+            schema["coverage"]["uhd.usrp.RXStreamer.get_max_num_samps"],
+            "implemented_with_documented_remote_difference",
+        )
         assert_release_coverage(schema)
 
     def test_promoted_signatures_preserve_native_defaults_and_parameter_kinds(self):
@@ -423,7 +433,7 @@ class DynamicV2ServerTests(unittest.TestCase):
             self.assertTrue(manager.close(session.session_id))
             self.assertTrue(inventory.live.closed)
 
-    def test_binary_rx_stream_returns_only_native_received_prefix(self):
+    def test_binary_rx_stream_coalesces_native_packets(self):
         inventory = FakeInventorySchema()
         context = {
             "schema": inventory,
@@ -533,14 +543,21 @@ class DynamicV2ServerTests(unittest.TestCase):
                 )
             data = responses[-1]
             self.assertEqual(data.kind, grpc_pb2.SAMPLE_FRAME_DATA)
-            self.assertEqual(data.sample_count, 2)
-            self.assertEqual(len(data.payload), 2 * np.dtype(np.complex64).itemsize)
+            self.assertEqual(data.sample_count, 4)
+            self.assertEqual(len(data.payload), 4 * np.dtype(np.complex64).itemsize)
             np.testing.assert_array_equal(
                 np.frombuffer(data.payload, dtype=np.complex64),
-                np.array([1 + 2j, 3 + 4j], dtype=np.complex64),
+                np.array(
+                    [1 + 2j, 3 + 4j, 1 + 2j, 3 + 4j],
+                    dtype=np.complex64,
+                ),
             )
             self.assertEqual(json.loads(data.metadata_json)["error_code"], "none")
-            self.assertEqual(
+            self.assertGreater(
+                manager.get_handle(session, handle).value.last_timeout,
+                0.0,
+            )
+            self.assertLessEqual(
                 manager.get_handle(session, handle).value.last_timeout,
                 0.1,
             )

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/tests/test_pluto_compat.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 import types
 import unittest
-from unittest.mock import patch
+from unittest.mock import call, patch
 
 import numpy as np
 
@@ -216,6 +216,27 @@ class PlutoCompatTests(unittest.TestCase):
         self.assertEqual(ident, "104473f6")
         self.assertEqual(dtype, "adalm_pluto")
 
+    def test_legacy_builtin_pluto_schema_is_registered_for_auto_upgrade(self) -> None:
+        expected_hash = (
+            "a3697eeef55827e0db7705685f8fe64b615468dd26057211de8b5805b9ecf583"
+        )
+        self.assertIn(expected_hash, device_manager._LEGACY_PLUTO_SCHEMA_HASHES)
+
+        with patch.object(device_manager, "_seed_default_driver") as seed:
+            device_manager._seed_default_pluto_drivers()
+
+        self.assertEqual(
+            seed.call_args_list,
+            [
+                call(
+                    "pluto_schema.py",
+                    "adalm_pluto",
+                    legacy_hashes=device_manager._LEGACY_PLUTO_SCHEMA_HASHES,
+                ),
+                call("pluto_mimo_schema.py", "adalm_pluto_mimo"),
+            ],
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

{remoterf_server-1.0.8 → remoterf_server-1.0.10}/tests/test_usrp_client_server_localhost.py

@@ -217,7 +217,7 @@ class USRPClientServerLocalhostTests(unittest.TestCase):
                     with device.get_rx_stream(stream_args) as streamer:
                         self.assertEqual(
                             streamer.get_max_num_samps(),
-                            256,
+                            64 * 1024,
                         )
                         samples = np.full(
                             4,
@@ -231,18 +231,11 @@ class USRPClientServerLocalhostTests(unittest.TestCase):
                             0.25,
                         )
 
-                self.assertEqual(count, 2)
+                self.assertEqual(count, 4)
                 np.testing.assert_array_equal(
                     samples[:count],
                     np.array(
-                        [1 + 2j, 3 + 4j],
-                        dtype=np.complex64,
-                    ),
-                )
-                np.testing.assert_array_equal(
-                    samples[count:],
-                    np.array(
-                        [99 + 0j, 99 + 0j],
+                        [1 + 2j, 3 + 4j, 1 + 2j, 3 + 4j],
                         dtype=np.complex64,
                     ),
                 )