autoverse-cli 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

avrs/requests/fault_injection.py

@@ -0,0 +1,155 @@
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawDescriptionHelpFormatter
+from argparse import RawTextHelpFormatter
+
+class AvrsFaultInjectionRequests():
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('inject-fault', help='utilty to inject faults into components (sensors, actuators, etc)')
+        sps = psr.add_subparsers(required= True, help='sub-command inject-fault')
+        AvrsGnssFaultRequest(sps, cfg)
+        AvrsLidarFaultRequest(sps, cfg)
+        AvrsImuFaultRequest(sps, cfg)
+    
+def add_base_injection_args(psr):
+
+    psr.add_argument(
+        '--target',
+        default='ego',
+        help='the simulated object to apply the fault to')
+
+    psr.add_argument(
+        '--duration',
+        type=float,
+        default=1.0,
+        help='how long to apply the fault (0.0 is infinite)')
+
+    psr.add_argument(
+            '--dropout',
+            action='store_true',
+            help='if specified, will apply a complete dropout fault')
+
+    psr.add_argument(
+            '--freeze',
+            action='store_true',
+            help='if specified, will freeze the data (values will not change)')
+
+class AvrsGnssFaultRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'FaultInjection', '')
+
+        psr = parser.add_parser(
+            'gnss', 
+            help='inject a gnss fault', 
+            formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--horizontal-bias',
+            type=float,
+            default=0.0,
+            help='horizontal bias to apply to the sensor as a fault')
+
+        psr.add_argument(
+            '--vertical-bias',
+            type=float,
+            default=0.0,
+            help='vertical bias to apply to the sensor as a fault')
+
+        psr.add_argument(
+            '--horizontal-stdev',
+            type=float,
+            default=0.0,
+            help='horizontal standard deviation to apply to the sensor')
+
+        psr.add_argument(
+            '--vertical-stdev',
+            type=float,
+            default=0.0,
+            help='vertical standard deviation to apply to the sensor')
+
+        add_base_injection_args(psr)
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        self.target_object_id = args.target
+        self.verbose = args.verbose
+        return {
+            'faultType': 'GnssFault',
+            'duration': args.duration,
+            'bIsDropout': args.dropout,
+            'bIsFreeze': args.freeze,
+            'JsonBody': {
+                'verticalBias': args.vertical_bias,
+                'verticalStdev': args.vertical_stdev,
+                'horizontalBias': args.horizontal_bias,
+                'horizontalStdev': args.horizontal_stdev
+            }
+        }
+
+class AvrsImuFaultRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'FaultInjection', '')
+
+        psr = parser.add_parser(
+            'imu', 
+            help='inject an imu fault', 
+            formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--bias',
+            type=float,
+            default=0.0,
+            help='horizontal bias to apply to the sensor as a fault')
+
+        psr.add_argument(
+            '--stdev',
+            type=float,
+            default=0.0,
+            help='horizontal standard deviation to apply to the sensor')
+
+        add_base_injection_args(psr)
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        self.target_object_id = args.target
+        self.verbose = args.verbose
+        return {
+            'faultType': 'ImuFault',
+            'duration': args.duration,
+            'bIsDropout': args.dropout,
+            'bIsFreeze': args.freeze,
+            'JsonBody': {
+                'bias': args.bias,
+                'stdev': args.stdev
+            }
+        }
+
+class AvrsLidarFaultRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'FaultInjection', '')
+
+        psr = parser.add_parser(
+            'lidar', 
+            help='inject a lidar fault', 
+            formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--point-density-reduction',
+            type=float,
+            default=0.5,
+            help='the percent of point density reduction, where 1.0 drops all points')
+
+        add_base_injection_args(psr)
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        self.target_object_id = args.target
+        self.verbose = args.verbose
+        return {
+            'faultType': 'LidarFault',
+            'duration': args.duration,
+            'bIsDropout': args.dropout,
+            'bIsFreeze': args.freeze,
+            'JsonBody': {
+                'pointDensityReduction': args.point_density_reduction
+            }
+        }

