| import pathlib, re, sys |
| |
| try: |
| p = pathlib.Path("comparison.md") |
| if not p.exists(): |
| print("comparison.md not found, skipping post-processing.") |
| sys.exit(0) |
| |
| lines = p.read_text(encoding="utf-8").splitlines() |
| processed_lines = [] |
| in_code = False |
| def strip_worker_suffix(text: str) -> str: |
| return re.sub(r'(\S+?)-\d+(\s|$)', r'\1\2', text) |
| |
| def get_icon(diff_val: float) -> str: |
| if diff_val > 10: |
| return "🐌" |
| if diff_val < -10: |
| return "🚀" |
| return "➡️" |
| |
| def clean_superscripts(text: str) -> str: |
| return re.sub(r'[¹²³⁴⁵⁶⁷⁸⁹⁰]', '', text) |
| |
| def parse_val(token: str): |
| if '%' in token or '=' in token: |
| return None |
| token = clean_superscripts(token) |
| token = token.split('±')[0].strip() |
| token = token.split('(')[0].strip() |
| if not token: |
| return None |
| |
| m = re.match(r'^([-+]?\d*\.?\d+)([a-zA-Zµ]+)?$', token) |
| if not m: |
| return None |
| try: |
| val = float(m.group(1)) |
| except ValueError: |
| return None |
| suffix = (m.group(2) or "").replace("µ", "u") |
| multipliers = { |
| "n": 1e-9, |
| "ns": 1e-9, |
| "u": 1e-6, |
| "us": 1e-6, |
| "m": 1e-3, |
| "ms": 1e-3, |
| "s": 1.0, |
| "k": 1e3, |
| "K": 1e3, |
| "M": 1e6, |
| "G": 1e9, |
| "Ki": 1024.0, |
| "Mi": 1024.0**2, |
| "Gi": 1024.0**3, |
| "Ti": 1024.0**4, |
| "B": 1.0, |
| "B/op": 1.0, |
| "C": 1.0, # tolerate degree/unit markers that don't affect ratio |
| } |
| return val * multipliers.get(suffix, 1.0) |
| |
| def extract_two_numbers(tokens): |
| found = [] |
| for t in tokens[1:]: # skip name |
| if t in {"±", "∞", "~", "│", "│"}: |
| continue |
| if '%' in t or '=' in t: |
| continue |
| val = parse_val(t) |
| if val is not None: |
| found.append(val) |
| if len(found) == 2: |
| break |
| return found |
| |
| # Pass 0: |
| # 1. find a header line with pipes to derive alignment hint |
| # 2. calculate max content width to ensure right-most alignment |
| max_content_width = 0 |
| |
| for line in lines: |
| if line.strip() == "```": |
| in_code = not in_code |
| continue |
| if not in_code: |
| continue |
| |
| # Skip footnotes/meta for width calculation |
| if re.match(r'^\s*[¹²³⁴⁵⁶⁷⁸⁹⁰]', line) or re.search(r'need\s*>?=\s*\d+\s+samples', line): |
| continue |
| if not line.strip() or line.strip().startswith(('goos:', 'goarch:', 'pkg:', 'cpu:')): |
| continue |
| # Header lines are handled separately in Pass 1 |
| if '│' in line and ('vs base' in line or 'old' in line or 'new' in line): |
| continue |
| |
| # It's likely a data line |
| # Check if it has an existing percentage we might move/align |
| curr_line = strip_worker_suffix(line).rstrip() |
| pct_match = re.search(r'([+-]?\d+\.\d+)%', curr_line) |
| if pct_match: |
| # If we are going to realign this, we count width up to the percentage |
| w = len(curr_line[:pct_match.start()].rstrip()) |
| else: |
| w = len(curr_line) |
| |
| if w > max_content_width: |
| max_content_width = w |
| |
| # Calculate global alignment target for Diff column |
| # Ensure target column is beyond the longest line with some padding |
| diff_col_start = max_content_width + 4 |
| |
| # Calculate right boundary (pipe) position |
| # Diff column width ~12 chars (e.g. "+100.00% 🚀") |
| right_boundary = diff_col_start + 14 |
| |
| # Reset code fence tracking state for Pass 1 |
| in_code = False |
| for line in lines: |
| |
| if line.strip() == "```": |
| in_code = not in_code |
| processed_lines.append(line) |
| continue |
| |
| if not in_code: |
| processed_lines.append(line) |
| continue |
| |
| # footnotes keep untouched |
| if re.match(r'^\s*[¹²³⁴⁵⁶⁷⁸⁹⁰]', line) or re.search(r'need\s*>?=\s*\d+\s+samples', line): |
| processed_lines.append(line) |
| continue |
| |
| # header lines: ensure last column labeled Diff and force alignment |
| if '│' in line and ('vs base' in line or 'old' in line or 'new' in line): |
| # Strip trailing pipe and whitespace |
| stripped_header = line.rstrip().rstrip('│').rstrip() |
| |
| # If "vs base" is present, ensure we don't duplicate "Diff" if it's already there |
| # But we want to enforce OUR alignment, so we might strip existing Diff |
| stripped_header = re.sub(r'\s+Diff\s*$', '', stripped_header, flags=re.IGNORECASE) |
| stripped_header = re.sub(r'\s+Delta\b', '', stripped_header, flags=re.IGNORECASE) |
| |
| # Pad to diff_col_start |
| if len(stripped_header) < diff_col_start: |
| new_header = stripped_header + " " * (diff_col_start - len(stripped_header)) |
| else: |
| new_header = stripped_header + " " |
| |
| # Add Diff column header if it's the second header row (vs base) |
| if 'vs base' in line: |
| new_header += "Diff" |
| |
| # Add closing pipe at the right boundary |
| current_len = len(new_header) |
| if current_len < right_boundary: |
| new_header += " " * (right_boundary - current_len) |
| |
| new_header += "│" |
| processed_lines.append(new_header) |
| continue |
| |
| # non-data meta lines |
| if not line.strip() or line.strip().startswith(('goos:', 'goarch:', 'pkg:')): |
| processed_lines.append(line) |
| continue |
| |
| line = strip_worker_suffix(line) |
| tokens = line.split() |
| if not tokens: |
| processed_lines.append(line) |
| continue |
| |
| numbers = extract_two_numbers(tokens) |
| pct_match = re.search(r'([+-]?\d+\.\d+)%', line) |
| |
| # Helper to align and append |
| def append_aligned(left_part, content): |
| if len(left_part) < diff_col_start: |
| aligned = left_part + " " * (diff_col_start - len(left_part)) |
| else: |
| aligned = left_part + " " |
| |
| # Ensure content doesn't exceed right boundary (visual check only, we don't truncate) |
| # But users asked not to exceed header pipe. |
| # Header pipe is at right_boundary. |
| # Content starts at diff_col_start. |
| # So content length should be <= right_boundary - diff_col_start |
| return f"{aligned}{content}" |
| |
| # Special handling for geomean when values missing or zero |
| is_geomean = tokens[0] == "geomean" |
| if is_geomean and (len(numbers) < 2 or any(v == 0 for v in numbers)) and not pct_match: |
| leading = re.match(r'^\s*', line).group(0) |
| left = f"{leading}geomean" |
| processed_lines.append(append_aligned(left, "n/a (has zero)")) |
| continue |
| |
| # when both values are zero, force diff = 0 and align |
| if len(numbers) == 2 and numbers[0] == 0 and numbers[1] == 0: |
| diff_val = 0.0 |
| icon = get_icon(diff_val) |
| left = line.rstrip() |
| processed_lines.append(append_aligned(left, f"{diff_val:+.2f}% {icon}")) |
| continue |
| |
| # recompute diff when we have two numeric values |
| if len(numbers) == 2 and numbers[0] != 0: |
| diff_val = (numbers[1] - numbers[0]) / numbers[0] * 100 |
| icon = get_icon(diff_val) |
| |
| left = line |
| if pct_match: |
| left = line[:pct_match.start()].rstrip() |
| else: |
| left = line.rstrip() |
| |
| processed_lines.append(append_aligned(left, f"{diff_val:+.2f}% {icon}")) |
| continue |
| |
| # fallback: align existing percentage to Diff column and (re)append icon |
| if pct_match: |
| try: |
| pct_val = float(pct_match.group(1)) |
| icon = get_icon(pct_val) |
| |
| left = line[:pct_match.start()].rstrip() |
| suffix = line[pct_match.end():] |
| # Remove any existing icon after the percentage to avoid duplicates |
| suffix = re.sub(r'\s*(🐌|🚀|➡️)', '', suffix) |
| |
| processed_lines.append(append_aligned(left, f"{pct_val:+.2f}% {icon}{suffix}")) |
| except ValueError: |
| processed_lines.append(line) |
| continue |
| |
| # If we cannot parse numbers or percentages, keep the original (only worker suffix stripped) |
| processed_lines.append(line) |
| |
| p.write_text("\n".join(processed_lines) + "\n", encoding="utf-8") |
| |
| except Exception as e: |
| print(f"Error post-processing comparison.md: {e}") |
| sys.exit(1) |
