remoteRF-server 1.0.0__tar.gz → 1.0.1__tar.gz

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/PKG-INFO

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

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/pyproject.toml

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

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/common/grpc/grpc_pb2.py

@@ -2,7 +2,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
 # source: grpc.proto
-# Protobuf Python Version: 5.29.0
+# Protobuf Python Version: 5.27.1
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -12,8 +12,8 @@ from google.protobuf.internal import builder as _builder
 _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     5,
-    29,
-    0,
+    27,
+    1,
     '',
     'grpc.proto'
 )
@@ -24,7 +24,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ngrpc.proto\x12\tremote_rf\"\xa2\x01\n\x11GenericRPCRequest\x12\x15\n\rfunction_name\x18\x01 \x01(\t\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32&.remote_rf.GenericRPCRequest.ArgsEntry\x1a@\n\tArgsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x13.remote_rf.Argument:\x02\x38\x01\"\x96\x01\n\x12GenericRPCResponse\x12;\n\x07results\x18\x01 \x03(\x0b\x32*.remote_rf.GenericRPCResponse.ResultsEntry\x1a\x43\n\x0cResultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x13.remote_rf.Argument:\x02\x38\x01\"\x19\n\nArrayShape\x12\x0b\n\x03\x64im\x18\x01 \x03(\x05\"+\n\rComplexNumber\x12\x0c\n\x04real\x18\x01 \x01(\x02\x12\x0c\n\x04imag\x18\x02 \x01(\x02\"a\n\x11\x43omplexNumpyArray\x12$\n\x05shape\x18\x01 \x01(\x0b\x32\x15.remote_rf.ArrayShape\x12&\n\x04\x64\x61ta\x18\x02 \x03(\x0b\x32\x18.remote_rf.ComplexNumber\"D\n\x0eRealNumpyArray\x12$\n\x05shape\x18\x01 \x01(\x0b\x32\x15.remote_rf.ArrayShape\x12\x0c\n\x04\x64\x61ta\x18\x02 \x03(\x02\"\xd7\x01\n\x08\x41rgument\x12\x16\n\x0cstring_value\x18\x01 \x01(\tH\x00\x12\x15\n\x0bint64_value\x18\x02 \x01(\x03H\x00\x12\x15\n\x0b\x66loat_value\x18\x03 \x01(\x02H\x00\x12\x14\n\nbool_value\x18\x04 \x01(\x08H\x00\x12\x35\n\rcomplex_array\x18\x05 \x01(\x0b\x32\x1c.remote_rf.ComplexNumpyArrayH\x00\x12/\n\nreal_array\x18\x06 \x01(\x0b\x32\x19.remote_rf.RealNumpyArrayH\x00\x42\x07\n\x05value2Q\n\nGenericRPC\x12\x43\n\x04\x43\x61ll\x12\x1c.remote_rf.GenericRPCRequest\x1a\x1d.remote_rf.GenericRPCResponseB\x1e\n\x10\x63om.example.demoB\nDemoProtosb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ngrpc.proto\x12\tremote_rf\"\xa2\x01\n\x11GenericRPCRequest\x12\x15\n\rfunction_name\x18\x01 \x01(\t\x12\x34\n\x04\x61rgs\x18\x02 \x03(\x0b\x32&.remote_rf.GenericRPCRequest.ArgsEntry\x1a@\n\tArgsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x13.remote_rf.Argument:\x02\x38\x01\"\x96\x01\n\x12GenericRPCResponse\x12;\n\x07results\x18\x01 \x03(\x0b\x32*.remote_rf.GenericRPCResponse.ResultsEntry\x1a\x43\n\x0cResultsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\"\n\x05value\x18\x02 \x01(\x0b\x32\x13.remote_rf.Argument:\x02\x38\x01\"\x19\n\nArrayShape\x12\x0b\n\x03\x64im\x18\x01 \x03(\x05\"+\n\rComplexNumber\x12\x0c\n\x04real\x18\x01 \x01(\x02\x12\x0c\n\x04imag\x18\x02 \x01(\x02\"a\n\x11\x43omplexNumpyArray\x12$\n\x05shape\x18\x01 \x01(\x0b\x32\x15.remote_rf.ArrayShape\x12&\n\x04\x64\x61ta\x18\x02 \x03(\x0b\x32\x18.remote_rf.ComplexNumber\"D\n\x0eRealNumpyArray\x12$\n\x05shape\x18\x01 \x01(\x0b\x32\x15.remote_rf.ArrayShape\x12\x0c\n\x04\x64\x61ta\x18\x02 \x03(\x02\"\xed\x01\n\x08\x41rgument\x12\x16\n\x0cstring_value\x18\x01 \x01(\tH\x00\x12\x15\n\x0bint64_value\x18\x02 \x01(\x03H\x00\x12\x15\n\x0b\x66loat_value\x18\x03 \x01(\x02H\x00\x12\x14\n\nbool_value\x18\x04 \x01(\x08H\x00\x12\x35\n\rcomplex_array\x18\x05 \x01(\x0b\x32\x1c.remote_rf.ComplexNumpyArrayH\x00\x12/\n\nreal_array\x18\x06 \x01(\x0b\x32\x19.remote_rf.RealNumpyArrayH\x00\x12\x14\n\njson_value\x18\x07 \x01(\tH\x00\x42\x07\n\x05value2Q\n\nGenericRPC\x12\x43\n\x04\x43\x61ll\x12\x1c.remote_rf.GenericRPCRequest\x1a\x1d.remote_rf.GenericRPCResponseB\x1e\n\x10\x63om.example.demoB\nDemoProtosb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -53,7 +53,7 @@ if not _descriptor._USE_C_DESCRIPTORS:
   _globals['_REALNUMPYARRAY']._serialized_start=514
   _globals['_REALNUMPYARRAY']._serialized_end=582
   _globals['_ARGUMENT']._serialized_start=585
