Saltar al contenido

Plantillas - Jinja2Templates

Puedes usar la clase Jinja2Templates para renderizar plantillas Jinja.

Lee más sobre esto en la documentación de FastAPI para Plantillas.

Puedes importarlo directamente desde fastapi.templating:

from fastapi.templating import Jinja2Templates

fastapi.templating.Jinja2Templates 

Jinja2Templates(
    directory: (
        str | PathLike[str] | Sequence[str | PathLike[str]]
    ),
    *,
    context_processors: (
        list[Callable[[Request], dict[str, Any]]] | None
    ) = None
)

Jinja2Templates(
    *,
    env: Environment,
    context_processors: (
        list[Callable[[Request], dict[str, Any]]] | None
    ) = None
)

Jinja2Templates(
    directory=None, *, context_processors=None, env=None
)

Renderizador de plantillas Jinja2.

Ejemplo 
from starlette.templating import Jinja2Templates

templates = Jinja2Templates(directory="templates")

async def homepage(request: Request) -> Response:
    return templates.TemplateResponse(request, "index.html")
Código fuente en starlette/templating.py 
def __init__(
    self,
    directory: str | PathLike[str] | Sequence[str | PathLike[str]] | None = None,
    *,
    context_processors: list[Callable[[Request], dict[str, Any]]] | None = None,
    env: jinja2.Environment | None = None,
) -> None:
    assert bool(directory) ^ bool(env), "either 'directory' or 'env' arguments must be passed"
    self.context_processors = context_processors or []
    if directory is not None:
        loader = jinja2.FileSystemLoader(directory)
        self.env = jinja2.Environment(loader=loader, autoescape=jinja2.select_autoescape())
    elif env is not None:  # pragma: no branch
        self.env = env

    self._setup_env_defaults(self.env)

context_processors instance-attribute 

context_processors = context_processors or []

env instance-attribute 

env = Environment(
    loader=loader, autoescape=select_autoescape()
)

get_template 

get_template(name)
Código fuente en starlette/templating.py 
def get_template(self, name: str) -> jinja2.Template:
    return self.env.get_template(name)

TemplateResponse 

TemplateResponse(
    request,
    name,
    context=None,
    status_code=200,
    headers=None,
    media_type=None,
    background=None,
)

Renderiza una plantilla y retorna una respuesta HTML.

PARÁMETRO DESCRIPCIÓN
request

La instancia de la petición entrante.

TYPE: Request

name

El nombre del archivo de plantilla a renderizar.

TYPE: str

context

Variables a pasar a la plantilla.

TYPE: dict[str, Any] | None DEFAULT: None

status_code

Código de estado HTTP para la respuesta.

TIPO: int DEFAULT: 200

headers

Headers adicionales a incluir en la respuesta.

TIPO: Mapping[str, str] | None DEFAULT: None

media_type

Tipo de media para la respuesta.

TYPE: str | None DEFAULT: None

background

Tarea en segundo plano a ejecutar después de enviar la respuesta.

TYPE: BackgroundTask | None DEFAULT: None

RETORNA DESCRIPCIÓN
_TemplateResponse

Una respuesta HTML con el contenido de la plantilla renderizada.
Código fuente en starlette/templating.py 
def TemplateResponse(
    self,
    request: Request,
    name: str,
    context: dict[str, Any] | None = None,
    status_code: int = 200,
    headers: Mapping[str, str] | None = None,
    media_type: str | None = None,
    background: BackgroundTask | None = None,
) -> _TemplateResponse:
    """
    Render a template and return an HTML response.

    Args:
        request: The incoming request instance.
        name: The template file name to render.
        context: Variables to pass to the template.
        status_code: HTTP status code for the response.
        headers: Additional headers to include in the response.
        media_type: Media type for the response.
        background: Background task to run after response is sent.

    Returns:
        An HTML response with the rendered template content.
    """
    context = context or {}

    context.setdefault("request", request)
    for context_processor in self.context_processors:
        context.update(context_processor(request))

    template = self.get_template(name)
    return _TemplateResponse(
        template,
        context,
        status_code=status_code,
        headers=headers,
        media_type=media_type,
        background=background,
    )