blob: db5b30e0b61b03edf1c136a6b7769126567faf2f [file] [log] [blame]
# Copyright (c) 2009-2021, Google LLC
# All rights reserved.
#
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file or at
# https://developers.google.com/open-source/licenses/bsd
"""Repository rule for using Python 3.x headers from the system."""
# Mock out rules_python's pip.bzl for cases where no system python is found.
_mock_pip = """
def _pip_install_impl(repository_ctx):
repository_ctx.file("BUILD.bazel", '''
py_library(
name = "noop",
visibility = ["//visibility:public"],
)
''')
repository_ctx.file("requirements.bzl", '''
def install_deps(*args, **kwargs):
print("WARNING: could not install pip dependencies")
def requirement(*args, **kwargs):
return "@{}//:noop"
'''.format(repository_ctx.attr.name))
pip_install = repository_rule(
implementation = _pip_install_impl,
attrs = {
"requirements": attr.string(),
"requirements_overrides": attr.string_dict(),
"python_interpreter_target": attr.string(),
},
)
pip_parse = pip_install
"""
# Alias rules_python's pip.bzl for cases where a system python is found.
_alias_pip = """
load("@rules_python//python:pip.bzl", _pip_parse = "pip_parse")
def _get_requirements(requirements, requirements_overrides):
for version, override in requirements_overrides.items():
if version in "{python_version}":
requirements = override
break
return requirements
def pip_parse(requirements, requirements_overrides={{}}, **kwargs):
_pip_parse(
python_interpreter_target = "@{repo}//:interpreter",
requirements_lock = _get_requirements(requirements, requirements_overrides),
**kwargs,
)
pip_install = pip_parse
"""
_mock_fuzzing_py = """
def fuzzing_py_install_deps():
print("WARNING: could not install fuzzing_py dependencies")
"""
# Alias rules_fuzzing's requirements.bzl for cases where a system python is found.
_alias_fuzzing_py = """
load("@fuzzing_py_deps//:requirements.bzl", _fuzzing_py_install_deps = "install_deps")
def fuzzing_py_install_deps():
_fuzzing_py_install_deps()
"""
_build_file = """
load("@bazel_skylib//lib:selects.bzl", "selects")
load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
load("@bazel_tools//tools/python:toolchain.bzl", "py_runtime_pair")
cc_library(
name = "python_headers",
hdrs = glob(["python/**/*.h"], allow_empty = True),
includes = ["python"],
visibility = ["//visibility:public"],
)
string_flag(
name = "internal_python_support",
build_setting_default = "{support}",
values = [
"None",
"Supported",
"Unsupported",
]
)
config_setting(
name = "none",
flag_values = {{
":internal_python_support": "None",
}},
visibility = ["//visibility:public"],
)
config_setting(
name = "supported",
flag_values = {{
":internal_python_support": "Supported",
}},
visibility = ["//visibility:public"],
)
config_setting(
name = "unsupported",
flag_values = {{
":internal_python_support": "Unsupported",
}},
visibility = ["//visibility:public"],
)
selects.config_setting_group(
name = "exists",
match_any = [":supported", ":unsupported"],
visibility = ["//visibility:public"],
)
sh_binary(
name = "interpreter",
srcs = ["interpreter"],
visibility = ["//visibility:public"],
)
py_runtime(
name = "py3_runtime",
interpreter_path = "{interpreter}",
python_version = "PY3",
)
py_runtime_pair(
name = "runtime_pair",
py3_runtime = ":py3_runtime",
)
toolchain(
name = "python_toolchain",
toolchain = ":runtime_pair",
toolchain_type = "@rules_python//python:toolchain_type",
)
"""
_register = """
def register_system_python():
native.register_toolchains("@{}//:python_toolchain")
"""
_mock_register = """
def register_system_python():
pass
"""
def _get_python_version(repository_ctx):
py_program = "import sys; print(str(sys.version_info.major) + '.' + str(sys.version_info.minor) + '.' + str(sys.version_info.micro))"
result = repository_ctx.execute(["python3", "-c", py_program])
return (result.stdout).strip().split(".")
def _get_python_path(repository_ctx):
py_program = "import sysconfig; print(sysconfig.get_config_var('%s'), end='')"
result = repository_ctx.execute(["python3", "-c", py_program % ("INCLUDEPY")])
if result.return_code != 0:
return None
return result.stdout
def _populate_package(ctx, path, python3, python_version):
ctx.symlink(path, "python")
supported = True
for idx, v in enumerate(ctx.attr.minimum_python_version.split(".")):
if int(python_version[idx]) < int(v):
supported = False
break
if "win" in ctx.os.name:
# buildifier: disable=print
print("WARNING: python is not supported on Windows")
supported = False
build_file = _build_file.format(
interpreter = python3,
support = "Supported" if supported else "Unsupported",
)
ctx.file("interpreter", "#!/bin/sh\nexec {} \"$@\"".format(python3))
ctx.file("BUILD.bazel", build_file)
ctx.file("version.bzl", "SYSTEM_PYTHON_VERSION = '{}{}'".format(python_version[0], python_version[1]))
ctx.file("register.bzl", _register.format(ctx.attr.name))
if supported:
ctx.file("pip.bzl", _alias_pip.format(
python_version = ".".join(python_version),
repo = ctx.attr.name,
))
ctx.file("fuzzing_py.bzl", _alias_fuzzing_py)
else:
# Dependencies are unlikely to be satisfiable for unsupported versions of python.
ctx.file("pip.bzl", _mock_pip)
ctx.file("fuzzing_py.bzl", _mock_fuzzing_py)
def _populate_empty_package(ctx):
# Mock out all the entrypoints we need to run from WORKSPACE. Targets that
# actually need python should use `target_compatible_with` and the generated
# @system_python//:exists or @system_python//:supported constraints.
ctx.file(
"BUILD.bazel",
_build_file.format(
interpreter = "",
support = "None",
),
)
ctx.file("version.bzl", "SYSTEM_PYTHON_VERSION = 'None'")
ctx.file("register.bzl", _mock_register)
ctx.file("pip.bzl", _mock_pip)
ctx.file("fuzzing_py.bzl", _mock_fuzzing_py)
def _system_python_impl(repository_ctx):
path = _get_python_path(repository_ctx)
python3 = repository_ctx.which("python3")
python_version = _get_python_version(repository_ctx)
if path and python_version[0] == "3":
_populate_package(repository_ctx, path, python3, python_version)
else:
# buildifier: disable=print
print("WARNING: no system python available, builds against system python will fail")
_populate_empty_package(repository_ctx)
# The system_python() repository rule exposes information from the version of python installed in the current system.
#
# In WORKSPACE:
# system_python(
# name = "system_python_repo",
# minimum_python_version = "3.7",
# )
#
# This repository exposes some repository rules for configuring python in Bazel. The python toolchain
# *must* be registered in your WORKSPACE:
# load("@system_python_repo//:register.bzl", "register_system_python")
# register_system_python()
#
# Pip dependencies can optionally be specified using a wrapper around rules_python's repository rules:
# load("@system_python//:pip.bzl", "pip_install")
# pip_install(
# name="pip_deps",
# requirements = "@com_google_protobuf//python:requirements.txt",
# )
# An optional argument `requirements_overrides` takes a dictionary mapping python versions to alternate
# requirements files. This works around the requirement for fully pinned dependencies in python_rules.
#
# Four config settings are exposed from this repository to help declare target compatibility in Bazel.
# For example, `@system_python_repo//:exists` will be true if a system python version has been found.
# The `none` setting will be true only if no python version was found, and `supported`/`unsupported`
# correspond to whether or not the system version is compatible with `minimum_python_version`.
#
# This repository also exposes a header rule that you can depend on from BUILD files:
# cc_library(
# name = "foobar",
# srcs = ["foobar.cc"],
# deps = ["@system_python_repo//:python_headers"],
# )
#
# The headers should correspond to the version of python obtained by running
# the `python3` command on the system.
system_python = repository_rule(
implementation = _system_python_impl,
local = True,
attrs = {
"minimum_python_version": attr.string(default = "3.7"),
},
)