python/private/zip_main_template.py - third_party/github/bazelbuild/rules_python - Git at Google

 # Template for the __main__.py file inserted into zip files
 #
 # NOTE: This file is a "stage 1" bootstrap, so it's responsible for locating the
 # desired runtime and having it run the stage 2 bootstrap. This means it can't
 # assume much about the current runtime and environment. e.g., the current
 # runtime may not be the correct one, the zip may not have been extract, the
 # runfiles env vars may not be set, etc.
 #
 # NOTE: This program must retain compatibility with a wide variety of Python
 # versions since it is run by an unknown Python interpreter.

 import sys

 # The Python interpreter unconditionally prepends the directory containing this
 # script (following symlinks) to the import path. This is the cause of #9239,
 # and is a special case of #7091. We therefore explicitly delete that entry.
 # TODO(#7091): Remove this hack when no longer necessary.
 del sys.path[0]

 import os
 import shutil
 import subprocess
 import tempfile
 import zipfile

 _STAGE2_BOOTSTRAP = "%stage2_bootstrap%"
 _PYTHON_BINARY = "%python_binary%"
 _WORKSPACE_NAME = "%workspace_name%"


 # Return True if running on Windows
 def is_windows():
     return os.name == "nt"


 def get_windows_path_with_unc_prefix(path):
     """Adds UNC prefix after getting a normalized absolute Windows path.

     No-op for non-Windows platforms or if running under python2.
     """
     path = path.strip()

     # No need to add prefix for non-Windows platforms.
     # And \\?\ doesn't work in python 2 or on mingw
     if not is_windows() or sys.version_info[0] < 3:
         return path

     # Starting in Windows 10, version 1607(OS build 14393), MAX_PATH limitations have been
     # removed from common Win32 file and directory functions.
     # Related doc: https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=cmd#enable-long-paths-in-windows-10-version-1607-and-later
     import platform

     if platform.win32_ver()[1] >= "10.0.14393":
         return path

     # import sysconfig only now to maintain python 2.6 compatibility
     import sysconfig

     if sysconfig.get_platform() == "mingw":
         return path

     # Lets start the unicode fun
     unicode_prefix = "\\\\?\\"
     if path.startswith(unicode_prefix):
         return path

     # os.path.abspath returns a normalized absolute path
     return unicode_prefix + os.path.abspath(path)


 def has_windows_executable_extension(path):
     return path.endswith(".exe") or path.endswith(".com") or path.endswith(".bat")


 if is_windows() and not has_windows_executable_extension(_PYTHON_BINARY):
     _PYTHON_BINARY = _PYTHON_BINARY + ".exe"


 def search_path(name):
     """Finds a file in a given search path."""
     search_path = os.getenv("PATH", os.defpath).split(os.pathsep)
     for directory in search_path:
         if directory:
             path = os.path.join(directory, name)
             if os.path.isfile(path) and os.access(path, os.X_OK):
                 return path
     return None


 def find_python_binary(module_space):
     """Finds the real Python binary if it's not a normal absolute path."""
     return find_binary(module_space, _PYTHON_BINARY)


 def print_verbose(*args, mapping=None, values=None):
     if bool(os.environ.get("RULES_PYTHON_BOOTSTRAP_VERBOSE")):
         if mapping is not None:
             for key, value in sorted((mapping or {}).items()):
                 print(
                     "bootstrap: stage 1:",
                     *args,
                     f"{key}={value!r}",
                     file=sys.stderr,
                     flush=True,
                 )
         elif values is not None:
             for i, v in enumerate(values):
                 print(
                     "bootstrap: stage 1:",
                     *args,
                     f"[{i}] {v!r}",
                     file=sys.stderr,
                     flush=True,
                 )
         else:
             print("bootstrap: stage 1:", *args, file=sys.stderr, flush=True)


 def find_binary(module_space, bin_name):
     """Finds the real binary if it's not a normal absolute path."""
     if not bin_name:
         return None
     if bin_name.startswith("//"):
         # Case 1: Path is a label. Not supported yet.
         raise AssertionError(
             "Bazel does not support execution of Python interpreters via labels yet"
         )
     elif os.path.isabs(bin_name):
         # Case 2: Absolute path.
         return bin_name
     # Use normpath() to convert slashes to os.sep on Windows.
     elif os.sep in os.path.normpath(bin_name):
         # Case 3: Path is relative to the repo root.
         return os.path.join(module_space, bin_name)
     else:
         # Case 4: Path has to be looked up in the search path.
         return search_path(bin_name)


 def extract_zip(zip_path, dest_dir):
     """Extracts the contents of a zip file, preserving the unix file mode bits.

     These include the permission bits, and in particular, the executable bit.

     Ideally the zipfile module should set these bits, but it doesn't. See:
     https://bugs.python.org/issue15795.

     Args:
         zip_path: The path to the zip file to extract
         dest_dir: The path to the destination directory
     """
     zip_path = get_windows_path_with_unc_prefix(zip_path)
     dest_dir = get_windows_path_with_unc_prefix(dest_dir)
     with zipfile.ZipFile(zip_path) as zf:
         for info in zf.infolist():
             zf.extract(info, dest_dir)
             # UNC-prefixed paths must be absolute/normalized. See
             # https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#maximum-path-length-limitation
             file_path = os.path.abspath(os.path.join(dest_dir, info.filename))
             # The Unix st_mode bits (see "man 7 inode") are stored in the upper 16
             # bits of external_attr. Of those, we set the lower 12 bits, which are the
             # file mode bits (since the file type bits can't be set by chmod anyway).
             attrs = info.external_attr >> 16
             if attrs != 0:  # Rumor has it these can be 0 for zips created on Windows.
                 os.chmod(file_path, attrs & 0o7777)


 # Create the runfiles tree by extracting the zip file
 def create_module_space():
     temp_dir = tempfile.mkdtemp("", "Bazel.runfiles_")
     extract_zip(os.path.dirname(__file__), temp_dir)
     # IMPORTANT: Later code does `rm -fr` on dirname(module_space) -- it's
     # important that deletion code be in sync with this directory structure
     return os.path.join(temp_dir, "runfiles")


 def execute_file(
     python_program,
     main_filename,
     args,
     env,
     module_space,
     workspace,
 ):
     # type: (str, str, list[str], dict[str, str], str, str|None, str|None) -> ...
     """Executes the given Python file using the various environment settings.

     This will not return, and acts much like os.execv, except is much
     more restricted, and handles Bazel-related edge cases.

     Args:
       python_program: (str) Path to the Python binary to use for execution
       main_filename: (str) The Python file to execute
       args: (list[str]) Additional args to pass to the Python file
       env: (dict[str, str]) A dict of environment variables to set for the execution
       module_space: (str) Path to the module space/runfiles tree directory
       workspace: (str|None) Name of the workspace to execute in. This is expected to be a
           directory under the runfiles tree.
     """
     # We want to use os.execv instead of subprocess.call, which causes
     # problems with signal passing (making it difficult to kill
     # Bazel). However, these conditions force us to run via
     # subprocess.call instead:
     #
     # - On Windows, os.execv doesn't handle arguments with spaces
     #   correctly, and it actually starts a subprocess just like
     #   subprocess.call.
     # - When running in a workspace or zip file, we need to clean up the
     #   workspace after the process finishes so control must return here.
     try:
         subprocess_argv = [python_program, main_filename] + args
         print_verbose("subprocess argv:", values=subprocess_argv)
         print_verbose("subprocess env:", mapping=env)
         print_verbose("subprocess cwd:", workspace)
         ret_code = subprocess.call(subprocess_argv, env=env, cwd=workspace)
         sys.exit(ret_code)
     finally:
         # NOTE: dirname() is called because create_module_space() creates a
         # sub-directory within a temporary directory, and we want to remove the
         # whole temporary directory.
         shutil.rmtree(os.path.dirname(module_space), True)


 def main():
     print_verbose("running zip main bootstrap")
     print_verbose("initial argv:", values=sys.argv)
     print_verbose("initial environ:", mapping=os.environ)
     print_verbose("initial sys.executable", sys.executable)
     print_verbose("initial sys.version", sys.version)

     args = sys.argv[1:]

     new_env = {}

     # The main Python source file.
     # The magic string percent-main-percent is replaced with the runfiles-relative
     # filename of the main file of the Python binary in BazelPythonSemantics.java.
     main_rel_path = _STAGE2_BOOTSTRAP
     if is_windows():
         main_rel_path = main_rel_path.replace("/", os.sep)

     module_space = create_module_space()
     print_verbose("extracted runfiles to:", module_space)

     new_env["RUNFILES_DIR"] = module_space

     # Don't prepend a potentially unsafe path to sys.path
     # See: https://docs.python.org/3.11/using/cmdline.html#envvar-PYTHONSAFEPATH
     new_env["PYTHONSAFEPATH"] = "1"

     main_filename = os.path.join(module_space, main_rel_path)
     main_filename = get_windows_path_with_unc_prefix(main_filename)
     assert os.path.exists(main_filename), (
         "Cannot exec() %r: file not found." % main_filename
     )
     assert os.access(main_filename, os.R_OK), (
         "Cannot exec() %r: file not readable." % main_filename
     )

     program = python_program = find_python_binary(module_space)
     if python_program is None:
         raise AssertionError("Could not find python binary: " + _PYTHON_BINARY)

     # Some older Python versions on macOS (namely Python 3.7) may unintentionally
     # leave this environment variable set after starting the interpreter, which
     # causes problems with Python subprocesses correctly locating sys.executable,
     # which subsequently causes failure to launch on Python 3.11 and later.
     if "__PYVENV_LAUNCHER__" in os.environ:
         del os.environ["__PYVENV_LAUNCHER__"]

     new_env.update((key, val) for key, val in os.environ.items() if key not in new_env)

     workspace = None
     # If RUN_UNDER_RUNFILES equals 1, it means we need to
     # change directory to the right runfiles directory.
     # (So that the data files are accessible)
     if os.environ.get("RUN_UNDER_RUNFILES") == "1":
         workspace = os.path.join(module_space, _WORKSPACE_NAME)

     sys.stdout.flush()
     execute_file(
         python_program,
         main_filename,
         args,
         new_env,
         module_space,
         workspace,
     )


 if __name__ == "__main__":
     main()
	# Template for the __main__.py file inserted into zip files
	#
	# NOTE: This file is a "stage 1" bootstrap, so it's responsible for locating the
	# desired runtime and having it run the stage 2 bootstrap. This means it can't
	# assume much about the current runtime and environment. e.g., the current
	# runtime may not be the correct one, the zip may not have been extract, the
	# runfiles env vars may not be set, etc.
	#
	# NOTE: This program must retain compatibility with a wide variety of Python
	# versions since it is run by an unknown Python interpreter.

	import sys

	# The Python interpreter unconditionally prepends the directory containing this
	# script (following symlinks) to the import path. This is the cause of #9239,
	# and is a special case of #7091. We therefore explicitly delete that entry.
	# TODO(#7091): Remove this hack when no longer necessary.
	del sys.path[0]

	import os
	import shutil
	import subprocess
	import tempfile
	import zipfile

	_STAGE2_BOOTSTRAP = "%stage2_bootstrap%"
	_PYTHON_BINARY = "%python_binary%"
	_WORKSPACE_NAME = "%workspace_name%"


	# Return True if running on Windows
	def is_windows():
	return os.name == "nt"


	def get_windows_path_with_unc_prefix(path):
	"""Adds UNC prefix after getting a normalized absolute Windows path.

	No-op for non-Windows platforms or if running under python2.
	"""
	path = path.strip()

	# No need to add prefix for non-Windows platforms.
	# And \\?\ doesn't work in python 2 or on mingw
	if not is_windows() or sys.version_info[0] < 3:
	return path

	# Starting in Windows 10, version 1607(OS build 14393), MAX_PATH limitations have been
	# removed from common Win32 file and directory functions.
	# Related doc: https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=cmd#enable-long-paths-in-windows-10-version-1607-and-later
	import platform

	if platform.win32_ver()[1] >= "10.0.14393":
	return path

	# import sysconfig only now to maintain python 2.6 compatibility
	import sysconfig

	if sysconfig.get_platform() == "mingw":
	return path

	# Lets start the unicode fun
	unicode_prefix = "\\\\?\\"
	if path.startswith(unicode_prefix):
	return path

	# os.path.abspath returns a normalized absolute path
	return unicode_prefix + os.path.abspath(path)


	def has_windows_executable_extension(path):
	return path.endswith(".exe") or path.endswith(".com") or path.endswith(".bat")


	if is_windows() and not has_windows_executable_extension(_PYTHON_BINARY):
	_PYTHON_BINARY = _PYTHON_BINARY + ".exe"


	def search_path(name):
	"""Finds a file in a given search path."""
	search_path = os.getenv("PATH", os.defpath).split(os.pathsep)
	for directory in search_path:
	if directory:
	path = os.path.join(directory, name)
	if os.path.isfile(path) and os.access(path, os.X_OK):
	return path
	return None


	def find_python_binary(module_space):
	"""Finds the real Python binary if it's not a normal absolute path."""
	return find_binary(module_space, _PYTHON_BINARY)


	def print_verbose(*args, mapping=None, values=None):
	if bool(os.environ.get("RULES_PYTHON_BOOTSTRAP_VERBOSE")):
	if mapping is not None:
	for key, value in sorted((mapping or {}).items()):
	print(
	"bootstrap: stage 1:",
	*args,
	f"{key}={value!r}",
	file=sys.stderr,
	flush=True,
	)
	elif values is not None:
	for i, v in enumerate(values):
	print(
	"bootstrap: stage 1:",
	*args,
	f"[{i}] {v!r}",
	file=sys.stderr,
	flush=True,
	)
	else:
	print("bootstrap: stage 1:", *args, file=sys.stderr, flush=True)


	def find_binary(module_space, bin_name):
	"""Finds the real binary if it's not a normal absolute path."""
	if not bin_name:
	return None
	if bin_name.startswith("//"):
	# Case 1: Path is a label. Not supported yet.
	raise AssertionError(
	"Bazel does not support execution of Python interpreters via labels yet"
	)
	elif os.path.isabs(bin_name):
	# Case 2: Absolute path.
	return bin_name
	# Use normpath() to convert slashes to os.sep on Windows.
	elif os.sep in os.path.normpath(bin_name):
	# Case 3: Path is relative to the repo root.
	return os.path.join(module_space, bin_name)
	else:
	# Case 4: Path has to be looked up in the search path.
	return search_path(bin_name)


	def extract_zip(zip_path, dest_dir):
	"""Extracts the contents of a zip file, preserving the unix file mode bits.

	These include the permission bits, and in particular, the executable bit.

	Ideally the zipfile module should set these bits, but it doesn't. See:
	https://bugs.python.org/issue15795.

	Args:
	zip_path: The path to the zip file to extract
	dest_dir: The path to the destination directory
	"""
	zip_path = get_windows_path_with_unc_prefix(zip_path)
	dest_dir = get_windows_path_with_unc_prefix(dest_dir)
	with zipfile.ZipFile(zip_path) as zf:
	for info in zf.infolist():
	zf.extract(info, dest_dir)
	# UNC-prefixed paths must be absolute/normalized. See
	# https://docs.microsoft.com/en-us/windows/desktop/fileio/naming-a-file#maximum-path-length-limitation
	file_path = os.path.abspath(os.path.join(dest_dir, info.filename))
	# The Unix st_mode bits (see "man 7 inode") are stored in the upper 16
	# bits of external_attr. Of those, we set the lower 12 bits, which are the
	# file mode bits (since the file type bits can't be set by chmod anyway).
	attrs = info.external_attr >> 16
	if attrs != 0: # Rumor has it these can be 0 for zips created on Windows.
	os.chmod(file_path, attrs & 0o7777)


	# Create the runfiles tree by extracting the zip file
	def create_module_space():
	temp_dir = tempfile.mkdtemp("", "Bazel.runfiles_")
	extract_zip(os.path.dirname(__file__), temp_dir)
	# IMPORTANT: Later code does `rm -fr` on dirname(module_space) -- it's
	# important that deletion code be in sync with this directory structure
	return os.path.join(temp_dir, "runfiles")


	def execute_file(
	python_program,
	main_filename,
	args,
	env,
	module_space,
	workspace,
	):
	# type: (str, str, list[str], dict[str, str], str, str\|None, str\|None) -> ...
	"""Executes the given Python file using the various environment settings.

	This will not return, and acts much like os.execv, except is much
	more restricted, and handles Bazel-related edge cases.

	Args:
	python_program: (str) Path to the Python binary to use for execution
	main_filename: (str) The Python file to execute
	args: (list[str]) Additional args to pass to the Python file
	env: (dict[str, str]) A dict of environment variables to set for the execution
	module_space: (str) Path to the module space/runfiles tree directory
	workspace: (str\|None) Name of the workspace to execute in. This is expected to be a
	directory under the runfiles tree.
	"""
	# We want to use os.execv instead of subprocess.call, which causes
	# problems with signal passing (making it difficult to kill
	# Bazel). However, these conditions force us to run via
	# subprocess.call instead:
	#
	# - On Windows, os.execv doesn't handle arguments with spaces
	# correctly, and it actually starts a subprocess just like
	# subprocess.call.
	# - When running in a workspace or zip file, we need to clean up the
	# workspace after the process finishes so control must return here.
	try:
	subprocess_argv = [python_program, main_filename] + args
	print_verbose("subprocess argv:", values=subprocess_argv)
	print_verbose("subprocess env:", mapping=env)
	print_verbose("subprocess cwd:", workspace)
	ret_code = subprocess.call(subprocess_argv, env=env, cwd=workspace)
	sys.exit(ret_code)
	finally:
	# NOTE: dirname() is called because create_module_space() creates a
	# sub-directory within a temporary directory, and we want to remove the
	# whole temporary directory.
	shutil.rmtree(os.path.dirname(module_space), True)


	def main():
	print_verbose("running zip main bootstrap")
	print_verbose("initial argv:", values=sys.argv)
	print_verbose("initial environ:", mapping=os.environ)
	print_verbose("initial sys.executable", sys.executable)
	print_verbose("initial sys.version", sys.version)

	args = sys.argv[1:]

	new_env = {}

	# The main Python source file.
	# The magic string percent-main-percent is replaced with the runfiles-relative
	# filename of the main file of the Python binary in BazelPythonSemantics.java.
	main_rel_path = _STAGE2_BOOTSTRAP
	if is_windows():
	main_rel_path = main_rel_path.replace("/", os.sep)

	module_space = create_module_space()
	print_verbose("extracted runfiles to:", module_space)

	new_env["RUNFILES_DIR"] = module_space

	# Don't prepend a potentially unsafe path to sys.path
	# See: https://docs.python.org/3.11/using/cmdline.html#envvar-PYTHONSAFEPATH
	new_env["PYTHONSAFEPATH"] = "1"

	main_filename = os.path.join(module_space, main_rel_path)
	main_filename = get_windows_path_with_unc_prefix(main_filename)
	assert os.path.exists(main_filename), (
	"Cannot exec() %r: file not found." % main_filename
	)
	assert os.access(main_filename, os.R_OK), (
	"Cannot exec() %r: file not readable." % main_filename
	)

	program = python_program = find_python_binary(module_space)
	if python_program is None:
	raise AssertionError("Could not find python binary: " + _PYTHON_BINARY)

	# Some older Python versions on macOS (namely Python 3.7) may unintentionally
	# leave this environment variable set after starting the interpreter, which
	# causes problems with Python subprocesses correctly locating sys.executable,
	# which subsequently causes failure to launch on Python 3.11 and later.
	if "__PYVENV_LAUNCHER__" in os.environ:
	del os.environ["__PYVENV_LAUNCHER__"]

	new_env.update((key, val) for key, val in os.environ.items() if key not in new_env)

	workspace = None
	# If RUN_UNDER_RUNFILES equals 1, it means we need to
	# change directory to the right runfiles directory.
	# (So that the data files are accessible)
	if os.environ.get("RUN_UNDER_RUNFILES") == "1":
	workspace = os.path.join(module_space, _WORKSPACE_NAME)

	sys.stdout.flush()
	execute_file(
	python_program,
	main_filename,
	args,
	new_env,
	module_space,
	workspace,
	)


	if __name__ == "__main__":
	main()