-  _globals['_ARGUMENT']._serialized_end=800
-  _globals['_GENERICRPC']._serialized_start=802
-  _globals['_GENERICRPC']._serialized_end=883
+  _globals['_ARGUMENT']._serialized_end=822
+  _globals['_GENERICRPC']._serialized_start=824
+  _globals['_GENERICRPC']._serialized_end=905
 # @@protoc_insertion_point(module_scope)

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/common/idl/schema.py

@@ -24,6 +24,7 @@ That's it. The server never needs to be modified.
 from __future__ import annotations
 
 import hashlib
+import inspect
 import importlib.util
 import json
 import sys
@@ -259,8 +260,10 @@ class DeviceSchema:
             if ex.kind == "get":
                 getters[name] = entry
             elif ex.kind == "set":
+                entry["args"] = self._args_metadata(ex, skip_self=True)
                 setters[name] = entry
             elif ex.kind == "call":
+                entry["args"] = self._args_metadata(ex, skip_self=True)
                 calls[name] = entry
 
         body = {
@@ -278,6 +281,98 @@ class DeviceSchema:
 
         return body
 
+    def _args_metadata(self, ex: "_Exposed", *, skip_self: bool) -> list[dict]:
+        sig = inspect.signature(ex.fn)
+        args = []
+        for pname, param in sig.parameters.items():
+            if skip_self and pname == "self":
+                continue
+            if param.kind is inspect.Parameter.POSITIONAL_ONLY:
+                raise TypeError(
+                    f"{self.device_type}.{ex.name} cannot expose positional-only "
+                    f"parameter {pname!r}"
+                )
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                raise TypeError(
+                    f"{self.device_type}.{ex.name} cannot be exposed with "
+                    f"{param.kind.description} parameter {pname!r}"
+                )
+
+            item = {
+                "name": pname,
+                "required": param.default is inspect.Parameter.empty,
+                "type": self._annotation_name(param.annotation),
+                "kind": (
+                    "keyword_only"
+                    if param.kind is inspect.Parameter.KEYWORD_ONLY
+                    else "positional_or_keyword"
+                ),
+            }
+            if param.default is not inspect.Parameter.empty:
+                item["default"] = self._json_default(ex, pname, param.default)
+            args.append(item)
+        return args
+
+    @staticmethod
+    def _annotation_name(annotation: Any) -> str:
+        if annotation is inspect.Parameter.empty:
+            return "any"
+        if isinstance(annotation, str):
+            return annotation
+        name = getattr(annotation, "__name__", None)
+        if name:
+            return str(name)
+        return str(annotation).replace("typing.", "")
+
+    def _json_default(self, ex: "_Exposed", pname: str, value: Any) -> Any:
+        try:
+            json.dumps(value)
+            return value
+        except TypeError as exc:
+            raise TypeError(
+                f"{self.device_type}.{ex.name} default for {pname!r} is not JSON serializable"
+            ) from exc
+
+    def _bind_exposed_args(
+        self,
+        ex: "_Exposed",
+        args: dict,
+        *,
+        allow_value_alias: bool,
+        allow_first_arg: bool = False,
+    ) -> dict:
+        sig = inspect.signature(ex.fn)
+        bound = {}
+        params = [
+            (pname, param)
+            for pname, param in sig.parameters.items()
+            if pname != "self"
+        ]
+
+        for pname, param in params:
+            if param.kind is inspect.Parameter.POSITIONAL_ONLY:
+                raise TypeError(
+                    f"{self.device_type}.{ex.name} cannot be dispatched with "
+                    f"positional-only parameter {pname!r}"
+                )
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                raise TypeError(
+                    f"{self.device_type}.{ex.name} cannot be dispatched with "
+                    f"{param.kind.description} parameter {pname!r}"
+                )
+
+            if pname in args:
+                bound[pname] = args[pname]
+            elif allow_value_alias and len(params) == 1 and "value" in args:
+                bound[pname] = args["value"]
+            elif allow_first_arg and len(params) == 1 and args:
+                first_key = next(iter(args))
+                bound[pname] = args[first_key]
+            elif param.default is inspect.Parameter.empty:
+                raise TypeError(f"missing required argument {pname!r} for {ex.name}")
+
+        return bound
+
     # ── Dispatch (server RPC layer calls this) ────────────────────
 
     def dispatch(self, method_name: str, args: dict) -> Any:
@@ -303,32 +398,19 @@ class DeviceSchema:
             return ex.fn(self)
 
         elif ex.kind == "set":
-            value = args.get("value")
-            if value is None and "value" not in args:
-                # Also check first positional-style arg key
-                for k, v in args.items():
-                    value = v
-                    break
-            return ex.fn(self, value)
+            call_args = self._bind_exposed_args(
+                ex,
+                args,
+                allow_value_alias=True,
+                allow_first_arg=True,
+            )
+            if not call_args:
+                raise TypeError(f"missing required setter value for {ex.name}")
+            return ex.fn(self, **call_args)
 
         elif ex.kind == "call":
-            # Calls can have 0 or more args
-            # Simple convention: if the function takes 'value', pass it
-            import inspect
-            sig = inspect.signature(ex.fn)
-            params = [p for p in sig.parameters if p != "self"]
-
-            if len(params) == 0:
-                return ex.fn(self)
-            elif len(params) == 1:
-                # Single arg — pull from args dict by param name or "value"
-                pname = params[0]
-                val = args.get(pname, args.get("value"))
-                return ex.fn(self, val)
-            else:
-                # Multi-arg — match by name
-                call_args = {p: args.get(p) for p in params if p in args}
-                return ex.fn(self, **call_args)
+            call_args = self._bind_exposed_args(ex, args, allow_value_alias=True)
+            return ex.fn(self, **call_args)
         else:
             raise ValueError(f"unknown kind '{ex.kind}' on {method_name}")
 

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/common/utils/process_arg.py

@@ -1,6 +1,61 @@
 from ..grpc import grpc_pb2, grpc_pb2_grpc
+import json
 import numpy as np
 
+_JSON_TYPE_KEY = "__remoterf_json_type__"
+
+def _json_safe(value):
+    if isinstance(value, np.ndarray):
+        if value.dtype == object:
+            raise ValueError(f"Cannot JSON-map object-dtype array: {value!r}")
+        array = np.asarray(value)
+        if np.iscomplexobj(array):
+            data = [[float(num.real), float(num.imag)] for num in array.ravel()]
+            return {
+                _JSON_TYPE_KEY: "ndarray",
+                "dtype": str(array.dtype),
+                "shape": list(array.shape),
+                "complex": True,
+                "data": data,
+            }
+        return {
+            _JSON_TYPE_KEY: "ndarray",
+            "dtype": str(array.dtype),
+            "shape": list(array.shape),
+            "complex": False,
+            "data": array.tolist(),
+        }
+    if isinstance(value, (np.bool_,)):
+        return bool(value)
+    if isinstance(value, (np.integer,)):
+        return int(value)
+    if isinstance(value, (np.floating,)):
+        return float(value)
+    if isinstance(value, complex):
+        return {_JSON_TYPE_KEY: "complex", "real": float(value.real), "imag": float(value.imag)}
+    if isinstance(value, dict):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    return value
+
+def _json_restore(value):
+    if isinstance(value, dict):
+        kind = value.get(_JSON_TYPE_KEY)
+        if kind == "ndarray":
+            shape = tuple(value.get("shape", ()))
+            dtype = value.get("dtype")
+            if value.get("complex"):
+                data = [complex(real, imag) for real, imag in value.get("data", [])]
+                return np.array(data, dtype=dtype or np.complex64).reshape(shape)
+            return np.array(value.get("data", []), dtype=dtype).reshape(shape)
+        if kind == "complex":
+            return complex(value.get("real", 0.0), value.get("imag", 0.0))
+        return {key: _json_restore(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_json_restore(item) for item in value]
+    return value
+
 def unmap_arg(arg):
     if arg.HasField('int64_value'):
         return arg.int64_value
@@ -17,6 +72,8 @@ def unmap_arg(arg):
         shape = tuple(arg.complex_array.shape.dim)
         data = [complex(c.real, c.imag) for c in arg.complex_array.data]
         return np.array(data, dtype=np.complex64).reshape(shape)
+    elif arg.HasField('json_value'):
+        return _json_restore(json.loads(arg.json_value))
     else:
         raise ValueError(f"Unknown argument type during unmapping: {arg}")
     
@@ -25,6 +82,8 @@ def map_arg(value):
     
     if isinstance(value, (bool, np.bool_)):
         arg.bool_value = bool(value)
+    elif value is None or isinstance(value, dict):
+        arg.json_value = json.dumps(_json_safe(value), separators=(",", ":"))
     elif isinstance(value, (int, np.integer)):
         arg.int64_value = int(value)
     elif isinstance(value, (float, np.floating)):
@@ -32,12 +91,17 @@ def map_arg(value):
     elif isinstance(value, str):
         arg.string_value = value
     elif isinstance(value, (list, tuple)):
-        array = np.asarray(value)
+        try:
+            array = np.asarray(value)
+        except Exception:
+            arg.json_value = json.dumps(_json_safe(value), separators=(",", ":"))
+            return arg
         if array.dtype == object:
             try:
                 array = np.stack(value)
-            except Exception as exc:
-                raise ValueError(f"Cannot map ragged/object array value: {value}") from exc
+            except Exception:
+                arg.json_value = json.dumps(_json_safe(value), separators=(",", ":"))
+                return arg
         return map_arg(array)
     elif isinstance(value, np.ndarray):
         if value.dtype == object:

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/drivers/adalm_pluto/pluto_remote_server.py

@@ -18,7 +18,7 @@ class PlutoServer:
             elif function_type == "SET":
                 PlutoServer.set(function_name=function_name, value=args[function_name], token=unmap_arg(args['a']))
                 
-            elif function_type in ("CALL0", "CALL1"):
+            elif function_type in ("CALL0", "CALL1", "CALLN"):
                 return PlutoServer.call_func(
                     function_name=function_name,
                     function_type=function_type,
@@ -60,6 +60,14 @@ class PlutoServer:
             # print(f"unmapped values: {python_arg}")
             # print(f"{function_name} is called on {device}")
             result = method(python_arg)
+        elif function_type == "CALLN":
+            reserved = {"a", "g", "token", "device_id", "device_name"}
+            call_args = {
+                str(key): unmap_arg(value)
+                for key, value in dict(args).items()
+                if str(key) not in reserved
+            }
+            result = method(**call_args)
         else:
             raise ValueError(f"Unsupported call type: {function_type} (arg length not supported)")
 
@@ -102,4 +110,4 @@ class PlutoServer:
             return {}
         except Exception as e:
             # print(f"UE: Pluto_server ln:44: {e}")
-            return {function_name:map_arg('None'), "UE":map_arg(f'{e}')}
+            return {function_name:map_arg('None'), "UE":map_arg(f'{e}')}

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/server/grpc_server.py

@@ -95,6 +95,7 @@ def _get_port(name: str, *, default: int | None = None) -> int:
     return n
 
 session = PromptSession()
+BANNER_CREDIT = "Created at UCLA by E. Ge and I. Roberts."
 
 from dotenv import load_dotenv, find_dotenv
 dotenv_path = find_dotenv('.env.server')
@@ -247,6 +248,7 @@ start_time = datetime.now()
 
 def welcome():
     printf(f"Server running nominally.", Sty.BOLD)
+    printf(BANNER_CREDIT, Sty.GRAY)
     printf(f"Local IP: ", Sty.DEFAULT, f"{local_ip}", Sty.ITALIC, f" | Port: ", Sty.DEFAULT, f"{local_port}", Sty.ITALIC)
     # printf(f"   -> Started at ", Sty.DEFAULT, f"{start_time}", Sty.DEFAULT)
     printf("Input ", Sty.DEFAULT, "'help'", Sty.BOLD," for help menu.", Sty.DEFAULT)
@@ -1020,4 +1022,4 @@ welcome()
 
 def main():
     while server_input(session.prompt(stylize('server@remoterf: ', Sty.BOLD))):
-        pass
+        pass

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/server/rpc_manager.py

@@ -180,6 +180,16 @@ class RpcManager:
             result = dev.dispatch(f"call_{prop}", {"value": value})
             return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
 
+        if verb == "CALLN":
+            reserved = {"a", "g", "token", "device_id", "device_name"}
+            call_args = {
+                str(key): unmap_arg(value)
+                for key, value in dict(args).items()
+                if str(key) not in reserved
+            }
+            result = dev.dispatch(f"call_{prop}", call_args)
+            return {prop: map_arg(result)} if result is not None else {prop: map_arg('None')}
+
         raise ValueError(f"Unknown verb {verb!r} in {function_name!r}")
 
     def _resolve_idl_target(self, args: dict) -> tuple[int | None, str | None]:

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server/serverrf_cli.py

@@ -161,6 +161,7 @@ def _tos_ack_path() -> Path:
 
 _TOS_VERSION = "2026"
 _TOS_URL = "https://remoterf.net/tos"
+BANNER_CREDIT = "Created at UCLA by E. Ge and I. Roberts."
 
 
 def _tos_acknowledged() -> bool:
@@ -224,6 +225,7 @@ def _ensure_tos_acknowledged() -> bool:
 def print_help() -> None:
     print(
         "RemoteRF Server CLI Help\n"
+        f"{BANNER_CREDIT}\n"
         "\n"
         "Usage:\n"
         "  serverrf -h | --help\n"

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server.egg-info/PKG-INFO

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

{remoterf_server-1.0.0 → remoterf_server-1.0.1}/src/remoteRF_server.egg-info/SOURCES.txt

@@ -47,4 +47,7 @@ src/remoteRF_server/server/user_group_handler.py
 src/remoteRF_server/tools/__init__.py
 src/remoteRF_server/tools/gen_certs.py
 src/remoteRF_server/tools/gist_status.py
-src/remoteRF_server/tools/gist_status_testing.py
+src/remoteRF_server/tools/gist_status_testing.py
+tests/test_idl_schema.py
+tests/test_process_arg.py
+tests/test_rpc_manager_calln.py

remoterf_server-1.0.1/tests/test_idl_schema.py

@@ -0,0 +1,81 @@
+import unittest
+
+from remoteRF_server.common.idl.schema import DeviceSchema, idl_expose
+
+
+class FakeSchema(DeviceSchema):
+    device_type = "fake"
+    driver_version = "0.0.0"
+
+    @idl_expose(kind="set")
+    def set_level(self, value: int):
+        self.device["level"] = value
+
+    @idl_expose(kind="call")
+    def call_ping(self):
+        return "pong"
+
+    @idl_expose(kind="call")
+    def call_echo(self, value):
+        return value
+
+    @idl_expose(kind="call")
+    def call_configure(self, freq: float, gain: int = 0, options: dict = None):
+        return {"freq": freq, "gain": gain, "options": options}
+
+    @idl_expose(kind="call")
+    def call_keyword(self, first: int = 1, *, required: str):
+        return {"first": first, "required": required}
+
+
+class DeviceSchemaTests(unittest.TestCase):
+    def test_schema_includes_arg_metadata(self):
+        schema = FakeSchema()
+        idl = schema.get_idl()
+
+        args = idl["calls"]["call_configure"]["args"]
+        self.assertEqual([arg["name"] for arg in args], ["freq", "gain", "options"])
+        self.assertEqual([arg["required"] for arg in args], [True, False, False])
+        self.assertEqual([arg["type"] for arg in args], ["float", "int", "dict"])
+        self.assertEqual(args[1]["default"], 0)
+        self.assertIsNone(args[2]["default"])
+        self.assertEqual(idl["setters"]["set_level"]["args"][0]["name"], "value")
+
+        keyword_args = idl["calls"]["call_keyword"]["args"]
+        self.assertEqual(
+            [(arg["name"], arg["kind"], arg["required"]) for arg in keyword_args],
+            [
+                ("first", "positional_or_keyword", False),
+                ("required", "keyword_only", True),
+            ],
+        )
+
+    def test_dispatch_supports_defaults_dicts_and_legacy_value_alias(self):
+        schema = FakeSchema()
+        schema.bind({})
+
+        self.assertEqual(schema.dispatch("call_ping", {}), "pong")
+        self.assertEqual(schema.dispatch("call_echo", {"value": "hello"}), "hello")
+        self.assertEqual(
+            schema.dispatch(
+                "call_configure",
+                {"freq": 2.4e9, "options": {"mode": "fast"}},
+            ),
+            {"freq": 2.4e9, "gain": 0, "options": {"mode": "fast"}},
+        )
+
+        schema.dispatch("set_level", {"value": 7})
+        self.assertEqual(schema.device["level"], 7)
+        schema.dispatch("set_level", {"level": 8})
+        self.assertEqual(schema.device["level"], 8)
+
+    def test_dispatch_missing_required_arg_raises(self):
+        schema = FakeSchema()
+        schema.bind({})
+
+        with self.assertRaisesRegex(TypeError, "missing required argument 'freq'"):
+            schema.dispatch("call_configure", {"gain": 3})
+
+
+if __name__ == "__main__":
+    unittest.main()

remoterf_server-1.0.1/tests/test_process_arg.py

@@ -0,0 +1,44 @@
+import unittest
+
+import numpy as np
+
+from remoteRF_server.common.utils.process_arg import map_arg, unmap_arg
+
+
+class ProcessArgTests(unittest.TestCase):
+    def test_json_values_round_trip_dict_and_none(self):
+        value = {"nested": {"x": 1}, "flag": True, "nothing": None}
+
+        self.assertEqual(unmap_arg(map_arg(value)), value)
+        self.assertIsNone(unmap_arg(map_arg(None)))
+
+    def test_existing_scalar_values_still_round_trip(self):
+        self.assertIs(unmap_arg(map_arg(True)), True)
+        self.assertEqual(unmap_arg(map_arg(12)), 12)
+        self.assertAlmostEqual(unmap_arg(map_arg(1.5)), 1.5)
+        self.assertEqual(unmap_arg(map_arg("abc")), "abc")
+
+    def test_arrays_and_list_values_still_round_trip_as_arrays(self):
+        real = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+        complex_value = np.array([1 + 2j, 3 + 4j], dtype=np.complex64)
+
+        np.testing.assert_allclose(unmap_arg(map_arg(real)), real)
+        np.testing.assert_allclose(unmap_arg(map_arg([1, 2, 3])), np.array([1, 2, 3]))
+        np.testing.assert_allclose(unmap_arg(map_arg(complex_value)), complex_value)
+
+    def test_json_values_can_contain_arrays_and_mixed_return_tuples(self):
+        samples = np.array([[1 + 2j, 3 + 4j]], dtype=np.complex64)
+        value = (2, samples, {"error_code": "none"})
+
+        count, restored_samples, metadata = unmap_arg(map_arg(value))
+
+        self.assertEqual(count, 2)
+        np.testing.assert_allclose(restored_samples, samples)
+        self.assertEqual(metadata, {"error_code": "none"})
+
+        nested = unmap_arg(map_arg({"samples": samples}))
+        np.testing.assert_allclose(nested["samples"], samples)
+
+
+if __name__ == "__main__":
+    unittest.main()

remoterf_server-1.0.1/tests/test_rpc_manager_calln.py

@@ -0,0 +1,71 @@
+import unittest
+import sys
+import types
+
+sys.modules.setdefault("adi", types.ModuleType("adi"))
+
+from remoteRF_server.common.utils.process_arg import map_arg, unmap_arg
+from remoteRF_server.server.rpc_manager import RpcManager
+
+
+class FakeDevice:
+    def __init__(self, result=None):
+        self.result = result
+        self.seen = None
+
+    def dispatch(self, method_name, args):
+        self.seen = (method_name, args)
+        return self.result if self.result is not None else {"method": method_name, "args": args}
+
+
+class RpcManagerCallNTests(unittest.TestCase):
+    def test_calln_unmaps_named_args_and_filters_transport_keys(self):
+        dev = FakeDevice()
+        result = RpcManager()._dispatch_local_schema(
+            function_name="Fake:configure:CALLN",
+            args={
+                "a": map_arg("token"),
+                "g": map_arg(123),
+                "device_id": map_arg(123),
+                "freq": map_arg(2.4e9),
+                "options": map_arg({"mode": "fast"}),
+            },
+            dev=dev,
+        )
+
+        self.assertEqual(
+            dev.seen,
+            ("call_configure", {"freq": 2.4e9, "options": {"mode": "fast"}}),
+        )
+        self.assertEqual(
+            unmap_arg(result["configure"]),
+            {"method": "call_configure", "args": {"freq": 2.4e9, "options": {"mode": "fast"}}},
+        )
+
+    def test_existing_call0_and_call1_paths_still_work(self):
+        dev = FakeDevice(result="ok")
+        manager = RpcManager()
+
+        self.assertEqual(
+            unmap_arg(manager._dispatch_local_schema(
+                function_name="Fake:ping:CALL0",
+                args={"a": map_arg("token")},
+                dev=dev,
+            )["ping"]),
+            "ok",
+        )
+        self.assertEqual(dev.seen, ("call_ping", {}))
+
+        self.assertEqual(
+            unmap_arg(manager._dispatch_local_schema(
+                function_name="Fake:echo:CALL1",
+                args={"a": map_arg("token"), "arg1": map_arg(42)},
+                dev=dev,
+            )["echo"]),
+            "ok",
+        )
+        self.assertEqual(dev.seen, ("call_echo", {"value": 42}))
+
+
+if __name__ == "__main__":
+    unittest.main()