remoterf 0.0.7.27__py3-none-any.whl

remoteRF/core/grpc_acc.py

@@ -0,0 +1,52 @@
+from .grpc_client import rpc_client
+from ..common.utils import *
+
+import datetime
+
+class RemoteRFAccount:
+    def __init__(self, username:str=None, password:str=None, email:str=None):
+        self.username = username
+        self.password = password
+        self.email = email
+    
+    def create_user(self):
+        response = rpc_client(function_name="ACC:create_user", args={"un":map_arg(self.username), "pw":map_arg(self.password), "em":map_arg(self.email)})
+        if 'UC' in response.results:
+            print(f'User {unmap_arg(response.results["UC"])} successfully created.')
+            return True
+        elif 'UE' in response.results:
+            print(f'Error: {unmap_arg(response.results["UE"])}')
+            return False
+    
+    def login_user(self):
+        username = self.username
+        password = self.password
+        response = rpc_client(function_name="ACC:login", args={"un":map_arg(username), "pw":map_arg(password)})
+        if 'UC' in response.results:
+            print(f'User {unmap_arg(response.results["UC"])} successful login.')
+            return True
+        elif 'UE' in response.results:
+            print(f'Error: {unmap_arg(response.results["UE"])}')
+            return False
+    
+    def reserve_device(self, device_id:int, start_time:datetime, end_time:datetime):
+        response = rpc_client(function_name="ACC:reserve_device", args={"un":map_arg(self.username), "pw":map_arg(self.password), "dd":map_arg(device_id), "st":map_arg(int(start_time.timestamp())), "et":map_arg(int(end_time.timestamp()))})
+        
+        if 'ace' in response.results:
+            raise Exception(f'{unmap_arg(response.results["ace"])}')
+        elif 'Token' in response.results:
+            return unmap_arg(response.results["Token"])
+            
+    def get_reservations(self):
+        return rpc_client(function_name='ACC:get_res', args={"un":map_arg(self.username), "pw":map_arg(self.password)})
+    
+    def get_devices(self):
+        return rpc_client(function_name='ACC:get_dev', args={"un":map_arg(self.username), "pw":map_arg(self.password)})
+    
+    def cancel_reservation(self, res_id:int):
+        return rpc_client(function_name='ACC:cancel_res', args={"un":map_arg(self.username), "pw":map_arg(self.password), "res_id":map_arg(res_id)})
+    
+    def get_perms(self):
+        return rpc_client(function_name='ACC:get_perms', args={"un":map_arg(self.username), "pw":map_arg(self.password)})
+    
+    

remoteRF/core/grpc_client.py

