forked from bazel-contrib/rules_python
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathflags.bzl
More file actions
238 lines (209 loc) · 8.73 KB
/
flags.bzl
File metadata and controls
238 lines (209 loc) · 8.73 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
# Copyright 2024 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.
"""Values and helpers for flags.
NOTE: The transitive loads of this should be kept minimal. This avoids loading
unnecessary files when all that are needed are flag definitions.
"""
load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
load(":enum.bzl", "FlagEnum", "enum")
# Maps "--myflag" to a tuple of:
#
# - the flag's ctx.fragments native API accessor
# -"native|starlark": which definition to use if the flag is available both
# from ctx.fragments and Starlark
#
# Builds that set --incompatible_remove_ctx_py_fragment or
# --incompatible_remove_ctx_bazel_py_fragment disable ctx.fragments. These
# builds assume flags are solely defined in Starlark.
#
# The "native|starlark" override is only for devs who are testing flag
# Starlarkification. If ctx.fragments.[py|bazel_py] is available and
# a flag is set to "starlark", we exclusively read its starlark version.
#
# See https://github.com/bazel-contrib/rules_python/issues/3252.
_POSSIBLY_NATIVE_FLAGS = {
"build_python_zip": (lambda ctx: ctx.fragments.py.build_python_zip, "native"),
"default_to_explicit_init_py": (lambda ctx: ctx.fragments.py.default_to_explicit_init_py, "native"),
"python_import_all_repositories": (lambda ctx: ctx.fragments.bazel_py.python_import_all_repositories, "native"),
"python_path": (lambda ctx: ctx.fragments.bazel_py.python_path, "native"),
}
def read_possibly_native_flag(ctx, flag_name):
"""
Canonical API for reading a Python build flag.
Flags might be defined in Starlark or native-Bazel. This function reasd flags
from tbe correct source based on supporting Bazel version and --incompatible*
flags that disable native references.
Args:
ctx: Rule's configuration context.
flag_name: Name of the flag to read, without preceding "--".
Returns:
The flag's value.
"""
# Bazel 9.0+ can disable these fragments with --incompatible_remove_ctx_py_fragment and
# --incompatible_remove_ctx_bazel_py_fragment. Disabling them means bazel expects
# Python to read Starlark flags.
use_native_def = hasattr(ctx.fragments, "py") and hasattr(ctx.fragments, "bazel_py")
# Developer override to force the Starlark definition for testing.
if _POSSIBLY_NATIVE_FLAGS[flag_name][1] == "starlark":
use_native_def = False
if use_native_def:
return _POSSIBLY_NATIVE_FLAGS[flag_name][0](ctx)
else:
# Starlark definition of "--foo" is assumed to be a label dependency named "_foo".
return getattr(ctx.attr, "_" + flag_name + "_flag")[BuildSettingInfo].value
def _AddSrcsToRunfilesFlag_is_enabled(ctx):
value = ctx.attr._add_srcs_to_runfiles_flag[BuildSettingInfo].value
if value == AddSrcsToRunfilesFlag.AUTO:
value = AddSrcsToRunfilesFlag.ENABLED
return value == AddSrcsToRunfilesFlag.ENABLED
# buildifier: disable=name-conventions
AddSrcsToRunfilesFlag = FlagEnum(
AUTO = "auto",
ENABLED = "enabled",
DISABLED = "disabled",
is_enabled = _AddSrcsToRunfilesFlag_is_enabled,
)
def _string_flag_impl(ctx):
if ctx.attr.override:
value = ctx.attr.override
else:
value = ctx.build_setting_value
if value not in ctx.attr.values:
fail((
"Invalid value for {name}: got {value}, must " +
"be one of {allowed}"
).format(
name = ctx.label,
value = value,
allowed = ctx.attr.values,
))
return [
BuildSettingInfo(value = value),
config_common.FeatureFlagInfo(value = value),
]
string_flag = rule(
implementation = _string_flag_impl,
build_setting = config.string(flag = True),
attrs = {
"override": attr.string(),
"values": attr.string_list(),
},
)
def _bootstrap_impl_flag_get_value(ctx):
return ctx.attr._bootstrap_impl_flag[config_common.FeatureFlagInfo].value
# buildifier: disable=name-conventions
BootstrapImplFlag = enum(
SYSTEM_PYTHON = "system_python",
SCRIPT = "script",
get_value = _bootstrap_impl_flag_get_value,
)
def _precompile_flag_get_effective_value(ctx):
value = ctx.attr._precompile_flag[BuildSettingInfo].value
if value == PrecompileFlag.AUTO:
value = PrecompileFlag.DISABLED
return value
# Determines if the Python exec tools toolchain should be registered.
# buildifier: disable=name-conventions
ExecToolsToolchainFlag = enum(
# Enable registering the exec tools toolchain using the hermetic toolchain.
ENABLED = "enabled",
# Disable registering the exec tools toolchain using the hermetic toolchain.
DISABLED = "disabled",
)
# Determines if Python source files should be compiled at build time.
#
# NOTE: The flag value is overridden by the target-level attribute, except
# for the case of `force_enabled` and `forced_disabled`.
# buildifier: disable=name-conventions
PrecompileFlag = enum(
# Automatically decide the effective value based on environment,
# target platform, etc.
AUTO = "auto",
# Compile Python source files at build time.
ENABLED = "enabled",
# Don't compile Python source files at build time.
DISABLED = "disabled",
# Like `enabled`, except overrides target-level setting. This is mostly
# useful for development, testing enabling precompilation more broadly, or
# as an escape hatch to force all transitive deps to precompile.
FORCE_ENABLED = "force_enabled",
# Like `disabled`, except overrides target-level setting. This is useful
# useful for development, testing enabling precompilation more broadly, or
# as an escape hatch if build-time compiling is not available.
FORCE_DISABLED = "force_disabled",
get_effective_value = _precompile_flag_get_effective_value,
)
def _precompile_source_retention_flag_get_effective_value(ctx):
value = ctx.attr._precompile_source_retention_flag[BuildSettingInfo].value
if value == PrecompileSourceRetentionFlag.AUTO:
value = PrecompileSourceRetentionFlag.KEEP_SOURCE
return value
# Determines if, when a source file is compiled, if the source file is kept
# in the resulting output or not.
# buildifier: disable=name-conventions
PrecompileSourceRetentionFlag = enum(
# Automatically decide the effective value based on environment, etc.
AUTO = "auto",
# Include the original py source in the output.
KEEP_SOURCE = "keep_source",
# Don't include the original py source.
OMIT_SOURCE = "omit_source",
get_effective_value = _precompile_source_retention_flag_get_effective_value,
)
def _venvs_use_declare_symlink_flag_get_value(ctx):
return ctx.attr._venvs_use_declare_symlink_flag[BuildSettingInfo].value
# Decides if the venv created by bootstrap=script uses declare_file() to
# create relative symlinks. Workaround for #2489 (packaging rules not supporting
# declare_link() files).
# buildifier: disable=name-conventions
VenvsUseDeclareSymlinkFlag = FlagEnum(
# Use declare_file() and relative symlinks in the venv
YES = "yes",
# Do not use declare_file() and relative symlinks in the venv
NO = "no",
get_value = _venvs_use_declare_symlink_flag_get_value,
)
def _venvs_site_packages_is_enabled(ctx):
if not ctx.attr.experimental_venvs_site_packages:
return False
flag_value = ctx.attr.experimental_venvs_site_packages[BuildSettingInfo].value
return flag_value == VenvsSitePackages.YES
# Decides if libraries try to use a site-packages layout using venv_symlinks
# buildifier: disable=name-conventions
VenvsSitePackages = FlagEnum(
# Use venv_symlinks
YES = "yes",
# Don't use venv_symlinks
NO = "no",
is_enabled = _venvs_site_packages_is_enabled,
)
# Used for matching freethreaded toolchains and would have to be used in wheels
# as well.
# buildifier: disable=name-conventions
FreeThreadedFlag = enum(
# Use freethreaded python toolchain and wheels.
YES = "yes",
# Do not use freethreaded python toolchain and wheels.
NO = "no",
)
# Determines which libc flavor is preferred when selecting the toolchain and
# linux whl distributions.
#
# buildifier: disable=name-conventions
LibcFlag = FlagEnum(
# Prefer glibc wheels (e.g. manylinux_2_17_x86_64 or linux_x86_64)
GLIBC = "glibc",
# Prefer musl wheels (e.g. musllinux_2_17_x86_64)
MUSL = "musl",
)