/** Writes the content of this request to [sink]. */
  @Throws(IOException::class)
  abstract fun writeTo(sink: BufferedSink)

  /**
   * A duplex request body is special in how it is **transmitted** on the network and
   * in the **API contract** between OkHttp and the application.
   *
   * This method returns false unless it is overridden by a subclass.
   *
   * ### Duplex Transmission
   *

   *   challenge. In this case the request URL may be different than the initial request URL.
   *
   * Use the `request` of the [networkResponse] field to get the wire-level request that was
   * transmitted. In the case of follow-ups and redirects, also look at the `request` of the
   * [priorResponse] objects, which have its own [priorResponse].
   */
  @get:JvmName("request") val request: Request,

    }
  }

  /**
   * Returns true if this stream is open. A stream is open until either:
   *
   *  * A `SYN_RESET` frame abnormally terminates the stream.
   *  * Both input and output streams have transmitted all data and headers.
   *
   * Note that the input stream may continue to yield data even after a stream reports itself as
   * not open. This is because input data is buffered.
   */
  val isOpen: Boolean

6. Here we are returning a dictionary that contains `items` which is a list of dataclasses.

    FastAPI is still capable of <abbr title="converting the data to a format that can be transmitted">serializing</abbr> the data to JSON.

7. Here the `response_model` is using a type annotation of a list of `Author` dataclasses.

    Again, you can combine `dataclasses` with standard type annotations.

  /** Flush the request to the underlying socket. */
  @Throws(IOException::class)
  fun flushRequest()

  /** Flush the request to the underlying socket and signal no more bytes will be transmitted. */
  @Throws(IOException::class)
  fun finishRequest()

  /**
   * Parses bytes of a response header from an HTTP transport.
   *

     */
    fun cacheUrlOverride(cacheUrlOverride: HttpUrl?) =
      apply {
        this.cacheUrlOverride = cacheUrlOverride
      }

    /**
     * Configures this request's body to be compressed when it is transmitted. This also adds the
     * 'Content-Encoding: gzip' header.
     *
     * Only use this method if you have prior knowledge that the receiving server supports
     * gzip-compressed requests.
     *

  /** Outgoing messages and close frames in the order they should be written. */
  private val messageAndCloseQueue = ArrayDeque<Any>()

  /** The total size in bytes of enqueued but not yet transmitted messages. */
  private var queueSize = 0L

  /** True if we've enqueued a close frame. No further message frames will be enqueued. */
  private var enqueuedClose = false

    This should make it easier to use OkHttp in Gradle plugins.

 *  Fix: Don't start the clock on response timeouts until the request body is fully transmitted.
    This is only relevant for duplex request bodies, because they are written concurrently when
    reading the response body.

    )
    val read = response1.body.source().read(ByteArray(8192))
    assertThat(read).isEqualTo(8192)

    // Make a second call that should transmit the response headers. The response body won't be
    // transmitted until the flow-control window is updated from the first request.
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.code).isEqualTo(200)

{* ../../docs_src/custom_response/tutorial006c_py39.py hl[2,7,9] *}

### `StreamingResponse` { #streamingresponse }

Toma un generador `async` o un generador/iterador normal y transmite el cuerpo del response.

{* ../../docs_src/custom_response/tutorial007_py39.py hl[2,14] *}

#### Usando `StreamingResponse` con objetos similares a archivos { #using-streamingresponse-with-file-like-objects }