lasvsim-openapi 0.1.8__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- lasvsim_openapi/__init__.py +2 -0
- lasvsim_openapi/client.py +32 -0
- lasvsim_openapi/http_client.py +58 -0
- lasvsim_openapi/main.py +418 -0
- lasvsim_openapi/process_task.py +43 -0
- lasvsim_openapi/process_task_model.py +39 -0
- lasvsim_openapi/qxmap_model.py +728 -0
- lasvsim_openapi/request_model.py +25 -0
- lasvsim_openapi/resources.py +20 -0
- lasvsim_openapi/response_model.py +971 -0
- lasvsim_openapi/sim_record.py +63 -0
- lasvsim_openapi/sim_record_model.py +282 -0
- lasvsim_openapi/simulator.py +439 -0
- lasvsim_openapi/train_task.py +26 -0
- lasvsim_openapi-0.1.8.dist-info/METADATA +154 -0
- lasvsim_openapi-0.1.8.dist-info/RECORD +34 -0
- lasvsim_openapi-0.1.8.dist-info/WHEEL +5 -0
- lasvsim_openapi-0.1.8.dist-info/top_level.txt +1 -0
- qianxing_openapi/__init__.py +2 -0
- qianxing_openapi/client.py +31 -0
- qianxing_openapi/http_client.py +58 -0
- qianxing_openapi/main.py +418 -0
- qianxing_openapi/process_task.py +43 -0
- qianxing_openapi/process_task_model.py +39 -0
- qianxing_openapi/qxmap_model.py +728 -0
- qianxing_openapi/request_model.py +25 -0
- qianxing_openapi/request_struct.py +25 -0
- qianxing_openapi/resources.py +20 -0
- qianxing_openapi/response_model.py +971 -0
- qianxing_openapi/response_struct.py +898 -0
- qianxing_openapi/sim_record.py +63 -0
- qianxing_openapi/sim_record_model.py +282 -0
- qianxing_openapi/simulator.py +430 -0
- qianxing_openapi/train_task.py +26 -0
|
@@ -0,0 +1,971 @@
|
|
|
1
|
+
from dataclasses import dataclass
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
# -----------------------------地图相关结构--------------------------------
|
|
5
|
+
@dataclass
|
|
6
|
+
class Movement:
|
|
7
|
+
map_id: int = None
|
|
8
|
+
movement_id: str = None
|
|
9
|
+
upstream_link_id: str = None
|
|
10
|
+
downstream_link_id: str = None
|
|
11
|
+
junction_id: str = None
|
|
12
|
+
flow_direction: str = None
|
|
13
|
+
|
|
14
|
+
def __init__(self, data: dict) -> None:
|
|
15
|
+
if data == None:
|
|
16
|
+
return
|
|
17
|
+
|
|
18
|
+
self.__dict__ = data
|
|
19
|
+
|
|
20
|
+
|
|
21
|
+
@dataclass
|
|
22
|
+
class Point:
|
|
23
|
+
x: float = None
|
|
24
|
+
y: float = None
|
|
25
|
+
z: float = 0
|
|
26
|
+
|
|
27
|
+
def __init__(self, data: dict) -> None:
|
|
28
|
+
if data == None:
|
|
29
|
+
return
|
|
30
|
+
|
|
31
|
+
self.__dict__ = data
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
@dataclass
|
|
35
|
+
class Position:
|
|
36
|
+
point: Point = None
|
|
37
|
+
phi: float = None
|
|
38
|
+
lane_id: str = None
|
|
39
|
+
link_id: str = None
|
|
40
|
+
junction_id: str = None
|
|
41
|
+
segment_id: str = None
|
|
42
|
+
dis_to_lane_end: float = None
|
|
43
|
+
position_type: int = None
|
|
44
|
+
|
|
45
|
+
def __init__(self, data: dict) -> None:
|
|
46
|
+
if data == None:
|
|
47
|
+
return
|
|
48
|
+
point = data.pop("point", None)
|
|
49
|
+
|
|
50
|
+
self.__dict__ = data
|
|
51
|
+
self.point = None if point == None else Point(point)
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
@dataclass
|
|
55
|
+
class NavigationInfo:
|
|
56
|
+
link_nav: list[str] = None
|
|
57
|
+
destination: Position = None
|
|
58
|
+
|
|
59
|
+
def __init__(self, data: dict) -> None:
|
|
60
|
+
if data == None:
|
|
61
|
+
return
|
|
62
|
+
destination = data.pop("destination", None)
|
|
63
|
+
|
|
64
|
+
self.__dict__ = data
|
|
65
|
+
self.destination = None if destination == None else Position(destination)
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
@dataclass
|
|
69
|
+
class LaneNav:
|
|
70
|
+
nav: dict[int, str] = None
|
|
71
|
+
|
|
72
|
+
def __init__(self, data: dict) -> None:
|
|
73
|
+
if data == None:
|
|
74
|
+
return
|
|
75
|
+
self.__dict__ = data
|
|
76
|
+
|
|
77
|
+
|
|
78
|
+
@dataclass
|
|
79
|
+
class ReferenceLine:
|
|
80
|
+
lane_ids: list[str] = None
|
|
81
|
+
lane_types: list[str] = None
|
|
82
|
+
points: list[Point] = None
|
|
83
|
+
lane_idxes: list[int] = None
|
|
84
|
+
opposite: bool = None
|
|
85
|
+
|
|
86
|
+
def __init__(self, data: dict) -> None:
|
|
87
|
+
if data == None:
|
|
88
|
+
return
|
|
89
|
+
points = data.pop("points", None)
|
|
90
|
+
|
|
91
|
+
self.__dict__ = data
|
|
92
|
+
self.points = None if points == None else [Point(point) for point in points]
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
@dataclass
|
|
96
|
+
class Header:
|
|
97
|
+
north: float = None
|
|
98
|
+
south: float = None
|
|
99
|
+
east: float = None
|
|
100
|
+
west: float = None
|
|
101
|
+
center_point: Point = None
|
|
102
|
+
version: str = None
|
|
103
|
+
zone: float = None
|
|
104
|
+
use_bias: bool = None
|
|
105
|
+
|
|
106
|
+
def __init__(self, data: dict) -> None:
|
|
107
|
+
if data == None:
|
|
108
|
+
return
|
|
109
|
+
center_point = data.pop("center_point", None)
|
|
110
|
+
|
|
111
|
+
self.__dict__ = data
|
|
112
|
+
self.center_point = None if center_point == None else Point(center_point)
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
@dataclass
|
|
116
|
+
class Junction:
|
|
117
|
+
map_id: int = None
|
|
118
|
+
junction_id: str = None
|
|
119
|
+
name: str = None
|
|
120
|
+
type: str = None
|
|
121
|
+
link_ids: list[str] = None
|
|
122
|
+
shape: list[Point] = None
|
|
123
|
+
traffic_light_id: str = None
|
|
124
|
+
in_segment_ids: list[str] = None
|
|
125
|
+
out_segment_ids: list[str] = None
|
|
126
|
+
|
|
127
|
+
def __init__(self, data: dict) -> None:
|
|
128
|
+
if data == None:
|
|
129
|
+
return
|
|
130
|
+
shape = data.pop("shape", None)
|
|
131
|
+
|
|
132
|
+
self.__dict__ = data
|
|
133
|
+
self.shape = None if shape == None else [Point(point) for point in shape]
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
@dataclass
|
|
137
|
+
class Segment:
|
|
138
|
+
map_id: int = None
|
|
139
|
+
segment_id: str = None
|
|
140
|
+
name: str = None
|
|
141
|
+
ordered_link_ids: list[str] = None
|
|
142
|
+
start_junction_id: str = None
|
|
143
|
+
end_junction_id: str = None
|
|
144
|
+
length: float = None
|
|
145
|
+
heading: float = None
|
|
146
|
+
traffic_light_pole_id: str = None
|
|
147
|
+
s_offset: float = None
|
|
148
|
+
|
|
149
|
+
def __init__(self, data: dict) -> None:
|
|
150
|
+
if data == None:
|
|
151
|
+
return
|
|
152
|
+
self.__dict__ = data
|
|
153
|
+
|
|
154
|
+
|
|
155
|
+
@dataclass
|
|
156
|
+
class Link:
|
|
157
|
+
map_id: int = None
|
|
158
|
+
link_id: str = None
|
|
159
|
+
pair_id: str = None
|
|
160
|
+
width: float = None
|
|
161
|
+
ordered_lane_ids: list[str] = None
|
|
162
|
+
lane_num: int = None
|
|
163
|
+
start_point: Point = None
|
|
164
|
+
end_point: Point = None
|
|
165
|
+
gradient: float = None
|
|
166
|
+
segment_id: str = None
|
|
167
|
+
length: float = None
|
|
168
|
+
type: str = None
|
|
169
|
+
heading: float = None
|
|
170
|
+
link_order: int = None
|
|
171
|
+
left_boundary: list[Point] = None
|
|
172
|
+
right_boundary: list[Point] = None
|
|
173
|
+
road_type: str = None
|
|
174
|
+
s_offset: float = None
|
|
175
|
+
|
|
176
|
+
def __init__(self, data: dict) -> None:
|
|
177
|
+
if data == None:
|
|
178
|
+
return
|
|
179
|
+
start_point = data.pop("start_point", None)
|
|
180
|
+
end_point = data.pop("end_point", None)
|
|
181
|
+
left_boundary = data.pop("left_boundary", None)
|
|
182
|
+
right_boundary = data.pop("right_boundary", None)
|
|
183
|
+
|
|
184
|
+
self.__dict__ = data
|
|
185
|
+
self.start_point = None if start_point == None else Point(start_point)
|
|
186
|
+
self.end_point = None if end_point == None else Point(end_point)
|
|
187
|
+
self.left_boundary = (
|
|
188
|
+
None if left_boundary == None else [Point(point) for point in left_boundary]
|
|
189
|
+
)
|
|
190
|
+
self.right_boundary = (
|
|
191
|
+
None
|
|
192
|
+
if right_boundary == None
|
|
193
|
+
else [Point(point) for point in right_boundary]
|
|
194
|
+
)
|
|
195
|
+
|
|
196
|
+
|
|
197
|
+
@dataclass
|
|
198
|
+
class DirectionPoint:
|
|
199
|
+
point: Point = None
|
|
200
|
+
pitching: float = None
|
|
201
|
+
heading: float = None
|
|
202
|
+
rolling: float = None
|
|
203
|
+
|
|
204
|
+
def __init__(self, data: dict) -> None:
|
|
205
|
+
if data == None:
|
|
206
|
+
return
|
|
207
|
+
point = data.pop("point", None)
|
|
208
|
+
|
|
209
|
+
self.__dict__ = data
|
|
210
|
+
self.point = None if point == None else Point(point)
|
|
211
|
+
|
|
212
|
+
|
|
213
|
+
@dataclass
|
|
214
|
+
class Turn:
|
|
215
|
+
direction_point: DirectionPoint = None
|
|
216
|
+
turn: str = None
|
|
217
|
+
turn_mapping: dict[str, str] = None
|
|
218
|
+
|
|
219
|
+
def __init__(self, data: dict) -> None:
|
|
220
|
+
if data == None:
|
|
221
|
+
return
|
|
222
|
+
direction_point = data.pop("direction_point", None)
|
|
223
|
+
|
|
224
|
+
self.__dict__ = data
|
|
225
|
+
self.direction_point = (
|
|
226
|
+
None if direction_point == None else DirectionPoint(direction_point)
|
|
227
|
+
)
|
|
228
|
+
|
|
229
|
+
|
|
230
|
+
@dataclass
|
|
231
|
+
class Speed:
|
|
232
|
+
s: float = None
|
|
233
|
+
length: float = None
|
|
234
|
+
value: float = None
|
|
235
|
+
uint: str = None
|
|
236
|
+
source: str = None
|
|
237
|
+
|
|
238
|
+
def __init__(self, data: dict) -> None:
|
|
239
|
+
if data == None:
|
|
240
|
+
return
|
|
241
|
+
self.__dict__ = data
|
|
242
|
+
|
|
243
|
+
|
|
244
|
+
@dataclass
|
|
245
|
+
class LaneMarkAttribution:
|
|
246
|
+
length: float = None
|
|
247
|
+
s: float = None
|
|
248
|
+
start_index: int = None
|
|
249
|
+
end_index: int = None
|
|
250
|
+
style: str = None
|
|
251
|
+
color: str = None
|
|
252
|
+
width: float = None
|
|
253
|
+
|
|
254
|
+
def __init__(self, data: dict) -> None:
|
|
255
|
+
if data == None:
|
|
256
|
+
return
|
|
257
|
+
self.__dict__ = data
|
|
258
|
+
|
|
259
|
+
|
|
260
|
+
@dataclass
|
|
261
|
+
class LaneMark:
|
|
262
|
+
shape: list[Point] = None
|
|
263
|
+
lane_mark_attrs: list[LaneMarkAttribution] = None
|
|
264
|
+
|
|
265
|
+
def __init__(self, data: dict) -> None:
|
|
266
|
+
if data == None:
|
|
267
|
+
return
|
|
268
|
+
shape = data.pop("shape", None)
|
|
269
|
+
lane_mark_attrs = data.pop("lane_mark_attrs", None)
|
|
270
|
+
|
|
271
|
+
self.__dict__ = data
|
|
272
|
+
self.shape = None if shape == None else [Point(point) for point in shape]
|
|
273
|
+
self.lane_mark_attrs = (
|
|
274
|
+
None
|
|
275
|
+
if lane_mark_attrs == None
|
|
276
|
+
else [LaneMarkAttribution(la) for la in lane_mark_attrs]
|
|
277
|
+
)
|
|
278
|
+
|
|
279
|
+
|
|
280
|
+
@dataclass
|
|
281
|
+
class Lane:
|
|
282
|
+
map_id: int = None
|
|
283
|
+
lane_id: str = None
|
|
284
|
+
type: str = None
|
|
285
|
+
lane_offset: int = None
|
|
286
|
+
link_id: str = None
|
|
287
|
+
turn: Turn = None
|
|
288
|
+
speeds: list[Speed] = None
|
|
289
|
+
stopline_id: str = None
|
|
290
|
+
width: float = None
|
|
291
|
+
center_line: list[Point] = None
|
|
292
|
+
connect_link_ids: list[str] = None
|
|
293
|
+
left_lane_mark: LaneMark = None
|
|
294
|
+
right_lane_mark: LaneMark = None
|
|
295
|
+
upstream_link_ids: list[str] = None
|
|
296
|
+
downstream_link_ids: list[str] = None
|
|
297
|
+
cut_s_list: list[float] = None
|
|
298
|
+
length: float = None
|
|
299
|
+
|
|
300
|
+
def __init__(self, data: dict) -> None:
|
|
301
|
+
if data == None:
|
|
302
|
+
return
|
|
303
|
+
turn = data.pop("turn", None)
|
|
304
|
+
speeds = data.pop("speeds", None)
|
|
305
|
+
center_line = data.pop("center_line", None)
|
|
306
|
+
left_lane_mark = data.pop("left_lane_mark", None)
|
|
307
|
+
right_lane_mark = data.pop("right_lane_mark", None)
|
|
308
|
+
|
|
309
|
+
self.__dict__ = data
|
|
310
|
+
self.turn = None if turn == None else Turn(turn)
|
|
311
|
+
self.speeds = None if speeds == None else [Speed(speed) for speed in speeds]
|
|
312
|
+
self.center_line = (
|
|
313
|
+
None if center_line == None else [Point(point) for point in center_line]
|
|
314
|
+
)
|
|
315
|
+
self.left_lane_mark = (
|
|
316
|
+
None if left_lane_mark == None else LaneMark(left_lane_mark)
|
|
317
|
+
)
|
|
318
|
+
self.right_lane_mark = (
|
|
319
|
+
None if right_lane_mark == None else LaneMark(right_lane_mark)
|
|
320
|
+
)
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
@dataclass
|
|
324
|
+
class Turn:
|
|
325
|
+
direction_point: DirectionPoint = None
|
|
326
|
+
turn: str = None
|
|
327
|
+
turn_mapping: dict[str, str] = None
|
|
328
|
+
|
|
329
|
+
def __init__(self, data: dict) -> None:
|
|
330
|
+
if data == None:
|
|
331
|
+
return
|
|
332
|
+
direction_point = data.pop("direction_point", None)
|
|
333
|
+
|
|
334
|
+
self.__dict__ = data
|
|
335
|
+
self.direction_point = (
|
|
336
|
+
None if direction_point == None else DirectionPoint(direction_point)
|
|
337
|
+
)
|
|
338
|
+
|
|
339
|
+
|
|
340
|
+
@dataclass
|
|
341
|
+
class Crosswalk:
|
|
342
|
+
map_id: int = None
|
|
343
|
+
crosswalk_id: str = None
|
|
344
|
+
heading: float = None
|
|
345
|
+
shape: list[Point] = None
|
|
346
|
+
|
|
347
|
+
def __init__(self, data: dict) -> None:
|
|
348
|
+
if data == None:
|
|
349
|
+
return
|
|
350
|
+
shape = data.pop("shape", None)
|
|
351
|
+
|
|
352
|
+
self.__dict__ = data
|
|
353
|
+
self.shape = None if shape == None else [Point(point) for point in shape]
|
|
354
|
+
|
|
355
|
+
|
|
356
|
+
@dataclass
|
|
357
|
+
class Stopline:
|
|
358
|
+
map_id: int = None
|
|
359
|
+
stopline_id: str = None
|
|
360
|
+
shape: list[Point] = None
|
|
361
|
+
|
|
362
|
+
def __init__(self, data: dict) -> None:
|
|
363
|
+
if data == None:
|
|
364
|
+
return
|
|
365
|
+
shape = data.pop("shape", None)
|
|
366
|
+
|
|
367
|
+
self.__dict__ = data
|
|
368
|
+
self.shape = None if shape == None else [Point(point) for point in shape]
|
|
369
|
+
|
|
370
|
+
|
|
371
|
+
@dataclass
|
|
372
|
+
class TrafficLight_MovementSignal_SignalOfGreen:
|
|
373
|
+
green_start: int = None
|
|
374
|
+
green_duration: int = None
|
|
375
|
+
yellow: int = None
|
|
376
|
+
redClean: int = None
|
|
377
|
+
|
|
378
|
+
def __init__(self, data: dict) -> None:
|
|
379
|
+
if data == None:
|
|
380
|
+
return
|
|
381
|
+
self.__dict__ = data
|
|
382
|
+
|
|
383
|
+
|
|
384
|
+
@dataclass
|
|
385
|
+
class TrafficLight_MovementSignal:
|
|
386
|
+
movement_id: str = None
|
|
387
|
+
traffic_light_pole_id: str = None
|
|
388
|
+
signal_of_green: list[TrafficLight_MovementSignal_SignalOfGreen] = None
|
|
389
|
+
|
|
390
|
+
def __init__(self, data: dict) -> None:
|
|
391
|
+
if data == None:
|
|
392
|
+
return
|
|
393
|
+
signal_of_green = data.pop("signal_of_green", None)
|
|
394
|
+
|
|
395
|
+
self.__dict__ = data
|
|
396
|
+
self.signal_of_green = (
|
|
397
|
+
None
|
|
398
|
+
if signal_of_green == None
|
|
399
|
+
else [
|
|
400
|
+
TrafficLight_MovementSignal_SignalOfGreen(signal)
|
|
401
|
+
for signal in signal_of_green
|
|
402
|
+
]
|
|
403
|
+
)
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
@dataclass
|
|
407
|
+
class TrafficLight:
|
|
408
|
+
map_id: int = None
|
|
409
|
+
traffic_light_id: str = None
|
|
410
|
+
junction_id: str = None
|
|
411
|
+
cycle: int = None
|
|
412
|
+
offset: int = None
|
|
413
|
+
is_yellow: bool = None
|
|
414
|
+
movement_signals: dict[str, TrafficLight_MovementSignal] = None
|
|
415
|
+
|
|
416
|
+
def __init__(self, data: dict) -> None:
|
|
417
|
+
if data == None:
|
|
418
|
+
return
|
|
419
|
+
movement_signals = data.pop("movement_signals", None)
|
|
420
|
+
|
|
421
|
+
self.__dict__ = data
|
|
422
|
+
self.movement_signals = (
|
|
423
|
+
None
|
|
424
|
+
if movement_signals == None
|
|
425
|
+
else {
|
|
426
|
+
key: TrafficLight_MovementSignal(value)
|
|
427
|
+
for key, value in movement_signals
|
|
428
|
+
}
|
|
429
|
+
)
|
|
430
|
+
|
|
431
|
+
|
|
432
|
+
@dataclass
|
|
433
|
+
class TrafficSign:
|
|
434
|
+
map_id: int = None
|
|
435
|
+
traffic_sign_id: str = None
|
|
436
|
+
type: str = None
|
|
437
|
+
direction_point: DirectionPoint = None
|
|
438
|
+
|
|
439
|
+
def __init__(self, data: dict) -> None:
|
|
440
|
+
if data == None:
|
|
441
|
+
return
|
|
442
|
+
direction_point = data.pop("direction_point", None)
|
|
443
|
+
|
|
444
|
+
self.__dict__ = data
|
|
445
|
+
self.direction_point = (
|
|
446
|
+
None if direction_point == None else DirectionPoint(direction_point)
|
|
447
|
+
)
|
|
448
|
+
|
|
449
|
+
|
|
450
|
+
@dataclass
|
|
451
|
+
class Connection:
|
|
452
|
+
map_id: int = None
|
|
453
|
+
connection_id: str = None
|
|
454
|
+
junction_id: str = None
|
|
455
|
+
movement_id: str = None
|
|
456
|
+
upstream_lane_id: str = None
|
|
457
|
+
downstream_lane_id: str = None
|
|
458
|
+
path: list[Point] = None
|
|
459
|
+
flow_direction: str = None
|
|
460
|
+
upstream_link_id: str = None
|
|
461
|
+
downstream_link_id: str = None
|
|
462
|
+
type: str = None
|
|
463
|
+
|
|
464
|
+
def __init__(self, data: dict) -> None:
|
|
465
|
+
if data == None:
|
|
466
|
+
return
|
|
467
|
+
path = data.pop("path", None)
|
|
468
|
+
|
|
469
|
+
self.__dict__ = data
|
|
470
|
+
self.path = None if path == None else [Point(point) for point in path]
|
|
471
|
+
|
|
472
|
+
|
|
473
|
+
# -------------------------车辆(物体)参数相关结构------------------------------------
|
|
474
|
+
@dataclass
|
|
475
|
+
class ObjBaseInfo:
|
|
476
|
+
length: int = None
|
|
477
|
+
width: int = None
|
|
478
|
+
height: int = None
|
|
479
|
+
weight: int = None
|
|
480
|
+
|
|
481
|
+
def __init__(self, data: dict):
|
|
482
|
+
if data == None:
|
|
483
|
+
return
|
|
484
|
+
self.__dict__ = data
|
|
485
|
+
|
|
486
|
+
|
|
487
|
+
@dataclass
|
|
488
|
+
class DynamicInfo:
|
|
489
|
+
front_wheel_stiffness: float = None
|
|
490
|
+
rear_wheel_stiffness: float = None
|
|
491
|
+
front_axle_to_center: float = None
|
|
492
|
+
rear_axle_to_center: float = None
|
|
493
|
+
yaw_moment_of_inertia: float = None
|
|
494
|
+
|
|
495
|
+
def __init__(self, data: dict):
|
|
496
|
+
if data == None:
|
|
497
|
+
return
|
|
498
|
+
self.__dict__ = data
|
|
499
|
+
|
|
500
|
+
|
|
501
|
+
@dataclass
|
|
502
|
+
class ObjMovingInfo:
|
|
503
|
+
u: float = None
|
|
504
|
+
u_acc: float = None
|
|
505
|
+
v: float = None
|
|
506
|
+
v_acc: float = None
|
|
507
|
+
w: float = None
|
|
508
|
+
w_acc: float = None
|
|
509
|
+
|
|
510
|
+
def __init__(self, data: dict):
|
|
511
|
+
if data == None:
|
|
512
|
+
return
|
|
513
|
+
self.__dict__ = data
|
|
514
|
+
|
|
515
|
+
|
|
516
|
+
@dataclass
|
|
517
|
+
class ControlInfo:
|
|
518
|
+
ste_wheel: float = None # 方向盘转角[逆时针为正]
|
|
519
|
+
lon_acc: float = None # 纵向加速度[m/s^2]
|
|
520
|
+
fl_torque: float = None # 左前轮扭矩[N*m]
|
|
521
|
+
fr_torque: float = None # 右前轮扭矩[N*m]
|
|
522
|
+
rl_torque: float = None # 左后轮扭矩[N*m]
|
|
523
|
+
rr_torque: float = None # 右后轮扭矩[N*m]
|
|
524
|
+
|
|
525
|
+
def __init__(self, data: dict):
|
|
526
|
+
if data == None:
|
|
527
|
+
return
|
|
528
|
+
self.__dict__ = data
|
|
529
|
+
|
|
530
|
+
|
|
531
|
+
# -------------------------------------------------------------
|
|
532
|
+
@dataclass
|
|
533
|
+
class StepRes(object):
|
|
534
|
+
code: int = None
|
|
535
|
+
message: str = None
|
|
536
|
+
|
|
537
|
+
def __init__(self, data: dict) -> None:
|
|
538
|
+
if data == None:
|
|
539
|
+
return
|
|
540
|
+
self.__dict__ = data
|
|
541
|
+
|
|
542
|
+
|
|
543
|
+
@dataclass
|
|
544
|
+
class StopRes(object):
|
|
545
|
+
def __init__(self, data: dict) -> None:
|
|
546
|
+
if data == None:
|
|
547
|
+
return
|
|
548
|
+
self.__dict__ = data
|
|
549
|
+
|
|
550
|
+
|
|
551
|
+
@dataclass
|
|
552
|
+
class ResetRes(object):
|
|
553
|
+
def __init__(self, data: dict) -> None:
|
|
554
|
+
if data == None:
|
|
555
|
+
return
|
|
556
|
+
self.__dict__ = data
|
|
557
|
+
|
|
558
|
+
|
|
559
|
+
@dataclass
|
|
560
|
+
class GetCurrentStageRes(object):
|
|
561
|
+
movement_ids: list[str] = None
|
|
562
|
+
countdown: int = None
|
|
563
|
+
|
|
564
|
+
def __init__(self, data: dict) -> None:
|
|
565
|
+
if data == None:
|
|
566
|
+
return
|
|
567
|
+
self.__dict__ = data
|
|
568
|
+
|
|
569
|
+
|
|
570
|
+
@dataclass
|
|
571
|
+
class GetMovementSignalRes(object):
|
|
572
|
+
current_signal: int = None
|
|
573
|
+
countdown: int = None
|
|
574
|
+
|
|
575
|
+
def __init__(self, data: dict) -> None:
|
|
576
|
+
if data == None:
|
|
577
|
+
return
|
|
578
|
+
self.__dict__ = data
|
|
579
|
+
|
|
580
|
+
|
|
581
|
+
@dataclass
|
|
582
|
+
class GetSignalPlanRes_Stage(object):
|
|
583
|
+
movement_ids: list[str] = None
|
|
584
|
+
duration: int = None
|
|
585
|
+
|
|
586
|
+
def __init__(self, data: dict) -> None:
|
|
587
|
+
if data == None:
|
|
588
|
+
return
|
|
589
|
+
self.__dict__ = data
|
|
590
|
+
|
|
591
|
+
|
|
592
|
+
@dataclass
|
|
593
|
+
class GetSignalPlanRes(object):
|
|
594
|
+
junction_id: str = None
|
|
595
|
+
cycle: int = None
|
|
596
|
+
offset: int = None
|
|
597
|
+
stages: list[GetSignalPlanRes_Stage] = None
|
|
598
|
+
|
|
599
|
+
def __init__(self, data: dict) -> None:
|
|
600
|
+
if data == None:
|
|
601
|
+
return
|
|
602
|
+
stages = data.pop("stages", None)
|
|
603
|
+
|
|
604
|
+
self.__dict__ = data
|
|
605
|
+
self.stages = (
|
|
606
|
+
None
|
|
607
|
+
if stages == None
|
|
608
|
+
else [GetSignalPlanRes_Stage(stage) for stage in stages]
|
|
609
|
+
)
|
|
610
|
+
|
|
611
|
+
|
|
612
|
+
@dataclass
|
|
613
|
+
class GetMovementListRes:
|
|
614
|
+
list: list[Movement] # type: ignore
|
|
615
|
+
|
|
616
|
+
def __init__(self, data: dict) -> None:
|
|
617
|
+
if data == None:
|
|
618
|
+
return
|
|
619
|
+
list = data.pop("list", None)
|
|
620
|
+
|
|
621
|
+
self.list = None if list == None else [Movement[movement] for movement in list]
|
|
622
|
+
|
|
623
|
+
|
|
624
|
+
@dataclass
|
|
625
|
+
class GetVehicleIdListRes:
|
|
626
|
+
list: list[str] # type: ignore
|
|
627
|
+
|
|
628
|
+
def __init__(self, data: dict) -> None:
|
|
629
|
+
if data == None:
|
|
630
|
+
return
|
|
631
|
+
self.list = data.get("list", None)
|
|
632
|
+
|
|
633
|
+
|
|
634
|
+
@dataclass
|
|
635
|
+
class GetTestVehicleIdListRes:
|
|
636
|
+
list: list[str] # type: ignore
|
|
637
|
+
|
|
638
|
+
def __init__(self, data: dict) -> None:
|
|
639
|
+
if data == None:
|
|
640
|
+
return
|
|
641
|
+
self.__dict__ = data
|
|
642
|
+
# self.list = data.get("list", None) 两种写法都可以
|
|
643
|
+
|
|
644
|
+
|
|
645
|
+
@dataclass
|
|
646
|
+
class GetVehicleBaseInfoRes_VehicleBaseInfo:
|
|
647
|
+
base_info: ObjBaseInfo = None
|
|
648
|
+
dynamic_info: DynamicInfo = None
|
|
649
|
+
|
|
650
|
+
def __init__(self, data: dict) -> None:
|
|
651
|
+
if data == None:
|
|
652
|
+
return
|
|
653
|
+
base_info = data.pop("base_info", None)
|
|
654
|
+
dynamic_info = data.pop("dynamic_info", None)
|
|
655
|
+
# self.__dict__ = data
|
|
656
|
+
# base_info
|
|
657
|
+
self.base_info = None if base_info == None else ObjBaseInfo(base_info)
|
|
658
|
+
# dynamic_info
|
|
659
|
+
self.dynamic_info = None if dynamic_info == None else DynamicInfo(dynamic_info)
|
|
660
|
+
|
|
661
|
+
|
|
662
|
+
@dataclass
|
|
663
|
+
class GetVehicleBaseInfoRes:
|
|
664
|
+
info_dict: dict[str:GetVehicleBaseInfoRes_VehicleBaseInfo] = None
|
|
665
|
+
|
|
666
|
+
def __init__(self, data: dict) -> None:
|
|
667
|
+
if data == None:
|
|
668
|
+
return
|
|
669
|
+
info_dict = data.pop("info_dict", None)
|
|
670
|
+
# self.__dict__ = data
|
|
671
|
+
self.info_dict = (
|
|
672
|
+
None
|
|
673
|
+
if info_dict == None
|
|
674
|
+
else {
|
|
675
|
+
key: GetVehicleBaseInfoRes_VehicleBaseInfo(value)
|
|
676
|
+
for key, value in info_dict.items()
|
|
677
|
+
}
|
|
678
|
+
)
|
|
679
|
+
|
|
680
|
+
|
|
681
|
+
@dataclass
|
|
682
|
+
class GetVehiclePositionRes:
|
|
683
|
+
position_dict: dict[str, Position] = None
|
|
684
|
+
|
|
685
|
+
def __init__(self, data: dict) -> None:
|
|
686
|
+
if data == None:
|
|
687
|
+
return
|
|
688
|
+
position_dict = data.pop("position_dict", None)
|
|
689
|
+
|
|
690
|
+
# self.__dict__ = data
|
|
691
|
+
self.position_dict = (
|
|
692
|
+
None
|
|
693
|
+
if position_dict == None
|
|
694
|
+
else {key: Position(value) for key, value in position_dict.items()}
|
|
695
|
+
)
|
|
696
|
+
|
|
697
|
+
|
|
698
|
+
@dataclass
|
|
699
|
+
class GetVehicleMovingInfoRes:
|
|
700
|
+
moving_info_dict: dict[str, ObjMovingInfo] = None
|
|
701
|
+
|
|
702
|
+
def __init__(self, data: dict) -> None:
|
|
703
|
+
if data == None:
|
|
704
|
+
return
|
|
705
|
+
moving_info_dict = data.pop("moving_info_dict", None)
|
|
706
|
+
# self.__dict__ = data
|
|
707
|
+
self.moving_info_dict = (
|
|
708
|
+
None
|
|
709
|
+
if moving_info_dict == None
|
|
710
|
+
else {key: ObjMovingInfo(value) for key, value in moving_info_dict.items()}
|
|
711
|
+
)
|
|
712
|
+
|
|
713
|
+
|
|
714
|
+
@dataclass
|
|
715
|
+
class GetVehicleControlInfoRes:
|
|
716
|
+
control_info_dict: dict[str, ControlInfo] = None
|
|
717
|
+
|
|
718
|
+
def __init__(self, data: dict) -> None:
|
|
719
|
+
if data == None:
|
|
720
|
+
return
|
|
721
|
+
control_info_dict = data.pop("control_info_dict", None)
|
|
722
|
+
|
|
723
|
+
# self.__dict__ = data
|
|
724
|
+
self.control_info_dict = (
|
|
725
|
+
None
|
|
726
|
+
if control_info_dict == None
|
|
727
|
+
else {key: ControlInfo(value) for key, value in control_info_dict.items()}
|
|
728
|
+
)
|
|
729
|
+
|
|
730
|
+
|
|
731
|
+
@dataclass
|
|
732
|
+
class GetVehiclePerceptionInfoRes_PerceptionObj:
|
|
733
|
+
object_id: str = None
|
|
734
|
+
base_info: ObjBaseInfo = None
|
|
735
|
+
moving_info: ObjMovingInfo = None
|
|
736
|
+
position: Position = None
|
|
737
|
+
|
|
738
|
+
def __init__(self, data: dict) -> None:
|
|
739
|
+
if data == None:
|
|
740
|
+
return
|
|
741
|
+
|
|
742
|
+
base_info = data.pop("base_info", None)
|
|
743
|
+
moving_info = data.pop("moving_info", None)
|
|
744
|
+
position = data.pop("position", None)
|
|
745
|
+
|
|
746
|
+
self.__dict__ = data
|
|
747
|
+
self.base_info = None if base_info == None else ObjBaseInfo(base_info)
|
|
748
|
+
self.moving_info = None if moving_info == None else ObjMovingInfo(moving_info)
|
|
749
|
+
self.position = None if position == None else Position(position)
|
|
750
|
+
|
|
751
|
+
|
|
752
|
+
@dataclass
|
|
753
|
+
class GetVehiclePerceptionInfoRes:
|
|
754
|
+
list: list[GetVehiclePerceptionInfoRes_PerceptionObj] # type: ignore
|
|
755
|
+
|
|
756
|
+
def __init__(self, data: dict) -> None:
|
|
757
|
+
if data == None:
|
|
758
|
+
return
|
|
759
|
+
list = data.pop("list", None)
|
|
760
|
+
|
|
761
|
+
self.list = (
|
|
762
|
+
None
|
|
763
|
+
if list == None
|
|
764
|
+
else [GetVehiclePerceptionInfoRes_PerceptionObj(percep) for percep in list]
|
|
765
|
+
)
|
|
766
|
+
|
|
767
|
+
|
|
768
|
+
@dataclass
|
|
769
|
+
class GetVehicleReferenceLinesRes:
|
|
770
|
+
reference_lines: list[ReferenceLine] = None
|
|
771
|
+
|
|
772
|
+
def __init__(self, data: dict) -> None:
|
|
773
|
+
if data == None:
|
|
774
|
+
return
|
|
775
|
+
reference_lines = data.pop("reference_lines", None)
|
|
776
|
+
|
|
777
|
+
self.reference_lines = (
|
|
778
|
+
None
|
|
779
|
+
if reference_lines == None
|
|
780
|
+
else [ReferenceLine(lines) for lines in reference_lines]
|
|
781
|
+
)
|
|
782
|
+
|
|
783
|
+
|
|
784
|
+
@dataclass
|
|
785
|
+
class GetVehiclePlanningInfoRes:
|
|
786
|
+
planning_path: list[Point] = None
|
|
787
|
+
|
|
788
|
+
def __init__(self, data: dict) -> None:
|
|
789
|
+
if data == None:
|
|
790
|
+
return
|
|
791
|
+
planning_path = data.pop("planning_path", None)
|
|
792
|
+
|
|
793
|
+
self.planning_path = (
|
|
794
|
+
None if planning_path == None else [Point(path) for path in planning_path]
|
|
795
|
+
)
|
|
796
|
+
|
|
797
|
+
|
|
798
|
+
@dataclass
|
|
799
|
+
class GetVehicleNavigationInfoRes:
|
|
800
|
+
navigation_info: NavigationInfo
|
|
801
|
+
|
|
802
|
+
def __init__(self, data: dict) -> None:
|
|
803
|
+
if data == None:
|
|
804
|
+
return
|
|
805
|
+
navigation_info = data.pop("navigation_info", None)
|
|
806
|
+
|
|
807
|
+
self.navigation_info = (
|
|
808
|
+
None if navigation_info == None else NavigationInfo(navigation_info)
|
|
809
|
+
)
|
|
810
|
+
|
|
811
|
+
|
|
812
|
+
@dataclass
|
|
813
|
+
class GetVehicleCollisionStatusRes:
|
|
814
|
+
collision_status: bool = False
|
|
815
|
+
|
|
816
|
+
def __init__(self, data: dict) -> None:
|
|
817
|
+
if data == None:
|
|
818
|
+
return
|
|
819
|
+
self.__dict__ = data
|
|
820
|
+
|
|
821
|
+
|
|
822
|
+
@dataclass
|
|
823
|
+
class SetVehiclePlanningInfoRes:
|
|
824
|
+
def __init__(self, data: dict) -> None:
|
|
825
|
+
if data == None:
|
|
826
|
+
return
|
|
827
|
+
self.__dict__ = data
|
|
828
|
+
|
|
829
|
+
|
|
830
|
+
@dataclass
|
|
831
|
+
class SetVehicleControlInfoRes:
|
|
832
|
+
def __init__(self, data: dict) -> None:
|
|
833
|
+
if data == None:
|
|
834
|
+
return
|
|
835
|
+
self.__dict__ = data
|
|
836
|
+
|
|
837
|
+
|
|
838
|
+
@dataclass
|
|
839
|
+
class SetVehiclePositionRes:
|
|
840
|
+
def __init__(self, data: dict) -> None:
|
|
841
|
+
if data == None:
|
|
842
|
+
return
|
|
843
|
+
self.__dict__ = data
|
|
844
|
+
|
|
845
|
+
|
|
846
|
+
@dataclass
|
|
847
|
+
class SetVehicleMovingInfoRes:
|
|
848
|
+
def __init__(self, data: dict) -> None:
|
|
849
|
+
if data == None:
|
|
850
|
+
return
|
|
851
|
+
self.__dict__ = data
|
|
852
|
+
|
|
853
|
+
|
|
854
|
+
@dataclass
|
|
855
|
+
class SetVehicleBaseInfoRes:
|
|
856
|
+
def __init__(self, data: dict) -> None:
|
|
857
|
+
if data == None:
|
|
858
|
+
return
|
|
859
|
+
self.__dict__ = data
|
|
860
|
+
|
|
861
|
+
|
|
862
|
+
@dataclass
|
|
863
|
+
class SetVehicleRouteNavRes:
|
|
864
|
+
def __init__(self, data: dict) -> None:
|
|
865
|
+
if data == None:
|
|
866
|
+
return
|
|
867
|
+
self.__dict__ = data
|
|
868
|
+
|
|
869
|
+
|
|
870
|
+
@dataclass
|
|
871
|
+
class SetVehicleLinkNavRes:
|
|
872
|
+
def __init__(self, data: dict) -> None:
|
|
873
|
+
if data == None:
|
|
874
|
+
return
|
|
875
|
+
self.__dict__ = data
|
|
876
|
+
|
|
877
|
+
|
|
878
|
+
@dataclass
|
|
879
|
+
class SetVehicleLaneNavRes:
|
|
880
|
+
def __init__(self, data: dict) -> None:
|
|
881
|
+
if data == None:
|
|
882
|
+
return
|
|
883
|
+
self.__dict__ = data
|
|
884
|
+
|
|
885
|
+
|
|
886
|
+
@dataclass
|
|
887
|
+
class SetVehicleDestinationRes:
|
|
888
|
+
def __init__(self, data: dict) -> None:
|
|
889
|
+
if data == None:
|
|
890
|
+
return
|
|
891
|
+
self.__dict__ = data
|
|
892
|
+
|
|
893
|
+
|
|
894
|
+
@dataclass
|
|
895
|
+
class GetPedIdListRes:
|
|
896
|
+
list: list[str] # type: ignore
|
|
897
|
+
|
|
898
|
+
def __init__(self, data: dict) -> None:
|
|
899
|
+
if data == None:
|
|
900
|
+
return
|
|
901
|
+
self.list = data.get("list", None)
|
|
902
|
+
|
|
903
|
+
|
|
904
|
+
@dataclass
|
|
905
|
+
class GetPedBaseInfoRes:
|
|
906
|
+
base_info_dict: dict[str, ObjBaseInfo] = None
|
|
907
|
+
|
|
908
|
+
def __init__(self, data: dict) -> None:
|
|
909
|
+
if data == None:
|
|
910
|
+
return
|
|
911
|
+
base_info_dict = data.pop("base_info_dict", None)
|
|
912
|
+
|
|
913
|
+
# self.__dict__ = data
|
|
914
|
+
self.base_info_dict = (
|
|
915
|
+
None
|
|
916
|
+
if base_info_dict == None
|
|
917
|
+
else {key: ObjBaseInfo(value) for key, value in base_info_dict.items()}
|
|
918
|
+
)
|
|
919
|
+
|
|
920
|
+
|
|
921
|
+
@dataclass
|
|
922
|
+
class SetPedPositionRes:
|
|
923
|
+
def __init__(self, data: dict) -> None:
|
|
924
|
+
if data == None:
|
|
925
|
+
return
|
|
926
|
+
self.__dict__ = data
|
|
927
|
+
|
|
928
|
+
|
|
929
|
+
@dataclass
|
|
930
|
+
class GetNMVIdListRes:
|
|
931
|
+
list: list[str] # type: ignore
|
|
932
|
+
|
|
933
|
+
def __init__(self, data: dict) -> None:
|
|
934
|
+
if data == None:
|
|
935
|
+
return
|
|
936
|
+
self.list = data.get("list", None)
|
|
937
|
+
|
|
938
|
+
|
|
939
|
+
@dataclass
|
|
940
|
+
class GetNMVBaseInfoRes:
|
|
941
|
+
base_info_dict: dict[str, ObjBaseInfo] = None
|
|
942
|
+
|
|
943
|
+
def __init__(self, data: dict) -> None:
|
|
944
|
+
if data == None:
|
|
945
|
+
return
|
|
946
|
+
base_info_dict = data.pop("base_info_dict", None)
|
|
947
|
+
|
|
948
|
+
# self.__dict__ = data
|
|
949
|
+
self.base_info_dict = (
|
|
950
|
+
None
|
|
951
|
+
if base_info_dict == None
|
|
952
|
+
else {key: ObjBaseInfo(value) for key, value in base_info_dict.items()}
|
|
953
|
+
)
|
|
954
|
+
|
|
955
|
+
|
|
956
|
+
@dataclass
|
|
957
|
+
class SetNMVPositionRes:
|
|
958
|
+
def __init__(self, data: dict) -> None:
|
|
959
|
+
if data == None:
|
|
960
|
+
return
|
|
961
|
+
self.__dict__ = data
|
|
962
|
+
|
|
963
|
+
|
|
964
|
+
@dataclass
|
|
965
|
+
class GetVehicleTargetSpeedRes:
|
|
966
|
+
target_speed: float
|
|
967
|
+
|
|
968
|
+
def __init__(self, data: dict):
|
|
969
|
+
if data == None:
|
|
970
|
+
return
|
|
971
|
+
self.__dict__ = data
|