autoverse-cli 0.28.1__py3-none-any.whl

avrs/requests/npc.py

@@ -0,0 +1,289 @@
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawDescriptionHelpFormatter
+from argparse import RawTextHelpFormatter
+
+class Npc():
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('npc', help='Peforms a variety of NPC control commands')
+        sps = psr.add_subparsers(required= True, help='sub-command of NPC')
+        NpcSpawn(sps, cfg)
+        NpcDespawn(sps, cfg)
+        NpcChangeDifficulty(sps, cfg)
+        NpcStart(sps, cfg)
+        NpcStop(sps, cfg)
+        NpcSetSpeed(sps, cfg)
+        NpcChangeProfile(sps, cfg)
+        NpcTeleport(sps, cfg)
+       
+NPC_SPAWN_POSITION_HELP = '''
+spawn the NPC in a relative position or absoulte position
+'''
+
+NPC_SPAWN_PROFILE_HELP = '''
+Sets the profile of which the npc follows. Note: the profiles provided are ones Provided by Autonoma. 
+If you wish to use your own you have two options. If your custom profile
+is located in the saved folder of the simulator you can just enter the filename. 
+However if this is not the case you must enter the absolute path of the file
+Provided Profiles:
+    middleRouteYas
+    leftRouteYas
+    rightRouteYas
+    backMiddleRouteYas
+    backLeftRouteYas
+'''
+
+NPC_ROUTE_CHOICES = [
+    'middleRouteYas', 
+    'leftRouteYas', 
+    'rightRouteYas', 
+    'backMiddleRouteYas', 
+    'backLeftRouteYas', 
+    'atlNpc1', 
+    'atlNpc2', 
+    'atlNpc3', 
+    'atlNpc4', 
+    'atlNpc5'
+]
+
+class NpcSpawn(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'SpawnObject', '')
+        psr = parser.add_parser(
+            'spawn', help='spawn an NPC', formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--name', 
+            default='npc0', 
+            help='name of the npc to spawn')
+
+        psr.add_argument(
+            '--vehicle-type', 
+            default='HondaOdyssey', 
+            help='what type of vehicle to spawn as an NPC')
+
+        psr.add_argument(
+            '--position', 
+            choices=('relative', 'absolute'), 
+            default='absolute', 
+            help=NPC_SPAWN_POSITION_HELP)
+
+        psr.add_argument(
+            '--profile', 
+            default='leftRouteYas', 
+            help=NPC_SPAWN_PROFILE_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(
+            '--difficulty', 
+            type=float, 
+            default=1.0, 
+            help='the playback speed of the velocity profile, 1.0 is normal')
+
+        psr.add_argument(
+            '--enable-sensors', 
+            type=bool, 
+            default=False, 
+            help='whether to enable sensors on the NPC')
+
+        psr.add_argument(
+            '--with-view-cameras',
+            type=bool,
+            default=False,
+            help='whether to attach viewing cameras to the NPC')
+        
+        psr.set_defaults(func=self.send_request)
+    
+
+    def get_request_body(self, args):        
+        if args.profile not in NPC_ROUTE_CHOICES:
+            print(f"Warning: '{args.profile}' is not a default option, procceeding with custom file")
+        
+        npc_init_pld = {
+            'Name': args.name,
+            'Position': args.position,
+            'Profile': args.profile,
+            'Velocity' : args.velocity_type,
+            'Speed' : args.speed,
+            'Difficulty' : args.difficulty,
+            'bEnableSensors': args.enable_sensors
+        }
+
+        eav_init_pld = {
+            'VehicleCanName': 'can0'
+        }
+
+        plds = [
+            {
+                'TypeName': 'NpcInitializer',
+                'Body': npc_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 NpcDespawn(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcDespawn', 'Npc')
+        psr = parser.add_parser('despawn', help='despawn an NPC')
+        psr.add_argument('name', help = 'name of the npc to despawn')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+            'Name': args.name
+        }
+    
+
+class NpcTeleport(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcTeleport', 'Npc')
+        psr = parser.add_parser('teleport', help = 'telport an active NPC to new x,y,z location,' 
+                                + 'a location on the path will be selected closeset to this value')
+        psr.add_argument('name', help='name of npc to teleport')
+        subparsers = psr.add_subparsers(dest = "action", help='sub-command of NPC teleport')
+
+        # Define the parser for the 'vehicle' option
+        vehicle_parser = subparsers.add_parser('vehicle', help='Teleport to the vehicle to an existing car')
+
+        # Defines the parser for the 'custom' option
+        custom_parser = subparsers.add_parser('custom', help='Teleport to custom coordinates')
+        custom_parser.add_argument('x', type=float,  help='X coordinate.')
+        custom_parser.add_argument('y', type=float,  help='Y coordinate.')
+        custom_parser.add_argument('z', type=float,  help='Y coordinate.')
+        
+        psr.set_defaults(func = self.send_request)
+    
+    def get_request_body(self, args):
+        if args.action == 'vehicle':
+            print("Correct")
+            return {
+                'Name': args.name,
+                'Type': args.action,
+                'X': 0,
+                'Y': 0,
+                'Z': 0
+            }
+        else:
+            return {
+                'Name': args.name,
+                'Type': args.action,
+                'X': args.x,
+                'Y': args.y,
+                'Z ': args.z
+            }
+        
+class NpcChangeProfile(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcChangeProfile', 'Npc')
+        psr = parser.add_parser('change-path', help = 'changes the raceline of an active NPC')
+        psr.add_argument('name', help='name of npc to change the path for')
+        psr.add_argument('profile', type=str, help = 'change the profile of the NPC, the same profile constraints apply as the spawn command')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        choices =  ['middleRouteYas', 'leftRouteYas', 'rightRouteYas', 'backMiddleRouteYas', 'backLeftRouteYas', 'atlNpc1', 'atlNpc2', 'atlNpc3', 'atlNpc4', 'atlNpc5']
+        if args.profile not in choices:
+            print(f"Warning: '{args.profile}' is not a default option, procceeding with custom file")
+        return {
+            'Name': args.name,
+            'NewProfile': args.profile
+        }
+    
+class NpcChangeDifficulty(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcChangeDifficulty', 'Npc')
+        psr = parser.add_parser('change-difficulty', help = 'changes the difficulty or the the playback speed '
+                                + 'of an npc with a non-constant velocity')
+        psr.add_argument('name', help='name of npc to change the path for')
+        psr.add_argument('difficulty', type = float, help='name of npc to change the path for')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+            'Name': args.name,
+            'NewDifficulty': args.difficulty
+        }
+
+
+class NpcStart(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcStart', 'Npc')
+        psr = parser.add_parser('start', help = 'start an NPC')
+        psr.add_argument('name', help='name of npc to start')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+           'Name' : args.name
+        }
+    
+class NpcStop(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcStop', 'Npc')
+        psr = parser.add_parser('stop', help = 'stop an NPC')
+        psr.add_argument('name', help='name of npc to stop')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+            'Name' : args.name
+        }
+    
+
+class NpcSetSpeed(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'NpcSetSpeed', 'Npc')
+        psr = parser.add_parser('set-speed', help = 'sets the speed of an Anctive NPC')
+        psr.add_argument('name', help='name of npc to change the speed for')
+        psr.add_argument('speed', type = float, help='speed of the NPC')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+            'Name': args.name,
+            'Speed': args.speed
+        }
+    
+
+    
+
+
+    
+
+
+
+    
+
+
+
+

avrs/requests/race_control.py

@@ -0,0 +1,48 @@
+from avrs.requests.request import AvrsApiRequest
+class AvrsRaceControlRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'RaceControl', 'Ego')
+        psr = parser.add_parser('race-control', help='send different flags to the race control')
+        self.sector_number = 3  # Assuming there are 3 sectors; adjust as necessary, constant for now
+
+        psr.add_argument(
+            '--session-type', 
+            type=int, 
+            default=-1,
+            help='the id of the session type to set')
+
+        psr.add_argument(
+            '--track-flag', 
+            type=int, 
+            default=-1,
+            help='the id of the track flag to set')
+
+        psr.add_argument(
+            '--car-flag', 
+            type=int, 
+            default=-1,
+            help='the id of the car flag to set')
+        
+        psr.add_argument(
+            '--sector-flag',
+            nargs=self.sector_number, 
+            type=int,
+            default=[-1, -1, -1],
+            help='the ids of the sector flags to set, provide 3 values for sector 1, sector 2 and sector 3 in that order')
+
+        psr.add_argument(
+            '--object-name', 
+            default='Ego', 
+            help='the name of the car to set flags on')
+
+
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return {
+            'sessionType': args.session_type,
+            'trackFlag': args.track_flag,
+            'carFlag': args.car_flag,
+            'sectorFlag': args.sector_flag
+        }

avrs/requests/request.py

@@ -0,0 +1,61 @@
+import socket
+import json
+import os
+import os.path
+import multiprocessing
+import time
+import sys
+import http.client
+
+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
+        self.cfg = cfg
+
+    def get_request(self, args):
+        body = self.get_request_body(args)
+        return {
+            'TargetObjectId': self.target_object_id,
+            'RequestType': self.request_type,
+            'bVerboseResponse': args.verbose or self.verbose,
+            'RequestBody': body
+        }
+
+    def get_request_body(self, args):
+        return '{}'
+
+    def send_request(self, args):
+        #self.send_tcp_request(args)
+        self.send_http_request(args)
+
+    def send_tcp_request(self, args):
+        pass
+        # s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        # s.connect((self.ip, self.port))
+        # s.send(json.dumps(self.get_request(args)).encode('utf-8'))
+        # response = s.recv(self.buffer_size).decode('utf-8')
+        # print('{}'.format(response))
+
+    def send_http_request(self, args):
+
+        sim_address = 'localhost'
+        if 'sim_address' in self.cfg:
+            sim_address = self.cfg['sim_address']
+        connection_addr = os.environ.get('AVRS_SIM_ADDRESS', sim_address)
+
+        sim_port = 30313
+        if 'sim_api_port' in self.cfg:
+            sim_port = self.cfg['sim_api_port']
+
+        if args.verbose:
+            print('sending request to: {}:{}'.format(connection_addr, sim_port))
+        connection = http.client.HTTPConnection(connection_addr, sim_port, timeout=10)
+        headers = {'Content-type': 'application/json'}
+        body = json.dumps(self.get_request(args)).encode('utf-8')
+        connection.request('POST', '/post', body, headers)
+        response = connection.getresponse()
+        if response.status != 200:
+            print('response had status code {}'.format(response))
+        print('{}'.format(response.read().decode('utf-8')))

avrs/requests/reset_to_track.py

@@ -0,0 +1,21 @@
+from avrs.requests.request import AvrsApiRequest
+
+class ResetToTrack(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ResetToTrack', 'Ego')
+        psr = parser.add_parser(
+            'reset-to-track', 
+            help='moves the car to the closest point on track pointing down track')
+
+        psr.add_argument(
+            '--object-name',
+            default='ego',
+            help='the simulated object to reset to track')
+
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return {
+            
+        }

avrs/requests/rest_request.py

@@ -0,0 +1,45 @@
+import socket
+import json
+import os
+import os.path
+import multiprocessing
+import time
+import sys
+import http.client
+
+# the new API request
+
+class AvrsRestApiRequest:
+    def __init__(self, parser, cfg, endpoint, method):
+        self.endpoint = endpoint
+        self.method = method
+        self.verbose = False
+        self.cfg = cfg
+
+    def get_request_body(self, args):
+        return {}
+
+    def get_request_params(self, args):
+        return {}
+
+    def send_request(self, args):
+
+        sim_address = '0.0.0.0'
+        # if 'sim_address' in self.cfg:
+        #     sim_address = self.cfg['sim_address']
+        # connection_addr = os.environ.get('AVRS_SIM_ADDRESS', sim_address)
+
+        sim_port = 51111
+        # if 'sim_api_port' in self.cfg:
+        #     sim_port = self.cfg['sim_api_port']
+
+        if args.verbose:
+            print('sending request to: {}:{}'.format(sim_address, sim_port))
+        connection = http.client.HTTPConnection(sim_address, sim_port, timeout=10)
+        headers = {'Content-type': 'application/json'}
+        body = json.dumps(self.get_request_body(args)).encode('utf-8')
+        connection.request(self.method, self.endpoint, body, headers)
+        response = connection.getresponse()
+        if response.status != 200:
+            print('response had status code {}'.format(response.status))
+        print('{}'.format(response.read().decode('utf-8')))

avrs/requests/restart.py

@@ -0,0 +1,12 @@
+from avrs.requests.request import AvrsApiRequest
+
+class Restart(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'RestartSimulation', 0)
+        psr = parser.add_parser('restart', help='command to restart the entire simulator')
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        return {
+            
+        }

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/spawn_object.py

@@ -0,0 +1,44 @@
+from avrs.requests.request import AvrsApiRequest
+from argparse import RawTextHelpFormatter
+
+SPAWN_OBJECT_HELP = '''
+spawn an object with the specified configuration, optionally overriding its name
+'''
+
+class AvrsSpawnObjectRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'SpawnObject', 0)
+        psr = parser.add_parser('spawn-object', help=SPAWN_OBJECT_HELP, formatter_class=RawTextHelpFormatter)
+
+        psr.add_argument(
+            '--object-type',
+            default='Eav24',
+            help='the type of object to spawn')
+
+        psr.add_argument(
+            'spec',
+            help='the specialization of the object (eg eav24_mv0)')
+
+        psr.add_argument(
+            '--name-override',
+            default='',
+            help='if not empty, will override the name given to the spawned object')
+
+        psr.add_argument(
+            'spawn_landmark',
+            help='what landmark to spawn at (eg MvStart0, MvStart1, MvStart2, or MvStart3)')
+
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+
+        return {
+            'name': args.name_override,
+            'type': args.object_type,
+            'spec': args.spec,
+            'bUseStoredInitializer': True,
+            'location': {},
+            'rotation': {},
+            'landmark': args.spawn_landmark,
+            'payloads': []
+        }

avrs/requests/teleport.py

@@ -0,0 +1,40 @@
+from avrs.requests.request import AvrsApiRequest
+
+class Teleport(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'Teleport', "Ego")
+        
+        psr = parser.add_parser('teleport', 
+            help='Teleports the car to the given x,y,z in either NED or LLA.')
+
+        psr.add_argument('x', type=float, 
+            help='new x position (NED meters) or latitude (if frame is set to LLA)')
+
+        psr.add_argument('y', type=float, 
+            help='new y position (NED meters) or longitude (if frame is set to LLA)')
+
+        psr.add_argument('z', type=float, 
+            help='new z position (NED meters) or altitude (if frame is set to LLA)')
+
+        psr.add_argument('--yaw', type=float, default=0.0, 
+            help='the yaw in degrees (0 north, + CW) to apply post teleport')
+
+        psr.add_argument('--frame', choices=['LLA', 'ned'], default='ned', help='LLA or NED coordinate system.')
+
+        psr.add_argument(
+            '--object-name',
+            default='ego',
+            help='the simulated object to teleport')
+
+        psr.set_defaults(func=self.send_request)
+
+
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return { 
+            "X": args.x,
+            "Y": args.y,
+            "Z": args.z,
+            "yaw": args.yaw,
+            "NavFrame": args.frame 
+        }

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/vd.py

@@ -0,0 +1,64 @@
+from avrs.requests.request import AvrsApiRequest
+
+class Vd():
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('vd', help='Vehicle dynamic options')
+        sps = psr.add_subparsers(required= True, help='sub-command of vd')
+        SetFrictionModifier(sps, cfg)
+        GetFrictionModifier(sps, cfg)
+        #SlipModel(sps, cfg)
+
+class SetFrictionModifier(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'SetFrictionModifiers', 'Ego')
+        psr = parser.add_parser('set-friction-modifier', help='Change the amount of grip the car has.' 
+            + '0 is no grip and higher values will prevent spinning')
+        psr.add_argument('modifier', type = float, help = "Modified grip value")
+        psr.add_argument('tires', help = "Tires to apply the modifier to", 
+            choices=("FL", "FR", "RL", "RR", "F", "R", "All"))
+
+        psr.add_argument(
+            '--object-name',
+            default='ego',
+            help='the simulated object to modify the friction for')
+        
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return {
+            'NewModifier': args.modifier,
+            'Tires': args.tires
+        }
+    
+class GetFrictionModifier(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'GetFrictionModifiers', 'Ego')
+        psr = parser.add_parser('get-friction-modifier', help='Get the amount of grip the car has.')
+        psr.add_argument('tires', help = "Tires to get the grip value from", 
+            choices=("FL", "FR", "RL", "RR", "F", "R", "All"))
+
+        psr.add_argument(
+            '--object-name',
+            default='ego',
+            help='the simulated object to get the friction from')
+
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return {
+            'Tires': args.tires
+        }
+    
+# class SlipModel(AvrsApiRequest):
+#     def __init__(self, parser, cfg):
+#         AvrsApiRequest.__init__(self, parser, cfg, 'SlipModel', 'Ego')
+#         psr = parser.add_parser('slip-model', help='Change the tire slip model to be pure slip only or combined slip')
+#         psr.add_argument('slip', choices = ['pure-slip, combined-slip'], help = 'type of slip')
+#         psr.set_defaults(func=self.send_request)
+    
+#     def get_request_body(self, args):
+#         return {
+#             'Modifier Value': args.slip
+#         }