async def get_async_callable_dependency_class(
    value: str, instance: AsyncCallableDependency = Depends()
):
    return await instance(value)


@app.get("/async-callable-gen-dependency-class")
async def get_async_callable_gen_dependency_class(
    value: str, instance: AsyncCallableGenDependency = Depends()
):
    return await instance(value).__anext__()


@app.get("/callable-dependency")

    }

    @Override
    public void await() throws InterruptedException {
      lock.lock();
      try {
        condition.await();
      } finally {
        lock.unlock();
      }
    }

    @Override
    public boolean await(long time, TimeUnit unit) throws InterruptedException {
      lock.lock();
      try {
        return condition.await(time, unit);
      } finally {

* `read(size)`: Lê `size` (`int`) bytes/caracteres do arquivo.
* `seek(offset)`: Vai para o byte na posição `offset` (`int`) no arquivo.
    * Por exemplo, `await myfile.seek(0)` irá para o início do arquivo.
    * Isso é especialmente útil se você executar `await myfile.read()` uma vez e precisar ler o conteúdo novamente.
* `close()`: Fecha o arquivo.

Como todos esses métodos são métodos `assíncronos`, você precisa "aguardar" por eles.

                                        with anyio.fail_after(_PING_INTERVAL):
                                            data = await receive_stream.receive()
                                        await send_keepalive.send(data)
                                    except TimeoutError:
                                        await send_keepalive.send(KEEPALIVE_COMMENT)
                            except anyio.EndOfStream:

        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()

/// note | 技術細節

你也可以使用 `from starlette.websockets import WebSocket`。

**FastAPI** 直接提供相同的 `WebSocket` 只是為了方便你這位開發者，但它其實是直接來自 Starlette。

///

## 等待與傳送訊息 { #await-for-messages-and-send-messages }

在你的 WebSocket 路由中，你可以 `await` 接收訊息並傳送訊息。

{* ../../docs_src/websockets_/tutorial001_py310.py hl[48:52] *}

你可以接收與傳送二進位、文字與 JSON 資料。

## 試試看 { #try-it }

如果你的檔案名為 `main.py`，用以下指令執行應用：

        content={"detail": jsonable_encoder(exc.errors())},
    )


async def websocket_request_validation_exception_handler(
    websocket: WebSocket, exc: WebSocketRequestValidationError
) -> None:
    await websocket.close(
        code=WS_1008_POLICY_VIOLATION, reason=jsonable_encoder(exc.errors())

                // start all threads at once
                try {
                    startLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // wait for all thread to end
                try {
                    endLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();

{* ../../docs_src/async_tests/app_a_py310/test_main.py hl[9:12] *}

Это эквивалентно следующему:

```Python
response = client.get('/')
```

...которое мы использовали для отправки наших запросов с `TestClient`.

/// tip | Подсказка

Обратите внимание, что мы используем async/await с `AsyncClient` - запрос асинхронный.

///

      // SequentialExecutor by the time the barrier is satisfied
      barrier.await(1, SECONDS);
      executor.execute(barrierTask);
      // timeout means the second task wasn't even tried
      barrier.await(1, SECONDS);
    } finally {
      service.shutdown();
    }
  }

  public void testRejectedExecutionThrownWithMultipleCalls() throws Exception {