Remove tabulate from CI tests and migrate regex to pcre (#2787)

* Remove tabulate from CI tests and migrate regex to pcre

* Run formatter and fix HF compat import

Author: Qubitium

.github/scripts/ci_deps.py

@@ -1,14 +1,14 @@
 import argparse
-import re
 import subprocess
 import sys
 from pathlib import Path
 from typing import Any
 
+import pcre
 import yaml
 
 BASE_DIR = Path(__file__).resolve().parent
-_PKG_NAME_RE = re.compile(r"^[A-Za-z0-9_.-]+")
+_PKG_NAME_RE = pcre.compile(r"^[A-Za-z0-9_.-]+")
 
 
 def resolve_test_path(raw_name: str) -> Path:

.github/scripts/ci_tests.py

@@ -1,6 +1,5 @@
 import argparse
 import os
-import re
 import signal
 import subprocess
 import sys
@@ -9,14 +8,15 @@
 import urllib.error
 from pathlib import Path
 
+import pcre
 from ci_gpu import (
     build_job_request,
     extract_gpu_ids,
     normalize_base_url,
     request_json,
 )
 
-ERROR_PATTERN = re.compile(
+ERROR_PATTERN = pcre.compile(
     r"nvcc fatal|error:|fatal error|ModuleNotFoundError|ImportError|AssertionError|Exception|is the correct path|No such file or directory|Repo id must be in"
 )
 

.github/scripts/ci_workflow.py

@@ -1,13 +1,13 @@
 import argparse
 import json
 import os
-import re
 import shlex
 import sys
 from pathlib import Path
 from pathlib import PurePosixPath
 from typing import Any
 
+import pcre
 import requests
 import yaml
 from packaging.specifiers import SpecifierSet
@@ -129,9 +129,9 @@ def is_model_compat_test(rel_path: str, file_path: Path) -> bool:
 
 
 def matches_test_regex(test_regex: str, rel_path: str) -> bool:
-    if re.match(test_regex, rel_path):
+    if pcre.match(test_regex, rel_path):
         return True
-    return re.match(test_regex, PurePosixPath(rel_path).name) is not None
+    return pcre.match(test_regex, PurePosixPath(rel_path).name) is not None
 
 
 def should_skip_test(yaml_file: str | Path, rel_path: str) -> bool:

.github/scripts/deps.yaml

@@ -1,7 +1,6 @@
 common:
   - tokenicer
   - transformers
-  - tabulate
   - swig # for models/tests
 
 tests:

gptqmodel/exllamav3/util/memory.py

@@ -72,7 +72,7 @@ def list_gpu_tensors(min_size: int = 1, cuda_only: bool = True):
 
     import threading
     import warnings
-    from tabulate import tabulate
+    from ...utils.logger import render_table
 
     # Suppress FutureWarning from Torch every time we try to access certain objects
     warnings.simplefilter(action = 'ignore', category = FutureWarning)
@@ -225,4 +225,4 @@ def collect(path, item):
         print("--------------")
         print()
         headers = ["size // MB", "path", "shape", "dtype"]
-        print(tabulate(devices[k], headers = headers, tablefmt = "github", intfmt=","))
+        print(render_table(devices[k], headers=headers, tablefmt="github"))

gptqmodel/quantization/config.py

@@ -23,6 +23,8 @@
 
 from ..adapter.adapter import Lora, normalize_adapter
 from ..utils.logger import setup_logger
+
+
 log = setup_logger()
 
 

gptqmodel/utils/cpp.py

@@ -9,7 +9,6 @@
 import logging
 import math
 import os
-import re
 import shutil
 import subprocess
 import sys
@@ -373,7 +372,7 @@ def cuda_include_paths_with_fallback(
     return _dedupe_path_strings(resolved_include_paths)
 
 
-_CUDA_ARCH_TOKEN_RE = re.compile(r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\+PTX)?$")
+_CUDA_ARCH_TOKEN_RE = pcre.compile(r"^(?P<major>\d+)\.(?P<minor>\d+)(?:\+PTX)?$")
 
 
 def _supported_cuda_arch_pairs() -> list[tuple[int, int]]:
@@ -413,7 +412,7 @@ def _visible_cuda_arch_tokens() -> list[str]:
 def _merge_cuda_arch_override_with_visible_caps(raw_override: str) -> str:
     requested_tokens: list[str] = []
     requested_bases: set[str] = set()
-    for token in re.split(r"[;\s,]+", raw_override.strip()):
+    for token in pcre.split(r"[;\s,]+", raw_override.strip()):
         if not token:
             continue
         requested_tokens.append(token)

gptqmodel/utils/hf.py

@@ -16,7 +16,13 @@
 import torch
 import transformers
 from accelerate import init_empty_weights
-from transformers import AutoConfig, AutoModelForCausalLM, GenerationConfig, PreTrainedModel
+from transformers import (
+    AutoConfig,
+    AutoModelForCausalLM,
+    GenerationConfig,
+    PreTrainedConfig,
+    PreTrainedModel,
+)
 
 from ..nn_modules.qlinear.gguf import (
     PRISM_Q1_0_G128_BLOCK_SIZE,

gptqmodel/utils/logger.py

@@ -4,16 +4,21 @@
 # Contact: qubitium@modelcloud.ai, x.com/qubitium
 
 import contextlib
+import numbers
 import os
 import sys
 import threading
 import time
 from collections import OrderedDict
-from typing import Dict, Iterator, Optional
+from typing import Any, Dict, Iterator, Optional, Sequence
 
+import pcre
 from logbar import LogBar
 
 
+_ANSI_ESCAPE_RE = pcre.compile(r"\x1b\[[0-9;]*m")
+
+
 class _SilentProgress:
     """Minimal no-op progress handle for non-interactive test sessions."""
 
@@ -102,6 +107,99 @@ def setup_logger():
     return _AdaptiveLoggerProxy(LogBar.shared())
 
 
+def _table_cell_text(value: Any, floatfmt: Optional[str]) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return str(value)
+    if floatfmt is not None and isinstance(value, numbers.Real) and not isinstance(value, numbers.Integral):
+        return format(float(value), floatfmt)
+    return str(value)
+
+
+def _visible_width(value: str) -> int:
+    return len(_ANSI_ESCAPE_RE.sub("", value))
+
+
+def _pad_table_cell(value: str, width: int) -> str:
+    return value + (" " * max(0, width - _visible_width(value)))
+
+
+def _render_grid_table(headers: Sequence[str], rows: Sequence[Sequence[str]], widths: Sequence[int]) -> str:
+    def border() -> str:
+        return "+" + "+".join("-" * (width + 2) for width in widths) + "+"
+
+    def row_line(values: Sequence[str]) -> str:
+        return "| " + " | ".join(_pad_table_cell(value, widths[idx]) for idx, value in enumerate(values)) + " |"
+
+    lines = [border(), row_line(headers), border()]
+    lines.extend(row_line(row) for row in rows)
+    lines.append(border())
+    return "\n".join(lines)
+
+
+def _render_github_table(headers: Sequence[str], rows: Sequence[Sequence[str]], widths: Sequence[int]) -> str:
+    def row_line(values: Sequence[str]) -> str:
+        return "| " + " | ".join(_pad_table_cell(value, widths[idx]) for idx, value in enumerate(values)) + " |"
+
+    separator = "| " + " | ".join("-" * width for width in widths) + " |"
+    lines = [row_line(headers), separator]
+    lines.extend(row_line(row) for row in rows)
+    return "\n".join(lines)
+
+
+def _render_simple_table(headers: Sequence[str], rows: Sequence[Sequence[str]], widths: Sequence[int]) -> str:
+    def row_line(values: Sequence[str]) -> str:
+        return "  ".join(_pad_table_cell(value, widths[idx]) for idx, value in enumerate(values))
+
+    separator = "  ".join("-" * width for width in widths)
+    lines = [row_line(headers), separator]
+    lines.extend(row_line(row) for row in rows)
+    return "\n".join(lines)
+
+
+def render_table(
+    rows: Sequence[Sequence[Any]],
+    *,
+    headers: Sequence[Any],
+    tablefmt: str = "grid",
+    floatfmt: Optional[str] = None,
+    logger: Optional[LogBar] = None,
+) -> str:
+    """Render a small diagnostic table using LogBar-compatible column sizing."""
+
+    header_text = [str(header) for header in headers]
+    row_text: list[list[str]] = []
+    for row in rows:
+        values = list(row)
+        if len(values) != len(header_text):
+            raise ValueError(
+                f"Row length {len(values)} does not match header length {len(header_text)}"
+            )
+        row_text.append([_table_cell_text(value, floatfmt) for value in values])
+
+    widths = [_visible_width(header) for header in header_text]
+    if header_text:
+        columns = (logger or LogBar.shared()).columns(
+            cols=[{"label": header, "width": "fit"} for header in header_text],
+            padding=1,
+        )
+        for row in row_text:
+            columns.info.simulate(*row)
+        widths = [max(widths[idx], width) for idx, width in enumerate(columns.widths)]
+
+    for row in row_text:
+        for idx, cell in enumerate(row):
+            widths[idx] = max(widths[idx], _visible_width(cell))
+
+    tablefmt_normalized = (tablefmt or "grid").lower()
+    if tablefmt_normalized == "github":
+        return _render_github_table(header_text, row_text, widths)
+    if tablefmt_normalized == "simple":
+        return _render_simple_table(header_text, row_text, widths)
+    return _render_grid_table(header_text, row_text, widths)
+
+
 class QuantizationRegionTimer:
     """Aggregate and display timing statistics for key quantization stages."""
 

gptqmodel/utils/paroquant_benchmark.py

@@ -11,14 +11,14 @@
 from typing import Any, Optional
 
 import torch
-from tabulate import tabulate
 
 from gptqmodel import GPTQModel
 from gptqmodel.nn_modules.qlinear.paroquant import ParoLinear
 from gptqmodel.nn_modules.qlinear.paroquant_triton import ParoQuantTritonLinear
 from gptqmodel.quantization import FORMAT, METHOD
 from gptqmodel.quantization.config import QuantizeConfig
 from gptqmodel.utils.backend import BACKEND
+from gptqmodel.utils.logger import render_table
 
 
 _NM_CALIBRATION_PATH = "/monster/data/model/dataset/nm-calibration"
@@ -868,22 +868,22 @@ def comparison_rows(*cases: dict[str, Any]) -> list[list[str]]:
 
 def render_case_tables(case: dict[str, Any]) -> dict[str, str]:
     return {
-        "comparison": tabulate(
+        "comparison": render_table(
             comparison_rows(case),
             headers=["case", "opt_scope", "sym", "fused_opt", "gsm8k_platinum_cot", "quant_wall_s", "eval_wall_s"],
             tablefmt="grid",
         ),
-        "module_times": tabulate(
+        "module_times": render_table(
             case.get("module_time_rows", []),
             headers=["layer", "module", "feat", "samples", "loss", "time_s"],
             tablefmt="grid",
         ),
-        "regions": tabulate(
+        "regions": render_table(
             case.get("region_rows", []),
             headers=["region", "count", "last_s", "avg_s", "total_s", "pct", "source"],
             tablefmt="grid",
         ),
-        "kernels": tabulate(
+        "kernels": render_table(
             case.get("kernel_rows", []),
             headers=[
                 "module",