autoverse-cli 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

{autoverse_cli-0.4.1.dist-info → autoverse_cli-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autoverse-cli
-Version: 0.4.1
+Version: 0.6.0
 Summary: The Autoverse CLI
 Author-email: Dan Kamrath <dan.kamrath@autonomalabs.com>
 License: # End-User License Agreement (EULA) of the Autonoma AutoVerse CLI
@@ -42,6 +42,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3
+Requires-Dist: cantools
 
 # Autoverse CLI
 

autoverse_cli-0.6.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+avrs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+avrs/app_version.py,sha256=MRoy99DwudgXSSMa5eP0kVNc3PCETDrhmmPJC6NtIc8,855
+avrs/argparse_help.py,sha256=EoEaohGXZXqJvs1dFEzbo9vh47CYdHdSY2Im2Ps2iFo,945
+avrs/avrs.py,sha256=6fV-br7njgk1fOmv2G2gz0JDqBMpz_OhecZRojG4B-c,2685
+avrs/can_tool.py,sha256=IBoctKobBJ3wCq4ZdtuXuXH4AMEUxazCfYT6YP0Luw8,7161
+avrs/can_tool_util.py,sha256=G3q21dTGMLc09SDq_RieoW7kSn-kXPkXxPDjavPh4hQ,7710
+avrs/cfg.py,sha256=kMn08Z4Ms1PAu2-U1QI8weEJeIVEppP4A4_tFfwnjtg,2924
+avrs/launcher.py,sha256=u7COEMvvkqxeGyW0kd2m6KK4375nWY5ONO4TxKJ2Xt4,7710
+avrs/launcher_util.py,sha256=y_F2YvIe81l3B1_lCjpoOgkbE4hAr2C9eaPio0es34o,5236
+avrs/simconfig.py,sha256=CtpIeU32Lfsek37Z4XR4mjSKwF27IlYvC92184VOuuQ,2389
+avrs/simconfig_util.py,sha256=R3ggjx1fIdOAHpUroNLjH6gg0G07PbFTI4PfwUOWtdw,2277
+avrs/tests.py,sha256=3JeYBjn0tRqHXERDROfzmYuW1KXeCcKur5Bw-EIegto,153
+avrs/requests/change_camera.py,sha256=twqdE049DHwdjgKFZbindwpK7Oz-ivCjbI8WQj8QsxI,416
+avrs/requests/code_booz.py,sha256=5bzT8Ra6EIwI19TqXMxkHG_llnyFgqSzTSo7yLNV9Vc,2274
+avrs/requests/demo.py,sha256=cbGQJK-OfeFUkQwVzafHgoWP15xoKL-ZgYkQ7moEt2A,872
+avrs/requests/environment.py,sha256=ORwOBxhXPcatn_W8aY5pgIy4f2paUbqIYii5oE540xA,1305
+avrs/requests/fault_injection.py,sha256=EkpjPCx-UtrNbAR_vQS1zaGKN49UDCyYOoVcdlP1T0M,5948
+avrs/requests/list_sim_objects.py,sha256=YWpqHdCHijerPxI5606_KjeFvezcLFN33wO4YOr9G3U,977
+avrs/requests/log_path.py,sha256=Ur24C9VqPVx78MfpicgQu2uOEe-0dXbGoWF_7dzMtZE,1326
+avrs/requests/move_to_landmark.py,sha256=cLRBKu9XEDsmCoftBJ8JwoBLqzb0IZsxFMBnus4T-kc,702
+avrs/requests/npc.py,sha256=Y_WovbcLomCCcOLAMMO_DHZtc1crAzWo97qEIGS3SvU,9691
+avrs/requests/request.py,sha256=1g_0NLpKRRdHW10LAPa9N1jW3zZSdq8yUQFeAPyErtE,1595
+avrs/requests/reserve_mv_slot.py,sha256=p_jiTV7rcoyJU6u3UR9sqPBpSaq8-PWMEs0Ckm2Hf8w,3843
+avrs/requests/reset_to_track.py,sha256=lSd2YavBxDV_hQMhVoi08_TpTFEq7G2MA18xosFYa1g,450
+avrs/requests/restart.py,sha256=ih5mnWiU34q3-xhOth45CtOUXxKI0PoMDCnFJV0JbwE,415
+avrs/requests/scenario_control.py,sha256=u-KQx-mdCm6IE_c88a6iEgWUsZZVOayxBo58Ocjg0ZI,1502
+avrs/requests/teleport.py,sha256=WpnB2-Ii0FGI11EXTAHlaF5zqZIsgEyJnJ2j_w4rDFY,824
+avrs/requests/toggle_hud.py,sha256=sV5t5QZc4uvRihPVk8jEKZiQNsyF9tsUwq5b4jjZplc,397
+avrs/requests/vd.py,sha256=at6oUAGY2h0OxYU6MLOi1gnxyUn6i24vL9DUAj0L880,1600
+avrs/requests/vehicle_input.py,sha256=R1b1xkRtOBkwyU6OSN4bWVlYsIUroZG0WKbYbc4pEH8,729
+avrs/requests/vehicle_replay.py,sha256=wlfkieaSrpXZCsyjtM6fociRXWpBLGZXhaJAS1sNS0o,7603
+autoverse_cli-0.6.0.dist-info/LICENSE,sha256=d4eWXho-u18HkBsX4K21uHX_bBb2UXZSrJdsb7Z_JlM,2647
+autoverse_cli-0.6.0.dist-info/METADATA,sha256=a4uddOOnI-EuiR0BH9prt_l7aLEPJXVjJ1CouGs5bdU,3341
+autoverse_cli-0.6.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+autoverse_cli-0.6.0.dist-info/entry_points.txt,sha256=Cb9qsUyU5AKkklehCcvtfT0-N3SXbUEqvjze4iEU5kE,40
+autoverse_cli-0.6.0.dist-info/top_level.txt,sha256=-AJO2e4MCVej6hY0U84pu5NfMeMW5qaAPSMisDT5rmA,5
+autoverse_cli-0.6.0.dist-info/RECORD,,

{autoverse_cli-0.4.1.dist-info → autoverse_cli-0.6.0.dist-info}/WHEEL

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

avrs/app_version.py

@@ -2,7 +2,7 @@ import http.client
 import json
 
 def get_app_version():
-    return '0.4.1'
+    return '0.6.0'
 
 def check_app_is_latest():
     pass

avrs/avrs.py

@@ -6,21 +6,28 @@ from argparse import RawTextHelpFormatter
 from avrs.app_version import *
 from avrs.cfg import *
 from avrs.launcher import *
+from avrs.can_tool import *
 from avrs.argparse_help import *
 
 from avrs.requests.move_to_landmark import MoveToLandmarkRequest
 from avrs.requests.restart import Restart
 from avrs.requests.reset_to_track import ResetToTrack
 from avrs.requests.teleport import Teleport
-#from src.requests.can import Can
 from avrs.requests.npc import Npc
 from avrs.requests.reserve_mv_slot import ReserveMvSlot
 from avrs.requests.vd import Vd
-from avrs.requests.input import InputRequest
+from avrs.requests.vehicle_input import AvrsConfigureVehicleInputRequest
 from avrs.requests.log_path import LogPath
 from avrs.requests.demo import AvrsDemoRequest
-from avrs.requests.edit_environment import AvrsEditEnvironmentRequests
+from avrs.requests.environment import *
 from avrs.requests.code_booz import *
+from avrs.requests.vehicle_replay import *
+from avrs.requests.scenario_control import *
+from avrs.requests.list_sim_objects import *
+from avrs.requests.fault_injection import *
+from avrs.requests.change_camera import *
+from avrs.requests.toggle_hud import * 
+from avrs.simconfig import *
 
 
 def get_version():
@@ -39,6 +46,11 @@ def main():
             action='version', 
             version=get_version())
 
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='request verbose output')
+
     sps = parser.add_subparsers(required=True, help='sub-command help')
 
     cfg = load_cfg('avrs')
