# Dokumentasi Django 5.2.8

# Bagaimana menerapkan backend cetakan disesuaikan

## Backend penyesuaian

Ini adalah bagaimana menerapkan backend cetakan penyesuaian untuk menggunakan sistem cetakan lain. Sebuah backend cetakan adalah sebuah kelas yang mewarisi `django.template.backends.base.BaseEngine`. Itu harus diterapkan `get_template()` dan pilihan `from_string()`. Ini adalah sebuah contoh untuk pustaka cetakan khayal `foobar`:

    from django.template import TemplateDoesNotExist, TemplateSyntaxError
    from django.template.backends.base import BaseEngine
    from django.template.backends.utils import csrf_input_lazy, csrf_token_lazy

    import foobar

    class FooBar(BaseEngine):
        # Name of the subdirectory containing the templates for this engine
        # inside an installed application.
        app_dirname = "foobar"

        def __init__(self, params):
            params = params.copy()
            options = params.pop("OPTIONS").copy()
            super().__init__(params)

            self.engine = foobar.Engine(**options)

        def from_string(self, template_code):
            try:
                return Template(self.engine.from_string(template_code))
            except foobar.TemplateCompilationFailed as exc:
                raise TemplateSyntaxError(exc.args)

        def get_template(self, template_name):
            try:
                return Template(self.engine.get_template(template_name))
            except foobar.TemplateNotFound as exc:
                raise TemplateDoesNotExist(exc.args, backend=self)
            except foobar.TemplateCompilationFailed as exc:
                raise TemplateSyntaxError(exc.args)

    class Template:
        def __init__(self, template):
            self.template = template

        def render(self, context=None, request=None):
            if context is None:
                context = {}
            if request is not None:
                context["request"] = request
                context["csrf_input"] = csrf_input_lazy(request)
                context["csrf_token"] = csrf_token_lazy(request)
            return self.template.render(context)

Lihat DEP 182 untuk informasi lebih.

## Penyatuan mencari kesalahan untuk mesin disesuaikan

Halaman mencari kesalahan Django memiliki kait untuk menyediakan informasi rinci ketika cetakan kesalahan muncul. Mesin penyesuaian cetakan dapat menggunakan kait ini untuk meningkatkan lacak kembali informasi yang muncul ke pengguna. Kait berikut tersedia:

### Cetakan postmortem

Postmortem muncul ketika `TemplateDoesNotExist` dimunculkan. Dia mendaftarkan mesin cetakan dan pemuat yang digunakan ketika mencoba menemukan cetakan yang diberikan. Sebagai contoh, jika dua mesin Django dikonfigurasi, postmortem akan muncul seperti:

Mesin penyesuaian dapat mengumpulkan postmortem dengan melewatkan argumen `backend` dan `tried` ketika memunculkan `TemplateDoesNotExist`. Backend yang menggunakan postmortem should specify an origin pada objek cetakan.

### Informasi baris kontekstual

Jika sebuah kesalahan terjadi selama mengurai cetakan atau sedang membangun, Django dapat menampilkan baris dari kesalahan yang terjadi. Sebagai contoh:

Mesin penyesuaian dapat mengumpulkan informasi ini dengan mengatur atribut `template_debug` pada pengecualian dimunculkan selama mengurai dan membangun. Atribut ini adalah `dict` dengan nilai berikut:

- `'name'`: Nama dari cetakan dimana pengecualian muncul.

- `'message'`: Pesan pengecualian.

- `'source_lines'`: Baris sebelum, sesudah, dan termasuk baris pengecualian yang muncul. Ini untuk konteks, jadi itu jangan mengandung lebih dari 20 baris atau lebih.

- `'line'`: Baris angka dimana pengecualian muncul.

- `'before'`: Isi pada baris kesalahan sebelum token yang memunculkan kesalahan.

- `'during'`: Token yang memunculkan kesalahan.

- `'after'`: Isi pada baris kesalahan setelah token yang memunculkan kesalahan.

- `'total'`: Jumlah baris dalam `source_lines`.

- `'top'`: Baris angka dimana `source_lines` mulai.

- `'bottom'`: Baris angka dimana `source_lines` berakhir.

Diberikan cetakan kesalahan diatas, `template_debug` akan berupa seperti:

    {
        "name": "/path/to/template.html",
        "message": "Invalid block tag: 'syntax'",
        "source_lines": [
            (1, "some\n"),
            (2, "lines\n"),
            (3, "before\n"),
            (4, "Hello {% syntax error %} {{ world }}\n"),
            (5, "some\n"),
            (6, "lines\n"),
            (7, "after\n"),
            (8, ""),
        ],
        "line": 4,
        "before": "Hello ",
        "during": "{% syntax error %}",
        "after": " {{ world }}\n",
        "total": 9,
        "bottom": 9,
        "top": 1,
    }

### API asli dan penggabungan pihak-ketiga

Cetakan Django mempunyai objek `Origin` tersedia melalui atribut `template.origin`. Ini mengadakan informasi pencarian kesalahan untuk ditampilkan dalam template postmortem, sama halnyadi pustaka pihak-3, seperti Django Debug Toolbar.

Mesin disesuaikan dapat menyediakan informasi `template.origin` milik mereka sendiri dengan membuat sebuah obyek yang menentukan atribut berikut:

- `'name'`: Jalur penih pada cetakan.

- `'template_name'`: Jalur relatif ke cetakan ketika dilewatkan kedalam metode memuat cetakan.

- `'loader_name'`: Sebuah string pilihan mencirikan fungsi atau kelas digunakan untuk memuat cetakan misalnya `django.template.loaders.filesystem.Loader`.