if !metaArr[index].InlineData() {
				// If the data is not inlined, we may end up incorrectly
				// inlining the data here, that leads to an inconsistent
				// situation where some objects are were not inlined
				// were now inlined, make sure to `nil` the Data such
				// that xl.meta is written as expected.
				metaArr[index].Data = nil
			}
			metaArr[index].Metadata = srcInfo.UserDefined

    /**
     * Processes an FTP request to retrieve data from the specified URI.
     * This method handles the complete FTP request lifecycle including timeout management,
     * connection setup, and data retrieval.
     *
     * @param uri The URI to retrieve data from
     * @param includeContent Whether to include the actual content in the response
     * @return The response data containing the retrieved information

    # Update the viewport manually
    context = browser.new_context(viewport={"width": 960, "height": 1080})
    page = context.new_page()
    page.goto("http://localhost:8000/docs")
    page.get_by_role("button", name="POST /data Post Data").click()
    # Manually add the screenshot
    page.screenshot(path="docs/en/docs/img/tutorial/json-base64-bytes/image01.png")

    # ---------------------
    context.close()
    browser.close()

	}
	data = data[len(line):]
	line, isPrefix, err = l.ReadLine()
	if !isPrefix || !bytes.Equal(line, data[:minReadBufferSize]) || err != nil {
		t.Errorf("bad result for second line: got %q want %q %v", line, data[:minReadBufferSize], err)
	}
	data = data[len(line):]
	line, isPrefix, err = l.ReadLine()
	if isPrefix || !bytes.Equal(line, data[:minReadBufferSize/2]) || err != nil {

    * If you didn't use FastAPI and used Starlette directly (or another tool, like Sanic, Flask, Responder, etc) you would have to implement all the data validation and serialization yourself. So, your final application would...

func newTestReaderEOF(data []byte) io.Reader {
	return &testOneByteReadEOF{false, data}
}

// OneByteReadEOF - implements io.Reader which returns 1 byte along with io.EOF error.
type testOneByteReadEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF
	}
	n = copy(p, r.data)
	r.eof = true
	return n, io.EOF
}

If you don't declare a response model, FastAPI will use the `jsonable_encoder` explained in [JSON Compatible Encoder](../tutorial/encoder.md) and put it in a `JSONResponse`.

            RenderDataUtil.register(data, "endpoint", fessConfig.getStorageEndpoint());
            RenderDataUtil.register(data, "bucket", fessConfig.getStorageBucket());
            RenderDataUtil.register(data, "path", path);
            RenderDataUtil.register(data, "pathItems", createPathItems(path));
            RenderDataUtil.register(data, "parentId", createParentId(path));

        advance(l);
    }

    /**
     * Returns the length of data in the buffer.
     *
     * @return the data length
     */
    public int getLength() {
        return deferred.length;
    }

    /**
     * Sets the length of data in the buffer.
     *
     * @param length the new data length
     */
    public void setLength(final int length) {

    }

    /**
     * Registers a value in the render data with the specified key.
     * If the value is an Entity object, it will be converted to a Map using BeanUtil.
     * If the value is a Collection containing Entity objects, each Entity will be converted to a Map.
     * For other types of values, they are registered directly.
     *
     * @param data the RenderData object to register the value in