@@ -50,16 +62,25 @@ def main():
     MoveToLandmarkRequest(sps, cfg)
     Restart(sps, cfg)
     ResetToTrack(sps, cfg)
-    #Can(sps, cfg)
     Teleport(sps, cfg)
-    Npc(sps, cfg)
+    #Npc(sps, cfg)
     ReserveMvSlot(sps, cfg)
     Vd(sps, cfg)
-    #InputRequest(sps, cfg)
+    AvrsConfigureVehicleInputRequest(sps, cfg)
     LogPath(sps, cfg)
-    AvrsEditEnvironmentRequests(sps, cfg)
+    AvrsEnvironmentRequests(sps, cfg)
     AvrsCodeBoozRequest(sps, cfg)
-    AvrsDemoRequest(sps, cfg)
+    AvrsVehicleReplayRequests(sps, cfg)
+    AvrsCanTool(sps, cfg)
+    AvrsSimConfig(sps, cfg)
+    AvrsScenarioRequests(sps, cfg)
+    AvrsListSimObjectsRequest(sps, cfg)
+    AvrsFaultInjectionRequests(sps, cfg)
+    AvrsChangeCameraRequest(sps, cfg)
+    AvrsToggleHudRequest(sps, cfg)
+
+    if os.environ.get('AVRS_WITH_DEMO', '0') == '1':
+        AvrsDemoRequest(sps, cfg)
 
     if os.environ.get('AVRS_GEN_DOCS', '0') == '1':
         generate_argparse_docs(parser)

