from typing import List

from fastapi import FastAPI, File, UploadFile
from fastapi.responses import HTMLResponse
from typing_extensions import Annotated

app = FastAPI()


@app.post("/files/")
async def create_files(files: Annotated[List[bytes], File()]):
    return {"file_sizes": [len(file) for file in files]}


@app.post("/uploadfiles/")
async def create_upload_files(files: List[UploadFile]):

Pour déclarer ces types et les types internes, on utilise le module standard de Python `typing`.

Il existe spécialement pour supporter ces annotations de types.

#### `List`

Par exemple, définissons une variable comme `list` de `str`.

Importez `List` (avec un `L` majuscule) depuis `typing`.

```

the default of `q` will be: `["foo", "bar"]` and your response will be:

```JSON
{
  "q": [
    "foo",
    "bar"
  ]
}
```

#### Using just `list`

You can also use `list` directly instead of `List[str]` (or `list[str]` in Python 3.9+):

//// tab | Python 3.9+

```Python hl_lines="9"
{!> ../../docs_src/query_params_str_validations/tutorial013_an_py39.py!}
```

////

      object : BasicDerAdapter.Codec<T> {
        override fun decode(reader: DerReader): T {
          return reader.withTypeHint {
            val list = mutableListOf<Any?>()

            while (list.size < members.size) {
              val member = members[list.size]
              list += member.fromDer(reader)
            }

            if (reader.hasNext()) {

    public abstract void overriddenAndAnnotatedInSubclass(Object o);
  }

  static class SubClass extends SuperClass {
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = Lists.newArrayList();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = Lists.newArrayList();

    @Override
    public void overriddenInSubclassNowhereAnnotated(Object o) {
      overriddenInSubclassNowhereAnnotatedEvents.add(o);

import static org.junit.Assert.assertThat;

import java.util.Iterator;
import java.util.List;

import org.junit.Test;

/**
 * @author koichik
 *
 */
public class MultiIteratorTest {

    /**
     *
     */
    @Test
    public void test() {
        final List<String> list1 = asList("Foo", "Bar");
        final List<String> list2 = asList("Baz");

        @SuppressWarnings("unchecked")

from typing import List

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: List[str] = Query(default=["foo", "bar"])):
    query_items = {"q": q}

                logBuildResumeHint(context, "mvn [args] -r");
            } else if (!failedProjects.isEmpty()) {
                List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();

                // Sort the failedProjects list in the topologically sorted order.
                failedProjects.sort(comparing(sortedProjects::indexOf));

  optional string message = 5;
}

// DeploymentList is a list of Deployments.
message DeploymentList {
  // Standard list metadata.
  // +optional
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1;

  // Items is the list of Deployments.
  repeated Deployment items = 2;
}

// DeploymentSpec is the specification of the desired behavior of the Deployment.

	waypointListCmd := &cobra.Command{
		Use:   "list",
		Short: "List managed waypoint configurations",
		Long:  "List managed waypoint configurations in the cluster",
		Example: `  # List all waypoints in a specific namespace
  istioctl waypoint list --namespace default

  # List all waypoints in the cluster
  istioctl waypoint list -A`,
		RunE: func(cmd *cobra.Command, args []string) error {