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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.0.6
+Version: 1.0.7
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -334,13 +334,13 @@ separate policy file. This includes transmit controls, transmit streaming,
 GPIO/register methods, and property-tree writes. `usrp_policy.yml` is not read
 or required by the current server.
 
-RemoteRF sets `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
+RemoteRF forces `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
 messages do not overwrite the interactive `serverrf` prompt. To temporarily
-restore UHD diagnostics, set a level such as `warning`, `info`, or `debug`
-before starting the server:
+restore UHD diagnostics, explicitly set `REMOTERF_UHD_CONSOLE_LEVEL` to a level
+such as `warning`, `info`, or `debug` before starting the server:
 
 ```bash
-UHD_LOG_CONSOLE_LEVEL=warning serverrf -s
+REMOTERF_UHD_CONSOLE_LEVEL=warning serverrf -s
 ```
 
 On every qualified target, generate the introspection record and enforce the

{remoterf_server-1.0.6 → remoterf_server-1.0.7}/README.md

@@ -319,13 +319,13 @@ separate policy file. This includes transmit controls, transmit streaming,
 GPIO/register methods, and property-tree writes. `usrp_policy.yml` is not read
 or required by the current server.
 
-RemoteRF sets `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
+RemoteRF forces `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
 messages do not overwrite the interactive `serverrf` prompt. To temporarily
-restore UHD diagnostics, set a level such as `warning`, `info`, or `debug`
-before starting the server:
+restore UHD diagnostics, explicitly set `REMOTERF_UHD_CONSOLE_LEVEL` to a level
+such as `warning`, `info`, or `debug` before starting the server:
 
 ```bash
-UHD_LOG_CONSOLE_LEVEL=warning serverrf -s
+REMOTERF_UHD_CONSOLE_LEVEL=warning serverrf -s
 ```
 
 On every qualified target, generate the introspection record and enforce the

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

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

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

@@ -11,7 +11,10 @@ import os
 
 def _configure_uhd_console_logging():
     """Keep native UHD logs out of the interactive server console by default."""
-    os.environ.setdefault("UHD_LOG_CONSOLE_LEVEL", "off")
+    os.environ["UHD_LOG_CONSOLE_LEVEL"] = os.getenv(
+        "REMOTERF_UHD_CONSOLE_LEVEL",
+        "off",
+    )
 
 
 _configure_uhd_console_logging()

{remoterf_server-1.0.6 → remoterf_server-1.0.7}/src/remoteRF_server/server/device_manager.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import re
 import shutil
+import hashlib
 import time
 import yaml
 import threading
@@ -419,10 +420,60 @@ def _driver_registers_type(path: Path, device_type: str) -> bool:
     pattern = rf"(?:idl_register|register_driver)\(\s*['\"]{re.escape(device_type)}['\"]\s*\)"
     return re.search(pattern, text) is not None
 
-def _seed_default_driver(filename: str, *device_types: str) -> None:
+def _driver_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _managed_driver_marker(target: Path) -> Path:
+    return target.with_name(f".{target.name}.remoterf-managed")
+
+
+def _refresh_managed_driver(
+    target: Path,
+    source: Path,
+    *,
+    legacy_hashes: tuple[str, ...] = (),
+) -> bool:
+    """Refresh an unmodified RemoteRF-managed schema and preserve user edits."""
+    marker = _managed_driver_marker(target)
+    try:
+        target_hash = _driver_sha256(target)
+        marker_hash = marker.read_text(encoding="utf-8").strip() if marker.exists() else ""
+    except OSError:
+        return False
+
+    if target_hash != marker_hash and target_hash not in legacy_hashes:
+        return False
+
+    try:
+        source_hash = _driver_sha256(source)
+        if target_hash != source_hash:
+            shutil.copy2(source, target)
+        marker.write_text(source_hash + "\n", encoding="utf-8")
+    except OSError:
+        return False
+    return True
+
+
+def _seed_default_driver(
+    filename: str,
+    *device_types: str,
+    legacy_hashes: tuple[str, ...] = (),
+) -> None:
     drivers_dir = get_drivers_dir()
     target = drivers_dir / filename
+    source = _packaged_driver_schema_path(filename)
     if target.exists() or target.is_symlink():
