mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 19:04:08 +03:00
2d11905f79
The `command '...' failed` pattern also matched a compiler that ran and
failed on a source error ("command 'gcc' failed with exit code 1"), so the
hint told users to install a compiler they already have. Match distutils'
missing-executable form ("failed: No such file or directory") only.
99 lines
4.6 KiB
Python
99 lines
4.6 KiB
Python
"""Point native source builds under PM's pinned interpreter at tools this host has.
|
|
|
|
python-build-standalone records the toolchain it was built with in sysconfig:
|
|
on Linux ``CC = 'clang -pthread'``, ``CXX = 'clang++ -pthread'``, linkers that
|
|
start with the same commands, and an ``AR`` under its deleted ``/tools/llvm``
|
|
build directory; on macOS only that archiver is foreign. setuptools compiles
|
|
every extension with those values unless the environment overrides them, so a
|
|
Debian/Ubuntu/WSL host with only gcc/g++ failed any sdist build with
|
|
``No such file or directory: 'clang++'`` (python-olm, via the matrix extra).
|
|
|
|
Stdlib only: ``pm.environment.classify_uv_failure`` imports this on the
|
|
bootstrap runner's pre-3.11 system python.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping
|
|
import functools
|
|
import json
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
|
|
# setuptools derives LDSHARED from an overridden CC but never LDCXXSHARED from
|
|
# CXX, so each compiler's own linker is rewritten with it.
|
|
_COMPILERS = (("CC", "LDSHARED"), ("CXX", "LDCXXSHARED"))
|
|
_GCC_FAMILY = {"clang": "gcc", "clang++": "g++"}
|
|
_RECORDED = ("CC", "CXX", "LDSHARED", "LDCXXSHARED", "AR")
|
|
|
|
_MISSING_COMPILER = (
|
|
re.compile(r"No such file or directory: '([^']+)'"),
|
|
# distutils' spawn when the executable is absent; a compiler that ran and failed
|
|
# ("command 'gcc' failed with exit code 1") is a source error, not a missing tool.
|
|
re.compile(r"command '([^']+)' failed: No such file or directory"),
|
|
re.compile(r"No CMAKE_(?:C|CXX)_COMPILER could be found"),
|
|
)
|
|
_COMPILER_NAME = re.compile(r"(?:clang(?:\+\+)?|g?cc|g\+\+|c\+\+)(?:-[\d.]+)?")
|
|
_COMPILER_REMEDY = ("{what}: install a C/C++ compiler (Debian/Ubuntu/WSL: `sudo apt install build-essential`; "
|
|
"Fedora: `sudo dnf install gcc gcc-c++`; macOS: `xcode-select --install`) "
|
|
"or point CC/CXX at one, then retry")
|
|
|
|
|
|
@functools.lru_cache(maxsize=None) # noqa: UP033 -- functools.cache is 3.9+; the bootstrap runner can be older
|
|
def _recorded_toolchain(python: str) -> dict[str, str]:
|
|
code = ("import json, sysconfig; "
|
|
f"print(json.dumps({{k: sysconfig.get_config_var(k) or '' for k in {_RECORDED!r}}}))")
|
|
try:
|
|
result = subprocess.run([python, "-I", "-c", code], capture_output=True, text=True,
|
|
timeout=30, check=False)
|
|
return json.loads(result.stdout) if result.returncode == 0 else {}
|
|
except (OSError, subprocess.TimeoutExpired, ValueError):
|
|
return {}
|
|
|
|
|
|
def _linux_defaults(recorded: Mapping[str, str], env: Mapping[str, str]) -> dict[str, str]:
|
|
search = env.get("PATH")
|
|
defaults: dict[str, str] = {}
|
|
for compiler_var, linker_var in _COMPILERS:
|
|
command = recorded.get(compiler_var, "")
|
|
program = command.split(" ", 1)[0]
|
|
substitute = _GCC_FAMILY.get(program)
|
|
if (compiler_var in env or substitute is None or shutil.which(program, path=search)
|
|
or not shutil.which(substitute, path=search)):
|
|
continue
|
|
defaults[compiler_var] = substitute + command[len(program):]
|
|
linker = recorded.get(linker_var, "")
|
|
if linker_var not in env and linker.split(" ", 1)[0] == program:
|
|
defaults[linker_var] = substitute + linker[len(program):]
|
|
archiver = recorded.get("AR", "")
|
|
if archiver and not shutil.which(archiver, path=search) and shutil.which("ar", path=search):
|
|
defaults["AR"] = "ar"
|
|
return defaults
|
|
|
|
|
|
def pinned_build_defaults(python: Path, env: Mapping[str, str]) -> dict[str, str]:
|
|
"""Defaults for build variables the pinned interpreter records but this host lacks.
|
|
|
|
Callers ``setdefault`` them, so a CC/CXX/AR the user set always wins. A recorded
|
|
compiler with no gcc-family equivalent on PATH is left alone; the build then
|
|
fails and ``missing_compiler_remedy`` names the fix.
|
|
"""
|
|
if sys.platform == "darwin":
|
|
return {"AR": "/usr/bin/ar"}
|
|
if sys.platform != "linux":
|
|
return {}
|
|
return _linux_defaults(_recorded_toolchain(str(python)), env)
|
|
|
|
|
|
def missing_compiler_remedy(output: str) -> str:
|
|
"""The install hint for a build that failed because no compiler exists, else ''."""
|
|
for pattern in _MISSING_COMPILER:
|
|
for match in pattern.finditer(output):
|
|
if not match.groups():
|
|
return _COMPILER_REMEDY.format(what="this package compiles native code and no compiler was found")
|
|
if _COMPILER_NAME.fullmatch(Path(match.group(1)).name):
|
|
return _COMPILER_REMEDY.format(what=f"the build needs `{match.group(1)}`, which is not on PATH")
|
|
return ""
|