```Python hl_lines="6"
{!../../docs_src/first_steps/tutorial001.py!}
```

Le `@app.get("/")` dit à **FastAPI** que la fonction en dessous est chargée de gérer les requêtes qui vont sur :

* le chemin `/`
* en utilisant une <abbr title="une méthode GET HTTP">opération <code>get</code></abbr>

/// info | "`@décorateur` Info"

Cette syntaxe `@something` en Python est appelée un "décorateur".

* **rota**: é `/`.
* **operação**: é `get`.
* **função**: é a função abaixo do "decorador" (abaixo do `@app.get("/")`).

```Python hl_lines="7"
{!../../docs_src/first_steps/tutorial001.py!}
```

Esta é uma função Python.

Ela será chamada pelo **FastAPI** sempre que receber uma requisição para a URL "`/ `" usando uma operação `GET`.

Neste caso, é uma função `assíncrona`.

---

      for (V value : sampleValues()) {
        resetContainer();

        List<V> values = multimap().get(key);
        List<V> expectedValues = copyToList(values);

        assertTrue(multimap().put(key, value));
        expectedValues.add(value);

        assertGet(key, expectedValues);
        assertEquals(value, values.get(values.size() - 1));
      }
    }
  }

  @MapFeature.Require(SUPPORTS_PUT)

  }

  public void testOrderedGet() {
    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();
    assertThat(multimap.get(null)).containsExactly(7, 3, 1).inOrder();
    assertThat(multimap.get("google")).containsExactly(6, 2).inOrder();
    assertThat(multimap.get("tree")).containsExactly(null, 0).inOrder();
  }

  public void testOrderedKeySet() {

     */
    @Test
    public void testGet() throws Exception {
        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        assertThat(list.get(0), is("1"));
        assertThat(list.get(1), is("2"));
        assertThat(list.get(2), is("3"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSerialize() throws Exception {
        list.addLast("1");

		}
	}
}

func fwdStatusToAPIError(resp *http.Response) *APIError {
	if status := resp.Header.Get(xhttp.AmzFwdStatus); status != "" && StatusCode(status) > -1 {
		apiErr := &APIError{
			HTTPStatusCode: StatusCode(status),
			Description:    resp.Header.Get(xhttp.AmzFwdErrorMessage),
			Code:           resp.Header.Get(xhttp.AmzFwdErrorCode),
		}
		if apiErr.HTTPStatusCode == http.StatusOK {
			return nil
		}

    private static final Logger logger = LogManager.getLogger(ApiAdminDictMappingAction.class);

    @Resource
    private CharMappingService charMappingService;

    // GET /api/admin/dict/mapping/settings/{dictId}
    @Execute
    public JsonResponse<ApiResult> get$settings(final String dictId, final SearchBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});

    @Resource
    private StemmerOverrideService stemmerOverrideService;

    // GET /api/admin/dict/stemmerOverride/settings/{dictId}
    @Execute
    public JsonResponse<ApiResult> get$settings(final String dictId, final SearchBody body) {
        body.dictId = dictId;
        validateApi(body, messages -> {});

   * {@code function} is invoked on each call to {@link Future#get() get()} on the returned future.
   *
   * <p>The returned {@code Future} reflects the input's cancellation state directly, and any
   * attempt to cancel the returned Future is likewise passed through to the input Future.
   *
   * <p>Note that calls to {@linkplain Future#get(long, TimeUnit) timed get} only apply the timeout

        final CrawlingConfig crawlingConfig = crawlingConfigHelper.get(crawlerContext.getSessionId());
        final Map<String, String> clientConfigMap = crawlingConfig.getConfigParameterMap(ConfigName.CLIENT);
        final String value = clientConfigMap.get(CRAWLER_CLIENTS);
        final CrawlerClient client = getClientRuleList(value).stream().map(e -> {