autoverse-cli 0.1.0__py3-none-any.whl

avrs/requests/can.py

@@ -0,0 +1,131 @@
+from avrs.requests.request import AvrsApiRequest
+import can
+import cantools
+import time
+import os
+import pandas as pd
+import datetime
+
+# class Can():
+#     def __init__(self, parser, cfg):
+#         psr = parser.add_parser('can', help='Peforms a variety of CAN commands')
+#         sps = psr.add_subparsers(required= True, help='sub-command of NPC')
+#         SendCan(sps, dbc)
+#         #TestCanRates(sps, cfg)
+#         LogCan(sps, dbc)  
+
+
+# class SendCan(AvrsApiRequest):
+#     def __init__(self, parser, dbc):
+#         psr = parser.add_parser('send', help='sends CAN data for given duration (seconds) with given throttle and steer percent values')
+#         psr.add_argument('duration', type=float, help='Length of time to send Can data')
+#         psr.add_argument('hertz', type=float, help = 'Frequency of Can Messages')
+#         psr.add_argument('throttle', type=float, help='throttle (in percent)')
+#         psr.add_argument('steer', type=float, help='steer (in percent)')
+#         self.dbc = dbc
+#         psr.set_defaults(func=self.send_can_values)
+
+
+#     def send_can_values(self, args):
+#         with can.interface.Bus('vcan0', bustype='socketcan') as bus:
+#             message_1 = self.dbc.get_message_by_name("HL_Msg_01")
+#             message_2 = self.dbc.get_message_by_name("HL_Msg_02")
+#             signals_1 = {
+#                 "HL_TargetThrottle": args.throttle,
+#                 "HL_TargetGear": 1,
+#                 "HL_TargetPressure_RR": 0,
+#                 "HL_TargetPressure_RL": 0,
+#                 "HL_TargetPressure_FR": 0,
+#                 "HL_TargetPressure_FL": 0,
+#                 "HL_Alive_01": 0, 
+#             }
+
+#             signals_2 = {
+#                 "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": args.steer,
+#                 "HL_PSA_ModeOfOperation": 0,
+#             }
+
+#             start_time = time.time()
+
+#             print('sending can data...')
+#             while time.time() - start_time < args.duration:
+#                 data = message_1.encode(signals_1)
+#                 msg = can.Message(arbitration_id=message_1.frame_id, data=data, is_extended_id=False)
+#                 bus.send(msg)
+
+#                 data = message_2.encode(signals_2)
+#                 msg = can.Message(arbitration_id=message_2.frame_id, data=data, is_extended_id=False)
+#                 bus.send(msg)
+#                 time.sleep(args.hertz)
+#             print('done')
+    
+
+# # class TestCanRates(AvrsApiRequest):
+# #     def __init__(self, parser, cfg):
+# #         AvrsApiRequest.__init__(self, parser, cfg, 'TestCanRates')
+# #         psr = parser.add_parser('test-rates', help='get average can message rates over given duration for all can messages on vcan0')
+# #         psr.add_argument('duration', type=float, help='Length of time to test Can rates')
+# #         psr.set_defaults(func=self.send_request)
+        
+
+# #     def get_request_body(self, args):
+# #         return {
+# #             'Duration': args.duration,
+# #         }
+    
+# class LogCan(AvrsApiRequest):
+#     def __init__(self, parser, dbc):
+#         psr = parser.add_parser('log', help='logs csv CAN data for given duration (seconds) to the given absolute file path. Will append numbers to colliding file names')
+#         psr.add_argument('duration', type=float, help='length of time to log Can data')
+#         psr.add_argument('path', help='absoulte file path')
+#         psr.set_defaults(func=self.log_can)
+#         self.dbc = dbc
+    
+#     def log_can(self, args):
+#         start_time = time.time()
+
+#         # Check and remove the existing 'messages.csv' file
+#         file_no = 1
+#         tmp_file_path = args.path
+#         print(tmp_file_path)
+#         while os.path.exists(tmp_file_path):
+#             tmp_file_path = args.path.replace('.csv', '{}.csv'.format(file_no))
+#             file_no += 1
+#         args.path = tmp_file_path
+
+#         messages_list = []
+#         databases = [self.dbc]
+#         print('logging can data...')
+        
+#         with can.interface.Bus('vcan0', bustype='socketcan') as bus:
+#             while time.time() - start_time < args.duration:
+#                 message = bus.recv()
+#                 # If a message was received
+#                 if message is not None:
+#                     for db in databases:
+#                         decoded = self.decode_message(message)
+#                         if decoded:
+#                             messages_list.append(decoded)
+#                             break
+#             df = pd.DataFrame(messages_list)
+#             df.to_csv(args.path, index=False)
+#         print('done')
+
+
+#     def decode_message(self, message):
+#         try:
+#             decoded_message = self.dbc.decode_message(message.arbitration_id, message.data)
+#             message_name = self.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 if decoding fails
+#             return None
+    
+
+        
+

