RemoteRF 2.0.14__tar.gz → 2.0.15__tar.gz

{remoterf-2.0.14/src/remoterf.egg-info → remoterf-2.0.15}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.0.14
+Version: 2.0.15
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
-Author: Ethan Ge
-Author-email: ethoGalaxy@gmail.com
-License: GPL-3.0-or-later
+Author-email: Ethan Ge <ethoGalaxy@gmail.com>
+License-Expression: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -16,17 +14,7 @@ Requires-Dist: protobuf<7.0.0,>=6.31.1
 Requires-Dist: numpy
 Requires-Dist: prompt_toolkit
 Requires-Dist: python-dotenv
-Requires-Dist: prompt-toolkit
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Remote RF
 

remoterf-2.0.15/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "remoterf"
+version = "2.0.15"
+description = "A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts."
+readme = "README.md"
+license = "GPL-3.0-or-later"
+license-files = ["LICENSE"]
+authors = [{ name = "Ethan Ge", email = "ethoGalaxy@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+  "grpcio>=1.78.1,<2.0.0",
+  "protobuf>=6.31.1,<7.0.0",
+  "numpy",
+  "prompt_toolkit",
+  "python-dotenv",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+[project.scripts]
+remoterf = "remoteRF.remoterf_cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.crt", "*.key", "*.pem", "*.txt", "*.pyi", "*.proto"]

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoteRF/common/grpc/v2_codec.py

@@ -48,7 +48,7 @@ def _json_safe(value):
     if hasattr(value, "as_payload"):
         return _json_safe(value.as_payload())
     if isinstance(value, np.generic):
-        return value.item()
+        return _json_safe(value.item())
     if isinstance(value, complex):
         return {
             _JSON_TYPE_KEY: "complex",

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoteRF/core/grpc_acc.py

@@ -56,7 +56,7 @@ class RemoteRFAccount:
             token = unmap_arg(response.results["Token"])
             try:
                 from ..drivers.dynamic_device import install_driver
-                install_driver(device_id=device_id)
+                install_driver(token=token, device_id=device_id)
             except Exception as e:
                 print(f"Warning: could not install driver for device {device_id}: {e}")
             return token

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoteRF/drivers/dynamic_device.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 
 import json
 import keyword
+import sys
 from pathlib import Path
 
 from ..common.utils import map_arg, unmap_arg
@@ -89,29 +90,20 @@ def fetch_idl(
             "schema_hash": "sha256:...",
         }
     """
-    if token is not None and prefer_v2:
-        from .dynamic_v2 import fetch_schema_v2
-        from ..core.v2_errors import RemoteRFProtocolError, RemoteRFTransportError
-
-        try:
-            return fetch_schema_v2(str(token))
-        except RemoteRFProtocolError:
-            # The selected device may only publish v1 (for example Pluto).
-            pass
-        except RemoteRFTransportError as exc:
-            # Old servers report the additive v2 service as UNIMPLEMENTED.
-            if exc.details.get("grpc_code") != "UNIMPLEMENTED":
-                raise
-
     args: dict = {}
-    if token is not None:
-        args['token'] = map_arg(str(token))
-    elif device_id is not None:
+    if device_id is not None:
         args['device_id'] = map_arg(int(device_id))
+    elif token is not None:
+        args['token'] = map_arg(str(token))
     elif device_name is not None:
         args['device_name'] = map_arg(str(device_name))
     else:
         raise ValueError("fetch_idl requires token, device_id, or device_name")
+    if prefer_v2:
+        # One RPC either way: servers that know v2 answer with it when the
+        # device publishes one (also by device_id, which needs no active
+        # reservation); v1-only devices and older servers answer v1.
+        args['schema_versions'] = map_arg(["2.0"])
 
     from ..core.grpc_client import rpc_client
 
@@ -1381,8 +1373,14 @@ _DRIVERS_DIR = Path(__file__).parent
 
 
 def _write_driver_files(schema: dict) -> Path:
-    if str(schema.get("schema_version")) == "2.0":
-        return _write_v2_driver_files(schema)
+    pkg_dir = _write_v2_driver_files(schema) if str(schema.get("schema_version")) == "2.0" else _write_v1_driver_files(schema)
+    stale = f"remoteRF.drivers.{pkg_dir.name}"
+    for name in [m for m in sys.modules if m == stale or m.startswith(stale + ".")]:
+        del sys.modules[name]
+    return pkg_dir
+
+
+def _write_v1_driver_files(schema: dict) -> Path:
 
     (
         device_type,
@@ -1397,8 +1395,13 @@ def _write_driver_files(schema: dict) -> Path:
         _call_map,
     ) = _schema_maps(schema)
     pkg_dir = _DRIVERS_DIR / device_type
+    remote_path = pkg_dir / f"{device_type}_remote.py"
+    if remote_path.exists() and _is_v2_driver(remote_path):
+        # The server answered v1 (older server, or a device that no longer
+        # publishes v2); don't trade an installed Dynamic v2 driver for it.
+        return pkg_dir
     pkg_dir.mkdir(exist_ok=True)
-    (pkg_dir / f"{device_type}_remote.py").write_text(_codegen(schema), encoding="utf-8")
+    remote_path.write_text(_codegen(schema), encoding="utf-8")
     init_lines = [
         *_GPL_NOTICE_LINES,
         "from importlib import import_module as _import_module",
@@ -1550,11 +1553,7 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
         device_name=device_name,
         prefer_v2=True,
     )
-    device_type = (
-        _require_package_name(schema.get("device_type"), field="device_type")
-        if str(schema.get("schema_version")) == "2.0"
-        else _schema_maps(schema)[0]
-    )
+    device_type = _schema_device_type(schema)
     remote_path = _DRIVERS_DIR / device_type / f"{device_type}_remote.py"
 
     if not remote_path.exists():
@@ -1566,6 +1565,8 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
     current_hash = _read_schema_hash(remote_path)
     if current_hash != schema.get("schema_hash"):
         _write_driver_files(schema)
+        if _read_schema_hash(remote_path) == current_hash:
+            return
         print(
             f"Driver for '{device_type}' updated "
             f"(was {(current_hash or '?')[:16]}…, "
@@ -1574,6 +1575,19 @@ def ensure_driver(*, token: str = None, device_id: int = None, device_name: str
         )
 
 
+def _schema_device_type(schema: dict) -> str:
+    if str(schema.get("schema_version")) == "2.0":
+        return _require_package_name(schema.get("device_type"), field="device_type")
+    return _schema_maps(schema)[0]
+
+
+def _is_v2_driver(path: Path) -> bool:
+    try:
+        return "build_uhd_bindings" in path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+
+
 def _read_schema_hash(path: Path) -> str | None:
     """Extract _SCHEMA_HASH value from a generated driver file without importing it."""
     try:
@@ -1601,12 +1615,14 @@ def install_driver_if_stale(*, token: str, current_hash: str) -> bool:
 
         from remoteRF.drivers.pluto import *
     """
-    schema = fetch_idl(token=token, prefer_v2=False)
+    schema = fetch_idl(token=token, prefer_v2=True)
     if schema.get("schema_hash") == current_hash:
         return False
 
-    device_type = _schema_maps(schema)[0]
-    _write_driver_files(schema)
+    device_type = _schema_device_type(schema)
+    pkg_dir = _write_driver_files(schema)
+    if _read_schema_hash(pkg_dir / f"{device_type}_remote.py") == current_hash:
+        return False
     print(
         f"Driver for '{device_type}' updated "
         f"(was {current_hash[:16]}…, now {schema.get('schema_hash','?')[:16]}…).\n"

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoteRF/drivers/dynamic_v2.py

@@ -21,7 +21,6 @@ import hashlib
 import json
 import keyword
 import numbers
-import re
 import types
 import weakref
 
@@ -83,24 +82,6 @@ _PARAMETER_KINDS = {
 _PARAMETER_DIRECTIONS = {"in", "out", "inout"}
 
 
-def _canonical_native_version(value) -> str:
-    """Strip distro/build metadata while retaining the pinned upstream API."""
-    text = str(value or "").strip()
-    if text.lower().startswith("uhd "):
-        text = text[4:].strip()
-    match = re.match(
-        r"^(\d+)\.(\d+)\.(\d+)(?:\.(\d+|main|head))?",
-        text,
-        flags=re.IGNORECASE,
-    )
-    if match is None:
-        return text.partition("-")[0].strip()
-    major, minor, patch, build = match.groups()
-    if build is None or build.lower() in {"main", "head"}:
-        build = "0"
-    return ".".join((major, minor, patch, build))
-
-
 def validate_schema_v2(schema: dict) -> dict:
     if not isinstance(schema, dict) or schema.get("schema_version") != "2.0":
         raise RemoteRFProtocolError("Dynamic schema_version must be '2.0'")
@@ -223,9 +204,13 @@ def _matches_type(value, wire_type: str) -> bool:
             return True
         if choice == "bytes" and isinstance(value, (bytes, bytearray, memoryview)):
             return True
-        if choice == "complex" and isinstance(value, (complex, np.complexfloating)):
+        if (
+            choice == "complex"
+            and isinstance(value, (numbers.Complex, np.number))
+            and not isinstance(value, bool)
+        ):
             return True
-        if choice.startswith("list") and isinstance(value, (list, tuple)):
+        if choice.startswith("list") and isinstance(value, (list, tuple, np.ndarray)):
             if "[" not in choice:
                 return True
             item_type = choice.partition("[")[2].rpartition("]")[0]
@@ -295,7 +280,11 @@ class OverloadBinder:
             else:
                 raise TypeError(f"missing required argument {name!r}")
 
-            if supplied and not _matches_type(value, spec.get("type", "any")):
+            if (
+                supplied
+                and not (value is None and not spec.get("required", True))
+                and not _matches_type(value, spec.get("type", "any"))
+            ):
                 raise TypeError(
                     f"argument {name!r} must match {spec.get('type')}, "
                     f"not {type(value).__name__}"
@@ -678,23 +667,21 @@ def build_uhd_bindings(schema: dict, *, transport_factory=DynamicV2Transport):
             self.token = str(token)
             self._transport = transport_factory()
             self._transport.negotiate()
-            opened = self._transport.open_session(self.token, schema["schema_hash"])
-            required_uhd = str(
-                schema.get("native_api", {}).get("version") or ""
-            )
-            actual_uhd = str(opened.get("uhd_version") or "")
-            if (
-                required_uhd
-                and _canonical_native_version(actual_uhd)
-                != _canonical_native_version(required_uhd)
-            ):
-                try:
-                    self._transport.close_session(opened["session_id"])
-                finally:
+            try:
+                opened = self._transport.open_session(self.token, schema["schema_hash"])
+            except RemoteRFProtocolError as exc:
+                if not exc.details.get("current"):
+                    raise
+                from .dynamic_device import install_driver_if_stale
+
+                device_type = schema.get("device_type", "usrp")
+                if install_driver_if_stale(token=self.token, current_hash=schema["schema_hash"]):
                     raise RemoteRFProtocolError(
-                        f"client requires UHD {required_uhd}; "
-                        f"server reports {actual_uhd or 'unknown'}"
-                    )
+                        f"the server's {device_type} driver changed and the local copy "
+                        f"was updated; reimport remoteRF.drivers.{device_type} and retry",
+                        details=dict(exc.details),
+                    ) from exc
+                raise
             self._session_id = opened["session_id"]
             self._handle = opened["device_handle"]
             self._generation = 0

{remoterf-2.0.14 → remoterf-2.0.15/src/remoterf.egg-info}/PKG-INFO

@@ -1,12 +1,10 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.0.14
+Version: 2.0.15
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
-Author: Ethan Ge
-Author-email: ethoGalaxy@gmail.com
-License: GPL-3.0-or-later
+Author-email: Ethan Ge <ethoGalaxy@gmail.com>
+License-Expression: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -16,17 +14,7 @@ Requires-Dist: protobuf<7.0.0,>=6.31.1
 Requires-Dist: numpy
 Requires-Dist: prompt_toolkit
 Requires-Dist: python-dotenv
-Requires-Dist: prompt-toolkit
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Remote RF
 

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoterf.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
-MANIFEST.in
 README.md
-setup.py
+pyproject.toml
 src/remoteRF/__init__.py
 src/remoteRF/remoterf_cli.py
 src/remoteRF/version.py

{remoterf-2.0.14 → remoterf-2.0.15}/src/remoterf.egg-info/requires.txt

@@ -3,4 +3,3 @@ protobuf<7.0.0,>=6.31.1
 numpy
 prompt_toolkit
 python-dotenv
-prompt-toolkit

{remoterf-2.0.14 → remoterf-2.0.15}/tests/test_dynamic_device_codegen.py

@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+import json
 import os
 import unittest
 import sys
@@ -1055,3 +1056,78 @@ class DynamicDeviceCodegenTests(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class DriverInstallPathTests(unittest.TestCase):
+    """The default USRP driver must land on Dynamic v2 and stay there."""
+
+    V2 = {
+        "schema_version": "2.0", "device_type": "usrp", "client_class": "MultiUSRP", "driver_version": "t",
+        "native_api": {}, "hardware_profiles": [], "objects": [], "methods": [], "errors": [],
+        "capability_fields": [], "coverage": {}, "deprecations": [],
+    }
+    V1 = {"schema_version": "1.0", "device_type": "usrp", "client_class": "MultiUSRP", "driver_version": "t",
+          "schema_hash": "sha256:v1", "getters": {}, "setters": {}, "calls": {}}
+
+    @classmethod
+    def setUpClass(cls):
+        import hashlib
+        body = json.dumps(cls.V2, sort_keys=True, separators=(",", ":"))
+        cls.V2 = dict(cls.V2, schema_hash="sha256:" + hashlib.sha256(body.encode()).hexdigest())
+
+    def _run(self, respond, call):
+        seen = []
+
+        class Response:
+            def __init__(self, results):
+                self.results = results
+
+        def rpc_client(function_name, args):
+            plain = {k: unmap_arg(v) for k, v in args.items()}
+            seen.append(plain)
+            return Response({"schema": map_arg(json.dumps(respond(plain)))})
+
+        old_rpc_client = fake_grpc_client.rpc_client
+        old_drivers_dir = dynamic_device._DRIVERS_DIR
+        fake_grpc_client.rpc_client = rpc_client
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                dynamic_device._DRIVERS_DIR = Path(temp_dir)
+                result = call()
+                remote = Path(temp_dir) / "usrp" / "usrp_remote.py"
+                text = remote.read_text() if remote.exists() else ""
+        finally:
+            fake_grpc_client.rpc_client = old_rpc_client
+            dynamic_device._DRIVERS_DIR = old_drivers_dir
+        return seen, text, result
+
+    def test_install_asks_the_legacy_endpoint_for_v2_and_writes_a_v2_driver(self):
+        seen, text, _ = self._run(
+            lambda plain: self.V2 if "2.0" in plain.get("schema_versions", []) else self.V1,
+            lambda: dynamic_device.install_driver(token="future-token", device_id=4),
+        )
+        # device_id first: a not-yet-active reservation's token is inert.
+        self.assertEqual(seen, [{"device_id": 4, "schema_versions": ["2.0"]}])
+        self.assertIn("build_uhd_bindings", text)
+
+    def test_a_v1_answer_never_replaces_an_installed_v2_driver(self):
+        def call():
+            dynamic_device._write_driver_files(self.V2)
+            dynamic_device.install_driver(device_id=4)
+            self.assertFalse(dynamic_device.install_driver_if_stale(token="t", current_hash=self.V2["schema_hash"]))
+
+        seen, text, _ = self._run(lambda plain: self.V1, call)
+        self.assertEqual(len(seen), 2)
+        self.assertIn("build_uhd_bindings", text)
+
+    def test_rewriting_a_driver_drops_the_cached_package_so_reimport_works(self):
+        sys.modules["remoteRF.drivers.usrp"] = types.ModuleType("remoteRF.drivers.usrp")
+        sys.modules["remoteRF.drivers.usrp.usrp_remote"] = types.ModuleType("remoteRF.drivers.usrp.usrp_remote")
+        try:
+            self._run(lambda plain: self.V2,
+                      lambda: dynamic_device.install_driver_if_stale(token="t", current_hash="sha256:v1"))
+            self.assertNotIn("remoteRF.drivers.usrp", sys.modules)
+            self.assertNotIn("remoteRF.drivers.usrp.usrp_remote", sys.modules)
+        finally:
+            sys.modules.pop("remoteRF.drivers.usrp", None)
+            sys.modules.pop("remoteRF.drivers.usrp.usrp_remote", None)

{remoterf-2.0.14 → remoterf-2.0.15}/tests/test_dynamic_v2.py

@@ -509,20 +509,68 @@ class DynamicV2Tests(unittest.TestCase):
         self.assertEqual(encoded.WhichOneof("value"), "json_value")
         self.assertEqual(decode_value(encoded), all_indexes)
 
-    def test_client_rejects_a_different_upstream_uhd_version(self):
-        class MismatchedTransport(FakeTransport):
+    def test_client_accepts_an_older_upstream_uhd_version(self):
+        class OlderTransport(FakeTransport):
             def open_session(self, token, schema_hash):
                 result = super().open_session(token, schema_hash)
-                result["uhd_version"] = "4.10.0.1-0ubuntu1"
+                result["uhd_version"] = "3.15.0.0"
                 return result
 
-        transport = MismatchedTransport()
+        transport = OlderTransport()
         _, MultiUSRP = build_uhd_bindings(
             schema(), transport_factory=lambda: transport
         )
-        with self.assertRaisesRegex(Exception, "requires UHD 4.10.0.0"):
-            MultiUSRP("token")
-        self.assertEqual(transport.closed_sessions, ["session"])
+        device = MultiUSRP("token")
+        self.assertEqual(transport.closed_sessions, [])
+        self.assertTrue(device.close())
+
+    def test_binder_is_no_stricter_than_native_uhd(self):
+        dc_offset = descriptor(
+            "uhd.usrp.MultiUSRP",
+            "set_rx_dc_offset",
+            [
+                overload("offset", [param("offset", "complex"), param("chan", "int", required=False, default=0)]),
+                overload("enable", [param("enb", "bool"), param("chan", "int", required=False, default=0)]),
+            ],
+        )
+        overload_id, bound = OverloadBinder(dc_offset).bind((0,), {})
+        self.assertEqual((overload_id, bound), ("offset", {"offset": 0, "chan": 0}))
+        overload_id, _ = OverloadBinder(dc_offset).bind((False,), {})
+        self.assertEqual(overload_id, "enable")
+        with self.assertRaisesRegex(TypeError, "incompatible arguments"):
+            OverloadBinder(dc_offset).bind(("0",), {})
+
+        optional = descriptor(
+            "uhd.usrp.MultiUSRP",
+            "get_rx_freq",
+            [overload("default", [param("chan", "int", required=False, default=0)], "float")],
+        )
+        _, bound = OverloadBinder(optional).bind((), {"chan": None})
+        self.assertEqual(bound, {"chan": None})
+
+        phases = descriptor(
+            "uhd.usrp.MultiUSRP",
+            "phaser_set_phases",
+            [overload("default", [param("phases_deg", "list[float]")], "list[float]")],
+        )
+        OverloadBinder(phases).bind((np.linspace(0, 315, 8),), {})   # numpy arrays are sequences
+        self.assertEqual(decode_value(encode_value(np.complex64(1 + 2j))), 1 + 2j)
+
+    def test_a_stale_v2_driver_refreshes_itself_and_says_so(self):
+        from unittest.mock import patch
+
+        class StaleTransport(FakeTransport):
+            def open_session(self, token, schema_hash):
+                raise RemoteRFProtocolError(
+                    "client schema hash is stale",
+                    details={"requested": schema_hash, "current": "sha256:newer"},
+                )
+
+        _, MultiUSRP = build_uhd_bindings(schema(), transport_factory=StaleTransport)
+        with patch("remoteRF.drivers.dynamic_device.install_driver_if_stale", return_value=True) as refresh:
+            with self.assertRaisesRegex(RemoteRFProtocolError, "reimport remoteRF.drivers.usrp"):
+                MultiUSRP("token")
+        refresh.assert_called_once_with(token="token", current_hash=schema()["schema_hash"])
 
     def test_client_accepts_conda_forge_uhd_main_release_version(self):
         class CondaForgeTransport(FakeTransport):

remoterf-2.0.14/MANIFEST.in

@@ -1,3 +0,0 @@
-# Include all .crt, .key, and .pem files
-recursive-include src/remoteRF *.crt *.key *.pem
-recursive-include src/remoteRF *.txt

remoterf-2.0.14/setup.py

@@ -1,60 +0,0 @@
-# Copyright (C) 2026 RemoteRF
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-from setuptools import setup, find_packages
-import os
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="remoterf",
-    version="2.0.14",
-    author="Ethan Ge",
-    author_email="ethoGalaxy@gmail.com",
-    description="A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.",
-    long_description=long_description,  # Set the README content here
-    long_description_content_type="text/markdown",  # Specify that it's Markdown
-    packages=find_packages(where="src"),  # Automatically finds subpackages like core, deviceA, deviceB
-    package_dir={"": "src"},
-    license='GPL-3.0-or-later',
-    include_package_data=True,  # Includes files specified in MANIFEST.in
-    install_requires=[
-        "grpcio>=1.78.1,<2.0.0", "protobuf>=6.31.1,<7.0.0", "numpy", "prompt_toolkit", "python-dotenv", "prompt-toolkit"
-    ],
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
-        "Operating System :: OS Independent",
-    ],
-    python_requires='>=3.10',
-    # entry_points={
-    #     'console_scripts': [
-    #         'remoterf-login=remoteRF.core.acc_login:main',
-    #         'remoterf-v=remoteRF.core.version:main',
-    #         'remoterf-config=remoteRF.config.config_cli:main',
-    #     ],
-    # },
-    
-    entry_points={
-    "console_scripts": [
-        "remoterf=remoteRF.remoterf_cli:main",
-        # "remoterf-login=remoteRF.core.acc_login:main",
-        # "remoterf-v=remoteRF.core.version:main",
-        # "remoterf-config=remoteRF.config.config_cli:main",
-    ],
-},
-
-)