```console
// Créer un répertoire "Code"
$ mkdir code
// Aller dans ce répertoire
$ cd code
```

... et un exemple de code Python ...

```Python
wont_work()  # Cela ne fonctionnera pas 😱
works(foo="bar")  # Cela fonctionne 🎉
```

... et c’est tout.

////

//// tab | Info

Le code dans les blocs de code ne doit pas être modifié, à l’exception des commentaires.

 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent
 * read operations will work correctly. To allow concurrent update operations, wrap your multimap
 * with a call to {@link Multimaps#synchronizedListMultimap}.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/NewCollectionTypesExplained#multimap">{@code Multimap}</a>.
 *
 * @author Jared Levy

 * FutureTask}, {@code ListenableFutureTask} does not provide an overrideable {@link
 * FutureTask#done() done()} method. For similar functionality, call {@link #addListener}.
 *
 * <p>Few users should use this class. It is intended primarily for those who are implementing an
 * {@code ExecutorService}. Most users should call {@link ListeningExecutorService#submit(Callable)
 * ListeningExecutorService.submit} on a service obtained from {@link

# Modèles de paramètres de cookies { #cookie-parameter-models }

Si vous avez un groupe de **cookies** liés, vous pouvez créer un **modèle Pydantic** pour les déclarer. 🍪

Cela vous permet de **réutiliser le modèle** à **plusieurs endroits** et aussi de déclarer des validations et des métadonnées pour tous les paramètres en une seule fois. 😎

/// note | Remarque

Ceci est pris en charge depuis la version `0.115.0` de FastAPI. 🤓

///

    this.ticker = checkNotNull(ticker, "ticker");
  }

  /**
   * Returns {@code true} if {@link #start()} has been called on this stopwatch, and {@link #stop()}
   * has not been called since the last call to {@code start()}.
   */
  public boolean isRunning() {
    return isRunning;
  }

  /**
   * Starts the stopwatch.
   *
   * @return this {@code Stopwatch} instance

        .connectionSpecs(listOf(spec))
        .eventListenerFactory(
          clientTestRule.wrap(
            object : EventListener() {
              override fun connectionAcquired(
                call: Call,
                connection: Connection,
              ) {
                val sslSocket = connection.socket() as SSLSocket

                sessionIds.add(
                  sslSocket.session.id

	public fun onOpen (Lokhttp3/sse/EventSource;Lokhttp3/Response;)V
}

public final class okhttp3/sse/EventSources {
	public static final field INSTANCE Lokhttp3/sse/EventSources;
	public static final fun createFactory (Lokhttp3/Call$Factory;)Lokhttp3/sse/EventSource$Factory;
	public static final synthetic fun createFactory (Lokhttp3/OkHttpClient;)Lokhttp3/sse/EventSource$Factory;

  }

  public void testPadStart_negativeMinLength() {
    assertThat(Strings.padStart("x", -1, '-')).isSameInstanceAs("x");
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testPadStart_null() {
    assertThrows(NullPointerException.class, () -> Strings.padStart(null, 5, '0'));
  }

  public void testPadEnd_noPadding() {

	ADDW 433954697820(AX), AX       // ERROR "offset too large"
	// Pseudo-registers should not be used as scaled index.
	CALL (AX)(PC*1)                 // ERROR "invalid instruction"
	CALL (AX)(SB*1)                 // ERROR "invalid instruction"
	CALL (AX)(FP*1)                 // ERROR "invalid instruction"
	// Forbid memory operands for MOV CR/DR. See #24981.

Note that the C errno value may be non-zero, and thus the err result may be
non-nil, even if the function call is successful. Unlike normal Go conventions,
you should first check whether the call succeeded before checking the error
result. For example:

	n, err := C.setenv(key, value, 1)
	if n != 0 {
		// we know the call failed, so it is now valid to use err
		return err
	}