elif is_gen_callable(call) or is_async_gen_callable(call):
            solved = await solve_generator(
                call=call, stack=async_exit_stack, sub_values=sub_values
            )
        elif is_coroutine_callable(call):
            solved = await call(**sub_values)
        else:
            solved = await run_in_threadpool(call, **sub_values)
        if sub_dependant.name is not None:

  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag, long timeoutMillis) {
  //         long startTime = System.nanoTime();
  //         while (!flag.get()) {

  //      */
  //     public void await(AtomicBoolean flag) {
  //         await(flag, LONG_DELAY_MS);
  //     }

  //     /**
  //      * Spin-waits up to the specified timeout until flag becomes true.
  //      */
  //     public void await(AtomicBoolean flag, long timeoutMillis) {
  //         long startTime = System.nanoTime();
  //         while (!flag.get()) {

  // CHECK: [[c:%.*]] = tf_mlrt.await [[futures]]#1
  %c = "tf_mlrt.tf_await"(%future_c) : (!mlrt.future) ->tensor<i32>
  // CHECK: [[f:%.*]] = tf_mlrt.executeop([[e]], [[c]])
  // CHECK-SAME: Div
  %f = "tf.Div"(%e, %c) {__op_key = 8: i32}: (tensor<i32>, tensor<i32>) -> tensor<i32>

  // CHECK: [[b:%.*]] = tf_mlrt.await [[futures]]#0
  %b = "tf_mlrt.tf_await"(%future_b) : (!mlrt.future) ->tensor<i32>

* `seek(offset)`: Goes to the byte position `offset` (`int`) in the file.
    * E.g., `await myfile.seek(0)` would go to the start of the file.
    * This is especially useful if you run `await myfile.read()` once and then need to read the contents again.
* `close()`: Closes the file.

As all these methods are `async` methods, you need to "await" them.

For example, inside of an `async` *path operation function* you can get the contents with:

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()
    assertThat(exceptionRef.get()).isNotNull()
  }

  @Test
  fun timeoutProcessing() {
    server.enqueue(
      MockResponse.Builder()

* `seek(offset)`: Перейти к байту на позиции `offset` (`int`) в файле.
    * Наример, `await myfile.seek(0)` перейдет к началу файла.
    * Это особенно удобно, если вы один раз выполнили команду `await myfile.read()`, а затем вам нужно прочитать содержимое файла еще раз.
* `close()`: Закрыть файл.

Поскольку все эти методы являются `async` методами, вам следует использовать "await" вместе с ними.

    Variadic<TFTensorType>:$results
  );

  let assemblyFormat = "attr-dict `:` type($results)";
}

def AwaitOp: TensorflowMlrt_Op<"await", [Pure]> {
  let summary = "Await a tensor from a !mlrt.future";

  let description = [{
    Await a tensor from a !mlrt.future.

    $future: A value of type !mlrt.future. The underlying value must be a tensorflow tensor.

    $result: a tensorflow tensor.

                    workerLeaseService.withLocks([projectLock]) {
                        assert lockIsHeld(projectLock)
                    }
                }
            }
            started.await()
            instant.releaseAll
        }

        then:
        noExceptionThrown()
    }

    def "multiple threads can coordinate locking of a project using tryLock"() {
        def threadCount = 10

* `seek(versatz)`: Geht zur Position `versatz` (`int`) in der Datei.
    * Z. B. würde `await myfile.seek(0)` zum Anfang der Datei gehen.
    * Das ist besonders dann nützlich, wenn Sie `await myfile.read()` einmal ausführen und dann diese Inhalte erneut auslesen müssen.
* `close()`: Schließt die Datei.

Da alle diese Methoden `async`hron sind, müssen Sie sie `await`en („erwarten“).