remoteRF-server-testing 0.0.0__py3-none-any.whl

remoteRF_server/common/idl/schema.py

@@ -0,0 +1,358 @@
+# 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 @idl_register("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
+
+idl_register = register_driver
+
+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/common/utils/__init__.py

@@ -0,0 +1,6 @@
+from .api_token import validate_token, generate_token, hash_token
+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, get_certs_dir, get_drivers_dir, get_remoterf_root

remoteRF_server/common/utils/ansi_codes.py

@@ -0,0 +1,120 @@
+from prompt_toolkit.styles import Style
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit import print_formatted_text
+from enum import Enum
+
+class Sty(Enum):
+    # Basic colors
+    RED = 'red'
+    GREEN = 'green'
+    BLUE = 'blue'
+    YELLOW = 'yellow'
+    MAGENTA = 'magenta'
+    CYAN = 'cyan'
+    GRAY = 'gray'
+    
+    # Background colors
+    BG_RED = 'bg-red'
+    BG_GREEN = 'bg-green'
+    BG_BLUE = 'bg-blue'
+    
+    # Bright versions
+    BRIGHT_RED = 'bright-red'
+    BRIGHT_GREEN = 'bright-green'
+    BRIGHT_BLUE = 'bright-blue'
+    
+    # Formatting
+    BOLD = 'bold'
+    ITALIC = 'italic'
+    UNDERLINE = 'underline'
+    BLINK = 'blink'
+    REVERSE = 'reverse'
+    
+    # Combinations
+    ERROR = 'error'
+    WARNING = 'warning'
+    INFO = 'info'
+    
+    # Special
+    SELECTED = 'selected'
+    DEFAULT = 'default'
+
+# Define the styles based on ANSI codes
+style = Style.from_dict({
+    # Basic colors
+    'red': 'fg:#110000',
+    'green': 'fg:#003300',
+    'blue': 'fg:#0000ff',
+    'yellow': 'fg:#ffff00',
+    'magenta': 'fg:#ff00ff',
+    'cyan': 'fg:#00ffff',
+    'gray': 'fg:#808080',
+    
+    # Bright versions
+    'bright-red': 'fg:#ff5555',
+    'bright-green': 'fg:#00ff00',
+    'bright-blue': 'fg:#5555ff',
+    
+    # Formatting
+    'bold': 'bold',
+    'italic': 'italic',
+    'underline': 'underline',
+    'reverse': 'reverse',
+    
+    # Combinations
+    'error': 'bg:#ff0000 fg:#ffffff bold',
+    'warning': 'bg:#ffff00 fg:#000000 bold',
+    'info': 'bg:#0000ff fg:#ffffff italic underline',
+    
+    # Special
+    'selected': 'bg:#ffffff #000000 reverse',
+    'default':''
+})
+
+def printf(*args) -> str:
+    if len(args) % 2 != 0:
+        raise ValueError('Arguments must be in pairs of two.')
+    
+    # Create formatted text using the defined style
+    formatted_text = []
+    
+    for i in range(0, len(args), 2):
+        message = args[i]
+        styles = args[i+1]
+        
+        if not isinstance(styles, tuple):
+            styles = (styles,)
+            
+        resolved_styles = (s.value if isinstance(s, Enum) else s for s in styles)
+        
+        style_class = ' '.join(resolved_styles)
+        
+        formatted_text.append(('class:' + style_class, message))
+    
+    # Create FormattedText object from pairs
+    text = FormattedText(formatted_text)
+    
+    print_formatted_text(text, style=style)
+    return text
+
+def stylize(*args):
+    """
+    Create a styled prompt text based on pairs of (text, (Sty, ...), ...).
+    """
+    if len(args) % 2 != 0:
+        raise ValueError("Arguments must be in pairs of (text, style_class).")
+    
+    styled_parts = []
+    for i in range(0, len(args), 2):
+        text = args[i]
+        styles = args[i + 1]
+        
+        if not isinstance(styles, tuple):
+            styles = (styles,)
+            
+        resolved_styles = (s.value if isinstance(s, Enum) else s for s in styles)
+        
+        style_class = ' '.join(resolved_styles)
+        styled_parts.append(('class:' + style_class, text))
+    
+    return FormattedText(styled_parts)

remoteRF_server/common/utils/api_token.py

@@ -0,0 +1,21 @@
+import os
+import hashlib
+import base64
+import secrets
+from dotenv import load_dotenv, find_dotenv
+
+def generate_token(length=8) -> tuple[str, str, str]:
+    random_bytes = secrets.token_bytes(length)  
+    token = base64.urlsafe_b64encode(random_bytes).decode('utf-8').rstrip('=')  # Encode in base64 format
+    salt = os.urandom(16).hex()  # 16 bytes of random salt
+    hashed = hashlib.sha256(bytes.fromhex(salt) + token.encode()).hexdigest()  # Hash to sha256 standard
+    return salt, hashed, token
+
+def validate_token(salt, hash, token) -> bool:
+    new_hashed = hashlib.sha256(bytes.fromhex(salt) + token.encode()).hexdigest()
+    return new_hashed == hash
+
+def hash_token(token: str) -> tuple[str, str]:
+    salt = os.urandom(16).hex()
+    hashed = hashlib.sha256(bytes.fromhex(salt) + token.encode()).hexdigest()
+    return salt, hashed

