* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.binarycompatibility

import org.jsoup.Jsoup
import org.jsoup.nodes.Document
import java.io.File


internal
fun scrapeRichReport(richReportFile: File): RichReport =

    Jsoup.parse(richReportFile, "UTF-8").run {
        RichReport(
            scrapeMessagesForSeverity("error"),

A typical platform builds on other platforms in order to add more capabilities, for example, to add support for a particular language.

See the [discovery document](https://docs.google.com/document/d/1-oKG23gLdx2D2uJvzir31AhDFyqSf81LDESfKKCU28c/edit#heading=h.pps74pn68uvk) (internal document) for more context.

### Platforms

The platforms and their architecture modules are:

#### Core automation platform

    <section><title>Methods</title><table><thead><tr></tr></thead></table></section>
</section>
''')

        when:
        ClassDoc doc = withCategories {
            def doc = new ClassDoc('org.gradle.Class', content, document, classMetaData, null)
            doc.superClass = superDoc
            doc.interfaces << superType1
            doc.interfaces << superType2
            builder.build(doc)
            return doc
        }

///

**FastAPI** will do the automatic conversion from the request, so that the parameter `item` receives its specific content and the same for `user`.

It will perform the validation of the compound data, and will document it like that for the OpenAPI schema and automatic docs.

## Singular values in body { #singular-values-in-body }

</section>
''')

        when:
        ClassDoc doc = withCategories {
            def doc = new ClassDoc('org.gradle.Class', content, document, classMetaData, null)
            doc.superClass = superClass
            doc.interfaces << superType1
            doc.interfaces << superType2
            builder.build(doc)
            doc
        }

The string will be checked to be a valid URL, and documented in JSON Schema / OpenAPI as such.

## Attributes with lists of submodels { #attributes-with-lists-of-submodels }

You can also use Pydantic models as subtypes of `list`, `set`, etc.:

{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}

This will expect (convert, validate, document, etc.) a JSON body like:

```JSON hl_lines="11"
{

			};
		}

		const go = new Go();
		let mod, inst;
		WebAssembly.instantiateStreaming(fetch("test.wasm"), go.importObject).then((result) => {
			mod = result.module;
			inst = result.instance;
			document.getElementById("runButton").disabled = false;
		}).catch((err) => {
			console.error(err);
		});

		async function run() {
			console.clear();
			await go.run(inst);

 * non-ASCII characters to their numeric entity replacements. These XML escapers provide the minimal
 * level of escaping to ensure that the output can be safely included in a Unicode XML document.
 *
 * <p>For details on the behavior of the escapers in this class, see sections <a
 * href="http://www.w3.org/TR/2008/REC-xml-20081126/#charsets">2.2</a> and <a

 * (such as an XML document). Typically (but not always), the inverse process of "unescaping" the
 * 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

`jstream` is a streaming JSON parser and value extraction library for Go.

Unlike most JSON parsers, `jstream` is document position- and depth-aware -- this enables the extraction of values at a specified depth, eliminating the overhead of allocating encompassing arrays or objects; e.g:

Using the below example document:
<img width="85%" src="https://bradley.codes/static/img/jstream-levels.gif" alt="jstream"/>