statLock    sync.RWMutex
	targetStats map[TargetID]targetStat
}

type targetStat struct {
	// The number of concurrent async Send calls per targets
	currentSendCalls int64
	// The number of total events per target
	totalEvents int64
	// The number of failed events per target
	failedEvents int64
}

func (list *TargetList) getStatsByTargetID(id TargetID) (stat targetStat) {
	list.statLock.RLock()

 * <li>{@literal file}</li>
 * <li>{@literal jar}</li>
 * <li>{@literal wsjar} (WebSphere proprietary protocol, alias for {@literal jar})</li>
 * <li>{@literal zip} (WebLogic proprietary protocol, use {@literal jar} protocol for normal zip files)</li>
 * <li>{@literal code-source} (Oracle AS(OC4J) proprietary protocol)</li>
 * <li>{@literal vfsfile} (JBossAS5 proprietary protocol, alias for {@literal file})</li>

{* ../../docs_src/settings/app02_an_py39/main.py hl[6,12:13] *}

/// tip | Dica

Vamos discutir o `@lru_cache` em breve.

Por enquanto, você pode assumir que `get_settings()` é uma função normal.

///

E então podemos exigi-la na *função de operação de rota* como dependência e usá-la onde for necessário.

{* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *}

            path = "../";
        }
        out.println(dirCount + fileCount + " objects (" + dirCount + " directories, " + fileCount + " files)<br>");
        out.println("<b><a class=\"plain\" href=\".\">normal</a> | <a class=\"plain\" href=\"?fmt=detail\">detailed</a></b>");
        out.println("<p><table border='0' cellspacing='0' cellpadding='0'><tr><td>");

        out.print("<A style=\"width: " + maxLen);

  fun nextFrame(
    requireSettings: Boolean,
    handler: Handler,
  ): Boolean {
    try {
      source.require(9) // Frame header size.
    } catch (e: EOFException) {
      return false // This might be a normal socket close.
    }

    //  0                   1                   2                   3
    //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

Apenas um processo no servidor pode se conectar a uma porta em um endereço IP. Poderiam existir outros processos conectados em outras portas desse mesmo endereço IP, mas apenas um para cada combinação de endereço IP e porta.

TLS (HTTPS) usa a porta `443` por padrão. Então essa é a porta que precisamos.

Como apenas um único processo pode se comunicar com essa porta, o processo que faria isso seria o Proxy de Terminação TLS.

Si capturas una excepción usando `except` en una dependencia con `yield` y no la lanzas nuevamente (o lanzas una nueva excepción), FastAPI no podrá notar que hubo una excepción, al igual que sucedería con Python normal:

{* ../../docs_src/dependencies/tutorial008c_an_py39.py hl[15:16] *}

labels.description=Description
labels.user_title=Titre
labels.title=Titre
labels.user_pager=Téléavertisseur
labels.pager=Téléavertisseur
labels.user_street=Rue
labels.street=Rue
labels.user_postalCode=Code postal
labels.postalCode=Code postal
labels.user_physicalDeliveryOfficeName=Bureau
labels.physicalDeliveryOfficeName=Bureau
labels.user_destinationIndicator=Indicateur de destination
labels.destinationIndicator=Indicateur de destination

	MediumBlock = 128 * humanize.KiByte // Default r/w block size for medium sized objects.
	LargeBlock  = 1 * humanize.MiByte   // Default r/w block size for normal objects.
)

// AlignedBytePool is a pool of fixed size aligned blocks
type AlignedBytePool struct {
	size int
	p    bpool.Pool[*[]byte]
}

// NewAlignedBytePool creates a new pool with the specified size.

    /**
     * Reserve an opportunistic lock filter on the open
     */
    public static final int FILE_RESERVE_OPFILTER = 0x100000;
    /**
     * Open a reparse point and bypass normal reparse point processing
     */
    public static final int FILE_OPEN_REPARSE_POINT = 0x200000;
    /**
     * Open does not cause an opportunistic lock break for the file
     */