+        if target.is_file() and source.exists():
+            _refresh_managed_driver(
+                target,
+                source,
+                legacy_hashes=legacy_hashes,
+            )
         return
 
     try:
@@ -437,13 +488,16 @@ def _seed_default_driver(filename: str, *device_types: str) -> None:
         if any(_driver_registers_type(driver_file, device_type) for device_type in device_types):
             return
 
-    source = _packaged_driver_schema_path(filename)
     if not source.exists():
         print(f"Warning: default driver schema source is missing: {source}")
         return
 
     try:
         shutil.copy2(source, target)
+        _managed_driver_marker(target).write_text(
+            _driver_sha256(source) + "\n",
+            encoding="utf-8",
+        )
         print(f"Created default driver config at {target}")
     except OSError as e:
         print(f"Warning: could not create default driver config {target}: {e}")
@@ -453,7 +507,19 @@ def _seed_default_pluto_drivers() -> None:
     _seed_default_driver("pluto_mimo_schema.py", "adalm_pluto_mimo")
 
 def _seed_default_usrp_driver() -> None:
-    _seed_default_driver("usrp_schema.py", "usrp")
+    _seed_default_driver(
+        "usrp_schema.py",
+        "usrp",
+        legacy_hashes=(
+            # Previously shipped built-in copies. These are safe to refresh;
+            # any edited/custom schema has a different digest and is preserved.
+            "ec30aaadb1e8edec289de01e4f997aa3c8b59d3fd0a69c5ac94b37b05dac7a65",
+            "baf29cd0f22e84891b546c30c963cddb02bc93db0efb50fe32cc743c8600c227",
+            "01360d017359d6cb65761b78b5c2bb570b8f2f55e8ab280ba23d6813deddb233",
+            "ca32b958759a5f7933e10426a320ca74e7546734524749ea510de83cf5084397",
+            "0d185cd24571bae2d5f75d6c28164694918a86b20854b96fe9b77c475ca28ed1",
+        ),
+    )
 
 def _load_all_drivers() -> None:
     _seed_default_pluto_drivers()

{remoterf_server-1.0.6 → remoterf_server-1.0.7}/src/remoteRF_server/serverrf_cli.py

@@ -339,8 +339,13 @@ def _serve(*, headless: bool = False) -> int:
 
     # UHD writes native log messages to stderr/std::clog. Set this before the
     # server imports device drivers so those messages cannot corrupt the
