apache/beam · error · TimeoutError

Timeout waiting for asynchronous computation completion.

Error message

Timeout waiting for asynchronous computation completion.

What it means

Recording.wait_for_completion blocks on a threading.Event that the background recording thread sets when done. If the event is not set within the optional timeout, the method raises TimeoutError to signal that the asynchronous pipeline recording did not finish in time.

Solutions

Increase or omit the timeout passed to wait_for_completion / the recording's max duration so slow pipelines can finish
Stream results incrementally with recording.stream() instead of waiting for the full computation
Check pipeline health in the runner (Dataflow job status, logs) to see why the computation is slow
Poll wait_for_completion with progressive timeouts in a loop rather than one short timeout

Example fix

// before
recording.wait_for_completion(timeout=10)
// after
recording.wait_for_completion(timeout=None)  # wait as long as needed
# or poll:
while not recording.computed:
    time.sleep(5)
recording.wait_for_completion()

Defensive patterns

Strategy: try-catch

Validate before calling

if recording.computed:
    recording.wait_for_completion()
elif recording.max_duration and est_runtime > recording.max_duration:
    raise RuntimeError('recording will exceed max_duration; increase it')

Type guard

def is_ready(rec):
    return rec.computed or rec._completed_event.is_set()

Try / catch

try:
    recording.wait_for_completion(timeout=60)
except TimeoutError:
    # pipeline still running; poll again or stream incrementally
    pass

Prevention

Pass a generous timeout or None when pipelines are long-running
Use recording.stream() for incremental results instead of full completion waits
Monitor runner logs for pipeline progress before waiting
Set max_duration appropriately for the expected data volume

When it happens

Trigger: Calling ib.collect / recording.watch with a recording whose underlying Beam pipeline takes longer than the supplied timeout; passing a small timeout to Recording.wait_for_completion while the pipeline is still running.

Common situations: Interactive Beam notebooks with long-running pipelines (large inputs, slow runners like Dataflow), or code that polls a recording with a tight timeout instead of streaming incrementally.

Understand the failure class

Background: Request timed out: what client-side request timeouts mean across libraries (Request timed out, TIMED_OUT, APITimeoutError) — this error's family across 39 libraries.

Timeouts: ETIMEDOUT, deadlines, and hung requests — what actually expires when a request times out.

Related errors

AI-assisted analysis of apache/beam@12126d8942 (2026-09-13). Data as JSON: /api/errors/255ed8e2c2b27e4f. Report an issue: GitHub.

Appendix: source

Thrown at sdks/python/apache_beam/runners/interactive/recording_manager.py:158

    self._pipeline_result = pipeline_result
    if self._cancel_requested:
      self.cancel()

  def result(self, timeout=None):
    return self._future.result(timeout=timeout)

  def done(self):
    return self._future.done()

  def exception(self, timeout=None):
    try:
      return self._future.exception(timeout=timeout)
    except TimeoutError:
      return None

  def wait_for_completion(self, timeout=None):
    if not self._completed_event.wait(timeout=timeout):
      raise TimeoutError(
          'Timeout waiting for asynchronous computation completion.')
    if self._future.cancelled():
      raise RuntimeError('Asynchronous computation was cancelled.')
    exc = self.exception()
    if exc:
      raise exc

  def _on_done(self, future: Future):
    try:
      if future.cancelled():
        self.update_display('Computation Cancelled.', 1.0)
        return

      exc = future.exception()
      if exc:
        self.update_display(f'Error: {exc}', 1.0)
        _LOGGER.error('Asynchronous computation failed: %s', exc, exc_info=exc)
      else:

View on GitHub (pinned to 12126d8942)