* Importa `Jinja2Templates`.
* Crea un objeto `templates` que puedas reutilizar más tarde.
* Declara un parámetro `Request` en la *path operation* que devolverá una plantilla.
* Usa los `templates` que creaste para renderizar y devolver un `TemplateResponse`, pasa el nombre de la plantilla, el objeto de request, y un diccionario "context" con pares clave-valor que se usarán dentro de la plantilla Jinja2.

src/cmd/go.mod. When a package outside std or cmd is imported
by a package inside std or cmd, the import path is interpreted
as if it had a "vendor/" prefix. For example, within "crypto/tls",
an import of "golang.org/x/crypto/cryptobyte" resolves to
"vendor/golang.org/x/crypto/cryptobyte". When a package with the
same path is imported from a package outside std or cmd, it will
be resolved normally. Consequently, a binary may be built with two

     * </ul>
     *
     * @return a non-null string describing the source location
     */
    @Nonnull
    String getLocation();

    /**
     * Resolves a new source relative to this one.
     * <p>
     * The resolution strategy depends on the source type:
     * <ul>
     *   <li>File sources resolve against their parent directory</li>

{* ../../docs_src/path_params/tutorial005_py39.py hl[20] *}

/// tip | Consejo

También podrías acceder al valor `"lenet"` con `ModelName.lenet.value`.

///

#### Devolver *miembros* de enumeración { #return-enumeration-members }

Puedes devolver *miembros de enum* desde tu *path operation*, incluso anidados en un cuerpo JSON (por ejemplo, un `dict`).

    Map<PathType, List<Path>> resolveDependencies(
            @Nonnull Project project, @Nonnull PathScope scope, @Nonnull Collection<PathType> desiredTypes);

    /**
     * Resolves an artifact's meta version (if any) to a concrete version.
     * For example, resolves "1.0-SNAPSHOT" to "1.0-20090208.132618-23".
     * <p>
     * Shortcut for {@code getService(VersionResolver.class).resolve(...)}
     *

///

## Ordem de execução de múltiplos middlewares { #multiple-middleware-execution-order }

Quando você adiciona múltiplos middlewares usando o decorador `@app.middleware()` ou o método `app.add_middleware()`, cada novo middleware envolve a aplicação, formando uma pilha. O último middleware adicionado é o mais externo, e o primeiro é o mais interno.

No caminho da requisição, o middleware mais externo roda primeiro.

No caminho da resposta, ele roda por último.

                values, "values() order should match declaration order");
    }

    // Happy path: valueOf resolves each constant name; toString equals name; ordinal is stable
    @ParameterizedTest
    @ValueSource(strings = { "NONE", "NO_TIMEOUT", "NO_RETRY", "RETAIN_PAYLOAD" })

These details are useful mainly if you had a FastAPI application older than 0.121.0 and you are facing issues with dependencies with `yield`.

///

Dependencies with `yield` have evolved over time to account for the different use cases and to fix some issues, here's a summary of what has changed.

### Dependencies with `yield` and `scope` { #dependencies-with-yield-and-scope }

The Gradle codebase has evolved over time and has a mixture of simple getter/setter methods, Provider API and things in between.  It can be hard to follow best practices because Gradle provided types are reused in unexpected ways and extended by third party plugins.

        protected String getProperty(final String key, final String defaultValue) {
            return ComponentUtil.getSystemProperties().getProperty(key, defaultValue);
        }

        /**
         * Resolves a resource path to an absolute file path.
         *
         * @param path The resource path to resolve
         * @return The absolute file path of the resource, or null if not found
         */