From aae03be54b85f60721c8bcbcdad87ac3c8de0c20 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 1 Mar 2025 04:05:21 -0600 Subject: [PATCH] scripts: Fixed diff result sorting This was a bit broken when r was None. Which is unusual, but happens when rendering added/removed diff results. --- scripts/code.py | 19 +++++++++++-------- scripts/cov.py | 19 +++++++++++-------- scripts/csv.py | 19 +++++++++++-------- scripts/ctx.py | 19 +++++++++++-------- scripts/data.py | 19 +++++++++++-------- scripts/perf.py | 19 +++++++++++-------- scripts/perfbd.py | 19 +++++++++++-------- scripts/stack.py | 19 +++++++++++-------- scripts/structs.py | 19 +++++++++++-------- 9 files changed, 99 insertions(+), 72 deletions(-) diff --git a/scripts/code.py b/scripts/code.py index f2c647bd..6fe07e21 100755 --- a/scripts/code.py +++ b/scripts/code.py @@ -763,14 +763,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/cov.py b/scripts/cov.py index 729da94e..b92e5140 100755 --- a/scripts/cov.py +++ b/scripts/cov.py @@ -624,14 +624,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/csv.py b/scripts/csv.py index 6e09ebaa..1884750b 100755 --- a/scripts/csv.py +++ b/scripts/csv.py @@ -1906,14 +1906,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/ctx.py b/scripts/ctx.py index 3a70577b..cbcc78ba 100755 --- a/scripts/ctx.py +++ b/scripts/ctx.py @@ -1021,14 +1021,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/data.py b/scripts/data.py index 9d3c38b5..e34b2d46 100755 --- a/scripts/data.py +++ b/scripts/data.py @@ -763,14 +763,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/perf.py b/scripts/perf.py index 3a80bec6..d6ddc69e 100755 --- a/scripts/perf.py +++ b/scripts/perf.py @@ -1125,14 +1125,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/perfbd.py b/scripts/perfbd.py index d2eb5392..972d4431 100755 --- a/scripts/perfbd.py +++ b/scripts/perfbd.py @@ -1095,14 +1095,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/stack.py b/scripts/stack.py index d33c33ad..5954665e 100755 --- a/scripts/stack.py +++ b/scripts/stack.py @@ -767,14 +767,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None), diff --git a/scripts/structs.py b/scripts/structs.py index 17206504..a4aa15a1 100755 --- a/scripts/structs.py +++ b/scripts/structs.py @@ -841,14 +841,17 @@ def table(Result, results, diff_results=None, *, # sort again, now with diff info, note that python's sort is stable names_.sort(key=lambda n: ( # sort by explicit sort fields - tuple((Rev - if reverse ^ (not k or k in Result._fields) - else lambda x: x)( - tuple((getattr(table_[n], k_),) - if getattr(table_.get(n), k_, None) is not None - else () - for k_ in ([k] if k else Result._sort))) - for k, reverse in (sort or [])), + next( + tuple((Rev + if reverse ^ (not k or k in Result._fields) + else lambda x: x)( + tuple((getattr(r_, k_),) + if getattr(r_, k_) is not None + else () + for k_ in ([k] if k else Result._sort))) + for k, reverse in (sort or [])) + for r_ in [table_.get(n), diff_table_.get(n)] + if r_ is not None), # sort by ratio if diffing Rev(tuple(types[k].ratio( getattr(table_.get(n), k, None),