Rendering

Intermediate representation of a component invocation.

Created by Component(). Holds the component class and the kwargs/slots that were passed. Rendering is deferred until .render() is called.

Attributes

• comp_cls - The Component subclass to render.
• kwargs - The keyword arguments passed to the component.
• slots - The slot fills passed to the component. Filled from either channel: the reserved slots= kwarg when composing from Python (MyComp(title="x", slots={...})), or the collected <c-fill> tags / implicit default body when composed by a parent template. Values are raw inputs here (strings, functions, elements, Slots); they normalize to Slot instances when the component instance is created at render time.
• component_tag_client_bindings - The final source-ordered $c-props, Alpine event, and Citry event contributions captured from a component tag. They are framework metadata, not Python kwargs.
• ownership_invocation_id - The render-local component call record that this element will bind to its concrete component instance.
• ownership_graph - The render-local graph that allocated ownership_invocation_id. Retained explicitly so a lazy value invoked during another root render cannot bind a graph-local ID against the wrong graph.
• element_morph_metadata - Private metadata materialized only by the dynamic ordinary-element built-in.
• forward_ownership_invocation - Whether this element is the transparent dynamic selector and must forward the invocation to its selected target instead of consuming it.

render(template_globals: Mapping[str, Any] | None = None, provides: Mapping[str, Any] | None = None) -> CitryRender

The result of rendering a CitryElement (the render-phase output).

Attributes

• parts - Ordered list of str or nested CitryRender fragments.
• context - The CitryContext used to produce this render.
• is_component_root bool - True for a nontransparent component's whole output. Transparent whole outputs and interior renders (a <c-if>/<c-for> block, a nested template, slot-fill content rendered in the enclosing scope) are False. Serialization uses this to tell a completed child-component subtree (which becomes its own marked frame) from content that joins into the surrounding frame; the component on the context cannot tell these apart, because slot-fill content carries the context of the component that wrote it, not the one it renders inside.

is_component_root: bool

serialize(deps_strategy: DepsStrategy = 'document', deps_position: DepsPosition = 'smart', csp_nonce: str | None = None, security_csp: SecurityCspMode | None = None, security_javascript: SecurityJavascriptMode | None = None, security_script_integrity: SecurityScriptIntegrityMode | None = None) -> str

serialize_result(deps_strategy: DepsStrategy = 'document', deps_position: DepsPosition = 'smart', csp_nonce: str | None = None, security_csp: SecurityCspMode | None = None, security_javascript: SecurityJavascriptMode | None = None, security_script_integrity: SecurityScriptIntegrityMode | None = None) -> SerializedRender

Final HTML plus host-facing security metadata for those exact bytes.

html: str

security: SerializedSecurity

Security contributions produced by one serialization call.

csp_script_hashes is the deduplicated document-order tuple of quoted hash sources that a host can add to script-src. It and scripts are empty when digest-producing security features are disabled.

scripts: tuple[SerializedScriptSecurity, ...]

csp_script_hashes: tuple[str, ...]

Security metadata for one structured script in serialized output.

digests uses the unquoted SRI form, such as "sha384-...". provenance states whether Citry computed or verified those bytes. origin_class_id identifies the component class when one owns the tag.

location: Literal['inline', 'external']

url: str | None

digests: tuple[str, ...]

provenance: Literal['citry-computed', 'declared-verified', 'declared-unverified']

origin_class_id: str | None

Render-scoped state for a single component render.

Attributes

• variables - The per-component template variables (the template_data output). Read by nodes when evaluating expressions. Values are ordinary Python objects; the private mapping stores any Const promise separately by variable name.
• component - The Component instance currently rendering. Gives a node access to the component tree (its citry registry for resolving child component names, and its parent/root linkage). The current component is stored on the context, so each component render gets its own CitryContext.
• extra - Tree-wide scratch space for extensions (for example the collected JS/CSS dependency records). Top-level keys are namespaced by owner; see the module docstring.
• provides - The provide/inject entries active at this point of the render. Entries may hold a direct caller value, a frozen keyword- field payload, or a private blocked marker. Read-only by convention; Component.provide and Component.unprovide build a new mapping rather than mutating this one.

A component's loaded template: the source string, its origin, and its compiled form (once first rendered).

Attributes

• source str - The template string, after on_template_loaded hooks ran.
• origin str - Where the template came from, for error messages and debugging. The absolute file path for a file template, or "<module file>::<ClassName>" for an inline one.
• filepath Path | None - The resolved template file, or None when the template was inlined on the class.
• generate Callable[[], list[BodyItem]] | None - Internal. The compiled body-generating function; calling it yields a fresh node list. None until the render pipeline compiles the template on first render.
• used_vars frozenset[str] - Internal. Every variable name the template uses, including in nested tags (the parse-time Template.used_variables). Empty until compiled. The Const optimization keys its cache only on these.
• declared_slots tuple[DeclaredSlot, ...] - Internal. The <c-slot> tags the template declares (static names only), used to check the component against its Slots schema. Empty until compiled.

source: str

origin: str

filepath: Path | None

template_id: str

kind: Literal['primary', 'standalone', 'nested']

generate: Callable[[], list[BodyItem]] | None

used_vars: frozenset[str]

declared_slots: tuple[DeclaredSlot, ...]

foreign_spans: tuple[Any, ...]

foreign_provider_metadata: dict[str, Any]

foreign_compile_contexts: dict[str, Any]

foreign_prepared: bool

source_offset: int

root_source: str | None

compile_lock: RLock

standalone_bodies: OrderedDict[object, list[Any]]

Opaque handle to one already-compiled independent Citry body list.

Render a protected compiled body with a live host-variable overlay.

Collect fills from a host-selected compiled body against a live overlay.

A spot in the output whose final text is supplied at serialize time.

Rendered output is normally text and nested renders, fixed once rendered. A Placeholder marks a position whose content is only known when the whole page is serialized: the <c-js> / <c-css> built-ins render one each, and the dependencies extension fills them with the collected script/style tags via the on_serialize hook.

Attributes

• key - What belongs at this spot (e.g. "deps:js"). The serializer reports each occurrence to the on_serialize hook under this key plus a counter and a private per-serialization identity. An extension that knows the key supplies the text; an occurrence no extension fills serializes to nothing. The private identity keeps cleanup from matching an authored <template c-render-id> with the same key and counter.

Immutable identity needed to traverse and serialize one render frame.

render_id: str | None

class_id: str | None

class_name: str | None

is_component_root: bool

root_markers: tuple[str, ...]

is_transparent_root: bool

from_context(context: CitryContext, is_component_root: bool, is_transparent_root: bool = False) -> RenderFrame

Return True if value is marked Const.

Unwrap outer marker layers; leave plain values unchanged and reject marker cycles.

citry.Markup is exactly markupsafe.Markup, re-exported unchanged. Markup(value) trusts the complete value without sanitizing, validating, or escaping anything.

An expression attempted an operation blocked by the evaluator's sandbox.

The evaluator raises this at evaluation time when a checked variable, attribute, key, callable, or assignment is unsafe.