improved runner

Author: rene-d

scripts/runall.py

@@ -28,6 +28,7 @@
 WHITE = "\033[97m"
 YELLOW = "\033[93m"
 RESET = "\033[0m"
+BOLD = "\033[1m"
 FEINT = "\033[2m"
 ITALIC = "\033[3m"
 BLINK = "\033[6m"
@@ -38,7 +39,7 @@
 
 @lru_cache(maxsize=None)
 def aoc_available_puzzles(
-    year: int | None = None, seconds: float | None = None
+    year: t.Optional[int] = None, seconds: t.Optional[float] = None
 ) -> t.Union[dict[int, list[int]], list[int]]:
     """
     Returns a dict of available puzzles by year or the list of available puzzles for the given year.
@@ -71,7 +72,16 @@ def aoc_available_puzzles(
     return puzzles
 
 
-AOC_TARGET_DIR = os.environ.get("AOC_TARGET_DIR", "target")
+class Env:
+    """
+    Variables that can be overridden by environment variables.
+    """
+
+    AOC_TARGET_DIR = os.environ.get("AOC_TARGET_DIR", "target")
+    CARGO_TARGET_DIR = os.environ.get("CARGO_TARGET_DIR", "target")
+    CC = os.environ.get("CC", "cc")
+    CXX = os.environ.get("CXX", "c++")
+
 
 LANGUAGES = {
     "Rust": "src/year{year}/day{day}/day{day}.rs",
@@ -82,7 +92,7 @@ def aoc_available_puzzles(
     "JavaScript": "src/year{year}/day{day}/day{day}.js",
     "Ruby": "src/year{year}/day{day}/day{day}.rb",
     "Perl": "src/year{year}/day{day}/day{day}.pl",
-    "Bash": "src/year{year}/day{day}/day{day}.sh",
+    "Bash": "src/year{year}/day{day}/day{day}.bash",
     "Java": "{AOC_TARGET_DIR}/build/year{year}/day{day}.class",
     "Go": "{AOC_TARGET_DIR}/build/year{year}/day{day}_go",
     "C#": "{AOC_TARGET_DIR}/build/year{year}/day{day}_cs.exe",
@@ -113,8 +123,96 @@ def aoc_available_puzzles(
     "Ruby": {"Ruby": "ruby"},
     "Perl": {"Perl": "perl"},
     "Tcl": {"Tcl": "tclsh"},
+    "Bash": {"Bash": "bash"},
 }
 
+LANGUAGES_VERSIONS = {
+    "Rust": "rustc --version",
+    "Go": "go version",
+    "C": "{CC} --version",
+    "C++": "{CXX} --version",
+    "Swift": "swiftc -version",
+    "Java": "javac -version",
+    "C#": "mcs --version",
+    "Python": "{interpreter} -VV",
+    "Ruby": "{interpreter} --version",
+    "Lua": "{interpreter} -v",
+    "JavaScript": {"NodeJS": "{interpreter} -v"},
+    "Perl": "{interpreter} -v",
+    "Tcl": "echo 'puts [info patchlevel]' | {interpreter}",
+    "Bash": "{interpreter} --version",
+}
+
+
+def get_language_version(puzzle_lang: str) -> str:
+    for language, variants in INTERPRETERS.items():
+        # language = Python
+        # variants = Py3.11, Py3.12, ...
+        for variant, interpreters in variants.items():
+            if variant == puzzle_lang:
+                # language should be in the "show version" dict
+                if language not in LANGUAGES_VERSIONS:
+                    continue
+
+                # interpreter could be a string or an iterable of strings
+                if isinstance(interpreters, str):
+                    interpreters = (interpreters,)
+
+                # get the first available interpreter
+                for interpreter in interpreters:
+                    interpreter = interpreter.format(**vars(Env))
+                    if os.path.isfile(shutil.which(interpreter)):
+                        break
+                else:
+                    return ""
+
+                cmd = LANGUAGES_VERSIONS[language]
+                if isinstance(cmd, dict):
+                    for v, cmd_v in cmd.items():
+                        if v == variant:
+                            cmd = cmd_v
+                            break
+                    else:
+                        # variant has no "show version" command
+                        return ""
+
+                cmd = cmd.format(interpreter=interpreter)
+                cmd = cmd.format(**vars(Env))
+                try:
+                    lang_version = (
+                        subprocess.check_output(
+                            cmd,
+                            shell=True,
+                            stderr=subprocess.DEVNULL,
+                        )
+                        .decode()
+                        .strip()
+                        .splitlines()[0]
+                    )
+                    return lang_version
+                except Exception:
+                    return ""
+
+    if puzzle_lang in LANGUAGES_VERSIONS:
+        cmd = LANGUAGES_VERSIONS[puzzle_lang]
+        cmd = cmd.format(**vars(Env))
+        try:
+            lang_version = (
+                subprocess.check_output(
+                    cmd,
+                    shell=True,
+                    stderr=subprocess.DEVNULL,
+                )
+                .decode()
+                .strip()
+                .splitlines()[0]
+            )
+            return lang_version
+        except Exception:
+            return ""
+
+    return ""
+
 
 def get_cache(cache_file: Path = None):
     """Retrieve the cache instance from memory or load it from disk."""
@@ -211,14 +309,15 @@ def run(
     nb_expected: int,
     year: int,
     day: int,
+    quiet: bool,
 ) -> t.Dict[str, t.Any]:
     """
     TODO
     """
 
     if lang == "Rust":
         cmd = []
-        target = os.environ.get("CARGO_TARGET_DIR", "target")
+        target = Env.CARGO_TARGET_DIR
 
         f = Path(f"{prog.parent}/{prog.stem}/{target}/release/{prog.stem}")
         if f.is_file():
@@ -248,12 +347,14 @@ def run(
     cmd.append(file.absolute().as_posix())
     cmd.append("--elapsed")
 
-    env = os.environ
+    env = os.environ.copy()
     env["NO_COLOR"] = "1"
     cmdline = " ".join(map(str, cmd))
     cmdline = cmdline.replace(Path(__file__).parent.parent.as_posix() + "/", "")
     cmdline = cmdline.replace(Path.home().as_posix(), "~")
-    print(f"{FEINT}{cmdline}{RESET}", end=TRANSIENT)
+
+    if not quiet:
+        print(f"{FEINT}{cmdline}{RESET}", end=TRANSIENT)
 
     elapsed_measurement = "process"
     start = time.time_ns()
@@ -281,7 +382,7 @@ def run(
                     elif elapsed2.endswith("s"):
                         elapsed = int(10**9 * float(elapsed2.removesuffix("s")))
                     else:
-                        print(elapsed, elapsed2, "unknown suffix")
+                        print(elapsed, elapsed2, "unknown time suffix")
                         exit()
 
                     elapsed_measurement = "internal"
@@ -303,7 +404,7 @@ def run(
 
     result = {"elapsed": elapsed, "status": status, "answers": answers}
 
-    run_log = Path(AOC_TARGET_DIR) / "run.log"
+    run_log = Path(Env.AOC_TARGET_DIR) / "run.log"
 
     with run_log.open("at") as f:
         line = f"{datetime.now()} {lang} {cmd} {elapsed / 1e9} {elapsed_measurement} {status} '{answers}'"
@@ -317,7 +418,7 @@ def make(year: int, source: Path, dest: Path, language: str, disable_language: t
     if not source.is_file():
         return
 
-    build_dir = Path(f"{AOC_TARGET_DIR}/build/year{year}")
+    build_dir = Path(f"{Env.AOC_TARGET_DIR}/build/year{year}")
     build_dir.mkdir(parents=True, exist_ok=True)
 
     output = build_dir / dest
@@ -326,10 +427,10 @@ def make(year: int, source: Path, dest: Path, language: str, disable_language: t
         return
 
     if language == "C":
-        cmd = "cc -std=c11"
+        cmd = "{CC} -std=c11".format(CC=Env.CC)
         cmdline = f"{cmd} -o {output} -Wall -Wextra -Werror -O3 -DSTANDALONE -I{source.parent} {source}"
     elif language == "C++":
-        cmd = "c++ -std=c++23"
+        cmd = "{CXX} -std=c++23".format(CXX=Env.CXX)
         cmdline = f"{cmd} -o {output} -Wall -Wextra -Werror -O3 -DSTANDALONE -I{source.parent} {source}"
     elif language == "Java":
         cmdline = f"javac -d {build_dir} {source}"
@@ -497,6 +598,7 @@ def run_day(
     dry_run: bool,
     terminal_columns: int,
     wait: float,
+    quiet: bool,
 ):
     elapsed = defaultdict(list)
 
@@ -519,7 +621,7 @@ def run_day(
         results = set()
 
         for lang, (pattern, interpreter) in languages.items():
-            prog = Path(pattern.format(year=year, day=mday, AOC_TARGET_DIR=AOC_TARGET_DIR))
+            prog = Path(pattern.format(year=year, day=mday, AOC_TARGET_DIR=Env.AOC_TARGET_DIR))
             key = ":".join(map(str, (year, day, crc, prog, lang.lower())))
 
             if not prog.is_file():
@@ -540,20 +642,21 @@ def run_day(
             if not in_cache and not dry_run:
                 nb_expected = 1 if day == 25 else 2
 
-                e = run(prog, lang, interpreter, file, day_answers.get(crc), nb_expected, year, day)
+                e = run(prog, lang, interpreter, file, day_answers.get(crc), nb_expected, year, day, quiet)
 
                 if e:
                     update_cache(key, prog, "solutions", e)
 
                 if wait is not None:
-                    print(f"{CR}{CLEAR_EOL}waiting {wait:g}s...", end="")
+                    if not quiet:
+                        print(f"{CR}{CLEAR_EOL}waiting {wait:g}s...", end="")
                     time.sleep(wait)
 
             if not e:
                 continue
 
             if (e["status"] == "unknown" and day_answers.get(crc)) or e["status"] in ("error", "failed"):
-                resolve_script = Path(AOC_TARGET_DIR) / f"resolve_{e['status']}.sh"
+                resolve_script = Path(Env.AOC_TARGET_DIR) / f"resolve_{e['status']}.sh"
 
                 if not globals().get(resolve_script):
                     with resolve_script.open("wt") as f:
@@ -582,7 +685,9 @@ def run_day(
                 f" {GRAY}{'☽' if in_cache else ' '}"
             )
 
-            if terminal_columns < 60:
+            if quiet:
+                pass
+            elif terminal_columns < 60:
                 print(line)
             elif terminal_columns < 130:
                 print(line, f"{status_color}{str(answers)}{RESET}")
@@ -621,7 +726,7 @@ def lookup(interpreter: str) -> str:
 
                     if "{" in interpreter:
                         # interpreter = interpreter.format_map(globals())
-                        interpreter = interpreter.format(AOC_TARGET_DIR=AOC_TARGET_DIR)
+                        interpreter = interpreter.format(AOC_TARGET_DIR=Env.AOC_TARGET_DIR)
 
                     if "/" not in interpreter and "\\" not in interpreter:
                         interpreter = shutil.which(interpreter)
@@ -749,6 +854,7 @@ def main():
     parser = argparse.ArgumentParser(formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=28))
 
     parser.add_argument("-v", "--verbose", action="store_true", help="verbose")
+    parser.add_argument("-q", "--quiet", action="store_true", help="quiet")
     parser.add_argument("--cache", type=Path, help="cache database")
     parser.add_argument("--working-dir", type=Path, help=argparse.SUPPRESS)
 
@@ -856,7 +962,7 @@ def main():
         # load inputs and answers
         inputs, answers = load_data(filter_year, args.filter_user, args.exclude, args.verified)
 
-        for script in Path(AOC_TARGET_DIR).glob("resolve_*.sh"):
+        for script in Path(Env.AOC_TARGET_DIR).glob("resolve_*.sh"):
             script.unlink()
 
         # here we go!
@@ -880,7 +986,7 @@ def main():
                     day_solutions += Path(f"src/year{year}").glob(f"day{day}_*")
 
                 for mday in day_solutions:
-                    if prev_shown_year != year:
+                    if not args.quiet and prev_shown_year != year:
                         if prev_shown_year != 0:
                             line = (
                                 "=========================="  # prefix
@@ -905,17 +1011,19 @@ def main():
                         args.dry_run,
                         terminal_columns,
                         args.wait,
+                        args.quiet,
                     )
 
                     if elapsed:
-                        if nb_samples > 1:
-                            print(
-                                f"{CR}{CLEAR_EOL}--> ",
-                                " | ".join((f"{lang} : {t:.3f}s" for lang, t in elapsed.items())),
-                                f"{FEINT}({nb_samples} input{'s' if nb_samples > 1 else ''}){RESET}",
-                            )
-                        else:
-                            print(end=f"{CR}{CLEAR_EOL}")
+                        if not args.quiet:
+                            if nb_samples > 1:
+                                print(
+                                    f"{CR}{CLEAR_EOL}--> ",
+                                    " | ".join((f"{lang} : {t:.3f}s" for lang, t in elapsed.items())),
+                                    f"{FEINT}({nb_samples} input{'s' if nb_samples > 1 else ''}){RESET}",
+                                )
+                            else:
+                                print(end=f"{CR}{CLEAR_EOL}")
 
                         for lang, e in elapsed.items():
                             stats_elapsed[year, day, mday, lang] = (e, nb_samples)
@@ -945,22 +1053,24 @@ def main():
                 if average < 0.001:
                     average = f"{average:10.6f} s"
                 else:
-                    average = f"{average:7.3f} s"
-
-                lines.append(
-                    (
-                        t,
-                        f"{YELLOW}{lang:<10}{RESET}"
-                        f" : {GREEN}{t:9.3f}s{RESET} for {WHITE}{n:3}{RESET} puzzle{'s' if n > 1 else ' '},"
-                        f" average: {GREEN}{average}{RESET}",
-                    )
+                    average = f"{average:7.3f} s   "
+
+                stats = (
+                    f"{YELLOW}{lang:<10}{RESET}"
+                    f" : {GREEN}{t:9.3f}s{RESET} for {WHITE}{n:3}{RESET} puzzle{'s' if n > 1 else ' '},"
+                    f" average: {GREEN}{average}{RESET}"
                 )
+                ver = get_language_version(lang)
+                if ver:
+                    stats += f" ∞ {ITALIC}{ver}{RESET}"
+
+                lines.append((t, stats))
                 total_time += t
                 nb_solutions += n
 
-            print()
-            print("ELAPSED TIME:")
-            print("\n".join(map(itemgetter(1), sorted(lines))))
+            print(f"{CR}{CLEAR_EOL}")
+            print(f"{BOLD}ELAPSED TIME:{RESET}")
+            print("\n".join(map(itemgetter(1), sorted(lines, key=itemgetter(1)))))
             print(
                 "total     "
                 f" : {GREEN}{total_time:9.3f}s{RESET}"
@@ -1009,11 +1119,11 @@ def main():
                                 f"{YELLOW}{lang1:<7}{RESET}"
                                 f" vs. {YELLOW}{lang2:<7}{RESET}:"
                                 f" {GREEN}{t1 / n:7.3f}s{RESET} vs. {GREEN}{t2 / n:7.3f}s{RESET}"
-                                f" (x {faster:4.1f} faster) on {WHITE}{n:3}{RESET} puzzle{'s' if n > 1 else ''}",
+                                f" (x {faster:5.1f} faster) on {WHITE}{n:3}{RESET} puzzle{'s' if n > 1 else ''}",
                             )
                         )
                 print()
-                print("LANGUAGES COMPARISON:")
+                print(f"{BOLD}LANGUAGES COMPARISON:{RESET}")
                 print("\n".join(map(itemgetter(2), sorted(lines))))
 
             elif len(languages) > 1:
@@ -1025,7 +1135,7 @@ def main():
             for problem in problems:
                 print(problem)
 
-        for i, f in enumerate(Path(AOC_TARGET_DIR).glob("resolve_*.sh")):
+        for i, f in enumerate(Path(Env.AOC_TARGET_DIR).glob("resolve_*.sh")):
             if i == 0:
                 print("\nFix errors then run:")
             print(f"  {RED}{f}{RESET}")