avrs/can_tool.py

@@ -0,0 +1,192 @@
+from avrs.requests.request import AvrsApiRequest
+import can
+import cantools
+import time
+import os
+import datetime
+
+from avrs.cfg import *
+from avrs.can_tool_util import *
+
+class AvrsCanTool():
+    def __init__(self, parent_parser, cfg):
+        self.cfg = cfg
+        can_tool_parser = parent_parser.add_parser(
+            'can-tool', 
+            help='provides CAN utilities (echo certain signals, etc)\n\n')
+        sps = can_tool_parser.add_subparsers(required=True, help='can-tool options')
+
+        add_dbc_parser = sps.add_parser(
+            'add-dbc', 
+            help='save a dbc file to be used with other commands')
+        add_dbc_parser.add_argument(
+            'dbc_file_path', 
+            help='the path to the dbc file to add')
+        add_dbc_parser.add_argument(
+            '--overwrite-ok',
+            action='store_true',
+            help='is it ok to overwrite an existing file')
+        add_dbc_parser.set_defaults(func=self.add_dbc)
+
+        list_dbc_parser = sps.add_parser(
+            'list-dbc', 
+            help='list the dbc files that are known to avrs')
+        list_dbc_parser.set_defaults(func=self.list_dbc)
+
+        echo_parser = sps.add_parser(
+            'echo', 
+            help='echos CAN messages')
+        echo_parser.add_argument(
+            'can_names',
+            nargs='+',
+            help='the names of the CAN interfaces, eg "vcan0 vcan1" etc')
+        echo_parser.add_argument(
+            '--dbc_names',
+            nargs='+',
+            default='',
+            help='the names or indeces of a cached dbc files or path to existing dbc files to use')
+        echo_parser.add_argument(
+            '--isolate',
+            nargs='+',
+            default='',
+            help='a list of specific signal to echo, ignoring other signals')
+        echo_parser.add_argument(
+            '--duration',
+            type=float,
+            default=1.0,
+            help='the duration to echo can')
+        echo_parser.add_argument(
+            '--rates',
+            action='store_true',
+            help='echo the rates for messages instead of their values')
+        echo_parser.add_argument(
+            '--save-report-as',
+            default='',
+            help='if set along with the "--rates" flag, will save results to a json file')
+        echo_parser.set_defaults(func=self.echo)
+
+        eav_input_parser = sps.add_parser(
+            'send-eav24-input',
+            help='send some simple input (throttle, brake, steer etc) to an eav24 over CAN')
+        eav_input_parser.add_argument(
+            'can_name',
+            help='the name of the CAN interface, eg "vcan0"')
+        eav_input_parser.add_argument(
+            'dbc_name',
+            help='the name or index of a cached dbc file or path to existing dbc file to use')
+        eav_input_parser.add_argument(
+            '--throttle',
+            type=float,
+            default=0.0,
+            help='throttle to send 0 -> 1.0')
+        eav_input_parser.add_argument(
+            '--gear',
+            type=int,
+            default=0,
+            help='gear to send')
+        eav_input_parser.add_argument(
+            '--brake',
+            type=float,
+            default=0.0,
+            help='brake to send 0 -> 1.0')
+        eav_input_parser.add_argument(
+            '--steer',
+            type=float,
+            default=0.0,
+            help='steer to send -24 -> 24')
+        eav_input_parser.add_argument(
+            '--duration',
+            type=float,
+            default=1.0,
+            help='the duration to send the command can')
+        eav_input_parser.set_defaults(func=self.eav_input)
+
+        test_latency_parser = sps.add_parser(
+            'test-eav24-bsu-latency', 
+            help='test the latency in the EAV24 BSU CAN interface by waiting for command ACK')
+        test_latency_parser.add_argument(
+            'can_name',
+            help='the name of the CAN interface, eg "vcan0"')
+        test_latency_parser.add_argument(
+            'dbc_name',
+            help='the name or index of a cached dbc file or path to existing dbc file to use')
+        test_latency_parser.add_argument(
+            '--nsamples',
+            type=int,
+            default=5,
+            help='the number of samples to test')
+        test_latency_parser.add_argument(
+            '--duration',
+            type=float,
+            default=1.0,
+            help='the duration to send each command can to wait for a given ack')
+        test_latency_parser.add_argument(
+            '--send-rate-hz',
+            type=float,
+            default=50,
+            help='the rate in hz to send messages to wait for a given ack')
+        test_latency_parser.add_argument(
+            '--save-report-as',
+            default='',
+            help='if set will save results to a json file with this name')
+
+        test_latency_parser.set_defaults(func=self.test_eav24_latency)
+
+
+    def add_dbc(self, args):
+        ok, status = add_cached_file(
+            'avrs', 'dbc', args.dbc_file_path, args.overwrite_ok)
+        print(status)
+
+    def list_dbc(self, args):
+        files = get_cached_file_list('avrs', 'dbc')
+        s = ''
+        for i in range(len(files)):
+            s += '({}) {} \n'.format(i, files[i])
+        print(s) if len(files) > 0 else print('(empty)')
+
+    def echo(self, args):
+        dbcs = self.get_dbcs(args.dbc_names)
+        print('echoing {} using {} dbcs'.format(args.can_names, len(dbcs)))
+        if len(dbcs) > 0:
+            echo_can(args.can_names, dbcs, args.duration, args.isolate, args.rates, args.save_report_as)
+        else:
+            print('unable to echo can (dbc or can name error)')
+
+    def eav_input(self, args):
+        dbcs = self.get_dbcs([args.dbc_name])
+        if len(dbcs) > 0:
+            send_eav24_can_values(
+                args.can_name, dbcs[0], args.throttle, args.gear, args.brake, args.steer, args.duration)
+        else:
+            print('unable to echo can (dbc or can name error)')
+
+    def test_eav24_latency(self, args):
+        dbcs = self.get_dbcs([args.dbc_name])
+        if len(dbcs) > 0:
+            test_eav24_can_latency(
+                args.can_name, dbcs[0], args.nsamples, args.send_rate_hz, args.duration, args.save_report_as)
+        else:
+            print('unable to echo can (dbc or can name error)')
+
+    def get_dbcs(self, dbc_names):
+        dbcs = []
+        # If default, find all dbcs and return them
+        if dbc_names == '':
+            for d in get_cached_file_list('avrs', 'dbc'):
+                ok, cache_path = get_cached_file('avrs', 'dbc', d)
+                if ok:
+                    dbcs.append(cantools.database.load_file(cache_path))
+                else:
+                    print(cache_path)
+        else:
+            for d in dbc_names:
+                if os.path.isfile(d):
+                    dbc = cantools.database.load_file(d)
+                else:
+                    ok, cache_path = get_cached_file('avrs', 'dbc', d)
+                    if ok:
+                        dbcs.append(cantools.database.load_file(cache_path))
+                    else:
+                        print(cache_path)
+        return dbcs

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

