Distributed erasure coded configuration with 2 sets, 16 drives per set across hosts.

```
minio server http://host{1...32}/disk1
```

Distributed erasure coded configuration with rack level redundancy 32 sets in total, 16 drives per set.

```
minio server http://rack{1...4}-host{1...8}.example.net/export{1...16}

    assertThat(map.get(getKey)).isEqualTo(getKey + suffix);
    assertThat(map.get(refreshKey)).isEqualTo(refreshKey + suffix);
  }

  @SuppressWarnings("ThreadPriorityCheck") // doing our best to test for races
  public void testExpandDuringLoading() throws InterruptedException {
    int count = 3;
    AtomicInteger callCount = new AtomicInteger();
    // tells the computing thread when to start computing

        // Test characters just outside ranges that are not valid
        assertFalse(CharUtil.isUrlChar('`')); // backtick (just before 'a')
        assertFalse(CharUtil.isUrlChar('{')); // left brace (just after 'z')
        assertFalse(CharUtil.isUrlChar('^')); // caret (before 'a' range)
        assertFalse(CharUtil.isUrlChar('|')); // pipe (not in valid set)
    }

 * this structure is never mutated, it provides a thread-safe view of the backing map.
 *
 * <p>The {@link MapIteratorCache} assumes ownership of the backing map, and cannot guarantee
 * correctness in the face of external mutations to the backing map. As such, it is <b>strongly</b>
 * recommended that the caller does not persist a reference to the backing map (unless the backing
 * map is immutable).
 *

1F62C         ; valid                  ;      ; NV8    # 6.1  GRIMACING FACE
1F62D         ; valid                  ;      ; NV8    # 6.0  LOUDLY CRYING FACE
1F62E..1F62F  ; valid                  ;      ; NV8    # 6.1  FACE WITH OPEN MOUTH..HUSHED FACE
1F630..1F633  ; valid                  ;      ; NV8    # 6.0  FACE WITH OPEN MOUTH AND COLD SWEAT..FLUSHED FACE
1F634         ; valid                  ;      ; NV8    # 6.1  SLEEPING FACE

# Historia, Diseño y Futuro { #history-design-and-future }

Hace algún tiempo, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">un usuario de **FastAPI** preguntó</a>:

> ¿Cuál es la historia de este proyecto? Parece haber surgido de la nada y ser increíble en pocas semanas [...]

Aquí hay un poquito de esa historia.

## Alternativas { #alternatives }

///

La única cosa que la función devuelta por `GzipRequest.get_route_handler` hace diferente es convertir el `Request` en un `GzipRequest`.

Haciendo esto, nuestro `GzipRequest` se encargará de descomprimir los datos (si es necesario) antes de pasarlos a nuestras *path operations*.

	if !ok {
		dstRec = &Record{}
	}
	dstRec.object = v
	return dstRec, nil
}

// Close - closes underlying reader.
func (r *Reader) Close() error {
	// Close the input.
	// Potentially racy if the stream decoder is still reading.
	if r.readCloser != nil {
		r.readCloser.Close()
	}
	if r.exitReader != nil {
		close(r.exitReader)
		r.readerWg.Wait()
		r.exitReader = nil
		r.input = nil
	}

///

## Motivación { #motivation }

Comencemos con un ejemplo simple:

{* ../../docs_src/python_types/tutorial001_py39.py *}

Llamar a este programa genera:

```
John Doe
```

La función hace lo siguiente:

* Toma un `first_name` y `last_name`.
* Convierte la primera letra de cada uno a mayúsculas con `title()`.

## Détails techniques

Les versions modernes de Python supportent le **code asynchrone** grâce aux **"coroutines"** avec les syntaxes **`async` et `await`**.

Analysons les différentes parties de cette phrase dans les sections suivantes :

* **Code asynchrone**
* **`async` et `await`**
* **Coroutines**