}

        return responseData;
    }

    /**
     * Parses file ownership attributes and adds them to the response data.
     *
     * @param responseData the response data to add attributes to
     * @param file the file to parse attributes from
     * @return the file owner attribute view
     * @throws CrawlingAccessException if parsing fails
     */

Joe Tsai <******@****.***> 1503105518 -0700

    }

    void write(@Nonnull XmlWriterRequest<T> request) throws XmlWriterException;

    /**
     * Simply parse the given xml string.
     *
     * @param xml the input xml string
     * @return the parsed object
     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    @Nonnull
    default T fromXmlString(@Nonnull String xml) throws XmlReaderException {

        assertEquals(5, d.getTotalParameterCount(), "totalParameterCount parsed correctly");
        assertEquals(3, d.getTotalDataCount(), "totalDataCount parsed correctly");
        assertEquals(2, d.getParameterCount(), "parameterCount parsed");
        assertEquals(7, d.getDataCount(), "dataCount parsed");
        assertEquals(1, d.getSetupCount(), "setupCount parsed");
        // When bufDataStart was zero it should be set to totalParameterCount

Then we use the request directly, and extract the body as `bytes`. This means that FastAPI won't even try to parse the request payload as JSON.

And then in our code, we parse that YAML content directly, and then we are again using the same Pydantic model to validate the YAML content:

//// tab | Pydantic v2

    /**
     * If true, the parser will be namespace aware.
     */
    protected boolean namespaceAware;

    /**
     * If true, the parser will convert CDATA nodes to Text nodes and append them to the adjacent Text node.
     */
    protected boolean coalescing;

    /**
     * If true, the parser will expand entity reference nodes.
     */

 * text is performed automatically by the relevant parser.
 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code
 * "Foo&lt;Bar&gt;"} to prevent {@code "<Bar>"} from being confused with an XML tag. When the
 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *

            throw new DictionaryException("Failed to parse " + path, e);
        }
    }

    /**
     * Reloads the stemmer override dictionary from an input stream.
     *
     * @param updater An optional updater to apply changes.
     * @param in      The input stream to read the dictionary from.
     * @throws DictionaryException if the input stream cannot be parsed.
     */

     */
    public SuggestIndexer setAnalyzer(final SuggestAnalyzer analyzer) {
        this.analyzer = analyzer;
        return this;
    }

    /**
     * Sets the contents parser.
     * @param contentsParser The contents parser.
     * @return This SuggestIndexer instance.
     */
    public SuggestIndexer setContentsParser(final ContentsParser contentsParser) {
        this.contentsParser = contentsParser;

        return httpClient.execute(httpRequest, new BasicHttpContext(httpClientContext));
    }

    /**
     * Parses the last modified date from a string value.
     *
     * @param value The date string to parse
     * @return The parsed date, or null if parsing fails
     */
    protected Date parseLastModifiedDate(final String value) {