Import pip requirements into Bazel.
Macros and Functions
compile_pip_requirements
Generates targets for managing pip dependencies with pip-compile.
By default this rules generates a filegroup named "[name]" which can be included in the data
of some other compile_pip_requirements rule that references these requirements
(e.g. with -r ../other/requirements.txt
).
It also generates two targets for running pip-compile:
- validate with
bazel test <name>_test
- update with
bazel run <name>.update
Example usage (generated)
load("@rules_python//python:pip.bzl", "compile_pip_requirements")
compile_pip_requirements(
# base name for generated targets, typically "requirements"
name = "",
)
name
base name for generated targets, typically "requirements"
extra_args
passed to pip-compile
visibility
passed to both the _test and .update rules
requirements_in
file expressing desired dependencies
requirements_txt
result of "compiling" the requirements.in file
tags
tagging attribute common to all build rules, passed to both the _test and .update rules
kwargs
other bazel attributes passed to the "_test" rule
package_annotation
Annotations to apply to the BUILD file content from package generated from a pip_repository
rule.
Example usage (generated)
load("@rules_python//python:pip.bzl", "package_annotation")
package_annotation(
)
additive_build_content
Raw text to add to the generated BUILD
file of a package.
copy_files
A mapping of src
and out
files for [@bazel_skylib//rules:copy_file.bzl][cf]
copy_executables
A mapping of src
and out
files for
[@bazel_skylib//rules:copy_file.bzl][cf]. Targets generated here will also be flagged as
executable.
data
A list of labels to add as data
dependencies to the generated py_library
target.
data_exclude_glob
A list of exclude glob patterns to add as data
to the generated
py_library
target.
srcs_exclude_glob
A list of labels to add as srcs
to the generated py_library
target.
pip_install
Accepts a requirements.txt
file and installs the dependencies listed within.
Those dependencies become available in a generated requirements.bzl
file.
This macro runs a repository rule that invokes pip
. In your WORKSPACE file:
pip_install(
requirements = ":requirements.txt",
)
You can then reference installed dependencies from a BUILD
file with:
load("@pip//:requirements.bzl", "requirement")
py_library(
name = "bar",
...
deps = [
"//my/other:dep",
requirement("requests"),
requirement("numpy"),
],
)
Note that this convenience comes with a cost. Analysis of any BUILD file which loads the requirements helper in this way will cause an eager-fetch of all the pip dependencies, even if no python targets are requested to be built. In a multi-language repo, this may cause developers to fetch dependencies they don't need, so consider using the long form for dependencies if this happens.
In addition to the requirement
macro, which is used to access the py_library
target generated from a package's wheel, the generated requirements.bzl
file contains
functionality for exposing entry points as py_binary
targets.
load("@pip_deps//:requirements.bzl", "entry_point")
alias(
name = "pip-compile",
actual = entry_point(
pkg = "pip-tools",
script = "pip-compile",
),
)
Note that for packages whose name and script are the same, only the name of the package
is needed when calling the entry_point
macro.
load("@pip_deps//:requirements.bzl", "entry_point")
alias(
name = "flake8",
actual = entry_point("flake8"),
)
Example usage (generated)
load("@rules_python//python:pip.bzl", "pip_install")
pip_install(
# A 'requirements.txt' pip requirements file.
requirements = None,
)
requirements
A 'requirements.txt' pip requirements file.
name
A unique name for the created external repository (default 'pip').
kwargs
Keyword arguments passed directly to the pip_repository
repository rule.
pip_parse
Accepts a locked/compiled requirements file and installs the dependencies listed within.
Those dependencies become available in a generated requirements.bzl
file.
You can instead check this requirements.bzl
file into your repo, see the "vendoring" section below.
This macro runs a repository rule that invokes pip
. In your WORKSPACE file:
load("@rules_python//python:pip.bzl", "pip_parse")
pip_parse(
name = "pip_deps",
requirements_lock = ":requirements.txt",
)
load("@pip_deps//:requirements.bzl", "install_deps")
install_deps()
You can then reference installed dependencies from a BUILD
file with:
load("@pip_deps//:requirements.bzl", "requirement")
py_library(
name = "bar",
...
deps = [
"//my/other:dep",
requirement("requests"),
requirement("numpy"),
],
)
In addition to the requirement
macro, which is used to access the generated py_library
target generated from a package's wheel, The generated requirements.bzl
file contains
functionality for exposing entry points as py_binary
targets as well.
load("@pip_deps//:requirements.bzl", "entry_point")
alias(
name = "pip-compile",
actual = entry_point(
pkg = "pip-tools",
script = "pip-compile",
),
)
Note that for packages whose name and script are the same, only the name of the package
is needed when calling the entry_point
macro.
load("@pip_deps//:requirements.bzl", "entry_point")
alias(
name = "flake8",
actual = entry_point("flake8"),
)
Vendoring the requirements.bzl file
In some cases you may not want to generate the requirements.bzl file as a repository rule while Bazel is fetching dependencies. For example, if you produce a reusable Bazel module such as a ruleset, you may want to include the requirements.bzl file rather than make your users install the WORKSPACE setup to generate it. See https://github.com/bazelbuild/rules_python/issues/608
This is the same workflow as Gazelle, which creates go_repository
rules with
update-repos
Simply run the same tool that the pip_parse
repository rule calls.
You can find the arguments in the generated BUILD file in the pip_parse repo,
for example in $(bazel info output_base)/external/pypi/BUILD.bazel
for a repo
named pypi
.
The command will look like this:
bazel run -- @rules_python//python/pip_install/parse_requirements_to_bzl \
--requirements_lock ./requirements_lock.txt \
--quiet False --timeout 120 --repo pypi --repo-prefix pypi_ > requirements.bzl
Then load the requirements.bzl file directly, without using pip_parse
in the WORKSPACE.
requirements_lock
A fully resolved 'requirements.txt' pip requirement file containing the transitive set of your dependencies. If this file is passed instead of 'requirements' no resolve will take place and pip_repository will create individual repositories for each of your dependencies so that wheels are fetched/built only for the targets specified by 'build/run/test'.
name
The name of the generated repository. The generated repositories
containing each requirement will be of the form
kwargs
Additional keyword arguments for the underlying
pip_repository
rule.
pip_repositories
Obsolete macro to pull in dependencies needed to use the pip_import rule.
Example usage (generated)
load("@rules_python//python:pip.bzl", "pip_repositories")
pip_repositories(
)