assert response.status_code == 200, response.text
    assert response.json() == data


def test_model_with_tuple_invalid():
    data = {"items": [["foo", "bar"], ["baz", "whatelse", "too", "much"]]}
    response = client.post("/model-with-tuple/", json=data)
    assert response.status_code == 422, response.text

    data = {"items": [["foo", "bar"], ["baz"]]}

        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        if(( dst.length - dstIndex ) < pipeDataLen ) {
            if( log.level >= 3 )
                log.println( "TransTransactNamedPipe data too long for buffer" );
            return 0;
        }
        System.arraycopy( pipeData, pipeDataOff, dst, dstIndex, pipeDataLen );
        return pipeDataLen;
    }

            }
        )
    )


def test_cookie_param_model_extra(client: TestClient):
    with client as c:
        c.cookies.set("session_id", "123")
        c.cookies.set("extra", "track-me-here-too")
        response = c.get("/items/")
    assert response.status_code == 200
    assert response.json() == snapshot(
        {"session_id": "123", "fatebook_tracker": None, "googall_tracker": None}
    )

   * returned.
   *
   * @throws IllegalArgumentException if another entry in the bucket has the same key and {@code
   *     throwIfDuplicateKeys} is true
   * @throws BucketOverflowException if this bucket has too many entries, which may indicate a hash
   *     flooding attack
   */
  @CanIgnoreReturnValue
  @CheckForNull
  static <K, V> ImmutableMapEntry<K, V> checkNoConflictInKeyBucket(
      Object key,

   *
   * @param value any {@code long} value
   * @return the same value cast to {@code char} if it is in the range of the {@code char} type,
   *     {@link Character#MAX_VALUE} if it is too large, or {@link Character#MIN_VALUE} if it is too
   *     small
   */
  public static char saturatedCast(long value) {
    if (value > Character.MAX_VALUE) {
      return Character.MAX_VALUE;
    }
    if (value < Character.MIN_VALUE) {

   *
   * @param value any {@code long} value
   * @return the same value cast to {@code short} if it is in the range of the {@code short} type,
   *     {@link Short#MAX_VALUE} if it is too large, or {@link Short#MIN_VALUE} if it is too small
   */
  public static short saturatedCast(long value) {
    if (value > Short.MAX_VALUE) {
      return Short.MAX_VALUE;
    }
    if (value < Short.MIN_VALUE) {

   *
   * @param value any {@code long} value
   * @return the same value cast to {@code short} if it is in the range of the {@code short} type,
   *     {@link Short#MAX_VALUE} if it is too large, or {@link Short#MIN_VALUE} if it is too small
   */
  public static short saturatedCast(long value) {
    if (value > Short.MAX_VALUE) {
      return Short.MAX_VALUE;
    }
    if (value < Short.MIN_VALUE) {

And whenever you output that data, even if the source had duplicates, it will be output as a set of unique items.

And it will be annotated / documented accordingly too.

## Nested Models

Each attribute of a Pydantic model has a type.

But that type can itself be another Pydantic model.

		if err != nil {
			return false
		}
		return name < r.Name
	})

	// In Istio 1.5, it is not enough just to sort the routes.  The virtual hosts
	// within a route might have a different order.  Sort those too.
	for i := range drc {
		route := &route.RouteConfiguration{}
		err = drc[i].RouteConfig.UnmarshalTo(route)
		if err != nil {
			return nil, err
		}
		sort.Slice(route.VirtualHosts, func(i, j int) bool {

## Second dependency, "dependable" and "dependant"

Then you can create another dependency function (a "dependable") that at the same time declares a dependency of its own (so it is a "dependant" too):

//// tab | Python 3.10+

```Python hl_lines="13"
{!> ../../docs_src/dependencies/tutorial005_an_py310.py!}
```

////

//// tab | Python 3.9+

```Python hl_lines="13"