# Copyright 2022 The Bazel Authors. All rights reserved.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""Common functionality between test/binary executables."""

load("@bazel_skylib//lib:dicts.bzl", "dicts")

load("@bazel_skylib//lib:paths.bzl", "paths")

load("@bazel_skylib//lib:structs.bzl", "structs")

load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")

load("@rules_cc//cc/common:cc_common.bzl", "cc_common")

load("@rules_python_internal//:rules_python_config.bzl", rp_config = "config")

load(":attr_builders.bzl", "attrb")

load(

":attributes.bzl",

"AGNOSTIC_EXECUTABLE_ATTRS",

"COMMON_ATTRS",

"COVERAGE_ATTRS",

"IMPORTS_ATTRS",

"PY_SRCS_ATTRS",

"PrecompileAttr",

"PycCollectionAttr",

"REQUIRED_EXEC_GROUP_BUILDERS",

"WINDOWS_CONSTRAINTS_ATTRS",

"apply_config_settings_attr",

)

load(":builders.bzl", "builders")

load(":cc_helper.bzl", "cc_helper")

load(

":common.bzl",

"ExplicitSymlink",

"actions_run",

"collect_cc_info",

"collect_deps",

"collect_imports",

"collect_runfiles",

"create_binary_semantics_struct",

"create_cc_details_struct",

"create_instrumented_files_info",

"create_output_group_info",

"create_py_info",

"create_windows_exe_launcher",

"csv",

"filter_to_py_srcs",

"is_bool",

"is_windows_platform",

"maybe_create_repo_mapping",

"relative_path",

"runfiles_root_path",

)

load(":common_labels.bzl", "labels")

load(":flags.bzl", "BootstrapImplFlag", "ValidateTestMainFlag", "VenvsUseDeclareSymlinkFlag", "read_possibly_native_flag")

load(":precompile.bzl", "maybe_precompile")

load(":py_cc_link_params_info.bzl", "PyCcLinkParamsInfo")

load(":py_executable_info.bzl", "PyExecutableInfo")

load(":py_info.bzl", "PyInfo", "VenvSymlinkKind")

load(":py_internal.bzl", "py_internal")

load(":py_interpreter_program.bzl", "PyInterpreterProgramInfo")

load(":py_runtime_info.bzl", "DEFAULT_STUB_SHEBANG")

load(":reexports.bzl", "BuiltinPyInfo", "BuiltinPyRuntimeInfo")

load(":rule_builders.bzl", "ruleb")

load(":toolchain_types.bzl", "CC_TOOLCHAIN_TYPE", "EXEC_TOOLS_TOOLCHAIN_TYPE", "LAUNCHER_MAKER_TOOLCHAIN_TYPE", TOOLCHAIN_TYPE = "TARGET_TOOLCHAIN_TYPE")

load(":transition_labels.bzl", "TRANSITION_LABELS")

load(":venv_runfiles.bzl", "create_venv_app_files")

_py_builtins = py_internal

_EXTERNAL_PATH_PREFIX = "external"

_ZIP_RUNFILES_DIRECTORY_NAME = "runfiles"

_INIT_PY = "__init__.py"

# Non-Google-specific attributes for executables

# These attributes are for rules that accept Python sources.

