def main(argv):
args = get_arg_parser().parse_args(sys.argv[1:])
if not args.data_dir:
print('Data directory invalid.')
return
if not args.route_name:
# Extract route name from path
args.route_name = os.path.basename(args.data_dir)
args.data_dir = os.path.dirname(args.data_dir)
route = Route(args.route_name, args.data_dir)
lr = MultiLogIterator(route.log_paths())
with open(args.out_path, 'wb') as f:
try:
done = False
i = 0
while not done:
msg = next(lr)
if not msg:
break
smsg = msg.as_builder()
typ = smsg.which()
if typ == 'ubloxRaw':
f.write(smsg.to_bytes())
i += 1
except StopIteration:
print('All done')
print(f'Writed {i} msgs')
def logreader_from_route_or_segment(r):
sn = SegmentName(r, allow_route_name=True)
route = Route(sn.route_name.canonical_name)
if sn.segment_num < 0:
return MultiLogIterator(route.log_paths())
else:
return LogReader(route.log_paths()[sn.segment_num])
def juggle_segment(route_name, segment_nr):
r = Route(route_name)
lp = r.log_paths()[segment_nr]
if lp is None:
print("This segment does not exist, please try a different one")
return
uf = URLFile(lp)
juggle_file(uf.name)
def juggle_segment(route_name, segment_nr):
r = Route(route_name)
lp = r.log_paths()[segment_nr]
if lp is None:
print("This segment does not exist, please try a different one")
return
uf = URLFile(lp)
subprocess.call(f"bin/plotjuggler -d {uf.name}", shell=True)
def juggle_route(route_name):
r = Route(route_name)
all_data = []
pool = multiprocessing.Pool(24)
all_data = []
for d in pool.map(load_segment, r.log_paths()):
all_data += d
tempfile = NamedTemporaryFile(suffix='.rlog')
save_log(tempfile.name, all_data, compress=False)
del all_data
juggle_file(tempfile.name)
def setUpClass(cls):
if cls.__name__ == 'TestCarModel' or cls.__name__.endswith('Base'):
raise unittest.SkipTest
if 'FILTER' in os.environ:
if not cls.car_model.startswith(
tuple(os.environ.get('FILTER').split(','))):
raise unittest.SkipTest
if cls.test_route is None:
if cls.car_model in non_tested_cars:
print(f"Skipping tests for {cls.car_model}: missing route")
raise unittest.SkipTest
raise Exception(f"missing test route for {cls.car_model}")
disable_radar = False
test_segs = (2, 1, 0)
if cls.test_route.segment is not None:
test_segs = (cls.test_route.segment, )
for seg in test_segs:
try:
if cls.ci:
lr = LogReader(get_url(cls.test_route.route, seg))
else:
lr = LogReader(
Route(cls.test_route.route).log_paths()[seg])
except Exception:
continue
can_msgs = []
fingerprint = defaultdict(dict)
for msg in lr:
if msg.which() == "can":
for m in msg.can:
if m.src < 64:
fingerprint[m.src][m.address] = len(m.dat)
can_msgs.append(msg)
elif msg.which() == "carParams":
if msg.carParams.openpilotLongitudinalControl:
disable_radar = True
if cls.car_model is None and not cls.ci:
cls.car_model = msg.carParams.carFingerprint
if len(can_msgs) > int(50 / DT_CTRL):
break
else:
raise Exception(
f"Route: {repr(cls.test_route.route)} with segments: {test_segs} not found or no CAN msgs found. Is it uploaded?"
)
cls.can_msgs = sorted(can_msgs, key=lambda msg: msg.logMonoTime)
cls.CarInterface, cls.CarController, cls.CarState = interfaces[
cls.car_model]
cls.CP = cls.CarInterface.get_params(cls.car_model, fingerprint, [],
disable_radar)
assert cls.CP
assert cls.CP.carFingerprint == cls.car_model
labels, sizes = zip(*sizes_large)
plt.figure()
plt.title(f"{typ}")
plt.pie(sizes, labels=labels, autopct='%1.1f%%')
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='Check qlog size based on a rlog')
parser.add_argument('route', help='route to use')
parser.add_argument('segment', type=int, help='segment number to use')
args = parser.parse_args()
r = Route(args.route)
rlog = r.log_paths()[args.segment]
msgs = list(LogReader(rlog))
msgs_by_type = defaultdict(list)
for m in msgs:
msgs_by_type[m.which()].append(m.as_builder().to_bytes())
qlog_by_type = defaultdict(list)
for name, service in service_list.items():
if service.decimation is None:
continue
for i, msg in enumerate(msgs_by_type[name]):
if i % service.decimation == 0:
qlog_by_type[name].append(msg)
import json
import sys
from tools.lib.route import Route
route_name = sys.argv[1]
routes = Route(route_name)
data_dump = {"camera": routes.camera_paths(), "logs": routes.log_paths()}
json.dump(data_dump, open("routes.json", "w"))
from tools.lib.logreader import LogReader
from tools.lib.route import Route
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("route", help="The route name")
parser.add_argument("segment", type=int, help="The index of the segment")
args = parser.parse_args()
out_path = os.path.join("jpegs",
f"{args.route.replace('|', '_')}_{args.segment}")
mkdirs_exists_ok(out_path)
r = Route(args.route)
path = r.log_paths()[args.segment] or r.qlog_paths()[args.segment]
lr = list(LogReader(path))
for msg in tqdm(lr):
if msg.which() == 'thumbnail':
with open(os.path.join(out_path, f"{msg.thumbnail.frameId}.jpg"),
'wb') as f:
f.write(msg.thumbnail.thumbnail)
elif msg.which() == 'navThumbnail':
with open(
os.path.join(out_path,
f"nav_{msg.navThumbnail.frameId}.jpg"),
'wb') as f:
f.write(msg.navThumbnail.thumbnail)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--level', default='DEBUG')
parser.add_argument('--addr', default='127.0.0.1')
parser.add_argument("route",
type=str,
nargs='*',
help="route name + segment number for offline usage")
args = parser.parse_args()
logs = None
if len(args.route):
r = Route(args.route[0])
logs = r.log_paths() # TODO: switch to qlogs when logs are in there
if len(args.route) == 2 and logs:
n = int(args.route[1])
logs = [logs[n]]
min_level = LEVELS[args.level]
if logs:
for log in logs:
if log:
lr = LogReader(log)
for m in lr:
if m.which() == 'logMessage':
print_logmessage(m.logMonoTime, m.logMessage,
import argparse
from selfdrive.test.process_replay.compare_logs import save_log
from selfdrive.test.process_replay.process_replay import CONFIGS, replay_process
from tools.lib.logreader import MultiLogIterator
from tools.lib.route import Route
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Run process on route and create new logs",
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("route", help="The route name to use")
parser.add_argument("process", help="The process to run")
args = parser.parse_args()
cfg = [c for c in CONFIGS if c.proc_name == args.process][0]
route = Route(args.route)
lr = MultiLogIterator(route.log_paths(), wraparound=False)
inputs = list(lr)
outputs = replay_process(cfg, inputs)
# Remove message generated by the process under test and merge in the new messages
produces = set(o.which() for o in outputs)
inputs = [i for i in inputs if i.which() not in produces]
outputs = sorted(inputs + outputs, key=lambda x: x.logMonoTime)
fn = f"{args.route}_{args.process}.bz2"
save_log(fn, outputs)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('--level', default='DEBUG')
parser.add_argument('--addr', default='127.0.0.1')
parser.add_argument("route",
type=str,
nargs='*',
help="route name + segment number for offline usage")
args = parser.parse_args()
logs = None
if len(args.route):
r = Route(args.route[0])
logs = [
q_log if r_log is None else r_log
for (q_log, r_log) in zip(r.qlog_paths(), r.log_paths())
]
if len(args.route) == 2 and logs:
n = int(args.route[1])
logs = [logs[n]]
min_level = LEVELS[args.level]
if logs:
for log in logs:
if log:
lr = LogReader(log)
