# 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.

"""This module is used to construct the config settings in the BUILD file in this same package.

"""

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

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

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

_PYTHON_VERSION_FLAG = Label("//python/config_settings:python_version")

_PYTHON_VERSION_MAJOR_MINOR_FLAG = Label("//python/config_settings:python_version_major_minor")

def construct_config_settings(*, name, default_version, versions, minor_mapping): # buildifier: disable=function-docstring

"""Create a 'python_version' config flag and construct all config settings used in rules_python.

This mainly includes the targets that are used in the toolchain and pip hub

repositories that only match on the 'python_version' flag values.

Args:

name: {type}`str` A dummy name value that is no-op for now.

default_version: {type}`str` the default value for the `python_version` flag.

versions: {type}`list[str]` A list of versions to build constraint settings for.

minor_mapping: {type}`dict[str, str]` A mapping from `X.Y` to `X.Y.Z` python versions.

"""

_ = name # @unused

_python_version_flag(

name = _PYTHON_VERSION_FLAG.name,

build_setting_default = default_version,

visibility = ["//visibility:public"],

)

_python_version_major_minor_flag(

name = _PYTHON_VERSION_MAJOR_MINOR_FLAG.name,

build_setting_default = "",

visibility = ["//visibility:public"],

)

native.config_setting(

name = "is_python_version_unset",

flag_values = {_PYTHON_VERSION_FLAG: ""},

visibility = ["//visibility:public"],

)

_reverse_minor_mapping = {full: minor for minor, full in minor_mapping.items()}

for version in versions:

minor_version = _reverse_minor_mapping.get(version)

if not minor_version:

native.config_setting(

name = "is_python_{}".format(version),

flag_values = {":python_version": version},

visibility = ["//visibility:public"],

)

continue

# Also need to match the minor version when using

name = "is_python_{}".format(version)

native.config_setting(

name = "_" + name,

flag_values = {":python_version": version},

visibility = ["//visibility:public"],

)

# An alias pointing to an underscore-prefixed config_setting_group

# is used because config_setting_group creates

# `is_{version}_N` targets, which are easily confused with the

# `is_{minor}.{micro}` (dot) targets.

selects.config_setting_group(

name = "_{}_group".format(name),

match_any = [

":_is_python_{}".format(version),

":is_python_{}".format(minor_version),

],

visibility = ["//visibility:private"],

)

native.alias(

name = name,

actual = "_{}_group".format(name),

visibility = ["//visibility:public"],

)

# This matches the raw flag value, e.g. --//python/config_settings:python_version=3.8

# It's private because matching the concept of e.g. "3.8" value is done

# using the `is_python_X.Y` config setting group, which is aware of the

# minor versions that could match instead.

for minor in minor_mapping.keys():

native.config_setting(

name = "is_python_{}".format(minor),

flag_values = {_PYTHON_VERSION_MAJOR_MINOR_FLAG: minor},

visibility = ["//visibility:public"],

)

def _python_version_flag_impl(ctx):

value = ctx.build_setting_value

return [

# BuildSettingInfo is the original provider returned, so continue to

# return it for compatibility

BuildSettingInfo(value = value),

# FeatureFlagInfo is returned so that config_setting respects the value

# as returned by this rule instead of as originally seen on the command

# line.

# It is also for Google compatibility, which expects the FeatureFlagInfo

# provider.

config_common.FeatureFlagInfo(value = value),

]

_python_version_flag = rule(

implementation = _python_version_flag_impl,

build_setting = config.string(flag = True),

attrs = {},

)

def _python_version_major_minor_flag_impl(ctx):

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

if input:

version = semver(input)

value = "{}.{}".format(version.major, version.minor)

else:

value = ""

return [config_common.FeatureFlagInfo(value = value)]

_python_version_major_minor_flag = rule(

implementation = _python_version_major_minor_flag_impl,

build_setting = config.string(flag = False),

attrs = {

"_python_version_flag": attr.label(

default = _PYTHON_VERSION_FLAG,

),

},

)