EXECUTABLE_ATTRS = dicts.add(

COMMON_ATTRS,

AGNOSTIC_EXECUTABLE_ATTRS,

PY_SRCS_ATTRS,

IMPORTS_ATTRS,

WINDOWS_CONSTRAINTS_ATTRS,

# starlark flags attributes

{

"_build_python_zip_flag": attr.label(default = "//python/config_settings:build_python_zip"),

"_default_to_explicit_init_py_flag": attr.label(default = "//python/config_settings:incompatible_default_to_explicit_init_py"),

"_python_import_all_repositories_flag": attr.label(default = "//python/config_settings:experimental_python_import_all_repositories"),

"_python_path_flag": attr.label(default = "//python/config_settings:python_path"),

},

{

"interpreter_args": lambda: attrb.StringList(

doc = """

Arguments that are only applicable to the interpreter.

The args an interpreter supports are specific to the interpreter. For

CPython, see <https://docs.python.org/3/using/cmdline.html>.

:::{note}

Only supported for {obj}`--bootstrap_impl=script`. Ignored otherwise.

:::

:::{seealso}

The {any}`RULES_PYTHON_ADDITIONAL_INTERPRETER_ARGS` environment variable

:::

:::{versionadded} 1.3.0

:::

""",

),

"legacy_create_init": lambda: attrb.Int(

default = -1,

values = [-1, 0, 1],

doc = """\

Whether to implicitly create empty `__init__.py` files in the runfiles tree.

These are created in every directory containing Python source code or shared

libraries, and every parent directory of those directories, excluding the repo

root directory. The default, `-1` (auto), means true unless

`--incompatible_default_to_explicit_init_py` is used. If false, the user is

responsible for creating (possibly empty) `__init__.py` files and adding them to

the `srcs` of Python targets as required.

""",

),

# TODO(b/203567235): In the Java impl, any file is allowed. While marked

# label, it is more treated as a string, and doesn't have to refer to

# anything that exists because it gets treated as suffix-search string

# over `srcs`.

"main": lambda: attrb.Label(

allow_single_file = True,

doc = """\

Optional; the name of the source file that is the main entry point of the

application. This file must also be listed in `srcs`. If left unspecified,

`name`, with `.py` appended, is used instead. If `name` does not match any

filename in `srcs`, `main` must be specified.

This is mutually exclusive with {obj}`main_module`.

""",

),

"main_module": lambda: attrb.String(

doc = """

Module name to execute as the main program.

When set, `srcs` is not required, and it is assumed the module is

provided by a dependency.

See <https://docs.python.org/3/using/cmdline.html#cmdoption-m> for more

information about running modules as the main program.

This is mutually exclusive with {obj}`main`.

:::{versionadded} 1.3.0

:::

:::{versionchanged} 1.7.0

Support added for {obj}`--bootstrap_impl=system_python`.

:::

""",

),

"pyc_collection": lambda: attrb.String(

default = PycCollectionAttr.INHERIT,

values = sorted(PycCollectionAttr.__members__.values()),

doc = """

Determines whether pyc files from dependencies should be manually included.

Valid values are:

* `inherit`: Inherit the value from {flag}`--precompile`.

* `include_pyc`: Add implicitly generated pyc files from dependencies. i.e.

pyc files for targets that specify {attr}`precompile="inherit"`.

* `disabled`: Don't add implicitly generated pyc files. Note that

pyc files may still come from dependencies that enable precompiling at the

target level.

""",

),

"python_version": lambda: attrb.String(

# TODO(b/203567235): In the Java impl, the default comes from

# --python_version. Not clear what the Starlark equivalent is.

doc = """

The Python version this target should use.

The value should be in `X.Y` or `X.Y.Z` (or compatible) format. If empty or

unspecified, the incoming configuration's {obj}`--python_version` flag is

inherited. For backwards compatibility, the values `PY2` and `PY3` are

accepted, but treated as an empty/unspecified value.

:::{note}

In order for the requested version to be used, there must be a

toolchain configured to match the Python version. If there isn't, then it

may be silently ignored, or an error may occur, depending on the toolchain

configuration.

:::

:::{versionchanged} 1.1.0

This attribute was changed from only accepting `PY2` and `PY3` values to

accepting arbitrary Python versions.

:::

""",

),

# Required to opt-in to the transition feature.

"_allowlist_function_transition": lambda: attrb.Label(

default = "@bazel_tools//tools/allowlists/function_transition_allowlist",

),

"_bootstrap_impl_flag": lambda: attrb.Label(

default = labels.BOOTSTRAP_IMPL,

providers = [BuildSettingInfo],

),

"_bootstrap_template": lambda: attrb.Label(

allow_single_file = True,

default = "@bazel_tools//tools/python:python_bootstrap_template.txt",

),

"_build_data_writer": lambda: attrb.Label(

default = "//python/private:build_data_writer",

allow_files = True,

cfg = "exec",

),

"_debugger_flag": lambda: attrb.Label(

default = "//python/private:debugger_if_target_config",

providers = [PyInfo],

),

"_exe_zip_maker": lambda: attrb.Label(

cfg = "exec",

default = "//tools/private/zipapp:exe_zip_maker",

),

"_launcher": lambda: attrb.Label(

cfg = "target",

# NOTE: This is an executable, but is only used for Windows. It

# can't have executable=True because the backing target is an

# empty target for other platforms.

default = "//tools/launcher:launcher",

),

"_python_version_flag": lambda: attrb.Label(

default = labels.PYTHON_VERSION,

),

"_uncachable_version_file": lambda: attrb.Label(

default = "//python/private:uncachable_version_file",

allow_files = True,

),

"_venvs_use_declare_symlink_flag": lambda: attrb.Label(

default = labels.VENVS_USE_DECLARE_SYMLINK,

providers = [BuildSettingInfo],

),

"_zipper": lambda: attrb.Label(

cfg = "exec",

executable = True,

default = "@bazel_tools//tools/zip:zipper",

),

},

{

"_windows_launcher_maker": lambda: attrb.Label(

default = "@bazel_tools//tools/launcher:launcher_maker",

cfg = "exec",

executable = True,

),

} if not rp_config.bazel_9_or_later else {},

)

