About

The htpy library renders HTML using pure Python function calls, replacing traditional template languages (Jinja2, Django Templates) with type-checked, composable code. Converting existing HTML to htpy by hand is tedious and error-prone. A misplaced parenthesis or forgotten comma in deeply nested structures silently produces malformed output. This tool parses your HTML through the browser's native DOMParser API, walks the resulting node tree, and emits syntactically correct htpy Python code. It handles attribute-to-keyword mapping, CSS selector shorthand (["#id.class"]), void elements, text node escaping, and configurable import styles. Note: the converter assumes well-formed HTML. Malformed input (unclosed tags, invalid nesting) is corrected by the browser's parser before conversion, which may alter your intended structure.

Formulas

The conversion follows a deterministic tree-walking algorithm. Given an HTML element E with tag name t, attributes set A = {a₁, a₂, …, a_n}, and children C = [c₁, c₂, …, c_m], the output function call is:

htpy(E) = t(selector, kwargs)[htpy(c₁), …, htpy(c_m)]

Where selector is the optional CSS shorthand string built from id and class attributes: selector = "#" + id + "." + join(".", classes). The kwargs dict contains remaining attributes with Python-safe key names: for → for_, class → class_ (when shorthand disabled), hyphenated attributes like data-x use dict unpacking syntax. Text nodes map to Python string literals. Void elements (where m = 0 by spec) omit the bracket notation entirely.

Reference Data

HTML Element	htpy Function	Void/Self-Closing	Common Attributes
`<div>`	div	No	id, class, style, data-*
`<span>`	span	No	id, class, style
`<p>`	p	No	id, class
`<a>`	a	No	href, target, rel
`<img>`	img	Yes	src, alt, width, height
`<input>`	input	Yes	type, name, value, placeholder
`<br>`	br	Yes	-
`<hr>`	hr	Yes	class
`<meta>`	meta	Yes	name, content, charset
`<link>`	link	Yes	rel, href, type
`<ul>`	ul	No	id, class
`<ol>`	ol	No	start, type
`<li>`	li	No	value
`<table>`	table	No	id, class, border
`<form>`	form	No	action, method, enctype
`<button>`	button	No	type, name, disabled
`<textarea>`	textarea	No	name, rows, cols, placeholder
`<select>`	select	No	name, multiple, size
`<option>`	option	No	value, selected
`<header>`	header	No	id, class
`<footer>`	footer	No	id, class
`<nav>`	nav	No	id, class, aria-label
`<section>`	section	No	id, class
`<article>`	article	No	id, class
`<main>`	main	No	id, class
`<h1> - <h6>`	h1 - h6	No	id, class
`<source>`	source	Yes	src, type, media
`<track>`	track	Yes	src, kind, srclang, label
`<wbr>`	wbr	Yes	-
`<col>`	col	Yes	span
`<embed>`	embed	Yes	src, type, width, height

Frequently Asked Questions

The tool uses the browser's native DOMParser API, which applies the HTML5 error recovery algorithm before conversion. This means unclosed tags get auto-closed, misnested elements get rearranged, and invalid nesting (e.g., a

inside a ) is corrected. The htpy output reflects the corrected DOM, not the raw input string. If structural fidelity matters, validate your HTML first.

Python identifiers cannot contain hyphens. The converter outputs hyphenated attributes using dictionary unpacking syntax: for example, data-value="5" becomes {"data-value": "5"} passed to the element call. The htpy library supports this pattern natively.

When enabled (default), the id and class attributes are extracted and combined into a CSS-like selector string as the first argument: div("#main.container.wide"). When disabled, they appear as keyword arguments instead: div(id="main", class_="container wide"). Shorthand produces more concise code, but explicit kwargs may be clearer for dynamic attribute patterns.

Yes. The text content inside script and style elements is preserved as a raw Python string literal. However, be aware that DOMParser may interpret certain sequences (like appearing in a string) during initial parsing. For complex inline scripts, convert them separately.

Boolean attributes without values are converted to Python keyword arguments set to True: e.g., becomes input(disabled=True). This follows htpy's convention for boolean attribute rendering.

The generated code produces standard htpy element trees that are fully compatible with htpy's render_node(), string conversion, and streaming/chunked rendering. No modifications are needed. The output is valid Python that can be pasted directly into an htpy-based application.