remoteRF-server-testing 0.0.2__tar.gz → 0.0.4__tar.gz

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/PKG-INFO

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

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/pyproject.toml

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

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server/common/idl/pluto_schema.py

@@ -84,12 +84,14 @@ class PlutoSchema(DeviceSchema):
         self.device.gain_control_mode_chan0 = value
 
     @idl_expose(kind="get")
-    def get_rx_hardwaregain_chan0(self):
-        return self.device.rx_hardwaregain_chan0
+    def get_hardwaregain_chan0(self):
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        return self.device.hardwaregain_chan0
 
     @idl_expose(kind="set")
-    def set_rx_hardwaregain_chan0(self, value):
-        self.device.rx_hardwaregain_chan0 = value
+    def set_hardwaregain_chan0(self, value):
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        self.device.hardwaregain_chan0 = value
 
     @idl_expose(kind="get")
     def get_tx_hardwaregain_chan0(self):
@@ -173,6 +175,11 @@ class PlutoSchema(DeviceSchema):
     def call_tx_destroy_buffer(self):
         self.device.tx_destroy_buffer()
 
+    @idl_expose(kind="call")
+    def call_disable_dds(self):
+        """Disable the internal DDS tone generator."""
+        self.device.disable_dds()
+
     # endregion
 
     # region ip / repr

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server/common/utils/process_arg.py

@@ -31,6 +31,8 @@ def map_arg(value):
         arg.string_value = value
     elif isinstance(value, bool):
         arg.bool_value = value
+    elif isinstance(value, (list, tuple)):
+        return map_arg(np.array(value))
     elif isinstance(value, np.ndarray):
         if np.iscomplexobj(value):
             complex_array = arg.complex_array

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server/host/host_tunnel_server.py

@@ -259,6 +259,12 @@ class HostTunnelRegistry:
         self._host_status: Dict[str, HostStatus] = {}
         self._device_status: Dict[str, DeviceStatus] = {}
 
+        # IDL capability strings received via HostMeta.kv from each host.
+        # Keyed by device_id (string gid).  Value is the compact caps string
+        # emitted by the host's capabilities_string() helper, e.g.:
+        #   "disable_dds:call0,filter:rw,hardwaregain_chan0:rw,..."
+        self._host_device_caps: Dict[str, str] = {}
+
         # persistence
         cfg = cfg_dir_from_file(__file__)
         cfg.mkdir(parents=True, exist_ok=True)
@@ -531,6 +537,26 @@ class HostTunnelRegistry:
 
         info(f"[registry] heartbeat: host_id={host_id!r} unix_ms={now}")
 
+    # ── IDL capability cache ────────────────────────────────────────
+
+    def store_host_device_caps(self, host_id: str, device_id: str, caps: str) -> None:
+        """
+        Store the IDL capability string for a host device.
+
+        Called when the server receives HostMeta.kv["device.<gid>.caps"] in a
+        MetaResponse.  The caps string is the compact attr:access list emitted
+        by the host's capabilities_string() helper.
+        """
+        with self._lock:
+            self._host_device_caps[str(device_id)] = str(caps)
+
+    def get_host_device_caps(self, device_id: str) -> str:
+        """
+        Return the IDL capability string for *device_id*, or "" if not yet received.
+        """
+        with self._lock:
+            return self._host_device_caps.get(str(device_id), "")
+
     def announce_devices(self, host_id: str, devices: list) -> None:
         info(f"[registry] announce_devices: host_id={host_id!r} n={len(devices)}")
 
@@ -1147,7 +1173,7 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                             warn(f"[inbound] rpc_response has no inflight waiter req_id={rid} stream_sess={stream_uuid}")
 
                     elif which == "meta_response":
-                        # NEW proto: MetaResponse.meta.devices
+                        # NEW proto: MetaResponse.meta.devices + meta.kv (IDL caps)
                         if host_id is None or session is None:
                             warn(f"[inbound] meta_response before hello/session: ignoring peer={peer} stream_sess={stream_uuid}")
                             continue
@@ -1186,6 +1212,24 @@ class HostTunnelServicer(host_tunnel_pb2_grpc.HostTunnelServicer):
                             else:
                                 info("[inbound] META_RESPONSE had no meta.devices (or empty)")
 
+                            # Read per-device IDL capability strings from meta.kv.
+                            # Keys: "device.<gid>.caps"  "device.<gid>.type"
+                            # These are emitted by the host's tunnel_agent._collect_meta().
+                            try:
+                                kv = dict(getattr(meta, "kv", {}) or {})
+                                for k, v in kv.items():
+                                    # e.g. k="device.0.caps", v="disable_dds:call0,filter:rw,..."
+                                    parts = k.split(".")
+                                    if len(parts) == 3 and parts[0] == "device" and parts[2] == "caps":
+                                        device_id = parts[1]
+                                        self.registry.store_host_device_caps(host_id, device_id, str(v))
+                                        info(
+                                            f"[inbound] stored IDL caps device_id={device_id} "
+                                            f"host_id={host_id!r} n_attrs={len(v.split(','))}"
+                                        )
+                            except Exception:
+                                exception("[inbound] META_RESPONSE failed reading meta.kv caps")
+
                     elif which == "heartbeat":
                         if session is not None and host_id is not None:
                             ms = int(getattr(frame.heartbeat, "unix_ms", 0) or 0) or now_ms()

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server/server/device_manager.py

