autoverse-cli 0.28.1__py3-none-any.whl

avrs/can_tool_util.py

@@ -0,0 +1,190 @@
+import can
+import cantools
+import time
+import os
+import datetime
+import threading
+import queue
+import json
+import math
+import statistics
+
+def get_eav24_hl0(throttle, gear, brake):
+    return {
+        "HL_TargetThrottle": throttle,
+        "HL_TargetGear": gear,
+        "HL_TargetPressure_RR": brake,
+        "HL_TargetPressure_RL": brake,
+        "HL_TargetPressure_FR": brake,
+        "HL_TargetPressure_FL": brake,
+        "HL_Alive_01": 0
+    }
+
+def get_eav24_hl2(steer):
+    return {
+        "HL_Alive_02": 0, 
+        "HL_PSA_Profile_Vel_rad_s": 0,
+        "HL_PSA_Profile_Dec_rad_s2": 0,
+        "HL_PSA_Profile_Acc_rad_s2": 0,
+        "HL_TargetPSAControl": steer,
+        "HL_PSA_ModeOfOperation": 0
+    }
+
+def get_eav24_msigs(dbc, throttle, gear, brake, steer):
+    return {
+        dbc.get_message_by_name('HL_Msg_01'): get_eav24_hl0(throttle, gear, brake),
+        dbc.get_message_by_name('HL_Msg_02'): get_eav24_hl2(steer)
+    }
+
+def send_eav24_can_values(can_name, dbc, throttle, gear, brake, steer, duration, rate = 100):
+    with can.interface.Bus(can_name, bustype='socketcan') as bus:
+        message_1 = dbc.get_message_by_name('HL_Msg_01')
+        message_2 = dbc.get_message_by_name('HL_Msg_02')
+        print('sending EAV24 CAN inputs on {} with throttle {}, gear {}, brake {}, steer {}, for {} seconds'.format(can_name, throttle, gear, brake, steer, duration))
+        signals_1 = get_eav24_hl0(throttle, gear, brake)
+        signals_2 = get_eav24_hl2(steer)
+
+        msigs = get_eav24_msigs(dbc, throttle, gear, brake, steer)
+        send_eav24_can_signals(bus, msigs, rate, duration)
+
+def send_eav24_can_signals(bus, message_signals, rate, duration):
+    start_time = time.time()
+    while time.time() - start_time < duration:
+        for msg, sig in message_signals.items():
+            bus.send(can.Message(arbitration_id=msg.frame_id, data=msg.encode(sig), is_extended_id=False))
+        time.sleep(1.0 / rate)
+
+def test_eav24_can_latency(can_name, dbc, nsamples, send_rate, duration, save_report_as):
+    with can.interface.Bus(can_name, bustype='socketcan') as bus:
+        delays = []
+        times = []
+
+        for i in range(nsamples):
+            print('test {}'.format(i))
+            start_time = time.time()
+            last_throttle_time = time.time()
+            last_throttle_value = 50;
+
+            msigs = get_eav24_msigs(dbc, last_throttle_value, 1, 0, 0)
+            
+            send_thread = threading.Thread(target=send_eav24_can_signals, args=(bus, msigs, send_rate, duration))
+            send_thread.start()
+            
+            is_back_to_zero = False
+            while not is_back_to_zero:
+                message = bus.recv()
+                if message is not None:
+                    decoded = decode_can_message(dbc, message)
+                    if decoded and decoded['name'] == 'ICE_Status_01':
+                        ack_value = decoded['data']['ICE_TargetThrottle_ACK']
+                        if math.isclose(ack_value, last_throttle_value):
+                            t = time.time()
+                            #print('got throttle ack matching command at t{}'.format(t - last_throttle_time))
+                            delay = t - last_throttle_time
+                            delays.append(delay)
+                            times.append(t)
+                            print('got throttle ack for command {} after {} seconds'.format(last_throttle_value, delay))
+                            if last_throttle_value == 0:
+                                is_back_to_zero = True
+                                send_thread.join()
+                            else:
+                                last_throttle_value = 0
+                                msigs = get_eav24_msigs(dbc, last_throttle_value, 1, 0, 0)
+                                send_thread.join()
+                                send_thread = threading.Thread(target=send_eav24_can_signals, args=(bus, msigs, send_rate, duration))
+                                send_thread.start()
+                            last_throttle_time = time.time()
+
+        # Plot results
+        avg_delay = statistics.mean(delays)
+        print('avg delay {}, min delay {}, max dealy {}'.format(avg_delay, min(delays), max(delays)))
+
+        if save_report_as != '':
+            print('saving report to {}'.format(save_report_as))
+            report = {
+                'average_delay': avg_delay,
+                'min_delay': min(delays),
+                'max_delay': max(delays),
+                'num_samples': nsamples
+            }
+            with open(save_report_as, 'w', encoding='utf-8') as f:
+                json.dump(report, f, ensure_ascii=False, indent=4)
+
+
+def echo_can(can_names, dbcs, duration, isolate, do_rates, save_report_as):
+    start_time = time.time()
+    report = {}
+    rates = {}
+    print_interval = 1.0
+    last_print = start_time
+
+    jobs = []
+    print_lock = threading.Lock()
+    for n in can_names:
+        echo_thread = threading.Thread(target=echo_can_job, args=(n, dbcs, duration, isolate, do_rates, rates, print_lock))
+        echo_thread.start()
+        jobs.append(echo_thread)
+
+    while time.time() - start_time < duration:
+        t = time.time()
+        if do_rates and t - last_print > print_interval:
+            last_print = t
+            for r in rates:
+                print('{} rate: {}hz ({} samples)'.format(r, 1.0 / rates[r]['rate'], rates[r]['ct']))
+            print('=' * 15)
+
+    for j in jobs:
+        j.join()
+    
+    if do_rates and save_report_as != '':
+        print('saving report to {}'.format(save_report_as))
+        with open(save_report_as, 'w', encoding='utf-8') as f:
+            json.dump(rates, f, ensure_ascii=False, indent=4)
+
+def echo_can_job(can_name, dbcs, duration, isolate, do_rates, out_rate_data, print_lock):
+    start_time = time.time()
+    with can.interface.Bus(can_name, bustype='socketcan') as bus:
+        while time.time() - start_time < duration:
+            message = bus.recv()
+            if message is not None:
+                for db in dbcs:
+                    decoded = decode_can_message(db, message)
+                    if decoded is not None and (len(isolate) == 0 or decoded['name'] in isolate):
+                        update_can_rate_stats(decoded, out_rate_data, start_time)
+                        if not do_rates and print_lock.acquire(True):
+                            print(decoded)
+                            print_lock.release()
+
+def decode_can_message(dbc, message):
+    try:
+        decoded_message = dbc.decode_message(message.arbitration_id, message.data)
+        message_name = dbc.get_message_by_frame_id(message.arbitration_id).name
+        timestamp = datetime.datetime.now().isoformat()
+        return {'timestamp': timestamp, 'name': message_name, 'data': decoded_message}
+    except KeyError:
+        return None
+    
+def update_can_rate_stats(message, rates, start_time):
+    if not message['name'] in rates:
+        rates[message['name']] = {
+            'prev_t': start_time,
+            'rate': time.time() - start_time,
+            'ct': 0,
+            'min': 100000000,
+            'max': 0.0000001
+        }
+    r = rates[message['name']]['rate']
+    t = rates[message['name']]['prev_t']
+    ct = rates[message['name']]['ct'] + 1
+    dt = time.time() - t
+    rate_diff = dt - r
+    rates[message['name']]['rate'] = r + (1.0 / ct) * rate_diff
+    rates[message['name']]['ct'] = ct
+    rates[message['name']]['prev_t'] = time.time()
+
+    this_rate = 1.0 / dt
+    if this_rate > rates[message['name']]['max']:
+        rates[message['name']]['max'] = this_rate
+    elif this_rate < rates[message['name']]['min']:
+        rates[message['name']]['min'] = this_rate
+

