source values from select and flags

Author: rickeylev

python/config_settings/BUILD.bazel

@@ -220,3 +220,21 @@ string_flag(
 define_pypi_internal_flags(
     name = "define_pypi_internal_flags",
 )
+
+# todo: have single --pypi_env_config flag instead? Under the hood, it
+# could be driven more more discrete flags, which could be considered an
+# implementation detail of our particular impl.
+# A label is used to allow users to use select() to affect the value.
+# A target providing BuildSettingInfo is used to allow users to define
+# a flag as the target, which lets them CLI-override or transition it easily.
+label_flag(
+    name = "pip_platform_release_config",
+    build_setting_default = ":_pip_platform_release_default_config",
+)
+
+# docs: points to a label that provides BuildSettingInfo for the value.
+# A label and BuildSettingInfo are used for the same reason as platform_release
+label_flag(
+    name = "pip_platform_version_config",
+    build_setting_default = ":_pip_platform_version_default_config",
+)

python/private/pypi/dependency_specifier_flag.bzl

@@ -1,7 +1,10 @@
 load("//python/private:toolchain_types.bzl", "TARGET_TOOLCHAIN_TYPE")
 load(":pep508_evaluate.bzl", "evaluate")
 
+# todo: maybe put all the env into a single target and have a
+# PyPiEnvMarkersInfo provider? Have --pypi_env=//some:target?
 def _impl(ctx):
+    # todo: should unify with pep508_env.bzl
     env = {}
 
     runtime = ctx.toolchains[TARGET_TOOLCHAIN_TYPE].py3_runtime
@@ -20,28 +23,16 @@ def _impl(ctx):
     # We assume cpython if the toolchain doesn't specify because it's most
     # likely to be true.
     env["implementation_name"] = runtime.implementation_name or "cpython"
-
-    # todo: map from os constraint
-    env["os_name"] = struct()
-
-    # todo: map from os constraint
-    env["sys_platform"] = struct()
-
-    # todo: map from cpu flag (x86_64, etc)
-    env["platform_machine"] = struct()
+    env["os_name"] = ctx.attr.os_name
+    env["sys_platform"] = ctx.attr.sys_platform
+    env["platform_machine"] = ctx.attr.platform_machine
 
     # todo: add PyRuntimeInfo.platform_python_implementation
     # The values are slightly different to implementation_name
     env["platform_python_implementation"] = runtime.implementation_name
-
-    # todo: add flag to carry this
-    env["platform_release"] = struct()
-
-    # todo: map from os constraint
-    env["platform_system"] = struct()
-
-    # todo: add flag to carry this
-    env["platform_version"] = struct()
+    env["platform_release"] = ctx.attr._platform_release_config_flag[BuildSettingInfo].value
+    env["platform_system"] = ctx.attr.platform_system
+    env["platform_version"] = ctx.attr._platform_version_config_flag[BuildSettingInfo].value
 
     if evalute(ctx.attr.expression, env):
         value = "yes"
@@ -67,15 +58,60 @@ def format_full_info(info):
     )
     return version
 
+def pypa_dep_spec(**kwargs):
+    pypa_dependency_specification(
+        # todo: copied from pep508_env.bzl
+        os_name = select({
+            # The "java" value is documented, but with Jython defunct,
+            # shouldn't occur in practice.
+            # The osname value is technically a property of the runtime, not the
+            # targetted OS at runtime, but the distinction shouldn't matter in
+            # practice.
+            "@//platforms/os:windows": "nt",
+            "//conditions:default": "posix",
+        }),
+        # todo: copied from pep508_env.bzl
+        sys_platform = select({
+            "@//platforms/os:windows": "win32",
+            "@//platforms/os:linux": "linux",
+            "@//platforms/os:osx": "darwin",
+            # todo: what does spec say unknown value is?
+            "//conditions:default": "",
+        }),
+        # todo: copied from pep508_env.bzl
+        # todo: there are many more cpus. Unfortunately, it doesn't look like
+        # the value is directly accessible to starlark. It might be possible to
+        # get it via CcToolchain.cpu though.
+        platform_machine = select({
+            "@platforms//cpu:x86_64": "x86_64",
+            "@platforms//cpu:aarch64": "aarch64",
+            # todo: what does spec say unknown value is?
+            "//conditions:default": "",
+        }),
+        # todo: copied from pep508_env.bzl
+        platform_system = select({
+            "@//platforms/os:windows": "Windows",
+            "@//platforms/os:linux": "Linux",
+            "@//platforms/os:osx": "Darwin",
+            # todo: what does spec say unknown value is?
+            "//conditions:default": "",
+        }),
+    )
+
 pypa_dependency_specification = rule(
     implementation = _impl,
     attrs = {
         "expression": attt.string(),
-        "_os_name": attr.label(),
-        "_sys_platform_flag": attr.label(),
-        "_platform_release_flag": attr.label(),
-        "_platform_system_flag": attr.label(),
-        "_platform_version_flag": attr.label(),
+        "os_name": attr.string(),
+        "sys_platform": attr.string(),
+        "platform_machine": attr.string(),
+        "platform_system": attr.string(),
+        "_platform_release_config_flag": attr.label(
+            default = "//python/config_settings:pip_platform_release_config",
+        ),
+        "_platform_version_config_flag": attr.label(
+            default = "//python/config_settings:pip_platform_version_config",
+        ),
         "_python_version_flag": attr.label(
             default = "//python/config_settings:_python_version_major_minor",
         ),

python/private/pypi/flags.bzl

@@ -81,6 +81,20 @@ def define_pypi_internal_flags(name):
         name = "_internal_pip_whl",
         visibility = ["//visibility:public"],
     )
+    _platform_release_config(
+        name = "_pip_platform_release_default_config",
+        value = select({
+            "//conditions:osx": "USE_OSX_VERSION_FLAG",
+            "//conditions:default": "",
+        }),
+    )
+    _platform_version_config(
+        name = "_pip_platform_version_default_config",
+        value = select({
+            "//conditions:osx": "USE_OSX_VERSION_FLAG",
+            "//conditions:default": "",
+        }),
+    )
 
 def _allow_wheels_flag_impl(ctx):
     input = ctx.attr._setting[BuildSettingInfo].value
@@ -97,3 +111,35 @@ This rule allows us to greatly reduce the number of config setting targets at no
 if we are duplicating some of the functionality of the `native.config_setting`.
 """,
 )
+
+def _platform_release_config_impl(ctx):
+    value = ctx.attr.value
+    if value == "USE_OSX_VERSION_FLAG":
+        value = ctx.attr._osx_version[BuildSettingInfo].value
+
+    return [BuildSettingInfo(value = ctx.attr.value)]
+
+# This value is loosely some version-value looking thing, but the format
+# varies depending on the OS.
+_platform_release_config = rule(
+    implementation = _platform_release_config_impl,
+    attrs = {
+        "value": attr.string(),
+        "_osx_version": attr.label(
+            default = "//python/config_settings:pip_whl_osx_version",
+        ),
+    },
+)
+
+def _platform_version_config_impl(ctx):
+    value = ctx.attr.value
+    return [BuildSettingInfo(value = ctx.attr.value)]
+
+# Despite its name, this "version" value is not a simple version value.
+# It's a more detailed, arbitrary, description the OS gives about itself.
+_platform_version_config = rule(
+    implementation = _platform_version_config_impl,
+    attrs = {
+        "value": attr.string(),
+    },
+)