remoteRF_server/common/utils/db_connection.py

@@ -0,0 +1,35 @@
+import sqlite3
+from functools import wraps
+
+def db_connection(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        with self.lock:  
+            old_db = getattr(self, "db", None)
+            old_cursor = getattr(self, "cursor", None)
+
+            conn = sqlite3.connect(str(self.filepath), timeout=5.0, check_same_thread=False)
+            try:
+                conn.execute("PRAGMA busy_timeout=5000;")
+                conn.execute("PRAGMA journal_mode=WAL;")
+
+                cur = conn.cursor()
+                self.db = conn
+                self.cursor = cur
+
+                try:
+                    result = func(self, *args, **kwargs)
+                    conn.commit()
+                    return result
+                except Exception:
+                    conn.rollback()
+                    raise
+                finally:
+                    try: cur.close()
+                    except Exception: pass
+            finally:
+                try: conn.close()
+                except Exception: pass
+                self.db = old_db
+                self.cursor = old_cursor
+    return wrapper

remoteRF_server/common/utils/db_location.py

@@ -0,0 +1,24 @@
+import os
+from pathlib import Path
+
+APP_NAME = "remoterf"
+
+def get_remoterf_root() -> Path:
+    # Linux-only: XDG_CONFIG_HOME or ~/.config
+    root = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / APP_NAME
+    root.mkdir(parents=True, exist_ok=True)
+
+    # ensure sibling folders exist
+    (root / "certs").mkdir(parents=True, exist_ok=True)
+    (root / "db").mkdir(parents=True, exist_ok=True)
+
+    return root
+
+def get_certs_dir() -> Path:
+    return get_remoterf_root() / "certs"
+
+def get_db_dir() -> Path:
+    return get_remoterf_root() / "db"
+
+def get_drivers_dir() -> Path:
+    return get_remoterf_root() / "drivers"

remoteRF_server/common/utils/list_string.py

@@ -0,0 +1,5 @@
+def list_to_str(list:list) -> str:
+    return ','.join(str(x) for x in list)
+
+def str_to_list(s:str) -> list[int]:
+    return [int(x) for x in s.split(',')]

remoteRF_server/common/utils/process_arg.py

@@ -0,0 +1,80 @@
+from ..grpc import grpc_pb2, grpc_pb2_grpc
+import numpy as np
+
+def unmap_arg(arg):
+    if arg.HasField('int64_value'):
+        return arg.int64_value
+    elif arg.HasField('float_value'):
+        return arg.float_value
+    elif arg.HasField('string_value'):
+        return arg.string_value
+    elif arg.HasField('bool_value'):
+        return arg.bool_value
+    elif arg.HasField('real_array'):
+        shape = tuple(arg.real_array.shape.dim)
+        return np.array(arg.real_array.data, dtype=np.float64).reshape(shape)
+    elif arg.HasField('complex_array'):
+        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)
+    else:
+        raise ValueError(f"Unknown argument type during unmapping: {arg}")
+    
+def map_arg(value):
+    arg = grpc_pb2.Argument()
+    
+    if isinstance(value, int):
+        arg.int64_value = value
+    elif isinstance(value, float):
+        arg.float_value = value
+    elif isinstance(value, str):
+        arg.string_value = value
+    elif isinstance(value, bool):
+        arg.bool_value = value
+    elif isinstance(value, np.ndarray):
+        if np.iscomplexobj(value):
+            complex_array = arg.complex_array
+            complex_array.shape.dim.extend(value.shape)
+            for num in value.ravel():
+                complex_num = complex_array.data.add()
+                complex_num.real = num.real
+                complex_num.imag = num.imag
+        else:
+            float_array = arg.real_array
+            float_array.shape.dim.extend(value.shape)
+            float_array.data.extend(value.ravel())
+    else:
+        raise ValueError(f"Unknown argument type during mapping: {value}")
+    return arg
+        
+def map_array_proto(np_array):
+    arg = grpc_pb2.Argument()
+    
+    # Check if the array is complex
+    if np.iscomplexobj(np_array):
+        complex_array = grpc_pb2.ComplexArray()
+        for num in np_array.flat:
+            complex_number = complex_array.data.add()
+            complex_number.real = num.real
+            complex_number.imag = num.imag
+        arg.complex_array.CopyFrom(complex_array)
+    else:
+        # Handle as a regular float array
+        float_array = grpc_pb2.FloatArray()
+        float_array.data.extend(np_array.flat)
+        arg.float_array.CopyFrom(float_array)
+
+    return arg
+
+def unmap_array_proto(arg):
+    # Check which type of array is available and convert appropriately
+    if arg.HasField('complex_array'):
+        # Convert ComplexArray to a numpy array of complex numbers
+        data = [complex(cn.real, cn.imag) for cn in arg.complex_array.data]
+        return np.array(data, dtype=np.complex64)
+    elif arg.HasField('float_array'):
+        # Convert FloatArray to a numpy array of floats
+        return np.array(arg.float_array.data, dtype=np.float32)
+    else:
+        raise ValueError("Argument does not contain a recognizable array.")
+