return new Multisets.AbstractEntry<E>() {
      @Override
      @ParametricNullness
      public E getElement() {
        return baseEntry.getElement();
      }

      @Override
      public int getCount() {
        int result = baseEntry.getCount();
        if (result == 0) {
          return count(getElement());
        } else {
          return result;
        }
      }
    };
  }

          () -> new ToOptionalState<>(null),
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**

          () -> new ToOptionalState<>(null),
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**

Mais vous pouvez avoir des milliers d'endpoints (*chemins d'accès*) utilisant le même système de sécurité.

Et tous (ou seulement une partie d'entre eux, si vous le souhaitez) peuvent profiter de la réutilisation de ces dépendances ou de toute autre dépendance que vous créez.

Et tous ces milliers de *chemins d'accès* peuvent tenir en seulement 3 lignes :

{* ../../docs_src/security/tutorial002_an_py310.py hl[30:32] *}

## Récapitulatif { #recap }

     * represent the same element and count. That is, two entries {@code a} and {@code b} are equal
     * if:
     *
     * {@snippet :
     * Objects.equals(a.getElement(), b.getElement()) && a.getCount() == b.getCount()
     * }
     */
    @Override
    // TODO(kevinb): check this wrt TreeMultiset?
    boolean equals(@Nullable Object o);

    /**
     * {@inheritDoc}

De la même manière, cette base de données n'accepterait pas un modèle Pydantic (un objet avec des attributs), seulement un `dict`.

Vous pouvez utiliser `jsonable_encoder` pour cela.

Elle reçoit un objet, comme un modèle Pydantic, et renvoie une version compatible JSON :

{* ../../docs_src/encoder/tutorial001_py310.py hl[4,21] *}

* Configurez toutes les autorisations et tous les rôles nécessaires à l'aide de dépendances.
* Ne stockez jamais de mots de passe en clair, seulement des hachages de mots de passe.
* Implémentez et utilisez des outils cryptographiques reconnus, comme pwdlib et des jetons JWT, ... etc.
* Ajoutez des contrôles d'autorisation plus granulaires avec des scopes OAuth2 lorsque nécessaire.

Vous ne voulez pas exécuter la dépendance originale (ni ses éventuelles sous‑dépendances).

À la place, vous souhaitez fournir une dépendance différente, utilisée uniquement pendant les tests (éventuellement seulement pour certains tests), et qui fournira une valeur utilisable partout où l’on utilisait celle de la dépendance originale.

### Cas d’usage : service externe { #use-cases-external-service }

Votre API aura presque toujours à envoyer un corps de **réponse**. Mais un client n'a pas toujours à envoyer un **corps de requête** : parfois il demande seulement un chemin, peut-être avec quelques paramètres de requête, mais n'envoie pas de corps.

## Documenter le callback { #documenting-the-callback }

Le code réel du callback dépendra fortement de votre application API.

Et il variera probablement beaucoup d’une application à l’autre.

Cela pourrait être seulement une ou deux lignes de code, comme :

```Python
callback_url = "https://example.com/api/v1/invoices/events/"
httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
```