def convert_legacy_create_init_to_int(kwargs):

"""Convert "legacy_create_init" key to int, in-place.

Args:

kwargs: The kwargs to modify. The key "legacy_create_init", if present

and bool, will be converted to its integer value, in place.

"""

if is_bool(kwargs.get("legacy_create_init")):

kwargs["legacy_create_init"] = 1 if kwargs["legacy_create_init"] else 0

def py_executable_impl(ctx, *, is_test, inherited_environment):

return py_executable_base_impl(

ctx = ctx,

semantics = create_binary_semantics(),

is_test = is_test,

inherited_environment = inherited_environment,

)

def create_binary_semantics():

return create_binary_semantics_struct(

# keep-sorted start

get_native_deps_dso_name = _get_native_deps_dso_name,

should_build_native_deps_dso = lambda ctx: False,

# keep-sorted end

)

def _should_create_init_files(ctx):

if ctx.attr.legacy_create_init == -1:

return not read_possibly_native_flag(ctx, "default_to_explicit_init_py")

else:

return bool(ctx.attr.legacy_create_init)

def _create_executable(

ctx,

*,

executable,

main_py,

imports,

is_test,

runtime_details,

cc_details,

native_deps_details,

runfiles_details,

extra_deps):

_ = is_test, cc_details, native_deps_details # @unused

is_windows = is_windows_platform(ctx)

if is_windows:

if not executable.extension == "exe":

fail("Should not happen: somehow we are generating a non-.exe file on windows")

base_executable_name = executable.basename[0:-4]

else:

base_executable_name = executable.basename

# Venv outputs are package-relative, so preserve the full target name to

# avoid collisions between targets like foo/tool, bar/tool, and foo_tool.

venv_output_prefix = ctx.label.name

venv = None

# The check for stage2_bootstrap_template is to support legacy

# BuiltinPyRuntimeInfo providers, which is likely to come from

# @bazel_tools//tools/python:autodetecting_toolchain, the toolchain used

# for workspace builds when no rules_python toolchain is configured.

if (

runtime_details.effective_runtime and

hasattr(runtime_details.effective_runtime, "stage2_bootstrap_template")

):

venv = _create_venv(

ctx,

output_prefix = venv_output_prefix,

imports = imports,

runtime_details = runtime_details,

add_runfiles_root_to_sys_path = (

"1" if BootstrapImplFlag.get_value(ctx) == BootstrapImplFlag.SYSTEM_PYTHON else "0"

),

extra_deps = extra_deps,

)

stage2_bootstrap = _create_stage2_bootstrap(

ctx,

output_prefix = base_executable_name,

output_sibling = executable,

main_py = main_py,

imports = imports,

runtime_details = runtime_details,

venv = venv,

build_data_file = runfiles_details.build_data_file,

)

extra_runfiles = ctx.runfiles(

[stage2_bootstrap] + (

venv.files_without_interpreter if venv else []

),

).merge(venv.lib_runfiles)

zip_main = _create_zip_main(

ctx,

stage2_bootstrap = stage2_bootstrap,

runtime_details = runtime_details,

venv = venv,

)

else:

stage2_bootstrap = None

extra_runfiles = ctx.runfiles()

zip_main = ctx.actions.declare_file(base_executable_name + ".temp", sibling = executable)

_create_stage1_bootstrap(

ctx,

output = zip_main,

main_py = main_py,

imports = imports,

is_for_zip = True,

runtime_details = runtime_details,

)

zip_file = ctx.actions.declare_file(base_executable_name + ".zip", sibling = executable)

_create_zip_file(

ctx,

output = zip_file,

zip_main = zip_main,

runfiles = runfiles_details.runfiles_without_exe.merge(extra_runfiles),

)

extra_default_outputs = []

# NOTE: --build_python_zip defaults to true on Windows

build_zip_enabled = read_possibly_native_flag(ctx, "build_python_zip") and not is_windows

if is_windows:

# The legacy build_python_zip codepath isn't compatible with full venvs on Windows.

build_zip_enabled = False

# When --build_python_zip is enabled, then the zip file becomes

# one of the default outputs.

if build_zip_enabled:

if not is_windows:

# buildifier: disable=print

print(

"""

======================================================================

WARNING: Target: {}

The `--build_python_zip` flag and implicit zipapp output of `py_binary`

and `py_test` is deprecated and will be removed in a future release.

Switch to `py_zipapp_binary` or `py_zipapp_test`. For migration

instructions and guide, see:

https://github.com/bazel-contrib/rules_python/issues/3567

======================================================================

""".rstrip().format(ctx.label),

)

extra_default_outputs.append(zip_file)

# The logic here is a bit convoluted. Essentially, there are 3 types of

# executables produced:

