* where this isn't true, but we ignore it: If we record an exception, then someone calls
         * initCause() on it, and then we examine it again, we'll conclude that we've seen the whole
         * chain before when in fact we haven't. But this should be rare.)
         */
        return false;
      }
    }
    return true;
  }

   * contain will be cached, but {@code getAll} will throw an exception. If the returned map
   * contains extra keys not present in {@code keys} then all returned entries will be cached, but
   * only the entries for {@code keys} will be returned from {@code getAll}.
   *
   * <p>This method should be overridden when bulk retrieval is significantly more efficient than

 *
 * <p>To force selection of our fallback strategies, we load {@link AbstractFuture} (and all of
 * {@code com.google.common.util.concurrent}) in degenerate class loaders which make certain
 * platform classes unavailable. Then we construct a test suite so we can run the normal
 * AbstractFutureTest test methods in these degenerate classloaders.
 */

@NullUnmarked
@GwtIncompatible
@J2ktIncompatible

///

## `Field` additional arguments { #field-additional-arguments }

When using `Field()` with Pydantic models, you can also declare additional `examples`:

{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}

## `examples` in JSON Schema - OpenAPI { #examples-in-json-schema-openapi }

When using any of:

* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
* `Body()`
* `Form()`

          set +x
          STATUS=$(curl -s https://api.github.com/repos/elastic/elasticsearch/branches/%BRANCH% | jq '.protected')
          echo "Branch %BRANCH% protection status is: $STATUS"
          if [[ "$STATUS" == "false" ]]; then
            echo "Development branch %BRANCH% is not set as protected in GitHub but should be."
            exit 1

    /*
     * Since we can't loop inside awaitUninterruptibly(Condition, ...), the user is responsible for
     * calling us again in case of interrupt. Then, if we were to call await(...) immediately, as we
     * do in the other Uninterruptibles methods, it would throw immediately. Then we'd restore the
     * interrupt and return again, and the user would call us again, creating a busy wait.
     *

     * useful regardless of this renderer's needs, since now there will be a link embedded in the report
     * to quickly open the changes file.  By then we can also regex that path out of the description
     * in order to create a changes {@link File} for further use in this class.
     *
     * @param data the report data containing a description to parse

        // replaces?
        AbstractRepositoryMetadata repoMetadata = (AbstractRepositoryMetadata) metadata;
        this.metadata.merge(repoMetadata.getMetadata());
    }

    @Override
    public void merge(ArtifactMetadata metadata) {
        // TODO not sure that it should assume this, maybe the calls to addMetadata should pre-merge, then artifact
        // replaces?

  source:
	type: TYPE # valid values are "minio"
	bucket: BUCKET
	prefix: PREFIX
	# NOTE: if source is remote then target must be "local"
	# endpoint: ENDPOINT
	# credentials:
	#   accessKey: ACCESS-KEY
	#   secretKey: SECRET-KEY
	#   sessionToken: SESSION-TOKEN # Available when rotating credentials are used

  # target where the objects must be replicated
  target:
	type: TYPE # valid values are "minio"

Let's say you only have a single `item` body parameter from a Pydantic model `Item`.

By default, **FastAPI** will then expect its body directly.

But if you want it to expect a JSON with a key `item` and inside of it the model contents, as it does when you declare extra body parameters, you can use the special `Body` parameter `embed`:

```Python
item: Item = Body(embed=True)
```

as in: