Cancellation(boolean wasInterrupted, @Nullable Throwable cause) {
      this.wasInterrupted = wasInterrupted;
      this.cause = cause;
    }
  }

  /** A special value that encodes the 'setFuture' state. */
  private static final class DelegatingToFuture<V extends @Nullable Object> implements Runnable {
    final AbstractFuture<V> owner;
    final ListenableFuture<? extends V> future;

	mw := msgp.NewWriter(rw)
	responses := make(chan ReadMultipleResp, len(req.Files))
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		for resp := range responses {
			err := resp.EncodeMsg(mw)
			if err != nil {
				rw.CloseWithError(err)
				return
			}
			mw.Flush()
		}
	}()
	err = s.getStorage().ReadMultiple(r.Context(), req, responses)
	wg.Wait()

			AccessTime: time.Unix(1389782991, 419875220),
			ChangeTime: time.Unix(1389782956, 794414986),
			Xattrs: map[string]string{
				"user.key":  "value",
				"user.key2": "value2",
				// Interestingly, selinux encodes the terminating null inside the xattr
				"security.selinux": "unconfined_u:object_r:default_t:s0\x00",
			},
			PAXRecords: map[string]string{
				"mtime":                         "1386065770.44825232",

    `HeldCertificate` is a TLS certificate and its private key. Generate a certificate with its
    builder then use it to sign another certificate or perform a TLS handshake. The
    `certificatePem()` method encodes the certificate in the familiar PEM format
    (`--- BEGIN CERTIFICATE ---`); the `privateKeyPkcs8Pem()` does likewise for the private key.

			n, err := mw.Write(data[:])
			if err != nil {
				w.CloseWithError(err)
				return
			}
			if n != len(data) {
				w.CloseWithError(io.ErrShortWrite)
				return
			}
			err = v.EncodeMsg(mw)
			mw.Flush()
			w.CloseWithError(err)
		}()
		return r
	}

	globalLocalDrivesMu.RLock()
	localDrives := cloneDrives(globalLocalDrivesMap)
	globalLocalDrivesMu.RUnlock()

    get_body_field,
    get_dependant,
    get_flat_dependant,
    get_parameterless_sub_dependant,
    get_stream_item_type,
    get_typed_return_annotation,
    solve_dependencies,
)
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import (
    EndpointContext,
    FastAPIError,
    RequestValidationError,
    ResponseValidationError,
    WebSocketRequestValidationError,
)

    * In `encoders.jsonable_encoder`:
        * Remove deprecated `skip_defaults`, use instead `exclude_unset`.
        * Set default of `exclude` from `set()` to `None` (as is in Pydantic).
    * PR [#1862](https://github.com/tiangolo/fastapi/pull/1862).
* In `encoders.jsonable_encoder` remove parameter `sqlalchemy_safe`.

}}ToBytes(out, (*{{ .Prefix }}UntypedFieldElement)(&tmp)) {{ .Prefix }}InvertEndianness(out[:]) return out[:] } // SetBytes sets e = v, where v is a big-endian {{ .BytesLen }}-byte encoding, and returns e. // If v is not {{ .BytesLen }} bytes or it encodes a value higher than {{ .Prime }}, // SetBytes returns nil and an error, and e is unchanged. func (e *{{ .Element }}) SetBytes(v []byte) (*{{ .Element }}, error) { if len(v) != {{ .Prefix }}ElementLen { return nil, errors.New("invalid {{ .Element }}...

}}ToBytes(out, (*{{ .Prefix }}UntypedFieldElement)(&tmp)) {{ .Prefix }}InvertEndianness(out[:]) return out[:] } // SetBytes sets e = v, where v is a big-endian {{ .BytesLen }}-byte encoding, and returns e. // If v is not {{ .BytesLen }} bytes or it encodes a value higher than {{ .Prime }}, // SetBytes returns nil and an error, and e is unchanged. func (e *{{ .Element }}) SetBytes(v []byte) (*{{ .Element }}, error) { if len(v) != {{ .Prefix }}ElementLen { return nil, errors.New("invalid {{ .Element }}...

*   `tf.random`:
    * Added `tf.random.experimental.index_shuffle`, for shuffling a sequence without materializing the sequence in memory.

*   `tf.RaggedTensor`:
    *   Introduced `tf.experimental.RowPartition`, which encodes how one dimension in a RaggedTensor relates to another, into the public API.
    *   Introduced `tf.experimental.DynamicRaggedShape`, which represents the shape of a RaggedTensor.

## Security