# Templating - `Jinja2Templates`

You can use the `Jinja2Templates` class to render Jinja templates.

Read more about it in the [FastAPI docs for Templates](https://fastapi.tiangolo.com/advanced/templates/).

You can import it directly from `fastapi.templating`:

```python
from fastapi.templating import Jinja2Templates
```

# Templating – `Jinja2Templates`

Sie können die `Jinja2Templates`-Klasse verwenden, um Jinja-Templates zu rendern.

Lesen Sie mehr darüber in der [FastAPI-Dokumentation zu Templates](../advanced/templates.md).

Sie können die Klasse direkt von `fastapi.templating` importieren:

```python
from fastapi.templating import Jinja2Templates
```

		name: name,
	}
	t.init()
	return t
}

// Name returns the name of the template.
func (t *Template) Name() string {
	return t.name
}

// New allocates a new, undefined template associated with the given one and with the same
// delimiters. The association, which is transitive, allows one template to
// invoke another with a {{template}} action.
//

import (
	"encoding/base64"
	"fmt"
	"io"
	"reflect"
	"text/template"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/json"
)

// GoTemplatePrinter is an implementation of ResourcePrinter which formats data with a Go Template.
type GoTemplatePrinter struct {
	rawTemplate string
	template    *template.Template
}

func NewGoTemplatePrinter(tmpl []byte) (*GoTemplatePrinter, error) {

package param

import (
	"text/template"
	"text/template/parse"

	"istio.io/istio/pkg/util/sets"
)

// Template that has been parsed to search for template parameters.
type Template struct {
	*template.Template
	params sets.String
}

// Parse the given template to find the set of template parameters used.
func Parse(t *template.Template) *Template {
	return &Template{
		Template: t,

*/

package util

import (
	"bytes"
	"text/template"

	"github.com/pkg/errors"
)

// ParseTemplate validates and parses passed as argument template
func ParseTemplate(strtmpl string, obj interface{}) ([]byte, error) {
	var buf bytes.Buffer
	tmpl, err := template.New("template").Parse(strtmpl)
	if err != nil {
		return nil, errors.Wrap(err, "error when parsing template")
	}
	err = tmpl.Execute(&buf, obj)
	if err != nil {

from starlette.templating import Jinja2Templates as Jinja2Templates  # noqa...

// PatherTemplateMatcher creates a URI template matcher for path.
func PathTemplateMatcher(path string) *uri_template.UriTemplateMatchConfig {
	return &uri_template.UriTemplateMatchConfig{
		PathTemplate: sanitizePathTemplate(path),
	}
}

// sanitizePathTemplate converts the path template into a valid envoy uri template.

{{ template "base" .KubeHome }}
ENCRYPTION_PROVIDER_CONFIG_PATH={{.EncryptionProviderConfigPath}}
{{if .EncryptionProviderConfig}}
  ENCRYPTION_PROVIDER_CONFIG={{.EncryptionProviderConfig}}
{{end}}
{{if .CloudKMSIntegration}}
  readonly CLOUD_KMS_INTEGRATION=true
{{end}}

{{ template "base" .KubeHome }}
readonly ETCD_APISERVER_CA_KEY={{.CAKey}}
readonly ETCD_APISERVER_CA_CERT={{.CACert}}
readonly ETCD_APISERVER_SERVER_KEY={{.APIServerKey}}
readonly ETCD_APISERVER_SERVER_CERT={{.APIServerCert}}
readonly ETCD_APISERVER_CLIENT_KEY={{.ETCDKey}}
readonly ETCD_APISERVER_CLIENT_CERT={{.ETCDCert}}
readonly ETCD_SERVERS={{.ETCDServers}}
readonly ETCD_APISERVER_CA_CERT_PATH={{.CACertPath}}