cardbleed 0.1.0__py3-none-any.whl

cardbleed/__init__.py

@@ -0,0 +1,25 @@
+"""Extend the borders of card scans outward for printing.
+
+Continues the existing border pattern (holo speckle, solid colors, ...)
+uniformly on all four edges without ever degrading the original image data:
+
+  PNG  -> PNG   original pixels bit-identical (lossless re-serialize)
+  WebP -> WebP  written lossless; decoded original pixels preserved exactly
+  JPEG -> JPEG  DCT-domain surgery: original coefficient blocks are copied
+                bit-exact into a larger grid; only new border blocks are
+                encoded (with the original's own quantization tables)
+
+Python API (stable surface):
+
+    from cardbleed import Params, extend_image
+
+    result = extend_image(arr, (16, 16, 16, 16), Params(),
+                          np.random.default_rng(0), overwrite=True, notes=[])
+"""
+
+from ._version import __version__
+from .cli import cli
+from .errors import FileError
+from .synthesis import Params, extend_image
+
+__all__ = ["FileError", "Params", "__version__", "cli", "extend_image"]

cardbleed/__main__.py

@@ -0,0 +1,4 @@
+from cardbleed import cli
+
+if __name__ == "__main__":
+    cli()

cardbleed/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cardbleed/cli.py