avrs/requests/list_sim_objects.py

@@ -0,0 +1,26 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsListSimObjectsRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ListSimObjects', 0)
+        psr = parser.add_parser('list-sim-objects', help='list all the sim objects that currently exist in the simulator')
+        psr.add_argument(
+            '-v',
+            action='store_true',
+            help='request verbose output')
+        psr.add_argument(
+            '--components',
+            action='store_true',
+            help='also print information about the object components')
+        psr.add_argument(
+            '--isolate',
+            default='',
+            help='indicate a specific object of interest')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+            "bVerbose": args.v,
+            'bListComponents': args.components,
+            'isolate': args.isolate
+        }

avrs/requests/request.py

@@ -11,12 +11,15 @@ class AvrsApiRequest:
     def __init__(self, parser, cfg, request_type, target_id):
         self.target_object_id = target_id
         self.request_type = request_type
+        self.verbose = False
 
     def get_request(self, args):
+        body = json.dumps(self.get_request_body(args))
         return {
             'TargetObjectId': self.target_object_id,
             'RequestType': self.request_type,
-            'RequestBody': json.dumps(self.get_request_body(args))
+            'bVerboseResponse': self.verbose,
+            'RequestBody': body
         }
 
     def get_request_body(self, args):

avrs/requests/scenario_control.py

@@ -0,0 +1,43 @@
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawDescriptionHelpFormatter
+from argparse import RawTextHelpFormatter
+
+class AvrsScenarioRequests():
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('scenario', help='commands related to scenarios in the simulator')
+        sps = psr.add_subparsers(required= True, help='sub-command scenario')
+        StartScenarioRequest(sps, cfg)
+        StopScenarioRequest(sps, cfg)
+
+class StartScenarioRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ScenarioControl', '')
+        psr = parser.add_parser(
+            'start', help='start a scenario', formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            'scenario_name', 
+            default='', 
+            help='the name of the scenario to start')
+        
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):
+        return {
+            'scenarioName': args.scenario_name,
+            'action': 'start'
+        }
+
+class StopScenarioRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ScenarioControl', '')
+        psr = parser.add_parser(
+            'stop', help='stop any active scenarios', formatter_class=RawTextHelpFormatter)
+
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+            'action': 'stop'
+        }

avrs/requests/vehicle_input.py

@@ -0,0 +1,21 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsConfigureVehicleInputRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ConfigureVehicleInput', 'Ego')
+        psr = parser.add_parser(
+            'configure-vehicle-input', 
+            help='Allows different input modes to be set for a vehicle')
+
+        psr.add_argument(
+            'input_mode', 
+            default='None', 
+            choices=['None', 'Keyboard', 'WheelAndPedals', 'CAN'], 
+            help='the type of input mode to set')
+
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+            "InputMode": args.input_mode
+        }

avrs/requests/vehicle_replay.py