@@ -491,11 +491,28 @@ def get_device_by_id(device_id: int):
         return (st.dev, st.salt, st.hsh)
 
 def get_device_schema(device_id: int):
-    """Return the DeviceSchema instance for a local device, or None if unavailable."""
+    """
+    Return a DeviceSchema instance for this device, or None if unavailable.
+
+    For local devices: returns the live bound schema instance.
+    For host devices: instantiates an unbound schema from the driver registry
+    using the device's dtype — sufficient for IDL/hash purposes since the
+    schema structure is defined by the class, not the live device.
+    """
     with _state_lock:
         st = _devices.get(int(device_id))
-        if st and st.origin == "local" and st.dev is not None:
-            return st.dev  # DeviceSchema instance
+        if st is None:
+            return None
+
+        if st.origin == "local" and st.dev is not None:
+            return st.dev
+
+        if st.origin == "host" and st.dtype:
+            try:
+                return get_driver_class(st.dtype)()
+            except KeyError:
+                return None
+
     return None
 
 def get_schema_by_token(api_token: str):
@@ -542,6 +559,63 @@ def get_schema_by_token(api_token: str):
         return None
     return get_device_schema(gid)
 
+def resolve_gid_for_token(api_token: str) -> Optional[int]:
+    """
+    Resolve an API token to its device gid regardless of device origin
+    (local or host/VirtualDevice).
+
+    Unlike get_schema_by_token — which returns None for host devices because
+    they have no salt/hash — this function also covers:
+      • parsed master-tokens  ('{gid}:secret')  → any device by gid
+      • raw master_token                         → first connected device
+      • regular per-device tokens (salt/hsh)     → local devices
+
+    Used by IDL queries that need a schema even for host devices.
+    Does NOT acquire any device I/O lock.
+    """
+    if not api_token:
+        return None
+
+    _sync_host_devices()
+
+    # Parsed master-token: resolves any device directly by gid (local or host).
+    parsed = parse_mastertoken(api_token)
+    if parsed:
+        cand, _ = parsed
+        with _state_lock:
+            st = _devices.get(int(cand))
+            if st and _is_connected(st):
+                return int(cand)
+        return None
+
+    # Raw master token — prefer local, fall back to any connected device.
+    if api_token == master_token:
+        with _state_lock:
+            # local first
+            for k, st in _devices.items():
+                if st.origin == "local" and _is_connected(st) and st.salt == "" and st.hsh == "":
+                    return k
+            # then host
+            for k, st in _devices.items():
+                if _is_connected(st) and st.salt == "" and st.hsh == "":
+                    return k
+        return None
+
+    # Regular per-device token (salt/hsh).  Host devices have empty salt/hsh
+    # so they won't match here — but this covers local devices correctly.
+    with _state_lock:
+        snapshot = [
+            (k, st.salt, st.hsh)
+            for k, st in _devices.items()
+            if _is_connected(st)
+        ]
+    for k, salt, hsh in snapshot:
+        if salt and hsh and validate_token(salt, hsh, api_token):
+            return k
+
+    return None
+
+
 def find_device_id_by_name(name: str) -> Optional[int]:
     """Return the gid of the first device whose name matches (case-insensitive), or None."""
     name_lower = name.strip().lower()

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server/server/rpc_manager.py

@@ -52,7 +52,7 @@
 
 from .reservation import reservation_handler
 from ..common.utils import *
-from .device_manager import acquire_device, VirtualDevice, get_device_schema, find_device_id_by_name, get_schema_by_token
+from .device_manager import acquire_device, VirtualDevice, get_device_schema, find_device_id_by_name, get_schema_by_token, resolve_gid_for_token
 from ..host import host_tunnel_server as hts
 
 class RpcManager:
@@ -151,7 +151,14 @@ class RpcManager:
                 api_token = str(unmap_arg(args['token']))
                 schema = get_schema_by_token(api_token)
                 if schema is None:
-                    return {'error': map_arg('No schema available for this token (invalid token or host device)')}
+                    # get_schema_by_token returns None for host (VirtualDevice) entries
+                    # because they carry no salt/hsh.  Fall through via gid resolution
+                    # which uses get_device_schema and handles host devices correctly.
+                    gid = resolve_gid_for_token(api_token)
+                    if gid is not None:
+                        schema = get_device_schema(gid)
+                if schema is None:
+                    return {'error': map_arg('No schema available for this token (invalid token or device offline)')}
 
             elif 'device_id' in args:
                 try:

{remoterf_server_testing-0.0.2 → remoterf_server_testing-0.0.4}/src/remoteRF_server_testing.egg-info/PKG-INFO

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