# Body - Nested Models { #body-nested-models }

With **FastAPI**, you can define, validate, document, and use arbitrarily deeply nested models (thanks to Pydantic).

## List fields { #list-fields }

You can define an attribute to be a subtype. For example, a Python `list`:

{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}

This will make `tags` be a list, although it doesn't declare the type of the elements of the list.

        env:
          POSTGRES_PASSWORD: gorm
          POSTGRES_USER: gorm
          POSTGRES_DB: gorm
          TZ: Asia/Shanghai
        ports:
          - 9920:5432
        # Set health checks to wait until postgres has started
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:

package main

import (
	"flag"
	"fmt"
	"go/build"
	"internal/testenv"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"sync"
	"testing"
)

var flagCheck = flag.Bool("check", false, "run API checks")

func TestMain(m *testing.M) {
	flag.Parse()
	for _, c := range contexts {
		c.Compiler = build.Default.Compiler
	}
	build.Default.GOROOT = testenv.GOROOT(nil)

	os.Exit(m.Run())
}

var (

import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import org.jspecify.annotations.Nullable;

/**
 * A wrapper around {@code TreeMap} that aggressively checks to see if keys are mutually comparable.
 * This implementation passes the navigable map test suites.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible

			if len(cm) == 1 {
				m.Aggregated.CPU.TimesStat = &cm[0]
			} else {
				m.Errors = append(m.Errors, fmt.Sprintf("%s: Expected one CPU stat, got %d", byHostName, len(cm)))
			}
		}
		cpuCount, err := c.Counts(true)
		if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v (cpuCount)", byHostName, err.Error()))
		} else {
			m.Aggregated.CPU.CPUCount = cpuCount
		}

		loadStat, err := load.Avg()

            } catch (final Exception e) {
                logger.warn("Failed to parse maven-metadata.xml: url={}", pluginUrl, e);
            }
        }
        return list;
    }

    /**
     * Checks if an artifact name should be excluded from the results.
     *
     * @param artifactType the type of the artifact
     * @param name the name of the artifact

func TestStartProfiler(t *testing.T) {
	_, err := startProfiler("")
	if err == nil {
		t.Fatal("Expected a non nil error, but nil error returned for invalid profiler.")
	}
}

// checkURL - checks if passed address correspond
func checkURL(urlStr string) (*url.URL, error) {
	if urlStr == "" {
		return nil, errors.New("Address cannot be empty")
	}
	u, err := url.Parse(urlStr)
	if err != nil {

// qProp contains analysis info about an SQL term.
type qProp struct {
	isAggregation, isRowFunc bool

	err error
}

// `combine` combines a pair of `qProp`s, so that errors are
// propagated correctly, and checks that an aggregation is not being
// combined with a row-function term.
func (p *qProp) combine(q qProp) {
	switch {
	case p.err != nil:
		// Do nothing
	case q.err != nil:
		p.err = q.err
	default:

	sort.Strings(entries)

	// Add entries slice for this test directory.
	testResults = append(testResults, result{dir, entries})
	return testResults
}

// checkResult - checks whether entries are got are same as expected entries.
func checkResult(expected []string, got []string) bool {
	// If length of expected and got slice are different, the test actually failed.
	if len(expected) != len(got) {

                for (int j = 0; j < 100; j++) {
                    List<DirectoryCacheEntry.FileInfo> children = entry.getChildren();
                    // Just read, don't assert specific counts due to race conditions
                    assertNotNull(children);
                }
            });
            readThreads[i].start();
        }

        // Wait for all threads