@@ -0,0 +1,191 @@
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawDescriptionHelpFormatter
+from argparse import RawTextHelpFormatter
+
+class AvrsVehicleReplayRequests():
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('vehicle-replay', help='utilty for recording and replaying vehicle motion')
+        sps = psr.add_subparsers(required= True, help='sub-command vehicle-replay')
+        SpawnReplayVehicle(sps, cfg)
+        StartVehicleReplayRecording(sps, cfg)
+        StopVehicleReplayRecording(sps, cfg)
+
+class SpawnReplayVehicle(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'SpawnObject', '')
+        psr = parser.add_parser(
+            'spawn', help='spawn a vehicle intended to replay motion', formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            'replay_file', 
+            default='', 
+            help='the replay file to use ("random" for a random profile)')
+
+        psr.add_argument(
+            '--name', 
+            default='npc0', 
+            help='name of the replay vehicle to spawn')
+
+        psr.add_argument(
+            '--vehicle-type', 
+            default='EAV24', 
+            help='what type of vehicle to spawn for replay')
+
+        # psr.add_argument(
+        #     '--position', 
+        #     choices=('relative', 'absolute'), 
+        #     default='absolute', 
+        #     help=NPC_SPAWN_POSITION_HELP)
+
+
+        # psr.add_argument(
+        #     '--velocity-type', 
+        #     default='constant', 
+        #     help='the path the NPC follows is a constant velocity or speed')
+
+        # psr.add_argument(
+        #     '--speed', 
+        #     type=float, 
+        #     default=20, 
+        #     help='the speed of the npc is m/s')
+
+        psr.add_argument(
+            '--rate', 
+            type=float, 
+            default=1.0, 
+            help='the playback rate, 1.0 is normal')
+
+        psr.add_argument(
+            '--random-start',
+            action='store_true',
+            help='if set, will start at a random point in the replay')
+
+        psr.add_argument(
+            '--relative-dist', 
+            type=float, 
+            default=40.0, 
+            help='the distance relative to ego to start the playback (-1 to start at playback start)')
+
+        psr.add_argument(
+            '--auto-start',
+            action='store_true',
+            help='if set, the npc will begin moving immediately')
+
+        # psr.add_argument(
+        #     '--enable-sensors', 
+        #     type=bool, 
+        #     default=False, 
+        #     help='whether to enable sensors on the replay vehicle')
+
+        psr.add_argument(
+            '--with-view-cameras',
+            action='store_true',
+            help='if set, will attach viewing cameras to the replay vehicle')
+        
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):
+
+        replay_ipd = {
+            'bEnableRecording': False,
+            'bRecordOnPhysicsTick': False,
+            'recordMotionMinSpeedThreshold': 0.01,
+            'bEnableReplay': True,
+            'bApplyInitialConfig': True,
+            'initialConfig': {
+                'playRate': args.rate,
+                'profile': args.replay_file,
+                'bUseRandomProfile': args.replay_file == 'random',
+                'replayAction': 'start' if args.auto_start else '',
+                'bStartReplayAtRandomTime': args.random_start,
+                'relativeDistance': args.relative_dist
+            }
+        }
+
+        eav_init_pld = {
+            "bEnableBsuCan": False,
+            "bEnableKistlerCan": False,
+            "bEnableBadeniaCan": False,
+            "bHudEnabled": False,
+            "bLidarEnabled": False,
+            "bCameraEnabled": False,
+            "bPublishInputs": False,
+            "bPublishGroundTruth": False
+        }
+
+        plds = [
+            {
+                'TypeName': 'WheeledVehicleReplayIpd',
+                'Body': replay_ipd
+            },
+            {
+                'TypeName': 'Eav24Initializer',
+                'Body': eav_init_pld
+            }
+        ]
+
+        if args.with_view_cameras:
+            plds.append(
+                {
+                    'TypeName': 'InitializerTemplates',
+                    'Body': {
+                        'Templates': [
+                            {
+                                'PayloadType': 'SimViewTargetIpd',
+                                'PayloadSpec': 'DefaultCarCams'
+                            }
+                        ]
+                    }
+                })
+
+        return {
+            'Name': args.name,
+            'Type': args.vehicle_type,
+            'Location': {},
+            'Rotation': {},
+            'Payloads': plds
+        }
+
+class StartVehicleReplayRecording(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ConfigureVehicleReplay', 'Ego')
+        psr = parser.add_parser(
+            'start-recording', help='begin recording vehicle motion', formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            'out_file',
+            help='the file name to use for the saved recording')
+
+        psr.add_argument(
+            '--rate-hz',
+            type=float,
+            default=100.0, 
+            help='the rate to record vehicle motion. high rates will produce large files')
+
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):
+        return {
+            'PlayRate': -1.0,
+            'profile': '',
+            'replayAction': '',
+            #'teleportLocation': '',
+            'recordAction': 'start',
+            'recordFileName': args.out_file,
+            'recordRateHz': args.rate_hz
+        }
+
+class StopVehicleReplayRecording(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ConfigureVehicleReplay', 'Ego')
+        psr = parser.add_parser(
+            'stop-recording', help='begin recording vehicle motion', formatter_class=RawTextHelpFormatter)
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):
+        return {
+            'recordAction': 'stop',
+        }