@@ -0,0 +1,97 @@
+import socket
+import getpass
+from pathlib import Path
+
+import grpc
+from ..common.grpc import grpc_pb2
+from ..common.grpc import grpc_pb2_grpc
+from ..common.utils import *
+
+# wlab credentials
+server_ip = '164.67.195.207'
+server_port = '61005'
+
+options = [
+      ('grpc.max_send_message_length', 100 * 1024 * 1024),
+      ('grpc.max_receive_message_length', 100 * 1024 * 1024),
+]
+
+# Server.crt
+certs_path = Path(__file__).resolve().parent.parent/'core'/'certs'/'server.crt'
+with certs_path.open('rb') as f:
+    trusted_certs = f.read()
+    
+credentials = grpc.ssl_channel_credentials(root_certificates=trusted_certs)
+channel = grpc.secure_channel(f'{server_ip}:{server_port}', credentials, options=options)
+stub = grpc_pb2_grpc.GenericRPCStub(channel)
+
+tcp_calls = 0
+
+def get_tcp_calls():
+    return tcp_calls
+        
+def rpc_client(*, function_name, args):
+    global tcp_calls
+    tcp_calls += 1
+    # print(tcp_calls)
+    # if not is_connected:
+    #     response = rpc_client(function_name="UserLogin", args={"username": grpc_pb2.Argument(string_value=input("Username: ")), "password": grpc_pb2.Argument(string_value=getpass.getpass("Password: ")), "client_ip": grpc_pb2.Argument(string_value=local_ip)})
+    #     if (response.results['status'].string_value == 'Success'):
+    #         print("Login successful.")
+    #         is_connected = True
+    
+    # TODO: Handle user login
+    
+    # print(f"Opening connection to {server_ip}:{server_port}")
+    
+    # TODO: Handle Errors
+    
+    # print(f"Calling function: {function_name}")
+    response = stub.Call(grpc_pb2.GenericRPCRequest(function_name=function_name, args=args))
+    
+    if 'a' in response.results:
+        print(f"Error: {unmap_arg(response.results['a'])}")
+        exit()
+        
+    if 'UE' in response.results:
+        print(f"UserError: {unmap_arg(response.results['UE'])}")
+        input("Hit enter to continue...")
+            
+    
+    return response
+
+#region Example Usage
+
+# if __name__ == '__main__':
+#     args={
+#         "key1": grpc_pb2.Argument(string_value="Hello"),
+#         "key2": grpc_pb2.Argument(int32_value=123),
+#         "key3": grpc_pb2.Argument(float_value=4.56),
+#         "key4": grpc_pb2.Argument(bool_value=True),
+#         "client_ip": grpc_pb2.Argument(string_value=local_ip)
+#     }
+    
+#     response = rpc_client(function_name="echo", args=args)
+    
+#     if 'client_ip' in response.results:
+#         del response.results['client_ip']
+    
+#     # Print results
+#     print("Received response:")
+#     for key, arg in response.results.items():
+#         # Decode the oneof fields
+#         if arg.HasField('string_value'):
+#             value = arg.string_value
+#         elif arg.HasField('int32_value'):
+#             value = arg.int32_value
+#         elif arg.HasField('float_value'):
+#             value = arg.float_value
+#         elif arg.HasField('bool_value'):
+#             value = arg.bool_value
+#         else:
+#             value = "Undefined"
+            
+#         print(f"{key}: {value}")
+
+#endregion
+    

remoteRF/drivers/adalm_pluto/__init__.py

@@ -0,0 +1 @@
+from . import pluto_remote as adi

remoteRF/drivers/adalm_pluto/pluto_remote.py

