> ## Documentation Index > Fetch the complete documentation index at: https://aspect.build/llms.txt > Use this file to discover all available pages before exploring further. # Build `function` **Build.execution\_logs**

              
          def Build.execution\_logs() -> typing.Iterable\[exec\_log\_entry]

An iterable over every entry of this build's decoded execution log. Takes the stream's one subscriber rather than cloning it, so it can be called once per build and only when nothing else decodes the log: a decoded `execution_log.file(...)` sink or an `execution_log.iterator()` handle is refused, with a message naming the replacement. A `compact_file(...)` sink is not one of those and combines freely. Iterate it before `build.wait()`. The producer blocks for this subscriber, which is what makes the iteration complete, and `wait()` releases it — so a `wait()` first ends the stream, and a call afterwards is refused. `function` **Build.interrupt**

        
          def Build.interrupt() -> None

Send the client one SIGINT now, bazel's graceful cancel, without going through its token. `function` **Build.try\_wait**

              
          def Build.try\_wait(
          \*,
          timeout\_ms: int = 0
          ) -> None | bazel.build.BuildStatus

Check whether the invocation has finished: its `BuildStatus`, or `None` while the client is still running. Non-blocking by default; with `timeout_ms` it waits up to that long first, a bounded wait for a loop that also watches a cancellation token. `function` **Build.wait**

              
          def Build.wait() -> bazel.build.BuildStatus

Block until the Bazel invocation finishes and return a `BuildStatus`. Every decoded execution-log consumer belongs **before** this call, not merely preferably. `wait()` releases each one — the `execution_logs()` iterator and every still-bound `execution_log.iterator()` handle — and then takes the stream, so a consumer stops yielding from here on, anything it had not been drained of is gone, and a later `execution_logs()` finds no stream and says so. That is deliberate: each of those is a subscriber the producer blocks for, which is what makes the iteration complete, and releasing them is the only thing that lets a build nobody drained end. The drain therefore belongs before the call, not after. `build_events()` remains usable after `wait()` for replaying historical events, because the build event stream retains its buffer. The wait ends the task instead if `ctx.cancellation.root` is cancelled meanwhile and no `intercept()` is in effect; the client has its SIGINT by then. `function` **Build.workspace\_events**

              
          def Build.workspace\_events() -> typing.Iterable\[workspace\_event]

`property` **Build.cancellation**

        
          Build.cancellation: cancellation.Token

The client's cancellation token, a `child()` of the one passed as `cancellation =` at the spawn (`ctx.cancellation.root` by default). `build.cancellation.cancel()` sends the client one SIGINT, bazel's own graceful cancel; the build then ends the way an interrupted bazel does, with exit code 8, and `wait()` returns. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.