Skip to main content

bxl.LazyContext type

bxl.LazyContext.analysis​

def bxl.LazyContext.analysis(
    label: bxl.ConfiguredTargetNode | configured_target_label | label,
    /,
) -> bxl.Lazy

Analyze a target lazily. This will return a lazy operation that can be evaluated later. The target should be a ConfiguredTargetLabel, a ConfiguredProvidersLabel, or a ConfiguredTargetNode.

Example:

def _impl(ctx):
    target = ctx.configured_targets("cell//path/to:target")
    analysis_result = ctx.lazy.analysis(target).resolve()
    (analysis_result, err) = ctx.lazy.analysis(target).try_resolve()

bxl.LazyContext.configured_target_node​

def bxl.LazyContext.configured_target_node(
    expr: bxl.ConfiguredTargetNode | bxl.UnconfiguredTargetNode | configured_target_label | str | target_label,
    /,
    *,
    target_platform: None | str | target_label = ...,
    modifiers: list[str] = [],
) -> bxl.Lazy

Gets the configured target node for the expr. If given a string target pattern, it will resolve to a target set of configured target nodes. it also accepts an optional target_platform and an optional modifers list which is used to resolve configurations of any unconfigured target nodes. The target_platform is either a string that can be parsed as a target label, or a target label.

The given expr is either:

- a single string that is a target ot a target pattern.
- a single target node or label, configured or unconfigured

Note that this function does not accept ConfiguredProviderLabel (which is a configured provider label), since this is the label of a subtarget. You can get the underlying configured target label on the Label using configured_targets() (ex: my_label.configured_target()).

This returns either a target set of ConfiguredTargetNodes if the given expr is a target pattern string, else a single ConfiguredTargetNode.

When the given a target pattern (returns the target set), for the incompatible targets, it will print the warning message of these incompatible targets. Else (returns a single ConfiguredTargetNode), it will raise an error if incompatible when resolve. Use Lazy.catch() to catch the error.

Example:

def _impl(ctx):
    # returns a single `ConfiguredTargetNode`
    node = ctx.lazy.configured_target_node("cell//path/to:target").resolve()

    # returns a target set of `ConfiguredTargetNode`s
    target_set = ctx.lazy.configured_target_node("cell//path/to:").resolve()

bxl.LazyContext.join​

def bxl.LazyContext.join(lazy0: bxl.Lazy, lazy1: bxl.Lazy, /) -> bxl.Lazy

Join two lazy operations into a single operation that can be evaluated.

Example:

def _impl(ctx):
    ...
    joined = ctx.lazy.join(ctx.lazy.analysis(t1), ctx.lazy.analysis(t2))
    (res1, res2) = joined.resolve()
    ctx.output.print(res1)
    ctx.output.print(res2)

bxl.LazyContext.join_all​

def bxl.LazyContext.join_all(operations: list[bxl.Lazy], /) -> bxl.Lazy

Join a list of lazy operations into a single operation that can be evaluated. This is useful when you want to evaluate multiple operations in parallel. Using .try_resolve() can catch errors for the individual operations.

Example:

def _impl(ctx):
    ...
    joined = ctx.lazy.join_all([ctx.lazy.analysis(t) for t in targets])
    analysis_results = joined.resolve()
    ctx.output.print(analysis_results)

bxl.LazyContext.unconfigured_target_node​

def bxl.LazyContext.unconfigured_target_node(
    expr: bxl.UnconfiguredTargetNode | str | target_label,
    /,
) -> bxl.Lazy

Gets the unconfigured target node(s) for the expr

The given expr is either:

- a single string that is a target ot a target pattern.
- a single unconfigured target node or label

This returns either a target set of UnconfiguredTargetNodes if the given expr is a target pattern string, else a single UnconfiguredTargetNode.