PyPDFForm 6.0.1__tar.gz → 6.0.2__tar.gz

{pypdfform-6.0.1 → pypdfform-6.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 6.0.1
+Version: 6.0.2
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -27,7 +27,7 @@ License-File: LICENSE
 Requires-Dist: cryptography<51.0.0,>=50.0.0
 Requires-Dist: fonttools<5.0.0,>=4.63.0
 Requires-Dist: pikepdf<11.0.0,>=10.7.2
-Requires-Dist: pillow<13.0.0,>=12.2.0
+Requires-Dist: pillow<14.0.0,>=12.2.0
 Requires-Dist: pypdf<7.0.0,>=6.12.2
 Requires-Dist: reportlab<6.0.0,>=4.5.1
 Provides-Extra: cli
@@ -39,7 +39,7 @@ Requires-Dist: coverage<8.0.0,>=7.14.1; extra == "dev"
 Requires-Dist: mike<3.0.0,>=2.2.0; extra == "dev"
 Requires-Dist: mkdocs<2.0.0,>=1.6.1; extra == "dev"
 Requires-Dist: mkdocs-material<10.0.0,>=9.7.6; extra == "dev"
-Requires-Dist: pudb<2026.0.0,>=2025.1.5; extra == "dev"
+Requires-Dist: pudb<2027.0.0,>=2025.1.5; extra == "dev"
 Requires-Dist: pylint<5.0.0,>=4.0.5; extra == "dev"
 Requires-Dist: pyright<2.0.0,>=1.1.409; extra == "dev"
 Requires-Dist: pytest<10.0.0,>=9.0.3; extra == "dev"

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/__init__.py

@@ -16,7 +16,7 @@ PyPDFForm aims to make PDF form automation straightforward whether it is used
 from Python code or from the command line.
 """
 
-__version__ = "6.0.1"
+__version__ = "6.0.2"
 
 from .lib.annotations import Annotations
 from .lib.assets.blank import BlankPage

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/constants.py

@@ -56,6 +56,7 @@ TU = "/TU"
 Rect = "/Rect"
 FT = "/FT"
 Parent = "/Parent"
+Kids = "/Kids"
 Ff = "/Ff"
 F = "/F"
 Tx = "/Tx"

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/egress.py

@@ -1,17 +1,22 @@
 # -*- coding: utf-8 -*-
 """
-A module for egress functions.
-
-This module provides functionalities that prepare the final PDF for output (egress),
-ensuring that it is properly formatted and ready for the end-user. This includes
-managing appearance streams (so form fields display correctly after being filled),
-handling the /NeedAppearances flag, and rebuilding the AcroForm `/Fields` array from
-the widget annotations present on each page. These functions are typically called
-right before the final PDF byte stream is returned by the wrapper module.
+Prepare PDF output and publish serialized PDFs to filesystem paths.
+
+Preparation helpers manage appearance streams and the /NeedAppearances flag,
+and rebuild the AcroForm `/Fields` array from page widget annotations before
+`PdfWrapper.read()` returns the final bytes.
+
+For path output, `write_path()` writes serialized bytes to a sibling temporary
+file and closes it before atomic replacement. It follows symlinks, preserves
+existing permission bits, and cleans up failed temporary writes.
 """
 
+import os
+import stat
+from contextlib import suppress
 from functools import lru_cache
 from io import BytesIO
+from tempfile import NamedTemporaryFile
 from warnings import catch_warnings, filterwarnings
 
 from pikepdf import Pdf
@@ -24,10 +29,57 @@ from .constants import (
     Annots,
     Fields,
     Parent,
+    Subtype,
+    Widget,
 )
 from .template import get_widget_key
 
 
+def write_path(dest: str | bytes | os.PathLike, content: bytes) -> None:
+    """
+    Write serialized content to a sibling temporary file and replace its target.
+
+    Symlinks are followed. Existing permission bits are copied before replacement;
+    new files retain the temporary file's private permissions. Other file metadata
+    and hard-link relationships are not preserved. Failures before replacement
+    leave the destination's bytes unchanged and remove the temporary file.
+    """
+    path = os.path.realpath(os.fsdecode(dest))
+    mode = None
+    try:
+        destination_stat = os.stat(path)
+    except FileNotFoundError:
+        pass
+    else:
+        if not stat.S_ISREG(destination_stat.st_mode):
+            message = "The output destination must be a regular file."
+            raise OSError(message)
+        mode = stat.S_IMODE(destination_stat.st_mode)
+
+    temporary_path = None
+    try:
+        with NamedTemporaryFile(
+            mode="wb", prefix=".pypdfform-", dir=os.path.dirname(path), delete=False
+        ) as output:
+            temporary_path = output.name
+            if output.write(content) != len(content):
+                message = "The temporary PDF write was incomplete."
+                raise OSError(message)
+
+        if mode is not None:
+            os.chmod(temporary_path, mode)
+        os.replace(temporary_path, path)
+    finally:
+        if temporary_path is not None:
+            with suppress(FileNotFoundError):
+                try:
+                    os.unlink(temporary_path)
+                except PermissionError:
+                    # Windows cannot unlink a temporary file made read-only above.
+                    os.chmod(temporary_path, stat.S_IRUSR | stat.S_IWUSR)
+                    os.unlink(temporary_path)
+
+
 @lru_cache(maxsize=8)
 def appearance_streams_handler(pdf: bytes, generate_appearance_streams: bool) -> bytes:
     """
@@ -85,8 +137,8 @@ def rebuild_acroform_fields(
     Rebuilds the AcroForm `/Fields` array from matching page annotations.
 
     The existing `/Fields` array is replaced, creating an AcroForm dictionary
-    when necessary. Each page annotation is resolved to a widget key, and only
-    annotations whose keys are present in `widget_keys` contribute their
+    when necessary. Only widget annotations are resolved to a widget key, and
+    those whose keys are present in `widget_keys` contribute their
     top-level field object to the new array. Page annotation arrays are left
     unchanged. When no matching page annotations are found, the original PDF
     stream is returned unchanged to avoid an unnecessary rewrite.
@@ -111,13 +163,17 @@ def rebuild_acroform_fields(
     seen_fields = set()
     for page in writer.pages:
         for annot in page.get(Annots, []):
-            key = get_widget_key(annot.get_object(), use_full_widget_name)
-            if key in widget_keys:
-                field_ref = _get_root_field_reference(writer, annot)
-                field_key = _field_reference_key(field_ref)
-                if field_key not in seen_fields:
-                    fields.append(field_ref)
-                    seen_fields.add(field_key)
+            annotation = annot.get_object()
+            if (
+                annotation.get(Subtype) != Widget
+                or get_widget_key(annotation, use_full_widget_name) not in widget_keys
+            ):
+                continue
+            field_ref = _get_root_field_reference(writer, annot)
+            field_key = _field_reference_key(field_ref)
+            if field_key not in seen_fields:
+                fields.append(field_ref)
+                seen_fields.add(field_key)
 
     if not seen_fields:
         return pdf

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/filler.py

@@ -12,9 +12,9 @@ from io import BytesIO
 from typing import Dict, cast
 
 from pypdf import PdfWriter
-from pypdf.generic import DictionaryObject
+from pypdf.generic import ArrayObject, DictionaryObject
 
-from .constants import Annots
+from .constants import AcroForm, Fields, Kids, Parent, Subtype, Widget
 from .hooks import update_field_readonly
 from .image import get_draw_image_resolutions, get_image_dimensions
 from .middleware import WIDGET_TYPES
@@ -90,7 +90,8 @@ def update_widget(
 
     This function updates the value of a single PDF form widget based on its type. It sets
     the read-only flag first when requested, skips value updates when the
-    middleware value is ``None``, tracks radio option indices within each group, and
+    middleware value is ``None``, tracks radio option indices within each group,
+    updates the entire radio group when its selected option is reached, and
     prepares images or signatures for later drawing instead of writing image data directly
     into the annotation.
 
@@ -156,6 +157,36 @@ def handle_image_drawing(
     return merge_watermarks_with_pdf(result, create_watermarks_and_draw(result, images))
 
 
+def _detach_consumed_widget(writer: PdfWriter, annot: DictionaryObject) -> None:
+    """
+    Detaches a consumed widget and empty ancestor fields from the AcroForm tree.
+
+    This function removes the widget from its parent's child array or the
+    AcroForm's root field array. It removes ancestors that become empty, stopping
+    at the first parent with remaining children. Resolved objects are compared
+    by identity so unrelated fields with the same name retain their references.
+    The caller is responsible for removing the widget from page annotations.
+
+    Args:
+        writer (PdfWriter): The PDF writer that owns the widget and field tree.
+        annot (DictionaryObject): The consumed image or signature widget to detach.
+    """
+    field = annot
+    while Parent in field:
+        parent = cast(DictionaryObject, field[Parent])
+        children = cast(ArrayObject, parent.get(Kids, ArrayObject()).get_object())
+        children[:] = [child for child in children if child.get_object() is not field]
+        if children:
+            return
+        field = parent
+
+    acroform = writer.root_object.get(AcroForm, DictionaryObject()).get_object()
+    fields = cast(ArrayObject, acroform.get(Fields, ArrayObject()).get_object())
+    fields[:] = [
+        reference for reference in fields if reference.get_object() is not field
+    ]
+
+
 def fill(
     template: bytes,
     widgets: Dict[str, WIDGET_TYPES],
@@ -169,8 +200,9 @@ def fill(
     widgets on each page of the PDF and updates their values based on the provided `widgets`
     dictionary. The function supports text fields, checkboxes, radio buttons, dropdowns,
     images, and signatures. It can set fields read-only during filling, and when images or
-    signatures are present it returns both the filled form stream and a second stream with
-    the image watermarks applied so callers can preserve non-image widgets separately.
+    signatures are present it removes only the widgets whose images were prepared,
+    including their field-tree entries, and returns a second stream with the image
+    watermarks applied. All other annotations retain their existing references.
 
     Args:
         template (bytes): The PDF template as bytes.
@@ -196,15 +228,21 @@ def fill(
 
     for page_num, page in enumerate(out.pages):
         images_to_draw[page_num + 1] = []
-        for annot in page.get(Annots, []):
-            annot = cast(DictionaryObject, annot.get_object())
+        annotations = page.annotations
+        if annotations is None:
+            continue
+        # Keep a snapshot because consumed widgets are removed during iteration.
+        for reference in annotations.copy():
+            annot = cast(DictionaryObject, reference.get_object())
+            if annot.get(Subtype) != Widget:
+                continue
             key = get_widget_key(annot.get_object(), use_full_widget_name)
 
             widget = widgets.get(key)
             if widget is None:
                 continue
 
-            any_image_to_draw |= update_widget(
+            consumed = update_widget(
                 annot,
                 widget,
                 key,
@@ -213,6 +251,12 @@ def fill(
                 need_appearances,
                 readonly,
             )
+            if consumed:
+                any_image_to_draw = True
+                annotations[:] = [
+                    item for item in annotations if item.get_object() is not annot
+                ]
+                _detach_consumed_widget(out, annot)
 
     with BytesIO() as f:
         out.write(f)

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/font.py

@@ -191,7 +191,14 @@ def temporary_font_registration(
     from the original font names to the unique names.
 
     The fonts are inserted into ReportLab's global font registry for the duration
-    of the context manager and removed again on exit.
+    of the context manager. Every inserted entry is tracked independently of the
+    alias mapping and removed on exit, including setup and drawing failures.
+    Repeated aliases resolve to the last registration. Cleanup only removes
+    entries still referencing the font objects inserted by this context.
+
+    Sequential and nested contexts are supported. Callers must serialize threaded
+    PyPDFForm and direct ReportLab operations in the same process for the entire
+    operation; this context manager does not synchronize the global registry.
 
     Args:
         fonts (list[tuple[str, bytes]]): A list of tuples, each containing a font name and its TTF stream.
@@ -200,16 +207,21 @@ def temporary_font_registration(
         dict: A mapping of the original font names to the temporary unique names used by ReportLab.
     """
     font_mapping = {}
-    for font_name, ttf_stream in fonts:
-        rl_name = uuid4().hex
-        font_mapping[font_name] = rl_name
-        _fonts[rl_name] = TTFont(rl_name, BytesIO(ttf_stream))
-
+    registered_fonts = {}
     try:
+        for font_name, ttf_stream in fonts:
+            rl_name = uuid4().hex
+            while rl_name in _fonts:
+                rl_name = uuid4().hex
+            font = TTFont(rl_name, BytesIO(ttf_stream))
+            registered_fonts[rl_name] = font
+            _fonts[rl_name] = font
+            font_mapping[font_name] = rl_name
+
         yield font_mapping
     finally:
-        for rl_name in font_mapping.values():
-            if rl_name in _fonts:
+        for rl_name, font in registered_fonts.items():
+            if _fonts.get(rl_name) is font:
                 del _fonts[rl_name]
 
 

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/patterns.py

@@ -34,6 +34,7 @@ from .constants import (
     F,
     Ff,
     I,
+    Kids,
     MaxLen,
     N,
     Off,
@@ -260,22 +261,22 @@ def get_checkbox_value(annot: DictionaryObject) -> bool | None:
 
 def update_radio_value(annot: DictionaryObject) -> None:
     """
-    Updates the value of a radio button annotation, selecting it.
+    Selects a radio button and clears every other widget in its group.
 
-    This function modifies the appearance state (AS) and value (V) of the radio button's
-    parent dictionary to reflect the selected state. It also removes the parent's
-    Opt entry when present so the selected appearance state is used directly.
+    The selected widget's non-Off normal appearance supplies the parent value
+    (V) and selected appearance state (AS). All other children, including those
+    on other pages, receive /Off. The parent's Opt export mapping is preserved.
 
     Args:
         annot (DictionaryObject): The radio button annotation dictionary.
     """
-    if Opt in annot[Parent]:
-        del annot[Parent][Opt]
-
     for each in annot[AP][N]:
         if str(each) != Off:
-            annot[NameObject(AS)] = NameObject(each)
-            annot[NameObject(Parent)][NameObject(V)] = NameObject(each)
+            parent = annot[Parent]
+            parent[NameObject(V)] = NameObject(each)
+            for reference in parent[Kids]:
+                child = reference.get_object()
+                child[NameObject(AS)] = NameObject(each if child is annot else Off)
             break
 
 

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm/lib/wrapper.py

@@ -40,6 +40,7 @@ from .coordinate import generate_coordinate_grid
 from .egress import (
     appearance_streams_handler,
     rebuild_acroform_fields,
+    write_path,
 )
 from .filler import fill
 from .font import (
@@ -50,7 +51,6 @@ from .font import (
 )
 from .hooks import trigger_widget_hooks
 from .middleware.dropdown import Dropdown
-from .middleware.signature import Signature
 from .middleware.text import Text
 from .template import (
     build_widgets,
@@ -574,26 +574,26 @@ class PdfWrapper:
 
         return self._stream
 
-    def write(self, dest: str | BinaryIO) -> PdfWrapper:
+    def write(self, dest: str | bytes | PathLike | BinaryIO) -> PdfWrapper:
         """
-        Writes the PDF to a file.
+        Serialize the PDF, then write it to a path or an open binary stream.
 
-        String, bytes, and PathLike destinations are opened in binary write mode.
-        Other objects are treated as already-open writable binary streams.
+        Paths use atomic replacement after a sibling temporary file closes; failures preserve existing bytes.
+        Symlinks are followed and permission bits preserved; new files are private (0600 on POSIX).
+        Other metadata and hard links are not preserved. Stream write failures can leave partial output.
 
         Args:
-            dest (str | BinaryIO): The destination to write the PDF to.
-                Can be a file path (str) or a file-like object (BinaryIO).
+            dest (str | bytes | PathLike | BinaryIO): A regular file path or writable binary stream.
 
         Returns:
             PdfWrapper: The `PdfWrapper` object, allowing for method chaining.
         """
 
+        content = self.read()
         if isinstance(dest, (str, bytes, PathLike)):
-            with open(dest, "wb+") as f:
-                f.write(self.read())
+            write_path(dest, content)
         else:
-            dest.write(self.read())
+            dest.write(content)
 
         return self
 
@@ -664,10 +664,11 @@ class PdfWrapper:
         Fills the PDF form with data from a dictionary.
 
         Only keys that already exist in `self.widgets` are applied. Filling delegates
-        to the lower-level filler, then handles the special image/signature path by
-        drawing those values as watermarks and copying the remaining widgets back onto
-        the output. The wrapper's widget cache is intentionally left in place so
-        subsequent style updates can still refer to the same middleware objects.
+        to the lower-level filler, which draws image/signature values onto the page
+        and removes only the consumed widgets. Other annotations and unfilled
+        signature/image fields are preserved. After image drawing, the widget cache
+        is refreshed to remove consumed fields while retaining the middleware objects
+        for surviving fields so subsequent style updates can still use them.
         Supplied and retained values are prepared before any assignments or PDF
         hooks are applied, so an invalid choice index leaves widget values,
         pending hooks, and PDF state unchanged. Only supplied values are assigned.
@@ -707,22 +708,11 @@ class PdfWrapper:
             readonly=kwargs.get("readonly", False),
         )
 
+        self._stream = (
+            image_drawn_stream if image_drawn_stream is not None else filled_stream
+        )
         if image_drawn_stream is not None:
-            keys_to_copy = [
-                k for k, v in self.widgets.items() if not isinstance(v, Signature)
-            ]  # only copy non-image fields
-            # Case: Single watermark PDF, mapping pages 1:1 to output pages.
-            filled_stream = copy_watermark_widgets(
-                remove_all_widgets(image_drawn_stream),
-                filled_stream,
-                keys_to_copy,
-                None,
-            )
-
-        self._stream = filled_stream
-        if image_drawn_stream is not None:
-            # because copy_watermark_widgets and remove_all_widgets
-            self._reregister_font()
+            self._init_helper()
 
         return self
 

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPDFForm
-Version: 6.0.1
+Version: 6.0.2
 Summary: The Python library & CLI for PDF forms.
 Author: Jinge Li
 License-Expression: MIT
@@ -27,7 +27,7 @@ License-File: LICENSE
 Requires-Dist: cryptography<51.0.0,>=50.0.0
 Requires-Dist: fonttools<5.0.0,>=4.63.0
 Requires-Dist: pikepdf<11.0.0,>=10.7.2
-Requires-Dist: pillow<13.0.0,>=12.2.0
+Requires-Dist: pillow<14.0.0,>=12.2.0
 Requires-Dist: pypdf<7.0.0,>=6.12.2
 Requires-Dist: reportlab<6.0.0,>=4.5.1
 Provides-Extra: cli
@@ -39,7 +39,7 @@ Requires-Dist: coverage<8.0.0,>=7.14.1; extra == "dev"
 Requires-Dist: mike<3.0.0,>=2.2.0; extra == "dev"
 Requires-Dist: mkdocs<2.0.0,>=1.6.1; extra == "dev"
 Requires-Dist: mkdocs-material<10.0.0,>=9.7.6; extra == "dev"
-Requires-Dist: pudb<2026.0.0,>=2025.1.5; extra == "dev"
+Requires-Dist: pudb<2027.0.0,>=2025.1.5; extra == "dev"
 Requires-Dist: pylint<5.0.0,>=4.0.5; extra == "dev"
 Requires-Dist: pyright<2.0.0,>=1.1.409; extra == "dev"
 Requires-Dist: pytest<10.0.0,>=9.0.3; extra == "dev"

{pypdfform-6.0.1 → pypdfform-6.0.2}/PyPDFForm.egg-info/requires.txt

@@ -1,7 +1,7 @@
 cryptography<51.0.0,>=50.0.0
 fonttools<5.0.0,>=4.63.0
 pikepdf<11.0.0,>=10.7.2
-pillow<13.0.0,>=12.2.0
+pillow<14.0.0,>=12.2.0
 pypdf<7.0.0,>=6.12.2
 reportlab<6.0.0,>=4.5.1
 
@@ -15,7 +15,7 @@ coverage<8.0.0,>=7.14.1
 mike<3.0.0,>=2.2.0
 mkdocs<2.0.0,>=1.6.1
 mkdocs-material<10.0.0,>=9.7.6
-pudb<2026.0.0,>=2025.1.5
+pudb<2027.0.0,>=2025.1.5
 pylint<5.0.0,>=4.0.5
 pyright<2.0.0,>=1.1.409
 pytest<10.0.0,>=9.0.3

{pypdfform-6.0.1 → pypdfform-6.0.2}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
     "cryptography>=50.0.0,<51.0.0",
     "fonttools>=4.63.0,<5.0.0",
     "pikepdf>=10.7.2,<11.0.0",
-    "pillow>=12.2.0,<13.0.0",
+    "pillow>=12.2.0,<14.0.0",
     "pypdf>=6.12.2,<7.0.0",
     "reportlab>=4.5.1,<6.0.0",
 ]
@@ -53,7 +53,7 @@ dev = [
     "mike>=2.2.0,<3.0.0",
     "mkdocs>=1.6.1,<2.0.0",
     "mkdocs-material>=9.7.6,<10.0.0",
-    "pudb>=2025.1.5,<2026.0.0",
+    "pudb>=2025.1.5,<2027.0.0",
     "pylint>=4.0.5,<5.0.0",
     "pyright>=1.1.409,<2.0.0",
     "pytest>=9.0.3,<10.0.0",

{pypdfform-6.0.1 → pypdfform-6.0.2}/tests/test_font_related.py

@@ -12,8 +12,10 @@ import pytest
 from fontTools.ttLib import TTLibError
 from pypdf import PdfReader, PdfWriter
 from pypdf.generic import NameObject
+from reportlab.pdfbase.pdfmetrics import _fonts
+from reportlab.pdfbase.ttfonts import TTFError, TTFont
 
-from PyPDFForm import PdfWrapper
+from PyPDFForm import PdfWrapper, RawElements
 from PyPDFForm.lib.constants import (
     DEFAULT_ASSUMED_GLYPH_WIDTH,
     DR,
@@ -24,7 +26,100 @@ from PyPDFForm.lib.constants import (
     MissingWidth,
     Widths,
 )
-from PyPDFForm.lib.font import compute_font_glyph_widths
+from PyPDFForm.lib.font import compute_font_glyph_widths, temporary_font_registration
+
+
+@pytest.fixture
+def font_registry():
+    original = dict(_fonts)
+    yield _fonts
+    # Restore shared state even when a regression assertion fails.
+    _fonts.clear()
+    _fonts.update(original)
+
+
+def test_temporary_font_registration_cleans_up_setup_failure(
+    sample_font_stream, font_registry
+):
+    original = dict(font_registry)
+    fonts = [("same", sample_font_stream)] * 2 + [("bad", b"invalid font")]
+    with pytest.raises(TTFError), temporary_font_registration(fonts):
+        pytest.fail("Invalid font setup must fail before entering the context")
+
+    assert font_registry == original
+
+
+def test_temporary_font_registration_preserves_other_registrations_on_failure(
+    sample_font_stream, font_registry
+):
+    original = dict(font_registry)
+    error = RuntimeError("drawing failed")
+    external = TTFont("external", BytesIO(sample_font_stream))
+
+    def fail_drawing():
+        font_registry["external"] = external
+        raise error
+
+    with temporary_font_registration([("same", sample_font_stream)]):
+        outer_state = dict(font_registry)
+        with (
+            pytest.raises(RuntimeError, match="drawing failed") as caught,
+            temporary_font_registration([("same", sample_font_stream)] * 2),
+        ):
+            fail_drawing()
+
+        assert caught.value is error
+        assert font_registry == {**outer_state, "external": external}
+
+    assert font_registry == {**original, "external": external}
+
+
+def test_temporary_font_registration_only_removes_owned_entries(
+    sample_font_stream, font_registry
+):
+    existing = TTFont("existing", BytesIO(sample_font_stream))
+    font_registry["existing"] = existing
+    original = dict(font_registry)
+    with patch("PyPDFForm.lib.font.uuid4") as uuid:
+        uuid.side_effect = [MagicMock(hex="existing"), MagicMock(hex="temporary")]
+        with temporary_font_registration([("same", sample_font_stream)]) as mapping:
+            assert mapping == {"same": "temporary"}
+            assert font_registry["existing"] is existing
+            font_registry[mapping["same"]] = existing
+
+    assert font_registry == {**original, "temporary": existing}
+
+
+@pytest.mark.parametrize("need_appearances", [False, True])
+def test_repeated_draws_with_duplicate_font_aliases(
+    template_stream, sample_font_stream, font_samples, font_registry, need_appearances
+):
+    # Initialize ReportLab's lazily loaded built-in fonts before taking a snapshot.
+    PdfWrapper(template_stream).draw([RawElements.RawText("Warm up", 1, 100, 100)])
+    form = PdfWrapper(template_stream, need_appearances=need_appearances)
+    form.register_font("same", os.path.join(font_samples, "LiberationSerif-Italic.ttf"))
+    form.register_font("same", sample_font_stream)
+    original = dict(font_registry)
+    original_fields = set(form.widgets)
+
+    for index in range(3):
+        text = f"Font lifecycle {index}"
+        form.draw([RawElements.RawText(text, 1, 100, 100 + index * 25, font="same")])
+        stream = form.read()
+        assert font_registry == original
+
+        reopened = PdfWrapper(stream)
+        assert set(reopened.widgets) == original_fields
+        assert "LiberationSerif-BoldItalic" in reopened.fonts
+        page = PdfReader(BytesIO(stream)).pages[0]
+        assert text in page.extract_text()
+        assert any(
+            font["/BaseFont"].endswith("LiberationSerif-BoldItalic")
+            and font["/FontDescriptor"]["/FontFile2"].get_data()
+            for font in (
+                ref.get_object() for ref in page["/Resources"]["/Font"].values()
+            )
+        )
 
 
 @pytest.fixture