* OAuth2 Scopes: Scopes de OAuth2 (do not translate to "Alcances de OAuth2")
* on the fly: sobre la marcha (do not translate to "al vuelo")
* terminal: terminal (femenine, as in "la terminal")
* terminals: terminales (plural femenine, as in "las terminales")
* lifespan: lifespan (do not translate to "vida útil" or "tiempo de vida")
* unload: quitar de memoria (do not translate to "descargar")

<div class="termy">

```console
$ pip install "fastapi[standard]"

---> 100%
```

</div>

**Nota**: Asegúrate de poner `"fastapi[standard]"` entre comillas para asegurar que funcione en todas las terminales.

## Ejemplo

### Créalo

* Crea un archivo `main.py` con:

```Python
from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")

     * State#FAILED fail}/{@linkplain State#TERMINATED terminate} before all other services have
     * started {@linkplain State#RUNNING running} then this method will not be called.
     */
    public void healthy() {}

    /**
     * Called when the all of the component services have reached a terminal state, either
     * {@linkplain State#TERMINATED terminated} or {@linkplain State#FAILED failed}.
     */

   * executor will not be {@linkplain ScheduledExecutorService#shutdown shutdown} when this service
   * {@linkplain Service.State#TERMINATED terminates} or {@linkplain Service.State#TERMINATED
   * fails}. Subclasses may override this method to supply a custom {@link ScheduledExecutorService}
   * instance. This method is guaranteed to only be called once.
   *

   * executor will not be {@linkplain ScheduledExecutorService#shutdown shutdown} when this service
   * {@linkplain Service.State#TERMINATED terminates} or {@linkplain Service.State#TERMINATED
   * fails}. Subclasses may override this method to supply a custom {@link ScheduledExecutorService}
   * instance. This method is guaranteed to only be called once.
   *

         */
        public void setFinished(final boolean finished) {
            this.finished = finished;
        }

        /**
         * Checks if the process has been terminated due to timeout.
         * @return True if the process was terminated, false otherwise.
         */
        public boolean isTeminated() {
            return teminated;
        }
    }

    /**

                logger.error("IndexUpdater is terminated.", e);
            } else if (logger.isInfoEnabled()) {
                logger.info("IndexUpdater is terminated.");
            }
            forceStop();
        } catch (final Throwable t) {
            if (ComponentUtil.available()) {
                logger.error("IndexUpdater is terminated.", t);
            } else if (logger.isDebugEnabled()) {

     * @param cmdList the list of command arguments to execute
     * @return the exit code of the process if it finishes normally; -1 if the process fails or is terminated
     */
    protected int executeCommand(final String thumbnailId, final List<String> cmdList) {
        ProcessDestroyer task = null;
        Process p = null;
        InputStreamThread ist = null;
        try {

            }
        }
    }

    /**
     * Interrupts the thread and waits for it to terminate.
     *
     * @param timeoutMillis
     *            The time to wait (in milliseconds)
     * @return <code>true</code> if the thread has terminated
     * @throws InterruptedException
     *             If interrupted while waiting
     */

            fail(); // Time Out
        }

        logger.info("Crawler is running");
        count = 0;
        isRunning = true;
        while (count < 300 && isRunning) { // Wait until the crawler terminates
            ThreadUtil.sleep(1000);
            count++;
            final Map<String, Object> scheduler = getSchedulerItem(namePrefix);
            assertTrue(scheduler.containsKey("running"));