avrs/cfg.py

@@ -0,0 +1,78 @@
+import json
+import os
+import shutil
+
+def get_cfg_dir(cli_name):
+    return os.path.join(os.environ['HOME'], '.config', cli_name)
+
+def get_cfg_file(cli_name):
+    return os.path.join(get_cfg_dir(cli_name), 'config.json')
+
+def load_cfg(cli_name):
+    cfg_dir = get_cfg_dir(cli_name)
+    if not os.path.exists(cfg_dir):
+        os.makedirs(cfg_dir)
+
+    cfg_path = get_cfg_file(cli_name)
+    cfg = {}
+
+    if os.path.exists(cfg_path):
+        with open(cfg_path, 'r', encoding='utf-8') as f:
+            cfg = json.load(f)
+    return cfg
+
+def save_cfg(cli_name, cfg):
+    cfg_path = get_cfg_file(cli_name)
+    with open(cfg_path, 'w', encoding='utf-8') as f:
+            json.dump(cfg, f, ensure_ascii=False, indent=4)
+
+# Save a file to be re-used later to a cached location
+def add_cached_file(cli_name, category, file_to_cache, overwrite_ok):
+    if not os.path.exists(file_to_cache):
+        return (False, '{} is not a valid file'.format(file_to_cache))
+    cfg = load_cfg(cli_name)
+    if '__cached_files__' not in cfg:
+        cfg['__cached_files__'] = {}
+    if category not in cfg['__cached_files__']:
+        cfg['__cached_files__'][category] = []
+    file_to_cache_name = os.path.basename(file_to_cache)
+    cfg['__cached_files__'][category].append(file_to_cache_name)
+    cat_path = os.path.join(get_cfg_dir(cli_name), category)
+    if not os.path.exists(cat_path):
+        os.makedirs(cat_path)
+    cache_path = os.path.join(cat_path, file_to_cache_name)
+    if os.path.isfile(cache_path) and not overwrite_ok:
+        return (False, '{} already exists and overwrite not specified as ok'.format(cache_path))
+    shutil.copyfile(file_to_cache, cache_path)
+    save_cfg(cli_name, cfg)
+    return (True, '{} cached to {}'.format(file_to_cache, cache_path))
+
+# Get a file previously cached
+def get_cached_file(cli_name, category, file_to_get):
+    cfg = load_cfg(cli_name)
+    if '__cached_files__' not in cfg:
+        return (False, 'no cached files')
+    if category not in cfg['__cached_files__']:
+        return (False, 'cached file {} not found'.format(file_to_get))
+    cache_path = os.path.join(get_cfg_dir(cli_name), category, file_to_get)
+    cf = cfg['__cached_files__'][category]
+    # Check by index
+    try:
+        file_index = int(file_to_get)
+        if file_index > -1 and file_index < len(cf):
+            cache_path = os.path.join(get_cfg_dir(cli_name), category, cf[file_index])
+        else:
+            return (False, '{} is not a valid file index'.format(file_index))
+    except Exception as e:
+        pass
+    if not os.path.exists(cache_path):
+        return (False, 'failed to get cached file at {}'.format(cache_path))
+    return (True, cache_path)
+
+def get_cached_file_list(cli_name, category):
+    cfg = load_cfg(cli_name)
+    if '__cached_files__' not in cfg:
+        return []
+    if category not in cfg['__cached_files__']:
+        return []
+    return cfg['__cached_files__'][category]

