*/
    protected abstract void doSendFragment(byte[] buf, int off, int length, boolean isDirect) throws IOException;

    /**
     * Receives a DCERPC fragment from the remote endpoint
     * @param buf the buffer to receive the fragment
     * @param isDirect whether to use direct reception
     * @throws IOException if an I/O error occurs
     */

    def receive_wrapper(self, receive):
        received = 0

        async def inner():
            nonlocal received
            message = await receive()
            if message["type"] != "http.request":
                return message  # pragma: no cover

            body_len = len(message.get("body", b""))
            received += body_len
            if received > self.max_content_size:

     */
    SmbFileHandle ensureOpen() throws CIFSException;

    /**
     * Receive data from the pipe
     *
     * @param buf buffer to receive data into
     * @param off offset in the buffer
     * @param length maximum length to receive
     * @return number of bytes received
     * @throws IOException if an I/O error occurs
     */
    int recv(byte[] buf, int off, int length) throws IOException;

):
    return ItemOut(name=item.name, value=item.value, dep=dep)


@app.post("/sync/large-receive")
def sync_large_receive(payload: LargeIn):
    return {"received": len(payload.items)}


@app.post("/async/large-receive")
async def async_large_receive(payload: LargeIn):
    return {"received": len(payload.items)}


@app.get("/sync/large-dict-no-response-model")

  var writeBytesMaximum: Long = connection.peerSettings.initialWindowSize.toLong()
    internal set

  /** Received headers yet to be [taken][takeHeaders]. */
  private val headersQueue = ArrayDeque<Headers>()

  /** True if response headers have been sent or received. */
  private var hasResponseHeaders: Boolean = false

  override val source =
    FramingSource(

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

For example, it doesn't receive `datetime` objects, as those are not compatible with JSON.

So, a `datetime` object would have to be converted to a `str` containing the data in [ISO format](https://en.wikipedia.org/wiki/ISO_8601).

The same way, this database wouldn't receive a Pydantic model (an object with attributes), only a `dict`.

    }

    /**
     * Get maximum receive size
     *
     * @return maximum receive size in bytes
     */
    public int getMaxReceiveSize() {
        return maxReceiveSize;
    }

    /**
     * Set maximum receive size
     *
     * @param maxReceiveSize maximum receive size in bytes
     */
    public void setMaxReceiveSize(int maxReceiveSize) {

    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;

    /**
     * Receive data using RDMA
     *
     * @param timeout timeout in milliseconds
     * @return received data buffer, or null if timeout
     * @throws IOException if receive fails
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;

    /**
     * Perform RDMA read operation
     *

We are still using the same `OAuth2PasswordRequestForm`. It includes a property `scopes` with a `list` of `str`, with each scope it received in the request.

And we return the scopes as part of the JWT token.

/// danger

For simplicity, here we are just adding the scopes received directly to the token.

        this.creditsGranted = creditsGranted;
    }

    /**
     * Get maximum receive size
     *
     * @return maximum receive size in bytes
     */
    public int getMaxReceiveSize() {
        return maxReceiveSize;
    }

    /**
     * Set maximum receive size
     *
     * @param maxReceiveSize maximum receive size in bytes
     */
    public void setMaxReceiveSize(int maxReceiveSize) {