-    # interactive prompt. An explicit administrator setting still wins.
-    os.environ.setdefault("UHD_LOG_CONSOLE_LEVEL", "off")
+    # interactive prompt. RemoteRF keeps this off even when the surrounding
+    # shell has a noisy UHD default; diagnostics require an explicit RemoteRF
+    # opt-in.
+    os.environ["UHD_LOG_CONSOLE_LEVEL"] = os.getenv(
+        "REMOTERF_UHD_CONSOLE_LEVEL",
+        "off",
+    )
 
     from remoteRF_server.server.grpc_server import (
         headless_main,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 1.0.6
+Version: 1.0.7
 Summary: RemoteRF server-side control package
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -334,13 +334,13 @@ separate policy file. This includes transmit controls, transmit streaming,
 GPIO/register methods, and property-tree writes. `usrp_policy.yml` is not read
 or required by the current server.
 
-RemoteRF sets `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
+RemoteRF forces `UHD_LOG_CONSOLE_LEVEL=off` before importing UHD so native UHD
 messages do not overwrite the interactive `serverrf` prompt. To temporarily
-restore UHD diagnostics, set a level such as `warning`, `info`, or `debug`
-before starting the server:
+restore UHD diagnostics, explicitly set `REMOTERF_UHD_CONSOLE_LEVEL` to a level
+such as `warning`, `info`, or `debug` before starting the server:
 
 ```bash
-UHD_LOG_CONSOLE_LEVEL=warning serverrf -s
+REMOTERF_UHD_CONSOLE_LEVEL=warning serverrf -s
 ```
 
 On every qualified target, generate the introspection record and enforce the

{remoterf_server-1.0.6 → remoterf_server-1.0.7}/tests/test_default_usrp_schema.py

@@ -1,4 +1,5 @@
 import os
+import hashlib
 from pathlib import Path
 import subprocess
 import sys
@@ -12,7 +13,13 @@ SOURCE_ROOT = PROJECT_ROOT / "src"
 
 
 class DefaultUsrpSchemaTests(unittest.TestCase):
-    def _run_fresh_server_import(self, script, *, custom_driver=None):
+    def _run_fresh_server_import(
+        self,
+        script,
+        *,
+        custom_driver=None,
+        managed_driver=None,
+    ):
         with tempfile.TemporaryDirectory() as raw_temp:
             temp = Path(raw_temp)
             blocker = temp / "blocker"
@@ -30,6 +37,15 @@ class DefaultUsrpSchemaTests(unittest.TestCase):
                     custom_driver,
                     encoding="utf-8",
                 )
+            if managed_driver is not None:
+                drivers_dir.mkdir(parents=True, exist_ok=True)
+                target = drivers_dir / "usrp_schema.py"
+                target.write_text(managed_driver, encoding="utf-8")
+                marker = drivers_dir / ".usrp_schema.py.remoterf-managed"
+                marker.write_text(
+                    hashlib.sha256(managed_driver.encode("utf-8")).hexdigest() + "\n",
+                    encoding="utf-8",
+                )
 
             env = dict(os.environ)
             env["HOME"] = str(temp / "home")
@@ -58,6 +74,7 @@ class DefaultUsrpSchemaTests(unittest.TestCase):
 
             seeded = get_drivers_dir() / "usrp_schema.py"
             assert seeded.is_file(), seeded
+            assert (get_drivers_dir() / ".usrp_schema.py.remoterf-managed").is_file()
 
             schema = get_driver_class("usrp")()
             legacy = schema.get_idl()
@@ -124,6 +141,38 @@ class DefaultUsrpSchemaTests(unittest.TestCase):
         )
         self.assertIn("CUSTOM_USRP_SCHEMA_OK", result.stdout)
 
+    def test_unmodified_managed_usrp_driver_is_refreshed_on_upgrade(self):
+        stale_managed_driver = textwrap.dedent(
+            """
+            from remoteRF_server.common.idl import DeviceSchema, idl_register
+
+            @idl_register("usrp")
+            class StaleManagedUsrpSchema(DeviceSchema):
+                device_type = "usrp"
+                driver_version = "stale-managed"
+            """
+        )
+        result = self._run_fresh_server_import(
+            """
+            from remoteRF_server.common.idl.schema import get_driver_class
+            from remoteRF_server.common.utils import get_drivers_dir
+            from remoteRF_server.server import device_manager
+
+            schema_path = get_drivers_dir() / "usrp_schema.py"
+            assert "stale-managed" not in schema_path.read_text(encoding="utf-8")
+            assert get_driver_class("usrp").driver_version != "stale-managed"
+            print("MANAGED_USRP_SCHEMA_REFRESHED")
+            """,
+            managed_driver=stale_managed_driver,
+        )
+
+        self.assertEqual(
+            result.returncode,
+            0,
+            msg=f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}",
+        )
+        self.assertIn("MANAGED_USRP_SCHEMA_REFRESHED", result.stdout)
+
 
 if __name__ == "__main__":
     unittest.main()

{remoterf_server-1.0.6 → remoterf_server-1.0.7}/tests/test_dynamic_v2.py

@@ -139,14 +139,18 @@ class FakeInventorySchema:
 
 
 class DynamicV2ServerTests(unittest.TestCase):
-    def test_usrp_console_logging_is_off_by_default_but_admin_override_wins(self):
-        with patch.dict(os.environ, {}, clear=True):
+    def test_usrp_console_logging_is_forced_off_without_remoterf_opt_in(self):
+        with patch.dict(
+            os.environ,
+            {"UHD_LOG_CONSOLE_LEVEL": "debug"},
+            clear=True,
+        ):
             _configure_uhd_console_logging()
             self.assertEqual(os.environ["UHD_LOG_CONSOLE_LEVEL"], "off")
 
         with patch.dict(
             os.environ,
-            {"UHD_LOG_CONSOLE_LEVEL": "warning"},
+            {"REMOTERF_UHD_CONSOLE_LEVEL": "warning"},
             clear=True,
         ):
             _configure_uhd_console_logging()