avrs/launcher.py

@@ -0,0 +1,256 @@
+import os
+import stat
+import json
+import logging
+import http.client
+import boto3
+import sys
+import shutil
+from avrs.cfg import *
+from avrs.launcher_util import *
+
+class AvrsLauncher:
+    def __init__(self, parent_parser, cfg):
+        self.cfg = cfg
+        self.logger = logging.getLogger('avrs')
+        provision_parser = parent_parser.add_parser(
+            'launcher', 
+            help='launcher operations, such as license registration or updating a sim install\n\n')
+        sps = provision_parser.add_subparsers(required=True, help='launcher options')
+
+        register_license_psr = sps.add_parser(
+            'register-license', 
+            help='registers a user license, allowing certain functionaility')
+        register_license_psr.add_argument(
+            'license_path', 
+            help='the path to the license file to register')
+        register_license_psr.set_defaults(func=self.register_license)
+
+        license_status_psr = sps.add_parser(
+            'license-status', 
+            help='shows information related to a user license')
+        license_status_psr.set_defaults(func=self.license_status)
+
+        get_latest_psr = sps.add_parser(
+            'get-latest-sim-version', 
+            help='ask the build info api for the latest sim version')
+        get_latest_psr.add_argument("variant", help="which variant to get the latest verison of")
+        get_latest_psr.set_defaults(func=self.get_latest_sim_version)
+
+        get_variants_psr = sps.add_parser(
+            'list-variants',
+            help='lists the available variants of the simulator that can be downloaded')
+        get_variants_psr.set_defaults(func=self.get_variants)
+
+        download_sim_psr = sps.add_parser('download-simulator', help='download the simulator')
+        download_sim_psr.add_argument('variant', help='which variant of the simulator to download (eg, \"a2rl-iron\" or \"a2rl-humble\")')
+        download_sim_psr.add_argument('install_path', help='path to install the simulator')
+        download_sim_psr.add_argument('--target-version', default='', help='specify a version other than the most recent to download')
+        download_sim_psr.add_argument(
+            '--copy-saved-from', 
+            default='', 
+            help='path to an existing installation from which to copy saved information')
+        download_sim_psr.add_argument(
+            '--update-existing', 
+            action='store_true', 
+            help='indicates that the user understands that they are updating an existing installation')
+        download_sim_psr.set_defaults(func=self.download_simulator)
+
+    def register_license(self, args):
+        print('Trying to Register License File: {}'.format(args.license_path))
+
+        # Load and validate provided license file
+        license_ok, license_status, license = validate_license_file(args.license_path)
+        if not license_ok:
+            print('Error Reading License File: {}'.format(license_status))
+            return
+
+        # Cache license info in config
+        license_name = os.path.basename(args.license_path)
+        self.cfg['license'] = {
+            'filename': os.path.basename(license_name),
+            'data': license
+        }
+        save_cfg('avrs', self.cfg)
+        print('License Registration Success: {}'.format(self.cfg['license']['filename']))
+
+        # Try to exchange license info for download keys
+        print('Retrieving Launcher Download Keys...')
+        (dl_keys_ok, dl_keys_status, self.cfg) = try_get_launcher_download_keys(self.cfg)
+        if not dl_keys_ok:
+            print('Error Getting Launcher Download Keys: {}'.format(dl_keys_status))
+            return
+        save_cfg('avrs', self.cfg)
+        print('Download Key Retrieval Success')
+
+    def license_status(self, args):
+        status = get_launcher_license_status_string(self.cfg)
+        print('Launcher License Status: {}'.format(status))
+
+    def get_available_sim_versions(self, args):
+        pass
+
+        # query something to find out what versions of the sim we can download
+
+    def get_variants(self, args):
+        if 'license' not in self.cfg:
+            print('no license has been registered\n')
+            return
+
+        (dl_keys_ok, dl_keys_status, self.cfg) = try_get_launcher_download_keys(self.cfg)
+        if not dl_keys_ok:
+            print('Error Getting Launcher Download Keys: {}'.format(dl_keys_status))
+            return
+        save_cfg('avrs', self.cfg)
+        print('{}'.format(self.cfg['variants']))
+
+
+    def get_latest_sim_version(self, args):
+        self.logger.info('getting latest sim version')
+        # Validate status of download keys
+        dl_keys_ok, dl_keys_status = has_launcher_download_keys(self.cfg)
+        if not dl_keys_ok:
+            print('Launcher Download Keys Error: {}'.format(dl_keys_status))
+            return
+
+        # Check if variant is valid (for backwards compatibility, we still proceed even if invalid)
+        variant_is_invalid = False
+        if args.variant not in ["staged", "feature"]:
+            # Ensure variants are loaded
+            if 'variants' not in self.cfg:
+                (dl_keys_ok, dl_keys_status, self.cfg) = try_get_launcher_download_keys(self.cfg)
+                if not dl_keys_ok:
+                    # If we can't get variants, proceed anyway for backwards compatibility
+                    pass
+            if 'variants' in self.cfg and args.variant not in self.cfg['variants']:
+                variant_is_invalid = True
+                # Write warning to stderr so it doesn't interfere with scripts parsing stdout
+                sys.stderr.write('Warning: "{}" is not a known variant. Available variants: {}\n'.format(
+                    args.variant, self.cfg['variants']))
+
+        variant_to_query = "autoverse" if args.variant in ["staged", "feature"] else args.variant
+
+        # Get latest build info from API
+        build_info_ok, build_info_status, latest_version, staged_version, build_info = get_launcher_build_info(
+            self.cfg, variant_to_query)
+        if not build_info_ok:
+            print('Error Getting Latest Version Info: {}'.format(build_info_status))
+            return
+
+        if args.variant == "staged":
+            print('{}'.format(staged_version))
+        elif args.variant == "feature":
+            feature_info = build_info.get('feature', {})
+            if isinstance(feature_info, str):
+                try:
+                    feature_info = json.loads(feature_info)
+                except json.JSONDecodeError:
+                    pass
+            print('{}'.format(json.dumps(feature_info)))
+        else:
+            print('{}'.format(latest_version))
+            if variant_is_invalid:
+                # Explain that the output is the default/prod variant version, not the requested variant
+                sys.stderr.write('Note: The version shown above is the production version of the default variant, not "{}"\n'.format(
+                    args.variant))
+
+    def download_simulator(self, args):
+
+        # update variants before each download. also updates download keys
+        print('Updating Variants...')
+        self.get_variants(args)
+
+        if args.variant not in self.cfg['variants']:
+            print('\"{}\" is not a known variant, try one of: {}'.format(
+                args.variant, self.cfg['variants']))
+            return
+
+        file_path = args.install_path
+        if not os.path.exists(file_path):
+            print('Cannot Install Simulator at: {} (Invalid Path, Specify a Directory)'.format(file_path))
+            return
+
+        # Validate status of download keys
+        dl_keys_ok, dl_keys_status = has_launcher_download_keys(self.cfg)
+        if not dl_keys_ok:
+            print('Launcher Download Keys Error: {}'.format(dl_keys_status))
+            return
+
+        # Get latest build info from API
+        build_info_ok, build_info_status, latest_version, staged_version, _build_info = get_launcher_build_info(
+            self.cfg, args.variant)
+        if not build_info_ok:
+            print('Error Getting Latest Version Info: {}'.format(build_info_status))
+            return
+
+        # If we want to copy saved info from another installation
+        copy_saved = False
+        copy_saved_cache = ''
+        if args.copy_saved_from != '':
+            if not is_installed_sim(args.copy_saved_from):
+                print('The Path: {} Is not an Existing Installation. Cannot Copy Saved'.format(args.copy_saved_from))
+                return
+            else:
+                copy_saved = True
+
+        if copy_saved:
+            print('Caching Saved from Existing Installation at: {}'.format(args.copy_saved_from))
+            copy_from_saved_dir = os.path.join(args.copy_saved_from, 'Linux', 'Autoverse', 'Saved')
+            copy_saved_cache = os.path.join(args.install_path, 'autoverse-saved-cache')
+            shutil.copytree(copy_from_saved_dir, copy_saved_cache)
+
+        target_version = latest_version
+        if args.target_version == 'staged':
+            target_version = staged_version
+            print('attempting to download staged version: {}'.format(target_version))
+        elif args.target_version != '':  
+            target_version = args.target_version
+            print('attempting to download specified version: {}'.format(target_version))
+
+        package_zip_name = 'autoverse-linux-{}.zip'.format(target_version)
+        package_name = 'autoverse-linux'
+        if target_version == 'feature':
+            args.variant = 'feature'
+        bucket_path = '{}/{}'.format(args.variant, package_zip_name)
+        dl_path = os.path.join(args.install_path, package_zip_name)
+        unzip_path = os.path.join(args.install_path, package_name)
+
+        if is_installed_sim(unzip_path) and not args.update_existing:
+            print('''
+Downloading at {} will update an existing installation and override its saved information. 
+make sure you have backups of any configuration or use the --copy-saved-from option.
+If you are sure, re-run with the --update-existing flag
+                '''.format(unzip_path))
+            return
+
+        if not is_installed_sim(unzip_path):
+            if not 'installs' in self.cfg:
+                self.cfg['installs'] = []
+            self.cfg['installs'].append(unzip_path)
+            save_cfg('avrs', self.cfg)
+
+        print('Downloading {} to {}. This May Take Several Minutes Depending on Connection Speed'.format(bucket_path, dl_path))
+        download_simulator_archive(self.cfg, bucket_path, dl_path)
+
+        print('Extracting {} to {}'.format(dl_path, unzip_path))
+        shutil.unpack_archive(dl_path, unzip_path)
+
+        if copy_saved:
+            print('Migrating Saved Files')
+            shutil.copytree(copy_saved_cache, os.path.join(unzip_path, 'Linux', 'Autoverse', 'Saved'), dirs_exist_ok=True)
+            shutil.rmtree(copy_saved_cache)
+
+        # Install license if missing
+        if not copy_saved:
+            print('Installing Registered License: {}'.format(self.cfg['license']['filename']))
+            license_install_path = os.path.join(unzip_path, 'Linux', 'Autoverse', 'Saved', self.cfg['license']['filename'])
+            with open(license_install_path, 'w', encoding='utf-8') as f:
+                json.dump(self.cfg['license']['data'], f, ensure_ascii=False, indent=4)
+
+        # Make Autovers.sh executable
+        autoverse_exe = os.path.join(unzip_path, 'Linux', 'Autoverse.sh')
+        st = os.stat(autoverse_exe)
+        os.chmod(autoverse_exe, st.st_mode | stat.S_IEXEC)
+
+        print('Cleaning up')
+        os.remove(dl_path)