@@ -1,5 +1,6 @@
 import json
 import os
+import shutil
 
 def get_cfg_dir(cli_name):
     return os.path.join(os.environ['HOME'], '.config', cli_name)
@@ -23,4 +24,55 @@ def load_cfg(cli_name):
 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)
+            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

@@ -98,7 +98,7 @@ class AvrsLauncher:
 
         file_path = args.install_path
         if not os.path.exists(file_path):
-            print('Cannot Install Simulator at: {} (Invalid Path)'.format(file_path))
+            print('Cannot Install Simulator at: {} (Invalid Path, Specify a Directory)'.format(file_path))
             return
 
         # Validate status of download keys
@@ -143,6 +143,12 @@ 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)
 

avrs/launcher_util.py

@@ -124,6 +124,9 @@ def download_simulator_archive(cfg, source_path, target_path):
         aws_secret_access_key=cfg['dlkey'])
     s3_download_with_progress(s3_client, 'autoverse-builds', source_path, target_path)
 
+def get_sim_saved_dir(sim_install_path):
+    return os.path.join(sim_install_path, 'Linux', 'Autoverse', 'Saved')
+
 def is_installed_sim(file_path):
     """
     Check if the given path appears to be the root of

avrs/requests/change_camera.py

@@ -0,0 +1,11 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsChangeCameraRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ChangeCamera', '')
+        psr = parser.add_parser('change-camera', help='changes the active camera on an object')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+        }

avrs/requests/demo.py

@@ -5,9 +5,7 @@ class AvrsDemoRequest(AvrsApiRequest):
         AvrsApiRequest.__init__(self, parser, cfg, 'DemoSendConfig', '')
         psr = parser.add_parser('demo', help='Sends a request used for a demonstration')
         psr.add_argument('--ego-type-index', type=int, default=0, help='')
-        psr.add_argument('--num-npcs', type=int, default=0, help='')
-        psr.add_argument('--npc-trajs', type=int, default=[0, 0, 0, 0], nargs='+', help='')
-        psr.add_argument('--npc-type-index', default=0, type=int)
+        psr.add_argument('--npc-density', type=int)
         psr.add_argument('--env-type-index', default=0, type=int)
         psr.add_argument('--weather-type-index', default=0, type=int)
         psr.set_defaults(func=self.send_request)
@@ -15,9 +13,7 @@ class AvrsDemoRequest(AvrsApiRequest):
     def get_request_body(self, args):
         return {
             'IndexEgoType': args.ego_type_index,
-            'NumberNPCS': args.num_npcs,
-            'NPCTrajectories': args.npc_trajs,
-            'IndexNPCType': args.npc_type_index,
+            'NpcDensity': args.npc_density,
             'IndexEnvironmentType': args.env_type_index,
-            'TypeIndexIndex': args.weather_type_index
+            'indexWeatherType': args.weather_type_index
         }