avrs/simconfig.py

@@ -0,0 +1,61 @@
+import os
+import stat
+import json
+import http.client
+from avrs.cfg import *
+from avrs.launcher_util import *
+from avrs.simconfig_util import *
+
+class AvrsSimConfig:
+    def __init__(self, parent_parser, cfg):
+        self.cfg = cfg
+        sim_config_parser = parent_parser.add_parser(
+            'sim-config', 
+            help='utilities for easily configuring the simulator\n\n')
+
+        sps = sim_config_parser.add_subparsers(required=True, help='sim-config options')
+
+        apply_preset_parser = sps.add_parser(
+            'apply-preset',
+            help='apply a preset configuration for a certain use-case')
+        apply_preset_parser.add_argument(
+            'preset_name',
+            choices=['default', 'lightweight', 'a2rl'],
+            help='the name of the preset to apply')
+        apply_preset_parser.add_argument(
+            '--sim-path',
+            default='',
+            help='''
+the path to the simulator installation having the intended config to modify, or the
+index of a known installation. if there is only one known installation, it will be used as
+the target
+''')
+        apply_preset_parser.set_defaults(func=self.apply_preset)
+
+
+    def apply_preset(self, args):
+        sim_path = args.sim_path
+        if sim_path == '':
+            if 'installs' in self.cfg and len(self.cfg['installs']) > 0:
+                if len(self.cfg['installs']) > 1:
+                    print('multiple known installs. specify path or index')
+                    for i in range(len(self.cfg['installs'])):
+                        print('({}) {}'.format(i, self.cfg['installs'][i]))
+                    return
+                else:
+                    sim_path = self.cfg['installs'][0]
+            else:
+                print('sim_path not specified and no known existing installations')
+                return
+        try:
+            sim_path_index = int(sim_path)
+            if 'installs' in self.cfg and len(self.cfg['installs']) > sim_path_index:
+                sim_path = self.cfg['installs'][sim_path_index]
+        except Exception as e:
+            pass
+        if not is_installed_sim(sim_path):
+            print('{} is not a valid sim installation'.format(sim_path))
+            return
+
+        print('applying preset {} to sim install at {}'.format(args.preset_name, sim_path))
+        apply_simconfig_preset(get_sim_saved_dir(sim_path), args.preset_name)

avrs/simconfig_util.py

@@ -0,0 +1,70 @@
+import os
+import json
+
+class SimConfigFiles():
+    def __init__(self, saved_dir):
+
+        self.required_files = {
+            'main': os.path.join(saved_dir, 'simconfig.json'),
+            'eav24': os.path.join(saved_dir, 'Objects', 'Eav24_default.json'),
+            'yas': os.path.join(saved_dir, 'Environments', 'yasmarina_env.json')
+        }
+        self.files = {}
+
+        ok, status = self.valdiate()
+        if ok:
+            for name, path in self.required_files.items():
+                with open(path, 'r', encoding='utf-8') as f:
+                    self.files[name] = json.load(f)
+
+    def valdiate(self):
+        for name, path in self.required_files.items():
+            if not os.path.exists(path):
+                return (False, '{} not found'.format(path))
+        return (True, '')
+
+    def save(self):
+        for name, path in self.required_files.items():
+            with open(path, 'w', encoding='utf-8') as f:
+                json.dump(self.files[name], f, ensure_ascii=False, indent=4)
+
+def apply_simconfig_preset(sim_saved_dir, preset_name):
+    cfg_files = SimConfigFiles(sim_saved_dir)
+    ok, status = cfg_files.valdiate()
+    if not ok:
+        print(status)
+        return
+
+    presets = {
+        'default': apply_default_simconfig_preset,
+        'lightweight': apply_lightweight_simconfig_preset,
+        'a2rl': apply_a2rl_simconfig_preset
+    }
+    presets[preset_name](cfg_files)    
+
+def apply_default_simconfig_preset(cfg_files):
+    files = cfg_files.files
+    
+    print('globally enabling ROS2 and CAN')
+    files['main']['interfaces']['bEnableRos2'] = True
+    files['main']['interfaces']['bEnableCan'] = True
+
+    print('ensuring default eav24 and yasmarina are reference in main config')
+    if not 'Environments/yasmarina_env.json' in files['main']['environmentPaths']:
+        print('missing yas environment. adding')
+        print('{}'.format(files['main']['environmentPaths']))
+    if not 'Objects/Eav24_default.json' in files['main']['objectTemplatePaths']:
+        print('missing eav24. adding')
+
+    cfg_files.save()
+
+
+def apply_lightweight_simconfig_preset(cfg_files):
+    files = cfg_files.files
+    
+    cfg_files.save()
+
+def apply_a2rl_simconfig_preset(cfg_files):
+    files = cfg_files.files
+    
+    cfg_files.save()

