python-api-reference.md

# fontpixel Python API reference

<!-- Generated by tools/bindings/gen_pyref.py; do not edit by hand. -->

Every public module, class, function, method, property and constant of the
`fontpixel` package with its typed signature (as in the bundled type stubs) and
docstring. Plain-data shapes (`FontMetrics`, `RenderOptions`, `PcfWriteOptions`,
...) are the `TypedDict`s and `Literal` aliases of `fontpixel.types`; see
[python-api.md](python-api.md) for the concepts and how to discover option
shapes at run time.

## Modules

- [`fontpixel`](#fontpixel) (459) fontpixel: bitmap font toolkit (Python bindings).
- [`fontpixel.compat`](#fontpixelcompat) (0) Compatibility layers over the native fontpixel core.
- [`fontpixel.compat.bdfparser`](#fontpixelcompatbdfparser) (87) bdfparser-compatible API (bdfparser 3.0 / SPEC-v3) on the fontpixel Rust core.
- [`fontpixel.compat.bdfparser.bitmap`](#fontpixelcompatbdfparserbitmap) (1) `Bitmap` of the bdfparser-compatible API.
- [`fontpixel.compat.bdfparser.cli`](#fontpixelcompatbdfparsercli) (1) Command line interface of the bdfparser-compatible API: `convert | info | preview`.
- [`fontpixel.compat.bdfparser.encoding`](#fontpixelcompatbdfparserencoding) (15) Charset support of the bdfparser-compatible API (SPEC-v3 §4, §11.1).
- [`fontpixel.compat.bdfparser.errors`](#fontpixelcompatbdfparsererrors) (0) Warning and exception classes of the bdfparser-compatible API.
- [`fontpixel.compat.bdfparser.font`](#fontpixelcompatbdfparserfont) (0) `Font` of the bdfparser-compatible API (handle over the Rust compat font).
- [`fontpixel.compat.bdfparser.glyph`](#fontpixelcompatbdfparserglyph) (1) `Glyph` of the bdfparser-compatible API (handle over the Rust compat glyph).
- [`fontpixel.compat.bdfparser.outline`](#fontpixelcompatbdfparseroutline) (2) Bitmap outlines of the bdfparser-compatible API (SPEC-v3 §7.1, §7.2, §7.4).
- [`fontpixel.compat.bdfparser.pcf`](#fontpixelcompatbdfparserpcf) (3) PCF input/output of the bdfparser-compatible API (SPEC-v3 §6).
- [`fontpixel.compat.bdfparser.ttf`](#fontpixelcompatbdfparserttf) (2) Pixel TrueType output/input of the bdfparser-compatible API (SPEC-v3 §8, §8.1).
- [`fontpixel.formats`](#fontpixelformats) (3) Per-codec namespaces (`fontpixel.formats.<module>`) and typed option helpers.
- [`fontpixel.formats.amiga`](#fontpixelformatsamiga) (3) Direct codec functions of `fontpixel::formats::amiga`.
- [`fontpixel.formats.bbc`](#fontpixelformatsbbc) (3) Direct codec functions of `fontpixel::formats::bbc`.
- [`fontpixel.formats.bdf`](#fontpixelformatsbdf) (5) Direct codec functions of `fontpixel::formats::bdf`.
- [`fontpixel.formats.beos`](#fontpixelformatsbeos) (3) Direct codec functions of `fontpixel::formats::beos`.
- [`fontpixel.formats.bmfont`](#fontpixelformatsbmfont) (3) Direct codec functions of `fontpixel::formats::bmfont`.
- [`fontpixel.formats.c`](#fontpixelformatsc) (3) Direct codec functions of `fontpixel::formats::c`.
- [`fontpixel.formats.catalyst`](#fontpixelformatscatalyst) (3) Direct codec functions of `fontpixel::formats::catalyst`.
- [`fontpixel.formats.chiwriter`](#fontpixelformatschiwriter) (3) Direct codec functions of `fontpixel::formats::chiwriter`.
- [`fontpixel.formats.comfont`](#fontpixelformatscomfont) (3) Direct codec functions of `fontpixel::formats::comfont`.
- [`fontpixel.formats.consoleet`](#fontpixelformatsconsoleet) (3) Direct codec functions of `fontpixel::formats::consoleet`.
- [`fontpixel.formats.cpi`](#fontpixelformatscpi) (3) Direct codec functions of `fontpixel::formats::cpi`.
- [`fontpixel.formats.cybiko`](#fontpixelformatscybiko) (3) Direct codec functions of `fontpixel::formats::cybiko`.
- [`fontpixel.formats.daisy`](#fontpixelformatsdaisy) (3) Direct codec functions of `fontpixel::formats::daisy`.
- [`fontpixel.formats.dashen`](#fontpixelformatsdashen) (3) Direct codec functions of `fontpixel::formats::dashen`.
- [`fontpixel.formats.dosstart`](#fontpixelformatsdosstart) (3) Direct codec functions of `fontpixel::formats::dosstart`.
- [`fontpixel.formats.draw`](#fontpixelformatsdraw) (3) Direct codec functions of `fontpixel::formats::draw`.
- [`fontpixel.formats.drcs`](#fontpixelformatsdrcs) (3) Direct codec functions of `fontpixel::formats::drcs`.
- [`fontpixel.formats.drhalo`](#fontpixelformatsdrhalo) (3) Direct codec functions of `fontpixel::formats::drhalo`.
- [`fontpixel.formats.edwin`](#fontpixelformatsedwin) (3) Direct codec functions of `fontpixel::formats::edwin`.
- [`fontpixel.formats.embedded`](#fontpixelformatsembedded) (7) Embedded bitmap sfnt codecs (`fontpixel::formats::embedded`): otb, bdat, color.
- [`fontpixel.formats.fbit`](#fontpixelformatsfbit) (5) Direct codec functions of `fontpixel::formats::fbit`.
- [`fontpixel.formats.figlet`](#fontpixelformatsfiglet) (3) Direct codec functions of `fontpixel::formats::figlet`.
- [`fontpixel.formats.fnt`](#fontpixelformatsfnt) (5) Direct codec functions of `fontpixel::formats::fnt`.
- [`fontpixel.formats.fon`](#fontpixelformatsfon) (3) Direct codec functions of `fontpixel::formats::fon`.
- [`fontpixel.formats.fontx2`](#fontpixelformatsfontx2) (3) Direct codec functions of `fontpixel::formats::fontx2`.
- [`fontpixel.formats.fzx`](#fontpixelformatsfzx) (3) Direct codec functions of `fontpixel::formats::fzx`.
- [`fontpixel.formats.gdr`](#fontpixelformatsgdr) (3) Direct codec functions of `fontpixel::formats::gdr`.
- [`fontpixel.formats.gem`](#fontpixelformatsgem) (3) Direct codec functions of `fontpixel::formats::gem`.
- [`fontpixel.formats.geos`](#fontpixelformatsgeos) (3) Direct codec functions of `fontpixel::formats::geos`.
- [`fontpixel.formats.gf`](#fontpixelformatsgf) (3) Direct codec functions of `fontpixel::formats::gf`.
- [`fontpixel.formats.gpi`](#fontpixelformatsgpi) (3) Direct codec functions of `fontpixel::formats::gpi`.
- [`fontpixel.formats.grasp`](#fontpixelformatsgrasp) (3) Direct codec functions of `fontpixel::formats::grasp`.
- [`fontpixel.formats.hanfont`](#fontpixelformatshanfont) (4) Direct codec functions of `fontpixel::formats::hanfont`.
- [`fontpixel.formats.hbf`](#fontpixelformatshbf) (3) Direct codec functions of `fontpixel::formats::hbf`.
- [`fontpixel.formats.hex`](#fontpixelformatshex) (3) Direct codec functions of `fontpixel::formats::hex`.
- [`fontpixel.formats.hmzk`](#fontpixelformatshmzk) (3) Direct codec functions of `fontpixel::formats::hmzk`.
- [`fontpixel.formats.hppcl`](#fontpixelformatshppcl) (3) Direct codec functions of `fontpixel::formats::hppcl`.
- [`fontpixel.formats.hrcg`](#fontpixelformatshrcg) (3) Direct codec functions of `fontpixel::formats::hrcg`.
- [`fontpixel.formats.hzk`](#fontpixelformatshzk) (6) Direct codec functions of `fontpixel::formats::hzk`.
- [`fontpixel.formats.iigs`](#fontpixelformatsiigs) (3) Direct codec functions of `fontpixel::formats::iigs`.
- [`fontpixel.formats.image`](#fontpixelformatsimage) (3) Direct codec functions of `fontpixel::formats::image`.
- [`fontpixel.formats.kbits`](#fontpixelformatskbits) (3) Direct codec functions of `fontpixel::formats::kbits`.
- [`fontpixel.formats.kbitx`](#fontpixelformatskbitx) (3) Direct codec functions of `fontpixel::formats::kbitx`.
- [`fontpixel.formats.lisa`](#fontpixelformatslisa) (3) Direct codec functions of `fontpixel::formats::lisa`.
- [`fontpixel.formats.mgtk`](#fontpixelformatsmgtk) (3) Direct codec functions of `fontpixel::formats::mgtk`.
- [`fontpixel.formats.mkwinfont`](#fontpixelformatsmkwinfont) (3) Direct codec functions of `fontpixel::formats::mkwinfont`.
- [`fontpixel.formats.nfnt`](#fontpixelformatsnfnt) (4) Direct codec functions of `fontpixel::formats::nfnt`.
- [`fontpixel.formats.oberon`](#fontpixelformatsoberon) (3) Direct codec functions of `fontpixel::formats::oberon`.
- [`fontpixel.formats.palm`](#fontpixelformatspalm) (3) Direct codec functions of `fontpixel::formats::palm`.
- [`fontpixel.formats.pbf`](#fontpixelformatspbf) (3) Direct codec functions of `fontpixel::formats::pbf`.
- [`fontpixel.formats.pcf`](#fontpixelformatspcf) (3) Direct codec functions of `fontpixel::formats::pcf`.
- [`fontpixel.formats.pcgeos`](#fontpixelformatspcgeos) (3) Direct codec functions of `fontpixel::formats::pcgeos`.
- [`fontpixel.formats.pcr`](#fontpixelformatspcr) (3) Direct codec functions of `fontpixel::formats::pcr`.
- [`fontpixel.formats.pf2`](#fontpixelformatspf2) (3) Direct codec functions of `fontpixel::formats::pf2`.
- [`fontpixel.formats.pfr`](#fontpixelformatspfr) (3) Direct codec functions of `fontpixel::formats::pfr`.
- [`fontpixel.formats.pilfont`](#fontpixelformatspilfont) (3) Direct codec functions of `fontpixel::formats::pilfont`.
- [`fontpixel.formats.pk`](#fontpixelformatspk) (3) Direct codec functions of `fontpixel::formats::pk`.
- [`fontpixel.formats.plan9`](#fontpixelformatsplan9) (3) Direct codec functions of `fontpixel::formats::plan9`.
- [`fontpixel.formats.playdate`](#fontpixelformatsplaydate) (3) Direct codec functions of `fontpixel::formats::playdate`.
- [`fontpixel.formats.plus3dos`](#fontpixelformatsplus3dos) (3) Direct codec functions of `fontpixel::formats::plus3dos`.
- [`fontpixel.formats.polyprint`](#fontpixelformatspolyprint) (3) Direct codec functions of `fontpixel::formats::polyprint`.
- [`fontpixel.formats.prebuilt`](#fontpixelformatsprebuilt) (3) Direct codec functions of `fontpixel::formats::prebuilt`.
- [`fontpixel.formats.printshop`](#fontpixelformatsprintshop) (3) Direct codec functions of `fontpixel::formats::printshop`.
- [`fontpixel.formats.psf`](#fontpixelformatspsf) (3) Direct codec functions of `fontpixel::formats::psf`.
- [`fontpixel.formats.psf2txt`](#fontpixelformatspsf2txt) (3) Direct codec functions of `fontpixel::formats::psf2txt`.
- [`fontpixel.formats.pxl`](#fontpixelformatspxl) (3) Direct codec functions of `fontpixel::formats::pxl`.
- [`fontpixel.formats.qpf`](#fontpixelformatsqpf) (3) Direct codec functions of `fontpixel::formats::qpf`.
- [`fontpixel.formats.qpf2`](#fontpixelformatsqpf2) (3) Direct codec functions of `fontpixel::formats::qpf2`.
- [`fontpixel.formats.raw`](#fontpixelformatsraw) (4) Direct codec functions of `fontpixel::formats::raw`.
- [`fontpixel.formats.riscos`](#fontpixelformatsriscos) (3) Direct codec functions of `fontpixel::formats::riscos`.
- [`fontpixel.formats.rockbox`](#fontpixelformatsrockbox) (3) Direct codec functions of `fontpixel::formats::rockbox`.
- [`fontpixel.formats.sbf`](#fontpixelformatssbf) (3) Direct codec functions of `fontpixel::formats::sbf`.
- [`fontpixel.formats.sfd`](#fontpixelformatssfd) (3) Direct codec functions of `fontpixel::formats::sfd`.
- [`fontpixel.formats.sfont`](#fontpixelformatssfont) (3) Direct codec functions of `fontpixel::formats::sfont`.
- [`fontpixel.formats.signum`](#fontpixelformatssignum) (3) Direct codec functions of `fontpixel::formats::signum`.
- [`fontpixel.formats.snf`](#fontpixelformatssnf) (3) Direct codec functions of `fontpixel::formats::snf`.
- [`fontpixel.formats.ssfn`](#fontpixelformatsssfn) (3) Direct codec functions of `fontpixel::formats::ssfn`.
- [`fontpixel.formats.svg`](#fontpixelformatssvg) (6) Direct codec functions of `fontpixel::formats::svg`.
- [`fontpixel.formats.symbos`](#fontpixelformatssymbos) (3) Direct codec functions of `fontpixel::formats::symbos`.
- [`fontpixel.formats.tasprint`](#fontpixelformatstasprint) (3) Direct codec functions of `fontpixel::formats::tasprint`.
- [`fontpixel.formats.u8m`](#fontpixelformatsu8m) (3) Direct codec functions of `fontpixel::formats::u8m`.
- [`fontpixel.formats.vector_raster`](#fontpixelformatsvector_raster) (6) Outline rasterization and vectorization (`fontpixel::formats::vector_raster`).
- [`fontpixel.formats.vfont`](#fontpixelformatsvfont) (3) Direct codec functions of `fontpixel::formats::vfont`.
- [`fontpixel.formats.vlw`](#fontpixelformatsvlw) (3) Direct codec functions of `fontpixel::formats::vlw`.
- [`fontpixel.formats.vtfont`](#fontpixelformatsvtfont) (3) Direct codec functions of `fontpixel::formats::vtfont`.
- [`fontpixel.formats.writeon`](#fontpixelformatswriteon) (3) Direct codec functions of `fontpixel::formats::writeon`.
- [`fontpixel.formats.wsfont`](#fontpixelformatswsfont) (3) Direct codec functions of `fontpixel::formats::wsfont`.
- [`fontpixel.formats.wyse`](#fontpixelformatswyse) (3) Direct codec functions of `fontpixel::formats::wyse`.
- [`fontpixel.formats.x11`](#fontpixelformatsx11) (2) X11 source-row helpers shared by BDF and PCF (`fontpixel::formats::x11`).
- [`fontpixel.formats.xbin`](#fontpixelformatsxbin) (3) Direct codec functions of `fontpixel::formats::xbin`.
- [`fontpixel.formats.xerox`](#fontpixelformatsxerox) (3) Direct codec functions of `fontpixel::formats::xerox`.
- [`fontpixel.formats.yaff`](#fontpixelformatsyaff) (3) Direct codec functions of `fontpixel::formats::yaff`.
- [`fontpixel.formats.zapfont`](#fontpixelformatszapfont) (3) Direct codec functions of `fontpixel::formats::zapfont`.
- [`fontpixel.merge`](#fontpixelmerge) (12) Merge selected glyphs from ordered font parts.
- [`fontpixel.ops`](#fontpixelops) (44) Every fontpixel command-line operation as an in-process call.
- [`fontpixel.outline`](#fontpixeloutline) (7) Deterministic bitmap contours in upward-facing font design coordinates.
- [`fontpixel.outline.path`](#fontpixeloutlinepath) (3) Line/quadratic/cubic edge rasterization.
- [`fontpixel.sfnt`](#fontpixelsfnt) (14) Bounded sfnt container, OpenType tables, collections, CFF and subsetting.
- [`fontpixel.sfnt.bitmap`](#fontpixelsfntbitmap) (12) Embedded bitmaps: EBDT/EBLC, bdat/bloc, CBDT/CBLC, EBSC and sbix.
- [`fontpixel.sfnt.cff`](#fontpixelsfntcff) (15) CFF1 reading, writing and subsetting.
- [`fontpixel.sfnt.cmap`](#fontpixelsfntcmap) (4) Character-to-glyph mapping table.
- [`fontpixel.sfnt.collection`](#fontpixelsfntcollection) (9) TrueType/OpenType collections (ttcf).
- [`fontpixel.sfnt.gasp`](#fontpixelsfntgasp) (2) Grid-fitting and scan-conversion table.
- [`fontpixel.sfnt.glyf`](#fontpixelsfntglyf) (8) TrueType glyf/loca tables.
- [`fontpixel.sfnt.gsub`](#fontpixelsfntgsub) (4) Glyph substitution table.
- [`fontpixel.sfnt.metrics`](#fontpixelsfntmetrics) (4) hhea/hmtx and vhea/vmtx tables.
- [`fontpixel.sfnt.name`](#fontpixelsfntname) (8) Naming table.
- [`fontpixel.sfnt.os2`](#fontpixelsfntos2) (9) OS/2 and Windows metrics table.
- [`fontpixel.sfnt.post`](#fontpixelsfntpost) (2) PostScript table.
- [`fontpixel.sfnt.subset`](#fontpixelsfntsubset) (2) Compact Unicode subsets with GSUB/composite closure.
- [`fontpixel.variants`](#fontpixelvariants) (29) Regional bitmap alternatives, deduplication and locl-enabled OpenType output.
- [`fontpixel.woff`](#fontpixelwoff) (1) Bounded standalone sfnt <-> WOFF1/WOFF2 containers.
- [`fontpixel.woff.woff1`](#fontpixelwoffwoff1) (2) WOFF 1.0 (zlib).
- [`fontpixel.woff.woff2`](#fontpixelwoffwoff2) (5) WOFF 2.0 (Brotli, glyf/loca/hmtx transforms, collections).

## fontpixel

fontpixel: bitmap font toolkit (Python bindings).

The complete native API lives in this package; ``fontpixel.compat.bdfparser``
provides a bdfparser-compatible layer on the same Rust core.

### `fontpixel.AmbiguousFormatError(FontpixelError)`

*exception* -- Several formats match; pass an explicit format.

### `fontpixel.BdfParseError(FontpixelError)`

*exception* -- Fatal BDF syntax error.

### `fontpixel.Bitmap(width: int = ..., height: int = ..., depth: Depth = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*class*

A Mono or Gray8 raster (`fontpixel::model::GlyphBitmap`). Always owned:
reading a glyph's bitmap returns a copy; assign it back to edit the glyph.

#### `fontpixel.Bitmap.as_bytes() -> bytes`

*method* -- A copy of the canonical storage (`Bitmap::as_bytes`).

#### `fontpixel.Bitmap.bbox() -> Bounds`

*method*

Tight ink rectangle in bottom-left coordinates, as a bounds dict
(`Bitmap::bbox`).

#### `fontpixel.Bitmap.bold(n: int = ...) -> Bitmap`

*method* -- Rightward emboldening by `n` pixels (`Bitmap::bold`).

#### `fontpixel.Bitmap.byte_pad(pixels: int) -> Bitmap`

*method* -- Pad the width up to a multiple of `pixels` (`Bitmap::byte_pad`).

#### `fontpixel.Bitmap.composite(source: BitmapLike, x: int = ..., y: int = ..., mode: CompositeMode | None = ...) -> None`

*method*

Combine `source` into this bitmap in place at `(x, y)` with `mode`
(`Bitmap::composite`).

#### `fontpixel.Bitmap.composite_region(source: BitmapLike, region: Bounds, x: int = ..., y: int = ..., mode: CompositeMode | None = ...) -> None`

*method*

Combine `region` (bounds dict, top-left offsets into `source`) of
`source` in place at `(x, y)` (`Bitmap::composite_region`).

#### `fontpixel.Bitmap.concat(other: BitmapLike, direction: Direction | None = ..., alignment: Alignment | None = ..., gap: int = ...) -> Bitmap`

*method*

Concatenate with `other` (`Bitmap::concat`). The later operand wins
where both have ink.

#### `fontpixel.Bitmap.concat_all(bitmaps: Iterable[BitmapLike], direction: Direction | None = ..., alignment: Alignment | None = ..., gaps: Sequence[int] | None = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*static method*

Concatenate several bitmaps in one allocation (`Bitmap::concat_all`).
`gaps` is empty or has one entry per boundary.

#### `fontpixel.Bitmap.copy() -> Bitmap`

*method* -- An independent copy.

#### `fontpixel.Bitmap.crop(width: int, height: int, x: int = ..., y: int = ...) -> Bitmap`

*method*

Crop or zero-extend to `width`×`height` at bottom-left offset `(x, y)`
(`Bitmap::crop`).

#### `fontpixel.Bitmap.crop_bounds(bounds: Bounds) -> Bitmap`

*method*

Crop to a bounds dict `{width, height, x, y}` (`Bitmap::crop_bounds`;
also `GlyphBitmap::crop`).

#### `fontpixel.Bitmap.depth: Depth`

*property* -- `"mono"` or `"gray8"`.

#### `fontpixel.Bitmap.enlarge(x: int, y: int | None = ...) -> Bitmap`

*method* -- Scale by integer factors (`Bitmap::enlarge`; `y` defaults to `x`).

#### `fontpixel.Bitmap.extend(left: int = ..., right: int = ..., top: int = ..., bottom: int = ...) -> Bitmap`

*method* -- Add blank margins (`Bitmap::extend`).

#### `fontpixel.Bitmap.flip_horizontal() -> Bitmap`

*method* -- Mirror left/right (`Bitmap::flip_horizontal`).

#### `fontpixel.Bitmap.flip_vertical() -> Bitmap`

*method* -- Mirror top/bottom (`Bitmap::flip_vertical`).

#### `fontpixel.Bitmap.from_bytes(width: int, height: int, data: Buffer | Sequence[int], layout: ByteLayout | None = ..., depth: Depth = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*static method*

From an exact-sized byte stream in `layout` (a `ByteLayout` dict:
`bit_order` "msb"/"lsb", `byte_order` "big"/"little", `row_alignment`,
`scan_unit`, `row_order` "top-down"/"bottom-up") (`Bitmap::from_bytes`).

#### `fontpixel.Bitmap.from_dict(data: GlyphBitmap) -> Bitmap`

*static method* -- From the plain-data form produced by `to_dict`.

#### `fontpixel.Bitmap.from_hex_rows(width: int, rows: Sequence[str], limits: BitmapLimits | None = ...) -> Bitmap`

*static method*

Parse strict BDF-style byte-padded hex rows into a Mono bitmap
(`Bitmap::<Mono>::from_hex_rows`).

#### `fontpixel.Bitmap.from_raw(width: int, height: int, data: Buffer | Sequence[int], depth: Depth = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*static method*

From canonical storage: top-down rows, Mono rows packed MSB-first and
padded to whole bytes, Gray8 one byte per pixel (`Bitmap::from_raw`).

#### `fontpixel.Bitmap.from_rows(rows: Sequence[Buffer | Sequence[int]], depth: Depth = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*static method* -- From a list of rows of pixel values, top row first (inverse of `to_rows`).

#### `fontpixel.Bitmap.from_text(text: str, palette: TextPalette | None = ..., depth: Depth = ..., limits: BitmapLimits | None = ...) -> Bitmap`

*static method*

Parse text rows through `palette` (dict `{char: value}` or pairs); the
Mono default accepts `#`/`1` as ink and `.`/`0` as paper. Blank leading
and trailing lines are ignored (`Bitmap::from_text`).

#### `fontpixel.Bitmap.get_pixel(x: int, y: int) -> int`

*method* -- Pixel value at `(x, y)` (`Bitmap::get_pixel`).

#### `fontpixel.Bitmap.glow(diagonals: bool, ink: int, value: int) -> Bitmap`

*method* -- One-pixel glow around pixels equal to `ink` (`Bitmap::glow`).

#### `fontpixel.Bitmap.has_ink() -> bool`

*method* -- Whether any pixel is nonzero (`Bitmap::has_ink`).

#### `fontpixel.Bitmap.height: int`

*property* -- Height in pixels.

#### `fontpixel.Bitmap.invert() -> None`

*method*

Binary inversion in place: zero becomes full ink, nonzero zero
(`Bitmap::invert`).

#### `fontpixel.Bitmap.invert_with(ink: int) -> None`

*method* -- Binary inversion in place with ink value `ink` (`Bitmap::invert_with`).

#### `fontpixel.Bitmap.italic(step: int, base: int = ...) -> Bitmap`

*method* -- Slant by `floor((row_from_bottom - base) / step)` (`Bitmap::italic`).

#### `fontpixel.Bitmap.limits: BitmapLimits`

*property* -- The bitmap's resource limits as a dict (`Bitmap::limits`).

#### `fontpixel.Bitmap.max_value: int`

*property* -- Largest pixel value: 1 for Mono, 255 for Gray8 (`PixelFormat::MAX`).

#### `fontpixel.Bitmap.negate() -> None`

*method* -- Continuous-tone inversion `255 - v` in place (`Bitmap::<Gray8>::negate`).

#### `fontpixel.Bitmap.overlay(source: BitmapLike) -> None`

*method* -- `paste(source, 0, 0)` (`Bitmap::overlay`).

#### `fontpixel.Bitmap.packed: bool`

*property* -- Whether rows are bit-packed (`PixelFormat::PACKED`).

#### `fontpixel.Bitmap.paste(source: BitmapLike, x: int = ..., y: int = ...) -> None`

*method* -- `composite(source, x, y, "over")` (`Bitmap::paste`).

#### `fontpixel.Bitmap.replace(old: int, new: int) -> None`

*method* -- Replace every pixel equal to `old` with `new`, in place (`Bitmap::replace`).

#### `fontpixel.Bitmap.replace_pattern(old: Buffer | Sequence[int], new: Buffer | Sequence[int]) -> Bitmap`

*method* -- Row-wise non-overlapping pattern replacement (`Bitmap::replace_pattern`).

#### `fontpixel.Bitmap.rotate(degrees: int) -> Bitmap`

*method* -- Rotate clockwise by a multiple of 90 degrees (`Bitmap::rotate`).

#### `fontpixel.Bitmap.set_limits(limits: BitmapLimits) -> None`

*method*

Replace the limits after checking the current size against them
(`Bitmap::set_limits`).

#### `fontpixel.Bitmap.set_pixel(x: int, y: int, value: int) -> None`

*method* -- Set the pixel at `(x, y)`; the value must fit the depth (`Bitmap::set_pixel`).

#### `fontpixel.Bitmap.shadow(dx: int, dy: int, value: int) -> Bitmap`

*method* -- Displaced silhouette behind the ink (`Bitmap::shadow`).

#### `fontpixel.Bitmap.shift(dx: int, dy: int) -> Bitmap`

*method* -- Move pixels right/up inside the same size, filling with 0 (`Bitmap::shift`).

#### `fontpixel.Bitmap.stride: int`

*property* -- Bytes per canonical row (`Bitmap::stride`).

#### `fontpixel.Bitmap.to_bytes(layout: ByteLayout | None = ...) -> bytes`

*method*

Serialize in an explicit `ByteLayout` (default: MSB-first, byte rows,
top-down) (`Bitmap::to_bytes`).

#### `fontpixel.Bitmap.to_dict() -> GlyphBitmap`

*method* -- Plain data: `{"mono" | "gray8": {"width", "height", "data": [...]}}`.

#### `fontpixel.Bitmap.to_gray8() -> Bitmap`

*method* -- Gray8 copy with paper 0 and ink 255 (`Bitmap::<Mono>::to_gray8`).

#### `fontpixel.Bitmap.to_gray8_palette(paper: int, ink: int) -> Bitmap`

*method*

Gray8 copy with explicit paper and ink values
(`Bitmap::<Mono>::to_gray8_palette`).

#### `fontpixel.Bitmap.to_hex_rows() -> list[str]`

*method* -- Byte-padded uppercase hex rows (BDF storage) (`Bitmap::<Mono>::to_hex_rows`).

#### `fontpixel.Bitmap.to_list() -> list[int]`

*method* -- Every pixel value in row-major order.

#### `fontpixel.Bitmap.to_mono(threshold: int) -> Bitmap`

*method* -- Mono copy: ink where the value is `>= threshold` (`Bitmap::<Gray8>::to_mono`).

#### `fontpixel.Bitmap.to_numeric_hex_rows() -> list[str]`

*method* -- Right-aligned lowercase hex rows (`Bitmap::<Mono>::to_numeric_hex_rows`).

#### `fontpixel.Bitmap.to_palette_bytes(palette: Mapping[int, Buffer] | Iterable[tuple[int, Buffer]]) -> bytes`

*method*

One fixed-size byte string per pixel, from `palette` (dict
`{value: bytes}` or pairs) (`Bitmap::to_palette_bytes`).

#### `fontpixel.Bitmap.to_row_values() -> list[int]`

*method*

Rows as integers, leftmost pixel most significant; width ≤ 64
(`Bitmap::<Mono>::to_row_values`).

#### `fontpixel.Bitmap.to_rows() -> list[list[int]]`

*method* -- Rows of pixel values, top row first.

#### `fontpixel.Bitmap.to_text(palette: OutputPalette | None = ...) -> str`

*method*

Text rows through `palette` (dict `{value: char}` or pairs; Mono
default `.`/`#`) (`Bitmap::to_text`).

#### `fontpixel.Bitmap.trim() -> Bitmap`

*method* -- Crop to the ink (`Bitmap::trim`).

#### `fontpixel.Bitmap.width: int`

*property* -- Width in pixels.

#### `fontpixel.Bitmap.with_limits(width: int, height: int, limits: BitmapLimits, depth: Depth = ...) -> Bitmap`

*static method* -- A blank raster under explicit limits (`Bitmap::with_limits`).

### `fontpixel.BitmapProjection(scalable_advance: ScalableAdvance | None = ..., font_name: str | None = ..., size: SizeProjection | None = ..., properties: Iterable[PropertyEdit] | None = ...) -> BitmapProjection`

*class*

Typed bitmap-projection options (`fontpixel::projection::BitmapProjection`
with owned `PropertyEdit`s). The default changes nothing.

- `scalable_advance`: `"preserve"` or
  `{"from_device": {"units_per_em": int, "reference_ppem": int}}`
- `font_name`: complete `FONT`/XLFD name
- `size`: `{"point_size": {"numerator", "denominator"}, "resolution": {"x", "y"}}`
- `properties`: edits `{"set": {"name", "value": int | str}}` or
  `{"remove": {"name"}}`, applied in order

#### `fontpixel.BitmapProjection.apply(font_set: FontSet, max_working_bytes: int | None = ...) -> ProjectionOutcome`

*method* -- Apply to every strike of `font_set` (`apply_bitmap_projection`).

#### `fontpixel.BitmapProjection.font_name: str | None`

*property* -- The projected font name.

#### `fontpixel.BitmapProjection.is_identity() -> bool`

*method* -- Whether these options change nothing (`BitmapProjection::is_identity`).

#### `fontpixel.BitmapProjection.properties: list[PropertyEdit]`

*property* -- The property edits, as dicts.

#### `fontpixel.BitmapProjection.property_names() -> list[str]`

*method* -- The edited property names in order (`PropertyEdit::name`).

#### `fontpixel.BitmapProjection.scalable_advance: ScalableAdvance`

*property* -- The scalable-advance policy (serde form).

#### `fontpixel.BitmapProjection.scalable_from_device(units_per_em: int, reference_ppem: int) -> BitmapProjection`

*static method*

Options deriving scalable advances from device advances
(`BitmapProjection::scalable_from_device`).

#### `fontpixel.BitmapProjection.size: SizeProjection | None`

*property* -- The projected size, as a dict.

### `fontpixel.CJK_RANGES: tuple[UnicodeRange, ...]`

*constant*

### `fontpixel.CancelledError(FontpixelError)`

*exception* -- A progress callback cancelled the operation (returned False); nothing was written.

### `fontpixel.CharsetCodec(name: str, gl: bool | None = ...) -> CharsetCodec`

*class* -- An exact charset mapping (`fontpixel::charset::CharsetCodec`).

#### `fontpixel.CharsetCodec.char2cp(value: str) -> int | None`

*method* -- Glyph code for a character, or `None` (`CharsetCodec::char2cp`).

#### `fontpixel.CharsetCodec.cp2char(code: int) -> str | None`

*method* -- Character for a glyph code, or `None` (`CharsetCodec::cp2char`).

#### `fontpixel.CharsetCodec.cp2unicode(code: int) -> int | None`

*method* -- Unicode value for a glyph code, or `None` (`CharsetCodec::cp2unicode`).

#### `fontpixel.CharsetCodec.for_font(font_or_charset: Font | FontCharset) -> CharsetCodec`

*static method*

The codec of a font's `charset` (`FontCharset::codec`); accepts a
`Font` or a `FontCharset` dict.

#### `fontpixel.CharsetCodec.from_key(key: str, gl: bool | None = ...) -> CharsetCodec`

*static method*

Resolve a canonical key or cleaned alias without re-sanitizing it
(`CharsetCodec::from_key`).

#### `fontpixel.CharsetCodec.gl: bool`

*property* -- Whether 94×94 GL codes are used (`CharsetCodec::gl`).

#### `fontpixel.CharsetCodec.kind: CharsetKind`

*property* -- Allowed code lengths (`CharsetCodec::kind`).

#### `fontpixel.CharsetCodec.known: bool`

*property* -- Whether the name resolved to a known table (`CharsetCodec::known`).

#### `fontpixel.CharsetCodec.name: str`

*property* -- Canonical key (`CharsetCodec::name`).

#### `fontpixel.CharsetCodec.unicode2cp(value: int) -> int | None`

*method* -- Glyph code for a Unicode value, or `None` (`CharsetCodec::unicode2cp`).

### `fontpixel.Codepoint(value: int, kind: CodepointKind = ...) -> Codepoint`

*class*

A tagged character code (`fontpixel::model::Codepoint`): either a Unicode
scalar value or a legacy code in the font's own charset.

Functions that take a codepoint also accept an `int` (Unicode), a
one-character `str` (Unicode) or the plain-data dict `{"Unicode": n}` /
`{"Legacy": n}`.

#### `fontpixel.Codepoint.from_dict(value: CodepointLike) -> Codepoint`

*static method* -- Build from the plain-data form (or any accepted codepoint value).

#### `fontpixel.Codepoint.is_unicode: bool`

*property* -- Whether this is a Unicode codepoint.

#### `fontpixel.Codepoint.kind: CodepointKind`

*property* -- `"unicode"` or `"legacy"`.

#### `fontpixel.Codepoint.legacy(value: int) -> Codepoint`

*static method* -- A legacy charset code (`Codepoint::Legacy`).

#### `fontpixel.Codepoint.scalar() -> str | None`

*method*

The character for a Unicode scalar value, or `None` for legacy codes
and surrogates (`Codepoint::scalar`).

#### `fontpixel.Codepoint.to_dict() -> CodepointDict`

*method* -- Plain-data form: `{"Unicode": n}` or `{"Legacy": n}`.

#### `fontpixel.Codepoint.unicode(value: int) -> Codepoint`

*static method* -- A Unicode codepoint (`Codepoint::Unicode`).

#### `fontpixel.Codepoint.value: int`

*property* -- The numeric value regardless of kind (`Codepoint::value`).

### `fontpixel.FeatureDisabledError(FontpixelError)`

*exception* -- Format compiled out of this build.

### `fontpixel.Font(glyphs: Iterable[GlyphLike] | None = ...) -> Font`

*class* -- One strike (`fontpixel::model::Font`), owned or a view into a `FontSet`.

#### `fontpixel.Font.add_glyph(glyph: GlyphLike) -> int`

*method*

Add a copy of `glyph` (a `Glyph` or glyph dict) after validating it;
returns its new ID (`Font::add_glyph`).

#### `fontpixel.Font.charset: FontCharset`

*property* -- Charset identification (`FontCharset`) as a dict copy; assignable.

#### `fontpixel.Font.charset_canonical_name() -> str`

*method* -- The canonical charset name of `charset` (`FontCharset::canonical_name`).

#### `fontpixel.Font.cloned_usage(max_bytes: int | None = ...) -> ModelUsage`

*method*

Storage a new owned copy would need, without copying
(`Font::cloned_usage`).

#### `fontpixel.Font.codepoint_range(start: CodepointLike, end: CodepointLike) -> list[tuple[Codepoint, int]]`

*method*

Effective mappings with `start <= codepoint <= end` (inclusive, in the
`Codepoint` order where every Unicode code precedes every legacy code;
empty when `start > end`) (`Font::codepoint_range`).

#### `fontpixel.Font.codepoints() -> list[tuple[Codepoint, int]]`

*method*

`(Codepoint, id)` pairs of every effective mapping, in codepoint order
(`Font::codepoints`).

#### `fontpixel.Font.copy() -> Font`

*method* -- An owned copy of this font.

#### `fontpixel.Font.draw(text: str, options: RenderOptions | None = ..., missing_glyph: GlyphLike | None = ...) -> Rendered`

*method*

Render Unicode `text` through the font's charset map
(`Font::draw`). Returns `Rendered`; raises `StrictLossError` (with
`report`) in strict mode and `ResourceLimitError` over budget.

#### `fontpixel.Font.draw_all(order: RenderGlyphOrder | None = ..., ranges: Sequence[tuple[int, int]] | None = ..., options: RenderOptions | None = ..., missing_glyph: GlyphLike | None = ...) -> Rendered`

*method*

Render every effective mapping in `order` (`"ascending"`,
`"descending"`, `"file"`, `"reverse_file"`), optionally restricted to
inclusive `(start, end)` ranges (`Font::draw_all`).

#### `fontpixel.Font.draw_codepoints(codes: Iterable[CodepointLike | None], options: RenderOptions | None = ..., missing_glyph: GlyphLike | None = ...) -> Rendered`

*method*

Render explicit codes; `None` entries stand for unencodable
characters (`Font::draw_codepoints`).

#### `fontpixel.Font.edit_glyph(id: int, func: Callable[[Glyph], object]) -> None`

*method*

Edit glyph `id` through `func(glyph)`, which receives an owned copy;
the edited copy replaces the glyph when `func` returns, and nothing
changes if it raises (`Font::edit_glyph`).

#### `fontpixel.Font.from_dict(data: FontDict) -> Font`

*static method*

Build from the plain-data form produced by `to_dict` (serde shape;
`glyphs` keeps `None` for removed slots so IDs survive).

#### `fontpixel.Font.glyph(id: int) -> Glyph | None`

*method* -- A live view of glyph `id`, or `None` (`Font::glyph`).

#### `fontpixel.Font.glyph_for_codepoint(codepoint: CodepointLike) -> Glyph | None`

*method*

The effective glyph for a codepoint, as a view, or `None`
(`Font::glyph_for_codepoint`).

#### `fontpixel.Font.glyph_for_sequence(sequence: Iterable[CodepointLike] | str) -> Glyph | None`

*method*

The effective glyph for a Unicode sequence (list of ints or a `str`),
as a view, or `None` (`Font::glyph_for_sequence`).

#### `fontpixel.Font.glyph_id(codepoint: CodepointLike) -> int | None`

*method* -- The effective glyph ID for a codepoint, or `None` (`Font::glyph_id`).

#### `fontpixel.Font.glyph_ids() -> list[int]`

*method* -- IDs of every live glyph in order.

#### `fontpixel.Font.glyph_ids_for_codepoint(codepoint: CodepointLike) -> list[int]`

*method*

Every glyph ID mapped to a codepoint, ascending; the last is effective
(`Font::glyph_ids_for_codepoint`).

#### `fontpixel.Font.glyph_in_cell(id: int) -> Bitmap`

*method*

Glyph `id` cropped or extended to the font's cell bounds
(`Font::glyph_in_cell`).

#### `fontpixel.Font.glyphs() -> list[tuple[int, Glyph]]`

*method* -- `(id, glyph view)` pairs for every live glyph in ID order (`Font::glyphs`).

#### `fontpixel.Font.headers: Properties`

*property* -- Format header records (live `Properties` view); assignable.

#### `fontpixel.Font.is_empty() -> bool`

*method* -- Whether the font has no live glyphs (`Font::is_empty`).

#### `fontpixel.Font.is_view: bool`

*property* -- Whether this handle is a view into a `FontSet` (otherwise it owns its font).

#### `fontpixel.Font.localized_names: Properties`

*property* -- Live view of `names["localized"]`.

#### `fontpixel.Font.metrics: FontMetrics`

*property* -- Font-wide metrics (`FontMetrics`) as a dict copy; assign a dict to replace.

#### `fontpixel.Font.names: FontNames`

*property* -- Font names (`FontNames`) as a dict copy; assign a dict to replace.

#### `fontpixel.Font.properties: Properties`

*property* -- Font properties (live `Properties` view); assignable.

#### `fontpixel.Font.remove_glyph(id: int) -> Glyph | None`

*method*

Remove glyph `id`; returns it as an owned handle, or `None` if it does
not exist. Its ID is never reused (`Font::remove_glyph`).

#### `fontpixel.Font.replace_glyph(id: int, glyph: GlyphLike) -> Glyph`

*method*

Replace glyph `id` with a copy of `glyph`, re-indexing its codes;
returns the old glyph as an owned handle (`Font::replace_glyph`).

#### `fontpixel.Font.retained_usage(max_bytes: int | None = ...) -> ModelUsage`

*method* -- Conservative retained storage of this strike (`Font::retained_usage`).

#### `fontpixel.Font.slot_count: int`

*property* -- Number of assigned glyph IDs, including removed slots (`Font::slot_count`).

#### `fontpixel.Font.source_format: str | None`

*property* -- The format ID this strike was read from, if any.

#### `fontpixel.Font.to_dict() -> FontDict`

*method* -- The complete plain-data form; copies every pixel.

#### `fontpixel.Font.update_bounds() -> None`

*method*

Set `metrics["bounds"]` to the union of all inked glyph boxes
(`Font::update_bounds`).

#### `fontpixel.Font.validate(limits: ResourceLimits | None = ...) -> None`

*method*

Validate glyphs, the default glyph and resource budgets
(`Font::validate`).

### `fontpixel.FontSet(fonts: Iterable[FontLike] | None = ..., properties: PropertiesLike | None = ..., source_format: str | None = ...) -> FontSet`

*class* -- A set of strikes (`fontpixel::model::FontSet`).

#### `fontpixel.FontSet.append(font: FontLike) -> int`

*method* -- Append a copy of `font`; returns its index.

#### `fontpixel.FontSet.copy() -> FontSet`

*method* -- An independent copy of the set.

#### `fontpixel.FontSet.fonts: list[Font]`

*property*

Live views of the strikes, in order. Assigning a list of fonts
replaces them (copies). Views address fonts by index.

#### `fontpixel.FontSet.from_dict(data: FontSetDict) -> FontSet`

*static method* -- Build from the plain-data form produced by `to_dict` (serde shape).

#### `fontpixel.FontSet.into_single() -> Font`

*method*

An owned copy of the only strike (`FontSet::into_single`; Python keeps
the set intact).

#### `fontpixel.FontSet.pop(index: int = ...) -> Font`

*method*

Remove and return strike `index` (default: the last) as an owned font.
Views of later strikes now address the following font.

#### `fontpixel.FontSet.properties: Properties`

*property* -- Set-level properties (live `Properties` view); assignable.

#### `fontpixel.FontSet.retained_usage(max_bytes: int | None = ...) -> ModelUsage`

*method*

Conservative retained storage of the set (`FontSet::retained_usage`):
`{"bytes", "fonts", "glyphs", "glyph_slots"}`. Raises
`ResourceLimitError` above `max_bytes` (default: unbounded).

#### `fontpixel.FontSet.single() -> Font`

*method*

A view of the only strike; `InvalidInputError` unless there is
exactly one (`FontSet::single`).

#### `fontpixel.FontSet.source_format: str | None`

*property* -- The format ID the set was read from, if any.

#### `fontpixel.FontSet.to_dict() -> FontSetDict`

*method*

The complete plain-data form (`{"fonts": [...], "properties": [...],
"source_format"?: str}`); copies every pixel.

#### `fontpixel.FontSet.validate(limits: ResourceLimits | None = ...) -> None`

*method*

Check glyph counts, pixel and byte budgets for every strike
(`FontSet::validate`); raises `ResourceLimitError`/`InvalidInputError`.

### `fontpixel.FontpixelError(Exception)`

*exception* -- Base class of all fontpixel errors.

### `fontpixel.FontpixelIoError(FontpixelError)`

*exception* -- Operating-system or caller resource I/O error.

### `fontpixel.GEOMETRIC_RANGES: tuple[UnicodeRange, ...]`

*constant*

### `fontpixel.Glyph(bitmap: BitmapLike | None = ..., codepoints: Iterable[CodepointLike] | None = ..., name: str | None = ...) -> Glyph`

*class* -- One glyph (`fontpixel::model::Glyph`), owned or a view into a font.

#### `fontpixel.Glyph.bitmap: Bitmap`

*property*

A copy of the bitmap. Assigning a `Bitmap` replaces the pixels and
resizes `metrics["bounds"]`, keeping its offset.

#### `fontpixel.Glyph.bitmap_in_cell(cell: Bounds) -> Bitmap`

*method*

The glyph cropped or extended to `cell` (a bounds dict), in cell
coordinates (`Glyph::bitmap_in_cell`).

#### `fontpixel.Glyph.codepoints: list[Codepoint]`

*property*

Encoded codepoints (list of `Codepoint`); assignable from any
accepted codepoint values. Edits of a view re-index the font.

#### `fontpixel.Glyph.copy() -> Glyph`

*method* -- An owned copy.

#### `fontpixel.Glyph.from_dict(data: GlyphDict) -> Glyph`

*static method* -- Build from the plain-data form produced by `to_dict` (serde shape).

#### `fontpixel.Glyph.id: int | None`

*property* -- The glyph ID of a view, or `None` for an owned glyph.

#### `fontpixel.Glyph.is_view: bool`

*property* -- Whether this handle is a view into a font.

#### `fontpixel.Glyph.metrics: GlyphMetrics`

*property*

Glyph metrics (`GlyphMetrics`) as a dict copy; assign to replace
(validated: bounds must match the bitmap).

#### `fontpixel.Glyph.name: str | None`

*property* -- The glyph name, if any.

#### `fontpixel.Glyph.properties: Properties`

*property* -- Glyph properties (live `Properties` view); assignable.

#### `fontpixel.Glyph.set_bitmap(bitmap: BitmapLike, x: int = ..., y: int = ..., trim: bool = ...) -> None`

*method*

Replace the bitmap and its bounds, placing its bottom-left corner at
`(x, y)`; with `trim`, crop to the ink first (`Glyph::set_bitmap`).

#### `fontpixel.Glyph.shift(dx: int, dy: int) -> None`

*method* -- Move the glyph box by `(dx, dy)` with overflow checks (`Glyph::shift`).

#### `fontpixel.Glyph.to_dict() -> GlyphDict`

*method* -- The complete plain-data form; copies the pixels.

#### `fontpixel.Glyph.unicode_sequences: list[list[int]]`

*property* -- Unicode sequences (ligatures/clusters) mapped to this glyph.

#### `fontpixel.Glyph.validate() -> None`

*method* -- Check bounds/bitmap agreement and Unicode sequences (`Glyph::validate`).

### `fontpixel.Input(data: Buffer | Sequence[int], name: str | None = ..., resources: Resources | None = ...) -> Input`

*class*

Primary bytes, a filename hint and a sidecar resolver
(`fontpixel::resources::Input`). Immutable: `with_name` and
`with_resources` return new inputs.

#### `fontpixel.Input.data: bytes`

*property* -- A copy of the primary bytes.

#### `fontpixel.Input.directory(name: str, resources: Resources) -> Input`

*static method*

A directory entry point without primary bytes; `resources` is rooted
at the directory (`Input::directory`).

#### `fontpixel.Input.is_directory: bool`

*property* -- Whether this is a directory entry point.

#### `fontpixel.Input.name: str | None`

*property* -- The filename hint.

#### `fontpixel.Input.with_name(name: str) -> Input`

*method* -- A copy with a filename hint (`Input::with_name`).

#### `fontpixel.Input.with_resources(resources: Resources) -> Input`

*method* -- A copy with sidecar resources (`Input::with_resources`).

### `fontpixel.InvalidInputError(FontpixelError)`

*exception* -- Invalid options, registration, paths or data.

### `fontpixel.Loaded()`

*class*

A decoded model with its read report and the format actually used
(`fontpixel::formats::Loaded`).

#### `fontpixel.Loaded.fonts: FontSet | Font`

*property* -- `FontSet` handle (or `Font` handle after `into_single`).

#### `fontpixel.Loaded.format: str`

*property* -- Format ID used to decode the input.

#### `fontpixel.Loaded.into_single() -> Loaded`

*method*

The sole strike as a `Loaded` whose `fonts` is a `Font` handle
(`Loaded::into_single`). Raises `InvalidInputError` for several strikes.

#### `fontpixel.Loaded.report: Report`

*property* -- The read report as a dict (`{"entries": [...]}`).

### `fontpixel.MAX_FONT_NAME_BYTES: int`

*constant*

### `fontpixel.MAX_PROPERTY_EDITS: int`

*constant*

### `fontpixel.MAX_PROPERTY_NAME_BYTES: int`

*constant*

### `fontpixel.MAX_PROPERTY_TEXT_BYTES: int`

*constant*

### `fontpixel.MissingResourceError(FontpixelError)`

*exception* -- A referenced sidecar was not supplied.

### `fontpixel.MultipleAssetsError(FontpixelError)`

*exception* -- Several output assets where one was expected.

### `fontpixel.NotImplementedFormatError(FontpixelError)`

*exception* -- Capability not implemented for this format.

### `fontpixel.OutputAsset(path: str, data: Buffer | Sequence[int]) -> OutputAsset`

*class* -- One in-memory output file (`fontpixel::resources::OutputAsset`).

#### `fontpixel.OutputAsset.data: bytes`

*property* -- A copy of the bytes.

#### `fontpixel.OutputAsset.path: str`

*property* -- Validated relative path.

### `fontpixel.OutputBundle(primary: str, assets: Iterable[OutputAsset | OutputAssetDict], directory: bool = ...) -> OutputBundle`

*class*

In-memory output files with a primary asset
(`fontpixel::resources::OutputBundle`).

#### `fontpixel.OutputBundle.assets: list[OutputAsset]`

*property* -- Copies of every asset in order (`OutputBundle::assets`).

#### `fontpixel.OutputBundle.from_dict(data: OutputBundleDict) -> OutputBundle`

*static method*

From the plain-data form (`{"primary", "assets": [{"path", "bytes"}],
"directory"}`), validated like the constructors.

#### `fontpixel.OutputBundle.into_assets() -> list[OutputAsset]`

*method* -- The assets as a list (`OutputBundle::into_assets`; the bundle stays usable).

#### `fontpixel.OutputBundle.into_single() -> bytes`

*method*

The only file's bytes; `MultipleAssetsError` for several
(`OutputBundle::into_single`).

#### `fontpixel.OutputBundle.is_directory: bool`

*property* -- Whether the primary path names a directory (`OutputBundle::is_directory`).

#### `fontpixel.OutputBundle.primary: str`

*property* -- The primary path (`OutputBundle::primary`).

#### `fontpixel.OutputBundle.retained_bytes(max_bytes: int | None = ...) -> int`

*method*

Retained bytes of the bundle, checked against `max_bytes`
(`OutputBundle::retained_bytes`).

#### `fontpixel.OutputBundle.single(path: str, data: Buffer | Sequence[int]) -> OutputBundle`

*static method* -- A one-file bundle (`OutputBundle::single`).

#### `fontpixel.OutputBundle.to_dict() -> OutputBundleDict`

*method* -- Plain-data form (`bytes` as int lists, the serde shape).

### `fontpixel.Properties(items: PropertiesLike | None = ...) -> Properties`

*class*

An ordered list of named properties (`fontpixel::model::Properties`).

Obtained from `FontSet.properties`, `Font.properties`, `Font.headers`,
`Font.localized_names` or `Glyph.properties`, it is a live view: `set`,
`push` and `remove` edit the owning model in place. `Properties(items)`
builds a standalone list; `copy()` detaches a view.

Values are given as Python values (`int` → Integer, or Unsigned above
the `i64` range; `str` → Text; `bytes` → Bytes; `list` → List;
`None` → Flag) or as the tagged plain-data form (`{"Decimal": "1.5"}`).
Values are returned in the tagged form, which keeps every variant.

#### `fontpixel.Properties.copy() -> Properties`

*method* -- A standalone copy.

#### `fontpixel.Properties.get(name: str) -> PropertyValue | None`

*method*

The value of the last property named exactly `name`, in tagged form,
or `None` (`Properties::get`).

#### `fontpixel.Properties.get_case_insensitive(name: str) -> PropertyValue | None`

*method*

Like `get`, comparing names ASCII-case-insensitively
(`Properties::get_case_insensitive`).

#### `fontpixel.Properties.is_empty() -> bool`

*method* -- Whether the list is empty (`Properties::is_empty`).

#### `fontpixel.Properties.push(name: str, value: PropertyValueLike, raw: Buffer | Sequence[int] | None = ...) -> None`

*method*

Append a property, keeping duplicates (`Properties::push` with
`Property::new`; `raw` is the optional source spelling).

#### `fontpixel.Properties.remove(name: str) -> int`

*method*

Remove every property whose name matches case-insensitively; returns
the number removed (`Properties::remove`).

#### `fontpixel.Properties.set(name: str, value: PropertyValueLike) -> None`

*method*

Replace the last property whose name matches case-insensitively, or
append a new one (`Properties::set`).

#### `fontpixel.Properties.to_list() -> list[Property]`

*method* -- A list of property dicts (`Properties::iter` / `into_vec`).

### `fontpixel.RGBA_BLACK: Rgba`

*constant*

### `fontpixel.RGBA_TRANSPARENT: Rgba`

*constant*

### `fontpixel.RGBA_WHITE: Rgba`

*constant*

### `fontpixel.ReadContext(input: Input | Buffer, limits: ResourceLimits | None = ...) -> ReadContext`

*class*

Shared resource accounting for one input (`fontpixel::resources::ReadContext`).

Construction validates the primary input against `limits` and decodes a
gzip transport envelope. Each `resource*`/`list_resources_limited` call
counts against `max_resources` and the aggregate byte budget, exactly as
codecs see it. The context lives on a private worker thread (it borrows
its input); calls block until the worker answers, with the GIL released.

#### `fontpixel.ReadContext.bytes() -> bytes`

*method* -- Primary bytes after transport decoding (`ReadContext::bytes`).

#### `fontpixel.ReadContext.is_directory: bool`

*property* -- Whether the input is a directory entry point (`ReadContext::is_directory`).

#### `fontpixel.ReadContext.limits: ResourceLimits`

*property* -- The budgets in force (`ReadContext::limits`).

#### `fontpixel.ReadContext.list_resources_limited(directory: str | None, max_entries: int, max_bytes: int) -> list[str]`

*method*

List immediate files of `directory` with shared accounting
(`ReadContext::list_resources_limited`).

#### `fontpixel.ReadContext.name: str | None`

*property* -- The filename hint (`ReadContext::name`).

#### `fontpixel.ReadContext.resource(path: str) -> bytes`

*method* -- Resolve a sidecar under the remaining budget (`ReadContext::resource`).

#### `fontpixel.ReadContext.resource_limited(path: str, max_bytes: int) -> bytes`

*method* -- Resolve with an extra byte allowance (`ReadContext::resource_limited`).

#### `fontpixel.ReadContext.retained_input_bytes() -> int`

*method*

Bytes retained so far, including resolved resources
(`ReadContext::retained_input_bytes`).

### `fontpixel.Registry(builtin: bool = ...) -> Registry`

*class* -- The format registry (`fontpixel::Registry<FontSet>`).

#### `fontpixel.Registry.detect(data: ReadInput | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> Detected`

*method*

Detect the format of an input: content detectors first, the filename
hint only when no detector matches. Returns
`{"format": FormatInfo, "confidence": "certain"|"possible"|"extension"}`.
`directory` names a directory entry point (an error: directory inputs
need an explicit format).

#### `fontpixel.Registry.ensure_writable(format: str) -> None`

*method* -- Raise `NotImplementedFormatError` unless `format` has a writer.

#### `fontpixel.Registry.extension_candidates(name: str) -> list[FormatInfo]`

*method*

Formats whose extension is the longest matching suffix of `name`
(`FormatInfo` dicts; ties are all returned).

#### `fontpixel.Registry.format_from_name(name: str) -> FormatInfo`

*method*

The unique `FormatInfo` for a filename; raises `UnrecognizedFormatError`
or `AmbiguousFormatError` (with `candidates`).

#### `fontpixel.Registry.formats() -> list[FormatStatus]`

*method*

Every catalogue format with its capabilities, as `FormatStatus` dicts
(`{"format": {"id", "name", "extensions", "feature_enabled"}, "detect",
"read", "write"}`).

#### `fontpixel.Registry.read(data: ReadInput | None = ..., format: str | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> Loaded`

*method*

Decode an input (`Registry::read`). `format` bypasses detection;
`limits` is a `ResourceLimits` dict; `resources` supplies sidecars;
`directory="name"` reads a native directory entry point whose files come
from `resources` (an explicit format is then required).

#### `fontpixel.Registry.register(format: str | NewFormat, *, detector: Callable[[ReadContext], Confidence] | None = ..., reader: Callable[[ReadContext, FormatsReadOptions], tuple[FontSet, Report]] | None = ..., writer: PythonWriter | None = ...) -> None`

*method*

Register a format implemented in Python (`Registry::register` with a
`Registration`). `format` is a catalogue ID or
`{"id", "name", "extensions"}` for a new ID (lowercase ASCII letters,
digits and hyphens). Without hooks this is an honest planned entry
(`Registration::planned`). A live entry cannot be replaced: use
`Registry(builtin=False)` to register a catalogue ID.

#### `fontpixel.Registry.set_amiga_read_options(options: AmigaReadOptions) -> None`

*method* -- `Registry::set_amiga_read_options`: apply a `f::amiga::AmigaReadOptions` dict.

#### `fontpixel.Registry.set_amiga_write_options(options: AmigaWriteOptions) -> None`

*method* -- `Registry::set_amiga_write_options`: apply a `f::amiga::AmigaWriteOptions` dict.

#### `fontpixel.Registry.set_bbc_read_options(options: NativeReadOptions) -> None`

*method* -- `Registry::set_bbc_read_options`: apply a `f::bbc::BbcReadOptions` dict.

#### `fontpixel.Registry.set_bbc_write_options(options: W5a2CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_bbc_write_options`: apply a `f::bbc::BbcWriteOptions` dict.

#### `fontpixel.Registry.set_bdf_write_options(options: BdfWriteOptions) -> None`

*method*

`Registry::set_bdf_write_options`: apply a `f::bdf::BdfWriteOptions` dict; invalid combinations raise.

#### `fontpixel.Registry.set_beos_read_options(options: BeosReadOptions) -> None`

*method* -- `Registry::set_beos_read_options`: apply a `f::beos::BeosReadOptions` dict.

#### `fontpixel.Registry.set_beos_write_options(options: BeosWriteOptions) -> None`

*method* -- `Registry::set_beos_write_options`: apply a `f::beos::BeosWriteOptions` dict.

#### `fontpixel.Registry.set_bmfont_read_options(options: BmfontReadOptions) -> None`

*method* -- `Registry::set_bmfont_read_options`: apply a `f::bmfont::BmfontReadOptions` dict.

#### `fontpixel.Registry.set_bmfont_write_options(options: BmfontWriteOptions) -> None`

*method* -- `Registry::set_bmfont_write_options`: apply a `f::bmfont::BmfontWriteOptions` dict.

#### `fontpixel.Registry.set_c_read_options(options: CReadOptions) -> None`

*method* -- `Registry::set_c_read_options`: apply a `f::c::CReadOptions` dict.

#### `fontpixel.Registry.set_c_write_options(options: CWriteOptions) -> None`

*method* -- `Registry::set_c_write_options`: apply a `f::c::CWriteOptions` dict.

#### `fontpixel.Registry.set_catalyst_read_options(options: CatalystReadOptions) -> None`

*method* -- `Registry::set_catalyst_read_options`: apply a `f::catalyst::CatalystReadOptions` dict.

#### `fontpixel.Registry.set_catalyst_write_options(options: CatalystWriteOptions) -> None`

*method* -- `Registry::set_catalyst_write_options`: apply a `f::catalyst::CatalystWriteOptions` dict.

#### `fontpixel.Registry.set_chiwriter_read_options(options: ChiwriterReadOptions) -> None`

*method* -- `Registry::set_chiwriter_read_options`: apply a `f::chiwriter::ChiwriterReadOptions` dict.

#### `fontpixel.Registry.set_chiwriter_write_options(options: ChiwriterWriteOptions) -> None`

*method* -- `Registry::set_chiwriter_write_options`: apply a `f::chiwriter::ChiwriterWriteOptions` dict.

#### `fontpixel.Registry.set_codec(format: str, codec: Mapping[str, Any]) -> None`

*method*

Install a codec from its dict form (`{"read_options": …,
"write_options": …}`, the format's `*Codec` struct); missing sides use
their defaults.

#### `fontpixel.Registry.set_color_write_options(options: ColorWriteOptions) -> None`

*method* -- `Registry::set_color_write_options`: apply a `f::embedded::ColorWriteOptions` dict.

#### `fontpixel.Registry.set_comfont_read_options(options: ComfontReadOptions) -> None`

*method* -- `Registry::set_comfont_read_options`: apply a `f::comfont::ComfontReadOptions` dict.

#### `fontpixel.Registry.set_comfont_write_options(options: ComfontWriteOptions) -> None`

*method* -- `Registry::set_comfont_write_options`: apply a `f::comfont::ComfontWriteOptions` dict.

#### `fontpixel.Registry.set_consoleet_read_options(options: ConsoleetReadOptions) -> None`

*method* -- `Registry::set_consoleet_read_options`: apply a `f::consoleet::ConsoleetReadOptions` dict.

#### `fontpixel.Registry.set_consoleet_write_options(options: ConsoleetWriteOptions) -> None`

*method* -- `Registry::set_consoleet_write_options`: apply a `f::consoleet::ConsoleetWriteOptions` dict.

#### `fontpixel.Registry.set_cpi_read_options(options: CpiReadOptions) -> None`

*method* -- `Registry::set_cpi_read_options`: apply a `f::cpi::CpiReadOptions` dict.

#### `fontpixel.Registry.set_cpi_write_options(options: CpiWriteOptions) -> None`

*method* -- `Registry::set_cpi_write_options`: apply a `f::cpi::CpiWriteOptions` dict.

#### `fontpixel.Registry.set_cybiko_read_options(options: CybikoReadOptions) -> None`

*method* -- `Registry::set_cybiko_read_options`: apply a `f::cybiko::CybikoReadOptions` dict.

#### `fontpixel.Registry.set_cybiko_write_options(options: CybikoWriteOptions) -> None`

*method* -- `Registry::set_cybiko_write_options`: apply a `f::cybiko::CybikoWriteOptions` dict.

#### `fontpixel.Registry.set_daisy_read_options(options: DaisyReadOptions) -> None`

*method* -- `Registry::set_daisy_read_options`: apply a `f::daisy::DaisyReadOptions` dict.

#### `fontpixel.Registry.set_daisy_write_options(options: DaisyWriteOptions) -> None`

*method* -- `Registry::set_daisy_write_options`: apply a `f::daisy::DaisyWriteOptions` dict.

#### `fontpixel.Registry.set_dashen_read_options(options: DashenReadOptions) -> None`

*method* -- `Registry::set_dashen_read_options`: apply a `f::dashen::DashenReadOptions` dict.

#### `fontpixel.Registry.set_dashen_write_options(options: DashenWriteOptions) -> None`

*method* -- `Registry::set_dashen_write_options`: apply a `f::dashen::DashenWriteOptions` dict.

#### `fontpixel.Registry.set_dosstart_read_options(options: DosstartReadOptions) -> None`

*method* -- `Registry::set_dosstart_read_options`: apply a `f::dosstart::DosstartReadOptions` dict.

#### `fontpixel.Registry.set_dosstart_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_dosstart_write_options`: apply a `f::dosstart::DosstartWriteOptions` dict.

#### `fontpixel.Registry.set_draw_write_options(options: DrawWriteOptions) -> None`

*method* -- `Registry::set_draw_write_options`: apply a `f::draw::DrawWriteOptions` dict.

#### `fontpixel.Registry.set_drcs_read_options(options: DrcsReadOptions) -> None`

*method* -- `Registry::set_drcs_read_options`: apply a `f::drcs::DrcsReadOptions` dict.

#### `fontpixel.Registry.set_drcs_write_options(options: DrcsWriteOptions) -> None`

*method* -- `Registry::set_drcs_write_options`: apply a `f::drcs::DrcsWriteOptions` dict.

#### `fontpixel.Registry.set_drhalo_read_options(options: DrhaloReadOptions) -> None`

*method* -- `Registry::set_drhalo_read_options`: apply a `f::drhalo::DrhaloReadOptions` dict.

#### `fontpixel.Registry.set_drhalo_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_drhalo_write_options`: apply a `f::drhalo::DrhaloWriteOptions` dict.

#### `fontpixel.Registry.set_edwin_read_options(options: EdwinReadOptions) -> None`

*method* -- `Registry::set_edwin_read_options`: apply a `f::edwin::EdwinReadOptions` dict.

#### `fontpixel.Registry.set_edwin_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_edwin_write_options`: apply a `f::edwin::EdwinWriteOptions` dict.

#### `fontpixel.Registry.set_embedded_write_options(options: EmbeddedWriteOptions) -> None`

*method* -- `Registry::set_embedded_write_options`: apply a `f::embedded::EmbeddedWriteOptions` dict.

#### `fontpixel.Registry.set_fbit_read_options(options: FbitReadOptions) -> None`

*method* -- `Registry::set_fbit_read_options`: apply a `f::fbit::FbitReadOptions` dict.

#### `fontpixel.Registry.set_fbit_write_options(options: FbitWriteOptions) -> None`

*method* -- `Registry::set_fbit_write_options`: apply a `f::fbit::FbitWriteOptions` dict.

#### `fontpixel.Registry.set_figlet_read_options(options: FigletReadOptions) -> None`

*method* -- `Registry::set_figlet_read_options`: apply a `f::figlet::FigletReadOptions` dict.

#### `fontpixel.Registry.set_figlet_write_options(options: FigletWriteOptions) -> None`

*method* -- `Registry::set_figlet_write_options`: apply a `f::figlet::FigletWriteOptions` dict.

#### `fontpixel.Registry.set_fnt_read_options(options: FntReadOptions) -> None`

*method* -- `Registry::set_fnt_read_options`: apply a `f::fnt::FntReadOptions` dict.

#### `fontpixel.Registry.set_fnt_write_options(options: FntWriteOptions) -> None`

*method* -- `Registry::set_fnt_write_options`: apply a `f::fnt::FntWriteOptions` dict.

#### `fontpixel.Registry.set_fontx2_read_options(options: Fontx2ReadOptions) -> None`

*method* -- `Registry::set_fontx2_read_options`: apply a `f::fontx2::Fontx2ReadOptions` dict.

#### `fontpixel.Registry.set_fontx2_write_options(options: Fontx2WriteOptions) -> None`

*method* -- `Registry::set_fontx2_write_options`: apply a `f::fontx2::Fontx2WriteOptions` dict.

#### `fontpixel.Registry.set_fzx_read_options(options: FzxReadOptions) -> None`

*method* -- `Registry::set_fzx_read_options`: apply a `f::fzx::FzxReadOptions` dict.

#### `fontpixel.Registry.set_fzx_write_options(options: FzxWriteOptions) -> None`

*method* -- `Registry::set_fzx_write_options`: apply a `f::fzx::FzxWriteOptions` dict.

#### `fontpixel.Registry.set_gdr_read_options(options: GdrReadOptions) -> None`

*method* -- `Registry::set_gdr_read_options`: apply a `f::gdr::GdrReadOptions` dict.

#### `fontpixel.Registry.set_gdr_write_options(options: GdrWriteOptions) -> None`

*method* -- `Registry::set_gdr_write_options`: apply a `f::gdr::GdrWriteOptions` dict.

#### `fontpixel.Registry.set_gem_read_options(options: GemReadOptions) -> None`

*method* -- `Registry::set_gem_read_options`: apply a `f::gem::GemReadOptions` dict.

#### `fontpixel.Registry.set_gem_write_options(options: GemWriteOptions) -> None`

*method* -- `Registry::set_gem_write_options`: apply a `f::gem::GemWriteOptions` dict.

#### `fontpixel.Registry.set_geos_read_options(options: GeosReadOptions) -> None`

*method* -- `Registry::set_geos_read_options`: apply a `f::geos::GeosReadOptions` dict.

#### `fontpixel.Registry.set_geos_write_options(options: GeosWriteOptions) -> None`

*method* -- `Registry::set_geos_write_options`: apply a `f::geos::GeosWriteOptions` dict.

#### `fontpixel.Registry.set_gf_write_options(options: TexWriteOptions) -> None`

*method* -- `Registry::set_gf_write_options`: apply a `f::gf::GfWriteOptions` dict.

#### `fontpixel.Registry.set_gpi_read_options(options: GpiReadOptions) -> None`

*method* -- `Registry::set_gpi_read_options`: apply a `f::gpi::GpiReadOptions` dict.

#### `fontpixel.Registry.set_gpi_write_options(options: GpiWriteOptions) -> None`

*method* -- `Registry::set_gpi_write_options`: apply a `f::gpi::GpiWriteOptions` dict.

#### `fontpixel.Registry.set_grasp_read_options(options: NativeReadOptions) -> None`

*method* -- `Registry::set_grasp_read_options`: apply a `f::grasp::GraspReadOptions` dict.

#### `fontpixel.Registry.set_grasp_write_options(options: W5a2CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_grasp_write_options`: apply a `f::grasp::GraspWriteOptions` dict.

#### `fontpixel.Registry.set_hanfont_read_options(options: HanfontReadOptions) -> None`

*method* -- `Registry::set_hanfont_read_options`: apply a `f::hanfont::HanfontReadOptions` dict.

#### `fontpixel.Registry.set_hanfont_write_options(options: HanfontWriteOptions) -> None`

*method* -- `Registry::set_hanfont_write_options`: apply a `f::hanfont::HanfontWriteOptions` dict.

#### `fontpixel.Registry.set_hbf_write_options(options: HbfWriteOptions) -> None`

*method* -- `Registry::set_hbf_write_options`: apply a `f::hbf::HbfWriteOptions` dict.

#### `fontpixel.Registry.set_hex_read_options(options: HexReadOptions) -> None`

*method* -- `Registry::set_hex_read_options`: apply a `f::hex::HexReadOptions` dict.

#### `fontpixel.Registry.set_hex_write_options(options: HexWriteOptions) -> None`

*method* -- `Registry::set_hex_write_options`: apply a `f::hex::HexWriteOptions` dict.

#### `fontpixel.Registry.set_hmzk_read_options(options: HmzkReadOptions) -> None`

*method* -- `Registry::set_hmzk_read_options`: apply a `f::hmzk::HmzkReadOptions` dict.

#### `fontpixel.Registry.set_hmzk_write_options(options: HmzkWriteOptions) -> None`

*method* -- `Registry::set_hmzk_write_options`: apply a `f::hmzk::HmzkWriteOptions` dict.

#### `fontpixel.Registry.set_hppcl_read_options(options: HppclReadOptions) -> None`

*method* -- `Registry::set_hppcl_read_options`: apply a `f::hppcl::HppclReadOptions` dict.

#### `fontpixel.Registry.set_hppcl_write_options(options: HppclWriteOptions) -> None`

*method* -- `Registry::set_hppcl_write_options`: apply a `f::hppcl::HppclWriteOptions` dict.

#### `fontpixel.Registry.set_hrcg_read_options(options: NativeReadOptions) -> None`

*method* -- `Registry::set_hrcg_read_options`: apply a `f::hrcg::HrcgReadOptions` dict.

#### `fontpixel.Registry.set_hrcg_write_options(options: W5a2CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_hrcg_write_options`: apply a `f::hrcg::HrcgWriteOptions` dict.

#### `fontpixel.Registry.set_hzk_read_options(options: HzkReadOptions) -> None`

*method* -- `Registry::set_hzk_read_options`: apply a `f::hzk::HzkReadOptions` dict.

#### `fontpixel.Registry.set_hzk_write_options(options: HzkWriteOptions) -> None`

*method* -- `Registry::set_hzk_write_options`: apply a `f::hzk::HzkWriteOptions` dict.

#### `fontpixel.Registry.set_iigs_read_options(options: IigsReadOptions) -> None`

*method* -- `Registry::set_iigs_read_options`: apply a `f::iigs::IigsReadOptions` dict.

#### `fontpixel.Registry.set_iigs_write_options(options: IigsWriteOptions) -> None`

*method* -- `Registry::set_iigs_write_options`: apply a `f::iigs::IigsWriteOptions` dict.

#### `fontpixel.Registry.set_image_read_options(options: ImageReadOptions) -> None`

*method* -- `Registry::set_image_read_options`: apply a `f::image::ImageReadOptions` dict.

#### `fontpixel.Registry.set_image_write_options(options: ImageWriteOptions) -> None`

*method* -- `Registry::set_image_write_options`: apply a `f::image::ImageWriteOptions` dict.

#### `fontpixel.Registry.set_kbits_write_options(options: KbitsWriteOptions) -> None`

*method* -- `Registry::set_kbits_write_options`: apply a `f::kbits::KbitsWriteOptions` dict.

#### `fontpixel.Registry.set_kbitx_read_options(options: KbitxReadOptions) -> None`

*method* -- `Registry::set_kbitx_read_options`: apply a `f::kbitx::KbitxReadOptions` dict.

#### `fontpixel.Registry.set_kbitx_write_options(options: KbitxWriteOptions) -> None`

*method* -- `Registry::set_kbitx_write_options`: apply a `f::kbitx::KbitxWriteOptions` dict.

#### `fontpixel.Registry.set_lisa_read_options(options: LisaReadOptions) -> None`

*method* -- `Registry::set_lisa_read_options`: apply a `f::lisa::LisaReadOptions` dict.

#### `fontpixel.Registry.set_lisa_write_options(options: LisaWriteOptions) -> None`

*method* -- `Registry::set_lisa_write_options`: apply a `f::lisa::LisaWriteOptions` dict.

#### `fontpixel.Registry.set_mgtk_read_options(options: MgtkReadOptions) -> None`

*method* -- `Registry::set_mgtk_read_options`: apply a `f::mgtk::MgtkReadOptions` dict.

#### `fontpixel.Registry.set_mgtk_write_options(options: MgtkWriteOptions) -> None`

*method* -- `Registry::set_mgtk_write_options`: apply a `f::mgtk::MgtkWriteOptions` dict.

#### `fontpixel.Registry.set_mkwinfont_read_options(options: MkwinfontReadOptions) -> None`

*method* -- `Registry::set_mkwinfont_read_options`: apply a `f::mkwinfont::MkwinfontReadOptions` dict.

#### `fontpixel.Registry.set_mkwinfont_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_mkwinfont_write_options`: apply a `f::mkwinfont::MkwinfontWriteOptions` dict.

#### `fontpixel.Registry.set_nfnt_read_options(options: NfntReadOptions) -> None`

*method* -- `Registry::set_nfnt_read_options`: apply a `f::nfnt::NfntReadOptions` dict.

#### `fontpixel.Registry.set_nfnt_write_options(options: NfntWriteOptions) -> None`

*method* -- `Registry::set_nfnt_write_options`: apply a `f::nfnt::NfntWriteOptions` dict.

#### `fontpixel.Registry.set_oberon_read_options(options: OberonReadOptions) -> None`

*method* -- `Registry::set_oberon_read_options`: apply a `f::oberon::OberonReadOptions` dict.

#### `fontpixel.Registry.set_oberon_write_options(options: OberonWriteOptions) -> None`

*method* -- `Registry::set_oberon_write_options`: apply a `f::oberon::OberonWriteOptions` dict.

#### `fontpixel.Registry.set_options(format: str, read: Mapping[str, Any] | None = ..., write: Mapping[str, Any] | None = ...) -> None`

*method* -- Configure both sides of `format`; `None` leaves a side unchanged.

#### `fontpixel.Registry.set_palm_read_options(options: PalmReadOptions) -> None`

*method* -- `Registry::set_palm_read_options`: apply a `f::palm::PalmReadOptions` dict.

#### `fontpixel.Registry.set_palm_write_options(options: PalmWriteOptions) -> None`

*method* -- `Registry::set_palm_write_options`: apply a `f::palm::PalmWriteOptions` dict.

#### `fontpixel.Registry.set_pbf_read_options(options: PbfReadOptions) -> None`

*method* -- `Registry::set_pbf_read_options`: apply a `f::pbf::PbfReadOptions` dict.

#### `fontpixel.Registry.set_pbf_write_options(options: PbfWriteOptions) -> None`

*method* -- `Registry::set_pbf_write_options`: apply a `f::pbf::PbfWriteOptions` dict.

#### `fontpixel.Registry.set_pcf_write_options(options: PcfWriteOptions) -> None`

*method*

`Registry::set_pcf_write_options`: apply a `f::pcf::PcfWriteOptions` dict; invalid combinations raise.

#### `fontpixel.Registry.set_pcgeos_read_options(options: PcgeosReadOptions) -> None`

*method* -- `Registry::set_pcgeos_read_options`: apply a `f::pcgeos::PcgeosReadOptions` dict.

#### `fontpixel.Registry.set_pcgeos_write_options(options: PcgeosWriteOptions) -> None`

*method* -- `Registry::set_pcgeos_write_options`: apply a `f::pcgeos::PcgeosWriteOptions` dict.

#### `fontpixel.Registry.set_pcr_read_options(options: PcrReadOptions) -> None`

*method* -- `Registry::set_pcr_read_options`: apply a `f::pcr::PcrReadOptions` dict.

#### `fontpixel.Registry.set_pcr_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_pcr_write_options`: apply a `f::pcr::PcrWriteOptions` dict.

#### `fontpixel.Registry.set_pf2_read_options(options: Pf2ReadOptions) -> None`

*method* -- `Registry::set_pf2_read_options`: apply a `f::pf2::Pf2ReadOptions` dict.

#### `fontpixel.Registry.set_pf2_write_options(options: Pf2WriteOptions) -> None`

*method* -- `Registry::set_pf2_write_options`: apply a `f::pf2::Pf2WriteOptions` dict.

#### `fontpixel.Registry.set_pfr_read_options(options: PfrReadOptions) -> None`

*method* -- `Registry::set_pfr_read_options`: apply a `f::pfr::PfrReadOptions` dict.

#### `fontpixel.Registry.set_pfr_write_options(options: PfrWriteOptions) -> None`

*method* -- `Registry::set_pfr_write_options`: apply a `f::pfr::PfrWriteOptions` dict.

#### `fontpixel.Registry.set_pilfont_read_options(options: PilfontReadOptions) -> None`

*method* -- `Registry::set_pilfont_read_options`: apply a `f::pilfont::PilfontReadOptions` dict.

#### `fontpixel.Registry.set_pilfont_write_options(options: PilfontWriteOptions) -> None`

*method* -- `Registry::set_pilfont_write_options`: apply a `f::pilfont::PilfontWriteOptions` dict.

#### `fontpixel.Registry.set_pk_write_options(options: TexWriteOptions) -> None`

*method* -- `Registry::set_pk_write_options`: apply a `f::pk::PkWriteOptions` dict.

#### `fontpixel.Registry.set_plan9_write_options(options: Plan9WriteOptions) -> None`

*method* -- `Registry::set_plan9_write_options`: apply a `f::plan9::Plan9WriteOptions` dict.

#### `fontpixel.Registry.set_playdate_read_options(options: PlaydateReadOptions) -> None`

*method* -- `Registry::set_playdate_read_options`: apply a `f::playdate::PlaydateReadOptions` dict.

#### `fontpixel.Registry.set_playdate_write_options(options: PlaydateWriteOptions) -> None`

*method* -- `Registry::set_playdate_write_options`: apply a `f::playdate::PlaydateWriteOptions` dict.

#### `fontpixel.Registry.set_plus3dos_read_options(options: Plus3dosReadOptions) -> None`

*method* -- `Registry::set_plus3dos_read_options`: apply a `f::plus3dos::Plus3dosReadOptions` dict.

#### `fontpixel.Registry.set_plus3dos_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_plus3dos_write_options`: apply a `f::plus3dos::Plus3dosWriteOptions` dict.

#### `fontpixel.Registry.set_polyprint_read_options(options: PolyprintReadOptions) -> None`

*method* -- `Registry::set_polyprint_read_options`: apply a `f::polyprint::PolyprintReadOptions` dict.

#### `fontpixel.Registry.set_polyprint_write_options(options: PolyprintWriteOptions) -> None`

*method* -- `Registry::set_polyprint_write_options`: apply a `f::polyprint::PolyprintWriteOptions` dict.

#### `fontpixel.Registry.set_prebuilt_read_options(options: PrebuiltReadOptions) -> None`

*method* -- `Registry::set_prebuilt_read_options`: apply a `f::prebuilt::PrebuiltReadOptions` dict.

#### `fontpixel.Registry.set_prebuilt_write_options(options: PrebuiltWriteOptions) -> None`

*method* -- `Registry::set_prebuilt_write_options`: apply a `f::prebuilt::PrebuiltWriteOptions` dict.

#### `fontpixel.Registry.set_printshop_read_options(options: PrintshopReadOptions) -> None`

*method* -- `Registry::set_printshop_read_options`: apply a `f::printshop::PrintshopReadOptions` dict.

#### `fontpixel.Registry.set_printshop_write_options(options: PrintshopWriteOptions) -> None`

*method* -- `Registry::set_printshop_write_options`: apply a `f::printshop::PrintshopWriteOptions` dict.

#### `fontpixel.Registry.set_psf2txt_read_options(options: Psf2txtReadOptions) -> None`

*method* -- `Registry::set_psf2txt_read_options`: apply a `f::psf2txt::Psf2txtReadOptions` dict.

#### `fontpixel.Registry.set_psf2txt_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_psf2txt_write_options`: apply a `f::psf2txt::Psf2txtWriteOptions` dict.

#### `fontpixel.Registry.set_psf_write_options(options: PsfWriteOptions) -> None`

*method* -- `Registry::set_psf_write_options`: apply a `f::psf::PsfWriteOptions` dict.

#### `fontpixel.Registry.set_pxl_read_options(options: PxlReadOptions) -> None`

*method* -- `Registry::set_pxl_read_options`: apply a `f::pxl::PxlReadOptions` dict.

#### `fontpixel.Registry.set_pxl_write_options(options: PxlWriteOptions) -> None`

*method* -- `Registry::set_pxl_write_options`: apply a `f::pxl::PxlWriteOptions` dict.

#### `fontpixel.Registry.set_qpf2_read_options(options: Qpf2ReadOptions) -> None`

*method* -- `Registry::set_qpf2_read_options`: apply a `f::qpf2::Qpf2ReadOptions` dict.

#### `fontpixel.Registry.set_qpf2_write_options(options: Qpf2WriteOptions) -> None`

*method* -- `Registry::set_qpf2_write_options`: apply a `f::qpf2::Qpf2WriteOptions` dict.

#### `fontpixel.Registry.set_qpf_read_options(options: QpfReadOptions) -> None`

*method* -- `Registry::set_qpf_read_options`: apply a `f::qpf::QpfReadOptions` dict.

#### `fontpixel.Registry.set_qpf_write_options(options: QpfWriteOptions) -> None`

*method* -- `Registry::set_qpf_write_options`: apply a `f::qpf::QpfWriteOptions` dict.

#### `fontpixel.Registry.set_raw_read_options(options: RawReadOptions) -> None`

*method* -- `Registry::set_raw_read_options`: apply a `f::raw::RawReadOptions` dict.

#### `fontpixel.Registry.set_raw_write_options(options: RawWriteOptions) -> None`

*method* -- `Registry::set_raw_write_options`: apply a `f::raw::RawWriteOptions` dict.

#### `fontpixel.Registry.set_read_options(format: str, options: Mapping[str, Any]) -> None`

*method*

Configure the typed reader options of `format` from a dict (the
format's `*ReadOptions` fields; unknown keys raise `ValueError`).

#### `fontpixel.Registry.set_riscos_read_options(options: RiscosReadOptions) -> None`

*method* -- `Registry::set_riscos_read_options`: apply a `f::riscos::RiscosReadOptions` dict.

#### `fontpixel.Registry.set_riscos_write_options(options: RiscosWriteOptions) -> None`

*method* -- `Registry::set_riscos_write_options`: apply a `f::riscos::RiscosWriteOptions` dict.

#### `fontpixel.Registry.set_rockbox_read_options(options: RockboxReadOptions) -> None`

*method* -- `Registry::set_rockbox_read_options`: apply a `f::rockbox::RockboxReadOptions` dict.

#### `fontpixel.Registry.set_rockbox_write_options(options: RockboxWriteOptions) -> None`

*method* -- `Registry::set_rockbox_write_options`: apply a `f::rockbox::RockboxWriteOptions` dict.

#### `fontpixel.Registry.set_sbf_read_options(options: SbfReadOptions) -> None`

*method* -- `Registry::set_sbf_read_options`: apply a `f::sbf::SbfReadOptions` dict.

#### `fontpixel.Registry.set_sbf_write_options(options: SbfWriteOptions) -> None`

*method* -- `Registry::set_sbf_write_options`: apply a `f::sbf::SbfWriteOptions` dict.

#### `fontpixel.Registry.set_sfd_write_options(options: SfdWriteOptions) -> None`

*method* -- `Registry::set_sfd_write_options`: apply a `f::sfd::SfdWriteOptions` dict.

#### `fontpixel.Registry.set_sfont_read_options(options: SfontReadOptions) -> None`

*method* -- `Registry::set_sfont_read_options`: apply a `f::sfont::SfontReadOptions` dict.

#### `fontpixel.Registry.set_sfont_write_options(options: SfontWriteOptions) -> None`

*method* -- `Registry::set_sfont_write_options`: apply a `f::sfont::SfontWriteOptions` dict.

#### `fontpixel.Registry.set_signum_read_options(options: SignumReadOptions) -> None`

*method* -- `Registry::set_signum_read_options`: apply a `f::signum::SignumReadOptions` dict.

#### `fontpixel.Registry.set_signum_write_options(options: SignumWriteOptions) -> None`

*method* -- `Registry::set_signum_write_options`: apply a `f::signum::SignumWriteOptions` dict.

#### `fontpixel.Registry.set_snf_read_options(options: SnfReadOptions) -> None`

*method* -- `Registry::set_snf_read_options`: apply a `f::snf::SnfReadOptions` dict.

#### `fontpixel.Registry.set_snf_write_options(options: SnfWriteOptions) -> None`

*method* -- `Registry::set_snf_write_options`: apply a `f::snf::SnfWriteOptions` dict.

#### `fontpixel.Registry.set_ssfn_read_options(options: SsfnReadOptions) -> None`

*method* -- `Registry::set_ssfn_read_options`: apply a `f::ssfn::SsfnReadOptions` dict.

#### `fontpixel.Registry.set_ssfn_write_options(options: SsfnWriteOptions) -> None`

*method* -- `Registry::set_ssfn_write_options`: apply a `f::ssfn::SsfnWriteOptions` dict.

#### `fontpixel.Registry.set_svg_read_options(options: SvgReadOptions) -> None`

*method* -- `Registry::set_svg_read_options`: apply a `f::svg::ReadOptions` dict.

#### `fontpixel.Registry.set_svg_write_options(options: SvgWriteOptions) -> None`

*method* -- `Registry::set_svg_write_options`: apply a `f::svg::WriteOptions` dict.

#### `fontpixel.Registry.set_symbos_read_options(options: SymbosReadOptions) -> None`

*method* -- `Registry::set_symbos_read_options`: apply a `f::symbos::SymbosReadOptions` dict.

#### `fontpixel.Registry.set_symbos_write_options(options: SymbosWriteOptions) -> None`

*method* -- `Registry::set_symbos_write_options`: apply a `f::symbos::SymbosWriteOptions` dict.

#### `fontpixel.Registry.set_tasprint_read_options(options: TasprintReadOptions) -> None`

*method* -- `Registry::set_tasprint_read_options`: apply a `f::tasprint::TasprintReadOptions` dict.

#### `fontpixel.Registry.set_tasprint_write_options(options: TasprintWriteOptions) -> None`

*method* -- `Registry::set_tasprint_write_options`: apply a `f::tasprint::TasprintWriteOptions` dict.

#### `fontpixel.Registry.set_u8m_read_options(options: U8mReadOptions) -> None`

*method* -- `Registry::set_u8m_read_options`: apply a `f::u8m::U8mReadOptions` dict.

#### `fontpixel.Registry.set_u8m_write_options(options: U8mWriteOptions) -> None`

*method* -- `Registry::set_u8m_write_options`: apply a `f::u8m::U8mWriteOptions` dict.

#### `fontpixel.Registry.set_vector_read_options(options: VectorRasterOptions) -> None`

*method* -- `Registry::set_vector_read_options`: apply a `f::vector_raster::Options` dict.

#### `fontpixel.Registry.set_vector_write_options(options: VectorRasterWriteOptions) -> None`

*method* -- `Registry::set_vector_write_options`: apply a `f::vector_raster::WriteOptions` dict.

#### `fontpixel.Registry.set_vfont_read_options(options: VfontReadOptions) -> None`

*method* -- `Registry::set_vfont_read_options`: apply a `f::vfont::VfontReadOptions` dict.

#### `fontpixel.Registry.set_vfont_write_options(options: VfontWriteOptions) -> None`

*method* -- `Registry::set_vfont_write_options`: apply a `f::vfont::VfontWriteOptions` dict.

#### `fontpixel.Registry.set_vlw_read_options(options: VlwReadOptions) -> None`

*method* -- `Registry::set_vlw_read_options`: apply a `f::vlw::VlwReadOptions` dict.

#### `fontpixel.Registry.set_vlw_write_options(options: VlwWriteOptions) -> None`

*method* -- `Registry::set_vlw_write_options`: apply a `f::vlw::VlwWriteOptions` dict.

#### `fontpixel.Registry.set_vtfont_read_options(options: VtfontReadOptions) -> None`

*method* -- `Registry::set_vtfont_read_options`: apply a `f::vtfont::VtfontReadOptions` dict.

#### `fontpixel.Registry.set_vtfont_write_options(options: VtfontWriteOptions) -> None`

*method* -- `Registry::set_vtfont_write_options`: apply a `f::vtfont::VtfontWriteOptions` dict.

#### `fontpixel.Registry.set_write_options(format: str, options: Mapping[str, Any]) -> None`

*method*

Configure the typed writer options of `format` from a dict (the
format's `*WriteOptions` fields; unknown keys raise `ValueError`).

#### `fontpixel.Registry.set_writeon_read_options(options: WriteonReadOptions) -> None`

*method* -- `Registry::set_writeon_read_options`: apply a `f::writeon::WriteonReadOptions` dict.

#### `fontpixel.Registry.set_writeon_write_options(options: W5a1CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_writeon_write_options`: apply a `f::writeon::WriteonWriteOptions` dict.

#### `fontpixel.Registry.set_wsfont_read_options(options: WsfontReadOptions) -> None`

*method* -- `Registry::set_wsfont_read_options`: apply a `f::wsfont::WsfontReadOptions` dict.

#### `fontpixel.Registry.set_wsfont_write_options(options: WsfontWriteOptions) -> None`

*method* -- `Registry::set_wsfont_write_options`: apply a `f::wsfont::WsfontWriteOptions` dict.

#### `fontpixel.Registry.set_wyse_read_options(options: NativeReadOptions) -> None`

*method* -- `Registry::set_wyse_read_options`: apply a `f::wyse::WyseReadOptions` dict.

#### `fontpixel.Registry.set_wyse_write_options(options: W5a2CommonNativeWriteOptions) -> None`

*method* -- `Registry::set_wyse_write_options`: apply a `f::wyse::WyseWriteOptions` dict.

#### `fontpixel.Registry.set_xbin_read_options(options: NativeReadOptions) -> None`

*method* -- `Registry::set_xbin_read_options`: apply a `f::xbin::XbinReadOptions` dict.

#### `fontpixel.Registry.set_xbin_write_options(options: XbinWriteOptions) -> None`

*method* -- `Registry::set_xbin_write_options`: apply a `f::xbin::XbinWriteOptions` dict.

#### `fontpixel.Registry.set_xerox_read_options(options: XeroxReadOptions) -> None`

*method* -- `Registry::set_xerox_read_options`: apply a `f::xerox::XeroxReadOptions` dict.

#### `fontpixel.Registry.set_xerox_write_options(options: XeroxWriteOptions) -> None`

*method* -- `Registry::set_xerox_write_options`: apply a `f::xerox::XeroxWriteOptions` dict.

#### `fontpixel.Registry.set_yaff_write_options(options: YaffWriteOptions) -> None`

*method*

`Registry::set_yaff_write_options`: apply a `f::yaff::YaffWriteOptions` dict; invalid combinations raise.

#### `fontpixel.Registry.set_zapfont_read_options(options: ZapfontReadOptions) -> None`

*method* -- `Registry::set_zapfont_read_options`: apply a `f::zapfont::ZapfontReadOptions` dict.

#### `fontpixel.Registry.set_zapfont_write_options(options: ZapfontWriteOptions) -> None`

*method* -- `Registry::set_zapfont_write_options`: apply a `f::zapfont::ZapfontWriteOptions` dict.

#### `fontpixel.Registry.status(format: str) -> FormatStatus`

*method* -- The `FormatStatus` dict of one format ID; raises `UnknownFormatError`.

#### `fontpixel.Registry.write(fonts: FontSet | Font, format: str, *, report: Report | None = ..., primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*method*

Encode a `FontSet` (or one `Font`) as `format` (`Registry::write`, or
`write_with_report` when `report` carries earlier read diagnostics).
`primary_name` defaults to `font.<first extension>`; a `.gz` suffix
selects the gzip envelope. `strict=True` raises `StrictLossError` on
any read or write loss. `transport_limits` is a `TransportLimits` dict.

#### `fontpixel.Registry.write_owned(fonts: FontSet | Font, format: str, report: Report | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*method*

`Registry::write_owned`: hand the model over so it can be released
before later encoder stages. A `FontSet` argument is *moved*: the
handle is left empty (zero strikes) afterwards. Output and report equal
`write_with_report`; `transport_limits` include the model.

#### `fontpixel.Registry.write_reserved_with_report(fonts: FontSet | Font, format: str, report: Report | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*method*

`Registry::write_reserved_with_report`: as `write_with_report` while the
caller keeps the model's retained usage reserved outside
`transport_limits`. Output and report are identical.

#### `fontpixel.Registry.write_with_report(fonts: FontSet | Font, format: str, report: Report, *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*method*

`Registry::write_with_report`: combine `report` (earlier read
diagnostics, a dict) with the write diagnostics before strict checks.

### `fontpixel.Rendered()`

*class*

Result of a render call (`fontpixel::render::Rendered`): the Mono
`bitmap` (top-left origin) and the `report` dict with every diagnostic.

#### `fontpixel.Rendered.bitmap: Bitmap`

*property* -- Rendered pixels.

#### `fontpixel.Rendered.report: Report`

*property* -- Plain-data report (`{"entries": [...]}`).

#### `fontpixel.Rendered.to_dict() -> RenderedDict`

*method* -- Plain data: `{"bitmap": {"width", "height", "data"}, "report": {...}}`.

### `fontpixel.ReportedErrorsError(FontpixelError)`

*exception* -- A codec reported error diagnostics.

### `fontpixel.ResourceLimitError(FontpixelError)`

*exception* -- A configured resource limit was exceeded.

### `fontpixel.ResourceSet(files: Mapping[str, Buffer] | None = ...) -> ResourceSet`

*class*

Named in-memory files offered to readers as sidecars (a
`ResourceResolver`). Paths are validated `ResourcePath`s (`/`-separated,
relative, no `.`/`..`).

#### `fontpixel.ResourceSet.get(path: str) -> bytes | None`

*method* -- A copy of one file, or `None`.

#### `fontpixel.ResourceSet.insert(path: str, data: Buffer | Sequence[int]) -> None`

*method* -- Add or replace a file.

#### `fontpixel.ResourceSet.list(directory: str | None = ..., max_entries: int | None = ..., max_bytes: int | None = ...) -> list[str]`

*method*

Immediate files of `directory` (`None`: the root)
(`ResourceResolver::list`).

#### `fontpixel.ResourceSet.paths() -> list[str]`

*method* -- Every path in sorted order.

#### `fontpixel.ResourceSet.remove(path: str) -> bool`

*method* -- Remove a file; returns whether it existed.

#### `fontpixel.ResourceSet.resolve(path: str, max_bytes: int | None = ...) -> bytes`

*method* -- Resolve like a reader would (`ResourceResolver::resolve`).

### `fontpixel.StrictLossError(FontpixelError)`

*exception* -- Strict mode rejected an information loss.

### `fontpixel.UNICODE_BLOCKS: tuple[UnicodeRange, ...]`

*constant*

### `fontpixel.UNICODE_VERSION: str`

*constant*

### `fontpixel.UnknownFormatError(FontpixelError)`

*exception* -- Unknown format identifier.

### `fontpixel.UnrecognizedFormatError(FontpixelError)`

*exception* -- No detector recognized the input.

### `fontpixel.UnsupportedError(FontpixelError)`

*exception* -- Capability unavailable on this platform or build; see `reason`.

### `fontpixel.Written(output: OutputBundle, report: Report | None = ...) -> Written`

*class*

A writer result: the output bundle and its report
(`fontpixel::resources::Written`).

#### `fontpixel.Written.output: OutputBundle`

*property* -- Output files.

#### `fontpixel.Written.report: Report`

*property* -- Report dict.

#### `fontpixel.Written.to_dict() -> WrittenDict`

*method* -- Plain-data form (`{"output": {...}, "report": {...}}`).

### `fontpixel.apply_bitmap_projection(font_set: FontSet, projection: BitmapProjection | BitmapProjectionArgs, max_working_bytes: int | None = ...) -> ProjectionOutcome`

*function*

Apply `projection` (a `BitmapProjection` or a dict of its constructor
arguments) to every strike as one transaction; on error the set is
unchanged (`projection::apply_bitmap_projection`). Returns the
`ProjectionOutcome` dict (`report`, `scalable_advance_changes`,
`metadata_changes`) plus `retained_bytes`
(`ProjectionOutcome::retained_bytes`). `max_working_bytes` defaults to
unbounded.

### `fontpixel.apply_names(font_set: FontSet, overrides: NameOverrides | None = ..., limits: ResourceLimits | None = ...) -> Report`

*function*

Apply family/style/name/notice overrides to every strike as one
transaction (`metadata::apply_names`). `overrides` is a `NameOverrides`
dict (`family`, `style`, `full_name`, `postscript_name`, `version`,
`copyright`, `license`, `license_url`, `foundry`); an empty dict changes
nothing. Returns the report.

### `fontpixel.canonical_charset(name: str) -> str`

*function* -- Canonical key for a user-facing name (`canonical_charset`).

### `fontpixel.charset_canonical_name(font_or_charset: Font | FontCharset) -> str`

*function*

Canonical charset name of a `FontCharset` dict or `Font`
(`FontCharset::canonical_name`).

### `fontpixel.charset_props(key: str) -> tuple[str, str]`

*function* -- `(CHARSET_REGISTRY, CHARSET_ENCODING)` for a key (`charset_props`).

### `fontpixel.charset_table() -> list[CharsetTableEntry]`

*function*

Every canonical charset (`charset_table`), as dicts with `key`,
`python_codec`, `kind`, `gl_capable`, `force_gl`, `properties`,
`aliases` and `available` (`CharsetInfo::available`).

### `fontpixel.default_bitmap_limits() -> BitmapLimits`

*function* -- Default `BitmapLimits` as a dict.

### `fontpixel.default_byte_layout() -> ByteLayout`

*function* -- Default `ByteLayout` as a dict.

### `fontpixel.default_image_options() -> ImageOptions`

*function* -- Default `ImageOptions` as a dict.

### `fontpixel.default_render_limits() -> RenderLimits`

*function* -- Default `RenderLimits` as a dict.

### `fontpixel.default_render_options() -> RenderOptions`

*function* -- Default `RenderOptions` as a dict.

### `fontpixel.default_resource_limits() -> ResourceLimits`

*function* -- Default `ResourceLimits` as a dict.

### `fontpixel.default_transport_limits() -> TransportLimits`

*function* -- Default `TransportLimits` as a dict.

### `fontpixel.detect(data: ReadInput | None = ..., name: str | None = ..., *, resources: Resources | None = ..., limits: ResourceLimits | None = ...) -> Detected`

*function*

Detect the format of font bytes with the built-in registry. Returns
`{"format": FormatInfo, "confidence": …}`.

### `fontpixel.detect_gl(key: str, encoding: str | None, codes: Sequence[int]) -> bool`

*function* -- Infer the GL form from glyph codes (`detect_gl`).

### `fontpixel.east_asian_width(cp: int) -> EastAsianWidth | None`

*function*

East Asian Width property, or `None` for non-scalars
(`merge_categories::east_asian_width`).

### `fontpixel.euc_to_kuten(code: int) -> tuple[int, int] | None`

*function* -- EUC code to one-based `(row, cell)`, or `None` (`euc_to_kuten`).

### `fontpixel.is_cjk(cp: int) -> bool`

*function* -- Explicit CJK block policy (`merge_categories::is_cjk`).

### `fontpixel.is_geometric(cp: int) -> bool`

*function* -- Box/block/braille/Powerline ranges (`merge_categories::is_geometric`).

### `fontpixel.is_han(cp: int) -> bool`

*function* -- Han ideograph blocks (`merge_categories::is_han`).

### `fontpixel.is_scalar(cp: int) -> bool`

*function* -- Whether a value is a Unicode scalar (`merge_categories::is_scalar`).

### `fontpixel.is_unicode_charset(key: str) -> bool`

*function* -- Whether a canonical key denotes Unicode identity (`is_unicode_charset`).

### `fontpixel.is_western(cp: int) -> bool`

*function* -- Scalar complement of CJK (`merge_categories::is_western`).

### `fontpixel.kuten_to_euc(row: int, cell: int) -> int | None`

*function* -- One-based 94×94 row/cell to an EUC code, or `None` (`kuten_to_euc`).

### `fontpixel.list_formats() -> list[FormatStatus]`

*function* -- Every catalogue format with its capabilities (`FormatStatus` dicts).

### `fontpixel.name_overrides_is_empty(overrides: NameOverrides) -> bool`

*function* -- Whether a `NameOverrides` dict requests no change (`NameOverrides::is_empty`).

### `fontpixel.parse_rgba(text: str) -> Rgba`

*function*

Parse `#RGB`, `#RGBA`, `#RRGGBB`, `#RRGGBBAA` or `transparent` into a
color dict (`Rgba: FromStr`).

### `fontpixel.parse_writing_direction(spec: str) -> WritingDirection`

*function*

Strict direction parsing (`WritingDirection: FromStr`); raises
`InvalidInputError` for unknown spellings.

### `fontpixel.read(data: ReadInput | None = ..., format: str | None = ..., options: Mapping[str, Any] | None = ..., resources: Resources | None = ..., *, name: str | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> Loaded`

*function*

Decode font bytes with the built-in registry (`fontpixel::read`).

`format` selects the reader (otherwise content detection, then `name`
as a filename hint). `options` is the format's typed read-options dict.
`resources` supplies sidecars (`dict[str, bytes]`, a callable or a
resolver object). `limits` is a `ResourceLimits` dict. `directory="name"`
reads a native directory entry point through `resources`.

### `fontpixel.registry() -> Registry`

*function* -- The built-in registry (`fontpixel::registry()`).

### `fontpixel.report_extend(report: Report, other: Report) -> Report`

*function* -- A new report dict with every entry of `other` appended (`Report::extend`).

### `fontpixel.report_has_errors(report: Report) -> bool`

*function* -- Whether a report dict has any error entry (`Report::has_errors`).

### `fontpixel.report_has_loss(report: Report) -> bool`

*function* -- Whether a report dict has any loss entry (`Report::has_loss`).

### `fontpixel.report_push(report: Report, entry: ReportEntry) -> Report`

*function*

A new report dict with `entry` appended, after validating both
(`Report::push`).

### `fontpixel.report_to_text(report: Report) -> str`

*function* -- The report in the CLI's text form, one line per entry (`Report: Display`).

### `fontpixel.resource_path(path: str) -> str`

*function* -- Validate a portable relative asset path and return it (`ResourcePath::new`).

### `fontpixel.rgba(red: int, green: int, blue: int, alpha: int = ...) -> Rgba`

*function* -- An RGBA color dict (`Rgba::new`).

### `fontpixel.sanitize_charset(registry: str | None = ..., encoding: str | None = ...) -> str`

*function* -- Canonical key from XLFD registry/encoding (`sanitize_charset`).

### `fontpixel.to_png(bitmap: BitmapLike, options: ImageOptions | None = ...) -> bytes`

*function*

Encode a Mono bitmap as an indexed 1-bit PNG (`render::image::to_png`).
`options` is an `ImageOptions` dict (`scale`, `foreground`, `background`,
`limits`); colors are `{red, green, blue, alpha}` dicts.

### `fontpixel.to_svg(bitmap: BitmapLike, options: ImageOptions | None = ...) -> str`

*function* -- Export a Mono bitmap as a standalone SVG string (`render::image::to_svg`).

### `fontpixel.unicode_block(cp: int) -> UnicodeRange | None`

*function* -- The Unicode block `{start, end, name}`, or `None` (`merge_categories::unicode_block`).

### `fontpixel.windows_charset(value: int) -> WindowsCharset`

*function*

Resolve a Windows `dfCharSet` byte (`windows_charset`): `{"code_page":
"cp1252"}`, `"system_ansi"`, `"system_oem"`, `"system_mac"`, `"symbol"` or
`{"unknown": n}`.

### `fontpixel.write(fonts: FontSet | Font, format: str, options: Mapping[str, Any] | None = ..., *, report: Report | None = ..., primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` (or one `Font`) with the built-in registry
(`fontpixel::write`, or `write_with_report` when `report` is given).

`options` is the format's typed write-options dict. `primary_name`
defaults to `font.<first extension>`; a `.gz` suffix selects the gzip
envelope. `strict=True` raises `StrictLossError` on any loss.

### `fontpixel.writing_direction_from_spec(spec: str) -> WritingDirection`

*function*

Lenient SPEC direction parsing: invalid strings give `lrtb`
(`WritingDirection::from_spec`). Returns `{"glyphs", "lines"}`.

## fontpixel.compat

Compatibility layers over the native fontpixel core.

## fontpixel.compat.bdfparser

bdfparser-compatible API (bdfparser 3.0 / SPEC-v3) on the fontpixel Rust core.

`Font`, `Glyph`, `Bitmap`, the module functions (`encoding`, `outline`, `pcf`,
`ttf`, `cli`), `BDFParserWarning` and `BDFParseError` behave as in bdfparser.
Font data stays in Rust: `Font`/`Glyph` hold handles and `Bitmap` wraps a
native raster; pixels are converted to row strings only when requested.

### `fontpixel.compat.bdfparser.BDFParseError(ValueError)`

*exception*

Raised on fatal BDF parse errors (unexpected end of file inside the headers,
malformed numbers in required fields, glyph without `BBX`, ...).

`lineno` is the 1-based line number where the problem was detected (or `None`).

### `fontpixel.compat.bdfparser.BDFParserWarning(UserWarning)`

*exception*

Category of every warning emitted by the compatibility API (non-fatal
problems in a font, missing glyphs, unknown charsets, ...).

Filter them with the standard `warnings` machinery, e.g.
`warnings.simplefilter('ignore', BDFParserWarning)`.

### `fontpixel.compat.bdfparser.Bitmap(bin_bitmap_list: Iterable[str]) -> Bitmap`

*class*

A bitmap of `'0'`/`'1'`/`'2'` rows (row 0 at the top), backed by a native
raster. Equality compares pixels; instances are unhashable (mutable).

#### `fontpixel.compat.bdfparser.Bitmap.bbox() -> tuple[int, int, int, int]`

*method* -- Ink bounding box `(w, h, xoff, yoff)`, bottom-left origin (`Bitmap::bbox`).

#### `fontpixel.compat.bdfparser.Bitmap.bindata: list[str]`

*property* -- The rows as a new list of strings (`Bitmap::bindata`); assign to replace.

#### `fontpixel.compat.bdfparser.Bitmap.blank(w: int, h: int) -> Self`

*class method* -- An all-zero `w`×`h` bitmap (`Bitmap::blank`).

#### `fontpixel.compat.bdfparser.Bitmap.bold(n: int = ...) -> Bitmap`

*method* -- Embolden by `n` pixels (`Bitmap::bold`).

#### `fontpixel.compat.bdfparser.Bitmap.bytepad(bits: int = ...) -> Bitmap`

*method* -- Pad the width to a multiple of `bits` (`Bitmap::bytepad`).

#### `fontpixel.compat.bdfparser.Bitmap.clone() -> Self`

*method* -- Independent copy.

#### `fontpixel.compat.bdfparser.Bitmap.concat(bitmap: Bitmap, direction: int = ..., align: int = ..., offset: int = ...) -> Bitmap`

*method* -- Concatenate another bitmap in place (`Bitmap::concat`).

#### `fontpixel.compat.bdfparser.Bitmap.concatall(bitmaplist: Sequence[Bitmap], direction: int = ..., align: int = ..., offsetlist: Sequence[int] | None = ...) -> Self`

*class method*

Concatenate bitmaps: `direction` 1 right, 2 left, 0 down, -1 up; `align`
1 bottom/left, 0 top/right; `offsetlist` gaps between neighbours
(`Bitmap::concatall`).

#### `fontpixel.compat.bdfparser.Bitmap.crop(w: int, h: int, xoff: int = ..., yoff: int = ...) -> Bitmap`

*method*

Crop/extend to `w`×`h`; `(xoff, yoff)` is the new bottom-left corner
relative to the current one, y up (`Bitmap::crop`).

#### `fontpixel.compat.bdfparser.Bitmap.enlarge(x: int = ..., y: int = ...) -> Bitmap`

*method* -- Integer scale (`Bitmap::enlarge`).

#### `fontpixel.compat.bdfparser.Bitmap.equals(other: Bitmap) -> bool`

*method* -- Same as `==` (`Bitmap::equals`).

#### `fontpixel.compat.bdfparser.Bitmap.fliph() -> Bitmap`

*method* -- Mirror left-right (`Bitmap::fliph`).

#### `fontpixel.compat.bdfparser.Bitmap.flipv() -> Bitmap`

*method* -- Mirror top-bottom (`Bitmap::flipv`).

#### `fontpixel.compat.bdfparser.Bitmap.fromstring(text: str) -> Self`

*class method*

Parse a `str()` picture (`#`=1, `.`=0, `&`=2, digits accepted; outer empty
lines ignored) (`Bitmap::fromstring`).

#### `fontpixel.compat.bdfparser.Bitmap.getpixel(x: int, y: int) -> int`

*method* -- Pixel value at `(x, y)` (top-left origin) (`Bitmap::getpixel`).

#### `fontpixel.compat.bdfparser.Bitmap.glow(mode: int = ...) -> Bitmap`

*method* -- Add a label-2 glow (`mode` 0: 4-neighbour, 1: 8-neighbour) (`Bitmap::glow`).

#### `fontpixel.compat.bdfparser.Bitmap.height() -> int`

*method* -- Number of rows (`Bitmap::height`).

#### `fontpixel.compat.bdfparser.Bitmap.invert() -> Bitmap`

*method* -- Swap ink and background (`Bitmap::invert`).

#### `fontpixel.compat.bdfparser.Bitmap.italic(step: int = ..., base: int = ...) -> Bitmap`

*method* -- Shear rows: one pixel per `step` rows above `base` (`Bitmap::italic`).

#### `fontpixel.compat.bdfparser.Bitmap.overlay(bitmap: Bitmap) -> Bitmap`

*method*

Overlay another bitmap aligned top-left, keeping this size; warns when the
sizes differ (`Bitmap::overlay`).

#### `fontpixel.compat.bdfparser.Bitmap.paste(bitmap: Bitmap, x: int = ..., y: int = ...) -> Bitmap`

*method* -- Paste non-zero pixels of `bitmap` at `(x, y)` (top-left origin) (`Bitmap::paste`).

#### `fontpixel.compat.bdfparser.Bitmap.replace(substr: str | int, newsubstr: str | int) -> Bitmap`

*method* -- Replace a label substring (str or int) in every row (`Bitmap::replace`).

#### `fontpixel.compat.bdfparser.Bitmap.rotate(angle: int = ...) -> Bitmap`

*method* -- Rotate clockwise by a multiple of 90 degrees (`Bitmap::rotate`).

#### `fontpixel.compat.bdfparser.Bitmap.setpixel(x: int, y: int, value: str | int | None = ...) -> Bitmap`

*method* -- Set the pixel at `(x, y)` to 0, 1 or 2 (`Bitmap::setpixel`).

#### `fontpixel.compat.bdfparser.Bitmap.shadow(xoff: int = ..., yoff: int = ...) -> Bitmap`

*method* -- Add a label-2 shadow (`Bitmap::shadow`).

#### `fontpixel.compat.bdfparser.Bitmap.shift(dx: int = ..., dy: int = ...) -> Bitmap`

*method* -- Move the content by `(dx, dy)` (y up), keeping the size (`Bitmap::shift`).

#### `fontpixel.compat.bdfparser.Bitmap.tobytes(mode: str = ..., bytesdict: dict[str, Any] | None = ...) -> bytes`

*method*

Pillow `Image.frombytes` data for mode `'1'`, `'L'`, `'RGB'` or `'RGBA'`;
`bytesdict` maps labels 0/1/2 to bytes (or bits for mode `'1'`)
(`Bitmap::tobytes`). Unknown modes warn and fall back to RGB.

#### `fontpixel.compat.bdfparser.Bitmap.todata(datatype: int = ...) -> Any`

*method*

Export data type 0 (str), 1 (rows), 2 (int rows), 3 (flat ints), 4 (hex
rows) or 5 (int per row) (`Bitmap::todata`).

#### `fontpixel.compat.bdfparser.Bitmap.tosvg(pixelsize: float = ..., format: str = ..., inverted: bool = ..., xoff: float = ..., yoff: float = ..., shape: str = ...) -> str`

*method*

SVG output: `format` `'path'`, `'pathOnly'` or `'rect'`; `shape` `'square'`
or `'circle'` (`Bitmap::tosvg`).

#### `fontpixel.compat.bdfparser.Bitmap.trim() -> Bitmap`

*method* -- Remove empty outer rows and columns (`Bitmap::trim`).

#### `fontpixel.compat.bdfparser.Bitmap.width() -> int`

*method* -- Width in pixels (`Bitmap::width`).

### `fontpixel.compat.bdfparser.Font(source: 'Any' = None) -> 'None'`

*class*

`Font` object

https://font.tomchen.org/bdfparser_py/font

#### `fontpixel.compat.bdfparser.Font.addglyph(self, glyph: 'Glyph | dict[str, Any]', replace: 'bool' = True) -> 'Font'`

*method*

Add a glyph (`Glyph` or meta `dict`). An existing codepoint is replaced
when `replace` (default), else kept with a warning. Codepoint `-1` adds an
unencoded glyph. A `Glyph` becomes attached to this font.

https://font.tomchen.org/bdfparser_py/font#addglyph

#### `fontpixel.compat.bdfparser.Font.char2cp(self, char: 'str') -> 'int | None'`

*method*

Convert a character to a codepoint of the font's charset (`None` if not
representable).

https://font.tomchen.org/bdfparser_py/font#char2cp

#### `fontpixel.compat.bdfparser.Font.charset`

*property*

Canonical charset key: the `encoding(charset=...)` override if set, else
derived from `CHARSET_REGISTRY` / `CHARSET_ENCODING` (`'iso10646'` if absent).

https://font.tomchen.org/bdfparser_py/font#charset

#### `fontpixel.compat.bdfparser.Font.charsetconvert(self, newcharset: 'str') -> 'Font'`

*method*

Re-encode every glyph to `newcharset` (unrepresentable glyphs are dropped
with a warning), update CHARSET_REGISTRY / CHARSET_ENCODING and clear any
`encoding()` override.

https://font.tomchen.org/bdfparser_py/font#charsetconvert

#### `fontpixel.compat.bdfparser.Font.clone(self) -> 'Font'`

*method*

Get a deep copy of the font.

https://font.tomchen.org/bdfparser_py/font#clone

#### `fontpixel.compat.bdfparser.Font.cp2char(self, cp: 'int') -> 'str | None'`

*method*

Convert a codepoint of the font's charset to a character (`None` if not
representable).

https://font.tomchen.org/bdfparser_py/font#cp2char

#### `fontpixel.compat.bdfparser.Font.create(pixelsize: 'int' = 16, ascent: 'int | None' = None, descent: 'int | None' = None, fontname: 'str | None' = None, familyname: 'str' = 'Untitled', xres: 'int' = 75, yres: 'int' = 75) -> 'Font'`

*class method*

Create a new empty font.

https://font.tomchen.org/bdfparser_py/font#fontcreate

#### `fontpixel.compat.bdfparser.Font.delprop(self, key: 'str') -> 'Font'`

*method*

Remove a property (case-insensitive key) if present.

https://font.tomchen.org/bdfparser_py/font#delprop

#### `fontpixel.compat.bdfparser.Font.draw(self, string: 'str', linelimit: 'int' = 512, mode: 'int' = 1, direction: 'str' = 'lrtb', usecurrentglyphspacing: 'bool' = False, missing: 'Glyph | dict | None' = None) -> 'Bitmap'`

*method*

Draw (render) a text to a `Bitmap`.

https://font.tomchen.org/bdfparser_py/font#draw

#### `fontpixel.compat.bdfparser.Font.drawall(self, order: 'int' = 1, r: 'Range | None' = None, linelimit: 'int' = 512, mode: 'int' = 0, direction: 'str' = 'lrtb', usecurrentglyphspacing: 'bool' = False) -> 'Bitmap'`

*method*

Draw all glyphs (or those in range `r`) in `order` to a `Bitmap`.

https://font.tomchen.org/bdfparser_py/font#drawall

#### `fontpixel.compat.bdfparser.Font.drawcps(self, cps: 'Iterable[int | None]', linelimit: 'int' = 512, mode: 'int' = 1, direction: 'str' = 'lrtb', usecurrentglyphspacing: 'bool' = False, missing: 'Glyph | dict | None' = None) -> 'Bitmap'`

*method*

Draw the glyphs of the given codepoints (`None` = not representable) to a
`Bitmap`.

https://font.tomchen.org/bdfparser_py/font#drawcps

#### `fontpixel.compat.bdfparser.Font.encoding(self, charset: 'str | None' = None, char2cp: 'Callable[[str], int | None] | None' = None, cp2char: 'Callable[[int], str | None] | None' = None) -> 'Font'`

*method*

Override the charset resolution (`charset`, any spelling; `''` clears
the override) and/or the character <-> codepoint conversion functions.

https://font.tomchen.org/bdfparser_py/font#encoding

#### `fontpixel.compat.bdfparser.Font.getprop(self, key: 'str') -> 'Any'`

*method*

Get a property value (case-insensitive key), `None` if absent.

https://font.tomchen.org/bdfparser_py/font#getprop

#### `fontpixel.compat.bdfparser.Font.glyph(self, character: 'str') -> 'Glyph | None'`

*method*

Get a glyph (attached `Glyph`) by character.

https://font.tomchen.org/bdfparser_py/font#glyph

#### `fontpixel.compat.bdfparser.Font.glyphbycp(self, codepoint: 'int') -> 'Glyph | None'`

*method*

Get a glyph (attached `Glyph`) by codepoint; `None` (with a warning) if absent.

https://font.tomchen.org/bdfparser_py/font#glyphbycp

#### `fontpixel.compat.bdfparser.Font.glyphs`

*property* -- Encoded glyphs: codepoint -> 17 meta values (`META_TITLES` order).

#### `fontpixel.compat.bdfparser.Font.headers`

*property* -- Global headers (`bdfversion`, `fontname`, `pointsize`, `fbbx`, ...).

#### `fontpixel.compat.bdfparser.Font.itercps(self, order: 'int' = 1, r: 'Range | None' = None) -> 'Iterator[int]'`

*method*

Iterator of the encoded codepoints: `order` 1 ascending (default), 0 file
order, 2 descending, -1 reverse file order; `r` filters (an int `n` means
`cp < n`, a tuple an inclusive range, a list of tuples several ranges).

https://font.tomchen.org/bdfparser_py/font#itercps

#### `fontpixel.compat.bdfparser.Font.iterglyphs(self, order: 'int' = 1, r: 'Range | None' = None) -> 'Iterator[Glyph]'`

*method*

Iterator of the glyphs (attached `Glyph` objects), in the same order and
range semantics as `itercps`.

https://font.tomchen.org/bdfparser_py/font#iterglyphs

#### `fontpixel.compat.bdfparser.Font.lacksglyphs(self, string: 'str') -> 'list[str] | None'`

*method*

Characters of `string` without a glyph (repeats included), or `None`.

https://font.tomchen.org/bdfparser_py/font#lacksglyphs

#### `fontpixel.compat.bdfparser.Font.length(self) -> 'int'`

*method*

Number of encoded glyphs in the font.

https://font.tomchen.org/bdfparser_py/font#length

#### `fontpixel.compat.bdfparser.Font.load_bytes(self, data: 'bytes | bytearray | memoryview', **ttfoptions: 'Any') -> 'Font'`

*method*

Load a font from `bytes`, auto-detected: PCF, gzip-compressed PCF/BDF,
TrueType (`pixelsize=` may be needed, see `read_ttf`), else BDF (UTF-8).

https://font.tomchen.org/bdfparser_py/font#load_bytes

#### `fontpixel.compat.bdfparser.Font.load_file_obj(self, file_obj: 'Any') -> 'Font'`

*method*

Load a font from a file object: a text file is parsed as BDF, a binary
file is auto-detected (BDF, PCF, TTF).

https://font.tomchen.org/bdfparser_py/font#load_file_obj

#### `fontpixel.compat.bdfparser.Font.load_file_path(self, file_path: 'str | os.PathLike') -> 'Font'`

*method*

Load a font file (BDF, PCF, `.pcf.gz` or TTF, auto-detected by content).

https://font.tomchen.org/bdfparser_py/font#load_file_path

#### `fontpixel.compat.bdfparser.Font.load_lines(self, lines: 'Iterable[str]') -> 'Font'`

*method*

Load a BDF font from an iterable of lines (`str`s, line endings optional).

https://font.tomchen.org/bdfparser_py/font#load_lines

#### `fontpixel.compat.bdfparser.Font.load_string(self, text: 'str') -> 'Font'`

*method*

Load a BDF font from a `str`.

https://font.tomchen.org/bdfparser_py/font#load_string

#### `fontpixel.compat.bdfparser.Font.merge(self, other: 'Font', replace: 'bool' = False) -> 'Font'`

*method*

Copy the encoded glyphs of `other` (no charset conversion); existing
codepoints are kept unless `replace`.

https://font.tomchen.org/bdfparser_py/font#merge

#### `fontpixel.compat.bdfparser.Font.newglyph(self, cp: 'int', bitmap: 'Bitmap | None' = None, mode: 'int' = 0, name: 'str | None' = None, dwidth: 'int | None' = None) -> 'Glyph'`

*method*

Create a glyph at codepoint `cp` (replacing any existing one), optionally
with a bitmap placed as by `Glyph.setbitmap(bitmap, mode)`; returns it
attached.

https://font.tomchen.org/bdfparser_py/font#newglyph

#### `fontpixel.compat.bdfparser.Font.props`

*property* -- Properties (lower-case keys, `comment` included).

#### `fontpixel.compat.bdfparser.Font.removeglyph(self, cp_or_glyph: 'int | Glyph') -> 'Font'`

*method*

Remove a glyph (by codepoint or `Glyph`); no-op if missing. An attached
`Glyph` removes exactly its own slot.

https://font.tomchen.org/bdfparser_py/font#removeglyph

#### `fontpixel.compat.bdfparser.Font.save(self, path: 'str | os.PathLike', format: 'str | None' = None, **opts: 'Any') -> 'Font'`

*method*

Save the font to a file; the format (`'bdf'`, `'pcf'`, `'ttf'`, `'svg'`)
comes from `format` or the file extension, `opts` go to the writer.

https://font.tomchen.org/bdfparser_py/font#save

#### `fontpixel.compat.bdfparser.Font.setprop(self, key: 'str', value: 'int | str | None') -> 'Font'`

*method*

Set a property (case-insensitive key); remembers the spelling of a new key.

https://font.tomchen.org/bdfparser_py/font#setprop

#### `fontpixel.compat.bdfparser.Font.subset(self, r: 'Range') -> 'Font'`

*method*

New font (deep copy) with only the encoded glyphs in range `r`.

https://font.tomchen.org/bdfparser_py/font#subset

#### `fontpixel.compat.bdfparser.Font.swidth(self, dwx: 'int') -> 'int'`

*method*

Compute SWIDTH (scalable width, 1/1000 em) from DWIDTH (pixels).

https://font.tomchen.org/bdfparser_py/font#swidth

#### `fontpixel.compat.bdfparser.Font.tobdf(self) -> 'str'`

*method*

Get the font as BDF text.

https://font.tomchen.org/bdfparser_py/font#tobdf

#### `fontpixel.compat.bdfparser.Font.topcf(self, **opts: 'Any') -> 'bytes'`

*method*

Get the font as PCF `bytes` (options: see `bdfparser.pcf.write_pcf`).

https://font.tomchen.org/bdfparser_py/font#topcf

#### `fontpixel.compat.bdfparser.Font.tosvgfont(self, xoff: 'float' = 0, yoff: 'float' = 0, controlcharnoskip: 'bool' = False, unicodeformat: 'str' = 'hexncr') -> 'str'`

*method*

Get the font as an SVG font `str` (`unicodeformat`: `'hexncr'`, `'decncr'`
or `'char'`).

https://font.tomchen.org/bdfparser_py/font#tosvgfont

#### `fontpixel.compat.bdfparser.Font.tottf(self, **opts: 'Any') -> 'bytes'`

*method*

Get the font as TrueType `bytes` (options: see `bdfparser.ttf.write_ttf`).

https://font.tomchen.org/bdfparser_py/font#tottf

#### `fontpixel.compat.bdfparser.Font.transform(self, fn: 'Callable[[Bitmap], Bitmap | None]', r: 'Range | None' = None, mode: 'int' = 0) -> 'Font'`

*method*

Apply `Glyph.transform(fn, mode)` to every glyph (or those in `r`;
unencoded glyphs only when `r` is `None`).

https://font.tomchen.org/bdfparser_py/font#transform

#### `fontpixel.compat.bdfparser.Font.unencoded`

*property* -- Unencoded glyphs (`ENCODING -1`) as `{'altcode': int | None, 'meta': list}`.

#### `fontpixel.compat.bdfparser.Font.updatebbox(self) -> 'Font'`

*method*

Set FONTBOUNDINGBOX to the union of all glyph boxes (empty boxes ignored).

https://font.tomchen.org/bdfparser_py/font#updatebbox

### `fontpixel.compat.bdfparser.Glyph(meta_dict: 'Mapping[str, Any]', font: 'Font') -> 'None'`

*class*

`Glyph` object: the 17 meta values (`meta`, a `dict`) plus the font it
belongs to (`font`).

https://font.tomchen.org/bdfparser_py/glyph

#### `fontpixel.compat.bdfparser.Glyph.chr(self) -> 'str | None'`

*method*

Get the character of the glyph (converted with the font's charset);
`None` if the codepoint is not representable.

https://font.tomchen.org/bdfparser_py/glyph#chr

#### `fontpixel.compat.bdfparser.Glyph.clone(self) -> 'Glyph'`

*method*

Get a deep copy of the glyph (same font, detached).

https://font.tomchen.org/bdfparser_py/glyph#clone

#### `fontpixel.compat.bdfparser.Glyph.cp(self) -> 'int'`

*method*

Get the codepoint of the glyph.

https://font.tomchen.org/bdfparser_py/glyph#cp

#### `fontpixel.compat.bdfparser.Glyph.draw(self, mode: 'int' = 0, bb: 'tuple[int, int, int, int] | None' = None) -> 'Bitmap'`

*method*

Draw the glyph to a `Bitmap`: `mode=0` in the font's bounding box, `1` in
the glyph's BBX, `2` the original hex data with padding bits, `-1` in the
box `bb` (`(w, h, xoff, yoff)`).

https://font.tomchen.org/bdfparser_py/glyph#draw

#### `fontpixel.compat.bdfparser.Glyph.origin(self, mode: 'int' = 0, fromorigin: 'bool' = False, xoff: 'int | None' = None, yoff: 'int | None' = None) -> 'tuple[int, int]'`

*method*

Displacement of the origin from the bottom-left corner of the bitmap drawn
by `draw(mode)`, or vice versa with `fromorigin=True`.

https://font.tomchen.org/bdfparser_py/glyph#origin

#### `fontpixel.compat.bdfparser.Glyph.setbitmap(self, bitmap: 'Bitmap', mode: 'int' = 0, bb: 'tuple[int, int, int, int] | None' = None, trim: 'bool' = True) -> 'Glyph'`

*method*

Set the glyph's bitmap (inverse of `draw()`); any non-`'0'` pixel is ink.
DWIDTH / SWIDTH are not changed.

https://font.tomchen.org/bdfparser_py/glyph#setbitmap

#### `fontpixel.compat.bdfparser.Glyph.setmeta(self, obj: 'Mapping[str, Any] | None' = None, /, **kwargs: 'Any') -> 'Glyph'`

*method*

Set any of the 17 meta keys, e.g. `glyph.setmeta(dwx0=8, glyphname='A')`.
Unknown keys raise `KeyError`. Changing the codepoint of an attached glyph
moves it in the font (overwriting a glyph already at the destination).

https://font.tomchen.org/bdfparser_py/glyph#setmeta

#### `fontpixel.compat.bdfparser.Glyph.shift(self, dx: 'int' = 0, dy: 'int' = 0) -> 'Glyph'`

*method*

Move the glyph's bitmap relative to the origin (`bbxoff += dx`,
`bbyoff += dy`, y up).

https://font.tomchen.org/bdfparser_py/glyph#shift

#### `fontpixel.compat.bdfparser.Glyph.transform(self, fn: 'Callable[[Bitmap], Bitmap | None]', mode: 'int' = 0) -> 'Glyph'`

*method*

Draw the glyph (`draw(mode)`), pass the bitmap to `fn` and set the result
(or the mutated argument if `fn` returns `None`) with `setbitmap`.

https://font.tomchen.org/bdfparser_py/glyph#transform

### `fontpixel.compat.bdfparser.defaultglyphname(cp: int, charset_is_unicode: bool = ...) -> str`

*function* -- `defaultglyphname(cp, charset_is_unicode=True)`: `uniXXXX`, `uXXXXX` or `charN`.

## fontpixel.compat.bdfparser.bitmap

`Bitmap` of the bdfparser-compatible API.

`Bitmap` is the native class `fontpixel._native._bdfparser.Bitmap`: the pixels
live in a Rust raster of labels 0, 1 and 2; `bindata` builds the row strings on
request. Rows must be rectangular and made of `'0'`, `'1'` and `'2'`.

### `fontpixel.compat.bdfparser.bitmap.Bitmap`

*class* -- Same class as `fontpixel.compat.bdfparser.Bitmap`.

### `fontpixel.compat.bdfparser.bitmap.fmtnum(n: 'float') -> 'str'`

*function*

Shortest text of a number as written in SVG output: integral values without
a fraction (`3.0` -> `'3'`, `-0.0` -> `'0'`), others as Python `repr`.

## fontpixel.compat.bdfparser.cli

Command line interface of the bdfparser-compatible API: `convert | info | preview`.

Same arguments, output and exit codes as `bdfparser`'s console script; every
font operation goes through the compatibility `Font` (Rust core).
Run as `python -m fontpixel.compat.bdfparser`.

### `fontpixel.compat.bdfparser.cli.main(argv: 'Sequence[str] | None' = None) -> 'int'`

*function* -- Entry point of the `bdfparser`-compatible command line. Returns the exit status.

## fontpixel.compat.bdfparser.encoding

Charset support of the bdfparser-compatible API (SPEC-v3 §4, §11.1).

Every function delegates to the native charset API (`fontpixel.CharsetCodec`,
`fontpixel.canonical_charset`, ... over `fontpixel::charset`, generated from
CPython's codecs): canonical keys, `CHARSET_REGISTRY` /
`CHARSET_ENCODING` folding, strict one-character conversions and GL forms.

### `fontpixel.compat.bdfparser.encoding.CharsetCodec(name: 'str', codec: 'str | None' = None, gl: 'bool' = False, known: 'bool' = True) -> None`

*class*

Converter between glyph codepoints and characters for one charset: `name`
(canonical key), `codec` (CPython codec name, `None` for Unicode), `gl`
(2-byte codes stored in GL form), `known` (unknown charsets map as Unicode).

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.char2cp(self, char: 'str') -> 'int | None'`

*method* -- Codepoint of a single character, `None` if not representable.

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.codec: NoneType`

*constant*

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.cp2char(self, cp: 'int') -> 'str | None'`

*method* -- Character of a codepoint, `None` if not representable.

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.gl: bool`

*constant*

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.kind`

*property* -- `'unicode'`, `'sbcs'`, `'dbcs'` or `'gb18030'`.

#### `fontpixel.compat.bdfparser.encoding.CharsetCodec.known: bool`

*constant*

### `fontpixel.compat.bdfparser.encoding.UNICODE_PREFIXES: tuple`

*constant*

### `fontpixel.compat.bdfparser.encoding.canonical_charset(name: 'str') -> 'str'`

*function* -- Canonical key of any charset spelling (`'GB2312'`, `'Shift-JIS'`, ...).

### `fontpixel.compat.bdfparser.encoding.char2cp(char: 'str', charset: 'str' = 'iso10646', gl: 'bool | None' = None) -> 'int | None'`

*function* -- Character -> codepoint in a charset (any spelling); `None` if not representable.

### `fontpixel.compat.bdfparser.encoding.charset_codec(key: 'str', gl: 'bool | None' = None) -> 'CharsetCodec'`

*function*

`CharsetCodec` for a canonical key. `gl=None`: GL form only for charsets that
are always GL (`iso2022cn`); GL is ignored for charsets that are not 94x94.

### `fontpixel.compat.bdfparser.encoding.charset_map(key: 'str') -> 'dict[int, str]'`

*function*

Every valid 1- and 2-byte code of a non-Unicode charset (non-GL form) ->
its character, as `charset_codec(key, gl=False).cp2char` converts it.

### `fontpixel.compat.bdfparser.encoding.charset_props(key: 'str') -> 'tuple[str, str]'`

*function* -- `(CHARSET_REGISTRY, CHARSET_ENCODING)` written by `Font.charsetconvert`.

### `fontpixel.compat.bdfparser.encoding.charset_table() -> 'dict[str, dict[str, Any]]'`

*function*

The canonical charset table `{key: info}`; `info` has `codec`, `kind`
(`'unicode'`, `'sbcs'`, `'dbcs'`, `'gb18030'`), `gl`, `forcegl`, `props` and
`aliases`.

### `fontpixel.compat.bdfparser.encoding.codec_name(key: 'str') -> 'str | None'`

*function* -- CPython codec name of a known non-Unicode key (`None` otherwise).

### `fontpixel.compat.bdfparser.encoding.cp2char(cp: 'int', charset: 'str' = 'iso10646', gl: 'bool | None' = None) -> 'str | None'`

*function* -- Codepoint in a charset -> character; `None` if not representable.

### `fontpixel.compat.bdfparser.encoding.gb18030_ranges() -> 'list[tuple[int, int, int]]'`

*function*

The 4-byte GB18030 codes as runs `(index, codepoint, length)`, where for a
code `b0 b1 b2 b3`:
`index = (((b0 - 0x81) * 10 + (b1 - 0x30)) * 126 + (b2 - 0x81)) * 10 + (b3 - 0x30)`.

### `fontpixel.compat.bdfparser.encoding.is_unicode_charset(key: 'str') -> 'bool'`

*function* -- Whether a canonical key denotes Unicode identity (UTF prefixes included).

### `fontpixel.compat.bdfparser.encoding.sanitize_charset(registry: 'object' = None, encoding: 'object' = None) -> 'str'`

*function*

Canonical charset key from `CHARSET_REGISTRY` / `CHARSET_ENCODING` values
(`'iso10646'` when both are absent).

## fontpixel.compat.bdfparser.errors

Warning and exception classes of the bdfparser-compatible API.

bdfparser raises built-in exceptions (`ValueError`, `KeyError`, `OSError`, ...)
plus `BDFParseError` / `PCFError`. Errors coming from the Rust core are
translated by `_translate`: the raised class derives from both the bdfparser
class and the matching `fontpixel` exception (so `except ValueError` and
`except fontpixel.InvalidInputError` both work) and keeps the structured
attributes (`kind`, `resource`, `limit`, `line`, `report`, ...).

### `fontpixel.compat.bdfparser.errors.BDFParseError`

*class* -- Same class as `fontpixel.compat.bdfparser.BDFParseError`.

### `fontpixel.compat.bdfparser.errors.BDFParserWarning`

*class* -- Same class as `fontpixel.compat.bdfparser.BDFParserWarning`.

## fontpixel.compat.bdfparser.font

`Font` of the bdfparser-compatible API (handle over the Rust compat font).

The font data stays in the Rust model (`fontpixel::compat::bdfparser::Font`).
`headers`, `props`, `glyphs` and `unencoded` are live views: reading them
projects the current model, writing through them edits it in place (glyph
handles stay attached). Values read from them are fresh copies (editing a
returned list does not change the font, except for the 17-slot meta lists of
`font.glyphs[cp]` and `font.unencoded[i]['meta']`, whose item assignment is
written back). Warnings collected by the Rust model are re-emitted as
`BDFParserWarning`s through the `warnings` module after each call.

### `fontpixel.compat.bdfparser.font.Font`

*class* -- Same class as `fontpixel.compat.bdfparser.Font`.

## fontpixel.compat.bdfparser.glyph

`Glyph` of the bdfparser-compatible API (handle over the Rust compat glyph).

A glyph obtained from a font (`glyphbycp`, `glyph`, `iterglyphs`, `newglyph`,
or passed to `addglyph`) is *attached*: every editing method writes the updated
meta back into the font's native model immediately. A glyph constructed
directly, or a `clone()`, is detached.

### `fontpixel.compat.bdfparser.glyph.Glyph`

*class* -- Same class as `fontpixel.compat.bdfparser.Glyph`.

### `fontpixel.compat.bdfparser.glyph.META_TITLES: tuple[str, ...]`

*constant*

### `fontpixel.compat.bdfparser.glyph.defaultglyphname(cp: int, charset_is_unicode: bool = ...) -> str`

*function* -- `defaultglyphname(cp, charset_is_unicode=True)`: `uniXXXX`, `uXXXXX` or `charN`.

## fontpixel.compat.bdfparser.outline

Bitmap outlines of the bdfparser-compatible API (SPEC-v3 §7.1, §7.2, §7.4).

`bitmap_contours` and `rasterize` run the Rust SPEC outline code. A contour is
a list of `(x, y, on_curve)` points in font units, y up.

### `fontpixel.compat.bdfparser.outline.Contour`

*type alias* -- `Contour = list[tuple[float, float, bool]]`

### `fontpixel.compat.bdfparser.outline.Point`

*type alias* -- `Point = tuple[float, float, bool]`

### `fontpixel.compat.bdfparser.outline.bitmap_contours(bindata: 'Sequence[str]', shape: 'str' = 'square', dotsize: 'float' = 1.0, ppu: 'int' = 1, xoff: 'int' = 0, yoff: 'int' = 0) -> 'list[Contour]'`

*function*

Convert bitmap rows (top row first, any non-`'0'` pixel is ink) to
TrueType-style contours: `shape` `'square'` (merged outline when
`dotsize == 1`) or `'circle'`; `ppu` font units per pixel; `(xoff, yoff)`
the bottom-left pixel position.

### `fontpixel.compat.bdfparser.outline.rasterize(contours: 'Iterable[Sequence[tuple[float, float, bool]]]', ppu: 'float', xmin_px: 'int', ymin_px: 'int', w_px: 'int', h_px: 'int') -> 'list[str]'`

*function*

Rasterize contours (nonzero winding, pixel centres, 16 chords per quadratic
curve) into `h_px` rows of `w_px` pixels whose bottom-left pixel is at
`(xmin_px, ymin_px)`.

## fontpixel.compat.bdfparser.pcf

PCF input/output of the bdfparser-compatible API (SPEC-v3 §6).

Reading and writing use the native, bounded PCF codec. With default options the
output is byte-identical to `bdftopcf` run on the same BDF.

### `fontpixel.compat.bdfparser.pcf.PCFError(BDFParseError)`

*exception*

Raised for malformed PCF data or fonts that cannot be written as PCF.
Subclass of `BDFParseError` (itself a `ValueError`).

### `fontpixel.compat.bdfparser.pcf.read_pcf(data: 'bytes | bytearray | memoryview') -> 'Font'`

*function* -- Parse PCF (optionally gzip-compressed) bytes into a `Font`; `PCFError` on malformed input.

### `fontpixel.compat.bdfparser.pcf.write_pcf(font: 'Font', *, byteorder: 'str' = 'msb', bitorder: 'str' = 'msb', glyphpad: 'int' = 4, scanunit: 'int' = 1) -> 'bytes'`

*function*

Convert a font to PCF bytes. `byteorder`/`bitorder`: `'msb'` or `'lsb'`
(bdftopcf -M/-L, -m/-l); `glyphpad`: 1, 2, 4 or 8 (-p); `scanunit`: 1, 2 or
4 (-u).

## fontpixel.compat.bdfparser.ttf

Pixel TrueType output/input of the bdfparser-compatible API (SPEC-v3 §8, §8.1).

Both directions run the Rust compatibility writer/reader; output is
deterministic and byte-identical to bdfparser's.

### `fontpixel.compat.bdfparser.ttf.read_ttf(data: 'bytes | bytearray | memoryview', pixelsize: 'int | None' = None) -> 'Font'`

*function*

Read a TrueType (`glyf`) font. Fonts written by `write_ttf` with
`metadata=True` are restored losslessly; others are rasterized at
`pixelsize` pixels per em (required then).

### `fontpixel.compat.bdfparser.ttf.write_ttf(font: 'Font', *, shape: 'str' = 'square', dotsize: 'float' = 1.0, ppu: 'int' = 64, metadata: 'bool' = True, timestamp: 'int' = 0) -> 'bytes'`

*function*

Convert a font to a TrueType font with square or round pixel dots.

:param shape: `'square'` or `'circle'` dots.
:param dotsize: dot size relative to a pixel, `(0, 1.5]`.
:param ppu: font units per pixel (even integer >= 2).
:param metadata: embed the private `BDFP` table (lossless `read_ttf` round trip).
:param timestamp: Unix seconds for `head.created` / `head.modified`.

## fontpixel.formats

Per-codec namespaces (`fontpixel.formats.<module>`) and typed option helpers.

### `fontpixel.formats.CATALOGUE: list[FormatInfo]`

*constant*

### `fontpixel.formats.MODULES: list[str]`

*constant*

### `fontpixel.formats.__doc__: str`

*constant*

### `fontpixel.formats.configurable_formats() -> dict[str, list[str]]`

*function*

Format IDs whose registry readers / writers take typed options:
`{"read": [...], "write": [...]}`.

### `fontpixel.formats.normalize(type_name: str, value: Mapping[str, Any] | str | None = ...) -> Any`

*function*

Validate `value` as the Rust type `type_name` (a path such as
`"formats::fzx::FzxWriteOptions"` or `"resources::ResourceLimits"`) and
return its serialized form. `value=None` normalizes `{}`, giving the
documented defaults of option structs. Unknown keys, wrong types, unknown
enum names and out-of-range integers raise `ValueError`.

### `fontpixel.formats.option_types() -> list[str]`

*function* -- Every type name `normalize` accepts.

## fontpixel.formats.amiga

Direct codec functions of `fontpixel::formats::amiga`.

### `fontpixel.formats.amiga.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.amiga.__doc__: str`

*constant*

### `fontpixel.formats.amiga.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.amiga.read(data: ReadInput | None = ..., options: AmigaReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.amiga.write(fonts: FontSet | Font, options: AmigaWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.bbc

Direct codec functions of `fontpixel::formats::bbc`.

### `fontpixel.formats.bbc.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.bbc.__doc__: str`

*constant*

### `fontpixel.formats.bbc.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.bbc.read(data: ReadInput | None = ..., options: NativeReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.bbc.write(fonts: FontSet | Font, options: W5a2CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.bdf

Direct codec functions of `fontpixel::formats::bdf`.

### `fontpixel.formats.bdf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.bdf.__doc__: str`

*constant*

### `fontpixel.formats.bdf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.bdf.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.bdf.source_rows(glyph: Glyph) -> list[str] | None`

*function*

Original stripped hex rows of a glyph read from BDF/PCF source, or `None`
when the glyph has no source provenance (`x11::source_rows`).

### `fontpixel.formats.bdf.validate_bitmap(glyph: Glyph) -> None`

*function*

Reject invalid source hex with the exact glyph/row error
(`x11::validate_bitmap`).

### `fontpixel.formats.bdf.write(fonts: FontSet | Font, options: BdfWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.beos

Direct codec functions of `fontpixel::formats::beos`.

### `fontpixel.formats.beos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.beos.__doc__: str`

*constant*

### `fontpixel.formats.beos.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.beos.read(data: ReadInput | None = ..., options: BeosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.beos.write(fonts: FontSet | Font, options: BeosWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.bmfont

Direct codec functions of `fontpixel::formats::bmfont`.

### `fontpixel.formats.bmfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.bmfont.__doc__: str`

*constant*

### `fontpixel.formats.bmfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.bmfont.read(data: ReadInput | None = ..., options: BmfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[Font, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.bmfont.write(fonts: FontSet | Font, options: BmfontWriteOptions | None = ..., *, primary_name: str | None = ...) -> Written`

*function*

Encode with this module's write-options dict into a bundle whose
entry point is `primary_name` (default `font.<first extension>`).
Returns a `Written`.

## fontpixel.formats.c

Direct codec functions of `fontpixel::formats::c`.

### `fontpixel.formats.c.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.c.__doc__: str`

*constant*

### `fontpixel.formats.c.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.c.read(data: ReadInput | None = ..., options: CReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode through the built-in registry's reader for this format
with `options` (a read-options dict) applied. Returns
`(FontSet, report)`.

### `fontpixel.formats.c.write(fonts: FontSet | Font, options: CWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode through the built-in registry's writer for this format with
`options` (a write-options dict) applied. Returns a `Written`.

## fontpixel.formats.catalyst

Direct codec functions of `fontpixel::formats::catalyst`.

### `fontpixel.formats.catalyst.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.catalyst.__doc__: str`

*constant*

### `fontpixel.formats.catalyst.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.catalyst.read(data: ReadInput | None = ..., options: CatalystReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.catalyst.write(fonts: FontSet | Font, options: CatalystWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.chiwriter

Direct codec functions of `fontpixel::formats::chiwriter`.

### `fontpixel.formats.chiwriter.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.chiwriter.__doc__: str`

*constant*

### `fontpixel.formats.chiwriter.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.chiwriter.read(data: ReadInput | None = ..., options: ChiwriterReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.chiwriter.write(fonts: FontSet | Font, options: ChiwriterWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.comfont

Direct codec functions of `fontpixel::formats::comfont`.

### `fontpixel.formats.comfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.comfont.__doc__: str`

*constant*

### `fontpixel.formats.comfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.comfont.read(data: ReadInput | None = ..., options: ComfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.comfont.write(fonts: FontSet | Font, options: ComfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.consoleet

Direct codec functions of `fontpixel::formats::consoleet`.

### `fontpixel.formats.consoleet.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.consoleet.__doc__: str`

*constant*

### `fontpixel.formats.consoleet.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.consoleet.read(data: ReadInput | None = ..., options: ConsoleetReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.consoleet.write(fonts: FontSet | Font, options: ConsoleetWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.cpi

Direct codec functions of `fontpixel::formats::cpi`.

### `fontpixel.formats.cpi.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.cpi.__doc__: str`

*constant*

### `fontpixel.formats.cpi.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.cpi.read(data: Buffer | Sequence[int], options: CpiReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.cpi.write(fonts: FontSet | Font, options: CpiWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.cybiko

Direct codec functions of `fontpixel::formats::cybiko`.

### `fontpixel.formats.cybiko.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.cybiko.__doc__: str`

*constant*

### `fontpixel.formats.cybiko.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.cybiko.read(data: ReadInput | None = ..., options: CybikoReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.cybiko.write(fonts: FontSet | Font, options: CybikoWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.daisy

Direct codec functions of `fontpixel::formats::daisy`.

### `fontpixel.formats.daisy.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.daisy.__doc__: str`

*constant*

### `fontpixel.formats.daisy.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.daisy.read(data: ReadInput | None = ..., options: DaisyReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.daisy.write(fonts: FontSet | Font, options: DaisyWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.dashen

Direct codec functions of `fontpixel::formats::dashen`.

### `fontpixel.formats.dashen.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.dashen.__doc__: str`

*constant*

### `fontpixel.formats.dashen.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.dashen.read(data: ReadInput | None = ..., options: DashenReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.dashen.write(fonts: FontSet | Font, options: DashenWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.dosstart

Direct codec functions of `fontpixel::formats::dosstart`.

### `fontpixel.formats.dosstart.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.dosstart.__doc__: str`

*constant*

### `fontpixel.formats.dosstart.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.dosstart.read(data: ReadInput | None = ..., options: DosstartReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.dosstart.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.draw

Direct codec functions of `fontpixel::formats::draw`.

### `fontpixel.formats.draw.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.draw.__doc__: str`

*constant*

### `fontpixel.formats.draw.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.draw.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.draw.write(fonts: FontSet | Font, options: DrawWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.drcs

Direct codec functions of `fontpixel::formats::drcs`.

### `fontpixel.formats.drcs.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.drcs.__doc__: str`

*constant*

### `fontpixel.formats.drcs.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.drcs.read(data: Buffer | Sequence[int], options: DrcsReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.drcs.write(fonts: FontSet | Font, options: DrcsWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.drhalo

Direct codec functions of `fontpixel::formats::drhalo`.

### `fontpixel.formats.drhalo.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.drhalo.__doc__: str`

*constant*

### `fontpixel.formats.drhalo.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.drhalo.read(data: ReadInput | None = ..., options: DrhaloReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.drhalo.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.edwin

Direct codec functions of `fontpixel::formats::edwin`.

### `fontpixel.formats.edwin.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.edwin.__doc__: str`

*constant*

### `fontpixel.formats.edwin.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.edwin.read(data: ReadInput | None = ..., options: EdwinReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.edwin.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.embedded

Embedded bitmap sfnt codecs (`fontpixel::formats::embedded`): otb, bdat, color.

### `fontpixel.formats.embedded.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.embedded.__doc__: str`

*constant*

### `fontpixel.formats.embedded.codec(kind: BitmapKind) -> EmbeddedCodec`

*function* -- The default codec of `kind` as a dict (`EmbeddedCodec::new(kind)`).

### `fontpixel.formats.embedded.detect(data: Buffer | Sequence[int], kind: BitmapKind, *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function* -- Run the embedded-bitmap detector of `kind` (`EmbeddedCodec::new(kind)`).

### `fontpixel.formats.embedded.metadata_retained_bytes(options: EmbeddedMetadataOptions, maximum: int = ...) -> int`

*function*

Retained bytes of an `EmbeddedMetadataOptions` dict's caller-owned
configuration, bounded by `maximum` (`EmbeddedMetadataOptions::retained_bytes`).

### `fontpixel.formats.embedded.read(data: Buffer | Sequence[int], kind: BitmapKind, options: EmbeddedReadOptions | None = ...) -> tuple[FontSet | Font, Report]`

*function*

Decode a standalone sfnt into bitmap strikes (`embedded::read`). `kind` is
`"open_type"` (EBDT/EBLC), `"apple"` (bdat/bloc) or `"color"` (CBDT/sbix);
`options` is an `EmbeddedReadOptions` dict. Returns `(FontSet, report)`.

### `fontpixel.formats.embedded.validate_metadata(options: EmbeddedMetadataOptions, kind: BitmapKind) -> None`

*function*

Validate an `EmbeddedMetadataOptions` dict for `kind`
(`EmbeddedMetadataOptions::validate`); raises `InvalidInputError`.

### `fontpixel.formats.embedded.write(fonts: FontSet | Font, kind: BitmapKind, options: EmbeddedWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Write strikes as a bitmap-only sfnt (`embedded::write`). `options` is an
`EmbeddedWriteOptions` dict. Returns `(bytes, report)`.

### `fontpixel.formats.embedded.write_color(fonts: FontSet | Font, options: ColorWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Write coverage as CBDT/CBLC or sbix color bitmaps (`embedded::write_color`).
`options` is a `ColorWriteOptions` dict. Returns `(bytes, report)`.

## fontpixel.formats.fbit

Direct codec functions of `fontpixel::formats::fbit`.

### `fontpixel.formats.fbit.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.fbit.__doc__: str`

*constant*

### `fontpixel.formats.fbit.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.fbit.read(data: Buffer | Sequence[int], options: FbitReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.fbit.read_context(data: ReadInput | None = ..., options: FbitReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet | Font, Report]`

*function*

Decode FONTBIT through a context with explicitly scoped data/resource
forks (`fbit::read_context`). Returns `(FontSet, report)`.

### `fontpixel.formats.fbit.write(fonts: FontSet | Font, options: FbitWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

### `fontpixel.formats.fbit.write_bundle(fonts: FontSet | Font, options: FbitWriteOptions | None = ..., *, primary_name: str | None = ...) -> Written`

*function*

Emit every FONTBIT fork as a bundle (`fbit::write_bundle`). Returns a
`Written`.

## fontpixel.formats.figlet

Direct codec functions of `fontpixel::formats::figlet`.

### `fontpixel.formats.figlet.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.figlet.__doc__: str`

*constant*

### `fontpixel.formats.figlet.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.figlet.read(data: ReadInput | None = ..., options: FigletReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.figlet.write(fonts: FontSet | Font, options: FigletWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.fnt

Direct codec functions of `fontpixel::formats::fnt`.

### `fontpixel.formats.fnt.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.fnt.__doc__: str`

*constant*

### `fontpixel.formats.fnt.charset_name(id: int) -> str | None`

*function*

Exact code-page name of a Windows charset byte, or `None` for OEM, symbol,
DEFAULT and unknown identifiers (`fnt::charset_name`).

### `fontpixel.formats.fnt.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.fnt.read(data: Buffer | Sequence[int], options: FntReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.fnt.read_default(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[FontSet | Font, Report]`

*function*

Decode FNT bytes with default charset interpretation
(`fnt::read_default`). Returns `(Font, report)`.

### `fontpixel.formats.fnt.write(fonts: FontSet | Font, options: FntWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.fon

Direct codec functions of `fontpixel::formats::fon`.

### `fontpixel.formats.fon.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.fon.__doc__: str`

*constant*

### `fontpixel.formats.fon.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.fon.read(data: Buffer | Sequence[int], options: FntReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.fon.write(fonts: FontSet | Font, options: FntWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.fontx2

Direct codec functions of `fontpixel::formats::fontx2`.

### `fontpixel.formats.fontx2.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.fontx2.__doc__: str`

*constant*

### `fontpixel.formats.fontx2.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.fontx2.read(data: Buffer | Sequence[int], options: Fontx2ReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.fontx2.write(fonts: FontSet | Font, options: Fontx2WriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.fzx

Direct codec functions of `fontpixel::formats::fzx`.

### `fontpixel.formats.fzx.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.fzx.__doc__: str`

*constant*

### `fontpixel.formats.fzx.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.fzx.read(data: ReadInput | None = ..., options: FzxReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.fzx.write(fonts: FontSet | Font, options: FzxWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.gdr

Direct codec functions of `fontpixel::formats::gdr`.

### `fontpixel.formats.gdr.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.gdr.__doc__: str`

*constant*

### `fontpixel.formats.gdr.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.gdr.read(data: ReadInput | None = ..., options: GdrReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.gdr.write(fonts: FontSet | Font, options: GdrWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.gem

Direct codec functions of `fontpixel::formats::gem`.

### `fontpixel.formats.gem.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.gem.__doc__: str`

*constant*

### `fontpixel.formats.gem.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.gem.read(data: ReadInput | None = ..., options: GemReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.gem.write(fonts: FontSet | Font, options: GemWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.geos

Direct codec functions of `fontpixel::formats::geos`.

### `fontpixel.formats.geos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.geos.__doc__: str`

*constant*

### `fontpixel.formats.geos.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.geos.read(data: ReadInput | None = ..., options: GeosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.geos.write(fonts: FontSet | Font, options: GeosWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.gf

Direct codec functions of `fontpixel::formats::gf`.

### `fontpixel.formats.gf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.gf.__doc__: str`

*constant*

### `fontpixel.formats.gf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.gf.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.gf.write(fonts: FontSet | Font, options: TexWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.gpi

Direct codec functions of `fontpixel::formats::gpi`.

### `fontpixel.formats.gpi.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.gpi.__doc__: str`

*constant*

### `fontpixel.formats.gpi.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.gpi.read(data: ReadInput | None = ..., options: GpiReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.gpi.write(fonts: FontSet | Font, options: GpiWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.grasp

Direct codec functions of `fontpixel::formats::grasp`.

### `fontpixel.formats.grasp.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.grasp.__doc__: str`

*constant*

### `fontpixel.formats.grasp.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.grasp.read(data: ReadInput | None = ..., options: NativeReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.grasp.write(fonts: FontSet | Font, options: W5a2CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.hanfont

Direct codec functions of `fontpixel::formats::hanfont`.

### `fontpixel.formats.hanfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hanfont.__doc__: str`

*constant*

### `fontpixel.formats.hanfont.component_slots(codepoint: int) -> tuple[int, int, int | None]`

*function*

The `(initial, medial, final)` component slots of a modern Hangul
syllable; `final` is `None` when absent (`hanfont::component_slots`).

### `fontpixel.formats.hanfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hanfont.read(data: Buffer | Sequence[int], options: HanfontReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.hanfont.write(fonts: FontSet | Font, options: HanfontWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.hbf

Direct codec functions of `fontpixel::formats::hbf`.

### `fontpixel.formats.hbf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hbf.__doc__: str`

*constant*

### `fontpixel.formats.hbf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hbf.read(data: ReadInput | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[Font, Report]`

*function*

Decode one input through this module's context reader
(`resources` supplies sidecars). Returns `(model, report)`.

### `fontpixel.formats.hbf.write(fonts: FontSet | Font, options: HbfWriteOptions | None = ..., *, primary_name: str | None = ...) -> Written`

*function*

Encode with this module's write-options dict into a bundle whose
entry point is `primary_name` (default `font.<first extension>`).
Returns a `Written`.

## fontpixel.formats.hex

Direct codec functions of `fontpixel::formats::hex`.

### `fontpixel.formats.hex.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hex.__doc__: str`

*constant*

### `fontpixel.formats.hex.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hex.read(data: Buffer | Sequence[int], options: HexReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.hex.write(fonts: FontSet | Font, options: HexWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.hmzk

Direct codec functions of `fontpixel::formats::hmzk`.

### `fontpixel.formats.hmzk.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hmzk.__doc__: str`

*constant*

### `fontpixel.formats.hmzk.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hmzk.read(data: ReadInput | None = ..., options: HmzkReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.hmzk.write(fonts: FontSet | Font, options: HmzkWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.hppcl

Direct codec functions of `fontpixel::formats::hppcl`.

### `fontpixel.formats.hppcl.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hppcl.__doc__: str`

*constant*

### `fontpixel.formats.hppcl.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hppcl.read(data: ReadInput | None = ..., options: HppclReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.hppcl.write(fonts: FontSet | Font, options: HppclWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.hrcg

Direct codec functions of `fontpixel::formats::hrcg`.

### `fontpixel.formats.hrcg.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hrcg.__doc__: str`

*constant*

### `fontpixel.formats.hrcg.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hrcg.read(data: ReadInput | None = ..., options: NativeReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.hrcg.write(fonts: FontSet | Font, options: W5a2CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.hzk

Direct codec functions of `fontpixel::formats::hzk`.

### `fontpixel.formats.hzk.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.hzk.__doc__: str`

*constant*

### `fontpixel.formats.hzk.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.hzk.preset_geometry(preset: Preset) -> Geometry`

*function* -- The `Geometry` dict of an HZK/ASC preset (`hzk::Preset::geometry`).

### `fontpixel.formats.hzk.preset_name(preset: Preset) -> str`

*function* -- The CLI spelling of an HZK/ASC preset (`hzk::Preset::name`).

### `fontpixel.formats.hzk.presets() -> list[str]`

*function* -- Every HZK/ASC preset name in stable order (`hzk::Preset::ALL`).

### `fontpixel.formats.hzk.read(data: Buffer | Sequence[int], options: HzkReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.hzk.write(fonts: FontSet | Font, options: HzkWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.iigs

Direct codec functions of `fontpixel::formats::iigs`.

### `fontpixel.formats.iigs.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.iigs.__doc__: str`

*constant*

### `fontpixel.formats.iigs.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.iigs.read(data: Buffer | Sequence[int], options: IigsReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.iigs.write(fonts: FontSet | Font, options: IigsWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.image

Direct codec functions of `fontpixel::formats::image`.

### `fontpixel.formats.image.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.image.__doc__: str`

*constant*

### `fontpixel.formats.image.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.image.read(data: ReadInput | None = ..., options: ImageReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode through the built-in registry's reader for this format
with `options` (a read-options dict) applied. Returns
`(FontSet, report)`.

### `fontpixel.formats.image.write(fonts: FontSet | Font, options: ImageWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode through the built-in registry's writer for this format with
`options` (a write-options dict) applied. Returns a `Written`.

## fontpixel.formats.kbits

Direct codec functions of `fontpixel::formats::kbits`.

### `fontpixel.formats.kbits.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.kbits.__doc__: str`

*constant*

### `fontpixel.formats.kbits.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.kbits.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.kbits.write(fonts: FontSet | Font, options: KbitsWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.kbitx

Direct codec functions of `fontpixel::formats::kbitx`.

### `fontpixel.formats.kbitx.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.kbitx.__doc__: str`

*constant*

### `fontpixel.formats.kbitx.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.kbitx.read(data: Buffer | Sequence[int], options: KbitxReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.kbitx.write(fonts: FontSet | Font, options: KbitxWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.lisa

Direct codec functions of `fontpixel::formats::lisa`.

### `fontpixel.formats.lisa.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.lisa.__doc__: str`

*constant*

### `fontpixel.formats.lisa.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.lisa.read(data: Buffer | Sequence[int], options: LisaReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.lisa.write(fonts: FontSet | Font, options: LisaWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.mgtk

Direct codec functions of `fontpixel::formats::mgtk`.

### `fontpixel.formats.mgtk.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.mgtk.__doc__: str`

*constant*

### `fontpixel.formats.mgtk.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.mgtk.read(data: Buffer | Sequence[int], options: MgtkReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.mgtk.write(fonts: FontSet | Font, options: MgtkWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.mkwinfont

Direct codec functions of `fontpixel::formats::mkwinfont`.

### `fontpixel.formats.mkwinfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.mkwinfont.__doc__: str`

*constant*

### `fontpixel.formats.mkwinfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.mkwinfont.read(data: ReadInput | None = ..., options: MkwinfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.mkwinfont.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.nfnt

Direct codec functions of `fontpixel::formats::nfnt`.

### `fontpixel.formats.nfnt.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.nfnt.__doc__: str`

*constant*

### `fontpixel.formats.nfnt.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.nfnt.read(data: Buffer | Sequence[int], options: NfntReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.nfnt.write(fonts: FontSet | Font, options: NfntWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

### `fontpixel.formats.nfnt.write_bundle(fonts: FontSet | Font, options: NfntWriteOptions | None = ..., *, primary_name: str | None = ...) -> Written`

*function*

Encode every NFNT asset as a bundle (`nfnt::write_bundle`). Returns a
`Written`.

## fontpixel.formats.oberon

Direct codec functions of `fontpixel::formats::oberon`.

### `fontpixel.formats.oberon.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.oberon.__doc__: str`

*constant*

### `fontpixel.formats.oberon.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.oberon.read(data: ReadInput | None = ..., options: OberonReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.oberon.write(fonts: FontSet | Font, options: OberonWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.palm

Direct codec functions of `fontpixel::formats::palm`.

### `fontpixel.formats.palm.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.palm.__doc__: str`

*constant*

### `fontpixel.formats.palm.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.palm.read(data: ReadInput | None = ..., options: PalmReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.palm.write(fonts: FontSet | Font, options: PalmWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pbf

Direct codec functions of `fontpixel::formats::pbf`.

### `fontpixel.formats.pbf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pbf.__doc__: str`

*constant*

### `fontpixel.formats.pbf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pbf.read(data: Buffer | Sequence[int], options: PbfReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.pbf.write(fonts: FontSet | Font, options: PbfWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.pcf

Direct codec functions of `fontpixel::formats::pcf`.

### `fontpixel.formats.pcf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pcf.__doc__: str`

*constant*

### `fontpixel.formats.pcf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pcf.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.pcf.write(fonts: FontSet | Font, options: PcfWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.pcgeos

Direct codec functions of `fontpixel::formats::pcgeos`.

### `fontpixel.formats.pcgeos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pcgeos.__doc__: str`

*constant*

### `fontpixel.formats.pcgeos.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pcgeos.read(data: ReadInput | None = ..., options: PcgeosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.pcgeos.write(fonts: FontSet | Font, options: PcgeosWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pcr

Direct codec functions of `fontpixel::formats::pcr`.

### `fontpixel.formats.pcr.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pcr.__doc__: str`

*constant*

### `fontpixel.formats.pcr.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pcr.read(data: ReadInput | None = ..., options: PcrReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.pcr.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pf2

Direct codec functions of `fontpixel::formats::pf2`.

### `fontpixel.formats.pf2.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pf2.__doc__: str`

*constant*

### `fontpixel.formats.pf2.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pf2.read(data: Buffer | Sequence[int], options: Pf2ReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.pf2.write(fonts: FontSet | Font, options: Pf2WriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.pfr

Direct codec functions of `fontpixel::formats::pfr`.

### `fontpixel.formats.pfr.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pfr.__doc__: str`

*constant*

### `fontpixel.formats.pfr.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pfr.read(data: ReadInput | None = ..., options: PfrReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.pfr.write(fonts: FontSet | Font, options: PfrWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pilfont

Direct codec functions of `fontpixel::formats::pilfont`.

### `fontpixel.formats.pilfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pilfont.__doc__: str`

*constant*

### `fontpixel.formats.pilfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pilfont.read(data: ReadInput | None = ..., options: PilfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.pilfont.write(fonts: FontSet | Font, options: PilfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pk

Direct codec functions of `fontpixel::formats::pk`.

### `fontpixel.formats.pk.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pk.__doc__: str`

*constant*

### `fontpixel.formats.pk.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pk.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.pk.write(fonts: FontSet | Font, options: TexWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.plan9

Direct codec functions of `fontpixel::formats::plan9`.

### `fontpixel.formats.plan9.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.plan9.__doc__: str`

*constant*

### `fontpixel.formats.plan9.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.plan9.read(data: ReadInput | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[Font, Report]`

*function*

Decode one input through this module's context reader
(`resources` supplies sidecars). Returns `(model, report)`.

### `fontpixel.formats.plan9.write(fonts: FontSet | Font, options: Plan9WriteOptions | None = ..., *, primary_name: str | None = ...) -> Written`

*function*

Encode with this module's write-options dict into a bundle whose
entry point is `primary_name` (default `font.<first extension>`).
Returns a `Written`.

## fontpixel.formats.playdate

Direct codec functions of `fontpixel::formats::playdate`.

### `fontpixel.formats.playdate.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.playdate.__doc__: str`

*constant*

### `fontpixel.formats.playdate.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.playdate.read(data: ReadInput | None = ..., options: PlaydateReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.playdate.write(fonts: FontSet | Font, options: PlaydateWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.plus3dos

Direct codec functions of `fontpixel::formats::plus3dos`.

### `fontpixel.formats.plus3dos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.plus3dos.__doc__: str`

*constant*

### `fontpixel.formats.plus3dos.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.plus3dos.read(data: ReadInput | None = ..., options: Plus3dosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.plus3dos.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.polyprint

Direct codec functions of `fontpixel::formats::polyprint`.

### `fontpixel.formats.polyprint.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.polyprint.__doc__: str`

*constant*

### `fontpixel.formats.polyprint.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.polyprint.read(data: ReadInput | None = ..., options: PolyprintReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.polyprint.write(fonts: FontSet | Font, options: PolyprintWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.prebuilt

Direct codec functions of `fontpixel::formats::prebuilt`.

### `fontpixel.formats.prebuilt.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.prebuilt.__doc__: str`

*constant*

### `fontpixel.formats.prebuilt.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.prebuilt.read(data: ReadInput | None = ..., options: PrebuiltReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.prebuilt.write(fonts: FontSet | Font, options: PrebuiltWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.printshop

Direct codec functions of `fontpixel::formats::printshop`.

### `fontpixel.formats.printshop.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.printshop.__doc__: str`

*constant*

### `fontpixel.formats.printshop.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.printshop.read(data: ReadInput | None = ..., options: PrintshopReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.printshop.write(fonts: FontSet | Font, options: PrintshopWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.psf

Direct codec functions of `fontpixel::formats::psf`.

### `fontpixel.formats.psf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.psf.__doc__: str`

*constant*

### `fontpixel.formats.psf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.psf.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[Font, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.psf.write(fonts: FontSet | Font, options: PsfWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.psf2txt

Direct codec functions of `fontpixel::formats::psf2txt`.

### `fontpixel.formats.psf2txt.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.psf2txt.__doc__: str`

*constant*

### `fontpixel.formats.psf2txt.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.psf2txt.read(data: ReadInput | None = ..., options: Psf2txtReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.psf2txt.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.pxl

Direct codec functions of `fontpixel::formats::pxl`.

### `fontpixel.formats.pxl.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.pxl.__doc__: str`

*constant*

### `fontpixel.formats.pxl.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.pxl.read(data: ReadInput | None = ..., options: PxlReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.pxl.write(fonts: FontSet | Font, options: PxlWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.qpf

Direct codec functions of `fontpixel::formats::qpf`.

### `fontpixel.formats.qpf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.qpf.__doc__: str`

*constant*

### `fontpixel.formats.qpf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.qpf.read(data: Buffer | Sequence[int], options: QpfReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.qpf.write(fonts: FontSet | Font, options: QpfWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.qpf2

Direct codec functions of `fontpixel::formats::qpf2`.

### `fontpixel.formats.qpf2.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.qpf2.__doc__: str`

*constant*

### `fontpixel.formats.qpf2.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.qpf2.read(data: Buffer | Sequence[int], options: Qpf2ReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.qpf2.write(fonts: FontSet | Font, options: Qpf2WriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.raw

Direct codec functions of `fontpixel::formats::raw`.

### `fontpixel.formats.raw.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.raw.__doc__: str`

*constant*

### `fontpixel.formats.raw.preset_layout(preset: RawPreset) -> RawLayout`

*function* -- The `RawLayout` dict of a named raw preset (`raw::RawPreset::layout`).

### `fontpixel.formats.raw.raw_layout(width: int, height: int) -> RawLayout`

*function*

The default `RawLayout` dict of a `width`×`height` cell
(`raw::RawLayout::new`).

### `fontpixel.formats.raw.read(data: Buffer | Sequence[int], options: RawReadOptions | None = ..., *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict under
`limits`. Returns `(model, report)`.

### `fontpixel.formats.raw.write(fonts: FontSet | Font, options: RawWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.riscos

Direct codec functions of `fontpixel::formats::riscos`.

### `fontpixel.formats.riscos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.riscos.__doc__: str`

*constant*

### `fontpixel.formats.riscos.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.riscos.read(data: ReadInput | None = ..., options: RiscosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.riscos.write(fonts: FontSet | Font, options: RiscosWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.rockbox

Direct codec functions of `fontpixel::formats::rockbox`.

### `fontpixel.formats.rockbox.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.rockbox.__doc__: str`

*constant*

### `fontpixel.formats.rockbox.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.rockbox.read(data: ReadInput | None = ..., options: RockboxReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.rockbox.write(fonts: FontSet | Font, options: RockboxWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.sbf

Direct codec functions of `fontpixel::formats::sbf`.

### `fontpixel.formats.sbf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.sbf.__doc__: str`

*constant*

### `fontpixel.formats.sbf.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.sbf.read(data: ReadInput | None = ..., options: SbfReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.sbf.write(fonts: FontSet | Font, options: SbfWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.sfd

Direct codec functions of `fontpixel::formats::sfd`.

### `fontpixel.formats.sfd.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.sfd.__doc__: str`

*constant*

### `fontpixel.formats.sfd.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.sfd.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.sfd.write(fonts: FontSet | Font, options: SfdWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.sfont

Direct codec functions of `fontpixel::formats::sfont`.

### `fontpixel.formats.sfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.sfont.__doc__: str`

*constant*

### `fontpixel.formats.sfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.sfont.read(data: ReadInput | None = ..., options: SfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.sfont.write(fonts: FontSet | Font, options: SfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.signum

Direct codec functions of `fontpixel::formats::signum`.

### `fontpixel.formats.signum.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.signum.__doc__: str`

*constant*

### `fontpixel.formats.signum.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.signum.read(data: ReadInput | None = ..., options: SignumReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.signum.write(fonts: FontSet | Font, options: SignumWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.snf

Direct codec functions of `fontpixel::formats::snf`.

### `fontpixel.formats.snf.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.snf.__doc__: str`

*constant*

### `fontpixel.formats.snf.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.snf.read(data: ReadInput | None = ..., options: SnfReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.snf.write(fonts: FontSet | Font, options: SnfWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.ssfn

Direct codec functions of `fontpixel::formats::ssfn`.

### `fontpixel.formats.ssfn.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.ssfn.__doc__: str`

*constant*

### `fontpixel.formats.ssfn.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.ssfn.read(data: ReadInput | None = ..., options: SsfnReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.ssfn.write(fonts: FontSet | Font, options: SsfnWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.svg

Direct codec functions of `fontpixel::formats::svg`.

### `fontpixel.formats.svg.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.svg.__doc__: str`

*constant*

### `fontpixel.formats.svg.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.svg.glyph_image(glyph: Glyph, options: SvgImageOptions | None = ..., gray_threshold: int | None = ...) -> str`

*function*

One glyph's bitmap rectangle as SVG (`svg::glyph_image`); Gray8 glyphs
need `gray_threshold`.

### `fontpixel.formats.svg.image(bitmap: BitmapLike, options: SvgImageOptions | None = ...) -> str`

*function*

A standalone SVG image of a Mono bitmap (`svg::image`). `options` is a
`svg::ImageOptions` dict.

### `fontpixel.formats.svg.path_data(bitmap: BitmapLike, origin: tuple[int, int], units_per_pixel: int, shape: Shape | None = ..., dot_size: float = ..., limits: OutlineLimits | None = ..., max_bytes: int = ...) -> str`

*function*

Deterministic upward-facing SVG path data of a Mono bitmap
(`svg::path_data`). `shape` is an `outline::Shape` name, `limits` an
`outline::Limits` dict.

### `fontpixel.formats.svg.read(data: Buffer | Sequence[int], options: SvgReadOptions | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes with this module's read-options dict
(limits are part of the options). Returns `(model, report)`.

### `fontpixel.formats.svg.write(fonts: FontSet | Font, options: SvgWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.symbos

Direct codec functions of `fontpixel::formats::symbos`.

### `fontpixel.formats.symbos.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.symbos.__doc__: str`

*constant*

### `fontpixel.formats.symbos.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.symbos.read(data: ReadInput | None = ..., options: SymbosReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.symbos.write(fonts: FontSet | Font, options: SymbosWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.tasprint

Direct codec functions of `fontpixel::formats::tasprint`.

### `fontpixel.formats.tasprint.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.tasprint.__doc__: str`

*constant*

### `fontpixel.formats.tasprint.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.tasprint.read(data: ReadInput | None = ..., options: TasprintReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.tasprint.write(fonts: FontSet | Font, options: TasprintWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.u8m

Direct codec functions of `fontpixel::formats::u8m`.

### `fontpixel.formats.u8m.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.u8m.__doc__: str`

*constant*

### `fontpixel.formats.u8m.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.u8m.read(data: ReadInput | None = ..., options: U8mReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.u8m.write(fonts: FontSet | Font, options: U8mWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.vector_raster

Outline rasterization and vectorization (`fontpixel::formats::vector_raster`).

### `fontpixel.formats.vector_raster.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.vector_raster.__doc__: str`

*constant*

### `fontpixel.formats.vector_raster.codec(format: str) -> VectorRasterCodecDict`

*function*

The default codec options of `format` (`vector_raster::Codec::new`):
`{"id", "read_options", "write_options"}`.

### `fontpixel.formats.vector_raster.detect(data: Buffer | Sequence[int], format: str = ..., *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function* -- Run the outline detector of `format` (`vector_raster::Codec::new(format)`).

### `fontpixel.formats.vector_raster.detect_native_ppem(data: Buffer | Sequence[int], limits: VectorRasterLimits | None = ...) -> int | None`

*function*

Prove a standalone sfnt's native integral pixel grid
(`vector_raster::detect_native_ppem`); `None` for a valid non-grid font.
`limits` is a `vector_raster::Limits` dict.

### `fontpixel.formats.vector_raster.read(data: Buffer | Sequence[int], options: VectorRasterOptions | None = ...) -> tuple[FontSet | Font, Report]`

*function*

Rasterize a standalone outline font (`vector_raster::read`). `options` is
a `vector_raster::Options` dict. Returns `(FontSet, report)`.

### `fontpixel.formats.vector_raster.write(fonts: FontSet | Font, format: str, options: VectorRasterWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Vectorize strikes as `format` (`vector_raster::write`). `options` is a
`vector_raster::WriteOptions` dict. Returns `(bytes, report)`.

### `fontpixel.formats.vector_raster.write_owned(fonts: FontSet | Font, format: str, options: VectorRasterWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

As `write`, but the model is handed over (`vector_raster::write_owned`):
a `FontSet` handle is left empty afterwards. Output and report are equal.

## fontpixel.formats.vfont

Direct codec functions of `fontpixel::formats::vfont`.

### `fontpixel.formats.vfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.vfont.__doc__: str`

*constant*

### `fontpixel.formats.vfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.vfont.read(data: ReadInput | None = ..., options: VfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.vfont.write(fonts: FontSet | Font, options: VfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.vlw

Direct codec functions of `fontpixel::formats::vlw`.

### `fontpixel.formats.vlw.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.vlw.__doc__: str`

*constant*

### `fontpixel.formats.vlw.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.vlw.read(data: ReadInput | None = ..., options: VlwReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.vlw.write(fonts: FontSet | Font, options: VlwWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.vtfont

Direct codec functions of `fontpixel::formats::vtfont`.

### `fontpixel.formats.vtfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.vtfont.__doc__: str`

*constant*

### `fontpixel.formats.vtfont.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.vtfont.read(data: ReadInput | None = ..., options: VtfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.vtfont.write(fonts: FontSet | Font, options: VtfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.writeon

Direct codec functions of `fontpixel::formats::writeon`.

### `fontpixel.formats.writeon.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.writeon.__doc__: str`

*constant*

### `fontpixel.formats.writeon.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.writeon.read(data: ReadInput | None = ..., options: WriteonReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.writeon.write(fonts: FontSet | Font, options: W5a1CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.wsfont

Direct codec functions of `fontpixel::formats::wsfont`.

### `fontpixel.formats.wsfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.wsfont.__doc__: str`

*constant*

### `fontpixel.formats.wsfont.detect(data: Buffer | Sequence[int], *, name: str | None = ..., limits: ResourceLimits | None = ...) -> Confidence`

*function*

Run this format's registry detector hook (gzip transport is
decoded first; `name` is passed as the filename hint). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.wsfont.read(data: ReadInput | None = ..., options: WsfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.wsfont.write(fonts: FontSet | Font, options: WsfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.wyse

Direct codec functions of `fontpixel::formats::wyse`.

### `fontpixel.formats.wyse.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.wyse.__doc__: str`

*constant*

### `fontpixel.formats.wyse.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.wyse.read(data: ReadInput | None = ..., options: NativeReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.wyse.write(fonts: FontSet | Font, options: W5a2CommonNativeWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.x11

X11 source-row helpers shared by BDF and PCF (`fontpixel::formats::x11`).

### `fontpixel.formats.x11.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.x11.__doc__: str`

*constant*

### `fontpixel.formats.x11.source_rows(glyph: Glyph) -> list[str] | None`

*function*

Original stripped hex rows of a glyph read from BDF/PCF source, or `None`
when the glyph has no source provenance (`x11::source_rows`).

### `fontpixel.formats.x11.validate_bitmap(glyph: Glyph) -> None`

*function*

Reject invalid source hex with the exact glyph/row error
(`x11::validate_bitmap`).

## fontpixel.formats.xbin

Direct codec functions of `fontpixel::formats::xbin`.

### `fontpixel.formats.xbin.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.xbin.__doc__: str`

*constant*

### `fontpixel.formats.xbin.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.xbin.read(data: ReadInput | None = ..., options: NativeReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.xbin.write(fonts: FontSet | Font, options: XbinWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.xerox

Direct codec functions of `fontpixel::formats::xerox`.

### `fontpixel.formats.xerox.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.xerox.__doc__: str`

*constant*

### `fontpixel.formats.xerox.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.xerox.read(data: ReadInput | None = ..., options: XeroxReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.xerox.write(fonts: FontSet | Font, options: XeroxWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.formats.yaff

Direct codec functions of `fontpixel::formats::yaff`.

### `fontpixel.formats.yaff.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.yaff.__doc__: str`

*constant*

### `fontpixel.formats.yaff.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.yaff.read(data: Buffer | Sequence[int], *, limits: ResourceLimits | None = ...) -> tuple[FontSet, Report]`

*function*

Decode standalone bytes under `limits` (a `ResourceLimits` dict).
Returns `(model, report)`.

### `fontpixel.formats.yaff.write(fonts: FontSet | Font, options: YaffWriteOptions | None = ...) -> tuple[bytes, Report]`

*function*

Encode with this module's write-options dict. Returns
`(bytes, report)`.

## fontpixel.formats.zapfont

Direct codec functions of `fontpixel::formats::zapfont`.

### `fontpixel.formats.zapfont.FORMAT_IDS: list[str]`

*constant*

### `fontpixel.formats.zapfont.__doc__: str`

*constant*

### `fontpixel.formats.zapfont.detect(data: Buffer | Sequence[int]) -> Confidence`

*function*

Structural detector of this format (no filename evidence). Returns
`"no_match"`, `"possible"` or `"certain"`.

### `fontpixel.formats.zapfont.read(data: ReadInput | None = ..., options: ZapfontReadOptions | None = ..., *, name: str | None = ..., resources: Resources | None = ..., limits: ResourceLimits | None = ..., directory: str | None = ...) -> tuple[FontSet, Report]`

*function*

Decode one input through this module's context reader. `options`
is the module's read-options dict; `resources` supplies sidecars;
`directory` names a directory entry point. Returns
`(model, report)`.

### `fontpixel.formats.zapfont.write(fonts: FontSet | Font, options: ZapfontWriteOptions | None = ..., *, primary_name: str | None = ..., strict: bool = ..., transport_limits: TransportLimits | None = ...) -> Written`

*function*

Encode a `FontSet` with this module's write-options dict.
`primary_name` defaults to `font.<first extension>`. Returns a
`Written` with every asset and the full report.

## fontpixel.merge

Merge selected glyphs from ordered font parts.

### `fontpixel.merge.Selection(expression: str) -> Selection`

*class*

A parsed Unicode selection (`fontpixel::merge::Selection`): a union of
ranges with exclusions applied last, e.g. `"U+4E00-9FFF,-U+4E01"` or
category names such as `"cjk"`.

#### `fontpixel.merge.Selection.contains(codepoint: int) -> bool`

*method* -- `Selection::contains`: whether `codepoint` is selected.

#### `fontpixel.merge.Selection.expression: str`

*property* -- `Selection::expression`: the original expression text.

#### `fontpixel.merge.Selection.parse(expression: str) -> Selection`

*static method* -- `Selection::parse`: parse a selection expression.

#### `fontpixel.merge.Selection.ranges() -> list[CodepointRange]`

*method* -- `Selection::ranges`: normalized inclusive ranges `[{start, end}]`.

#### `fontpixel.merge.Selection.scalar_count() -> int`

*method* -- `Selection::scalar_count`: number of selected Unicode scalars.

### `fontpixel.merge.defaults() -> MergeDefaults`

*function*

Default MergeOptions (with an empty `family`, which `merge` rejects) and
PartLicense dicts.

### `fontpixel.merge.geometric_width_as_str(value: GeometricWidth) -> str`

*function* -- `GeometricWidth::as_str`: the CLI/JSON spelling of a geometric width.

### `fontpixel.merge.merge(parts: Sequence[MergePartArgs], options: MergeOptions) -> MergeOutcome`

*function*

`merge::merge`: merge `parts` in priority order under `options`
(MergeOptions dict; `family` is required). Returns `{font, report}`.

### `fontpixel.merge.modification_as_str(value: ModificationPermission) -> str`

*function* -- `ModificationPermission::as_str`: the JSON spelling of a permission.

### `fontpixel.merge.report_to_json(report: MergeReport) -> str`

*function*

`MergeReport::to_json`: the deterministic JSON of a report dict, exactly
as the CLI prints it.

### `fontpixel.merge.spacing_as_str(value: MergeSpacing) -> str`

*function* -- `MergeSpacing::as_str`: the CLI/JSON spelling of a spacing value.

## fontpixel.ops

Every fontpixel command-line operation as an in-process call.

Each operation takes a request dict in the flat ``fontpixel_ops`` shape (keys
are the command-line argument ids in snake_case: ``inputs``, ``output``, ``to``,
``max_total_bytes``, ``otb_upm``, ...) and/or the same keys as keyword
arguments. Unknown keys, invalid choices, out-of-range numbers and violated
command-line rules (``each`` without ``to``, ``text`` together with ``all``,
...) raise :class:`fontpixel.InvalidInputError` with ``exit_code`` 2 and the
command-line parser's message.

Storage is chosen per call with ``files``:

* ``files=None`` (default) -- filesystem mode: request paths are real paths
  (``str`` or ``os.PathLike``), sidecars are discovered beside their primary
  file, sources are protected from being overwritten and every multi-output
  group is written transactionally, exactly as ``fontpixel`` does.
* ``files={"name.bdf": b"...", ...}`` or a :class:`fontpixel.ResourceSet` --
  memory mode: paths are keys into the named buffers (``bytes``, ``bytearray``
  or ``memoryview``); sidecars resolve beside their primary key and a key
  prefix acts as a directory. Nothing is read from or written to disk;
  ``result.outputs`` maps each prepared asset's key to its bytes and
  ``result.bundles`` each destination to its :class:`fontpixel.OutputBundle`.
* ``files=<resolver>`` -- memory mode over an object with ``entry(path)``
  (``None``, a file length or ``"directory"``), ``read(path) -> bytes`` and
  ``list(directory) -> list[str]``; an exception raised by a callback is
  re-raised from the operation.

Results (:class:`OperationResult`, :class:`BatchResult`) reproduce the command
line's standard output: ``result.json()`` is the ``--report json``/``--json``
document and ``result.text()`` the text output, byte for byte. Failures raise
the ``fontpixel`` exception classes with ``exit_code`` (the command-line exit
status), ``kind`` and, for strict-loss and reported errors, the full
``report``. The GIL is released while an operation runs, so calls from several
threads proceed in parallel.

:func:`merge`, :func:`convert` and :func:`vectorize` accept
``progress=callback``: the callback receives a :class:`fontpixel.types.Progress`
dict (``step`` ``"read"``, ``"merge"`` or ``"encode"``, ``done``, ``total``,
``item``, ``glyphs``, ``bytes``) after each step, on the calling thread with
the GIL held, before anything is written. Returning ``False`` (exactly) cancels
the operation with :class:`fontpixel.CancelledError` (``exit_code`` 1);
raising cancels it and re-raises that exception. Nothing is written or
returned after a cancellation, and results never depend on the callback.

Example::

    from fontpixel import ops
    result = ops.convert(inputs=["font.bdf"], output="font.pcf",
                         files={"font.bdf": open("font.bdf", "rb").read()})
    pcf = result.outputs["font.pcf"]

### `fontpixel.ops.BatchResult()`

*class* -- The result of a batch: the complete JSON document plus typed summaries.

#### `fontpixel.ops.BatchResult.bundles: dict[str, OutputBundle]`

*property*

Committed outputs as `{destination key: fontpixel.OutputBundle}`
(memory mode only).

#### `fontpixel.ops.BatchResult.document: dict[str, Any]`

*property* -- The parsed batch document.

#### `fontpixel.ops.BatchResult.exit_code: int`

*property* -- Aggregate exit code (precedence 2 > 1 > 3 > 0), as `fontpixel batch`.

#### `fontpixel.ops.BatchResult.jobs: int`

*property* -- Requested worker ceiling, capped by the task count.

#### `fontpixel.ops.BatchResult.json() -> str`

*method* -- The complete batch JSON document exactly as `fontpixel batch` prints it.

#### `fontpixel.ops.BatchResult.outputs: dict[str, bytes]`

*property* -- Committed outputs as `{storage key: bytes}` (memory mode only).

#### `fontpixel.ops.BatchResult.tasks: list[BatchTaskOutcome]`

*property*

Per-task outcomes in request order (dicts with `index`, `id`, `kind`,
`success`, `exit_code`, `committed`, `diagnostics_truncated`, `error`).

#### `fontpixel.ops.BatchResult.workers: int`

*property* -- Worker threads actually used.

### `fontpixel.ops.DEFAULT_MAX_PENDING_BYTES: int`

*constant*

### `fontpixel.ops.DEFAULT_MAX_REPORT_BYTES: int`

*constant*

### `fontpixel.ops.DEFAULT_MAX_TASK_REPORT_BYTES: int`

*constant*

### `fontpixel.ops.DEFAULT_MAX_WORKING_BYTES: int`

*constant*

### `fontpixel.ops.OperationResult()`

*class*

The result of one operation.

`json()` and `text()` reproduce the command line's standard output for the
JSON and text report styles; `document` is the parsed JSON document,
`summary` the typed response fields, `report` the operation's diagnostics
(or `None` when it has several, see `summary`), and `outputs` maps every
prepared asset's storage key to its bytes (memory mode only).

#### `fontpixel.ops.OperationResult.bundles: dict[str, OutputBundle]`

*property*

Every prepared output as `{destination key: fontpixel.OutputBundle}`
(memory mode; the bundle holds the primary asset and its sidecars or
directory members, with paths relative to the destination's parent).

#### `fontpixel.ops.OperationResult.destinations: list[str]`

*property* -- The requested entry-point destination of each prepared output.

#### `fontpixel.ops.OperationResult.document: dict[str, Any]`

*property* -- The parsed JSON document (a dict), equal to `json.loads(self.json())`.

#### `fontpixel.ops.OperationResult.exit_code: int`

*property*

Command-line exit status of a completed operation: 0, or 1 for a diff
that found differences.

#### `fontpixel.ops.OperationResult.font_json(index: int, pretty: bool = ...) -> str`

*method* -- The JSON metadata of one decoded font (`info` only).

#### `fontpixel.ops.OperationResult.fonts: FontSet | None`

*property* -- Decoded fonts of an `info` call as a `fontpixel.FontSet`, else `None`.

#### `fontpixel.ops.OperationResult.format_status(id: str) -> FormatStatus | None`

*method* -- The status dict of one format identifier (`formats` only), or `None`.

#### `fontpixel.ops.OperationResult.json(pretty: bool = ...) -> str`

*method*

The command-line JSON document (`--report json` / `--json` stdout):
pretty for standalone commands, compact as in batch task results.

#### `fontpixel.ops.OperationResult.operation: str`

*property* -- Operation name (`"convert"`, `"merge"`, …).

#### `fontpixel.ops.OperationResult.outputs: dict[str, bytes]`

*property*

Every prepared asset as `{storage key: bytes}` (memory mode; empty
after filesystem mode, where the outputs were already committed).

#### `fontpixel.ops.OperationResult.report: Report | None`

*property*

The operation's diagnostics report, or `None` for operations with one
report per output or input (convert, merge, diff, formats).

#### `fontpixel.ops.OperationResult.summary: dict[str, Any]`

*property* -- Typed response fields as plain data (per operation; see the module docs).

#### `fontpixel.ops.OperationResult.text() -> str`

*method* -- The command line's text-mode standard output.

### `fontpixel.ops.batch(request: BatchRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> BatchResult`

*function*

Run typed tasks as one batch (`fontpixel batch` with typed tasks).

Request keys: `tasks` (list of request dicts, each with `id` and a `kind`
of `convert`, `vectorize`, `variants`, `subset`, `merge`, `charset`,
`validate` or `diff`), `jobs`, `max_working_bytes`, `max_pending_bytes`,
`max_report_bytes`, `max_task_report_bytes` and `protected_paths`. A task
whose request is invalid fails alone with exit code 2. Every successful
writer joins one output transaction (filesystem) or the returned outputs
(memory). A whole-batch failure raises with a `document` attribute.

### `fontpixel.ops.batch_file(path: StrPath, /, *, jobs: int | None = ...) -> BatchResult`

*function*

Run a TOML job file from the filesystem exactly as `fontpixel batch FILE
[--jobs N]` (the job file is protected from every output; `jobs` is
1..=64).

### `fontpixel.ops.batch_toml(text: str, /, *, base: StrPath | None = ..., jobs: int | None = ..., files: Files | None = ...) -> BatchResult`

*function*

Run a version-1 TOML job text (the `fontpixel batch` file format).
Relative paths resolve against `base`; `jobs` overrides the file's
worker ceiling.

### `fontpixel.ops.capabilities() -> Capabilities`

*function*

Platform capabilities of this build: `filesystem`, `threads` and
`toml_batch` (bools).

### `fontpixel.ops.charset(request: CharsetRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Remap glyph codes into another charset and write the result
(`fontpixel charset`).

### `fontpixel.ops.convert(request: ConvertRequest | None = ..., /, *, files: Files | None = ..., progress: Callable[[Progress], object] | None = ..., **options: Any) -> OperationResult`

*function*

Convert inputs into one output, or each input into its own output
(`fontpixel convert`). Request keys: `inputs`, `output`, `from`, `to`,
`each`, `strict`, `font_index`, `report` and every reader/writer option.

`progress`, if given, is called with a dict
`{"step", "done", "total", "item", "glyphs", "bytes"}` after each input
is read (`step` `"read"`) and each output is encoded (`"encode"`).
Returning `False` cancels with `CancelledError`; raising cancels and
re-raises; nothing is written either way. Results do not depend on it.

### `fontpixel.ops.diff(request: DiffRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Compare two inputs (`fontpixel diff`). Differences are reported in the
result (`summary["equal"]`, `exit_code` 1), not raised.

### `fontpixel.ops.formats(request: FormatsRequest | None = ..., /, **options: Any) -> OperationResult`

*function*

List every catalogue format with the reader/writer compiled into this
build (`fontpixel formats`).

### `fontpixel.ops.info(request: InfoRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Decode one input and describe its fonts (`fontpixel info`); the result's
`fonts` is the decoded `fontpixel.FontSet`.

### `fontpixel.ops.inspect_request(operation: str, request: Mapping[str, Any] | None = ..., /, **options: Any) -> InspectedRequest`

*function*

Validate a request for `operation` and describe it: the normalized
`request` (every default filled in), `report_style`,
`source_identity_total_bytes` and, for batch task kinds, `declared_inputs`
and `weight`. Raises `InvalidInputError` (exit code 2) exactly when the
operation would reject the request before running.

### `fontpixel.ops.memory_key(path: StrPath) -> str`

*function* -- The memory-storage key of a path: `.` removed, `..` folded, `/` separators.

### `fontpixel.ops.merge(request: MergeRequest | None = ..., /, *, files: Files | None = ..., progress: Callable[[Progress], object] | None = ..., **options: Any) -> OperationResult`

*function*

Merge selected glyphs from ordered parts and write every output as one
group (`fontpixel merge`). Request keys: `parts` (list of
`{input, take, dy, from, font_index}`), `outputs` (list of
`{destination, format}`), `family` and the merge/writer options.

`progress`, if given, is called with a dict
`{"step", "done", "total", "item", "glyphs", "bytes"}` after each part
is read (`"read"`), after the merge (`"merge"`) and after each output
is encoded (`"encode"`), before anything is written. Returning `False`
cancels with `CancelledError`; raising cancels and re-raises; nothing
is written either way. Results do not depend on it.

### `fontpixel.ops.output_format_for(destination: StrPath) -> str`

*function*

The output format `convert` infers for a destination path (OpenType
container extensions first, then the registry's filename hints); an
ambiguous or unknown extension raises like `convert` without `to`.

### `fontpixel.ops.parse_args(argv: Sequence[str]) -> ParsedArgs`

*function*

Parse a `fontpixel` command line (without the program name) with the
command-line definition and return `{"command", "request", "report_style",
"source_identity_total_bytes"}`; `request` can be passed to the matching
operation. A rejected command line raises `InvalidInputError` with the
parser's message and `exit_code` (0 for `--help`/`--version`).

### `fontpixel.ops.parse_batch_toml(text: str, /, *, base: StrPath | None = ...) -> ParsedBatch`

*function*

Parse a TOML job text without running it: the tasks as dicts with `id`,
`kind`, `declared_inputs` and either `request` (the normalized request)
and `weight`, or `error` for a task that failed preparation.

### `fontpixel.ops.preview(request: PreviewRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Lay out text (or every mapping) as character art (`fontpixel preview`):
`text()` is the art, `json()` the diagnostics document.

### `fontpixel.ops.render(request: RenderRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Lay out text (or every mapping with `all=True`) into a PNG or SVG image
(`fontpixel render`).

### `fontpixel.ops.subset(request: SubsetRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function* -- Subset an sfnt, WOFF or WOFF2 font (`fontpixel subset`).

### `fontpixel.ops.validate(request: ValidateRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function* -- Validate one input (`fontpixel validate`).

### `fontpixel.ops.variants(request: VariantsRequest | None = ..., /, *, files: Files | None = ..., **options: Any) -> OperationResult`

*function*

Build a locl-enabled OpenType font from regional and script faces
(`fontpixel variants`).

### `fontpixel.ops.vectorize(request: 'ConvertRequest | None' = None, /, *, files: 'Files | None' = None, progress: 'Callable[[Progress], object] | None' = None, **options: 'Any') -> 'OperationResult'`

*function*

Vectorize (``fontpixel vectorize``): the same operation as :func:`convert`.

The command-line ``vectorize`` is an alias of ``convert``; the result is
identical, including its JSON and text documents. ``progress`` behaves as
in :func:`convert`.

## fontpixel.outline

Deterministic bitmap contours in upward-facing font design coordinates.

### `fontpixel.outline.contours(bitmap: BitmapLike, options: OutlineOptions | None = ..., limits: OutlineLimits | None = ...) -> list[list[tuple[float, float, bool]]]`

*function* -- `outline::contours`: trace a Mono bitmap into closed contours.

### `fontpixel.outline.defaults() -> OutlineDefaults`

*function* -- Default `Options` and `Limits` dicts of `fontpixel.outline`.

### `fontpixel.outline.pixel_contour(options: OutlineOptions | None = ...) -> Contour`

*function* -- `outline::pixel_contour`: one independent square/dot inside the cell at `(0, 0)`.

### `fontpixel.outline.pixel_origins(bitmap: BitmapLike, options: OutlineOptions | None = ..., limits: OutlineLimits | None = ...) -> list[tuple[float, float]]`

*function* -- `outline::pixel_origins`: lower-left positions of ink cells, top-to-bottom.

### `fontpixel.outline.rasterize(contours: Sequence[Contour], units_per_pixel: float, origin: tuple[int, int], width: int, height: int, limits: OutlineLimits | None = ...) -> Bitmap`

*function*

`outline::rasterize`: unhinted nonzero-winding pixel-centre fill of
TrueType contours into a `width`×`height` Mono bitmap; `origin` and the
dimensions are in pixels, `units_per_pixel` is positive.

### `fontpixel.outline.segments(contour: Contour) -> list[Segment]`

*function*

`outline::segments`: segment dicts of a contour, with implied on-curve
midpoints resolved.

### `fontpixel.outline.spec_bitmap_contours(rows: Sequence[str], shape: str, dotsize: float, ppu: int, xoff: int, yoff: int) -> list[list[tuple[float, float, bool]]]`

*function*

`outline::spec_bitmap_contours`: the exact SPEC row adapter shared with the
bdfparser compatibility layer (`'0'` is paper, any other byte ink).

## fontpixel.outline.path

Line/quadratic/cubic edge rasterization.

### `fontpixel.outline.path.edge_max_y(edge: Edge) -> float`

*function* -- `Edge::max_y`: the largest y of an edge dict's points.

### `fontpixel.outline.path.edge_points(edge: Edge) -> list[tuple[float, float]]`

*function* -- `Edge::points`: endpoints and controls of an edge dict, in path order.

### `fontpixel.outline.path.rasterize(edges: Sequence[Edge], scale: float, origin: tuple[float, float], width: int, height: int, limits: OutlineLimits | None = ...) -> Bitmap`

*function*

`path::rasterize`: nonzero-winding fill at exact pixel centres of
line/quad/cubic edge dicts into a Mono bitmap.

## fontpixel.sfnt

Bounded sfnt container, OpenType tables, collections, CFF and subsetting.

### `fontpixel.sfnt.Sfnt(data: Buffer | Sequence[int], limits: SfntLimits | None = ...) -> Sfnt`

*class*

A parsed standalone sfnt (`fontpixel::sfnt::Sfnt`).

The handle owns the input bytes and the `Limits` it was validated with;
every method re-parses the directory from those bytes.

#### `fontpixel.sfnt.Sfnt.data: bytes`

*property* -- The font bytes this handle owns.

#### `fontpixel.sfnt.Sfnt.flavor: Flavor`

*property* -- Outline flavor: `"true_type"`, `"cff"` or `"apple_true_type"`.

#### `fontpixel.sfnt.Sfnt.limits: SfntLimits`

*property* -- The limits dict used for parsing.

#### `fontpixel.sfnt.Sfnt.parse(data: Buffer | Sequence[int], limits: SfntLimits | None = ...) -> Sfnt`

*static method*

Parse a standalone sfnt directory, checking table bounds and limits.

`limits` is a `fontpixel.sfnt` Limits dict (see `defaults()`); checksums
are checked separately by `validate_checksums()`.

#### `fontpixel.sfnt.Sfnt.table(tag: Tag) -> bytes | None`

*method* -- The bytes of table `tag` (`str` such as `"OS/2"` or 4 `bytes`), or `None`.

#### `fontpixel.sfnt.Sfnt.tables() -> list[TableRecord]`

*method* -- Directory records in tag order: dicts `{tag, checksum, offset, data}`.

#### `fontpixel.sfnt.Sfnt.validate_checksums() -> None`

*method* -- Check every table checksum and the head checksum adjustment.

### `fontpixel.sfnt.SfntBuilder(flavor: Flavor) -> SfntBuilder`

*class* -- Assembles a standalone sfnt (`fontpixel::sfnt::SfntBuilder`).

#### `fontpixel.sfnt.SfntBuilder.build(limits: SfntLimits | None = ...) -> bytes`

*method* -- Build the font with sorted tables, checksums and head adjustment.

#### `fontpixel.sfnt.SfntBuilder.insert(tag: Tag, table: Buffer | Sequence[int]) -> None`

*method* -- Add table `tag`; duplicate or malformed tags raise `InvalidInputError`.

### `fontpixel.sfnt.checksum(data: Buffer | Sequence[int]) -> int`

*function* -- `fontpixel::sfnt::checksum`: wrapping big-endian 32-bit word sum.

### `fontpixel.sfnt.defaults() -> SfntDefaults`

*function*

Default limit and option dicts of `fontpixel.sfnt` and its submodules,
keyed by Rust type path relative to `fontpixel::sfnt`.

### `fontpixel.sfnt.flavor_version(flavor: Flavor) -> int`

*function* -- `Flavor::version`: the four-byte sfnt version of a flavor string.

## fontpixel.sfnt.bitmap

Embedded bitmaps: EBDT/EBLC, bdat/bloc, CBDT/CBLC, EBSC and sbix.

### `fontpixel.sfnt.bitmap.decode(location: Buffer | Sequence[int], data: Buffer | Sequence[int], kind: BitmapKind, num_glyphs: int, limits: SfntBitmapLimits | None = ...) -> list[Strike]`

*function* -- `bitmap::decode`: strikes from location (EBLC/bloc/CBLC) and data tables.

### `fontpixel.sfnt.bitmap.decode_sbix(data: Buffer | Sequence[int], num_glyphs: int, darkness: bool = ..., limits: SfntBitmapLimits | None = ...) -> Sbix`

*function* -- `color::decode_sbix`: an Sbix dict (PNG payloads converted to gray).

### `fontpixel.sfnt.bitmap.decode_scaling(data: Buffer | Sequence[int], limits: SfntBitmapLimits | None = ...) -> list[Scale]`

*function* -- `bitmap::decode_scaling`: EBSC scale dicts.

### `fontpixel.sfnt.bitmap.decode_with_color(location: Buffer | Sequence[int], data: Buffer | Sequence[int], kind: BitmapKind, num_glyphs: int, darkness: bool, limits: SfntBitmapLimits | None = ...) -> list[Strike]`

*function*

`bitmap::decode_with_color`: as `decode`, converting color strikes to
gray (`darkness=True` uses darkness rather than luminance).

### `fontpixel.sfnt.bitmap.encode(strikes: Sequence[Strike], kind: BitmapKind, num_glyphs: int, limits: SfntBitmapLimits | None = ...) -> TablesBytes`

*function* -- `bitmap::encode`: `{data, location}` bytes for strike dicts.

### `fontpixel.sfnt.bitmap.encode_sbix(sbix: Sbix, num_glyphs: int, limits: SfntBitmapLimits | None = ...) -> bytes`

*function* -- `color::encode_sbix`: sbix table bytes.

### `fontpixel.sfnt.bitmap.encode_scaling(scales: Sequence[Scale], limits: SfntBitmapLimits | None = ...) -> bytes`

*function* -- `bitmap::encode_scaling`: EBSC bytes.

### `fontpixel.sfnt.bitmap.encode_shared_metric_runs(strikes: Sequence[Strike], kind: BitmapKind, num_glyphs: int, minimum_run: int, limits: SfntBitmapLimits | None = ...) -> SharedMetricRuns`

*function* -- `runs::encode_shared_metric_runs`: `{tables: {data, location}, shared_runs}`.

### `fontpixel.sfnt.bitmap.encode_spanning(strikes: Sequence[Strike], kind: BitmapKind, num_glyphs: int, limits: SfntBitmapLimits | None = ...) -> TablesBytes`

*function* -- `bitmap::encode_spanning`: as `encode`, with index subtables spanning gaps.

### `fontpixel.sfnt.bitmap.kind_tags(kind: BitmapKind) -> tuple[str, str]`

*function* -- `Kind::tags`: `(data_tag, location_tag)`, e.g. `("EBDT", "EBLC")`.

### `fontpixel.sfnt.bitmap.line_ascender(line_metrics: LineMetrics) -> int`

*function* -- `LineMetrics::ascender`: the signed ascender of a 12-byte LineMetrics value.

### `fontpixel.sfnt.bitmap.line_descender(line_metrics: LineMetrics) -> int`

*function* -- `LineMetrics::descender`: the signed descender of a LineMetrics value.

## fontpixel.sfnt.cff

CFF1 reading, writing and subsetting.

### `fontpixel.sfnt.cff.Cff()`

*class*

A parsed CFF1 table (`fontpixel::sfnt::cff::Cff`).

Owns the table (or containing sfnt) bytes and limits; each call re-parses.

#### `fontpixel.sfnt.cff.Cff.data: bytes`

*property* -- The CFF table bytes.

#### `fontpixel.sfnt.cff.Cff.from_sfnt(font: Sfnt, limits: CffLimits | None = ...) -> Cff`

*static method* -- The `CFF ` table of an `OTTO` sfnt handle (requires maxp 0.5 and head).

#### `fontpixel.sfnt.cff.Cff.global_subr_count() -> int`

*method* -- Number of global subroutines.

#### `fontpixel.sfnt.cff.Cff.glyph(gid: int, limits: CffLimits | None = ...) -> DecodedGlyph`

*method* -- Evaluate one glyph: `{advance, commands}` (DecodedGlyph dict).

#### `fontpixel.sfnt.cff.Cff.glyph_name(gid: int) -> bytes | None`

*method* -- The glyph name bytes of a name-keyed font, or `None`.

#### `fontpixel.sfnt.cff.Cff.identifier(gid: int) -> int | None`

*method* -- The SID or CID of glyph `gid`, or `None`.

#### `fontpixel.sfnt.cff.Cff.is_cid() -> bool`

*method* -- Whether this is a CID-keyed font.

#### `fontpixel.sfnt.cff.Cff.is_empty() -> bool`

*method* -- Whether the font has no glyphs.

#### `fontpixel.sfnt.cff.Cff.len() -> int`

*method* -- Number of glyphs (`Cff::len`).

#### `fontpixel.sfnt.cff.Cff.parse(data: Buffer | Sequence[int], units_per_em: int, limits: CffLimits | None = ...) -> Cff`

*static method* -- Parse a raw `CFF ` table with the containing font's units per em.

#### `fontpixel.sfnt.cff.Cff.read_all(limits: CffLimits | None = ...) -> list[DecodedGlyph]`

*method* -- Evaluate every glyph under one whole-font budget.

#### `fontpixel.sfnt.cff.Cff.subset(glyphs: Sequence[int], limits: CffLimits | None = ...) -> CffEncodedBytes`

*method* -- Subset to `glyphs` (old IDs in new order, `.notdef` first): CFF bytes.

### `fontpixel.sfnt.cff.encode(font: CffFont, limits: CffLimits | None = ...) -> CffEncodedBytes`

*function*

`cff::Font::encode`: encode a CFF Font dict; returns `{data, bounds, maxp}`
with `data`/`maxp` as `bytes`.

### `fontpixel.sfnt.cff.glyph_from_bitmap(name: str, advance: float, bitmap: BitmapLike, options: OutlineOptions | None = ..., limits: CffLimits | None = ...) -> SfntCffGlyph`

*function* -- `cff::Glyph::from_bitmap`: a CFF Glyph dict from a Mono bitmap handle.

## fontpixel.sfnt.cmap

Character-to-glyph mapping table.

### `fontpixel.sfnt.cmap.decode(data: Buffer | Sequence[int], num_glyphs: int, limits: SfntLimits | None = ...) -> dict[int, int]`

*function* -- `cmap::decode`: the preferred Unicode subtable as `{codepoint: glyph_id}`.

### `fontpixel.sfnt.cmap.encode(mapping: Mapping[int, int], num_glyphs: int, limits: SfntLimits | None = ...) -> EncodedCmapBytes`

*function*

`cmap::encode`: encode `{codepoint: glyph_id}` with the default record set.
Returns `{data: bytes, has_bmp_subtable}`.

### `fontpixel.sfnt.cmap.encode_records(mapping: Mapping[int, int], num_glyphs: int, unicode_full_for_bmp: bool, limits: SfntLimits | None = ...) -> EncodedCmapBytes`

*function*

`cmap::encode_records`: as `encode`, optionally adding the Unicode full
record even for BMP-only mappings.

### `fontpixel.sfnt.cmap.encode_with_records(mapping: Mapping[int, int], num_glyphs: int, records: FullRecords, limits: SfntLimits | None = ...) -> EncodedCmapBytes`

*function*

`cmap::encode_with_records`: choose the full-repertoire records
(`"always"`, `"non-bmp"` or `"when-needed"`).

## fontpixel.sfnt.collection

TrueType/OpenType collections (ttcf).

### `fontpixel.sfnt.collection.Collection(data: Buffer, limits: CollectionLimits | None = ...) -> Collection`

*class*

A parsed TrueType/OpenType collection (`fontpixel::sfnt::collection::Collection`).

Owns the bytes and limits; each call re-parses (every face is checked).

#### `fontpixel.sfnt.collection.Collection.data: bytes`

*property* -- The collection bytes this handle owns.

#### `fontpixel.sfnt.collection.Collection.extract(index: int, limits: CollectionLimits | None = ...) -> tuple[bytes, Report]`

*method* -- Extract face `index` as a standalone sfnt: `(bytes, report)`.

#### `fontpixel.sfnt.collection.Collection.faces: list[CollectionFace]`

*property* -- Faces as dicts `{flavor, offset, tables}` with table records as in `Sfnt.tables()`.

#### `fontpixel.sfnt.collection.Collection.parse(data: Buffer | Sequence[int], limits: CollectionLimits | None = ...) -> Collection`

*static method* -- Parse a `ttcf` collection, checking every face before exposing any.

#### `fontpixel.sfnt.collection.Collection.signature: bytes | None`

*property* -- The opaque version-2 DSIG block, or `None`.

#### `fontpixel.sfnt.collection.Collection.validate_checksums() -> None`

*method* -- Check every face's table checksums and head adjustment.

#### `fontpixel.sfnt.collection.Collection.version: int`

*property* -- TTC version (`0x00010000` or `0x00020000`).

### `fontpixel.sfnt.collection.encode(fonts: Sequence[Buffer], version: int, limits: CollectionLimits | None = ...) -> tuple[bytes, Report]`

*function*

`collection::encode`: build a collection from standalone fonts, sharing
identical tables. Returns `(bytes, report)`.

## fontpixel.sfnt.gasp

Grid-fitting and scan-conversion table.

### `fontpixel.sfnt.gasp.decode(data: Buffer | Sequence[int], limits: SfntLimits | None = ...) -> GaspTable`

*function* -- `GaspTable::decode`: a GaspTable dict.

### `fontpixel.sfnt.gasp.encode(table: GaspTable, limits: SfntLimits | None = ...) -> bytes`

*function* -- `GaspTable::encode`: gasp table bytes.

## fontpixel.sfnt.glyf

TrueType glyf/loca tables.

### `fontpixel.sfnt.glyf.component_translated(glyph_id: int, x: int, y: int) -> Component`

*function* -- `Component::translated`: a component dict offset by `(x, y)`.

### `fontpixel.sfnt.glyf.contours(table: GlyfTable, glyph_id: int, limits: GlyfLimits | None = ...) -> list[Contour]`

*function* -- `GlyfTable::contours`: flattened contours of `glyph_id` (composites expanded).

### `fontpixel.sfnt.glyf.decode(glyf: Buffer | Sequence[int], loca: Buffer | Sequence[int], num_glyphs: int, index_to_loc_format: int, limits: GlyfLimits | None = ...) -> GlyfTable`

*function* -- `GlyfTable::decode`: a GlyfTable dict from glyf and loca bytes.

### `fontpixel.sfnt.glyf.encode(table: GlyfTable, format: LocaFormat, limits: GlyfLimits | None = ...) -> GlyfEncodedBytes`

*function*

`GlyfTable::encode`: `{glyf, loca, index_to_loc_format, bounds, statistics}`
with `glyf`/`loca` as `bytes`; `format` is `"short"`, `"long"` or `"auto"`.

### `fontpixel.sfnt.glyf.from_sfnt(font: Sfnt, limits: GlyfLimits | None = ...) -> GlyfTable`

*function* -- `GlyfTable::from_sfnt`: the GlyfTable dict of an `Sfnt` handle.

### `fontpixel.sfnt.glyf.glyph_pixels(bitmap: BitmapLike, options: OutlineOptions | None = ..., shared_glyph: int = ..., limits: GlyfLimits | None = ...) -> SfntGlyfGlyph`

*function*

`Glyph::pixels`: a glyph dict tracing a Mono bitmap handle (Dot shapes
reference `shared_glyph`).

### `fontpixel.sfnt.glyf.glyph_simple(contours: Sequence[Contour]) -> SfntGlyfGlyph`

*function* -- `Glyph::simple`: a simple glyph dict from `[(x, y, on_curve), …]` contours.

### `fontpixel.sfnt.glyf.unhinted_maxp(statistics: Statistics, num_glyphs: int) -> bytes`

*function* -- `Statistics::unhinted_maxp`: maxp 1.0 bytes from encode statistics.

## fontpixel.sfnt.gsub

Glyph substitution table.

### `fontpixel.sfnt.gsub.closure(gsub: Gsub, glyphs: Set[int] | frozenset[int]) -> list[int]`

*function*

`Gsub::closure`: `glyphs` plus every glyph reachable by substitution,
returned as a sorted list.

### `fontpixel.sfnt.gsub.decode(data: Buffer | Sequence[int], num_glyphs: int, limits: LayoutLimits | None = ...) -> Gsub`

*function* -- `Gsub::decode`: a Gsub dict (scripts keyed by tag strings).

### `fontpixel.sfnt.gsub.encode(gsub: Gsub, num_glyphs: int, limits: LayoutLimits | None = ...) -> bytes`

*function* -- `Gsub::encode`: GSUB table bytes.

### `fontpixel.sfnt.gsub.subset(gsub: Gsub, mapping: Mapping[int, int]) -> Gsub`

*function* -- `Gsub::subset`: the Gsub dict remapped through `{old_id: new_id}`.

## fontpixel.sfnt.metrics

hhea/hmtx and vhea/vmtx tables.

### `fontpixel.sfnt.metrics.decode(axis: Axis, header: Buffer | Sequence[int], data: Buffer | Sequence[int], num_glyphs: int, limits: SfntLimits | None = ...) -> tuple[MetricsHeader, list[LongMetric]]`

*function* -- `metrics::decode`: `(header, metrics)` from the header and metrics tables.

### `fontpixel.sfnt.metrics.encode(axis: Axis, header: MetricsHeader, metrics: Sequence[LongMetric], compact: bool, limits: SfntLimits | None = ...) -> EncodedMetricsBytes`

*function* -- `metrics::encode`: `{header: bytes, metrics: bytes, num_long_metrics}`.

### `fontpixel.sfnt.metrics.header_new(axis: Axis) -> MetricsHeader`

*function*

`metrics::Header::new`: a default header dict for `axis`
(`"horizontal"` or `"vertical"`).

### `fontpixel.sfnt.metrics.header_recompute(header: MetricsHeader, metrics: Sequence[LongMetric], ink_extents: Sequence[int | None]) -> MetricsHeader`

*function*

`Header::recompute`: a copy of `header` with extents recomputed from
`metrics` (LongMetric dicts) and per-glyph ink extents (`None` = blank).

## fontpixel.sfnt.name

Naming table.

### `fontpixel.sfnt.name.decode(data: Buffer | Sequence[int], limits: SfntLimits | None = ...) -> NameTable`

*function* -- `NameTable::decode`: a NameTable dict `{records, language_tags}`.

### `fontpixel.sfnt.name.encode(table: NameTable, limits: SfntLimits | None = ...) -> bytes`

*function* -- `NameTable::encode`: canonical sorted name table bytes.

### `fontpixel.sfnt.name.encode_configured(table: NameTable, limits: SfntLimits | None = ...) -> bytes`

*function* -- `NameTable::encode_configured`: `validate_configured`, then encode.

### `fontpixel.sfnt.name.language_tag_well_formed(tag: str) -> bool`

*function* -- `name::language_tag_well_formed`: RFC 5646 well-formedness only.

### `fontpixel.sfnt.name.record_text(record: NameRecord) -> str | None`

*function*

`NameRecord::text`: the decoded text of a record dict, or `None` for
encodings without a text decoding.

### `fontpixel.sfnt.name.record_unicode(name_id: int, language_id: int, value: str) -> NameRecord`

*function* -- `NameRecord::unicode`: a Windows Unicode (3, 1) record dict.

### `fontpixel.sfnt.name.retained_bytes(table: NameTable, maximum: int) -> int`

*function*

`NameTable::retained_bytes`: retained logical storage of the table as
deserialized from `table` (spare capacity included), bounded by `maximum`.

### `fontpixel.sfnt.name.validate_configured(table: NameTable, limits: SfntLimits | None = ...) -> None`

*function*

`NameTable::validate_configured`: check platform/encoding/language/ID rules
for a caller-supplied table; raises `InvalidInputError`.

## fontpixel.sfnt.os2

OS/2 and Windows metrics table.

### `fontpixel.sfnt.os2.average_width(advances: Sequence[int]) -> int`

*function* -- `os2::average_width`: xAvgCharWidth of the given advances.

### `fontpixel.sfnt.os2.check_code_page_ranges(ranges: Sequence[int]) -> str | None`

*function* -- `os2::check_code_page_ranges`: `None` when valid, else the reason.

### `fontpixel.sfnt.os2.check_embedding_flags(flags: int) -> str | None`

*function* -- `os2::check_embedding_flags`: `None` when valid, else the reason.

### `fontpixel.sfnt.os2.check_selection_flags(flags: int, version: int) -> str | None`

*function* -- `os2::check_selection_flags`: `None` when valid for `version`, else the reason.

### `fontpixel.sfnt.os2.code_page_ranges(codepoints: Iterable[int], pages: Sequence[int]) -> list[int]`

*function*

`os2::code_page_ranges`: the two ulCodePageRange words for `codepoints`
and explicitly declared Windows code `pages`.

### `fontpixel.sfnt.os2.decode(data: Buffer | Sequence[int], limits: SfntLimits | None = ...) -> Os2Table`

*function* -- `Os2Table::decode`: an Os2Table dict.

### `fontpixel.sfnt.os2.encode(table: Os2Table, limits: SfntLimits | None = ...) -> bytes`

*function* -- `Os2Table::encode`: OS/2 table bytes of the dict's version.

### `fontpixel.sfnt.os2.set_unicode_coverage(table: Os2Table, codepoints: Iterable[int]) -> Os2Table`

*function*

`Os2Table::set_unicode_coverage`: a copy of `table` with Unicode ranges and
first/last character indexes derived from `codepoints`.

### `fontpixel.sfnt.os2.unicode_ranges(codepoints: Iterable[int]) -> list[int]`

*function* -- `os2::unicode_ranges`: the four ulUnicodeRange words.

## fontpixel.sfnt.post

PostScript table.

### `fontpixel.sfnt.post.decode(data: Buffer | Sequence[int], num_glyphs: int, limits: SfntLimits | None = ...) -> PostTable`

*function* -- `PostTable::decode`: a PostTable dict.

### `fontpixel.sfnt.post.encode(table: PostTable, num_glyphs: int, limits: SfntLimits | None = ...) -> bytes`

*function* -- `PostTable::encode`: post table bytes.

## fontpixel.sfnt.subset

Compact Unicode subsets with GSUB/composite closure.

### `fontpixel.sfnt.subset.options_text(text: str) -> SubsetOptions`

*function* -- `subset::Options::text`: options selecting every scalar of `text`.

### `fontpixel.sfnt.subset.subset(data: Buffer | Sequence[int], options: SubsetOptions | None = ...) -> SubsetResult`

*function*

`subset::subset`: subset a standalone sfnt. Returns
`{bytes, glyph_mapping, report}`; `glyph_mapping` maps old to new glyph IDs.

## fontpixel.variants

Regional bitmap alternatives, deduplication and locl-enabled OpenType output.

### `fontpixel.variants.PreparedVariants()`

*class*

An immutable plan ready for repeated exports
(`fontpixel::variants::PreparedVariants`). Safe to share between threads.

#### `fontpixel.variants.PreparedVariants.encode(options: ExportOptions | None = ...) -> EncodedFont`

*method*

`PreparedVariants::encode`: export without replanning; `options.limits`
must equal the limits given to `prepare`.

#### `fontpixel.variants.PreparedVariants.encode_allowance() -> int`

*method*

`PreparedVariants::encode_allowance`: bytes one `encode` may admit
besides the plan.

#### `fontpixel.variants.PreparedVariants.plan() -> Plan`

*method* -- `PreparedVariants::plan`: the Plan dict.

#### `fontpixel.variants.PreparedVariants.retained_bytes() -> int`

*method* -- `PreparedVariants::retained_bytes`: admitted bytes of the shared plan.

### `fontpixel.variants.Variants(base: FontLike) -> Variants`

*class*

One default face plus ordered language and script alternatives
(`fontpixel::variants::Variants`).

Holds the model behind a lock; calls copy a reference to the current
model and release the lock (and the GIL) while working.

#### `fontpixel.variants.Variants.add_language(language: str, font: FontLike) -> None`

*method*

`Variants::add_language`: add a BCP-47/OpenType language with the
default CJK script scope (DFLT, hani, kana, hang, bopo).

#### `fontpixel.variants.Variants.add_language_variant(language: Tag, scripts: Iterable[Tag], font: FontLike) -> None`

*method*

Append a language alternative with explicit OpenType `language` tag and
`scripts` tags (the `languages` field).

#### `fontpixel.variants.Variants.add_script(scripts: Iterable[Tag], font: FontLike) -> None`

*method* -- Append a script alternative for `scripts` tags (the `scripts` field).

#### `fontpixel.variants.Variants.base: Font`

*property* -- A copy of the default face as a `Font` handle.

#### `fontpixel.variants.Variants.consumed: bool`

*property* -- Whether `encode_owned()`/`into_prepared()` consumed this handle.

#### `fontpixel.variants.Variants.encode(options: ExportOptions | None = ...) -> EncodedFont`

*method* -- `variants::encode`: plan and export (`{bytes, report}`).

#### `fontpixel.variants.Variants.encode_owned(options: ExportOptions | None = ...) -> EncodedFont`

*method*

`Variants::encode_owned`: plan and export, consuming this handle's
model and dropping faces as soon as they are planned.

#### `fontpixel.variants.Variants.from_dict(value: VariantsDict) -> Variants`

*static method* -- Build from a serde Variants dict `{base, languages, scripts}`.

#### `fontpixel.variants.Variants.into_prepared(limits: LayoutLimits | None = ...) -> PreparedVariants`

*method* -- `Variants::into_prepared`: as `prepare`, consuming this handle's model.

#### `fontpixel.variants.Variants.languages: list[LanguageVariantItem]`

*property*

Language alternatives as `[{language, scripts, font}]` (OpenType tag
strings, `Font` handle copies), in application order.

#### `fontpixel.variants.Variants.plan(limits: LayoutLimits | None = ...) -> Plan`

*method*

`Variants::plan`: glyph order, deduplication and locl routing as a Plan
dict `{glyphs: [(name, glyph)], cmap, gsub}`.

#### `fontpixel.variants.Variants.prepare(limits: LayoutLimits | None = ...) -> PreparedVariants`

*method*

`Variants::prepare`: validate and plan once for repeated exports.

Plans an owned copy of the model (Rust borrows it instead), so the
returned handle is independent of later edits to this one.

#### `fontpixel.variants.Variants.retained_usage(max_bytes: int) -> int`

*method*

`Variants::retained_usage`: retained bytes as an owning caller charges
them; raises `ResourceLimitError` above `max_bytes`.

#### `fontpixel.variants.Variants.scripts: list[ScriptVariantItem]`

*property* -- Script alternatives as `[{scripts, font}]`.

#### `fontpixel.variants.Variants.to_dict() -> VariantsDict`

*method* -- The serde Variants dict (fonts as font dicts).

### `fontpixel.variants.defaults() -> VariantsDefaults`

*function* -- Default option dicts of `fontpixel.variants`.

### `fontpixel.variants.encode(variants: Variants, options: ExportOptions | None = ...) -> EncodedFont`

*function* -- `variants::encode`: plan and export a `Variants` handle.

### `fontpixel.variants.encode_single(font: FontLike, options: ExportOptions | None = ...) -> EncodedFont`

*function*

`variants::encode_single`: export one face without alternatives. Unlike
regional planning (`Variants`), this keeps physical glyph identity and
order, so its bytes differ from `Variants.encode_owned` by design.

### `fontpixel.variants.encode_single_owned(font: FontLike, options: ExportOptions | None = ...) -> EncodedFont`

*function*

`variants::encode_single_owned`: as `encode_single`, letting the export
own (and drop early) a copy of the face; output is identical.

### `fontpixel.variants.language_tag(value: str) -> str`

*function*

`variants::language_tag`: the OpenType language-system tag of a BCP-47 or
OpenType tag via the OpenType language registry (e.g. `"zh-HK"` → `"ZHH "`);
unknown tags raise `InvalidInputError`.

### `fontpixel.variants.notdef_empty_metrics(policy: NotdefPolicy) -> tuple[int, int] | None`

*function*

`NotdefPolicy::empty_metrics`: `(advance, left_side_bearing)` of an empty
`.notdef` policy, or `None` for `"preserve"`.

### `fontpixel.variants.script_tag(value: str) -> str`

*function*

`variants::script_tag`: validate an explicit four-letter script tag
(e.g. `"latn"`); other lengths or characters raise `InvalidInputError`.

### `fontpixel.variants.validate_metadata(metadata: MetadataOptions, flavor: OutlineFlavor, shape: Shape) -> None`

*function*

`MetadataOptions::validate`: check metadata controls against an outline
`flavor` (`"true_type"`/`"cff"`) and `shape`.

## fontpixel.woff

Bounded standalone sfnt <-> WOFF1/WOFF2 containers.

### `fontpixel.woff.defaults() -> WoffDefaults`

*function* -- Default limit and option dicts of `fontpixel.woff`.

## fontpixel.woff.woff1

WOFF 1.0 (zlib).

### `fontpixel.woff.woff1.decode(data: Buffer | Sequence[int], limits: WoffLimits | None = ...) -> WoffDecoded`

*function* -- `woff1::decode`: reconstruct the standalone sfnt from WOFF1 bytes.

### `fontpixel.woff.woff1.encode(data: Buffer | Sequence[int], options: Woff1Options | None = ..., limits: WoffLimits | None = ...) -> EncodedFont`

*function* -- `woff1::encode`: deterministic WOFF1 of a standalone sfnt.

## fontpixel.woff.woff2

WOFF 2.0 (Brotli, glyf/loca/hmtx transforms, collections).

### `fontpixel.woff.woff2.brotli_encoder_heap_bound(quality: int, lgwin: int, input_len: int, threads: int) -> int | None`

*function*

`woff2::brotli_encoder_heap_bound`: the admitted Brotli encoder heap bound
(proven for quality 0-9, an empirical envelope for 10-11), or `None` on
arithmetic overflow. WOFF2 always uses `lgwin = 22`.

### `fontpixel.woff.woff2.brotli_encoder_proven_heap_bound(quality: int, lgwin: int, input_len: int, threads: int) -> int | None`

*function*

`woff2::brotli_encoder_proven_heap_bound`: the source-derived upper bound
of all encoder heap for the same call shape, or `None` on overflow.

### `fontpixel.woff.woff2.decode(data: Buffer | Sequence[int], limits: WoffLimits | None = ...) -> WoffDecoded`

*function* -- `woff2::decode`: reconstruct the sfnt (or `ttcf` collection) from WOFF2.

### `fontpixel.woff.woff2.encode(data: Buffer | Sequence[int], options: Woff2Options | None = ..., limits: WoffLimits | None = ...) -> EncodedFont`

*function* -- `woff2::encode`: deterministic WOFF2 of an sfnt or `ttcf` collection.

### `fontpixel.woff.woff2.encode_many(inputs: Sequence[Buffer], options: Woff2Options | None = ..., limits: WoffLimits | None = ..., jobs: int = ...) -> list[EncodedFont]`

*function*

`woff2::encode_many`: encode several fonts with up to `jobs` worker
threads (bounded by `max_batch_fonts`/`max_batch_bytes`); output order
matches input order.