avrs/requests/demo.py

@@ -0,0 +1,23 @@
+from avrs.requests.request import AvrsApiRequest
+
+class AvrsDemoRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        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('--env-type-index', default=0, type=int)
+        psr.add_argument('--weather-type-index', default=0, type=int)
+        psr.set_defaults(func=self.send_request)
+
+    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,
+            'IndexEnvironmentType': args.env_type_index,
+            'TypeIndexIndex': args.weather_type_index
+        }

avrs/requests/input.py

@@ -0,0 +1,46 @@
+from avrs.requests.request import AvrsApiRequest
+
+class InputRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        psr = parser.add_parser('user-input', help='Commands related to controlling the vehicles with controllers')
+        sps = psr.add_subparsers(required= True, help='sub-command of Input')
+        EnableInput(sps, cfg)
+        DisableInput(sps, cfg)
+        ChangeInput(sps, cfg)
+        
+class EnableInput(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'EnableInput', 'Ego')
+        psr = parser.add_parser('enable', help='Enable user input on car')
+        psr.add_argument('controller', help='type of way to control the actor', nargs = 1,
+                         choices=('keyboard', 'xbox', 'wheel', 'can'))
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+            'Controller': args.controller
+        }
+
+class DisableInput(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'DisableInput', 'Ego')
+        psr = parser.add_parser('disable', help='disable user input on car')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+        }
+
+class ChangeInput(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'ChangeInput', 'Ego')
+        psr = parser.add_parser('change', help='change the input type if input is already enabled')
+        psr.add_argument('controller', help='type of way to control the actor', nargs = 1,
+                         choices=('keyboard', 'xbox', 'wheel'))
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        return {
+            'Controller': args.controller
+        }
+

avrs/requests/log_path.py

@@ -0,0 +1,28 @@
+from avrs.requests.request import AvrsApiRequest
+
+class LogPath(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'LogPath', 'Ego')
+        psr = parser.add_parser('log-path', help='logs the path of the current vehicle so it can be used as' +
+            ' an NPC profile')
+        
+        psr.add_argument('filename', help = 'the name of the file you want')
+        psr.add_argument('time', type = float, help = 'the time in seconds you want to log the vehicle path. If you want to keep continously logging until'
+            + ' end of simulation, enter -1')
+        psr.add_argument('filepath', nargs='?', help = '(Optional) By default the csv saves in your saved folder located in the simulator.' + 
+            ' However if you would like to save to a new location, please provide an ABSOLUTE file path', default = None)
+        psr.set_defaults(func=self.send_request)
+    
+    def get_request_body(self, args):
+        if args.filepath == None:
+            return {
+                'Filename' : args.filename,
+                'Time' : args.time,
+                'AbsolutePath' : ""
+            }
+        else:
+            return {
+                'Filename' : args.filename,
+                'Time' : args.time,
+                'Path' : args.filepath
+            }

avrs/requests/move_to_landmark.py

@@ -0,0 +1,16 @@
+
+from avrs.requests.request import AvrsApiRequest
+
+class MoveToLandmarkRequest(AvrsApiRequest):
+    def __init__(self, parser, cfg):
+        AvrsApiRequest.__init__(self, parser, cfg, 'MoveToLandmark', 'Ego')
+        psr = parser.add_parser('move-to-landmark', help='command an object to move to a landmark')
+        psr.add_argument('--object-name', default='Ego', help='the name of the object to move')
+        psr.add_argument('landmark', help='the name of the landmark to move the object to')
+        psr.set_defaults(func=self.send_request)
+
+    def get_request_body(self, args):
+        self.target_object_id = args.object_name
+        return {
+            'LandmarkName': args.landmark
+        }

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

@@ -0,0 +1,45 @@
+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
+
+    def get_request(self, args):
+        return {
+            'TargetObjectId': self.target_object_id,
+            'RequestType': self.request_type,
+            'RequestBody': json.dumps(self.get_request_body(args))
+        }
+
+    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):
+        connection = http.client.HTTPConnection("localhost", 30313, timeout=2)
+        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')))