# 1. (non-Windows) A bootstrap template based program.

# 2. (non-Windows) A self-executable zip file of a bootstrap template based program.

# 3. (Windows) A native Windows executable that finds and launches

# the actual underlying Bazel program (one of the above). Note that

# it implicitly assumes one of the above is located next to it, and

# that --build_python_zip defaults to true for Windows.

should_create_executable_zip = False

bootstrap_output = None

if not is_windows:

if build_zip_enabled:

should_create_executable_zip = True

else:

bootstrap_output = executable

else:

create_windows_exe_launcher(

ctx,

output = executable,

use_zip_file = build_zip_enabled,

python_binary_path = runtime_details.executable_interpreter_path,

)

# On Windows, the main executable has an "exe" extension, so

# here we re-use the un-extensioned name for the bootstrap output.

bootstrap_output = ctx.actions.declare_file(base_executable_name, sibling = executable)

# The launcher looks for the non-zip executable next to

# itself, so add it to the default outputs.

extra_default_outputs.append(bootstrap_output)

if should_create_executable_zip:

if bootstrap_output != None:

fail("Should not occur: bootstrap_output should not be used " +

"when creating an executable zip")

_create_executable_zip_file(

ctx,

output = executable,

zip_file = zip_file,

stage2_bootstrap = stage2_bootstrap,

runtime_details = runtime_details,

venv = venv,

)

elif bootstrap_output:

_create_stage1_bootstrap(

ctx,

output = bootstrap_output,

stage2_bootstrap = stage2_bootstrap,

runtime_details = runtime_details,

is_for_zip = False,

imports = imports,

main_py = main_py,

venv = venv,

)

else:

# Otherwise, this should be the Windows case of launcher + zip.

# Double check this just to make sure.

if not is_windows or not build_zip_enabled:

fail(("Should not occur: The non-executable-zip and " +

"non-bootstrap-template case should have windows and zip " +

"both true, but got " +

"is_windows={is_windows} " +

"build_zip_enabled={build_zip_enabled}").format(

is_windows = is_windows,

build_zip_enabled = build_zip_enabled,

))

app_runfiles = builders.RunfilesBuilder()

app_runfiles.add(runfiles_details.app_runfiles)

if venv:

app_runfiles.add(venv.files_without_interpreter)

app_runfiles.add(venv.lib_runfiles)

# The interpreter is added this late in the process so that it isn't

# added to the zipped files.

if venv and venv.interpreter_runfiles:

extra_runfiles = extra_runfiles.merge(venv.interpreter_runfiles)

return struct(

# depset[File] of additional files that should be included as default

# outputs.

extra_default_outputs = depset(extra_default_outputs),

# dict[str, depset[File]]; additional output groups that should be

# returned.

output_groups = {"python_zip_file": depset([zip_file])},

# runfiles; additional runfiles to include.

extra_runfiles = extra_runfiles,

# File|None; the stage2 bootstrap file, if any

stage2_bootstrap = stage2_bootstrap,

# runfiles; runfiles for the app itself (e.g its deps, but no Python

# runtime files)

app_runfiles = app_runfiles.build(ctx),

# depset[ExplicitSymlink]None; symlinks that should be created in

# the venv to augment app_runfiles

venv_app_symlinks = venv.lib_symlinks if venv else None,

# File|None; the venv `bin/python3` file, if any.

venv_python_exe = venv.interpreter if venv else None,

# runfiles|None; runfiles in the venv for the interpreter

venv_interpreter_runfiles = venv.interpreter_runfiles if venv else None,

# depset[ExplicitSymlink]|None; symlinks that should be created

venv_interpreter_symlinks = venv.interpreter_symlinks if venv else None,

)

def _create_zip_main(ctx, *, stage2_bootstrap, runtime_details, venv):

if venv.interpreter:

python_binary = runfiles_root_path(ctx, venv.interpreter.short_path)

else:

python_binary = ""

python_binary_actual = venv.interpreter_actual_path

# The location of this file doesn't really matter. It's added to

# the zip file as the top-level __main__.py file and not included

# elsewhere.

output = ctx.actions.declare_file(ctx.label.name + "_zip__main__.py")

ctx.actions.expand_template(

template = runtime_details.effective_runtime.zip_main_template,

output = output,

substitutions = {

"%python_binary%": python_binary,

"%python_binary_actual%": python_binary_actual,

"%stage2_bootstrap%": runfiles_root_path(ctx, stage2_bootstrap.short_path),

"%workspace_name%": ctx.workspace_name,

},

)

return output

# Create a venv the executable can use.

# For venv details and the venv startup process, see:

# * https://docs.python.org/3/library/venv.html

# * https://snarky.ca/how-virtual-environments-work/