@@ -0,0 +1,250 @@
+from ...core.grpc_client import rpc_client
+from ...common.utils import *
+from ...common.grpc import grpc_pb2
+from ...core.grpc_client import get_tcp_calls
+
+def try_get(function_name, token):
+    try:
+        return unmap_arg(rpc_client(function_name=f"Pluto:{function_name}:GET", args={'a':map_arg(token)}).results[function_name])
+    except Exception as e:
+        input(f"Error: {e}\nHit enter to continue...")
+    return None
+
+def try_set(function_name, value, token):
+    try:
+        rpc_client(function_name=f"Pluto:{function_name}:SET", args={function_name: map_arg(value), 'a':map_arg(token)})
+    except Exception as e:
+        input(f"Error: {e}\nHit enter to continue...")
+        
+def try_call_0_arg(function_name, token):   # 0 argument call
+    try:
+        response = rpc_client(
+            function_name=f"Pluto:{function_name}:CALL0", 
+            args={
+                'a': map_arg(token)
+            }
+        )
+        return unmap_arg(response.results[function_name])
+    except Exception as e:
+        input(f"RPC_0_call Error: {e}\nHit enter to continue...")
+    return None
+        
+def try_call_1_arg(function_name, arg, token):  # 1 argument call
+    try:
+        response = rpc_client(
+            function_name=f"Pluto:{function_name}:CALL1", 
+            args={
+                'a': map_arg(token),
+                'arg1': map_arg(arg)
+            }
+        )
+        # The server should return something like {function_name: <something>}
+        return unmap_arg(response.results[function_name])
+    except Exception as e:
+        input(f"RPC_1_call Error: {e}\nHit enter to continue...")
+    return None
+
+class rx_def:
+    pass
+
+class tx_def:
+    pass
+
+class rx_tx_def(rx_def, tx_def):
+    pass
+
+class ad9364(rx_tx_def):
+    pass
+
+class Pluto: # client
+    
+    def __init__(self, token='', debug=False):
+        self.token = token
+        try_set(function_name="ip", value=token)
+        
+        if debug:
+            print("Pluto Remote Client Initialized.")
+        
+    def api_token(self, token:str) -> None:
+        self.token = token
+    
+    # PlutoSDR
+    
+    _device_name = "PlutoSDR"
+    _uri_auto = "ip:pluto.local"
+
+    def __repr__(self): # ! UNTESTED !
+        return try_get("__repr__", self.token)
+    
+    #region ad9364
+    """AD9364 Transceiver"""
+
+    @property
+    def filter(self):
+        return try_get("filter", self.token)
+
+    @filter.setter
+    def filter(self, value):
+        try_set("filter", value, self.token)
+
+    @property
+    def loopback(self):
+        """loopback: Set loopback mode. Options are:
+        0 (Disable), 1 (Digital), 2 (RF)"""
+        return try_get("loopback", self.token)
+
+    @loopback.setter
+    def loopback(self, value):
+        try_set("loopback", value, self.token)
+
+    @property
+    def gain_control_mode_chan0(self):
+        """gain_control_mode_chan0: Mode of receive path AGC. Options are:
+        slow_attack, fast_attack, manual"""
+        return try_get("gain_control_mode_chan0", self.token)
+
+    @gain_control_mode_chan0.setter
+    def gain_control_mode_chan0(self, value):
+        try_set("gain_control_mode_chan0", value, self.token)
+
+    @property
+    def rx_hardwaregain_chan0(self):
+        """rx_hardwaregain_chan0: Gain applied to RX path. Only applicable when
+        gain_control_mode is set to 'manual'"""
+        return try_get("rx_hardwaregain_chan0", self.token)
+
+    @rx_hardwaregain_chan0.setter
+    def rx_hardwaregain_chan0(self, value):
+        try_set("rx_hardwaregain_chan0", value, self.token)
+
+    @property
+    def tx_hardwaregain_chan0(self):
+        """tx_hardwaregain_chan0: Attenuation applied to TX path"""
+        return try_get("tx_hardwaregain_chan0", self.token)
+
+    @tx_hardwaregain_chan0.setter
+    def tx_hardwaregain_chan0(self, value):
+        try_set("tx_hardwaregain_chan0", value, self.token)
+
+    @property
+    def rx_rf_bandwidth(self):
+        """rx_rf_bandwidth: Bandwidth of front-end analog filter of RX path"""
+        return try_get("rx_rf_bandwidth", self.token)
+
+    @rx_rf_bandwidth.setter
+    def rx_rf_bandwidth(self, value):
+        try_set("rx_rf_bandwidth", value, self.token)
+
+    @property
+    def tx_rf_bandwidth(self):
+        """tx_rf_bandwidth: Bandwidth of front-end analog filter of TX path"""
+        return try_get("tx_rf_bandwidth", self.token)
+
+    @tx_rf_bandwidth.setter
+    def tx_rf_bandwidth(self, value):
+        try_set("tx_rf_bandwidth", value, self.token)
+
+    @property
+    def sample_rate(self):                # ! UNTESTED !
+        """sample_rate: Sample rate RX and TX paths in samples per second"""
+        return try_get("sample_rate", self.token)
+
+    @sample_rate.setter
+    def sample_rate(self, rate):          # ! UNTESTED !
+        try_set("sample_rate", rate, self.token)
+
+    @property
+    def rx_lo(self):
+        """rx_lo: Carrier frequency of RX path"""
+        return try_get("rx_lo", self.token)
+
+    @rx_lo.setter
+    def rx_lo(self, value):
+        try_set("rx_lo", value, self.token)
+
+    @property
+    def tx_lo(self):
+        """tx_lo: Carrier frequency of TX path"""
+        return try_get("tx_lo", self.token)
+
+    @tx_lo.setter
+    def tx_lo(self, value):
+        try_set("tx_lo", value, self.token)
+        
+    @property
+    def tx_cyclic_buffer(self):
+        """tx_cyclic_buffer: Size of cyclic buffer"""
+        return try_get("tx_cyclic_buffer", self.token)
+    
+    @tx_cyclic_buffer.setter
+    def tx_cyclic_buffer(self, value):
+        try_set("tx_cyclic_buffer", value, self.token)
+        
+    def tx_destroy_buffer(self):
+        try_call_0_arg("tx_destroy_buffer", self.token)
+
+    def rx_destroy_buffer(self):
+        try_call_0_arg("rx_destroy_buffer", self.token)
+
+    #endregion
+    
+    #region rx_def
+    
+    def rx(self):
+        return try_get("rx", self.token)
+    
+    @property
+    def rx_buffer_size(self):
+        return try_get("rx_buffer_size", self.token)
+    
+    @rx_buffer_size.setter
+    def rx_buffer_size(self, value):
+        try_set("rx_buffer_size", value, self.token)
+    
+    #endregion
+    
+    #region tx_def
+    
+    def tx(self, value):
+        return try_call_1_arg("tx", value, self.token)
+    
+    # @tx.setter
+    # def tx(self, value):
+    #     try_set("tx", value, self.token)
+    
+    #endregion
+    
+    #region tx
+    
+    #endregion
+    
+    #region _dec_int_fpga_filter
+    
+    """Decimator and interpolator fpga filter controls"""
+
+    def _get_rates(self, dev, output):           # ! UNTESTED !
+        """Get the decimation and interpolation rates"""
+        return try_get("rates", self.token)
+
+    @property
+    def rx_dec8_filter_en(self) -> bool:         # ! UNTESTED !
+        """rx_dec8_filter_en: Enable decimate by 8 filter in FPGA"""
+        return try_get("rx_dec8_filter_en", self.token)
+
+    @rx_dec8_filter_en.setter
+    def rx_dec8_filter_en(self, value: bool):    # ! UNTESTED !
+        """rx_dec8_filter_en: Enable decimate by 8 filter in FPGA"""
+        return try_set("rx_dec8_filter_en", value, self.token)
+
+    @property
+    def tx_int8_filter_en(self) -> bool:         # ! UNTESTED !
+        """tx_int8_filter_en: Enable interpolate by 8 filter in FPGA"""
+        return try_get("tx_int8_filter_en", self.token)
+
+    @tx_int8_filter_en.setter
+    def tx_int8_filter_en(self, value: bool):    # ! UNTESTED !
+        """tx_int8_filter_en: Enable interpolate by 8 filter in FPGA"""
+        return try_set("tx_int8_filter_en", value, self.token)
+    
+    #endregion
+ 