autoverse_cli-0.4.0.dist-info/RECORD

@@ -1,28 +0,0 @@
-avrs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-avrs/app_version.py,sha256=U9S11DYP1oLycncpvTmnWvqUunUHaEDl_O6Elho4iEw,855
-avrs/argparse_help.py,sha256=EoEaohGXZXqJvs1dFEzbo9vh47CYdHdSY2Im2Ps2iFo,945
-avrs/avrs.py,sha256=3dP6YE8aB2IGN0wu_FUcRW4fch6h-b97sFcUeF0vfC0,1953
-avrs/cfg.py,sha256=9NBtPrJjVN7gj_vxlvO4wOEx3OFw4d2qQgLIVLiccD0,701
-avrs/launcher.py,sha256=OWwIQDgeIwGLgmLnCxv7RbzVfRNLxSbg3eaZLJ2K64s,7467
-avrs/launcher_util.py,sha256=X60Jd2JUXr1MmdEF0lwjUBC5gHZte9uLlSgLWOLofXc,5121
-avrs/tests.py,sha256=3JeYBjn0tRqHXERDROfzmYuW1KXeCcKur5Bw-EIegto,153
-avrs/requests/can.py,sha256=iL2Dsk-V4tm37D-F1QoauaxeQtLAbg5br7zJcoR9h0o,5295
-avrs/requests/code_booz.py,sha256=5bzT8Ra6EIwI19TqXMxkHG_llnyFgqSzTSo7yLNV9Vc,2274
-avrs/requests/demo.py,sha256=TksvKX5YmL8-FQ4h7MWwjyIwcaZQrF9vCQ20PdfgS3Q,1138
-avrs/requests/edit_environment.py,sha256=iITvLHJ4N6m-RE8dC_KnFxoTNKSjQu7ydERfQvVtb58,828
-avrs/requests/input.py,sha256=SkfVjk3LsOhYNXEwn0rcSS6kZK3g8DXoMPX8Zc9LnCo,1855
-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=3hbBAt_Kd9n-HuggIbziJ3xs-VcRfLBc2GEFSOQ-LJ4,1512
-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/teleport.py,sha256=WpnB2-Ii0FGI11EXTAHlaF5zqZIsgEyJnJ2j_w4rDFY,824
-avrs/requests/vd.py,sha256=at6oUAGY2h0OxYU6MLOi1gnxyUn6i24vL9DUAj0L880,1600
-autoverse_cli-0.4.0.dist-info/LICENSE,sha256=d4eWXho-u18HkBsX4K21uHX_bBb2UXZSrJdsb7Z_JlM,2647
-autoverse_cli-0.4.0.dist-info/METADATA,sha256=1ekzIvDf6Hwm5gthZcMYVCzcjFKRC7DIETN7cOCD4ng,3296
-autoverse_cli-0.4.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-autoverse_cli-0.4.0.dist-info/entry_points.txt,sha256=Cb9qsUyU5AKkklehCcvtfT0-N3SXbUEqvjze4iEU5kE,40
-autoverse_cli-0.4.0.dist-info/top_level.txt,sha256=-AJO2e4MCVej6hY0U84pu5NfMeMW5qaAPSMisDT5rmA,5
-autoverse_cli-0.4.0.dist-info/RECORD,,