# * https://github.com/python/cpython/blob/main/Modules/getpath.py

# * https://github.com/python/cpython/blob/main/Lib/site.py

def _create_venv(ctx, output_prefix, imports, runtime_details, add_runfiles_root_to_sys_path, extra_deps):

venv_ctx_rel_root = "_{}.venv".format(output_prefix.lstrip("_"))

runtime = runtime_details.effective_runtime

if runtime.interpreter:

interpreter_actual_path = runfiles_root_path(ctx, runtime.interpreter.short_path)

else:

interpreter_actual_path = runtime.interpreter_path

is_windows = is_windows_platform(ctx)

if is_windows:

venv_details = _create_venv_windows(

ctx,

venv_ctx_rel_root = venv_ctx_rel_root,

interpreter_actual_path = interpreter_actual_path,

runtime = runtime,

)

else:

venv_details = _create_venv_unixy(

ctx,

venv_ctx_rel_root = venv_ctx_rel_root,

interpreter_actual_path = interpreter_actual_path,

runtime = runtime,

)

site_packages = "{}/{}".format(venv_ctx_rel_root, venv_details.site_packages)

pth = ctx.actions.declare_file("{}/bazel.pth".format(site_packages))

ctx.actions.write(pth, "import _bazel_site_init\n")

site_init = ctx.actions.declare_file("{}/_bazel_site_init.py".format(site_packages))

computed_subs = ctx.actions.template_dict()

computed_subs.add_joined("%imports%", imports, join_with = ":", map_each = _map_each_identity)

ctx.actions.expand_template(

template = runtime.site_init_template,

output = site_init,

substitutions = {

"%add_runfiles_root_to_sys_path%": add_runfiles_root_to_sys_path,

"%coverage_tool%": _get_coverage_tool_runfiles_path(ctx, runtime),

"%import_all%": "True" if read_possibly_native_flag(ctx, "python_import_all_repositories") else "False",

"%site_init_runfiles_path%": runfiles_root_path(ctx, site_init.short_path),

"%workspace_name%": ctx.workspace_name,

},

computed_substitutions = computed_subs,

)

# See https://docs.python.org/3/library/sysconfig.html#posix-prefix

# for how schemes map under the venv.

venv_dir_map = {

VenvSymlinkKind.BIN: "{}/{}".format(venv_ctx_rel_root, venv_details.bin_dir),

VenvSymlinkKind.LIB: site_packages,

VenvSymlinkKind.INCLUDE: "{}/{}".format(venv_ctx_rel_root, venv_details.include_dir),

VenvSymlinkKind.DATA: venv_ctx_rel_root,

}

venv_app_files = create_venv_app_files(

ctx,

deps = collect_deps(ctx, extra_deps),

venv_dir_map = venv_dir_map,

)

files_without_interpreter = [pth, site_init] + venv_app_files.venv_files

if venv_details.pyvenv_cfg:

files_without_interpreter.append(venv_details.pyvenv_cfg)

return struct(

# File or None; the `bin/python3` executable in the venv.

# None if a full venv isn't created.

interpreter = venv_details.interpreter,

# Files in the venv that need to be created for the interpreter to work

interpreter_runfiles = venv_details.interpreter_runfiles,

# depset[ExplicitSymlink] of symlinks to create.

# This is only used when declare_symlink() can't be used to represent

# creating such a link (i.e Windows)

interpreter_symlinks = venv_details.interpreter_symlinks,

# bool; True if the venv should be recreated at runtime

recreate_venv_at_runtime = venv_details.recreate_venv_at_runtime,

# Runfiles root relative path or absolute path

interpreter_actual_path = interpreter_actual_path,

files_without_interpreter = files_without_interpreter,

# string; venv-relative path to the site-packages directory.

venv_site_packages = venv_details.site_packages,

# string; runfiles-root relative path to venv root.

venv_root = runfiles_root_path(

ctx,

paths.join(

py_internal.get_label_repo_runfiles_path(ctx.label),

venv_ctx_rel_root,

),

),

# venv files for user library dependencies (files that are specific

# to the executable bootstrap and python runtime aren't here).

# `root_symlinks` should be used, otherwise, with symlinks files always go

# to `_main` prefix, and binaries from non-root module become broken.

lib_runfiles = ctx.runfiles(

root_symlinks = venv_app_files.runfiles_symlinks,

),

lib_symlinks = venv_app_files.explicit_symlinks,

)

def _create_venv_unixy(ctx, *, venv_ctx_rel_root, runtime, interpreter_actual_path):

interpreter_runfiles = builders.RunfilesBuilder()

is_bootstrap_script = BootstrapImplFlag.get_value(ctx) == BootstrapImplFlag.SCRIPT

create_full_venv = True

