remoteRF-server 0.1.135__tar.gz → 0.2.0__tar.gz

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.135
+Version: 0.2.0
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf
@@ -9,6 +9,7 @@ Requires-Dist: prompt_toolkit
 Requires-Dist: python-dotenv
 Requires-Dist: grpcio-tools
 Requires-Dist: requests
+Requires-Dist: pyyaml
 
 # Remote RF Server Guide (Linux)
 

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "0.1.135"
+version = "0.2.0"
 dependencies = [
   "grpcio",
   "protobuf",
@@ -12,7 +12,8 @@ dependencies = [
   "prompt_toolkit",
   "python-dotenv",
   "grpcio-tools",
-  "requests"
+  "requests",
+  "pyyaml"
 ]
 readme = "README.md"
 

remoterf_server-0.2.0/src/remoteRF_server/common/idl/__init__.py

@@ -0,0 +1 @@
+from .schema import DeviceSchema, idl_register, idl_expose

remoterf_server-0.2.0/src/remoteRF_server/common/idl/device_schema.py

@@ -0,0 +1,39 @@
+# remoteRF_server/common/idl/schema_template.py
+
+# Include any necessary device imports, etc!
+
+# todo: 'throws error' if stuff isn't implemented, etc.
+# todo: have device_manifest live in .config, etc. (not in codebase)
+
+from . import * 
+
+# todo: would import the decorators from remoteRF_server ... -> which allows any admin script to run with the platform!
+# todo: you would run a 'baking the driver' (so it populates onto the .config or something with the proper version, etc. so the server knows!)
+
+class DeviceSchema:
+    
+    device_type = "template" # MUST match device_type in the device manifest!
+    driver_version = "0.0.1"
+    
+    # Returns instance of the device (ie: a class, etc!)
+    # Used by the server to actually 'connect' to the hardware devices!
+    # Define the proper args in the device Manifest -> pipes to this factory method to populate device list!
+    # todo: kwargs are EXACTLY the 'init' section of the device manifest!
+    @staticmethod
+    def make_device(**kwargs):
+        # Implement whatever logic you need to connect to the device (or init parameters, like BW, etc.)
+        raise NotImplementedError
+    
+    # Called by the server on init!
+    def __init__(self, device_instance):
+        self.device = device_instance
+    
+    @idl_expose # Decorators for each 'exposed' method/property!
+    def schema_info(self) -> float:
+        return f"{self.device_type} v{self.driver_version}"
+    
+    # Example exposed method:
+    @idl_expose # Decorators for each 'exposed' method/property!
+    def some_method(self, arg1: float, arg2: float) -> float:
+        return self.device.some_method(arg1, arg2) # EXAMPLE
+        # raise NotImplementedError

remoterf_server-0.2.0/src/remoteRF_server/common/idl/pluto_schema.py

@@ -0,0 +1,174 @@
+# ~/.config/remoterf/drivers/pluto_schema.py
+#
+# Admin-written schema for ADALM-Pluto devices.
+# Drop this file into the drivers folder, restart the server. Done.
+
+from . import *
+
+import subprocess
+import re
+import adi
+
+# ========================= PLUTO Connection Logic =========================
+
+def connect_pluto(*, serial: str):
+    serial = (serial or "").strip()
+    if not serial:
+        print("A Pluto serial must be provided")
+        return None
+
+    try:
+        out = subprocess.check_output(
+            ["iio_info", "-s"],
+            text=True,
+            stderr=subprocess.STDOUT
+        )
+
+        usb = None
+        for line in out.splitlines():
+            if (f"serial={serial}" in line) or (f"hw_serial={serial}" in line):
+                m = re.search(r"\[usb:([^\]]+)\]", line)
+                if m:
+                    usb = m.group(1).strip()
+                    break
+
+        if not usb:
+            print(f"No device found with serial {serial}")
+            return None
+
+        dev = adi.Pluto(f"usb:{usb}")
+        print(f"Connected to Pluto serial={serial} via usb:{usb}")
+        return dev
+
+    except Exception as e:
+        print(f"Failed to connect to Pluto serial={serial}: {e}")
+        return None
+
+# ========================= PLUTO Schema =========================
+
+@idl_register("pluto")
+class PlutoSchema(DeviceSchema):
+
+    device_type = "pluto"
+    driver_version = "0.0.1"
+
+    @staticmethod
+    def make_device(**kwargs):
+        serial = kwargs.get("serial")
+        return connect_pluto(serial=serial)
+
+    # region ad9364
+
+    @idl_expose(kind="get")
+    def get_filter(self):
+        return self.device.filter
+
+    @idl_expose(kind="set")
+    def set_filter(self, value):
+        self.device.filter = value
+
+    @idl_expose(kind="get")
+    def get_loopback(self):
+        return self.device.loopback
+
+    @idl_expose(kind="set")
+    def set_loopback(self, value):
+        self.device.loopback = value
+
+    @idl_expose(kind="get")
+    def get_gain_control_mode_chan0(self):
+        return self.device.gain_control_mode_chan0
+
+    @idl_expose(kind="set")
+    def set_gain_control_mode_chan0(self, value):
+        self.device.gain_control_mode_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_rx_hardwaregain_chan0(self):
+        return self.device.rx_hardwaregain_chan0
+
+    @idl_expose(kind="set")
+    def set_rx_hardwaregain_chan0(self, value):
+        self.device.rx_hardwaregain_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_tx_hardwaregain_chan0(self):
+        return self.device.tx_hardwaregain_chan0
+
+    @idl_expose(kind="set")
+    def set_tx_hardwaregain_chan0(self, value):
+        self.device.tx_hardwaregain_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_rx_rf_bandwidth(self):
+        return self.device.rx_rf_bandwidth
+
+    @idl_expose(kind="set")
+    def set_rx_rf_bandwidth(self, value):
+        self.device.rx_rf_bandwidth = value
+
+    @idl_expose(kind="get")
+    def get_tx_rf_bandwidth(self):
+        return self.device.tx_rf_bandwidth
+
+    @idl_expose(kind="set")
+    def set_tx_rf_bandwidth(self, value):
+        self.device.tx_rf_bandwidth = value
+
+    @idl_expose(kind="get")
+    def get_sample_rate(self):
+        return self.device.sample_rate
+
+    @idl_expose(kind="set")
+    def set_sample_rate(self, value):
+        self.device.sample_rate = value
+
+    @idl_expose(kind="get")
+    def get_rx_lo(self):
+        return self.device.rx_lo
+
+    @idl_expose(kind="set")
+    def set_rx_lo(self, value):
+        self.device.rx_lo = value
+
+    @idl_expose(kind="get")
+    def get_tx_lo(self):
+        return self.device.tx_lo
+
+    @idl_expose(kind="set")
+    def set_tx_lo(self, value):
+        self.device.tx_lo = value
+
+    @idl_expose(kind="get")
+    def get_tx_cyclic_buffer(self):
+        return self.device.tx_cyclic_buffer
+
+    @idl_expose(kind="set")
+    def set_tx_cyclic_buffer(self, value):
+        self.device.tx_cyclic_buffer = value
+
+    # region RX/TX
+
+    @idl_expose(kind="call")
+    def call_rx(self):
+        return self.device.rx()
+
+    @idl_expose(kind="get")
+    def get_rx_buffer_size(self):
+        return self.device.rx_buffer_size
+
+    @idl_expose(kind="set")
+    def set_rx_buffer_size(self, value):
+        self.device.rx_buffer_size = value
+
+    @idl_expose(kind="call")
+    def call_rx_destroy_buffer(self):
+        self.device.rx_destroy_buffer()
+
+    @idl_expose(kind="call")
+    def call_tx(self, value):
+        self.device.tx(value)
+
+    @idl_expose(kind="call")
+    def call_tx_destroy_buffer(self):
+        self.device.tx_destroy_buffer()

remoterf_server-0.2.0/src/remoteRF_server/common/idl/schema.py

@@ -0,0 +1,356 @@
+# src/remoteRF_server/common/idl/schema.py
+"""
+IDL Schema framework.
+
+Admin writes one .py per device TYPE, drops it in ~/.config/remoterf/drivers/,
+and the server auto-discovers it on startup via load_drivers().
+
+    ~/.config/remoterf/
+        devices.env                 ← "I have 3 plutos at these serials"
+        drivers/
+            pluto_schema.py         ← "here's what a pluto IS"
+            hackrf_schema.py
+            webcam_schema.py
+
+The admin's schema file:
+    1. Imports from this module
+    2. Subclasses DeviceSchema
+    3. Decorates with @register_driver("pluto")
+    4. Implements make_device(**kwargs) — factory from manifest config
+    5. Decorates exposed methods with @idl_expose(kind="get"|"set"|"call")
+
+That's it. The server never needs to be modified.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ..utils import *
+
+# ───────────────────────────────────────────────────────────────────
+# @idl_expose decorator
+# ───────────────────────────────────────────────────────────────────
+
+_EXPOSE_KEY = "__idl__"
+
+def idl_expose(_fn=None, *, kind: str = "call", doc: str = ""):
+    """
+    Mark a method as exposed over IDL.
+
+        @idl_expose(kind="get")
+        def get_tx_lo(self):
+            return self.device.tx_lo
+
+        @idl_expose(kind="set")
+        def set_tx_lo(self, value):
+            self.device.tx_lo = value
+
+        @idl_expose(kind="call")
+        def call_rx(self):
+            return self.device.rx()
+
+        @idl_expose                     # bare — defaults to kind="call"
+        def some_method(self, x):
+            ...
+
+    kind:
+        "get"  — property getter (no args beyond self)
+        "set"  — property setter (one arg: value)
+        "call" — general method (any args)
+    """
+    def _apply(fn):
+        meta = {
+            "kind": kind,
+            "doc": doc or (fn.__doc__ or "").strip(),
+        }
+        setattr(fn, _EXPOSE_KEY, meta)
+        return fn
+
+    if _fn is not None:
+        return _apply(_fn)
+    return _apply
+
+
+# ───────────────────────────────────────────────────────────────────
+# Driver registry
+# ───────────────────────────────────────────────────────────────────
+
+_DRIVER_REGISTRY: Dict[str, type] = {}
+
+def register_driver(device_type: str):
+    """
+    Class decorator — registers a schema so the server can find it by type string.
+
+        @register_driver("pluto")
+        class PlutoSchema(DeviceSchema):
+            ...
+    """
+    def decorator(cls):
+        key = device_type.strip().lower()
+        _DRIVER_REGISTRY[key] = cls
+        return cls
+    return decorator
+
+def get_driver_class(device_type: str) -> type:
+    cls = _DRIVER_REGISTRY.get(device_type.strip().lower())
+    if cls is None:
+        raise KeyError(
+            f"no driver for type '{device_type}'. "
+            f"registered: {list(_DRIVER_REGISTRY.keys()) or ['(none)']}"
+        )
+    return cls
+
+def list_registered_drivers() -> Dict[str, str]:
+    return {
+        k: f"{cls.device_type} v{cls.driver_version}"
+        for k, cls in _DRIVER_REGISTRY.items()
+    }
+
+# ───────────────────────────────────────────────────────────────────
+# Plugin loader — auto-discover driver schemas from a folder
+# ───────────────────────────────────────────────────────────────────
+
+def load_drivers() -> Dict[str, str]:
+    """
+    Import every .py in the drivers config dir.  Each file's @idl_register
+    decorator self-registers into the global registry.
+
+    Returns {filename: status} for logging.
+
+    Called once at server startup:
+        load_drivers()
+    """
+    drivers_dir = get_drivers_dir()
+    results: Dict[str, str] = {}
+
+    if not drivers_dir.is_dir():
+        return {"__error__": f"{drivers_dir} is not a directory"}
+
+    for f in sorted(drivers_dir.glob("*.py")):
+        if f.name.startswith("_"):
+            continue
+        try:
+            spec = importlib.util.spec_from_file_location(f.stem, str(f))
+            if spec is None or spec.loader is None:
+                results[f.name] = "skip: not a valid module"
+                continue
+            mod = importlib.util.module_from_spec(spec)
+            # Make our module importable from inside the driver file
+            # so `from schema import ...` works even when loaded as a plugin
+            sys.modules[f.stem] = mod
+            spec.loader.exec_module(mod)
+            results[f.name] = "ok"
+        except Exception as e:
+            results[f.name] = f"error: {e}"
+
+    return results
+
+
+# ───────────────────────────────────────────────────────────────────
+# DeviceSchema base class
+# ───────────────────────────────────────────────────────────────────
+
+class DeviceSchema:
+    """
+    Base for all device schemas.  Admin subclasses this once per device type.
+
+    Class attributes (admin sets these):
+        device_type      str   — must match the TYPE in devices.env
+        driver_version   str   — semver
+
+    Admin implements:
+        make_device(**kwargs)  — factory: manifest config → live device handle
+                                 returns the device object, or None on failure
+
+    Admin decorates exposed methods with @idl_expose(kind=...).
+
+    The server calls:
+        schema = PlutoSchema()
+        dev = schema.make_device(serial="00000001")
+        schema.device = dev                 # or schema.bind(dev)
+        schema.dispatch("get_tx_lo", {})    # → calls get_tx_lo()
+    """
+
+    device_type: str = ""
+    driver_version: str = ""
+
+    def __init__(self):
+        self.device = None                      # set after make_device()
+        self._exposed: Dict[str, _Exposed] = {}
+        self._schema_cache: dict | None = None
+        self._hash_cache: str | None = None
+        self._introspect()
+
+    # ── Factory (admin overrides) ─────────────────────────────────
+
+    @staticmethod
+    def make_device(**kwargs):
+        """
+        Create and return a live device handle using kwargs from the manifest.
+        Admin MUST override this.
+        """
+        raise NotImplementedError("make_device() must be implemented in the schema")
+
+    # ── Bind device to schema instance ────────────────────────────
+
+    def bind(self, device) -> None:
+        """Attach a live device handle so exposed methods can use self.device."""
+        self.device = device
+
+    def is_connected(self) -> bool:
+        return self.device is not None
+
+    # ── Introspection ─────────────────────────────────────────────
+
+    def _introspect(self):
+        seen: set = set()
+        for klass in type(self).__mro__:
+            for name, obj in vars(klass).items():
+                if name in seen or name.startswith("_"):
+                    continue
+                meta = getattr(obj, _EXPOSE_KEY, None)
+                if meta is None:
+                    continue
+                seen.add(name)
+                self._exposed[name] = _Exposed(
+                    name=name, fn=obj, kind=meta["kind"], doc=meta["doc"],
+                )
+
+    # ── IDL generation ────────────────────────────────────────────
+
+    def get_idl(self) -> dict:
+        """Full wire-ready schema dict with content-addressed hash."""
+        if self._schema_cache is not None:
+            return self._schema_cache
+
+        body = self._build_body()
+        canon = json.dumps(body, sort_keys=True, separators=(",", ":"))
+        h = f"sha256:{hashlib.sha256(canon.encode()).hexdigest()}"
+
+        self._hash_cache = h
+        self._schema_cache = {**body, "schema_hash": h}
+        return self._schema_cache
+
+    def get_idl_hash(self) -> str:
+        if self._hash_cache is None:
+            self.get_idl()
+        return self._hash_cache  # type: ignore
+
+    def get_idl_json(self, *, pretty: bool = False) -> str:
+        d = self.get_idl()
+        if pretty:
+            return json.dumps(d, indent=2, sort_keys=True)
+        return json.dumps(d, sort_keys=True, separators=(",", ":"))
+
+    def _build_body(self) -> dict:
+        getters = {}
+        setters = {}
+        calls = {}
+
+        for name, ex in sorted(self._exposed.items()):
+            entry = {"doc": ex.doc} if ex.doc else {}
+            if ex.kind == "get":
+                getters[name] = entry
+            elif ex.kind == "set":
+                setters[name] = entry
+            elif ex.kind == "call":
+                calls[name] = entry
+
+        return {
+            "schema_version": "1.0",
+            "device_type": self.device_type,
+            "driver_version": self.driver_version,
+            "getters": getters,
+            "setters": setters,
+            "calls": calls,
+        }
+
+    # ── Dispatch (server RPC layer calls this) ────────────────────
+
+    def dispatch(self, method_name: str, args: dict) -> Any:
+        """
+        Called by the RPC layer.  Finds the exposed method and calls it.
+
+            dispatch("get_tx_lo", {})               → self.get_tx_lo()
+            dispatch("set_tx_lo", {"value": 2.4e9}) → self.set_tx_lo(2.4e9)
+            dispatch("call_rx", {})                 → self.call_rx()
+            dispatch("call_tx", {"value": samples}) → self.call_tx(samples)
+        """
+        ex = self._exposed.get(method_name)
+        if ex is None:
+            raise KeyError(
+                f"'{method_name}' is not exposed on {self.device_type}. "
+                f"Available: {list(self._exposed.keys())}"
+            )
+
+        if self.device is None:
+            raise RuntimeError(f"no device bound to {self.device_type} schema")
+
+        if ex.kind == "get":
+            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)
+
+        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)
+        else:
+            raise ValueError(f"unknown kind '{ex.kind}' on {method_name}")
+
+    # ── Debug ─────────────────────────────────────────────────────
+
+    def list_exposed(self) -> dict:
+        by_kind: Dict[str, list] = {"get": [], "set": [], "call": []}
+        for name, ex in sorted(self._exposed.items()):
+            by_kind.get(ex.kind, []).append(name)
+        return {
+            "device_type": self.device_type,
+            "driver_version": self.driver_version,
+            "connected": self.is_connected(),
+            "getters": by_kind["get"],
+            "setters": by_kind["set"],
+            "calls": by_kind["call"],
+        }
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} type={self.device_type!r} connected={self.is_connected()}>"
+
+
+# ───────────────────────────────────────────────────────────────────
+# Internal
+# ───────────────────────────────────────────────────────────────────
+
+class _Exposed:
+    __slots__ = ("name", "fn", "kind", "doc")
+    def __init__(self, *, name, fn, kind, doc):
+        self.name = name
+        self.fn = fn
+        self.kind = kind
+        self.doc = doc

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server/common/utils/__init__.py

@@ -3,4 +3,4 @@ from .process_arg import unmap_arg, map_arg
 from .ansi_codes import printf, stylize, Sty
 from .list_string import list_to_str, str_to_list
 from .db_connection import db_connection
-from .db_location import get_db_dir
+from .db_location import get_db_dir, get_certs_dir, get_drivers_dir, get_remoterf_root

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server/common/utils/db_location.py

@@ -19,3 +19,6 @@ def get_certs_dir() -> Path:
 
 def get_db_dir() -> Path:
     return get_remoterf_root() / "db"
+
+def get_drivers_dir() -> Path:
+    return get_remoterf_root() / "drivers"

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server/server/device_manager.py

@@ -6,6 +6,7 @@ import os
 import re
 import time
 import adi
+import yaml
 import subprocess
 import threading
 from dataclasses import dataclass, field
@@ -13,7 +14,7 @@ from pathlib import Path
 from typing import Dict, Tuple, Optional, Any, List, Iterator
 from contextlib import contextmanager
 
-from ..common.utils import validate_token  
+from ..common.utils import validate_token, get_remoterf_root
 from ..host import host_tunnel_server as hts  
 
 _state_lock = threading.RLock()
@@ -226,17 +227,67 @@ def _host_devices_str_snapshot() -> Dict[int, str]:
 
 # Config paths (server-side)
 
-def _xdg_config_home() -> Path:
-    return Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+def _cfg_dir() -> Path:
+    return Path(os.getenv("REMOTERF_CONFIG_DIR", get_remoterf_root()))
 
+def _devices_yaml_path() -> Path:
+    p1 = _cfg_dir() / "devices.yml"
+    if p1.exists():
+        return p1
+    return _cfg_dir() / "devices.yaml"
 
-def _cfg_dir() -> Path:
-    # default: ~/.config/remoterf
-    return Path(os.getenv("REMOTERF_CONFIG_DIR", _xdg_config_home() / "remoterf"))
+def _load_device_records() -> Dict[int, Dict[str, str]]:
+    path = _devices_yaml_path()
+    if not path.exists():
+        return {}
+
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+    except Exception as e:
+        print(f"Error reading YAML config {path}: {e}")
+        return {}
+
+    devices = data.get("devices") or []
+    if not isinstance(devices, list):
+        print(f"Invalid YAML config {path}: 'devices' must be a list")
+        return {}
+
+    recs: Dict[int, Dict[str, str]] = {}
+
+    for item in devices:
+        if not isinstance(item, dict):
+            continue
+
+        try:
+            gid = int(item["device_id"])
+        except Exception:
+            print(f"Skipping device entry with invalid/missing device_id: {item}")
+            continue
+
+        dtype = str(item.get("device_type") or "pluto").strip().lower()
+        if dtype != "pluto":
+            print(f"Skipping unsupported device_type={dtype!r} for gid={gid}")
+            continue
 
+        name = str(item.get("name") or f"device-{gid}").strip()
+        init = item.get("init") or {}
+        if not isinstance(init, dict):
+            init = {}
 
-def _devices_env_path() -> Path:
-    return _cfg_dir() / "devices.env"
+        serial = str(init.get("serial") or "").strip()
+        if not serial:
+            print(f"Skipping Pluto gid={gid}: missing init.serial")
+            continue
+
+        recs[gid] = {
+            "TYPE": "pluto",
+            "NAME": name,
+            "IDENT_KIND": "iio_serial",
+            "IDENT": serial,
+        }
+
+    return recs
 
 # Pluto helpers
 
@@ -273,74 +324,6 @@ def get_usb_port_from_serial(serial: str) -> str | None:
     print(f"No device found with serial {serial}")
     return None
 
-# Parse devices.env
-
-_ENV_LINE = re.compile(r"^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$")
-_DEVICE_KEY_RE = re.compile(r"^DEVICE_(\d+)_(.+)$", re.IGNORECASE)
-
-def _strip_quotes(v: str) -> str:
-    v = (v or "").strip()
-    if len(v) >= 2 and ((v[0] == v[-1] == '"') or (v[0] == v[-1] == "'")):
-        return v[1:-1]
-    return v
-
-def _read_env_file(path: Path) -> Dict[str, str]:
-    out: Dict[str, str] = {}
-    if not path.exists():
-        return out
-    try:
-        txt = path.read_text(encoding="utf-8")
-    except Exception:
-        return out
-
-    for raw in txt.splitlines():
-        line = raw.strip()
-        if not line or line.startswith("#"):
-            continue
-        m = _ENV_LINE.match(line)
-        if not m:
-            continue
-        k = m.group(1).strip()
-        v = _strip_quotes(m.group(2))
-        out[k] = v
-    return out
-
-def _load_device_records() -> Dict[int, Dict[str, str]]:
-    # Returns: { gid: { "TYPE":..., "NAME":..., "IDENT_KIND":..., "IDENT":..., ... } }
-
-    kv = _read_env_file(_devices_env_path())
-    recs: Dict[int, Dict[str, str]] = {}
-
-    # New format: DEVICE_<gid>_<FIELD>
-    for k, v in kv.items():
-        m = _DEVICE_KEY_RE.match(k.strip())
-        if not m:
-            continue
-        try:
-            gid = int(m.group(1))
-        except Exception:
-            continue
-        field = m.group(2).strip().upper()
-        recs.setdefault(gid, {})[field] = str(v).strip()
-
-    # Back-compat: DEVICE_<gid>_ID treated as IDENT
-    for k, v in kv.items():
-        kk = k.strip().upper()
-        if not kk.startswith("DEVICE_") or not kk.endswith("_ID"):
-            continue
-        mid = kk[7:-3]
-        try:
-            gid = int(mid)
-        except Exception:
-            continue
-        recs.setdefault(gid, {})
-        recs[gid].setdefault("TYPE", "pluto")
-        recs[gid].setdefault("NAME", f"device-{gid}")
-        recs[gid].setdefault("IDENT_KIND", "iio_serial")
-        recs[gid].setdefault("IDENT", str(v).strip())
-
-    return recs
-
 def _connect_from_record(rec: Dict[str, str]):
     # Returns (device_obj, ident, dtype).
    

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server/server/reservation.py

@@ -478,12 +478,7 @@ class ReservationHandler:
                 print("Username:", account[1], f'<{perms.get_perms(account[1])[0][0]}>', " Email:", account[2], " Created At:", account[5])
         else:
             print("No accounts found.")
-    
-    
-    # ──────────────────────────────────────────────────────────────
-    # UPDATED: get_obfuscated_device_reservations_grouped_past_days
-    # (logs-only, no DB access)
-    # ──────────────────────────────────────────────────────────────
+            
     @db_connection
     def get_obfuscated_device_reservations_grouped_past_days(self, days: int) -> dict[str, dict[str, int]]:
         try:
@@ -505,105 +500,62 @@ class ReservationHandler:
 
             s = str(v).strip()
 
+            # Handles strings like:
+            #   "int64_value: 2"
+            #   "int64_value: 1772587800"
             if ":" in s:
                 s = s.split(":", 1)[1].strip()
 
+            # remove quotes/newlines if present
             s = s.strip().strip('"').strip("'")
             return int(float(s))
 
-        def _parse_logged_str(v) -> str:
-            if not isinstance(v, str):
-                return str(v).strip()
-            s = v.strip()
-            if ":" in s:
-                s = s.split(":", 1)[1].strip()
-            s = s.strip().strip('"').strip("'").strip()
-            return s
-
+        # Take a consistent snapshot of the log file under the same lock used by writers.
         try:
             with log_lock:
                 activity_log = _load_logs()
         except Exception:
             activity_log = []
 
-        # ── Pass 1: Collect all successful reserve_device entries in order ──
-        reserves = []  # list of (log_index, username, device_id, start_ts, end_ts)
-        for i, entry in enumerate(activity_log):
+        out: dict[str, dict[str, int]] = {}
+
+        for entry in activity_log:
             try:
                 if not isinstance(entry, dict):
                     continue
+
                 if str(entry.get("action", "")).strip() != "reserve_device":
                     continue
+
                 details = entry.get("details", {})
                 if not isinstance(details, dict):
                     continue
+
                 args = details.get("args", {})
                 result = details.get("result", {})
-                if not isinstance(args, dict) or not isinstance(result, dict):
-                    continue
-                if "Token" not in result:
-                    continue
 
-                raw_un = args.get("un")
-                raw_dd = args.get("dd")
-                raw_st = args.get("st")
-                raw_et = args.get("et")
-                if raw_dd is None or raw_st is None or raw_et is None:
+                if not isinstance(args, dict) or not isinstance(result, dict):
                     continue
 
-                username = _parse_logged_str(raw_un) if raw_un else None
-                device_id = _parse_logged_int(raw_dd)
-                start_ts = _parse_logged_int(raw_st)
-                end_ts = _parse_logged_int(raw_et)
-
-                reserves.append((i, username, device_id, start_ts, end_ts))
-            except Exception:
-                continue
-
-        # ── Pass 2: Collect successful cancel_res entries ──
-        cancels = []  # list of cancel_username (in log order)
-        for entry in activity_log:
-            try:
-                if not isinstance(entry, dict):
-                    continue
-                if str(entry.get("action", "")).strip() != "cancel_res":
-                    continue
-                details = entry.get("details", {})
-                if not isinstance(details, dict):
-                    continue
-                result = details.get("result", {})
-                args = details.get("args", {})
-                if not isinstance(result, dict) or not isinstance(args, dict):
-                    continue
-                if "UC" not in result:
+                # Only count SUCCESSFUL reservations
+                if "Token" not in result:
                     continue
 
-                cancel_username = _parse_logged_str(args.get("un", ""))
-                cancels.append(cancel_username)
-            except Exception:
-                continue
+                raw_device_id = args.get("dd")
+                raw_start = args.get("st")
+                raw_end = args.get("et")
 
-        # ── Match each cancel to the earliest unmatched reserve for that user ──
-        canceled_indices: set[int] = set()
-        for cancel_username in cancels:
-            for (log_i, res_un, dev_id, st, et) in reserves:
-                if log_i in canceled_indices:
+                if raw_device_id is None or raw_start is None or raw_end is None:
                     continue
-                if res_un == cancel_username:
-                    canceled_indices.add(log_i)
-                    break  # one cancel removes one reservation
-
-        # ── Build output, skipping canceled entries ──
-        out: dict[str, dict[str, int]] = {}
 
-        for (log_i, username, device_id, start_ts, end_ts) in reserves:
-            try:
-                if log_i in canceled_indices:
-                    continue
+                device_id = _parse_logged_int(raw_device_id)
+                start_ts = _parse_logged_int(raw_start)
+                end_ts = _parse_logged_int(raw_end)
 
                 start_dt = datetime.fromtimestamp(start_ts)
                 end_dt = datetime.fromtimestamp(end_ts)
 
+                # Same overlap semantics as before
                 if end_dt < cutoff or start_dt > now:
                     continue
 
@@ -619,11 +571,7 @@ class ReservationHandler:
                 continue
 
         return dict(sorted(out.items(), key=lambda kv: int(kv[0])))
-
-    # ──────────────────────────────────────────────
-    # UPDATED: get_obfuscated_usage_summary
-    # (logs-only, no DB access)
-    # ──────────────────────────────────────────────
+    
     @db_connection
     def get_obfuscated_usage_summary(self) -> dict[str, int | float]:
 
@@ -646,26 +594,17 @@ class ReservationHandler:
 
             return v
 
-        def _parse_logged_str(v) -> str:
-            if not isinstance(v, str):
-                return str(v).strip()
-            s = v.strip()
-            if ":" in s:
-                s = s.split(":", 1)[1].strip()
-            s = s.strip().strip('"').strip("'").strip()
-            return s
-
         try:
             with log_lock:
                 activity_log = _load_logs()
         except Exception:
             activity_log = []
 
-        # ── Collect successful reserves and account logins ──
-        reserves = []  # (log_index, username, start_ts, end_ts)
         accounts: set[str] = set()
+        total_reservations = 0
+        total_reserved_seconds = 0
 
-        for i, entry in enumerate(activity_log):
+        for entry in activity_log:
             try:
                 if not isinstance(entry, dict):
                     continue
@@ -687,71 +626,24 @@ class ReservationHandler:
                     elif username:
                         accounts.add(str(username))
 
-                # Collect successful reservations
-                if action == "reserve_device" and "Token" in result:
-                    res_username = _parse_logged_str(args.get("un", "")) if args.get("un") else (username or "")
+                # Count reservations + reserved time
+                if action == "reserve_device":
+                    total_reservations += 1
 
                     st = _parse_proto_value(args.get("st"))
                     et = _parse_proto_value(args.get("et"))
 
-                    start_ts = int(st) if isinstance(st, int) else 0
-                    end_ts = int(et) if isinstance(et, int) else 0
-
-                    reserves.append((i, res_username, start_ts, end_ts))
+                    if isinstance(st, int) and isinstance(et, int) and et > st:
+                        total_reserved_seconds += (et - st)
 
             except Exception:
                 continue
 
-        # ── Collect successful cancels ──
-        cancels = []
-        for entry in activity_log:
-            try:
-                if not isinstance(entry, dict):
-                    continue
-                if str(entry.get("action", "")).strip() != "cancel_res":
-                    continue
-                details = entry.get("details", {})
-                if not isinstance(details, dict):
-                    continue
-                result = details.get("result", {})
-                args = details.get("args", {})
-                if not isinstance(result, dict) or not isinstance(args, dict):
-                    continue
-                if "UC" not in result:
-                    continue
-
-                cancel_username = _parse_logged_str(args.get("un", ""))
-                cancels.append(cancel_username)
-            except Exception:
-                continue
-
-        # ── Match each cancel to the earliest unmatched reserve for that user ──
-        canceled_indices: set[int] = set()
-        for cancel_username in cancels:
-            for (log_i, res_un, st, et) in reserves:
-                if log_i in canceled_indices:
-                    continue
-                if res_un == cancel_username:
-                    canceled_indices.add(log_i)
-                    break
-
-        # ── Tally, excluding canceled ──
-        total_reservations = 0
-        total_reserved_seconds = 0
-
-        for (log_i, res_un, start_ts, end_ts) in reserves:
-            if log_i in canceled_indices:
-                continue
-            total_reservations += 1
-            if end_ts > start_ts:
-                total_reserved_seconds += (end_ts - start_ts)
-
         return {
             "account_count": len(accounts),
             "total_reservations": int(total_reservations),
             "total_reserved_hours": round(total_reserved_seconds / 3600.0, 1),
         }
-    
             
     def get_reservation_count(self, username):
         self.cursor.execute("SELECT COUNT(*) FROM Reservations WHERE username = ?", (username,))

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server/tools/gist_status.py

@@ -134,6 +134,6 @@ def start_status_publisher(*, period_sec: int = 60) -> None:
 
 
 if __name__ == "__main__":
-    start_status_publisher(period_sec=60)
+    start_status_publisher(period_sec=120)
     while True:
         time.sleep(3600)

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.1.135
+Version: 0.2.0
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf
@@ -9,6 +9,7 @@ Requires-Dist: prompt_toolkit
 Requires-Dist: python-dotenv
 Requires-Dist: grpcio-tools
 Requires-Dist: requests
+Requires-Dist: pyyaml
 
 # Remote RF Server Guide (Linux)
 

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server.egg-info/SOURCES.txt

@@ -14,6 +14,10 @@ src/remoteRF_server/common/grpc/grpc_host_pb2.py
 src/remoteRF_server/common/grpc/grpc_host_pb2_grpc.py
 src/remoteRF_server/common/grpc/grpc_pb2.py
 src/remoteRF_server/common/grpc/grpc_pb2_grpc.py
+src/remoteRF_server/common/idl/__init__.py
+src/remoteRF_server/common/idl/device_schema.py
+src/remoteRF_server/common/idl/pluto_schema.py
+src/remoteRF_server/common/idl/schema.py
 src/remoteRF_server/common/utils/__init__.py
 src/remoteRF_server/common/utils/ansi_codes.py
 src/remoteRF_server/common/utils/api_token.py

{remoterf_server-0.1.135 → remoterf_server-0.2.0}/src/remoteRF_server.egg-info/requires.txt

@@ -5,3 +5,4 @@ prompt_toolkit
 python-dotenv
 grpcio-tools
 requests
+pyyaml