For templates in Django, prepare an original parent/child block map and three-case render ledger. A small fixture can show what stays in the parent, what a child replaces, and what block.super deliberately retains. The local HTML comparison shows source specifications and expected output; it does not execute Django or establish an engine-render result.
Choose a documented version and a single shell
This plan uses the Django 5.2 template-language documentation. That is the selected reference version, not a claim that 5.2 is latest or installed locally. Record the actual engine, version, loader and template settings before implementing the fixture.
The original parent base.html owns one document shell. Its title block defaults to Notes; its body block contains one paragraph, “Shared checklist.” A footer outside the body block reads “Demo only.”
| Parent component | Original default | Location |
|---|---|---|
| title block | Notes | Document title |
| body block | Shared checklist. | Main content area |
| footer | Demo only. | Outside the body block |
Keep the footer outside that named body block for this experiment. Otherwise, replacing the body could change the footer too and obscure what the example is testing.
Give the child exactly the intended changes
The original child.html extends base.html as its first template tag. It replaces the title block with Practice. Its body block first requests block.super, then adds a paragraph, “Confirm the supplied inputs.”
The reviewed inheritance mechanism uses matching named blocks; parent content supplies defaults for blocks a child does not override. block.super requests the parent block's content when the child extends rather than completely replaces it.
The child's plan does not include another document shell or footer. Its changes occupy the matching title and body blocks. Keep one title block and one body block per template, with matching names; a differently named block is not a substitute for the intended parent's block.
Inspect the expected order and count
| Case | Expected title | Expected body, in order | Footer |
|---|---|---|---|
| Extend body with block.super | Practice | Shared checklist.; Confirm the supplied inputs. | Demo only. once |
| Omit the child body block | Practice | Shared checklist. | Demo only. once |
| Replace body without block.super | Practice | Confirm the supplied inputs. | Demo only. once |
In the extension case, each body sentence appears once and the shared sentence precedes the child's addition. In the omitted-block case, the parent default remains. In the replacement case, losing the shared sentence is intentional because the child did not request it; the footer remains because it is outside that block.
These are manually reasoned acceptance expectations. Exact output whitespace, bytes and rendered element counts still require the actual engine and source files. A mock result table is not evidence of a completed render.
Trace a missing result before changing the content
Keep the parent template name, loader location and exact block names in the native record. If base.html cannot be resolved, report the actual loader/render error instead of showing the predicted success table as output.
A typo such as a different body-block name needs a source-to-block comparison. Do not “fix” it by copying the shared checklist into the child or inserting another footer. That hides the inheritance defect and leaves two sources of truth.
For every later test, record which child case was used, the parent source version, actual engine/settings and observed result. Changing a parent or child invalidates an old render result; the next comparison needs a new render record.
Keep parent rendering separate from trust in external content
The reviewed documentation explains that block.super content is not escaped again because necessary escaping occurred in the parent context. This is inheritance behavior, not permission to treat arbitrary external HTML as trusted.
The fixture uses only its own fixed sentences. Do not add a blanket safe filter or disable escaping merely to make the sample look correct. Any future variable content needs its own reviewed handling under the actual template settings; this three-case ledger does not certify that handling.
Retain the native source and acceptance ledger
Prepare original parent/child source specifications and the block/render map first. Keep APIs, application routes, database context, backend and server setup outside this bounded inheritance task. The page-shell experiment can be understood without creating an application.
In the local HTML comparison, read the source specifications and expected output separately from actual engine results. A case selector can show the corresponding ledger, but it cannot claim to execute Django in the browser. Native template selection and engine-render results still require tests in the actual Django environment.
Copyable inheritance-ledger prompt
Prepare an original native Django parent/child block specification and three-case render acceptance ledger, plus an optional HTML comparison specification. Use reviewed Django 5.2 documentation as selected reference, not latest/installed proof. Actual version/engine/loader/settings must be recorded before implementation; do not create source files, app/server/backend or rendered HTML now.
Parent base.html owns one document shell: title block Notes, body block one paragraph “Shared checklist.”, footer outside body block “Demo only.” Child child.html extends base as first template tag; matching title block Practice; body block requests block.super then paragraph “Confirm the supplied inputs.” No child shell/footer copy or duplicate same-name blocks.
Expected extension: Practice title, Shared checklist. once then Confirm the supplied inputs. once, Demo only. once. Alternate child omits body block: retains Shared checklist. Alternate child replaces without super: only Confirm the supplied inputs. Footer retained in both. Exact bytes/whitespace/engine output unexecuted. Keep case/source version/settings and observed result separate from predictions.
Missing base reports real loader error, not fake valid output. Named-block typo requires map review, not copied parent body. Source changes retire old result evidence. block.super uses already parent-rendered content; it does not confer blanket trust on external HTML. No safe-filter/autoescape-off shortcut. Fixed original strings only; future variable handling needs separate review.
Native specifications and render ledger primary. Optional case selector displays expected records without pretending to execute Django. Provide exact block/order/count, omitted/default, no-super replacement, loader/typo/source-change checks. Mark actual files/engine/render/escaping/controls/article width/360 px and NOS sample checks not_tested. No copied official skeleton, API/backend, compiler/import/deployment or host promise.
Optional use for already rendered HTML
Keep the native Django templates and actual engine-render records as the primary developer materials. NOS supports saving and rendering prepared HTML. Verify that sample in the actual workspace; this does not establish Django template compilation or backend execution in NOS.
Explore NOS with prepared HTML, keeping the parent block and child change beside the expected one-document result so a shared checklist stays shared instead of becoming another copied page.