# The legacy build_python_zip codepath (enabled by default on windows) isn't

# compatible with full venv.

# TODO: Use non-build_python_zip codepath for Windows

if not rp_config.bazel_8_or_later and not is_bootstrap_script:

# Full venv for Bazel 7 + system_python is disabled because packaging

# it using build_python_zip=true or rules_pkg breaks.

# * Using build_python_zip=true breaks because the legacy zipapp support

# doesn't handle symlinks correctly.

# * Using rules_pkg breaks for two reasons:

# 1. It requires rules_pkg 1.2, which crashes under Bazel 7

# 2. It requires File.is_symlink, which is a Bazel 8+ API.

# While bootstrap=script has the same problems, it has always been like

# that.

create_full_venv = False

if create_full_venv:

# The pyvenv.cfg file must be present to trigger the venv site hooks.

# Because it's paths are expected to be absolute paths, we can't reliably

# put much in it. See https://github.com/python/cpython/issues/83650

pyvenv_cfg = ctx.actions.declare_file("{}/pyvenv.cfg".format(venv_ctx_rel_root))

ctx.actions.write(pyvenv_cfg, "")

else:

pyvenv_cfg = None

venvs_use_declare_symlink_enabled = (

VenvsUseDeclareSymlinkFlag.get_value(ctx) == VenvsUseDeclareSymlinkFlag.YES

)

recreate_venv_at_runtime = False

venv_bin_ctx_rel_path = "{}/bin".format(venv_ctx_rel_root)

if create_full_venv:

# Some wrappers around the interpreter (e.g. pyenv) use the program

# name to decide what to do, so preserve the name.

py_exe_basename = paths.basename(interpreter_actual_path)

if not venvs_use_declare_symlink_enabled or not runtime.supports_build_time_venv:

recreate_venv_at_runtime = True

# When the venv symlinks are disabled, the $venv/bin/python3 file isn't

# needed or used at runtime. However, the zip code uses the interpreter

# File object to figure out some paths.

interpreter = ctx.actions.declare_file("{}/{}".format(venv_bin_ctx_rel_path, py_exe_basename))

ctx.actions.write(interpreter, "actual:{}".format(interpreter_actual_path))

elif runtime.interpreter:

# Even though ctx.actions.symlink() is used, using

# declare_symlink() is required to ensure that the resulting file

# in runfiles is always a symlink. An RBE implementation, for example,

# may choose to write what symlink() points to instead.

interpreter = ctx.actions.declare_symlink("{}/{}".format(venv_bin_ctx_rel_path, py_exe_basename))

interpreter_runfiles.add(interpreter)

rel_path = relative_path(

# dirname is necessary because a relative symlink is relative to

# the directory the symlink resides within.

from_ = paths.dirname(runfiles_root_path(ctx, interpreter.short_path)),

to = interpreter_actual_path,

)

ctx.actions.symlink(output = interpreter, target_path = rel_path)

else:

interpreter = ctx.actions.declare_symlink("{}/{}".format(venv_bin_ctx_rel_path, py_exe_basename))

interpreter_runfiles.add(interpreter)

ctx.actions.symlink(output = interpreter, target_path = runtime.interpreter_path)

else:

interpreter = None

if runtime.interpreter_version_info:

version = "{}.{}".format(

runtime.interpreter_version_info.major,

runtime.interpreter_version_info.minor,

)

else:

version_flag = ctx.attr._python_version_flag[config_common.FeatureFlagInfo].value

version_flag_parts = version_flag.split(".")[0:2]

version = "{}.{}".format(*version_flag_parts)

# See site.py logic: free-threaded builds append "t" to the venv lib dir name

if "t" in runtime.abi_flags:

version += "t"

site_packages = "lib/python{}/site-packages".format(version)

return _venv_details(

interpreter = interpreter,

pyvenv_cfg = pyvenv_cfg,

site_packages = site_packages,

bin_dir = "bin",

include_dir = "include",

recreate_venv_at_runtime = recreate_venv_at_runtime,

interpreter_runfiles = interpreter_runfiles.build(ctx),

interpreter_symlinks = depset(),

)

def _create_venv_windows(ctx, *, venv_ctx_rel_root, runtime, interpreter_actual_path):

interpreter_runfiles = builders.RunfilesBuilder()

interpreter_symlinks = builders.DepsetBuilder()

# Some wrappers around the interpreter (e.g. pyenv) use the program

# name to decide what to do, so preserve the name.

py_exe_basename = paths.basename(interpreter_actual_path)

venv_bin_rel_path = "Scripts"

venv_bin_ctx_rel_path = "{}/{}".format(venv_ctx_rel_root, venv_bin_rel_path)

if runtime.interpreter:

