# Django 6.0.5 documentation

# Hur man implementerar en anpassad mallbackend

## Anpassade backends

Så här implementerar du en anpassad mallbackend för att kunna använda ett annat mallsystem. En template backend är en klass som ärver `django.template.backends.base.BaseEngine`. Den måste implementera `get_template()` och eventuellt `from_string()`. Här är ett exempel på ett fiktivt mallbibliotek för `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)

Se DEP 182 för mer information.

## Felsökningsintegration för anpassade motorer

Djangos debugsida har hooks för att ge detaljerad information när ett mallfel uppstår. Anpassade mallmotorer kan använda dessa hooks för att förbättra den spårningsinformation som visas för användarna. Följande hooks är tillgängliga:

### Mall för postmortem

Postmortem visas när `TemplateDoesNotExist` utlöses. Den listar de mallmotorer och laddare som användes när man försökte hitta en viss mall. Om till exempel två Django-motorer är konfigurerade kommer postmortem att se ut så här:

Anpassade motorer kan fylla i postmortem genom att skicka argumenten `backend` och `tried` när `TemplateDoesNotExist`. Backends som använder postmortem bör ange ett ursprung på mallobjektet.

### Kontextuell information om linjen

Om ett fel inträffar under mallparsning eller rendering kan Django visa den rad där felet inträffade. Till exempel:

Anpassade motorer kan fylla i denna information genom att ställa in ett `template_debug`-attribut på undantag som uppstår under parsning och rendering. Detta attribut är en `dict` med följande värden:

- `'namn'`: Namnet på den mall där undantaget inträffade.

- `'meddelande'`: Meddelandet om undantaget.

- `'source_lines'`: Raderna före, efter och inklusive den rad som undantaget inträffade på. Detta är för sammanhanget, så det bör inte innehålla mer än 20 rader eller så.

- `'rad'`: Radnumret på vilken undantaget inträffade.

- `'före'`: Innehållet på felraden före den token som orsakade felet.

- `'during'`: Den token som orsakade felet.

- `'after'`: Innehållet på felraden efter den token som orsakade felet.

- `'total'`: Antalet rader i `source_lines`.

- `'top'`: Radnumret där `source_lines` börjar.

- `'botten'`: Radnumret där `source_lines` slutar.

Med tanke på ovanstående mallfel skulle `template_debug` se ut så här:

    {
        "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,
    }

### Origin API och integration med tredje part

Django-mallar har ett `Origin`-objekt som är tillgängligt via attributet `template.origin`. Detta gör att felsökningsinformation kan visas i template postmortem, samt i tredjepartsbibliotek, som Django Debug Toolbar.

Anpassade motorer kan tillhandahålla sin egen `template.origin`-information genom att skapa ett objekt som anger följande attribut:

- `'namn'`: Den fullständiga sökvägen till mallen.

- `'template_name'`: Den relativa sökvägen till mallen som anges i metoderna för laddning av mallar.

- `'loader_name'`: En valfri sträng som identifierar den funktion eller klass som används för att ladda mallen, t.ex. `django.template.loaders.filesystem.Loader`.