Skip to main content

attrs

any​

def any(
*,
doc: str = "",
default = ...,
) -> Attr

Takes most builtin literals and passes them to the rule as a string. Discouraged, as it provides little type safety and destroys the structure.

arg​

def arg(
*,
json: bool = False,
default = ...,
doc: str = "",
anon_target_compatible: bool = False,
) -> Attr

Takes a command line argument from the user and supplies a cmd_args compatible value to the rule. The argument may contain special macros such as $(location :my_target) or $(exe :my_target) which will be replaced with references to those values in the rule. Takes in an optional anon_target_compatible flag, which indicates whether the args can be passed into anon targets. Note that there is a slight memory hit when using this flag.

bool​

def bool(
*,
default = ...,
doc: str = "",
) -> Attr

Takes a boolean and passes it to the rule as a boolean.

configuration_label​

def configuration_label(
*,
doc: str = "",
) -> Attr

configured_dep​

def configured_dep(
*,
providers: list | tuple = [],
default = ...,
doc: str = "",
) -> Attr

default_only​

def default_only(
inner: Attr,
/,
*,
doc: str = "",
) -> Attr

Rejects all values and uses the default for the inner argument. Often used to resolve dependencies, which otherwise can't be resolved inside a rule.

attrs.default_only(attrs.dep(default = "foo//my_package:my_target"))

dep​

def dep(
*,
providers: list | tuple = [],
pulls_plugins: list[PluginKind] | tuple[PluginKind, ...] = [],
pulls_and_pushes_plugins: AllPlugins | list[PluginKind] | tuple[PluginKind, ...] = ...,
default = ...,
doc: str = "",
) -> Attr

Takes a target from the user, as a string, and supplies a dependency to the rule. A target can be specified as an absolute dependency foo//bar:baz, omitting the cell (//bar:baz) or omitting the package name (:baz).

If supplied the providers argument ensures that specific providers will be present on the dependency.

dict​

def dict(
key: Attr,
value: Attr,
*,
sorted: bool = False,
default = ...,
doc: str = "",
) -> Attr

Takes a dict from the user, supplies a dict to the rule.

enum​

def enum(
variants: list[str] | tuple[str, ...],
/,
*,
default: Select | str = ...,
doc: str = "",
) -> Attr

Takes a string from one of the variants given, and gives that string to the rule. Strings are matched case-insensitively, and always passed to the rule lowercase.

exec_dep​

def exec_dep(
*,
providers: list | tuple = [],
default = ...,
doc: str = "",
) -> Attr

Takes a target from the user, as a string, and supplies a dependency to the rule. The dependency will transition to the execution platform. Use exec_dep if you plan to execute things from this dependency as part of the compilation.

int​

def int(
*,
default = ...,
doc: str = "",
) -> Attr

Takes an int from the user, supplies an int to the rule.

label​

def label(
*,
default = ...,
doc: str = "",
) -> Attr

Takes a target (as per deps) and passes a label to the rule. Validates that the target exists, but does not introduce a dependency on it.

list​

def list(
inner: Attr,
/,
*,
default = ...,
doc: str = "",
) -> Attr

Takes a list from the user, supplies a list to the rule.

named_set​

def named_set(
value_type: Attr,
/,
*,
sorted: bool = False,
default = ...,
doc: str = "",
) -> Attr

one_of​

def one_of(
*args: Attr,
default = ...,
doc: str = "",
) -> Attr

Given a list of alternative attributes, selects the first that matches and gives that to the rule.

option​

def option(
inner: Attr,
/,
*,
default = ...,
doc: str = "",
) -> Attr

Takes a value that may be None or some inner type, and passes either None or the value corresponding to the inner to the rule. Often used to make a rule optional:

attrs.option(attr.string(), default = None)

plugin_dep​

def plugin_dep(
*,
kind: PluginKind,
default = ...,
doc: str = "",
) -> Attr

query​

def query(
*,
doc: str = "",
) -> Attr

regex​

def regex(
*,
default = ...,
doc: str = "",
) -> Attr

Currently an alias for attrs.string.

set​

def set(
value_type: Attr,
/,
*,
sorted: bool = False,
default = ...,
doc: str = "",
) -> Attr

source​

def source(
*,
allow_directory: bool = False,
default = ...,
doc: str = "",
) -> Attr

Takes a source file from the user, supplies an artifact to the rule. The source file may be specified as a literal string (representing the path within this package), or a target (which must have a DefaultInfo with a default_outputs value).

split_transition_dep​

def split_transition_dep(
*,
providers: list | tuple = [],
cfg,
default = ...,
doc: str = "",
) -> Attr

string​

def string(
*,
default = ...,
validate = ...,
doc: str = "",
) -> Attr

Takes a string from the user, supplies a string to the rule.

toolchain_dep​

def toolchain_dep(
*,
providers: list | tuple = [],
default = ...,
doc: str = "",
) -> Attr

Takes a target from the user, as a string, and supplies a dependency to the rule. The dependency will be a toolchain dependency, meaning that its execution platform dependencies will be used to select the execution platform for this rule.

transition_dep​

def transition_dep(
*,
providers: list | tuple = [],
cfg = ...,
default = ...,
doc: str = "",
) -> Attr

tuple​

def tuple(
*args: Attr,
default = ...,
doc: str = "",
) -> Attr

Takes a tuple of values and gives a tuple to the rule.

versioned​

def versioned(
value_type: Attr,
*,
doc: str = "",
) -> Attr