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

avrs/requests/{edit_environment.py → environment.py}

@@ -1,10 +1,11 @@
 from avrs.requests.request import AvrsApiRequest
 
-class AvrsEditEnvironmentRequests():
+class AvrsEnvironmentRequests():
     def __init__(self, parser, cfg):
-            psr = parser.add_parser('edit-environment', help='Edits the environment')
+            psr = parser.add_parser('environment', help='Edits the environment')
             sps = psr.add_subparsers(required= True, help='')
             AvrsSetTimeOfDayRequest(sps, cfg)
+            AvrsGetEnvironmentMetaRequets(sps, cfg)
 
 
 class AvrsSetTimeOfDayRequest(AvrsApiRequest):
@@ -18,4 +19,15 @@ class AvrsSetTimeOfDayRequest(AvrsApiRequest):
         self.target_object_id = ''
         return {
             'TimeOfDay': args.tod
-        }
+        }
+
+class AvrsGetEnvironmentMetaRequets(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'GetEnvironmentMeta', '')
+        psr = parser.add_parser('get-meta', help='get metadata about the currently loaded environment')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+            self.target_object_id = ''
+            return {
+            }

avrs/requests/fault_injection.py

@@ -0,0 +1,186 @@
+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)
+        AvrsCanFaultRequest(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
+            }
+        }
+
+class AvrsCanFaultRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'FaultInjection', '')
+
+        psr = parser.add_parser(
+            'can', 
+            help='inject a can', 
+            formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            'can_type',
+            choices = ['bsu', 'badenia', 'kistler', 'all'],
+            help='what type of the can interface you wish to apply the fault to')
+
+        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': 'CanFault',
+            'duration': args.duration,
+            'bIsDropout': True,
+            'bIsFreeze': args.freeze,
+            'JsonBody': {
+                'canType': args.can_type
+            }
+        }

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 = 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/toggle_hud.py

@@ -0,0 +1,11 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsToggleHudRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ToggleHud', 'Ego')
+        psr = parser.add_parser('toggle-hud', help='toggles the HUD on or off')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+        }

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,235 @@
+import random
+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)
+        DespawnReplayVehicle(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='', 
+            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(
+            '--count',
+            type=int,
+            default=1,
+            help='the number of npcs to spawn (only works with automatic name)')
+
+        # 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 send_request(self, args):
+        for i in range(args.count):
+            self.send_http_request(args)
+
+    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'
+                            }
+                        ]
+                    }
+                })
+
+        # Create time based name if not specified
+        name = args.name
+        if name == '':
+            name = 'npc_{}'.format(random.randint(0, 100000))
+
+        return {
+            'Name': 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',
+        }
+
+class DespawnReplayVehicle(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'DespawnObject', 'Ego')
+        psr = parser.add_parser(
+            'despawn', help='despawn a replay vehicle or all replay vehicles', formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--name', 
+            default='',
+            help='name of the replay vehicle to despawn')
+
+        psr.add_argument(
+            '--all',
+            action='store_true',
+            help='if set, will despawn all replay vehicles')
+
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):
+        self.target_object_id = args.name
+        tags = ["Npc"] if args.all else []
+
+        return {
+            'tags': tags,
+            'bMatchAnyTag': True
+        }

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)