venv_rel_path = paths.join(venv_bin_rel_path, py_exe_basename)

venv_ctx_rel_path = paths.join(venv_ctx_rel_root, venv_rel_path)

interpreter = ctx.actions.declare_file(venv_ctx_rel_path)

interpreter_runfiles.add(interpreter)

ctx.actions.symlink(output = interpreter, target_file = runtime.interpreter)

rf_path = runfiles_root_path(ctx, interpreter.short_path)

interpreter_symlinks.add(ExplicitSymlink(

runfiles_path = rf_path,

venv_path = venv_rel_path,

link_to_path = interpreter_actual_path,

files = depset([runtime.interpreter]),

))

# This isn't strictly correct, but should work ok.

interpreter_symlinks.add(ExplicitSymlink(

runfiles_path = paths.join(paths.dirname(rf_path), "pythonw.exe"),

venv_path = paths.join(paths.dirname(venv_rel_path), "pythonw.exe"),

link_to_path = paths.join(paths.dirname(interpreter_actual_path), "pythonw.exe"),

files = depset(),

))

else:

# It's OK to use declare_symlink here because an absolute path

# will be written to it, so Bazel won't mangle it.

interpreter = ctx.actions.declare_symlink("{}/{}".format(venv_bin_ctx_rel_path, py_exe_basename))

interpreter_runfiles.add(interpreter)

ctx.actions.symlink(output = interpreter, target_path = runtime.interpreter_path)

# NOTE: The .dll files must exist, however, they may not be known at build time

# if the interpreter is resolved at runtime.

for f in runtime.venv_bin_files:

venv_rel_path = paths.join(venv_bin_rel_path, f.basename)

venv_ctx_rel_path = paths.join(venv_ctx_rel_root, venv_rel_path)

venv_file = ctx.actions.declare_file(venv_ctx_rel_path)

ctx.actions.symlink(output = venv_file, target_file = f)

interpreter_runfiles.add(venv_file)

rf_path = runfiles_root_path(ctx, venv_file.short_path)

interpreter_symlinks.add(ExplicitSymlink(

runfiles_path = rf_path,

venv_path = venv_rel_path,

link_to_path = runfiles_root_path(ctx, f.short_path),

files = depset([f]),

))

# See site.py logic: Windows uses a version/build agnostic site-packages path

site_packages = "Lib/site-packages"

return _venv_details(

interpreter = interpreter,

pyvenv_cfg = None,

site_packages = site_packages,

bin_dir = venv_bin_rel_path,

include_dir = "Include",

recreate_venv_at_runtime = True,

interpreter_runfiles = interpreter_runfiles.build(ctx),

interpreter_symlinks = interpreter_symlinks.build(),

)

def _venv_details(

*,

interpreter,

pyvenv_cfg,

site_packages,

bin_dir,

include_dir,

recreate_venv_at_runtime,

interpreter_runfiles,

interpreter_symlinks):

"""Helper to create a struct of platform-specific venv details."""

return struct(

# File; the `bin/python` executable (or equivalent) within the venv.

interpreter = interpreter,

# File|None; the pyvenv.cfg file, if any. May be none, in which case,

# it's expected that one will be created at runtime.

pyvenv_cfg = pyvenv_cfg,

# str; venv-relative path to the site-packages directory

site_packages = site_packages,

# str; venv-relative path to the venv's bin directory.

bin_dir = bin_dir,

# str; venv-relative-path to the venv's include directory.

include_dir = include_dir,

# bool; True if the venv needs to be recreated at runtime (because the

# build-time construction isn't sufficient). False if the build-time

# constructed venv is sufficient.

recreate_venv_at_runtime = recreate_venv_at_runtime,

# runfiles; runfiles for interpreter-specific files in the venv.

interpreter_runfiles = interpreter_runfiles,

# depset[ExplicitSymlink] of symlinks specific

# to the interpreter. Only used for Windows.

interpreter_symlinks = interpreter_symlinks,

)

def _map_each_identity(v):

return v

def _get_coverage_tool_runfiles_path(ctx, runtime):

if (ctx.configuration.coverage_enabled and

runtime and

runtime.coverage_tool):

return runfiles_root_path(ctx, runtime.coverage_tool.short_path)

else:

return ""

def _create_stage2_bootstrap(

ctx,

*,

output_prefix,

output_sibling,

main_py,

imports,

runtime_details,

build_data_file,

venv):

output = ctx.actions.declare_file(

# Prepend with underscore to prevent pytest from trying to

# process the bootstrap for files starting with `test_`

"_{}_stage2_bootstrap.py".format(output_prefix),

sibling = output_sibling,

)

runtime = runtime_details.effective_runtime

template = runtime.stage2_bootstrap_template

if main_py:

