suggester.switchIndex();

        // Verify indices still exist and are functional
        final GetAliasesResponse afterResponse = client.admin().indices().prepareGetAliases(suggester.getIndex()).execute().actionGet();

        assertNotNull("Aliases should still exist after switch", afterResponse.getAliases());

        // Cleanup

# Usar el Request Directamente { #using-the-request-directly }

Hasta ahora, has estado declarando las partes del request que necesitas con sus tipos.

Tomando datos de:

* El path como parámetros.
* Headers.
* Cookies.
* etc.

Y al hacerlo, **FastAPI** está validando esos datos, convirtiéndolos y generando documentación para tu API automáticamente.

Pero hay situaciones donde podrías necesitar acceder al objeto `Request` directamente.

        // Verify no front matter metadata
        assertNull(extractData.getValues("frontmatter.title"));
        assertNull(extractData.getValues("frontmatter.author"));

        // But content should still be present
        final String content = extractData.getContent();
        assertTrue(content.contains("Introduction"));
    }

    public void test_getText_withoutHeadings() {

 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.
 *   <li>Once an {@code AsyncCallable} returns a {@code Future}, this class considers that task to
 *       be "done" as soon as <i>that</i> {@code Future} completes in any way. Notably, a {@code

Cuando empiezas a trabajar en un proyecto de Python **por primera vez**, crea un entorno virtual **<abbr title="hay otras opciones, esto es solo una guía sencilla">dentro de tu proyecto</abbr>**.

/// tip | Consejo

Solo necesitas hacer esto **una vez por proyecto**, no cada vez que trabajas.

///

//// tab | `venv`

Para crear un entorno virtual, puedes usar el módulo `venv` que viene con Python.

def test_broken_no_raise():
    """
    When a dependency with yield raises after the yield (not in an except), the
    response is already "successfully" sent back to the client, but there's still
    an error in the server afterwards, an exception is raised and captured or shown
    in the server logs.
    """
    with TestClient(app, raise_server_exceptions=False) as client:
        response = client.get("/broken")

# Tipos de Datos Extra { #extra-data-types }

Hasta ahora, has estado usando tipos de datos comunes, como:

* `int`
* `float`
* `str`
* `bool`

Pero también puedes usar tipos de datos más complejos.

Y seguirás teniendo las mismas funcionalidades como hasta ahora:

* Gran soporte de editor.
* Conversión de datos de requests entrantes.
* Conversión de datos para datos de response.
* Validación de datos.

import jcifs.CIFSContext;
import jcifs.Configuration;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Echo request message.
 *
 * This command is used to test connectivity and ensure the
 * SMB2 connection is still active.
 *
 * @author mbechler
 */
public class Smb2EchoRequest extends ServerMessageBlock2Request<Smb2EchoResponse> {

    /**
     * Constructs an SMB2 echo request
     * @param config the client configuration

{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}

`PUT` se usa para recibir datos que deben reemplazar los datos existentes.

### Advertencia sobre el reemplazo { #warning-about-replacing }

Esto significa que si quieres actualizar el ítem `bar` usando `PUT` con un body que contenga:

```Python
{
    "name": "Barz",
    "price": 3,
    "description": None,
}
```

   * documented as being for use with type parameters that have parametric nullness. But Converter's
   * type parameters do not. Still, we use it here so that we can suppress a warning at a smaller
   * level than the whole method but without performing a runtime null check. That way, we can still
   * pass null inputs to LegacyConverter, and it can violate the contract of Converter.
   *