Le « flux » `password` est l'une des manières (« flows ») définies dans OAuth2 pour gérer la sécurité et l'authentification.

OAuth2 a été conçu pour que le backend ou l'API puisse être indépendant du serveur qui authentifie l'utilisateur.

Mais dans ce cas, la même application **FastAPI** gérera l'API et l'authentification.

Voyons cela selon ce point de vue simplifié :

  }

  /**
   * Builds a thread-safe map. This method does not alter the state of this {@code MapMaker}
   * instance, so it can be invoked again to create multiple independent maps.
   *
   * <p>The bulk operations {@code putAll}, {@code equals}, and {@code clear} are not guaranteed to
   * be performed atomically on the returned map. Additionally, {@code size} and {@code

            assertEquals(8388608, response.getTotalBytesWritten()); // 8MB total
        }

        @Test
        @DisplayName("Should create multiple independent instances")
        void testMultipleInstances() throws SMBProtocolDecodingException {
            SrvCopyChunkCopyResponse response1 = new SrvCopyChunkCopyResponse();

        assertEquals(1, chain.deleteCalls.size());
        assertEquals(1, chain.changePasswordCalls.size());
        assertEquals(1, chain.loadCalls.size());

        // Verify independence of operations
        assertEquals(user1, chain.updateCalls.get(0));
        assertEquals(user2, chain.deleteCalls.get(0));
        assertEquals("user3", chain.changePasswordCalls.get(0).getKey());

        assertTrue(result.length() > "TransPeekNamedPipeResponse[]".length());
    }

    @Test
    @DisplayName("Multiple instances should be independent")
    void testMultipleInstances() {
        // Arrange
        TransPeekNamedPipeResponse response1 = new TransPeekNamedPipeResponse(mockConfig);

This was changed in FastAPI 0.106.0 with the intention to not hold resources while waiting for the response to travel through the network.

/// tip

Additionally, a background task is normally an independent set of logic that should be handled separately, with its own resources (e.g. its own database connection).

So, this way you will probably have cleaner code.

///

// For objects with legal hold header set, the s3:PutObjectLegalHold permission is expected to be set
// Both legal hold and retention can be applied independently on an object

Esto cambió en FastAPI 0.106.0 con la intención de no retener recursos mientras se espera a que la response viaje por la red.

/// tip | Consejo

Adicionalmente, una tarea en segundo plano normalmente es un conjunto independiente de lógica que debería manejarse por separado, con sus propios recursos (por ejemplo, su propia conexión a la base de datos).

Así, probablemente tendrás un código más limpio.

///

    Previously OkHttp used its connection pool as a lock when making changes to connections and
    calls. With this change each connection is locked independently.

 *  Upgrade: [Okio 2.7.0][okio_2_7_0].

    ```kotlin
    implementation("com.squareup.okio:okio:2.7.0")
    ```

  try {
    close()
  } catch (rethrown: RuntimeException) {
    throw rethrown
  } catch (_: Exception) {
  }
}

/**
 * Returns true if file streams can be manipulated independently of their paths. This is typically
 * true for systems like Mac, Unix, and Linux that use inodes in their file system interface. It is
 * typically false on Windows.
 *