main_py_path = runfiles_root_path(ctx, main_py.short_path)

else:

main_py_path = ""

ctx.actions.expand_template(

template = template,

output = output,

substitutions = {

"%build_data_file%": runfiles_root_path(ctx, build_data_file.short_path),

"%coverage_instrumented%": str(int(ctx.configuration.coverage_enabled and ctx.coverage_instrumented())),

"%coverage_tool%": _get_coverage_tool_runfiles_path(ctx, runtime),

"%import_all%": "True" if read_possibly_native_flag(ctx, "python_import_all_repositories") else "False",

"%imports%": ":".join(imports.to_list()),

"%main%": main_py_path,

"%main_module%": ctx.attr.main_module,

"%target%": str(ctx.label),

"%venv_rel_site_packages%": venv.venv_site_packages,

"%venv_root%": venv.venv_root,

"%workspace_name%": ctx.workspace_name,

},

is_executable = True,

)

return output

def _create_stage1_bootstrap(

ctx,

*,

output,

main_py = None,

stage2_bootstrap = None,

imports = None,

is_for_zip,

runtime_details,

venv = None):

"""Create a legacy bootstrap script that is written in Python."""

runtime = runtime_details.effective_runtime

if venv:

if venv.interpreter:

python_binary_path = runfiles_root_path(ctx, venv.interpreter.short_path)

else:

python_binary_path = ""

else:

python_binary_path = runtime_details.executable_interpreter_path

python_binary_actual = venv.interpreter_actual_path if venv else ""

# Guard against the following:

# * Runtime may be None on Windows due to the --python_path flag.

# * Runtime may not have 'supports_build_time_venv' if a really old version is autoloaded

# on bazel 7.6.x.

if runtime and getattr(runtime, "supports_build_time_venv", False):

resolve_python_binary_at_runtime = "0"

else:

resolve_python_binary_at_runtime = "1"

subs = {

"%interpreter_args%": "\n".join(ctx.attr.interpreter_args),

"%is_zipfile%": "1" if is_for_zip else "0",

"%python_binary%": python_binary_path,

"%python_binary_actual%": python_binary_actual,

"%recreate_venv_at_runtime%": str(int(venv.recreate_venv_at_runtime)) if venv else "0",

"%resolve_python_binary_at_runtime%": resolve_python_binary_at_runtime,

"%target%": str(ctx.label),

"%venv_rel_site_packages%": venv.venv_site_packages if venv else "",

"%workspace_name%": ctx.workspace_name,

}

computed_subs = ctx.actions.template_dict()

if venv:

runtime_venv_symlinks = depset(

transitive = [venv.interpreter_symlinks, venv.lib_symlinks],

)

computed_subs.add_joined(

"%runtime_venv_symlinks%",

runtime_venv_symlinks,

join_with = "\n",

map_each = _map_runtime_venv_symlink,

)

if stage2_bootstrap:

subs["%stage2_bootstrap%"] = runfiles_root_path(ctx, stage2_bootstrap.short_path)

template = runtime.bootstrap_template

subs["%shebang%"] = runtime.stub_shebang

elif not ctx.files.srcs:

fail("mandatory 'srcs' files have not been provided")

else:

if (ctx.configuration.coverage_enabled and

runtime and

runtime.coverage_tool):

coverage_tool_runfiles_path = runfiles_root_path(ctx, runtime.coverage_tool.short_path)

else:

coverage_tool_runfiles_path = ""

if runtime:

subs["%shebang%"] = runtime.stub_shebang

template = runtime.bootstrap_template

else:

subs["%shebang%"] = DEFAULT_STUB_SHEBANG

template = ctx.file._bootstrap_template

subs["%coverage_tool%"] = coverage_tool_runfiles_path

subs["%import_all%"] = ("True" if read_possibly_native_flag(ctx, "python_import_all_repositories") else "False")

subs["%imports%"] = ":".join(imports.to_list())

subs["%main%"] = runfiles_root_path(ctx, main_py.short_path)

ctx.actions.expand_template(

template = template,

output = output,

substitutions = subs,

computed_substitutions = computed_subs,

is_executable = True,

)

def _map_runtime_venv_symlink(entry):

return entry.venv_path + "|" + entry.link_to_path

def _create_zip_file(ctx, *, output, zip_main, runfiles):

"""Create a Python zipapp (zip with __main__.py entry point)."""

workspace_name = ctx.workspace_name

legacy_external_runfiles = _py_builtins.get_legacy_external_runfiles(ctx)

manifest = ctx.actions.args()

manifest.use_param_file("@%s", use_always = True)

manifest.set_param_file_format("multiline")

manifest.add("__main__.py={}".format(zip_main.path))

manifest.add("__init__.py=")