@@ -0,0 +1,336 @@
+"""Command-line interface (click + rich-click)."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import rich_click as click
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+)
+
+from ._version import __version__
+from .errors import FileError
+from .process import iter_inputs, process_file
+from .selfcheck import selfcheck
+
+click.rich_click.USE_RICH_MARKUP = True
+click.rich_click.SHOW_ARGUMENTS = True
+click.rich_click.STYLE_OPTIONS_TABLE_LEADING = 0
+click.rich_click.OPTION_GROUPS = {
+    "*": [
+        {
+            "name": "Sizing",
+            "options": [
+                "--extend",
+                "--left",
+                "--right",
+                "--top",
+                "--bottom",
+                "--target",
+                "--fix-aspect",
+                "--card-size",
+            ],
+        },
+        {
+            "name": "Synthesis",
+            "options": [
+                "--mode",
+                "--sample",
+                "--trim",
+                "--jitter",
+                "--jitter-smooth",
+                "--jitter-cross",
+                "--shuffle",
+                "--noise",
+                "--smudge",
+                "--seam-feather",
+                "--corner-guard",
+                "--halo",
+                "--seed",
+            ],
+        },
+        {
+            "name": "Input / Output",
+            "options": [
+                "--out-dir",
+                "--suffix",
+                "--compare",
+                "--force",
+                "--recursive",
+                "--dry-run",
+                "--version",
+                "--help",
+            ],
+        },
+    ]
+}
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("inputs", nargs=-1, metavar="[INPUTS]...")
+# sizing ---------------------------------------------------------------------
+@click.option(
+    "-e",
+    "--extend",
+    default="16",
+    show_default=True,
+    metavar="AMT",
+    help="Border to add per edge: px ([cyan]16[/]) or mm ([cyan]2.5mm[/]).",
+)
+@click.option(
+    "--left",
+    default=None,
+    metavar="AMT",
+    help="Override for the left edge ([cyan]0[/] skips it).",
+)
+@click.option(
+    "--right", default=None, metavar="AMT", help="Override for the right edge."
+)
+@click.option("--top", default=None, metavar="AMT", help="Override for the top edge.")
+@click.option(
+    "--bottom", default=None, metavar="AMT", help="Override for the bottom edge."
+)
+@click.option(
+    "--target",
+    default=None,
+    metavar="WxH",
+    help="Pad (centered) to an exact final size, e.g. "
+    "[cyan]69x94mm[/] or [cyan]440x600[/]; overrides -e.",
+)
+@click.option(
+    "--fix-aspect",
+    is_flag=True,
+    help="First pad the short axis so the image matches the card "
+    "aspect ratio exactly, then add the border.",
+)
+@click.option(
+    "--card-size",
+    default="63x88",
+    show_default=True,
+    metavar="WxH",
+    help="Physical card size in mm — basis for all mm math "
+    "(embedded file DPI is never trusted).",
+)
+# synthesis ------------------------------------------------------------------
+@click.option(
+    "--mode",
+    type=click.Choice(["smart", "pattern", "naive"]),
+    default="smart",
+    show_default=True,
+    help="[cyan]smart[/]: stochastic band resampling · "
+    "[cyan]pattern[/]: structure-preserving randomized-mirror "
+    "continuation (auto-detects repeating patterns and keeps "
+    "them phase-aligned) · [cyan]naive[/]: replicate the "
+    "outermost clean line.",
+)
+@click.option(
+    "-k",
+    "--sample",
+    type=int,
+    default=12,
+    show_default=True,
+    metavar="N",
+    help="How many border pixels to sample patterns/colors from "
+    "(auto-clamped before inner border structure).",
+)
+@click.option(
+    "--trim",
+    default="auto",
+    show_default=True,
+    metavar="auto|N",
+    help="Outermost pixels treated as scanner bloom / cut-line junk: "
+    "excluded from sampling and (png/webp) replaced. "
+    "[cyan]auto[/] detects hard bloom lines per edge (max 3).",
+)
+@click.option(
+    "--jitter",
+    type=float,
+    default=0.85,
+    show_default=True,
+    help="0..1 randomness of the sampling depth "
+    "([cyan]0[/] = plain pattern continuation).",
+)
+@click.option(
+    "--jitter-smooth",
+    type=float,
+    default=1.2,
+    show_default=True,
+    metavar="SIGMA",
+    help="Smoothing of the jitter field; matches speckle grain size "
+    "([cyan]0[/] = per-pixel salt & pepper).",
+)
+@click.option(
+    "--jitter-cross",
+    type=float,
+    default=4.0,
+    show_default=True,
+    metavar="PX",
+    help="Local along-edge wobble of the sampling position; kills "
+    "repeated-fleck trails ([cyan]0[/] = perfectly straight).",
+)
+@click.option(
+    "--shuffle",
+    type=float,
+    default=48.0,
+    show_default=True,
+    metavar="PX",
+    help="Long-range texture borrowing along the edge (smoothed "
+    "patches): holo speckle is drawn from elsewhere on the "
+    "border so patterns never near-repeat in either direction "
+    "([cyan]0[/] = only local wobble).",
+)
+@click.option(
+    "--noise",
+    type=float,
+    default=0.35,
+    show_default=True,
+    metavar="F",
+    help="Added grain as a multiple of the border's own measured "
+    "grain (self-tuning; [cyan]0[/] = off).",
+)
+@click.option(
+    "--smudge",
+    type=float,
+    default=0.6,
+    show_default=True,
+    metavar="SIGMA",
+    help="Gaussian smudge of the new border, ramped toward the "
+    "outer edge ([cyan]0[/] = off).",
+)
+@click.option(
+    "--seam-feather",
+    type=int,
+    default=3,
+    show_default=True,
+    metavar="PX",
+    help="Pixels over which randomness ramps in from the seam.",
+)
+@click.option(
+    "--corner-guard",
+    type=int,
+    default=12,
+    show_default=True,
+    metavar="PX",
+    help="Keep sampling this far away from image corners (avoids "
+    "seeding from rounded/white scan corners).",
+)
+@click.option(
+    "--halo",
+    type=click.Choice(["auto", "overwrite", "blend"]),
+    default="auto",
+    show_default=True,
+    help="Trimmed halo ring handling: [cyan]overwrite[/] it "
+    "(png/webp default) or [cyan]blend[/] it out (jpeg "
+    "default; overwrite on jpeg re-encodes the outer "
+    "block ring).",
+)
+@click.option(
+    "--seed",
+    type=int,
+    default=0,
+    show_default=True,
+    help="RNG seed (per-file streams derived from filename).",
+)
+# input/output ---------------------------------------------------------------
+@click.option(
+    "-o",
+    "--out-dir",
+    default=None,
+    metavar="DIR",
+    help="Output directory (default: alongside each input).",
+)
+@click.option(
+    "--suffix",
+    default="_ext",
+    show_default=True,
+    help="Appended to the output file stem.",
+)
+@click.option(
+    "--compare",
+    is_flag=True,
+    help="Also write a QA sheet: original | result | result with "
+    "the original boundary marked.",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Overwrite existing output files (inputs are never overwritten).",
+)
+@click.option("--recursive", is_flag=True, help="Descend into subdirectories.")
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be done without writing anything."
+)
+@click.option("--selfcheck", is_flag=True, hidden=True)
+@click.version_option(__version__, "-V", "--version")
+@click.pass_context
+def cli(ctx: click.Context, **kw) -> None:
+    """Extend card scan borders for printing, continuing the existing
+    border pattern (holo speckle, solid colors, ...).
+
+    Original image data is [bold]never re-encoded[/]: PNG/WebP pixels stay
+    bit-identical and JPEG goes through lossless DCT-block surgery.
+    INPUTS are image files and/or directories (png/jpg/jpeg/webp).
+
+    [dim]Examples:[/]
+
+    [dim]  cardbleed card.png --compare[/]
+
+    [dim]  cardbleed ./cards/ -e 2.5mm --fix-aspect[/]
+    """
+    ctx.exit(run(SimpleNamespace(**kw)))
+
+
+def run(args) -> int:
+    console = Console(highlight=False)
+    err = Console(stderr=True, highlight=False)
+    if args.selfcheck:
+        return selfcheck(args)
+    if not args.inputs:
+        raise click.UsageError("no inputs given (image files or directories)")
+
+    files, input_errors = iter_inputs(list(args.inputs), args.recursive, args.suffix)
+    for e in input_errors:
+        err.print(f"[yellow]SKIPPED[/] {e}")
+    if not files:
+        err.print("[bold red]error:[/] no supported images found")
+        return 2
+
+    ok, failed = 0, len(input_errors)
+    claimed: dict = {}
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        console=console,
+        transient=True,
+        disable=len(files) < 3 or args.dry_run,
+    ) as progress:
+        task = progress.add_task("extending", total=len(files))
+        for f in files:
+            progress.update(task, description=f.name)
+            try:
+                process_file(f, args, console=console, claimed=claimed)
+                ok += 1
+            except FileError as e:
+                err.print(f"[bold cyan]{f.name}[/]: [yellow]SKIPPED[/] — {e}")
+                failed += 1
+            except Exception as e:  # unexpected: report, keep the batch alive
+                err.print(
+                    f"[bold cyan]{f.name}[/]: [bold red]ERROR[/] — "
+                    f"{type(e).__name__}: {e}"
+                )
+                failed += 1
+            progress.advance(task)
+    if len(files) > 1:
+        parts = [f"[green]{ok} ok[/]"]
+        if failed:
+            parts.append(f"[red]{failed} failed[/]")
+        console.print("[bold]done:[/] " + ", ".join(parts))
+    return 1 if failed else 0

cardbleed/errors.py

@@ -0,0 +1,2 @@
+class FileError(Exception):
+    """Per-file error: reported, file skipped, batch continues."""

cardbleed/filters.py

@@ -0,0 +1,68 @@
+"""Small separable-convolution helpers (pure NumPy, no SciPy)."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+
+def conv_axis(a: np.ndarray, kernel: np.ndarray, axis: int) -> np.ndarray:
+    """Convolve one axis of `a` with a 1-D kernel (reflect padding)."""
+    r = len(kernel) // 2
+    if a.shape[axis] < 2:
+        return a.astype(np.float32, copy=True)
+    pads = [(0, 0)] * a.ndim
+    pads[axis] = (r, r)
+    # reflect needs pad < dim; fall back to edge for tiny arrays
+    mode = "reflect" if a.shape[axis] > r else "edge"
+    ap = np.pad(a, pads, mode=mode)
+    out = np.zeros(a.shape, dtype=np.float32)
+    sl = [slice(None)] * a.ndim
+    for i, kv in enumerate(kernel):
+        sl[axis] = slice(i, i + a.shape[axis])
+        out += np.float32(kv) * ap[tuple(sl)]
+    return out
+
+
+def gauss_kernel(sigma: float) -> np.ndarray:
+    r = max(1, math.ceil(3 * sigma))
+    x = np.arange(-r, r + 1, dtype=np.float32)
+    k = np.exp(-(x * x) / (2 * sigma * sigma))
+    return k / k.sum()
+
+
+def gaussian_blur2d(a: np.ndarray, sigma: float) -> np.ndarray:
+    """Separable Gaussian blur over the first two axes of (H,W) or (H,W,C)."""
+    if sigma <= 0:
+        return a.astype(np.float32, copy=True)
+    k = gauss_kernel(sigma)
+    return conv_axis(conv_axis(a, k, 0), k, 1)
+
+
+def box_blur3(a: np.ndarray) -> np.ndarray:
+    k = np.full(3, 1 / 3, dtype=np.float32)
+    return conv_axis(conv_axis(a, k, 0), k, 1)
+
+
+def highpass_std(region: np.ndarray) -> np.ndarray:
+    """Per-channel std of the high-frequency residual of an (H,W,C) region."""
+    return (region.astype(np.float32) - box_blur3(region)).std(axis=(0, 1))
+
+
+def smooth_field(
+    rng: np.random.Generator,
+    shape: tuple[int, int],
+    sigma: float,
+    *,
+    standardize: bool = False,
+) -> np.ndarray:
+    """Random field blurred to a given correlation length.
+
+    Standardized fields have mean 0 / std 1 (for signed displacements);
+    otherwise the field is renormalized to span [0, 1].
+    """
+    f = gaussian_blur2d(rng.random(shape, dtype=np.float32), sigma)
+    if standardize:
+        return (f - f.mean()) / max(float(f.std()), 1e-6)
+    return (f - f.min()) / max(float(np.ptp(f)), 1e-6)

