if ok {
			statusCode = tc.ResponseRecorder.StatusCode
			outputBytes = int64(tc.ResponseRecorder.Size())
			headerBytes = int64(tc.ResponseRecorder.HeaderSize())
			timeToResponse = time.Now().UTC().Sub(tc.ResponseRecorder.StartTime)
			timeToFirstByte = tc.ResponseRecorder.TTFB()
		}

		entry.AccessKey = reqInfo.Cred.AccessKey
		entry.ParentUser = reqInfo.Cred.ParentUser

		entry.API.Name = reqInfo.API

		if !ps.Info.EndTime.IsZero() {
			stopTime = ps.Info.EndTime
		}

		if !stopTime.IsZero() { // rebalance is stopped or completed
			elapsed = stopTime.Sub(ps.Info.StartTime)
			eta = 0
		}

		r.Pools[i].Progress = rebalPoolProgress{
			NumObjects:  ps.NumObjects,
			NumVersions: ps.NumVersions,
			Bytes:       ps.Bytes,
			Elapsed:     elapsed,

	// the user and the application that acquired the WebIdentityToken (pairwise identifier).
	// For OpenID Connect ID tokens, this field contains the value returned by the identity
	// provider as the token's sub (Subject) claim.
	SubjectFromWebIdentityToken string `xml:",omitempty"`
}

// AssumeRoleWithClientGrantsResponse contains the result of successful AssumeRoleWithClientGrants request.

func dateDiff(timePart string, ts1, ts2 time.Time) (*Value, error) {
	if ts2.Before(ts1) {
		v, err := dateDiff(timePart, ts2, ts1)
		if err == nil {
			v.negate()
		}
		return v, err
	}

	duration := ts2.Sub(ts1)
	y1, m1, d1 := ts1.Date()
	y2, m2, d2 := ts2.Date()

	switch timePart {
	case timePartYear:
		dy := int64(y2 - y1)
		if m2 > m1 || (m2 == m1 && d2 >= d1) {
			return FromInt(dy), nil
		}

    AbstractTensorHandlePtr fMinus(f_outputs[0]);

    // Take Difference of both estimates: (f(theta + eps) - f(theta - eps)).
    TF_RETURN_IF_ERROR(
        ops::Sub(ctx, fPlus.get(), fMinus.get(), f_outputs, "sub_top"));
    AbstractTensorHandlePtr fDiff(f_outputs[0]);

    // Calculate using the difference quotient definition:
    // (f(theta + eps) - f(theta - eps)) / (2 * eps).

    checkNotNull(string);
    int end = string.length();
    int index = nextEscapeIndex(string, 0, end);
    return index == end ? string : escapeSlow(string, index);
  }

  /**
   * Scans a sub-sequence of characters from a given {@link CharSequence}, returning the index of
   * the next character that requires escaping.
   *
   * <p><b>Note:</b> When implementing an escaper, it is a good idea to override this method for

		tests []operandTest
	}
	for _, sub := range []subtest{
		{"amd64", amd64OperandTests},
		{"386", x86OperandTests},
		{"arm", armOperandTests},
		{"arm64", arm64OperandTests},
		{"ppc64", ppc64OperandTests},
		{"mips", mipsOperandTests},
		{"mips64", mips64OperandTests},
		{"loong64", loong64OperandTests},
		{"s390x", s390xOperandTests},
	} {
		t.Run(sub.arch, func(t *testing.T) {

package browser

import (
	"fmt"
	"strconv"
	"sync"

	"github.com/minio/minio/internal/config"
	"github.com/minio/pkg/v3/env"
)

// Browser sub-system constants
const (
	// browserCSPPolicy setting name for Content-Security-Policy response header value
	browserCSPPolicy = "csp_policy"

    assertThrows(IndexOutOfBoundsException.class, () -> iia.get(-1));
    assertThrows(IndexOutOfBoundsException.class, () -> iia.get(3));

    ImmutableLongArray sub = iia.subArray(1, 2);
    assertThrows(IndexOutOfBoundsException.class, () -> sub.get(-1));
  }

  public void testIndexOf() {
    ImmutableLongArray iia = ImmutableLongArray.of(1, 1, 2, 3, 5, 8);
    assertThat(iia.indexOf(1)).isEqualTo(0);

因此，你可以在该依赖中用 `except SomeException` 来捕获这个特定异常。

同样地，你可以使用 `finally` 来确保退出步骤一定会被执行，无论是否发生异常。

{* ../../docs_src/dependencies/tutorial007_py310.py hl[3,5] *}

## 使用 `yield` 的子依赖项 { #sub-dependencies-with-yield }

你可以声明任意大小和形状的子依赖及其“树”，其中任意一个或全部都可以使用 `yield`。

**FastAPI** 会确保每个带有 `yield` 的依赖中的“退出代码”按正确的顺序运行。

例如，`dependency_c` 可以依赖 `dependency_b`，而 `dependency_b` 则依赖 `dependency_a`：