remoterf-0.0.7.27.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: remoterf
+Version: 0.0.7.27
+Summary: A python API to remotely access signal centric hardware. Client-side only!
+Author: Ethan Ge
+Author-email: ethoGalaxy@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: grpcio==1.71.0
+Requires-Dist: protobuf
+Requires-Dist: numpy
+Requires-Dist: prompt-toolkit
+Requires-Dist: python-dotenv
+
+# Remote RF
+
+A python API to remotely access signal centric hardware. 
+
+Courtesy of Wireless Lab @ UCLA. - Ethan Ge
+
+## Prerequisites
+
+- **Python 3.10**: This package works in Python 3.10+. If you don’t have Python installed, you can download it from the [official Python website](https://www.python.org/downloads/).
+
+To check your current Python version, open a terminal and run:
+
+```bash
+python --version
+```
+
+- **UCLA VPN**: Please ensure that you are connected to the UCLA VPN. You can download and configure the VPN client from the following link: [UCLA VPN Client Download](https://www.it.ucla.edu/it-support-center/services/virtual-private-network-vpn-clients). If you’re not connected to the VPN, you will not have access to the lab servers.
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install remoteRF. It is recommended that you install this package within a [virtual environment](https://docs.python.org/3/library/venv.html).
+
+```bash
+python3 -m venv venv        # Create virtual environment
+source venv/bin/activate    # Activate virtual environment
+
+pip install remoteRF        # Install remoteRF
+```
+
+If `pip install` doesn't work, you can clone the [source](https://github.com/WirelessLabAtUCLA/RemoteRF-Client) directly from github.
+
+<!-- 1. **Clone the repository:**
+```bash
+git clone https://github.com/WirelessLabAtUCLA/RemoteRF-Client
+cd repository-name
+```
+2. **Install the package using** `pip` **in editable mode:**
+```bash
+pip install -e .
+```
+This command installs the package in "editable" mode, allowing for modifications to the local code without reinstalling. For more details on installing packages from local directories, refer to Python Packaging: [Installing from Local Archives](https://packaging.python.org/en/latest/tutorials/installing-packages/#installing-packages-from-local-archives). -->
+
+## Reservation
+
+Usage of the platform requires you to register a account and reserve a device in order to run scripts remotely. 
+
+### 1. **Start UCLA VPN**
+
+- Start the CISCO Secure client, login and connect to any of the options.
+
+### 2. **Register a account**:
+```bash
+remoterf-login  
+# Run in the terminal 
+# where the Python library is installed
+
+# Typically, this will be the terminal where you’ve activated the virtual environment if you’re using one
+```
+
+- Input `r` to register a account, or `l` to login to a existing one.
+
+<!-- 2. **You will be prompted with this**: -->
+```bash
+Welcome to Remote RF Account System.
+Please login or register to continue. (l/r):
+```
+
+- Once in, input `help` to see all avaliable commands.
+
+### 3. **Reserve Device**:
+```bash
+getdev  # To view all avaliable devices
+
+# Note the device ID. You will need this later to reserve said device
+```
+
+```bash
+getres  # To view times not avaliable
+
+# Optionally, you can also view all reservations, and determine a time slot you want a specific device reserved
+```
+```bash
+perms   # To view your permissions
+
+# Depending on your permission levels, you will be given different restrictions 
+```
+
+```bash
+resdev # To reserve a device
+
+# Input the number of days you want to view, and it will display available reservations in that time span.
+
+Reservation successful. Thy Token -> example_token
+
+# Take note of this token. You will need it to actually access the device.
+```
+
+## Remote Access
+
+With this token, you can now run scripts remotely. Please keep in mind that you MUST be connected to the UCLA VPN for this to work.
+Here is a explained sample script to get you going!
+
+#### Python Script:
+
+```python
+from remoteRF.drivers.adalm_pluto import *  # Imports device Pluto SDR remote drivers. Change depending on desired device.
+
+sdr = adi.Pluto(    # Device initialization.
+    token = 'example_token'     # Place the prior token here.
+)
+
+# You can now use this 'sdr' as you normally would with the default Pluto drivers.
+```
+
+If converting a existing `non-remoteRF` compatible script:
+
+```diff
+- import existing_device_drivers 
+
++ from remoteRF.drivers.device_drivers import *
+
+- device = device(init)
+
++ device = device(token = 'sample_token')
+```
+
+Nothing else needs changing! 
+
+## Closing
+
+This is fundamentally a experimental platform, and there will be many unknown bugs and issues. Some devices do not have universal support for all its functions at the moment, I am working on that aspect. 
+
+**So please submit feedback!**

remoterf-0.0.7.27.dist-info/RECORD

@@ -0,0 +1,30 @@
+remoteRF/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+remoteRF/common/__init__.py,sha256=8naT0ZphJxv_6uz7RRGvqfNB-UEznkzipJSVPD5n6iM,40
+remoteRF/common/grpc/__init__.py,sha256=GYLHC7riDbjdx2cNOhWymt0GLZ4mtGhuzZAXVRfNynw,37
+remoteRF/common/grpc/grpc_pb2.py,sha256=iMdLw3xly_2WjirEmVaxf7I8iiUmk-3YRqqIiRdNkPs,4082
+remoteRF/common/grpc/grpc_pb2_grpc.py,sha256=NofKaB3t0nAm_uxDgA5WXhWcsRWqsyfuMEEdBrosVKk,3368
+remoteRF/common/utils/__init__.py,sha256=JTP8gH-340HZI4F8oagPW-kxRCoVUnQB-_acmgXPaK4,204
+remoteRF/common/utils/ansi_codes.py,sha256=knGLOJK-lyDjfQHL0Upq5UPTg6J_6WYldga-ZOaerSs,3052
+remoteRF/common/utils/api_token.py,sha256=CdgnAIcKqhkJB_XqrshgJVZzfQIO-xeR8hVMi5bYPSI,1260
+remoteRF/common/utils/list_string.py,sha256=qsch666vX2e3CZ2W5EdYi62dOk37k1v2yPpHHm47a7A,156
+remoteRF/common/utils/process_arg.py,sha256=J1REqgjm-1daqTBdVASgDd-16y-KneOJpCZXPEOklVk,2971
+remoteRF/core/__init__.py,sha256=XQiCe8kyzM7XLxA883-uDndBmbr-NXo1uvtMJT2h6oA,73
+remoteRF/core/acc_login.py,sha256=UcY3rDLAwHoJ9lYXRfm26z_6yJX0JSoKv-u1mF6n0Gs,49
+remoteRF/core/app.py,sha256=WLVEReY7QgEuRUq2LS5H_X9yp4hoQnMoY-DW7BBNR6I,21215
+remoteRF/core/grpc_acc.py,sha256=bspLTzblhqYVVEFPwdvXrDZjREBWJVvD_SaT_cja6kU,2441
+remoteRF/core/grpc_client.py,sha256=UMWAV7o_UX2MdcSSgCqC3hXwMmicWU-M7NO3RCTXYIo,3037
+remoteRF/core/certs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+remoteRF/core/certs/ca.crt,sha256=Rp8V8Mi413an0rO_dy7sH32j77ppVP1POZ-g7_eVtDU,2004
+remoteRF/core/certs/ca.key,sha256=h5UQDlCcf7munMLTROYk6TGt9Guf0ar9aHoRPlsR2sk,3272
+remoteRF/core/certs/cert.pem,sha256=d90GwpyubEcyp1WUcyMCpn93HI8RUY96sMg5ynHrIMM,1127
+remoteRF/core/certs/key.pem,sha256=cWJ4BYX47boqXBcPmN5r_9KqYS4gLyGXnHGPMwwrNMo,1704
+remoteRF/core/certs/server.crt,sha256=lV7KfCMA2Yz0ysDT5GcoNawDAg9uvtS33eZvycWOR10,1151
+remoteRF/core/certs/server.key,sha256=F4hVXkENhugrpnHEYNesdvXJByvJ-_9Fxbiqf0Akn-U,1704
+remoteRF/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+remoteRF/drivers/adalm_pluto/__init__.py,sha256=_IOOeQXR6paCP7Eciw2aeKBUNvZs-jeBTwW8QqUlFyU,33
+remoteRF/drivers/adalm_pluto/pluto_remote.py,sha256=nXzc-V57ZGOwxK54t3w4d1aOpH1onSlhEkD1sxYPgC4,7457
+remoterf-0.0.7.27.dist-info/METADATA,sha256=tLvMUjBS3wRmrJYrPdII9TumygbMlOppcF1fTQVmwJ0,4928
+remoterf-0.0.7.27.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+remoterf-0.0.7.27.dist-info/entry_points.txt,sha256=TweiWBwjbPs3G5Xgx3kF7LqP3r-0Iy1BstMoX0mVnTM,64
+remoterf-0.0.7.27.dist-info/top_level.txt,sha256=XQJoVTmAOsHV9qtPSP_QSh0ma4jKxsDkxn4IjM_ZuZk,9
+remoterf-0.0.7.27.dist-info/RECORD,,

remoterf-0.0.7.27.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.2.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

remoterf-0.0.7.27.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+remoterf-login = remoteRF.core.acc_login:main

remoterf-0.0.7.27.dist-info/top_level.txt

@@ -0,0 +1 @@
+remoteRF