cardbleed/formats.py

@@ -0,0 +1,257 @@
+"""Format-preserving image I/O.
+
+The whole point of cardbleed is that original image data is never re-encoded:
+
+  PNG  -> PNG   lossless container; original pixels bit-identical
+  WebP -> WebP  written lossless (exact); decoded original pixels preserved
+  JPEG -> JPEG  DCT-domain surgery: original quantized coefficient blocks are
+                copied bit-exact into a larger grid; only new border blocks
+                are encoded, using the file's own quantization tables
+
+Adding a new format means adding a loader + saver here; synthesis is
+format-agnostic (it only ever sees an (H, W, C) uint8 array).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import math
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+from .errors import FileError
+from .synthesis import TRIM_CAP
+
+FORMATS = {".png": "png", ".jpg": "jpeg", ".jpeg": "jpeg", ".webp": "webp"}
+
+
+# --------------------------------------------------------------------------
+# loading
+# --------------------------------------------------------------------------
+
+
+def load_pixels(path: Path, fmt: str, notes: list[str]):
+    """Decode to (H,W,C) uint8 + a dict of metadata for the writer."""
+    if fmt == "jpeg":
+        import jpeglib
+
+        dct = jpeglib.read_dct(str(path))
+        cs = str(getattr(dct, "jpeg_color_space", ""))
+        if dct.num_components == 3 and "YCbCr" not in cs:
+            raise FileError(
+                f"JPEG color space {cs or 'unknown'} not supported "
+                "(only YCbCr and grayscale)"
+            )
+        spat = jpeglib.read_spatial(str(path))
+        arr = np.asarray(spat.spatial)
+        if arr.ndim == 2:
+            arr = arr[:, :, None]
+        if arr.shape[2] not in (1, 3):
+            raise FileError(
+                f"unsupported JPEG color layout ({arr.shape[2]} "
+                "channels; CMYK/YCCK not supported)"
+            )
+        return arr, {"dct": dct}
+
+    im = Image.open(path)
+    if fmt == "webp" and getattr(im, "is_animated", False):
+        raise FileError("animated WebP not supported")
+    meta = {"icc_profile": im.info.get("icc_profile"), "exif": im.info.get("exif")}
+    if im.mode == "P":
+        im = im.convert("RGBA" if "transparency" in im.info else "RGB")
+        notes.append(f"palette image promoted to {im.mode} (pixel values identical)")
+    if im.mode in ("I", "I;16", "I;16B", "I;16L", "F"):
+        raise FileError(
+            f"{im.mode} (high bit depth) not supported; convert to 8-bit first"
+        )
+    if im.mode not in ("L", "LA", "RGB", "RGBA"):
+        im = im.convert("RGB")
+        notes.append("converted to RGB")
+    meta["mode"] = im.mode
+    arr = np.asarray(im)
+    if arr.ndim == 2:
+        arr = arr[:, :, None]
+    return arr, meta
+
+
+# --------------------------------------------------------------------------
+# PNG / WebP saving (lossless)
+# --------------------------------------------------------------------------
+
+
+def save_png_webp(
+    arr: np.ndarray, meta: dict, out: Path, fmt: str, dpi: tuple[float, float]
+) -> None:
+    mode = meta.get("mode", "RGB")
+    im = Image.fromarray(arr[:, :, 0] if arr.shape[2] == 1 else arr, mode=mode)
+    kw = {}
+    if meta.get("icc_profile"):
+        kw["icc_profile"] = meta["icc_profile"]
+    if meta.get("exif"):
+        kw["exif"] = meta["exif"]
+    if fmt == "png":
+        im.save(out, format="PNG", dpi=dpi, **kw)
+    else:
+        # exact=True: keep RGB values under fully-transparent alpha
+        im.save(out, format="WEBP", lossless=True, quality=80, exact=True, **kw)
+
+
+# --------------------------------------------------------------------------
+# JPEG DCT surgery
+# --------------------------------------------------------------------------
+
+_DCT_M = None
+
+
+def _dct_matrix() -> np.ndarray:
+    global _DCT_M
+    if _DCT_M is None:
+        i = np.arange(8, dtype=np.float64)[:, None]
+        j = np.arange(8, dtype=np.float64)[None, :]
+        m = np.cos((2 * j + 1) * i * np.pi / 16)
+        m[0] *= math.sqrt(1 / 8)
+        m[1:] *= math.sqrt(2 / 8)
+        _DCT_M = m
+    return _DCT_M
+
+
+def _plane_to_qblocks(plane: np.ndarray, qt: np.ndarray) -> np.ndarray:
+    """(h,w) float plane -> quantized DCT blocks (bv,bh,8,8) int16."""
+    h, w = plane.shape
+    bv, bh = -(-h // 8), -(-w // 8)
+    plane = np.pad(plane, ((0, bv * 8 - h), (0, bh * 8 - w)), mode="edge")
+    blocks = plane.reshape(bv, 8, bh, 8).transpose(0, 2, 1, 3) - 128.0
+    D = _dct_matrix()
+    coeff = np.einsum("ik,vhkl,jl->vhij", D, blocks, D)
+    return np.rint(coeff / qt[None, None]).astype(np.int16)
+
+
+def _subsample(plane: np.ndarray, fx: int, fy: int) -> np.ndarray:
+    if fx == 1 and fy == 1:
+        return plane
+    h, w = plane.shape
+    plane = np.pad(plane, ((0, (-h) % fy), (0, (-w) % fx)), mode="edge")
+    return plane.reshape(plane.shape[0] // fy, fy, plane.shape[1] // fx, fx).mean(
+        axis=(1, 3)
+    )
+
+
+def jpeg_factors(dct, ci: int) -> tuple[int, int]:
+    """Subsampling divisors (fx, fy) of component ci.
+
+    jpeglib's samp_factor rows are ordered [vertical, horizontal].
+    """
+    sf = np.asarray(dct.samp_factor)
+    hmax, vmax = int(sf[:, 1].max()), int(sf[:, 0].max())
+    return hmax // int(sf[ci, 1]), vmax // int(sf[ci, 0])
+
+
+def jpeg_mcu(dct) -> tuple[int, int]:
+    """(mcu_width, mcu_height) in luma pixels."""
+    sf = np.asarray(dct.samp_factor)
+    return 8 * int(sf[:, 1].max()), 8 * int(sf[:, 0].max())
+
+
+def jpeg_paste_box(
+    dct,
+    ci: int,
+    size0: tuple[int, int],
+    extents: tuple[int, int, int, int],
+    halo_overwrite: bool,
+    trim_px: int = TRIM_CAP,
+) -> tuple[slice, slice, int, int]:
+    """Block region of component ci that stays bit-exact.
+
+    Returns (rows, cols, off_v, off_h): slices into the NEW block grid and the
+    placement offset of the original component blocks.
+    """
+    W0, H0 = size0
+    L, T, R, B = extents
+    fx, fy = jpeg_factors(dct, ci)
+    comps = [dct.Y, dct.Cb, dct.Cr][ci] if dct.Cb is not None else dct.Y
+    ov, oh = comps.shape[:2]
+    off_v, off_h = (T // fy) // 8, (L // fx) // 8
+    ch0, cw0 = -(-H0 // fy), -(-W0 // fx)  # component pixel dims (original)
+    lo_v, lo_h = off_v, off_h
+    hi_v, hi_h = off_v + ov, off_h + oh
+    # straddling last block row/col contains encoder padding that would become
+    # visible next to a new extension -> re-encode it (content preserved in
+    # pixel space; requantized with the original tables)
+    if B > 0 and ch0 % 8:
+        hi_v -= 1
+    if R > 0 and cw0 % 8:
+        hi_h -= 1
+    if halo_overwrite:
+        # opt-in: re-encode the outer block ring so the rewritten halo pixels
+        # actually land in the file — only on edges that were extended, and
+        # deep enough to cover the trimmed pixels
+        rx = max(1, -(-trim_px // (8 * fx)))
+        ry = max(1, -(-trim_px // (8 * fy)))
+        if L > 0:
+            lo_h += rx
+        if T > 0:
+            lo_v += ry
+        if R > 0:
+            hi_h -= rx
+        if B > 0:
+            hi_v -= ry
+    return slice(lo_v, max(lo_v, hi_v)), slice(lo_h, max(lo_h, hi_h)), off_v, off_h
+
+
+def save_jpeg(
+    arr: np.ndarray,
+    meta: dict,
+    out: Path,
+    size0: tuple[int, int],
+    extents: tuple[int, int, int, int],
+    halo_overwrite: bool,
+    trim_px: int = TRIM_CAP,
+) -> None:
+    import jpeglib
+
+    dct = meta["dct"]
+    H1, W1, _C = arr.shape
+    ncomp = dct.num_components
+    f = arr.astype(np.float32)
+    if ncomp == 1:
+        planes = [f[:, :, 0]]
+    else:
+        R, G, B = f[:, :, 0], f[:, :, 1], f[:, :, 2]
+        planes = [
+            0.299 * R + 0.587 * G + 0.114 * B,
+            128.0 - 0.168735892 * R - 0.331264108 * G + 0.5 * B,
+            128.0 + 0.5 * R - 0.418687589 * G - 0.081312411 * B,
+        ]
+
+    orig = [dct.Y, dct.Cb, dct.Cr][:ncomp]
+    comps = []
+    for ci in range(ncomp):
+        fx, fy = jpeg_factors(dct, ci)
+        qt = dct.get_component_qt(ci)
+        plane = _subsample(planes[ci], fx, fy)
+        blocks = _plane_to_qblocks(plane, np.asarray(qt, dtype=np.float64))
+        rows, cols, off_v, off_h = jpeg_paste_box(
+            dct, ci, size0, extents, halo_overwrite, trim_px
+        )
+        src = orig[ci]
+        blocks[rows, cols] = src[
+            rows.start - off_v : rows.stop - off_v,
+            cols.start - off_h : cols.stop - off_h,
+        ]
+        comps.append(np.ascontiguousarray(blocks))
+
+    # jpeglib's signature declares Cb/Cr as required arrays, but None is the
+    # documented value for grayscale files
+    new = jpeglib.from_dct(
+        Y=comps[0],
+        Cb=comps[1] if ncomp > 1 else None,  # pyright: ignore[reportArgumentType]
+        Cr=comps[2] if ncomp > 1 else None,  # pyright: ignore[reportArgumentType]
+        qt=dct.qt,
+        quant_tbl_no=list(np.asarray(dct.quant_tbl_no)),
+    )
+    new.width, new.height = W1, H1
+    with contextlib.suppress(Exception):
+        new.markers = dct.markers
+    new.write_dct(str(out))