return foo

    with pytest.raises(
        AssertionError,
        match=(
            "Cannot specify `Depends` in `Annotated` and default value"
            " together for 'foo'"
        ),
    ):

        @app.get("/")
        async def get2(foo: Annotated[int, Depends(dep)] = Depends(dep)):
            pass  # pragma: nocover

    with pytest.raises(

///

### `startup` and `shutdown` together { #startup-and-shutdown-together }

There's a high chance that the logic for your *startup* and *shutdown* is connected, you might want to start something and then finish it, acquire a resource and then release it, etc.

This is not a limitation of **FastAPI**, it's part of the HTTP protocol.

///

## Recap { #recap }

 */
package org.codelibs.fess.suggest.normalizer;

import java.util.ArrayList;
import java.util.List;

/**
 * The NormalizerChain class implements the Normalizer interface and allows chaining multiple normalizers together.
 * It applies each normalizer in the order they were added to the chain.
 *
 * <p>Usage example:</p>
 * <pre>
 * NormalizerChain chain = new NormalizerChain();
 * chain.add(new SomeNormalizer());

ADRs can be written by any team.
Like code, they should be reviewed by any other relevant teams.
The goal is not to *own* a decision, but to *share* it with other teams, and improve the build tool together.

### Format

The format for ADR should follow this template:

```markdown
# ADR-000X - Title

## Date

20YY-MM-DD

## Context

cmdtable = {}
command = registrar.command(cmdtable)
@command(b'goreposum', [], _('url'), norepo=True)
def goreposum(ui, url):
  """
  goreposum computes a checksum of all the named state in the remote repo.
  It hashes together all the branch names and hashes
  and then all the bookmark names and hashes.
  Tags are stored in .hgtags files in any of the branches,
  so the branch metadata includes the tags as well.
  """
  h = hashlib.sha256()

  {{.Name}} - {{.Usage}}

USAGE:
  {{.Name}} {{if .VisibleFlags}}[FLAGS]{{end}} [HEALINGBINFILE|INSPECTZIPFILE]

files ending in '.zip' will be searched for '.healing.bin files recursively and
printed together as a single JSON.

FLAGS:
  {{range .VisibleFlags}}{{.}}
  {{end}}
`
	app.Flags = []cli.Flag{}
	app.Action = func(c *cli.Context) error {
		if !c.Args().Present() {

## Benchmarks and speed { #benchmarks-and-speed }

When you check the benchmarks, it is common to see several tools of different types compared as equivalent.

Specifically, to see Uvicorn, Starlette and FastAPI compared together (among many other tools).

The simpler the problem solved by the tool, the better performance it will get. And most of the benchmarks don't test the additional features provided by the tool.

The hierarchy is like:

import jcifs.util.Hexdump;

/**
 * Base class for SMB1 AndX (chained) command messages.
 * This class extends ServerMessageBlock to support SMB1 command chaining, where multiple
 * related commands can be batched together in a single message for improved efficiency.
 */
public abstract class AndXServerMessageBlock extends ServerMessageBlock {

    private static final Logger log = LoggerFactory.getLogger(AndXServerMessageBlock.class);

	return false
}

// ListMultipartsInfo - represents bucket resources for incomplete multipart uploads.
type ListMultipartsInfo struct {
	// Together with upload-id-marker, this parameter specifies the multipart upload
	// after which listing should begin.
	KeyMarker string

	// Together with key-marker, specifies the multipart upload after which listing
	// should begin. If key-marker is not specified, the upload-id-marker parameter