---
title: "Conas cúltaca teimpléad saincheaptha a chur i bhfeidhm"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/howto/custom-template-backend/
canonical: https://djangodocs.dev/ga/5.2/howto/custom-template-backend/
---
# Conas cúltaca teimpléad saincheaptha a chur i bhfeidhm

## Cúltaca saincheaptha

Seo conas cúltaca teimpléad saincheaptha a chur i bhfeidhm d'fhonn córas teimpléid eile a úsáid. Is aicme é cúltaca teimpléad a fhaigheann `Django.Template.Backends.Base.BaseEngine` oidhreachta. Caithfidh sé ```get_template () ``a chur i bhfeidhm agus ``from_string ()``` roghnach. Seo sampla do leabharlann teimpléad ficseanúil `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)
```

Féach [DEP 182](https://github.com/django/deps/blob/main/final/0182-multiple-template-engines.rst) le haghaidh tuilleadh eolais.

## Comhtháthú dífhabhtaithe le haghaidh innill

Tá crúcaí ag an leathanach dífhabhtaithe Django chun faisnéis mhionsonraithe a sholáthar nuair a thagann earráid Is féidir le hinnill teimpléad saincheaptha na crúcaí seo a úsáid chun an fhaisnéis rianaithe a fheabhsaíonn d'úsáideoirí. Tá na crúcaí seo a leanas ar fáil:

### Teimpléad iar-bháis

Feictear an post mortem nuair a ardaítear: exc: ~django.template.templateDoesNotExist. Liostaíonn sé na hinnill teimpléid agus na luchtóirí a úsáideadh agus iad ag iarraidh teimpléad ar leith a fháil. Mar shampla, má tá dhá innill Django cumraithe, beidh an post mortem le feiceáil mar:

![](howto/_images/postmortem.png)

Is féidir le hinnill saincheaptha an post mortem a líonadh trí na hargóintí `backend` agus tried a rith agus iad ag ardú: exc: ~django.template.templateDoesNotExist. \<template-origin-api\>Ba chóir go mbeadh cúltaca a úsáideann an postmortem:ref: bunús 'a shonrú ar réad an teimpléid.

### Faisnéis líne comhthéacsúil

Má tharlaíonn earráid le linn parsála nó rindreála teimpléad, is féidir le Django an líne a tharla an earráid air a thaispeáint. Mar shampla:

![](howto/_images/template-lines.png)

Is féidir le hinnill saincheaptha an fhaisnéis seo a líonadh trí thréith `template_debug` a shocrú ar eisceachtaí a ardaítear le linn parsála agus rindreála. Is é an tréith seo a: class: dict leis na luachanna seo a leanas:

- ``` ``ainm ```: Ainm an teimpléid inar tharla an eisceacht.
- `` `'teachtaireacht e' ``: An teachtaireacht eisceachta.
- `` `'source_lines' ``: Na línte roimh, tar éis, agus lena n-áirítear an líne a tharla an eisceacht air. Tá sé seo le haghaidh comhthéacs, mar sin níor chóir go mbeadh níos mó ná 20 líne nó mar sin ann.
- `'líne '`: An uimhir líne ar tharla an eisceacht.
- `` `roimh ``: An t-ábhar ar an líne earráide roimh an comhartha a d'ardaigh an earráid.
- ``` ``le linn ' ```: An comhartha a d'ardaigh an earráid.
- ``` ``tar éis ' ```: An t-ábhar ar an líne earráide tar éis an chomhartha a d'ardaigh an earráid.
- `'iomlán'`: Líon na línte i `source_lines`.
- `'top'`: An uimhir líne ina dtosaíonn `source_lines`.
- `'bottom'`: An uimhir líne ina gcríochnaíonn `source_lines`.

Mar gheall ar an earráid teimpléid thuas, bheadh cuma `template_debug` mar:

```
{
    "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 Origin agus comhtháthú 3ú páirtí

Tá réad: class: ~django.template.base.origin ag teimpléid Django ar fáil tríd an tréith `template.origin`. \<django-debug-toolbar\>Cuireann sé seo ar chumas faisnéis dífhabhtaithe a thaispeáint in:ref: template postmortem \<template-postmortem\>, chomh maith le leabharlanna 3ú páirtí, cosúil leis an: pypi: Django Debug Toolbar.

Is féidir le hinnill saincheaptha a gcuid faisnéise template.origin\` féin a sholáthar trí réad a chruthú a shonraíonn na tréithe seo a leanas:

- ``` ``ainm ```: An cosán iomlán chuig an teimpléad.
- `'template_name'`: An cosán coibhneasta chuig an teimpléad mar a chuirtear isteach sna modhanna luchtaithe teimpléad.
- `` `loader_name' ``: Sreang roghnach a aithníonn an fheidhm nó an rang a úsáidtear chun an teimpléad a luchtú, m.sh. Django.Template.Loaders.FileSystem.Loader\`.