Now you can import and use the client code. It could look like this, notice that you get autocompletion for the methods:

<img src="/img/tutorial/generate-clients/image02.png">

You will also get autocompletion for the payload to send:

<img src="/img/tutorial/generate-clients/image03.png">

/// tip

Notice the autocompletion for `name` and `price`, that was defined in the FastAPI application, in the `Item` model.

///

- framework: framework (do not translate to cadre)
- performance: performance

- type hints: annotations de type
- type annotations: annotations de type

- autocomplete: autocomplétion
- autocompletion: autocomplétion

- the request (what the client sends to the server): la requête
- the response (what the server sends back to the client): la réponse

- the request body: le corps de la requête

In the Python developer surveys, it's clear [that one of the most used features is "autocompletion"](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features).

The whole **FastAPI** framework is based to satisfy that. Autocompletion works everywhere.

You will rarely need to come back to the docs.

Here's how your editor might help you:

It is **HIGHLY encouraged** that you write or copy the code, edit it and run it locally.

Using it in your editor is what really shows you the benefits of FastAPI, seeing how little code you have to write, all the type checks, autocompletion, etc.

---

## Install FastAPI { #install-fastapi }

The first step is to install FastAPI.

Make sure you create a [virtual environment](../virtual-environments.md), activate it, and then **install FastAPI**:

* /// note: /// note | Nota
* /// tip: /// tip | Dica
* /// warning: /// warning | Atenção
* you should: você deveria
* async context manager: gerenciador de contexto assíncrono
* autocomplete: autocompletar
* autocompletion: preenchimento automático
* auto-completion: preenchimento automático
* bug: bug
* context manager: gerenciador de contexto
* cross domain: cross domain (do not translate to "domínio cruzado")

Then I contributed to it, to make it fully compliant with JSON Schema, to support different ways to define constraint declarations, and to improve editor support (type checks, autocompletion) based on the tests in several editors.

During the development, I also contributed to [**Starlette**](https://www.starlette.dev/), the other key requirement.

## Development { #development }

* performance: rendimiento
* program (verb): programar
* code (verb): programar
* type hints: anotaciones de tipos
* type annotations: anotaciones de tipos
* autocomplete: autocompletado
* completion (in the context of autocompletion): autocompletado
* feature: funcionalidad
* sponsor: sponsor
* host (in a podcast): host
* request (as in HTTP request): request
* response (as in HTTP response): response

    print(f"Successfully initialized: {new_path}")
    update_languages()


@app.command()
def build_lang(
    lang: str = typer.Argument(
        ..., callback=lang_callback, autocompletion=complete_existing_lang
    ),
) -> None:
    """
    Build the docs for a language.
    """
    lang_path: Path = Path("docs") / lang
    if not lang_path.is_dir():

///

The dependencies will keep working as expected, and the **best part** is that the **type information will be preserved**, which means that your editor will be able to keep providing you with **autocompletion**, **inline errors**, etc. The same for other tools like `mypy`.

This will be especially useful when you use it in a **large code base** where you use **the same dependencies** over and over again in **many *path operations***.

///

## Recap { #recap }

With **FastAPI**, by using short, intuitive and standard Python type declarations, you get:

* Editor support: error checks, autocompletion, etc.
* Data "<dfn title="converting the string that comes from an HTTP request into Python data">parsing</dfn>"
* Data validation
* API annotation and automatic documentation

And you only have to declare them once.