env = os.environ.get(name)

if env is None:

return default

'--experimental-options',

'--python.PosixModuleBackend=java',

'--python.Sha3ModuleBackend=java',

for result in original_DefaultNativeProject_getArchivableResults(self, *args, **kwargs):

if any(r.endswith("pythonjni.dll") for r in result):

yield tuple(r.replace(".dll", ".lib") for r in result)

non_internal = []

additional_dists = []

for arg in args:

# Class path extensions

if arg.startswith('-add-dist='):

additional_dists += [arg[10:]]

else:

non_internal += [arg]

if register_project and register_distribution:

isolate_build_options = [

'-H:+DetectUserDirectoriesInImageHeap',

]

meta_pom = None

for dist in SUITE.dists:

if dist.name == 'PYTHON_POM':

meta_pom = dist

assert meta_pom, "Cannot find python meta-POM distribution in the graalpython suite"

mx_truffle.register_polyglot_isolate_distributions(SUITE, register_project, register_distribution, 'python',

'graalpython', meta_pom.name, meta_pom.maven_group_id(), meta_pom.theLicense,

if not SUITE_COMPILER:

if must_be_jvmci:

mx.abort('** Error ** : graal compiler was not found!')

sys.exit(1)

if vm_warning:

build_args = []

build_args += bytecode_dsl_build_args()

if mx_sdk_vm_ng.is_nativeimage_ee() and mx.get_os() == 'linux' and 'NATIVE_IMAGE_AUXILIARY_ENGINE_CACHE' not in os.environ:

build_args += ['--gc=G1', '-H:-ProtectionKeys']

if not os.environ.get("GRAALPY_PGO_PROFILE") and mx.suite('graalpython-enterprise', fatalIfMissing=False):

cmd = mx.command_function('python-get-latest-profile', fatalIfMissing=False)

if cmd:

profile = None

try:

profile = cmd([])

except BaseException:

pass

if profile and os.path.exists(profile):

mx.log(f"Using PGO profile {profile}")

build_args += [

f"--pgo={profile}",

"-H:+UnlockExperimentalVMOptions",

"-H:+PGOPrintProfileQuality",

"-H:-UnlockExperimentalVMOptions",

]

else:

mx.log(f"Not using any PGO profile")

"""

with set_env(GRAALPY_PGO_PROFILE=""):

mx.log(mx.colorize("[PGO] Building PGO-instrumented native image", color="yellow"))

build_home = graalpy_standalone_home('native', enterprise=True, build=True)

instrumented_home = build_home + "_PGO_INSTRUMENTED"

shutil.rmtree(instrumented_home, ignore_errors=True)

shutil.copytree(build_home, instrumented_home, symlinks=True, ignore_dangling_symlinks=True)

instrumented_launcher = os.path.join(instrumented_home, 'bin', _graalpy_launcher())

mx.log(mx.colorize(f"[PGO] Instrumented build complete: {instrumented_home}", color="yellow"))

mx.log(mx.colorize(f"[PGO] Running graalpytest with instrumented binary: {instrumented_launcher}", color="yellow"))

with tempfile.TemporaryDirectory() as d:

with set_env(

GRAALPYTEST_ALLOW_NO_JAVA_ASSERTIONS="true",

GRAAL_PYTHON_VM_ARGS="\v".join([

f"--vm.XX:ProfilesDumpFile={os.path.join(d, '$UUID$.iprof')}",

f"--vm.XX:ProfilesLCOVFile={os.path.join(d, '$UUID$.info')}",

]),

GRAALPY_HOME=instrumented_home,

):

graalpytest(["--python", instrumented_launcher, "test_venv.py"])

mx.command_function('benchmark')(["meso-small:*", "--", "--python-vm", "graalpython", "--python-vm-config", "custom"])

iprof_path = Path(SUITE.dir) / 'default.iprof'

lcov_path = Path(SUITE.dir) / 'default.lcov'

run([

os.path.join(

graalvm_jdk(enterprise=True),

"bin",

f"native-image-configure{'.exe' if mx.is_windows() else ''}",

),

"merge-pgo-profiles",

f"--input-dir={d}",

f"--output-file={iprof_path}"

])

run([

"/usr/bin/env",

"lcov",

"-o", str(lcov_path),

*itertools.chain.from_iterable([

["-a", f.absolute().as_posix()] for f in Path(d).glob("*.info")

])

], nonZeroIsFatal=False)

run([

"/usr/bin/env",

"genhtml",

"--source-directory", str(Path(SUITE.dir) / "com.oracle.graal.python" / "src"),

"--source-directory", str(Path(SUITE.dir) / "com.oracle.graal.python.pegparser" / "src"),

"--source-directory", str(Path(SUITE.get_output_root()) / "com.oracle.graal.python" / "src_gen"),

"--include", "com/oracle/graal/python",

"--keep-going",

"-o", "lcov_html",

str(lcov_path),

], nonZeroIsFatal=False)

if not os.path.isfile(iprof_path):

mx.abort(f"[PGO] Could not find profile file at expected location: {iprof_path}")

with set_env(GRAALPY_PGO_PROFILE=str(iprof_path)):

mx.log(mx.colorize("[PGO] Building optimized native image with collected profile", color="yellow"))

native_bin = graalpy_standalone('native', enterprise=True, build=True)

mx.log(mx.colorize(f"[PGO] Optimized PGO build complete: {native_bin}", color="yellow"))

iprof_gz_path = str(iprof_path) + '.gz'

with open(iprof_path, 'rb') as f_in, gzip.open(iprof_gz_path, 'wb') as f_out:

shutil.copyfileobj(f_in, f_out)

"""Run python from standalone build (unless kwargs are given). Does not build GraalPython sources automatically."""

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if "--hosted" in args[:2]:

args.remove("--hosted")

return python(args)

if '--vm.da' not in args:

args.insert(0, '--vm.ea')

if not any(arg.startswith('--experimental-options') for arg in args):

args.insert(0, '--experimental-options')

handle_debug_arg(args)

for arg in itertools.chain(

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_sfx))),

reversed(shlex.split(mx._opts.java_args if mx._opts.java_args else "")),

itertools.chain(*map(shlex.split, reversed(mx._opts.java_args_pfx))),

):

if arg.startswith("-"):

args.insert(0, f"--vm.{arg[1:]}")

else:

mx.warn(f"Dropping {arg}, cannot pass it to launcher")

standalone_home = graalpy_standalone_home('jvm', dev=True, build=False)

graalpy_path = os.path.join(standalone_home, 'bin', _graalpy_launcher())

if not os.path.exists(graalpy_path):

mx.abort("GraalPy standalone doesn't seem to be built.\n" +

"To build it: mx python-jvm\n" +

"Alternatively use: mx python --hosted")

"""run a Python program or shell"""

if not any(arg.startswith('--python.WithJavaStacktrace') for arg in args):

args.insert(0, '--python.WithJavaStacktrace=1')

if not any(arg.startswith("--python.CAPI") for arg in args):

capi_home = _get_capi_home()

args.insert(0, "--python.CAPI=%s" % capi_home)

args.insert(0, "--experimental-options")

if not env:

env = os.environ.copy()

env.setdefault("GRAAL_PYTHONHOME", _dev_pythonhome())

delete_bad_env_keys(env)

check_vm_env = env.get('GRAALPYTHON_MUST_USE_GRAAL', False)

if check_vm_env:

if check_vm_env == '1':

check_vm(must_be_jvmci=True)

elif check_vm_env == '0':

check_vm()

if minimal:

x = [x for x in SUITE.dists if x.name == "GRAALPYTHON"][0]

dists = [dep for dep in x.deps if dep.isJavaProject() or dep.isJARDistribution()]

# Hack: what we should just do is + ['GRAALPYTHON_VERSIONS_MAIN'] and let MX figure out

# the class-path and other VM arguments necessary for it. However, due to a bug in MX,

# LayoutDirDistribution causes an exception if passed to mx.get_runtime_jvm_args,

# because it does not properly initialize its super class ClasspathDependency, see MX PR: 1665.

ver_dep = mx.dependency('GRAALPYTHON_VERSIONS_MAIN').get_output()

cp_prefix = ver_dep if cp_prefix is None else (ver_dep + os.pathsep + cp_prefix)

else:

dists = ['GRAALPYTHON']

dists += ['GRAALPYTHON-LAUNCHER']

vm_args, graalpython_args = mx.extract_VM_args(args, useDoubleDash=True, defaultAllVMArgs=False)

if minimal:

vm_args.insert(0, f"-Dorg.graalvm.language.python.home={_dev_pythonhome()}")

graalpython_args, additional_dists = _extract_graalpython_internal_options(graalpython_args)

dists += additional_dists

if extra_dists:

dists += extra_dists

if not CI:

# Try eagerly to include tools for convenience when running Python

if not mx.suite("tools", fatalIfMissing=False):

SUITE.import_suite("tools", version=None, urlinfos=None, in_subdir=True)

if mx.suite("tools", fatalIfMissing=False):

for tool in ["CHROMEINSPECTOR", "TRUFFLE_COVERAGE"]:

if os.path.exists(mx.suite("tools").dependency(tool).path):

dists.append(tool)

graalpython_args.insert(0, '--experimental-options=true')

vm_args += mx.get_runtime_jvm_args(dists, jdk=jdk, cp_prefix=cp_prefix, cp_suffix=cp_suffix, force_cp=True)

if not jdk:

jdk = get_jdk()

# default: assertion checking is enabled

if extra_vm_args is None or '-da' not in extra_vm_args:

vm_args += ['-ea', '-esa']

if extra_vm_args:

vm_args += extra_vm_args

vm_args.append(main_class)

path = os.environ.get("PATH", "")

if mx.is_linux() and not shutil.which("patchelf"):

venv = Path(SUITE.get_output_root()).absolute() / "patchelf-venv"

path += os.pathsep + str(venv / "bin")

if not shutil.which("patchelf", path=path):

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [patchelf not found on PATH]")

t0 = time.time()

subprocess.check_call([sys.executable, "-m", "venv", str(venv)])

subprocess.check_call([str(venv / "bin" / "pip"), "install", "patchelf"])

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building patchelf-venv with {sys.executable}... [duration: {time.time() - t0}]")

if mx.is_windows() and not shutil.which("delvewheel"):

venv = Path(SUITE.get_output_root()).absolute() / "delvewheel-venv"

path += os.pathsep + str(venv / "Scripts")

if not shutil.which("delvewheel", path=path):

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {sys.executable}... [delvewheel not found on PATH]")

t0 = time.time()

subprocess.check_call([sys.executable, "-m", "venv", str(venv)])

subprocess.check_call([str(venv / "Scripts" / "pip.exe"), "install", "delvewheel"])

mx.log(f"{time.strftime('[%H:%M:%S] ')} Building delvewheel-venv with {sys.executable}... [duration: {time.time() - t0}]")

"""

path = get_path_with_patchelf()

args = [] if ars is None else ars

@dataclass

class TestConfig:

identifier: str

args: list

useResources: bool

reportConfig: bool = report

def __str__(self):

return f"args={self.args!r}, useResources={self.useResources}, report={self.reportConfig}"

configs = []

skip_leak_tests = False

if "--no-leak-tests" in args:

skip_leak_tests = True

args.remove("--no-leak-tests")

if is_collecting_coverage():

skip_leak_tests = True

vm_args = ['-Dpolyglot.engine.WarnInterpreterOnly=false']

if BYTECODE_DSL_INTERPRETER:

vm_args.append("-Dpython.EnableBytecodeDSLInterpreter=true")

# Note: we must use filters instead of --regex so that mx correctly processes the unit test configs,

# but it is OK to apply --regex on top of the filters

graalpy_tests = ['com.oracle.graal.python.test', 'com.oracle.graal.python.pegparser.test', 'org.graalvm.python.embedding.test']

configs += [

TestConfig("junit", vm_args + graalpy_tests + args, True),

TestConfig("junit", vm_args + graalpy_tests + args, False),

]

if '--regex' not in args:

async_regex = ['--regex', r'com\.oracle\.graal\.python\.test\.integration\.advanced\.AsyncActionThreadingTest']

configs.append(TestConfig("async", vm_args + ['-Dpython.AutomaticAsyncActions=false', 'com.oracle.graal.python.test', 'org.graalvm.python.embedding.test'] + async_regex + args, True, False))

else:

skip_leak_tests = True

for c in configs:

mx.log(f"Python JUnit tests configuration: {c}")

PythonMxUnittestConfig.useResources = c.useResources

with set_env(PATH=path):

mx_unittest.unittest(c.args, test_report_tags=({"task": f"punittest-{c.identifier}-{'w' if c.useResources else 'wo'}-resources"} if c.reportConfig else None))

if skip_leak_tests:

return

# test leaks with Python code only

run_leak_launcher(["--code", "pass", ])

run_leak_launcher(["--repeat-and-check-size", "250", "--null-stdout", "--code", "print('hello')"])

# test leaks when some C module code is involved

run_leak_launcher(["--code", 'import _testcapi, mmap, bz2; print(memoryview(b"").nbytes)'])

# test leaks with shared engine Python code only

run_leak_launcher(["--shared-engine", "--code", "pass"])

run_leak_launcher(["--shared-engine", "--repeat-and-check-size", "250", "--null-stdout", "--code", "print('hello')"])

# test leaks with shared engine when some C module code is involved

run_leak_launcher(["--shared-engine", "--code", 'import _testcapi, mmap, bz2; print(memoryview(b"").nbytes)'])

run_leak_launcher(["--shared-engine", "--code", '[10, 20]', "--python.UseNativePrimitiveStorageStrategy=true",

"--forbidden-class", "com.oracle.graal.python.runtime.sequence.storage.NativePrimitiveSequenceStorage",

"--forbidden-class", "com.oracle.graal.python.runtime.native_memory.NativePrimitiveReference"])

run_leak_launcher(["--code", '[10, 20]', "--python.UseNativePrimitiveStorageStrategy=true",

"--forbidden-class", "com.oracle.graal.python.runtime.sequence.storage.NativePrimitiveSequenceStorage",

"python-liblzma",

"python-libzsupport",

"python-libposix",

junit = 'python-junit'

junit_maven = 'python-junit-maven'

junit_maven_isolates = 'python-junit-polyglot-isolates'

jvmbuild = 'python-jvm-build'

unittest = 'python-unittest'

unittest_cpython = 'python-unittest-cpython'

unittest_sandboxed = 'python-unittest-sandboxed'

unittest_multi = 'python-unittest-multi-context'

unittest_jython = 'python-unittest-jython'

unittest_arrow = 'python-unittest-arrow-storage'

unittest_hpy = 'python-unittest-hpy'

unittest_hpy_sandboxed = 'python-unittest-hpy-sandboxed'

unittest_posix = 'python-unittest-posix'

unittest_standalone = 'python-unittest-standalone'

tagged = 'python-tagged-unittest'

svmbuild = 'python-svm-build'

svmunit = 'python-svm-unittest'

svmunit_sandboxed = 'python-svm-unittest-sandboxed'

graalvm = 'python-graalvm'

embedding = 'python-standalone-embedding'

graalvm_sandboxed = 'python-graalvm-sandboxed'

svm = 'python-svm'

native_image_embedder = 'python-native-image-embedder'

license = 'python-license'

language_checker = 'python-language-checker'

if not os.environ.get("JDT"):

os.environ["JDT"] = "builtin"

if not os.environ.get("ECLIPSE_EXE"):

find_eclipse()

if "--tags" not in args:

args += ["--tags"]

tags = ["style"]

for x in dir(GraalPythonTags):

v = getattr(GraalPythonTags, x)

if isinstance(v, str) and v.startswith("python-"):

if "sandboxed" not in v:

tags.append(v)

args.append(",".join(tags))

mx.log("Running mx python-gate " + " ".join(args))

pardir = os.path.abspath(os.path.join(SUITE.dir, ".."))

for f in [os.path.join(SUITE.dir, f)

for f in os.listdir(SUITE.dir)] + [os.path.join(pardir, f)

for f in os.listdir(pardir)]:

if os.path.basename(f) == "eclipse" and os.path.isdir(f):

mx.log("Automatically choosing %s for Eclipse" % f)

eclipse_exe = os.path.join(f, f"eclipse{'.exe' if mx.is_windows() else ''}")

if os.path.exists(eclipse_exe):

os.environ["ECLIPSE_EXE"] = eclipse_exe

"""Temporarily set the process environment variables"""

old_environ = dict(os.environ)

for k, v in environ.items():

if v is None:

if k in os.environ:

del os.environ[k]

else:

os.environ[k] = v

try:

yield

finally:

os.environ.clear()

assert standalone_type in ['native', 'jvm']

jdk_version = mx.get_jdk().version

# Check if GRAALPY_HOME points to some compatible pre-built GraalPy standalone

python_home = os.environ.get("GRAALPY_HOME", None)

if python_home:

python_home = os.path.abspath(glob.glob(python_home)[0])

mx.log("Using GraalPy standalone from GRAALPY_HOME: " + python_home)

# Try to verify that we're getting what we expect:

has_java = os.path.exists(os.path.join(python_home, 'jvm', 'bin', mx.exe_suffix('java')))

if has_java != (standalone_type == 'jvm'):

mx.abort(f"GRAALPY_HOME is not compatible with the requested distribution type.\n"

f"jvm/bin/java exists?: {has_java}, requested type={standalone_type}.")

line = ''

with open(os.path.join(python_home, 'release'), 'r') as f:

while 'JAVA_VERSION=' not in line:

line = f.readline()

if 'JAVA_VERSION=' not in line:

mx.abort(f"GRAALPY_HOME does not contain 'release' file. Cannot check Java version.")

actual_jdk_version = mx.VersionSpec(line.strip('JAVA_VERSION=').strip(' "\n\r'))

if actual_jdk_version != jdk_version:

mx.abort(f"GRAALPY_HOME is not compatible with the requested JDK version.\n"

f"actual version: '{actual_jdk_version}', version string: {line}, requested version: {jdk_version}.")

launcher = os.path.join(python_home, 'bin', _graalpy_launcher())

out = mx.OutputCapture()

mx.run([launcher, "-c", "print(__graalpython__.is_bytecode_dsl_interpreter)"], nonZeroIsFatal=False, out=out, err=out)

is_bytecode_dsl_interpreter = out.data.strip() == "True"

if is_bytecode_dsl_interpreter != BYTECODE_DSL_INTERPRETER:

requested = "Bytecode DSL" if BYTECODE_DSL_INTERPRETER else "Manual"

actual = "Bytecode DSL" if is_bytecode_dsl_interpreter else "Manual"

mx.abort(f"GRAALPY_HOME is not compatible with requested interpreter kind ({requested=}, {actual=})")

return python_home

# Build

if standalone_type == 'jvm':

if dev:

env_file = 'jvm'

else:

env_file = 'jvm-ee-libgraal' if enterprise else 'jvm-ce-libgraal'

standalone_dist = 'GRAALPY_JVM_STANDALONE'

if "GraalVM" in subprocess.check_output([get_jdk().java, '-version'], stderr=subprocess.STDOUT, universal_newlines=True):

env_file = ""

else:

env_file = 'native-ee' if enterprise else 'native-ce'

standalone_dist = 'GRAALPY_NATIVE_STANDALONE'

mx_args = ['-p', SUITE.dir, *(['--env', env_file] if env_file else [])]

mx_args.append("--extra-image-builder-argument=-g")

if BUILD_NATIVE_IMAGE_WITH_ASSERTIONS:

mx_args.append("--extra-image-builder-argument=-ea")

pgo_profile = os.environ.get("GRAALPY_PGO_PROFILE")

if pgo_profile is not None:

if not enterprise or standalone_type != "native":

mx.abort("PGO is only supported on enterprise NI")

if pgo_profile:

mx_args.append(f"--extra-image-builder-argument=--pgo={pgo_profile}")

mx_args.append(f"--extra-image-builder-argument=-H:+UnlockExperimentalVMOptions")

mx_args.append(f"--extra-image-builder-argument=-H:+PGOPrintProfileQuality")

else:

mx_args.append(f"--extra-image-builder-argument=--pgo-instrument")

mx_args.append(f"--extra-image-builder-argument=-H:+UnlockExperimentalVMOptions")

mx_args.append(f"--extra-image-builder-argument=-H:+ProfilingLCOV")

if mx_gate.get_jacoco_agent_args() or (build and not DISABLE_REBUILD):

mx_build_args = mx_args

if BYTECODE_DSL_INTERPRETER:

mx_build_args = mx_args + ["--extra-image-builder-argument=-Dpython.EnableBytecodeDSLInterpreter=true"]

# This build is purposefully done without the LATEST_JAVA_HOME in the

# environment, so we can build JVM standalones on an older Graal JDK

run_mx(mx_build_args + ["build", "--target", standalone_dist])

python_home = os.path.join(SUITE.dir, 'mxbuild', f"{mx.get_os()}-{mx.get_arch()}", standalone_dist)

if standalone_type == 'native':

debuginfo = os.path.join(SUITE.dir, 'mxbuild', f"{mx.get_os()}-{mx.get_arch()}", "libpythonvm", "libpythonvm.so.debug")

if os.path.exists(debuginfo):

shutil.copy(debuginfo, os.path.join(python_home, 'lib'))

assert standalone_type in ['native', 'jvm']

if standalone_type == 'native' and mx_gate.get_jacoco_agent_args():

return graalpy_standalone('jvm', enterprise=enterprise, dev=dev, build=build)

home = graalpy_standalone_home(standalone_type, enterprise=enterprise, dev=dev, build=build)

launcher = os.path.join(home, 'bin', _graalpy_launcher())

jdk_version = mx.get_jdk().version

# Check if GRAAL_JDK_HOME points to some compatible pre-built gvm

graal_jdk_home = os.environ.get("GRAAL_JDK_HOME", None)

if graal_jdk_home:

graal_jdk_home = os.path.abspath(glob.glob(graal_jdk_home)[0])

if sys.platform == "darwin":

jdk_home_subdir = os.path.join(graal_jdk_home, 'Contents', 'Home')

if os.path.exists(jdk_home_subdir):

graal_jdk_home = jdk_home_subdir

mx.log("Using Graal from GRAAL_JDK_HOME: " + graal_jdk_home)

# Try to verify that we're getting what we expect:

has_java = os.path.exists(os.path.join(graal_jdk_home, 'bin', mx.exe_suffix('java')))

if not has_java:

mx.abort(f"GRAAL_JDK_HOME does not contain java executable.")

release = os.path.join(graal_jdk_home, 'release')

if not os.path.exists(release):

mx.abort(f"No 'release' file in GRAAL_JDK_HOME.")

java_version = None

with open(release, 'r') as f:

while not java_version:

line = f.readline()

if 'JAVA_VERSION=' in line:

java_version = line

if not java_version:

mx.abort(f"Could not check Java version in GRAAL_JDK_HOME 'release' file.")

actual_jdk_version = mx.VersionSpec(java_version.strip('JAVA_VERSION=').strip(' "\n\r'))

if actual_jdk_version != jdk_version:

mx.abort(f"GRAAL_JDK_HOME is not compatible with the requested JDK version.\n"

f"actual version: '{actual_jdk_version}', version string: {java_version}, requested version: {jdk_version}.")

return graal_jdk_home

jdk_major_version = mx.get_jdk().version.parts[0]

if enterprise:

mx_args = ['-p', os.path.join(mx.suite('truffle').dir, '..', '..', 'graal-enterprise', 'vm-enterprise'), '--env', 'ee']

edition = ""

else:

mx_args = ['-p', os.path.join(mx.suite('truffle').dir, '..', 'vm'), '--env', 'ce']

edition = "COMMUNITY_"

if not DISABLE_REBUILD:

run_mx(mx_args + ["build", "--dep", f"GRAALVM_{edition}JAVA{jdk_major_version}"], env={**os.environ, **LATEST_JAVA_HOME})

out = mx.OutputCapture()

run_mx(mx_args + ["graalvm-home"], out=out)

env = {**os.environ.copy(), **(env or {})}

m2_cache = get_maven_cache()

if m2_cache:

mvn_repo_local = f'-Dmaven.repo.local={m2_cache}'

maven_opts = env.get('MAVEN_OPTS')

maven_opts = maven_opts + " " + mvn_repo_local if maven_opts else mvn_repo_local

env['MAVEN_OPTS'] = maven_opts

mx.log(f'Added {mvn_repo_local} to MAVEN_OPTS={maven_opts}')

run_mx_args = [

'-p',

os.path.join(mx.suite('truffle').dir, '..', 'vm'),

'--dy',

'graalpython',

]

if not DISABLE_REBUILD:

# build GraalPy and all the necessary dependencies, so that we can deploy them

run_mx(run_mx_args + ["build"], env={**env, **LATEST_JAVA_HOME})

# deploy maven artifacts

version = GRAAL_VERSION

path = os.path.join(SUITE.get_mx_output_dir(), 'public-maven-repo')

licenses = ['EPL-2.0', 'PSF-License', 'GPLv2-CPE', 'ICU,GPLv2', 'BSD-simplified', 'BSD-new', 'UPL', 'MIT', 'GFTC']

deploy_args = run_mx_args + [

'maven-deploy',

'--tags=public',

'--all-suites',

'--all-distribution-types',

f'--version-string={version}',

'--validate=none',

'--licenses', ','.join(licenses),

'--suppress-javadoc',

'local',

pathlib.Path(path).as_uri(),

]

if not DISABLE_REBUILD:

mx.rmtree(path, ignore_errors=True)

os.mkdir(path)

run_mx(deploy_args, env={**env, **LATEST_JAVA_HOME})

"""Returns the path to GraalPy from 'jvm' standalone dev build. Also builds the standalone."""

launcher = graalpy_standalone('jvm', dev=True)

mx.log(launcher)

if mx_gate.get_jacoco_agent_args():

# patch our launchers created under jacoco to also run with jacoco.

# do not use is_collecting_coverage() here, we only want to patch when

# jacoco agent is requested.

quote = shlex.quote if sys.platform != 'win32' else lambda x: x

def graalvm_vm_arg(java_arg):

return quote(f'--vm.{java_arg[1:] if java_arg.startswith("-") else java_arg}')

agent_args = ' '.join(graalvm_vm_arg(arg) for arg in mx_gate.get_jacoco_agent_args() or [])

# We need to make sure the arguments get passed to subprocesses, so we create a temporary launcher

# with the arguments. We also disable compilation, it hardly helps for this use case

original_launcher = os.path.abspath(os.path.realpath(launcher))

if sys.platform != 'win32':

coverage_launcher = original_launcher + '.sh'

preamble = '#!/bin/sh'

pass_args = '"$@"'

else:

coverage_launcher = original_launcher.replace('.exe', '.cmd')

# Windows looks for libraries on PATH, we need to add the jvm bin dir there or it won't find the instrumentation dlls

jvm_bindir = os.path.join(os.path.dirname(os.path.dirname(original_launcher)), 'jvm', 'bin')

preamble = f'@echo off\nset PATH=%PATH%;{jvm_bindir}'

pass_args = '%*'

with open(coverage_launcher, "w") as f:

f.write(f'{preamble}\n')

exe_arg = quote(f"--python.Executable={coverage_launcher}")

f.write(f'{original_launcher} --jvm {exe_arg} {agent_args} {pass_args}\n')

if sys.platform != 'win32':

os.chmod(coverage_launcher, 0o775)

mx.log(f"Replaced {launcher} with {coverage_launcher} to collect coverage")

launcher = coverage_launcher

"""Returns the path to GraalPy native image from 'native' standalone dev build.

if mx_gate.get_jacoco_agent_args():

return python_jvm()

launcher = graalpy_standalone('native')

mx.log(launcher)

# help is delegated to the runner, it will fake the mx-specific options as well

parser = ArgumentParser(prog='mx graalpytest', add_help=False)

parser.add_argument('--python')